]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/staging/xgifb/vb_setmode.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
staging: Add framebuffer driver for XGI chipsets
[net-next-2.6.git] / drivers / staging / xgifb / vb_setmode.c
CommitLineData
d7636e0b 1#include "osdef.h"
2
3#ifdef TC
4#include <stdio.h>
5#include <string.h>
6#include <conio.h>
7#include <dos.h>
8#endif
9
10
11#ifdef LINUX_XF86
12#include "xf86.h"
13#include "xf86PciInfo.h"
14#include "xgi.h"
15#include "xgi_regs.h"
16#endif
17
18#ifdef LINUX_KERNEL
19#include <asm/io.h>
20#include <linux/types.h>
21#include <linux/version.h>
22#include "XGIfb.h"
23/*#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
24#include <video/XGIfb.h>
25#else
26#include <linux/XGIfb.h>
27#endif*/
28#endif
29
30#ifdef WIN2000
31#include <dderror.h>
32#include <devioctl.h>
33#include <miniport.h>
34#include <ntddvdeo.h>
35#include <video.h>
36
37#include "xgiv.h"
38#include "dd_i2c.h"
39#include "tools.h"
40#endif
41
42#include "vb_def.h"
43#include "vgatypes.h"
44#include "vb_struct.h"
45#include "vb_util.h"
46#include "vb_table.h"
47
48
49
50#define IndexMask 0xff
51#ifndef XGI_MASK_DUAL_CHIP
52#define XGI_MASK_DUAL_CHIP 0x04 /* SR3A */
53#endif
54
55
56
57BOOLEAN XGI_IsLCDDualLink(PVB_DEVICE_INFO pVBInfo);
58BOOLEAN XGI_SetCRT2Group301(USHORT ModeNo, PXGI_HW_DEVICE_INFO HwDeviceExtension,PVB_DEVICE_INFO pVBInfo);
59BOOLEAN XGI_BacklightByDrv(PVB_DEVICE_INFO pVBInfo);
60
61BOOLEAN XGI_IsLCDON(PVB_DEVICE_INFO pVBInfo);
62BOOLEAN XGI_DisableChISLCD(PVB_DEVICE_INFO pVBInfo);
63BOOLEAN XGI_EnableChISLCD(PVB_DEVICE_INFO pVBInfo);
64BOOLEAN XGI_AjustCRT2Rate(USHORT ModeNo,USHORT ModeIdIndex,USHORT RefreshRateTableIndex,USHORT *i, PVB_DEVICE_INFO pVBInfo);
65BOOLEAN XGI_SearchModeID( USHORT ModeNo,USHORT *ModeIdIndex, PVB_DEVICE_INFO pVBInfo);
66BOOLEAN XGI_GetLCDInfo(USHORT ModeNo,USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo);
67BOOLEAN XGISetModeNew( PXGI_HW_DEVICE_INFO HwDeviceExtension , USHORT ModeNo ) ;
68BOOLEAN XGI_BridgeIsOn(PVB_DEVICE_INFO pVBInfo);
69UCHAR XGI_GetModePtr( USHORT ModeNo,USHORT ModeIdIndex,PVB_DEVICE_INFO pVBInfo);
70USHORT XGI_GetOffset(USHORT ModeNo,USHORT ModeIdIndex,USHORT RefreshRateTableIndex,PXGI_HW_DEVICE_INFO HwDeviceExtension,PVB_DEVICE_INFO pVBInfo);
71USHORT XGI_GetRatePtrCRT2( PXGI_HW_DEVICE_INFO pXGIHWDE, USHORT ModeNo,USHORT ModeIdIndex,PVB_DEVICE_INFO pVBInfo );
72USHORT XGI_GetResInfo(USHORT ModeNo,USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo);
73USHORT XGI_GetColorDepth(USHORT ModeNo,USHORT ModeIdIndex,PVB_DEVICE_INFO pVBInfo);
74USHORT XGI_GetVGAHT2(PVB_DEVICE_INFO pVBInfo);
75USHORT XGI_GetVCLK2Ptr(USHORT ModeNo,USHORT ModeIdIndex,USHORT RefreshRateTableIndex,PXGI_HW_DEVICE_INFO HwDeviceExtension,PVB_DEVICE_INFO pVBInfo);
76void XGI_VBLongWait(PVB_DEVICE_INFO pVBInfo);
77void XGI_SaveCRT2Info(USHORT ModeNo, PVB_DEVICE_INFO pVBInfo);
78void XGI_GetCRT2Data(USHORT ModeNo,USHORT ModeIdIndex,USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo);
79void XGI_GetCRT2ResInfo(USHORT ModeNo,USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo);
80void XGI_PreSetGroup1(USHORT ModeNo,USHORT ModeIdIndex, PXGI_HW_DEVICE_INFO HwDeviceExtension,USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo);
81void XGI_SetGroup1(USHORT ModeNo,USHORT ModeIdIndex, PXGI_HW_DEVICE_INFO HwDeviceExtension,USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo);
82void XGI_SetLockRegs(USHORT ModeNo,USHORT ModeIdIndex, PXGI_HW_DEVICE_INFO HwDeviceExtension,USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo);
83void XGI_SetLCDRegs(USHORT ModeNo,USHORT ModeIdIndex, PXGI_HW_DEVICE_INFO HwDeviceExtension,USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo);
84void XGI_SetGroup2(USHORT ModeNo,USHORT ModeIdIndex,USHORT RefreshRateTableIndex,PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo);
85void XGI_SetGroup3(USHORT ModeNo,USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo);
86void XGI_SetGroup4(USHORT ModeNo,USHORT ModeIdIndex,USHORT RefreshRateTableIndex,PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo);
87void XGI_SetGroup5(USHORT ModeNo,USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo);
88void* XGI_GetLcdPtr(USHORT BX, USHORT ModeNo, USHORT ModeIdIndex, USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo);
89void* XGI_GetTVPtr(USHORT BX, USHORT ModeNo,USHORT ModeIdIndex,USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo);
90void XGI_FirePWDEnable(PVB_DEVICE_INFO pVBInfo);
91void XGI_EnableGatingCRT(PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo);
92void XGI_DisableGatingCRT(PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo);
93void XGI_SetPanelDelay(USHORT tempbl, PVB_DEVICE_INFO pVBInfo);
94void XGI_SetPanelPower(USHORT tempah,USHORT tempbl, PVB_DEVICE_INFO pVBInfo);
95void XGI_EnablePWD( PVB_DEVICE_INFO pVBInfo);
96void XGI_DisablePWD( PVB_DEVICE_INFO pVBInfo);
97void XGI_AutoThreshold( PVB_DEVICE_INFO pVBInfo);
98void XGI_SetTap4Regs( PVB_DEVICE_INFO pVBInfo);
99
100void XGI_DisplayOn(PXGI_HW_DEVICE_INFO, PVB_DEVICE_INFO pVBInfo);
101void XGI_DisplayOff( PXGI_HW_DEVICE_INFO, PVB_DEVICE_INFO pVBInfo );
102void XGI_SetCRT1Group(PXGI_HW_DEVICE_INFO HwDeviceExtension,USHORT ModeNo,USHORT ModeIdIndex,PVB_DEVICE_INFO pVBInfo);
103void XGI_SetXG21CRTC(USHORT ModeNo, USHORT ModeIdIndex, USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo);
104void XGI_SetXG21LCD(PVB_DEVICE_INFO pVBInfo,USHORT RefreshRateTableIndex,USHORT ModeNo);
105void XGI_SetXG27CRTC(USHORT ModeNo, USHORT ModeIdIndex, USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo);
106void XGI_SetXG27LCD(PVB_DEVICE_INFO pVBInfo,USHORT RefreshRateTableIndex,USHORT ModeNo);
107void XGI_UpdateXG21CRTC(USHORT ModeNo, PVB_DEVICE_INFO pVBInfo, USHORT RefreshRateTableIndex);
108void XGI_WaitDisply(PVB_DEVICE_INFO pVBInfo);
109void XGI_SenseCRT1(PVB_DEVICE_INFO pVBInfo);
110void XGI_SetSeqRegs(USHORT ModeNo,USHORT StandTableIndex,USHORT ModeIdIndex,PVB_DEVICE_INFO pVBInfo);
111void XGI_SetMiscRegs(USHORT StandTableIndex, PVB_DEVICE_INFO pVBInfo);
112void XGI_SetCRTCRegs(PXGI_HW_DEVICE_INFO HwDeviceExtension,USHORT StandTableIndex, PVB_DEVICE_INFO pVBInfo);
113void XGI_SetATTRegs(USHORT ModeNo,USHORT StandTableIndex,USHORT ModeIdIndex,PVB_DEVICE_INFO pVBInfo );
114void XGI_SetGRCRegs(USHORT StandTableIndex, PVB_DEVICE_INFO pVBInfo);
115void XGI_ClearExt1Regs(PVB_DEVICE_INFO pVBInfo);
116
117void XGI_SetSync(USHORT RefreshRateTableIndex,PVB_DEVICE_INFO pVBInfo);
118void XGI_SetCRT1CRTC(USHORT ModeNo,USHORT ModeIdIndex,USHORT RefreshRateTableIndex,PVB_DEVICE_INFO pVBInfo,PXGI_HW_DEVICE_INFO HwDeviceExtension);
119void XGI_SetCRT1Timing_H(PVB_DEVICE_INFO pVBInfo,PXGI_HW_DEVICE_INFO HwDeviceExtension);
120void XGI_SetCRT1Timing_V(USHORT ModeIdIndex,USHORT ModeNo,PVB_DEVICE_INFO pVBInfo);
121void XGI_SetCRT1DE(PXGI_HW_DEVICE_INFO HwDeviceExtension,USHORT ModeNo,USHORT ModeIdIndex,USHORT RefreshRateTableIndex,PVB_DEVICE_INFO pVBInfo);
122void XGI_SetCRT1VCLK(USHORT ModeNo,USHORT ModeIdIndex,PXGI_HW_DEVICE_INFO HwDeviceExtension,USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo);
123void XGI_SetCRT1FIFO(USHORT ModeNo,PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo);
124void XGI_SetCRT1ModeRegs(PXGI_HW_DEVICE_INFO HwDeviceExtension,USHORT ModeNo,USHORT ModeIdIndex,USHORT RefreshRateTableIndex,PVB_DEVICE_INFO pVBInfo);
125void XGI_SetVCLKState(PXGI_HW_DEVICE_INFO HwDeviceExtension,USHORT ModeNo,USHORT RefreshRateTableIndex,PVB_DEVICE_INFO pVBInfo);
126
127void XGI_LoadDAC(USHORT ModeNo,USHORT ModeIdIndex,PVB_DEVICE_INFO pVBInfo);
128void XGI_WriteDAC(USHORT dl, USHORT ah, USHORT al, USHORT dh, PVB_DEVICE_INFO pVBInfo);
129/*void XGI_ClearBuffer(PXGI_HW_DEVICE_INFO HwDeviceExtension,USHORT ModeNo,PVB_DEVICE_INFO pVBInfo);*/
130void XGI_SetLCDAGroup(USHORT ModeNo,USHORT ModeIdIndex,PXGI_HW_DEVICE_INFO HwDeviceExtension,PVB_DEVICE_INFO pVBInfo);
131void XGI_GetLVDSResInfo( USHORT ModeNo,USHORT ModeIdIndex,PVB_DEVICE_INFO pVBInfo);
132void XGI_GetLVDSData(USHORT ModeNo,USHORT ModeIdIndex,USHORT RefreshRateTableIndex,PVB_DEVICE_INFO pVBInfo);
133void XGI_ModCRT1Regs(USHORT ModeNo,USHORT ModeIdIndex,USHORT RefreshRateTableIndex,PXGI_HW_DEVICE_INFO HwDeviceExtension,PVB_DEVICE_INFO pVBInfo);
134void XGI_SetLVDSRegs(USHORT ModeNo,USHORT ModeIdIndex,USHORT RefreshRateTableIndex,PVB_DEVICE_INFO pVBInfo);
135void XGI_UpdateModeInfo(PXGI_HW_DEVICE_INFO HwDeviceExtension,PVB_DEVICE_INFO pVBInfo);
136void XGI_GetVGAType(PXGI_HW_DEVICE_INFO HwDeviceExtension,PVB_DEVICE_INFO pVBInfo);
137void XGI_GetVBType(PVB_DEVICE_INFO pVBInfo);
138void XGI_GetVBInfo(USHORT ModeNo,USHORT ModeIdIndex,PXGI_HW_DEVICE_INFO HwDeviceExtension,PVB_DEVICE_INFO pVBInfo);
139void XGI_GetTVInfo(USHORT ModeNo,USHORT ModeIdIndex,PVB_DEVICE_INFO pVBInfo);
140void XGI_SetCRT2ECLK( USHORT ModeNo,USHORT ModeIdIndex,USHORT RefreshRateTableIndex,PVB_DEVICE_INFO pVBInfo);
141void InitTo330Pointer(UCHAR,PVB_DEVICE_INFO pVBInfo);
142void XGI_GetLCDSync(USHORT* HSyncWidth, USHORT* VSyncWidth, PVB_DEVICE_INFO pVBInfo);
143void XGI_DisableBridge(PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo);
144void XGI_EnableBridge(PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo);
145void XGI_SetCRT2VCLK(USHORT ModeNo,USHORT ModeIdIndex,USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo);
146void XGI_OEM310Setting(USHORT ModeNo,USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo);
147void XGI_SetDelayComp(PVB_DEVICE_INFO pVBInfo);
148void XGI_SetLCDCap(PVB_DEVICE_INFO pVBInfo);
149void XGI_SetLCDCap_A(USHORT tempcx,PVB_DEVICE_INFO pVBInfo);
150void XGI_SetLCDCap_B(USHORT tempcx,PVB_DEVICE_INFO pVBInfo);
151void SetSpectrum(PVB_DEVICE_INFO pVBInfo);
152void XGI_SetAntiFlicker(USHORT ModeNo,USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo);
153void XGI_SetEdgeEnhance(USHORT ModeNo,USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo);
154void XGI_SetPhaseIncr(PVB_DEVICE_INFO pVBInfo);
155void XGI_SetYFilter(USHORT ModeNo,USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo);
156void XGI_GetTVPtrIndex2(USHORT* tempbx,UCHAR* tempcl,UCHAR* tempch, PVB_DEVICE_INFO pVBInfo);
157USHORT XGI_GetTVPtrIndex( PVB_DEVICE_INFO pVBInfo );
158void XGI_SetCRT2ModeRegs(USHORT ModeNo,PXGI_HW_DEVICE_INFO, PVB_DEVICE_INFO pVBInfo );
159void XGI_CloseCRTC(PXGI_HW_DEVICE_INFO, PVB_DEVICE_INFO pVBInfo);
160void XGI_OpenCRTC(PXGI_HW_DEVICE_INFO, PVB_DEVICE_INFO pVBInfo);
161void XGI_GetRAMDAC2DATA(USHORT ModeNo,USHORT ModeIdIndex,USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo);
162void XGI_UnLockCRT2(PXGI_HW_DEVICE_INFO, PVB_DEVICE_INFO pVBInfo);
163void XGI_LockCRT2(PXGI_HW_DEVICE_INFO, PVB_DEVICE_INFO pVBInfo);
164void XGINew_EnableCRT2(PVB_DEVICE_INFO pVBInfo);
165void XGINew_LCD_Wait_Time(UCHAR DelayTime, PVB_DEVICE_INFO pVBInfo);
166void XGI_LongWait(PVB_DEVICE_INFO pVBInfo);
167void XGI_SetCRT1Offset( USHORT ModeNo , USHORT ModeIdIndex , USHORT RefreshRateTableIndex , PXGI_HW_DEVICE_INFO HwDeviceExtension,PVB_DEVICE_INFO pVBInfo );
168void XGI_GetLCDVCLKPtr(UCHAR* di_0,UCHAR *di_1, PVB_DEVICE_INFO pVBInfo);
169UCHAR XGI_GetVCLKPtr(USHORT RefreshRateTableIndex,USHORT ModeNo,USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo);
170void XGI_GetVCLKLen(UCHAR tempal,UCHAR* di_0,UCHAR* di_1, PVB_DEVICE_INFO pVBInfo);
171USHORT XGI_GetLCDCapPtr(PVB_DEVICE_INFO pVBInfo);
172USHORT XGI_GetLCDCapPtr1(PVB_DEVICE_INFO pVBInfo);
173XGI301C_Tap4TimingStruct* XGI_GetTap4Ptr(USHORT tempcx, PVB_DEVICE_INFO pVBInfo);
174void XGI_SetXG21FPBits(PVB_DEVICE_INFO pVBInfo);
175void XGI_SetXG27FPBits(PVB_DEVICE_INFO pVBInfo);
176UCHAR XGI_XG21GetPSCValue(PVB_DEVICE_INFO pVBInfo);
177UCHAR XGI_XG27GetPSCValue(PVB_DEVICE_INFO pVBInfo);
178void XGI_XG21BLSignalVDD(USHORT tempbh,USHORT tempbl, PVB_DEVICE_INFO pVBInfo);
179void XGI_XG27BLSignalVDD(USHORT tempbh,USHORT tempbl, PVB_DEVICE_INFO pVBInfo);
180void XGI_XG21SetPanelDelay(USHORT tempbl, PVB_DEVICE_INFO pVBInfo);
181BOOLEAN XGI_XG21CheckLVDSMode(USHORT ModeNo,USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo );
182void XGI_SetXG21LVDSPara(USHORT ModeNo,USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo );
183void XGI_SetXG27LVDSPara(USHORT ModeNo,USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo );
184UCHAR XGI_SetDefaultVCLK( PVB_DEVICE_INFO pVBInfo );
185
186extern void ReadVBIOSTablData( UCHAR ChipType , PVB_DEVICE_INFO pVBInfo);
187#ifdef WIN2000
188/* [Billy] 2007/05/17 For CH7007 */
189extern UCHAR CH7007TVReg_UNTSC[][8],CH7007TVReg_ONTSC[][8],CH7007TVReg_UPAL[][8],CH7007TVReg_OPAL[][8];
190extern UCHAR CH7007TVCRT1UNTSC_H[][10],CH7007TVCRT1ONTSC_H[][10],CH7007TVCRT1UPAL_H[][10],CH7007TVCRT1OPAL_H[][10] ;
191extern UCHAR CH7007TVCRT1UNTSC_V[][10],CH7007TVCRT1ONTSC_V[][10],CH7007TVCRT1UPAL_V[][10],CH7007TVCRT1OPAL_V[][10] ;
192extern UCHAR XGI7007_CHTVVCLKUNTSC[],XGI7007_CHTVVCLKONTSC[],XGI7007_CHTVVCLKUPAL[],XGI7007_CHTVVCLKOPAL[];
193
194extern BOOLEAN XGI_XG21CheckCH7007TVMode(USHORT ModeNo,USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo ) ;
195extern void SetCH7007Regs(PXGI_HW_DEVICE_INFO HwDeviceExtension, USHORT ModeNo, USHORT ModeIdIndex, USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo ) ;
196extern VP_STATUS TurnOnCH7007(PHW_DEVICE_EXTENSION pHWDE) ;
197extern VP_STATUS TurnOffCH7007(PHW_DEVICE_EXTENSION pHWDE) ;
198extern BOOLEAN IsCH7007TVMode(PVB_DEVICE_INFO pVBInfo) ;
199#endif
200
201/* USHORT XGINew_flag_clearbuffer; 0: no clear frame buffer 1:clear frame buffer */
202
203
204
205
206
207USHORT XGINew_MDA_DAC[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
208 0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
209 0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
210 0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,
211 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
212 0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
213 0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
214 0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F};
215
216USHORT XGINew_CGA_DAC[]={0x00,0x10,0x04,0x14,0x01,0x11,0x09,0x15,
217 0x00,0x10,0x04,0x14,0x01,0x11,0x09,0x15,
218 0x2A,0x3A,0x2E,0x3E,0x2B,0x3B,0x2F,0x3F,
219 0x2A,0x3A,0x2E,0x3E,0x2B,0x3B,0x2F,0x3F,
220 0x00,0x10,0x04,0x14,0x01,0x11,0x09,0x15,
221 0x00,0x10,0x04,0x14,0x01,0x11,0x09,0x15,
222 0x2A,0x3A,0x2E,0x3E,0x2B,0x3B,0x2F,0x3F,
223 0x2A,0x3A,0x2E,0x3E,0x2B,0x3B,0x2F,0x3F};
224
225USHORT XGINew_EGA_DAC[]={0x00,0x10,0x04,0x14,0x01,0x11,0x05,0x15,
226 0x20,0x30,0x24,0x34,0x21,0x31,0x25,0x35,
227 0x08,0x18,0x0C,0x1C,0x09,0x19,0x0D,0x1D,
228 0x28,0x38,0x2C,0x3C,0x29,0x39,0x2D,0x3D,
229 0x02,0x12,0x06,0x16,0x03,0x13,0x07,0x17,
230 0x22,0x32,0x26,0x36,0x23,0x33,0x27,0x37,
231 0x0A,0x1A,0x0E,0x1E,0x0B,0x1B,0x0F,0x1F,
232 0x2A,0x3A,0x2E,0x3E,0x2B,0x3B,0x2F,0x3F};
233
234USHORT XGINew_VGA_DAC[]={0x00,0x10,0x04,0x14,0x01,0x11,0x09,0x15,
235 0x2A,0x3A,0x2E,0x3E,0x2B,0x3B,0x2F,0x3F,
236 0x00,0x05,0x08,0x0B,0x0E,0x11,0x14,0x18,
237 0x1C,0x20,0x24,0x28,0x2D,0x32,0x38,0x3F,
238
239 0x00,0x10,0x1F,0x2F,0x3F,0x1F,0x27,0x2F,
240 0x37,0x3F,0x2D,0x31,0x36,0x3A,0x3F,0x00,
241 0x07,0x0E,0x15,0x1C,0x0E,0x11,0x15,0x18,
242 0x1C,0x14,0x16,0x18,0x1A,0x1C,0x00,0x04,
243 0x08,0x0C,0x10,0x08,0x0A,0x0C,0x0E,0x10,
244 0x0B,0x0C,0x0D,0x0F,0x10};
245
246
247/* --------------------------------------------------------------------- */
248/* Function : InitTo330Pointer */
249/* Input : */
250/* Output : */
251/* Description : */
252/* --------------------------------------------------------------------- */
253void InitTo330Pointer( UCHAR ChipType ,PVB_DEVICE_INFO pVBInfo)
254{
255 pVBInfo->SModeIDTable = (XGI_StStruct *) XGI330_SModeIDTable ;
256 pVBInfo->StandTable = (XGI_StandTableStruct *) XGI330_StandTable ;
257 pVBInfo->EModeIDTable = (XGI_ExtStruct *) XGI330_EModeIDTable ;
258 pVBInfo->RefIndex = (XGI_Ext2Struct *) XGI330_RefIndex ;
259 pVBInfo->XGINEWUB_CRT1Table = (XGI_CRT1TableStruct *) XGI_CRT1Table ;
260
261 /* add for new UNIVGABIOS */
262 /* XGINew_UBLCDDataTable = (XGI_LCDDataTablStruct *) XGI_LCDDataTable ; */
263 /* XGINew_UBTVDataTable = (XGI_TVDataTablStruct *) XGI_TVDataTable ; */
264
265
266 if ( ChipType >= XG40 )
267 {
268 pVBInfo->MCLKData = (XGI_MCLKDataStruct *) XGI340New_MCLKData ;
269 pVBInfo->ECLKData = (XGI_ECLKDataStruct *) XGI340_ECLKData ;
270 }
271 else
272 {
273 pVBInfo->MCLKData = (XGI_MCLKDataStruct *) XGI330New_MCLKData ;
274 pVBInfo->ECLKData = (XGI_ECLKDataStruct *) XGI330_ECLKData ;
275 }
276
277 pVBInfo->VCLKData = (XGI_VCLKDataStruct *) XGI_VCLKData ;
278 pVBInfo->VBVCLKData = (XGI_VBVCLKDataStruct *) XGI_VBVCLKData ;
279 pVBInfo->ScreenOffset = XGI330_ScreenOffset ;
280 pVBInfo->StResInfo = (XGI_StResInfoStruct *) XGI330_StResInfo ;
281 pVBInfo->ModeResInfo = (XGI_ModeResInfoStruct *) XGI330_ModeResInfo ;
282
283 pVBInfo->pOutputSelect = &XGI330_OutputSelect ;
284 pVBInfo->pSoftSetting = &XGI330_SoftSetting ;
285 pVBInfo->pSR07 = &XGI330_SR07 ;
286 pVBInfo->LCDResInfo = 0 ;
287 pVBInfo->LCDTypeInfo = 0 ;
288 pVBInfo->LCDInfo = 0 ;
289 pVBInfo->VBInfo = 0 ;
290 pVBInfo->TVInfo = 0;
291
292
293 pVBInfo->SR15 = XGI340_SR13 ;
294 pVBInfo->CR40 = XGI340_cr41 ;
295 pVBInfo->SR25 = XGI330_sr25 ;
296 pVBInfo->pSR31 = &XGI330_sr31 ;
297 pVBInfo->pSR32 = &XGI330_sr32 ;
298 pVBInfo->CR6B = XGI340_CR6B ;
299 pVBInfo->CR6E = XGI340_CR6E ;
300 pVBInfo->CR6F = XGI340_CR6F ;
301 pVBInfo->CR89 = XGI340_CR89 ;
302 pVBInfo->AGPReg = XGI340_AGPReg ;
303 pVBInfo->SR16 = XGI340_SR16 ;
304 pVBInfo->pCRCF = &XG40_CRCF ;
305 pVBInfo->pXGINew_DRAMTypeDefinition = &XG40_DRAMTypeDefinition ;
306
307
308 pVBInfo->CR49 = XGI330_CR49 ;
309 pVBInfo->pSR1F = &XGI330_SR1F ;
310 pVBInfo->pSR21 = &XGI330_SR21 ;
311 pVBInfo->pSR22 = &XGI330_SR22 ;
312 pVBInfo->pSR23 = &XGI330_SR23 ;
313 pVBInfo->pSR24 = &XGI330_SR24 ;
314 pVBInfo->pSR33 = &XGI330_SR33 ;
315
316
317
318 pVBInfo->pCRT2Data_1_2 = &XGI330_CRT2Data_1_2 ;
319 pVBInfo->pCRT2Data_4_D = &XGI330_CRT2Data_4_D ;
320 pVBInfo->pCRT2Data_4_E = &XGI330_CRT2Data_4_E ;
321 pVBInfo->pCRT2Data_4_10 = &XGI330_CRT2Data_4_10 ;
322 pVBInfo->pRGBSenseData = &XGI330_RGBSenseData ;
323 pVBInfo->pVideoSenseData = &XGI330_VideoSenseData ;
324 pVBInfo->pYCSenseData = &XGI330_YCSenseData ;
325 pVBInfo->pRGBSenseData2 = &XGI330_RGBSenseData2 ;
326 pVBInfo->pVideoSenseData2 = &XGI330_VideoSenseData2 ;
327 pVBInfo->pYCSenseData2 = &XGI330_YCSenseData2 ;
328
329 pVBInfo->NTSCTiming = XGI330_NTSCTiming ;
330 pVBInfo->PALTiming = XGI330_PALTiming ;
331 pVBInfo->HiTVExtTiming = XGI330_HiTVExtTiming ;
332 pVBInfo->HiTVSt1Timing = XGI330_HiTVSt1Timing ;
333 pVBInfo->HiTVSt2Timing = XGI330_HiTVSt2Timing ;
334 pVBInfo->HiTVTextTiming = XGI330_HiTVTextTiming ;
335 pVBInfo->YPbPr750pTiming = XGI330_YPbPr750pTiming ;
336 pVBInfo->YPbPr525pTiming = XGI330_YPbPr525pTiming ;
337 pVBInfo->YPbPr525iTiming = XGI330_YPbPr525iTiming ;
338 pVBInfo->HiTVGroup3Data = XGI330_HiTVGroup3Data ;
339 pVBInfo->HiTVGroup3Simu = XGI330_HiTVGroup3Simu ;
340 pVBInfo->HiTVGroup3Text = XGI330_HiTVGroup3Text ;
341 pVBInfo->Ren525pGroup3 = XGI330_Ren525pGroup3 ;
342 pVBInfo->Ren750pGroup3 = XGI330_Ren750pGroup3 ;
343
344
345 pVBInfo->TimingH = (XGI_TimingHStruct *) XGI_TimingH ;
346 pVBInfo->TimingV = (XGI_TimingVStruct *) XGI_TimingV ;
347 pVBInfo->UpdateCRT1 = (XGI_XG21CRT1Struct *) XGI_UpdateCRT1Table ;
348
349 pVBInfo->CHTVVCLKUNTSC = XGI330_CHTVVCLKUNTSC ;
350 pVBInfo->CHTVVCLKONTSC = XGI330_CHTVVCLKONTSC ;
351 pVBInfo->CHTVVCLKUPAL = XGI330_CHTVVCLKUPAL ;
352 pVBInfo->CHTVVCLKOPAL = XGI330_CHTVVCLKOPAL ;
353
354 /* 310 customization related */
355 if ( ( pVBInfo->VBType & VB_XGI301LV ) || ( pVBInfo->VBType & VB_XGI302LV ) )
356 pVBInfo->LCDCapList = XGI_LCDDLCapList ;
357 else
358 pVBInfo->LCDCapList = XGI_LCDCapList ;
359
360 if ( ( ChipType == XG21 ) || ( ChipType == XG27 ) )
361 pVBInfo->XG21_LVDSCapList = XGI21_LCDCapList ;
362
363 pVBInfo->XGI_TVDelayList = XGI301TVDelayList ;
364 pVBInfo->XGI_TVDelayList2 = XGI301TVDelayList2 ;
365
366
367 pVBInfo->pXGINew_I2CDefinition = &XG40_I2CDefinition ;
368
369 if ( ChipType >= XG20 )
370 pVBInfo->pXGINew_CR97 = &XG20_CR97 ;
371
372 if ( ChipType == XG27 )
373 {
374 pVBInfo->MCLKData = (XGI_MCLKDataStruct *) XGI27New_MCLKData ;
375 pVBInfo->CR40 = XGI27_cr41 ;
376 pVBInfo->pXGINew_CR97 = &XG27_CR97 ;
377 pVBInfo->pSR36 = &XG27_SR36 ;
378 pVBInfo->pCR8F = &XG27_CR8F ;
379 pVBInfo->pCRD0 = XG27_CRD0 ;
380 pVBInfo->pCRDE = XG27_CRDE ;
381 pVBInfo->pSR40 = &XG27_SR40 ;
382 pVBInfo->pSR41 = &XG27_SR41 ;
383
384 }
385
386 if ( ChipType >= XG20 )
387 {
388 pVBInfo->pDVOSetting = &XG21_DVOSetting ;
389 pVBInfo->pCR2E = &XG21_CR2E ;
390 pVBInfo->pCR2F = &XG21_CR2F ;
391 pVBInfo->pCR46 = &XG21_CR46 ;
392 pVBInfo->pCR47 = &XG21_CR47 ;
393 }
394
395}
396
397
398
399
400
401
402/* --------------------------------------------------------------------- */
403/* Function : XGISetModeNew */
404/* Input : */
405/* Output : */
406/* Description : */
407/* --------------------------------------------------------------------- */
408BOOLEAN XGISetModeNew( PXGI_HW_DEVICE_INFO HwDeviceExtension , USHORT ModeNo )
409{
410 USHORT ModeIdIndex ;
411 /* PUCHAR pVBInfo->FBAddr = HwDeviceExtension->pjVideoMemoryAddress ; */
412 VB_DEVICE_INFO VBINF;
413 PVB_DEVICE_INFO pVBInfo = &VBINF;
414 pVBInfo->ROMAddr = HwDeviceExtension->pjVirtualRomBase ;
415 pVBInfo->BaseAddr = (ULONG)HwDeviceExtension->pjIOAddress ;
416 pVBInfo->IF_DEF_LVDS = 0 ;
417 pVBInfo->IF_DEF_CH7005 = 0 ;
418 pVBInfo->IF_DEF_LCDA = 1 ;
419 pVBInfo->IF_DEF_CH7017 = 0 ;
420 pVBInfo->IF_DEF_CH7007 = 0 ; /* [Billy] 2007/05/14 */
421 pVBInfo->IF_DEF_VideoCapture = 0 ;
422 pVBInfo->IF_DEF_ScaleLCD = 0 ;
423 pVBInfo->IF_DEF_OEMUtil = 0 ;
424 pVBInfo->IF_DEF_PWD = 0 ;
425
426
427 if ( HwDeviceExtension->jChipType >= XG20 ) /* kuku 2004/06/25 */
428 {
429 pVBInfo->IF_DEF_YPbPr = 0 ;
430 pVBInfo->IF_DEF_HiVision = 0 ;
431 pVBInfo->IF_DEF_CRT2Monitor = 0 ;
432 pVBInfo->VBType = 0 ; /*set VBType default 0*/
433 }
434 else if ( HwDeviceExtension->jChipType >= XG40 )
435 {
436 pVBInfo->IF_DEF_YPbPr = 1 ;
437 pVBInfo->IF_DEF_HiVision = 1 ;
438 pVBInfo->IF_DEF_CRT2Monitor = 1 ;
439 }
440 else
441 {
442 pVBInfo->IF_DEF_YPbPr = 1 ;
443 pVBInfo->IF_DEF_HiVision = 1 ;
444 pVBInfo->IF_DEF_CRT2Monitor = 0 ;
445 }
446
447 pVBInfo->P3c4 = pVBInfo->BaseAddr + 0x14 ;
448 pVBInfo->P3d4 = pVBInfo->BaseAddr + 0x24 ;
449 pVBInfo->P3c0 = pVBInfo->BaseAddr + 0x10 ;
450 pVBInfo->P3ce = pVBInfo->BaseAddr + 0x1e ;
451 pVBInfo->P3c2 = pVBInfo->BaseAddr + 0x12 ;
452 pVBInfo->P3cc = pVBInfo->BaseAddr + 0x1C ;
453 pVBInfo->P3ca = pVBInfo->BaseAddr + 0x1a ;
454 pVBInfo->P3c6 = pVBInfo->BaseAddr + 0x16 ;
455 pVBInfo->P3c7 = pVBInfo->BaseAddr + 0x17 ;
456 pVBInfo->P3c8 = pVBInfo->BaseAddr + 0x18 ;
457 pVBInfo->P3c9 = pVBInfo->BaseAddr + 0x19 ;
458 pVBInfo->P3da = pVBInfo->BaseAddr + 0x2A ;
459 pVBInfo->Part0Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_00 ;
460 pVBInfo->Part1Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_04 ;
461 pVBInfo->Part2Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_10 ;
462 pVBInfo->Part3Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_12 ;
463 pVBInfo->Part4Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_14 ;
464 pVBInfo->Part5Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_14 + 2 ;
465
466 if ( HwDeviceExtension->jChipType == XG21 ) /* for x86 Linux, XG21 LVDS */
467 {
468 if ( ( XGINew_GetReg1( pVBInfo->P3d4 , 0x38 ) & 0xE0 ) == 0xC0 )
469 {
470 pVBInfo->IF_DEF_LVDS = 1 ;
471 }
472 }
473 if ( HwDeviceExtension->jChipType == XG27 )
474 {
475 if ( ( XGINew_GetReg1( pVBInfo->P3d4 , 0x38 ) & 0xE0 ) == 0xC0 )
476 {
477 if ( XGINew_GetReg1( pVBInfo->P3d4 , 0x30 ) & 0x20 )
478 {
479 pVBInfo->IF_DEF_LVDS = 1 ;
480 }
481 }
482 }
483
484 if ( HwDeviceExtension->jChipType < XG20 ) /* kuku 2004/06/25 */
485 XGI_GetVBType( pVBInfo ) ;
486
487 InitTo330Pointer( HwDeviceExtension->jChipType, pVBInfo ) ;
488#ifdef WIN2000
489 ReadVBIOSTablData( HwDeviceExtension->jChipType , pVBInfo) ;
490#endif
491 if ( ModeNo & 0x80 )
492 {
493 ModeNo = ModeNo & 0x7F ;
494/* XGINew_flag_clearbuffer = 0 ; */
495 }
496/* else
497 {
498 XGINew_flag_clearbuffer = 1 ;
499 }
500*/
501 XGINew_SetReg1( pVBInfo->P3c4 , 0x05 , 0x86 ) ;
502
503 if ( HwDeviceExtension->jChipType < XG20 ) /* kuku 2004/06/25 1.Openkey */
504 XGI_UnLockCRT2( HwDeviceExtension , pVBInfo ) ;
505
506 XGI_SearchModeID( ModeNo , &ModeIdIndex, pVBInfo ) ;
507
508 XGI_GetVGAType(HwDeviceExtension, pVBInfo) ;
509
510 if ( HwDeviceExtension->jChipType < XG20 ) /* kuku 2004/06/25 */
511 {
512 XGI_GetVBInfo(ModeNo , ModeIdIndex , HwDeviceExtension, pVBInfo ) ;
513 XGI_GetTVInfo(ModeNo , ModeIdIndex, pVBInfo ) ;
514 XGI_GetLCDInfo(ModeNo , ModeIdIndex, pVBInfo ) ;
515 XGI_DisableBridge( HwDeviceExtension,pVBInfo ) ;
516/* XGI_OpenCRTC( HwDeviceExtension, pVBInfo ) ; */
517
518 if ( pVBInfo->VBInfo & ( SetSimuScanMode | SetCRT2ToLCDA ) )
519 {
520 XGI_SetCRT1Group(HwDeviceExtension , ModeNo , ModeIdIndex, pVBInfo ) ;
521
522 if ( pVBInfo->VBInfo & SetCRT2ToLCDA )
523 {
524 XGI_SetLCDAGroup(ModeNo , ModeIdIndex , HwDeviceExtension, pVBInfo ) ;
525 }
526 }
527 else
528 {
529 if ( !( pVBInfo->VBInfo & SwitchToCRT2) )
530 {
531 XGI_SetCRT1Group( HwDeviceExtension , ModeNo , ModeIdIndex, pVBInfo ) ;
532 if ( pVBInfo->VBInfo & SetCRT2ToLCDA )
533 {
534 XGI_SetLCDAGroup( ModeNo , ModeIdIndex , HwDeviceExtension, pVBInfo ) ;
535 }
536 }
537 }
538
539 if ( pVBInfo->VBInfo & ( SetSimuScanMode | SwitchToCRT2 ) )
540 {
541 switch( HwDeviceExtension->ujVBChipID )
542 {
543 case VB_CHIP_301:
544 XGI_SetCRT2Group301( ModeNo , HwDeviceExtension, pVBInfo ) ; /*add for CRT2 */
545 break ;
546
547 case VB_CHIP_302:
548 XGI_SetCRT2Group301(ModeNo , HwDeviceExtension, pVBInfo ) ; /*add for CRT2 */
549 break ;
550
551 default:
552 break ;
553 }
554 }
555
556 XGI_SetCRT2ModeRegs( ModeNo, HwDeviceExtension,pVBInfo ) ;
557 XGI_OEM310Setting( ModeNo, ModeIdIndex,pVBInfo ) ; /*0212*/
558 XGI_CloseCRTC( HwDeviceExtension, pVBInfo ) ;
559 XGI_EnableBridge( HwDeviceExtension ,pVBInfo) ;
560 } /* !XG20 */
561 else
562 {
563#ifdef WIN2000
564 if ( pVBInfo->IF_DEF_CH7007 == 1 )
565 {
566
567 VideoDebugPrint((0, "XGISetModeNew: pVBIfo->IF_DEF_CH7007==1\n"));
568 pVBInfo->VBType = VB_CH7007 ;
569 XGI_GetVBInfo(ModeNo , ModeIdIndex , HwDeviceExtension, pVBInfo ) ;
570 XGI_GetTVInfo(ModeNo , ModeIdIndex, pVBInfo ) ;
571 XGI_GetLCDInfo(ModeNo , ModeIdIndex, pVBInfo ) ;
572 if( !(XGI_XG21CheckCH7007TVMode(ModeNo, ModeIdIndex, pVBInfo )) )
573 {
574 return FALSE;
575 }
576 }
577#endif
578
579
580 if ( pVBInfo->IF_DEF_LVDS == 1 )
581 {
582 if ( !XGI_XG21CheckLVDSMode(ModeNo , ModeIdIndex, pVBInfo) )
583 {
584 return FALSE;
585 }
586 }
587
588 if ( ModeNo <= 0x13 )
589 {
590 pVBInfo->ModeType = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag & ModeInfoFlag;
591 }
592 else
593 {
594 pVBInfo->ModeType = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag & ModeInfoFlag;
595 }
596
597 pVBInfo->SetFlag = 0 ;
598 if ( pVBInfo->IF_DEF_CH7007 != 1 )
599 {
600 pVBInfo->VBInfo = DisableCRT2Display ;
601 }
602
603
604 XGI_DisplayOff(HwDeviceExtension, pVBInfo) ;
605
606 XGI_SetCRT1Group(HwDeviceExtension , ModeNo , ModeIdIndex, pVBInfo ) ;
607
608 XGI_DisplayOn( HwDeviceExtension, pVBInfo ) ;
609 /*
610 if( HwDeviceExtension->jChipType == XG21 )
611 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x09 , ~0x80 , 0x80 ) ;
612 */
613 }
614
615
616/*
617 if ( ModeNo <= 0x13 )
618 {
619 modeflag = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag ;
620 }
621 else
622 {
623 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag ;
624 }
625 pVBInfo->ModeType = modeflag&ModeInfoFlag ;
626 pVBInfo->SetFlag = 0x00 ;
627 pVBInfo->VBInfo = DisableCRT2Display ;
628 temp = XGINew_CheckMemorySize( HwDeviceExtension , ModeNo , ModeIdIndex, pVBInfo ) ;
629
630 if ( temp == 0 )
631 return( 0 ) ;
632
633 XGI_DisplayOff( HwDeviceExtension, pVBInfo) ;
634 XGI_SetCRT1Group( HwDeviceExtension , ModeNo , ModeIdIndex, pVBInfo ) ;
635 XGI_DisplayOn( HwDeviceExtension, pVBInfo) ;
636*/
637
638 XGI_UpdateModeInfo( HwDeviceExtension, pVBInfo ) ;
639
640 if ( HwDeviceExtension->jChipType < XG20 ) /* kuku 2004/06/25 */
641{
642 XGI_LockCRT2( HwDeviceExtension, pVBInfo ) ;
643}
644
645 return( TRUE ) ;
646}
647
648
649/* --------------------------------------------------------------------- */
650/* Function : XGI_SetCRT1Group */
651/* Input : */
652/* Output : */
653/* Description : */
654/* --------------------------------------------------------------------- */
655void XGI_SetCRT1Group( PXGI_HW_DEVICE_INFO HwDeviceExtension , USHORT ModeNo , USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo )
656{
657 USHORT StandTableIndex ,
658 RefreshRateTableIndex ,
659 b3CC ,
660 temp ;
661
662 USHORT XGINew_P3cc = pVBInfo->P3cc;
663
664 /* XGINew_CRT1Mode = ModeNo ; // SaveModeID */
665 StandTableIndex = XGI_GetModePtr( ModeNo , ModeIdIndex, pVBInfo ) ;
666 /* XGI_SetBIOSData(ModeNo , ModeIdIndex ) ; */
667 /* XGI_ClearBankRegs( ModeNo , ModeIdIndex ) ; */
668 XGI_SetSeqRegs( ModeNo , StandTableIndex , ModeIdIndex, pVBInfo ) ;
669 XGI_SetMiscRegs( StandTableIndex, pVBInfo ) ;
670 XGI_SetCRTCRegs( HwDeviceExtension , StandTableIndex, pVBInfo) ;
671 XGI_SetATTRegs( ModeNo , StandTableIndex , ModeIdIndex, pVBInfo ) ;
672 XGI_SetGRCRegs( StandTableIndex, pVBInfo ) ;
673 XGI_ClearExt1Regs(pVBInfo) ;
674
675/* if ( pVBInfo->IF_DEF_ExpLink ) */
676 if ( HwDeviceExtension->jChipType == XG27 )
677 {
678 if ( pVBInfo->IF_DEF_LVDS == 0 )
679 {
680 XGI_SetDefaultVCLK( pVBInfo ) ;
681 }
682 }
683
684 temp = ~ProgrammingCRT2 ;
685 pVBInfo->SetFlag &= temp ;
686 pVBInfo->SelectCRT2Rate = 0 ;
687
688 if ( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
689 {
690 if ( pVBInfo->VBInfo & ( SetSimuScanMode | SetCRT2ToLCDA | SetInSlaveMode ) )
691 {
692 pVBInfo->SetFlag |= ProgrammingCRT2 ;
693 }
694 }
695
696 RefreshRateTableIndex = XGI_GetRatePtrCRT2( HwDeviceExtension, ModeNo , ModeIdIndex, pVBInfo ) ;
697 if ( RefreshRateTableIndex != 0xFFFF )
698 {
699 XGI_SetSync( RefreshRateTableIndex, pVBInfo ) ;
700 XGI_SetCRT1CRTC( ModeNo , ModeIdIndex , RefreshRateTableIndex, pVBInfo, HwDeviceExtension ) ;
701 XGI_SetCRT1DE( HwDeviceExtension , ModeNo , ModeIdIndex , RefreshRateTableIndex, pVBInfo ) ;
702 XGI_SetCRT1Offset( ModeNo , ModeIdIndex , RefreshRateTableIndex , HwDeviceExtension, pVBInfo ) ;
703 XGI_SetCRT1VCLK( ModeNo , ModeIdIndex , HwDeviceExtension , RefreshRateTableIndex, pVBInfo ) ;
704 }
705
706 if ( ( HwDeviceExtension->jChipType >= XG20 )&&
707 ( HwDeviceExtension->jChipType < XG27 ) ) /* fix H/W DCLK/2 bug */
708 {
709 if ( ( ModeNo == 0x00 ) | (ModeNo == 0x01) )
710 {
711 XGINew_SetReg1( pVBInfo->P3c4 , 0x2B , 0x4E) ;
712 XGINew_SetReg1( pVBInfo->P3c4 , 0x2C , 0xE9) ;
713 b3CC =(UCHAR) XGINew_GetReg2(XGINew_P3cc) ;
714 XGINew_SetReg3(XGINew_P3cc , (b3CC |= 0x0C) ) ;
715 }
716 else if ( ( ModeNo == 0x04) | ( ModeNo == 0x05) | ( ModeNo == 0x0D) )
717 {
718 XGINew_SetReg1( pVBInfo->P3c4 , 0x2B , 0x1B) ;
719 XGINew_SetReg1( pVBInfo->P3c4 , 0x2C , 0xE3) ;
720 b3CC = (UCHAR)XGINew_GetReg2(XGINew_P3cc) ;
721 XGINew_SetReg3(XGINew_P3cc , (b3CC |= 0x0C) ) ;
722 }
723 }
724
725 if ( HwDeviceExtension->jChipType >= XG21 )
726 {
727 temp = XGINew_GetReg1( pVBInfo->P3d4 , 0x38 ) ;
728 if ( temp & 0xA0 )
729 {
730
731 /*XGINew_SetRegAND( pVBInfo->P3d4 , 0x4A , ~0x20 ) ;*/ /* Enable write GPIOF */
732 /*XGINew_SetRegAND( pVBInfo->P3d4 , 0x48 , ~0x20 ) ;*/ /* P. DWN */
733 /* XG21 CRT1 Timing */
734 if ( HwDeviceExtension->jChipType == XG27 )
735 XGI_SetXG27CRTC( ModeNo, ModeIdIndex, RefreshRateTableIndex, pVBInfo );
736 else
737 XGI_SetXG21CRTC( ModeNo, ModeIdIndex, RefreshRateTableIndex, pVBInfo );
738
739 XGI_UpdateXG21CRTC( ModeNo , pVBInfo , RefreshRateTableIndex) ;
740
741 if ( HwDeviceExtension->jChipType == XG27 )
742 XGI_SetXG27LCD( pVBInfo , RefreshRateTableIndex , ModeNo );
743 else
744 XGI_SetXG21LCD( pVBInfo , RefreshRateTableIndex , ModeNo );
745
746 if ( pVBInfo->IF_DEF_LVDS == 1 )
747 {
748 if ( HwDeviceExtension->jChipType == XG27 )
749 XGI_SetXG27LVDSPara(ModeNo,ModeIdIndex, pVBInfo );
750 else
751 XGI_SetXG21LVDSPara(ModeNo,ModeIdIndex, pVBInfo );
752 }
753 /*XGINew_SetRegOR( pVBInfo->P3d4 , 0x48 , 0x20 ) ;*/ /* P. ON */
754 }
755 }
756
757 pVBInfo->SetFlag &= ( ~ProgrammingCRT2 ) ;
758 XGI_SetCRT1FIFO( ModeNo , HwDeviceExtension, pVBInfo ) ;
759 XGI_SetCRT1ModeRegs( HwDeviceExtension , ModeNo , ModeIdIndex , RefreshRateTableIndex , pVBInfo) ;
760
761
762 /* XGI_LoadCharacter(); //dif ifdef TVFont */
763
764 XGI_LoadDAC( ModeNo , ModeIdIndex, pVBInfo ) ;
765 /* XGI_ClearBuffer( HwDeviceExtension , ModeNo, pVBInfo ) ; */
766#ifdef WIN2000
767 if ( pVBInfo->IF_DEF_CH7007 == 1 ) /* [Billy] 2007/05/14 */
768 {
769 VideoDebugPrint((0, "XGI_SetCRT1Group: VBInfo->IF_DEF_CH7007==1\n"));
770 SetCH7007Regs(HwDeviceExtension, ModeNo, ModeIdIndex, RefreshRateTableIndex, pVBInfo ) ; /* 07/05/28 */
771 }
772#endif
773}
774
775
776/* --------------------------------------------------------------------- */
777/* Function : XGI_GetModePtr */
778/* Input : */
779/* Output : */
780/* Description : */
781/* --------------------------------------------------------------------- */
782UCHAR XGI_GetModePtr( USHORT ModeNo , USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo )
783{
784 UCHAR index ;
785
786 if ( ModeNo <= 0x13 )
787 index = pVBInfo->SModeIDTable[ ModeIdIndex ].St_StTableIndex ;
788 else
789 {
790 if ( pVBInfo->ModeType <= 0x02 )
791 index = 0x1B ; /* 02 -> ModeEGA */
792 else
793 index = 0x0F ;
794 }
795 return( index ) ; /* Get pVBInfo->StandTable index */
796}
797
798
799/* --------------------------------------------------------------------- */
800/* Function : XGI_SetBIOSData */
801/* Input : */
802/* Output : */
803/* Description : */
804/* --------------------------------------------------------------------- */
805/*UCHAR XGI_SetBIOSData( USHORT ModeNo , USHORT ModeIdIndex )
806{
807 return( 0 ) ;
808}
809*/
810
811/* --------------------------------------------------------------------- */
812/* Function : XGI_ClearBankRegs */
813/* Input : */
814/* Output : */
815/* Description : */
816/* --------------------------------------------------------------------- */
817/*UCHAR XGI_ClearBankRegs( USHORT ModeNo , USHORT ModeIdIndex )
818{
819 return( 0 ) ;
820}
821*/
822
823/* --------------------------------------------------------------------- */
824/* Function : XGI_SetSeqRegs */
825/* Input : */
826/* Output : */
827/* Description : */
828/* --------------------------------------------------------------------- */
829void XGI_SetSeqRegs( USHORT ModeNo , USHORT StandTableIndex , USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo )
830{
831 UCHAR tempah ,
832 SRdata ;
833
834 USHORT i ,
835 modeflag ;
836
837 if ( ModeNo <= 0x13 )
838 modeflag = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag ;
839 else
840 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag ;
841
842 XGINew_SetReg1( pVBInfo->P3c4 , 0x00 , 0x03 ) ; /* Set SR0 */
843 tempah=pVBInfo->StandTable[ StandTableIndex ].SR[ 0 ] ;
844
845 i = SetCRT2ToLCDA ;
846 if ( pVBInfo->VBInfo & SetCRT2ToLCDA )
847 {
848 tempah |= 0x01 ;
849 }
850 else
851 {
852 if ( pVBInfo->VBInfo & ( SetCRT2ToTV | SetCRT2ToLCD ) )
853 {
854 if ( pVBInfo->VBInfo & SetInSlaveMode )
855 tempah |= 0x01 ;
856 }
857 }
858
859 tempah |= 0x20 ; /* screen off */
860 XGINew_SetReg1( pVBInfo->P3c4 , 0x01 , tempah ) ; /* Set SR1 */
861
862 for( i = 02 ; i <= 04 ; i++ )
863 {
864 SRdata = pVBInfo->StandTable[ StandTableIndex ].SR[ i - 1 ] ; /* Get SR2,3,4 from file */
865 XGINew_SetReg1( pVBInfo->P3c4 , i , SRdata ) ; /* Set SR2 3 4 */
866 }
867}
868
869
870/* --------------------------------------------------------------------- */
871/* Function : XGI_SetMiscRegs */
872/* Input : */
873/* Output : */
874/* Description : */
875/* --------------------------------------------------------------------- */
876void XGI_SetMiscRegs( USHORT StandTableIndex, PVB_DEVICE_INFO pVBInfo )
877{
878 UCHAR Miscdata ;
879
880 Miscdata = pVBInfo->StandTable[ StandTableIndex ].MISC ; /* Get Misc from file */
881/*
882 if ( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
883 {
884 if ( pVBInfo->VBInfo & SetCRT2ToLCDA )
885 {
886 Miscdata |= 0x0C ;
887 }
888 }
889*/
890
891 XGINew_SetReg3( pVBInfo->P3c2 , Miscdata ) ; /* Set Misc(3c2) */
892}
893
894
895/* --------------------------------------------------------------------- */
896/* Function : XGI_SetCRTCRegs */
897/* Input : */
898/* Output : */
899/* Description : */
900/* --------------------------------------------------------------------- */
901void XGI_SetCRTCRegs( PXGI_HW_DEVICE_INFO HwDeviceExtension , USHORT StandTableIndex, PVB_DEVICE_INFO pVBInfo )
902{
903 UCHAR CRTCdata ;
904 USHORT i ;
905
906 CRTCdata = ( UCHAR )XGINew_GetReg1( pVBInfo->P3d4 , 0x11 ) ;
907 CRTCdata &= 0x7f ;
908 XGINew_SetReg1( pVBInfo->P3d4 , 0x11 , CRTCdata ) ; /* Unlock CRTC */
909
910 for( i = 0 ; i <= 0x18 ; i++ )
911 {
912 CRTCdata = pVBInfo->StandTable[ StandTableIndex ].CRTC[ i ] ; /* Get CRTC from file */
913 XGINew_SetReg1( pVBInfo->P3d4 , i , CRTCdata ) ; /* Set CRTC( 3d4 ) */
914 }
915/*
916 if ( ( HwDeviceExtension->jChipType == XGI_630 )&& ( HwDeviceExtension->jChipRevision == 0x30 ) )
917 {
918 if ( pVBInfo->VBInfo & SetInSlaveMode )
919 {
920 if ( pVBInfo->VBInfo & ( SetCRT2ToLCD | SetCRT2ToTV ) )
921 {
922 XGINew_SetReg1( pVBInfo->P3d4 , 0x18 , 0xFE ) ;
923 }
924 }
925 }
926*/
927}
928
929
930/* --------------------------------------------------------------------- */
931/* Function : */
932/* Input : */
933/* Output : */
934/* Description : */
935/* --------------------------------------------------------------------- */
936void XGI_SetATTRegs( USHORT ModeNo , USHORT StandTableIndex , USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo )
937{
938 UCHAR ARdata ;
939 USHORT i ,
940 modeflag ;
941
942 if ( ModeNo <= 0x13 )
943 modeflag = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag ;
944 else
945 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag ;
946
947 for( i = 0 ; i <= 0x13 ; i++ )
948 {
949 ARdata = pVBInfo->StandTable[ StandTableIndex ].ATTR[ i ] ;
950 if ( modeflag & Charx8Dot ) /* ifndef Dot9 */
951 {
952 if ( i == 0x13 )
953 {
954 if ( pVBInfo->VBInfo & SetCRT2ToLCDA )
955 ARdata = 0 ;
956 else
957 {
958 if ( pVBInfo->VBInfo & ( SetCRT2ToTV | SetCRT2ToLCD ) )
959 {
960 if ( pVBInfo->VBInfo & SetInSlaveMode )
961 ARdata = 0 ;
962 }
963 }
964 }
965 }
966
967 XGINew_GetReg2( pVBInfo->P3da ) ; /* reset 3da */
968 XGINew_SetReg3( pVBInfo->P3c0 , i ) ; /* set index */
969 XGINew_SetReg3( pVBInfo->P3c0 , ARdata ) ; /* set data */
970 }
971
972 XGINew_GetReg2( pVBInfo->P3da ) ; /* reset 3da */
973 XGINew_SetReg3( pVBInfo->P3c0 , 0x14 ) ; /* set index */
974 XGINew_SetReg3( pVBInfo->P3c0 , 0x00 ) ; /* set data */
975 XGINew_GetReg2( pVBInfo->P3da ) ; /* Enable Attribute */
976 XGINew_SetReg3( pVBInfo->P3c0 , 0x20 ) ;
977}
978
979
980/* --------------------------------------------------------------------- */
981/* Function : XGI_SetGRCRegs */
982/* Input : */
983/* Output : */
984/* Description : */
985/* --------------------------------------------------------------------- */
986void XGI_SetGRCRegs( USHORT StandTableIndex, PVB_DEVICE_INFO pVBInfo )
987{
988 UCHAR GRdata ;
989 USHORT i ;
990
991 for( i = 0 ; i <= 0x08 ; i++ )
992 {
993 GRdata = pVBInfo->StandTable[ StandTableIndex ].GRC[ i ] ; /* Get GR from file */
994 XGINew_SetReg1( pVBInfo->P3ce , i , GRdata ) ; /* Set GR(3ce) */
995 }
996
997 if ( pVBInfo->ModeType > ModeVGA )
998 {
999 GRdata = ( UCHAR )XGINew_GetReg1( pVBInfo->P3ce , 0x05 ) ;
1000 GRdata &= 0xBF ; /* 256 color disable */
1001 XGINew_SetReg1( pVBInfo->P3ce , 0x05 , GRdata ) ;
1002 }
1003}
1004
1005
1006/* --------------------------------------------------------------------- */
1007/* Function : XGI_ClearExt1Regs */
1008/* Input : */
1009/* Output : */
1010/* Description : */
1011/* --------------------------------------------------------------------- */
1012void XGI_ClearExt1Regs(PVB_DEVICE_INFO pVBInfo)
1013{
1014 USHORT i ;
1015
1016 for( i = 0x0A ; i <= 0x0E ; i++ )
1017 XGINew_SetReg1( pVBInfo->P3c4 , i , 0x00 ) ; /* Clear SR0A-SR0E */
1018}
1019
1020
1021/* --------------------------------------------------------------------- */
1022/* Function : XGI_SetDefaultVCLK */
1023/* Input : */
1024/* Output : */
1025/* Description : */
1026/* --------------------------------------------------------------------- */
1027UCHAR XGI_SetDefaultVCLK( PVB_DEVICE_INFO pVBInfo )
1028{
1029
1030 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x31 , ~0x30 , 0x20 ) ;
1031 XGINew_SetReg1( pVBInfo->P3c4 , 0x2B , pVBInfo->VCLKData[ 0 ].SR2B ) ;
1032 XGINew_SetReg1( pVBInfo->P3c4 , 0x2C , pVBInfo->VCLKData[ 0 ].SR2C ) ;
1033
1034 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x31 , ~0x30 , 0x10 ) ;
1035 XGINew_SetReg1( pVBInfo->P3c4 , 0x2B , pVBInfo->VCLKData[ 1 ].SR2B ) ;
1036 XGINew_SetReg1( pVBInfo->P3c4 , 0x2C , pVBInfo->VCLKData[ 1 ].SR2C ) ;
1037
1038 XGINew_SetRegAND( pVBInfo->P3c4 , 0x31 , ~0x30 ) ;
1039 return( 0 ) ;
1040}
1041
1042
1043/* --------------------------------------------------------------------- */
1044/* Function : XGI_GetRatePtrCRT2 */
1045/* Input : */
1046/* Output : */
1047/* Description : */
1048/* --------------------------------------------------------------------- */
1049USHORT XGI_GetRatePtrCRT2( PXGI_HW_DEVICE_INFO pXGIHWDE, USHORT ModeNo , USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo )
1050{
1051 SHORT LCDRefreshIndex[] = { 0x00 , 0x00 , 0x03 , 0x01 } ,
1052 LCDARefreshIndex[] = { 0x00 , 0x00 , 0x03 , 0x01 , 0x01 , 0x01 , 0x01 } ;
1053
1054 USHORT RefreshRateTableIndex , i ,
1055 modeflag , index , temp ;
1056
1057 if ( ModeNo <= 0x13 )
1058 {
1059 modeflag = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag ;
1060 }
1061 else
1062 {
1063 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag ;
1064 }
1065
1066 if ( pVBInfo->IF_DEF_CH7005 == 1 )
1067 {
1068 if ( pVBInfo->VBInfo & SetCRT2ToTV )
1069 {
1070 if ( modeflag & HalfDCLK )
1071 return( 0 ) ;
1072 }
1073 }
1074
1075 if ( ModeNo < 0x14 )
1076 return( 0xFFFF ) ;
1077
1078 index = XGINew_GetReg1( pVBInfo->P3d4 , 0x33 ) ;
1079 index = index >> pVBInfo->SelectCRT2Rate ;
1080 index &= 0x0F ;
1081
1082 if ( pVBInfo->LCDInfo & LCDNonExpanding )
1083 index = 0 ;
1084
1085 if ( index > 0 )
1086 index-- ;
1087
1088 if ( pVBInfo->SetFlag & ProgrammingCRT2 )
1089 {
1090 if ( pVBInfo->IF_DEF_CH7005 == 1 )
1091 {
1092 if ( pVBInfo->VBInfo & SetCRT2ToTV )
1093 {
1094 index = 0 ;
1095 }
1096 }
1097
1098 if ( pVBInfo->VBInfo & ( SetCRT2ToLCD | SetCRT2ToLCDA ) )
1099 {
1100 if( pVBInfo->IF_DEF_LVDS == 0 )
1101 {
1102 if ( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
1103 temp = LCDARefreshIndex[ pVBInfo->LCDResInfo & 0x0F ] ; /* 301b */
1104 else
1105 temp = LCDRefreshIndex[ pVBInfo->LCDResInfo & 0x0F ] ;
1106
1107 if ( index > temp )
1108 {
1109 index = temp ;
1110 }
1111 }
1112 else
1113 {
1114 index = 0 ;
1115 }
1116 }
1117 }
1118
1119 RefreshRateTableIndex = pVBInfo->EModeIDTable[ ModeIdIndex ].REFindex ;
1120 ModeNo = pVBInfo->RefIndex[ RefreshRateTableIndex ].ModeID ;
1121 if ( pXGIHWDE->jChipType >= XG20 ) /* for XG20, XG21, XG27 */
1122 {
1123 /*
1124 if ( pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_InfoFlag & XG2xNotSupport )
1125 {
1126 index++;
1127 }
1128 */
1129 if ( ( pVBInfo->RefIndex[ RefreshRateTableIndex ].XRes == 800 ) &&
1130 ( pVBInfo->RefIndex[ RefreshRateTableIndex ].YRes == 600 ) )
1131 {
1132 index++;
1133 }
1134/* Alan 10/19/2007; do the similiar adjustment like XGISearchCRT1Rate() */
1135 if ( ( pVBInfo->RefIndex[ RefreshRateTableIndex ].XRes == 1024 ) &&
1136 ( pVBInfo->RefIndex[ RefreshRateTableIndex ].YRes == 768 ) )
1137 {
1138 index++;
1139 }
1140 if ( ( pVBInfo->RefIndex[ RefreshRateTableIndex ].XRes == 1280 ) &&
1141 ( pVBInfo->RefIndex[ RefreshRateTableIndex ].YRes == 1024 ) )
1142 {
1143 index++;
1144 }
1145 }
1146
1147 i = 0 ;
1148 do
1149 {
1150 if ( pVBInfo->RefIndex[ RefreshRateTableIndex + i ].ModeID != ModeNo )
1151 break ;
1152 temp = pVBInfo->RefIndex[ RefreshRateTableIndex + i ].Ext_InfoFlag ;
1153 temp &= ModeInfoFlag ;
1154 if ( temp < pVBInfo->ModeType )
1155 break ;
1156 i++ ;
1157 index-- ;
1158
1159 } while( index != 0xFFFF ) ;
1160 if ( !( pVBInfo->VBInfo & SetCRT2ToRAMDAC ) )
1161 {
1162 if ( pVBInfo->VBInfo & SetInSlaveMode )
1163 {
1164 temp = pVBInfo->RefIndex[ RefreshRateTableIndex + i - 1 ].Ext_InfoFlag ;
1165 if ( temp & InterlaceMode )
1166 {
1167 i++ ;
1168 }
1169 }
1170 }
1171 i-- ;
1172 if ( ( pVBInfo->SetFlag & ProgrammingCRT2 ) )
1173 {
1174 temp = XGI_AjustCRT2Rate( ModeNo , ModeIdIndex , RefreshRateTableIndex , &i, pVBInfo) ;
1175 }
1176 return( RefreshRateTableIndex + i ) ; /*return(0x01|(temp1<<1)); */
1177}
1178
1179
1180/* --------------------------------------------------------------------- */
1181/* Function : XGI_AjustCRT2Rate */
1182/* Input : */
1183/* Output : */
1184/* Description : */
1185/* --------------------------------------------------------------------- */
1186BOOLEAN XGI_AjustCRT2Rate( USHORT ModeNo , USHORT ModeIdIndex , USHORT RefreshRateTableIndex , USHORT *i, PVB_DEVICE_INFO pVBInfo )
1187{
1188 USHORT tempax ,
1189 tempbx ,
1190 resinfo ,
1191 modeflag ,
1192 infoflag ;
1193
1194 if ( ModeNo <= 0x13 )
1195 {
1196 modeflag = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag ; /* si+St_ModeFlag */
1197 }
1198 else
1199 {
1200 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag ;
1201 }
1202
1203 resinfo = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_RESINFO ;
1204 tempbx = pVBInfo->RefIndex[ RefreshRateTableIndex + ( *i ) ].ModeID ;
1205 tempax = 0 ;
1206
1207 if ( pVBInfo->IF_DEF_LVDS == 0 )
1208 {
1209 if ( pVBInfo->VBInfo & SetCRT2ToRAMDAC )
1210 {
1211 tempax |= SupportRAMDAC2 ;
1212
1213 if ( pVBInfo->VBType & VB_XGI301C )
1214 tempax |= SupportCRT2in301C ;
1215 }
1216
1217 if ( pVBInfo->VBInfo & ( SetCRT2ToLCD | SetCRT2ToLCDA ) ) /* 301b */
1218 {
1219 tempax |= SupportLCD ;
1220
1221 if ( pVBInfo->LCDResInfo != Panel1280x1024 )
1222 {
1223 if ( pVBInfo->LCDResInfo != Panel1280x960 )
1224 {
1225 if ( pVBInfo->LCDInfo & LCDNonExpanding )
1226 {
1227 if ( resinfo >= 9 )
1228 {
1229 tempax = 0 ;
1230 return( 0 ) ;
1231 }
1232 }
1233 }
1234 }
1235 }
1236
1237 if ( pVBInfo->VBInfo & SetCRT2ToHiVisionTV ) /* for HiTV */
1238 {
1239 if ( ( pVBInfo->VBType & VB_XGI301LV ) && ( pVBInfo->VBExtInfo == VB_YPbPr1080i ) )
1240 {
1241 tempax |= SupportYPbPr ;
1242 if ( pVBInfo->VBInfo & SetInSlaveMode )
1243 {
1244 if ( resinfo == 4 )
1245 return( 0 ) ;
1246
1247 if ( resinfo == 3 )
1248 return( 0 ) ;
1249
1250 if ( resinfo > 7 )
1251 return( 0 ) ;
1252 }
1253 }
1254 else
1255 {
1256 tempax |= SupportHiVisionTV ;
1257 if ( pVBInfo->VBInfo & SetInSlaveMode )
1258 {
1259 if ( resinfo == 4 )
1260 return( 0 ) ;
1261
1262 if ( resinfo == 3 )
1263 {
1264 if ( pVBInfo->SetFlag & TVSimuMode )
1265 return( 0 ) ;
1266 }
1267
1268 if ( resinfo > 7 )
1269 return( 0 ) ;
1270 }
1271 }
1272 }
1273 else
1274 {
1275 if ( pVBInfo->VBInfo & ( SetCRT2ToAVIDEO | SetCRT2ToSVIDEO | SetCRT2ToSCART | SetCRT2ToYPbPr | SetCRT2ToHiVisionTV ) )
1276 {
1277 tempax |= SupportTV ;
1278
1279 if ( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
1280 {
1281 tempax |= SupportTV1024 ;
1282 }
1283
1284 if ( !( pVBInfo->VBInfo & SetPALTV ) )
1285 {
1286 if ( modeflag & NoSupportSimuTV )
1287 {
1288 if ( pVBInfo->VBInfo & SetInSlaveMode )
1289 {
1290 if ( !( pVBInfo->VBInfo & SetNotSimuMode ) )
1291 {
1292 return( 0 ) ;
1293 }
1294 }
1295 }
1296 }
1297 }
1298 }
1299 }
1300 else /* for LVDS */
1301 {
1302 if ( pVBInfo->IF_DEF_CH7005 == 1 )
1303 {
1304 if ( pVBInfo->VBInfo & SetCRT2ToTV )
1305 {
1306 tempax |= SupportCHTV ;
1307 }
1308 }
1309
1310 if ( pVBInfo->VBInfo & SetCRT2ToLCD )
1311 {
1312 tempax |= SupportLCD ;
1313
1314 if ( resinfo > 0x08 )
1315 return( 0 ) ; /* 1024x768 */
1316
1317 if ( pVBInfo->LCDResInfo < Panel1024x768 )
1318 {
1319 if ( resinfo > 0x07 )
1320 return( 0 ) ; /* 800x600 */
1321
1322 if ( resinfo == 0x04 )
1323 return( 0 ) ; /* 512x384 */
1324 }
1325 }
1326 }
1327
1328 for( ; pVBInfo->RefIndex[ RefreshRateTableIndex + ( *i ) ].ModeID == tempbx ; ( *i )-- )
1329 {
1330 infoflag = pVBInfo->RefIndex[ RefreshRateTableIndex + ( *i ) ].Ext_InfoFlag ;
1331 if ( infoflag & tempax )
1332 {
1333 return( 1 ) ;
1334 }
1335 if ( ( *i ) == 0 )
1336 break ;
1337 }
1338
1339 for( ( *i ) = 0 ; ; ( *i )++ )
1340 {
1341 infoflag = pVBInfo->RefIndex[ RefreshRateTableIndex + ( *i ) ].Ext_InfoFlag ;
1342 if ( pVBInfo->RefIndex[ RefreshRateTableIndex + ( *i ) ].ModeID != tempbx )
1343 {
1344 return( 0 ) ;
1345 }
1346
1347 if ( infoflag & tempax )
1348 {
1349 return( 1 ) ;
1350 }
1351 }
1352 return( 1 ) ;
1353}
1354
1355
1356/* --------------------------------------------------------------------- */
1357/* Function : XGI_SetSync */
1358/* Input : */
1359/* Output : */
1360/* Description : */
1361/* --------------------------------------------------------------------- */
1362void XGI_SetSync(USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo )
1363{
1364 USHORT sync ,
1365 temp ;
1366
1367 sync = pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_InfoFlag >> 8 ; /* di+0x00 */
1368 sync &= 0xC0 ;
1369 temp = 0x2F ;
1370 temp |= sync ;
1371 XGINew_SetReg3( pVBInfo->P3c2 , temp ) ; /* Set Misc(3c2) */
1372}
1373
1374
1375/* --------------------------------------------------------------------- */
1376/* Function : XGI_SetCRT1CRTC */
1377/* Input : */
1378/* Output : */
1379/* Description : */
1380/* --------------------------------------------------------------------- */
1381void XGI_SetCRT1CRTC( USHORT ModeNo , USHORT ModeIdIndex , USHORT RefreshRateTableIndex,PVB_DEVICE_INFO pVBInfo, PXGI_HW_DEVICE_INFO HwDeviceExtension )
1382{
1383 UCHAR index ,
1384 data ;
1385
1386 USHORT i ;
1387
1388 index = pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_CRT1CRTC ; /* Get index */
1389 index = index&IndexMask ;
1390
1391 data =( UCHAR )XGINew_GetReg1( pVBInfo->P3d4 , 0x11 ) ;
1392 data &= 0x7F ;
1393 XGINew_SetReg1(pVBInfo->P3d4,0x11,data); /* Unlock CRTC */
1394
1395 for( i = 0 ; i < 8 ; i++ )
1396 pVBInfo->TimingH[ 0 ].data[ i ] = pVBInfo->XGINEWUB_CRT1Table[ index ].CR[ i ] ;
1397
1398 for( i = 0 ; i < 7 ; i++ )
1399 pVBInfo->TimingV[ 0 ].data[ i ] = pVBInfo->XGINEWUB_CRT1Table[ index ].CR[ i + 8 ] ;
1400
1401 XGI_SetCRT1Timing_H( pVBInfo, HwDeviceExtension ) ;
1402
1403
1404
1405 XGI_SetCRT1Timing_V( ModeIdIndex , ModeNo, pVBInfo ) ;
1406
1407
1408 if( pVBInfo->ModeType > 0x03 )
1409 XGINew_SetReg1( pVBInfo->P3d4 , 0x14 , 0x4F ) ;
1410}
1411
1412
1413/* --------------------------------------------------------------------- */
1414/* Function : XGI_SetCRT1Timing_H */
1415/* Input : */
1416/* Output : */
1417/* Description : */
1418/* --------------------------------------------------------------------- */
1419void XGI_SetCRT1Timing_H( PVB_DEVICE_INFO pVBInfo, PXGI_HW_DEVICE_INFO HwDeviceExtension )
1420{
1421 UCHAR data , data1, pushax;
1422 USHORT i , j ;
1423
1424 /* XGINew_SetReg1( pVBInfo->P3d4 , 0x51 , 0 ) ; */
1425 /* XGINew_SetReg1( pVBInfo->P3d4 , 0x56 , 0 ) ; */
1426 /* XGINew_SetRegANDOR( pVBInfo->P3d4 ,0x11 , 0x7f , 0x00 ) ; */
1427
1428 data = ( UCHAR )XGINew_GetReg1( pVBInfo->P3d4 , 0x11 ) ; /* unlock cr0-7 */
1429 data &= 0x7F ;
1430 XGINew_SetReg1( pVBInfo->P3d4 , 0x11 , data ) ;
1431
1432 data = pVBInfo->TimingH[ 0 ].data[ 0 ] ;
1433 XGINew_SetReg1( pVBInfo->P3d4 , 0 , data ) ;
1434
1435 for( i = 0x01 ; i <= 0x04 ; i++ )
1436 {
1437 data = pVBInfo->TimingH[ 0 ].data[ i ] ;
1438 XGINew_SetReg1( pVBInfo->P3d4 , ( USHORT )( i + 1 ) , data ) ;
1439 }
1440
1441 for( i = 0x05 ; i <= 0x06 ; i++ )
1442 {
1443 data = pVBInfo->TimingH[ 0 ].data[ i ];
1444 XGINew_SetReg1( pVBInfo->P3c4 ,( USHORT )( i + 6 ) , data ) ;
1445 }
1446
1447 j = ( UCHAR )XGINew_GetReg1( pVBInfo->P3c4 , 0x0e ) ;
1448 j &= 0x1F ;
1449 data = pVBInfo->TimingH[ 0 ].data[ 7 ] ;
1450 data &= 0xE0 ;
1451 data |= j ;
1452 XGINew_SetReg1( pVBInfo->P3c4 , 0x0e , data ) ;
1453
1454 if ( HwDeviceExtension->jChipType >= XG20 )
1455 {
1456 data = ( UCHAR )XGINew_GetReg1( pVBInfo->P3d4 , 0x04 ) ;
1457 data = data - 1 ;
1458 XGINew_SetReg1( pVBInfo->P3d4 , 0x04 , data ) ;
1459 data = ( UCHAR )XGINew_GetReg1( pVBInfo->P3d4 , 0x05 ) ;
1460 data1 = data ;
1461 data1 &= 0xE0 ;
1462 data &= 0x1F ;
1463 if ( data == 0 )
1464 {
1465 pushax = data ;
1466 data = ( UCHAR )XGINew_GetReg1( pVBInfo->P3c4 , 0x0c ) ;
1467 data &= 0xFB ;
1468 XGINew_SetReg1( pVBInfo->P3c4 , 0x0c , data ) ;
1469 data = pushax ;
1470 }
1471 data = data - 1 ;
1472 data |= data1 ;
1473 XGINew_SetReg1( pVBInfo->P3d4 , 0x05 , data ) ;
1474 data = ( UCHAR )XGINew_GetReg1( pVBInfo->P3c4 , 0x0e ) ;
1475 data = data >> 5 ;
1476 data = data + 3 ;
1477 if ( data > 7 )
1478 data = data - 7 ;
1479 data = data << 5 ;
1480 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x0e , ~0xE0 , data ) ;
1481 }
1482}
1483
1484
1485/* --------------------------------------------------------------------- */
1486/* Function : XGI_SetCRT1Timing_V */
1487/* Input : */
1488/* Output : */
1489/* Description : */
1490/* --------------------------------------------------------------------- */
1491void XGI_SetCRT1Timing_V( USHORT ModeIdIndex , USHORT ModeNo,PVB_DEVICE_INFO pVBInfo )
1492{
1493 UCHAR data ;
1494 USHORT i , j ;
1495
1496 /* XGINew_SetReg1( pVBInfo->P3d4 , 0x51 , 0 ) ; */
1497 /* XGINew_SetReg1( pVBInfo->P3d4 , 0x56 , 0 ) ; */
1498 /* XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x11 , 0x7f , 0x00 ) ; */
1499
1500 for( i = 0x00 ; i <= 0x01 ; i++ )
1501 {
1502 data = pVBInfo->TimingV[ 0 ].data[ i ] ;
1503 XGINew_SetReg1( pVBInfo->P3d4 , ( USHORT )( i + 6 ) , data ) ;
1504 }
1505
1506 for( i = 0x02 ; i <= 0x03 ; i++ )
1507 {
1508 data = pVBInfo->TimingV[ 0 ].data[ i ] ;
1509 XGINew_SetReg1( pVBInfo->P3d4 , ( USHORT )( i + 0x0e ) , data ) ;
1510 }
1511
1512 for( i = 0x04 ; i <= 0x05 ; i++ )
1513 {
1514 data = pVBInfo->TimingV[ 0 ].data[ i ] ;
1515 XGINew_SetReg1( pVBInfo->P3d4 , ( USHORT )( i + 0x11 ) , data ) ;
1516 }
1517
1518 j = ( UCHAR )XGINew_GetReg1( pVBInfo->P3c4 , 0x0a ) ;
1519 j &= 0xC0 ;
1520 data = pVBInfo->TimingV[ 0 ].data[ 6 ] ;
1521 data &= 0x3F ;
1522 data |= j ;
1523 XGINew_SetReg1( pVBInfo->P3c4 , 0x0a , data ) ;
1524
1525 data = pVBInfo->TimingV[ 0 ].data[ 6 ] ;
1526 data &= 0x80 ;
1527 data = data >> 2 ;
1528
1529 if ( ModeNo <= 0x13 )
1530 i = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag ;
1531 else
1532 i = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag ;
1533
1534 i &= DoubleScanMode ;
1535 if ( i )
1536 data |= 0x80 ;
1537
1538 j = ( UCHAR )XGINew_GetReg1( pVBInfo->P3d4 , 0x09 ) ;
1539 j &= 0x5F ;
1540 data |= j ;
1541 XGINew_SetReg1( pVBInfo->P3d4 , 0x09 , data ) ;
1542}
1543
1544
1545/* --------------------------------------------------------------------- */
1546/* Function : XGI_SetXG21CRTC */
1547/* Input : Stand or enhance CRTC table */
1548/* Output : Fill CRT Hsync/Vsync to SR2E/SR2F/SR30/SR33/SR34/SR3F */
1549/* Description : Set LCD timing */
1550/* --------------------------------------------------------------------- */
1551void XGI_SetXG21CRTC(USHORT ModeNo, USHORT ModeIdIndex, USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo)
1552{
1553 UCHAR StandTableIndex, index, Tempax, Tempbx, Tempcx, Tempdx ;
1554 USHORT Temp1, Temp2, Temp3 ;
1555
1556 if ( ModeNo <= 0x13 )
1557 {
1558 StandTableIndex = XGI_GetModePtr( ModeNo , ModeIdIndex, pVBInfo ) ;
1559 Tempax = pVBInfo->StandTable[ StandTableIndex ].CRTC[ 4 ] ; /* CR04 HRS */
1560 XGINew_SetReg1( pVBInfo->P3c4 , 0x2E , Tempax ) ; /* SR2E [7:0]->HRS */
1561 Tempbx = pVBInfo->StandTable[ StandTableIndex ].CRTC[ 5 ] ; /* Tempbx: CR05 HRE */
1562 Tempbx &= 0x1F ; /* Tempbx: HRE[4:0] */
1563 Tempcx = Tempax ;
1564 Tempcx &= 0xE0 ; /* Tempcx: HRS[7:5] */
1565 Tempdx = Tempcx | Tempbx ; /* Tempdx(HRE): HRS[7:5]HRE[4:0] */
1566 if ( Tempbx < ( Tempax & 0x1F ) ) /* IF HRE < HRS */
1567 Tempdx |= 0x20 ; /* Tempdx: HRE = HRE + 0x20 */
1568 Tempdx <<= 2 ; /* Tempdx << 2 */
1569 XGINew_SetReg1( pVBInfo->P3c4 , 0x2F , Tempdx ) ; /* SR2F [7:2]->HRE */
1570 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x30 , 0xE3 , 00 ) ;
1571
1572 Tempax = pVBInfo->StandTable[ StandTableIndex ].CRTC[ 16 ] ; /* Tempax: CR16 VRS */
1573 Tempbx = Tempax ; /* Tempbx=Tempax */
1574 Tempax &= 0x01 ; /* Tempax: VRS[0] */
1575 XGINew_SetRegOR( pVBInfo->P3c4 , 0x33 , Tempax ) ; /* SR33[0]->VRS */
1576 Tempax = pVBInfo->StandTable[ StandTableIndex ].CRTC[ 7 ] ; /* Tempax: CR7 VRS */
1577 Tempdx = Tempbx >> 1 ; /* Tempdx: VRS[7:1] */
1578 Tempcx = Tempax & 0x04 ; /* Tempcx: CR7[2] */
1579 Tempcx <<= 5 ; /* Tempcx[7]: VRS[8] */
1580 Tempdx |= Tempcx ; /* Tempdx: VRS[8:1] */
1581 XGINew_SetReg1( pVBInfo->P3c4 , 0x34 , Tempdx ) ; /* SR34[7:0]: VRS[8:1] */
1582
1583 Temp1 = Tempcx << 1 ; /* Temp1[8]: VRS[8] UCHAR -> USHORT */
1584 Temp1 |= Tempbx ; /* Temp1[8:0]: VRS[8:0] */
1585 Tempax &= 0x80 ; /* Tempax[7]: CR7[7] */
1586 Temp2 = Tempax << 2 ; /* Temp2[9]: VRS[9] */
1587 Temp1 |= Temp2 ; /* Temp1[9:0]: VRS[9:0] */
1588
1589 Tempax = pVBInfo->StandTable[ StandTableIndex ].CRTC[ 17 ] ; /* CR16 VRE */
1590 Tempax &= 0x0F ; /* Tempax[3:0]: VRE[3:0] */
1591 Temp2 = Temp1 & 0x3F0 ; /* Temp2[9:4]: VRS[9:4] */
1592 Temp2 |= Tempax ; /* Temp2[9:0]: VRE[9:0] */
1593 Temp3 = Temp1 & 0x0F ; /* Temp3[3:0]: VRS[3:0] */
1594 if ( Tempax < Temp3 ) /* VRE[3:0]<VRS[3:0] */
1595 Temp2 |= 0x10 ; /* Temp2: VRE + 0x10 */
1596 Temp2 &= 0xFF ; /* Temp2[7:0]: VRE[7:0] */
1597 Tempax = (UCHAR)Temp2 ; /* Tempax[7:0]: VRE[7:0] */
1598 Tempax <<= 2 ; /* Tempax << 2: VRE[5:0] */
1599 Temp1 &= 0x600 ; /* Temp1[10:9]: VRS[10:9] */
1600 Temp1 >>= 9 ; /* [10:9]->[1:0] */
1601 Tempbx = (UCHAR)Temp1 ; /* Tempbx[1:0]: VRS[10:9] */
1602 Tempax |= Tempbx ; /* VRE[5:0]VRS[10:9] */
1603 Tempax &= 0x7F ;
1604 XGINew_SetReg1( pVBInfo->P3c4 , 0x3F , Tempax ) ; /* SR3F D[7:2]->VRE D[1:0]->VRS */
1605 }
1606 else
1607 {
1608 index = pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_CRT1CRTC ;
1609 Tempax = pVBInfo->XGINEWUB_CRT1Table[ index ].CR[ 3 ] ; /* Tempax: CR4 HRS */
1610 Tempcx = Tempax ; /* Tempcx: HRS */
1611 XGINew_SetReg1( pVBInfo->P3c4 , 0x2E , Tempax ) ; /* SR2E[7:0]->HRS */
1612
1613 Tempdx = pVBInfo->XGINEWUB_CRT1Table[ index ].CR[ 5 ] ; /* SRB */
1614 Tempdx &= 0xC0 ; /* Tempdx[7:6]: SRB[7:6] */
1615 Temp1 = Tempdx ; /* Temp1[7:6]: HRS[9:8] */
1616 Temp1 <<= 2 ; /* Temp1[9:8]: HRS[9:8] */
1617 Temp1 |= Tempax ; /* Temp1[9:0]: HRS[9:0] */
1618
1619 Tempax = pVBInfo->XGINEWUB_CRT1Table[ index ].CR[ 4 ] ; /* CR5 HRE */
1620 Tempax &= 0x1F ; /* Tempax[4:0]: HRE[4:0] */
1621
1622 Tempbx = pVBInfo->XGINEWUB_CRT1Table[ index ].CR[ 6 ] ; /* SRC */
1623 Tempbx &= 0x04 ; /* Tempbx[2]: HRE[5] */
1624 Tempbx <<= 3 ; /* Tempbx[5]: HRE[5] */
1625 Tempax |= Tempbx ; /* Tempax[5:0]: HRE[5:0] */
1626
1627 Temp2 = Temp1 & 0x3C0 ; /* Temp2[9:6]: HRS[9:6] */
1628 Temp2 |= Tempax ; /* Temp2[9:0]: HRE[9:0] */
1629
1630 Tempcx &= 0x3F ; /* Tempcx[5:0]: HRS[5:0] */
1631 if( Tempax < Tempcx ) /* HRE < HRS */
1632 Temp2 |= 0x40 ; /* Temp2 + 0x40 */
1633
1634 Temp2 &= 0xFF ;
1635 Tempax = (UCHAR)Temp2 ; /* Tempax: HRE[7:0] */
1636 Tempax <<= 2 ; /* Tempax[7:2]: HRE[5:0] */
1637 Tempdx >>= 6 ; /* Tempdx[7:6]->[1:0] HRS[9:8] */
1638 Tempax |= Tempdx ; /* HRE[5:0]HRS[9:8] */
1639 XGINew_SetReg1( pVBInfo->P3c4 , 0x2F , Tempax ) ; /* SR2F D[7:2]->HRE, D[1:0]->HRS */
1640 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x30 , 0xE3 , 00 ) ;
1641
1642 Tempax = pVBInfo->XGINEWUB_CRT1Table[ index ].CR[ 10 ] ; /* CR10 VRS */
1643 Tempbx = Tempax ; /* Tempbx: VRS */
1644 Tempax &= 0x01 ; /* Tempax[0]: VRS[0] */
1645 XGINew_SetRegOR( pVBInfo->P3c4 , 0x33 , Tempax ) ; /* SR33[0]->VRS[0] */
1646 Tempax = pVBInfo->XGINEWUB_CRT1Table[ index ].CR[ 9 ] ; /* CR7[2][7] VRE */
1647 Tempcx = Tempbx >> 1 ; /* Tempcx[6:0]: VRS[7:1] */
1648 Tempdx = Tempax & 0x04 ; /* Tempdx[2]: CR7[2] */
1649 Tempdx <<= 5 ; /* Tempdx[7]: VRS[8] */
1650 Tempcx |= Tempdx ; /* Tempcx[7:0]: VRS[8:1] */
1651 XGINew_SetReg1( pVBInfo->P3c4 , 0x34 , Tempcx ) ; /* SR34[8:1]->VRS */
1652
1653 Temp1 = Tempdx ; /* Temp1[7]: Tempdx[7] */
1654 Temp1 <<= 1 ; /* Temp1[8]: VRS[8] */
1655 Temp1 |= Tempbx ; /* Temp1[8:0]: VRS[8:0] */
1656 Tempax &= 0x80 ;
1657 Temp2 = Tempax << 2 ; /* Temp2[9]: VRS[9] */
1658 Temp1 |= Temp2 ; /* Temp1[9:0]: VRS[9:0] */
1659 Tempax = pVBInfo->XGINEWUB_CRT1Table[ index ].CR[ 14 ] ; /* Tempax: SRA */
1660 Tempax &= 0x08 ; /* Tempax[3]: VRS[3] */
1661 Temp2 = Tempax ;
1662 Temp2 <<= 7 ; /* Temp2[10]: VRS[10] */
1663 Temp1 |= Temp2 ; /* Temp1[10:0]: VRS[10:0] */
1664
1665 Tempax = pVBInfo->XGINEWUB_CRT1Table[ index ].CR[ 11 ] ; /* Tempax: CR11 VRE */
1666 Tempax &= 0x0F ; /* Tempax[3:0]: VRE[3:0] */
1667 Tempbx = pVBInfo->XGINEWUB_CRT1Table[ index ].CR[ 14 ] ; /* Tempbx: SRA */
1668 Tempbx &= 0x20 ; /* Tempbx[5]: VRE[5] */
1669 Tempbx >>= 1 ; /* Tempbx[4]: VRE[4] */
1670 Tempax |= Tempbx ; /* Tempax[4:0]: VRE[4:0] */
1671 Temp2 = Temp1 & 0x7E0 ; /* Temp2[10:5]: VRS[10:5] */
1672 Temp2 |= Tempax ; /* Temp2[10:5]: VRE[10:5] */
1673
1674 Temp3 = Temp1 & 0x1F ; /* Temp3[4:0]: VRS[4:0] */
1675 if ( Tempax < Temp3 ) /* VRE < VRS */
1676 Temp2 |= 0x20 ; /* VRE + 0x20 */
1677
1678 Temp2 &= 0xFF ;
1679 Tempax = (UCHAR)Temp2 ; /* Tempax: VRE[7:0] */
1680 Tempax <<= 2 ; /* Tempax[7:0]; VRE[5:0]00 */
1681 Temp1 &= 0x600 ; /* Temp1[10:9]: VRS[10:9] */
1682 Temp1 >>= 9 ; /* Temp1[1:0]: VRS[10:9] */
1683 Tempbx = (UCHAR)Temp1 ;
1684 Tempax |= Tempbx ; /* Tempax[7:0]: VRE[5:0]VRS[10:9] */
1685 Tempax &= 0x7F ;
1686 XGINew_SetReg1( pVBInfo->P3c4 , 0x3F , Tempax ) ; /* SR3F D[7:2]->VRE D[1:0]->VRS */
1687 }
1688}
1689
1690void XGI_SetXG27CRTC(USHORT ModeNo, USHORT ModeIdIndex, USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo)
1691{
1692 USHORT StandTableIndex, index, Tempax, Tempbx, Tempcx, Tempdx ;
1693
1694 if ( ModeNo <= 0x13 )
1695 {
1696 StandTableIndex = XGI_GetModePtr( ModeNo , ModeIdIndex, pVBInfo ) ;
1697 Tempax = pVBInfo->StandTable[ StandTableIndex ].CRTC[ 4 ] ; /* CR04 HRS */
1698 XGINew_SetReg1( pVBInfo->P3c4 , 0x2E , Tempax ) ; /* SR2E [7:0]->HRS */
1699 Tempbx = pVBInfo->StandTable[ StandTableIndex ].CRTC[ 5 ] ; /* Tempbx: CR05 HRE */
1700 Tempbx &= 0x1F ; /* Tempbx: HRE[4:0] */
1701 Tempcx = Tempax ;
1702 Tempcx &= 0xE0 ; /* Tempcx: HRS[7:5] */
1703 Tempdx = Tempcx | Tempbx ; /* Tempdx(HRE): HRS[7:5]HRE[4:0] */
1704 if ( Tempbx < ( Tempax & 0x1F ) ) /* IF HRE < HRS */
1705 Tempdx |= 0x20 ; /* Tempdx: HRE = HRE + 0x20 */
1706 Tempdx <<= 2 ; /* Tempdx << 2 */
1707 XGINew_SetReg1( pVBInfo->P3c4 , 0x2F , Tempdx ) ; /* SR2F [7:2]->HRE */
1708 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x30 , 0xE3 , 00 ) ;
1709
1710 Tempax = pVBInfo->StandTable[ StandTableIndex ].CRTC[ 16 ] ; /* Tempax: CR10 VRS */
1711 XGINew_SetReg1( pVBInfo->P3c4 , 0x34 , Tempax ) ; /* SR34[7:0]->VRS */
1712 Tempcx = Tempax ; /* Tempcx=Tempax=VRS[7:0] */
1713 Tempax = pVBInfo->StandTable[ StandTableIndex ].CRTC[ 7 ] ; /* Tempax[7][2]: CR7[7][2] VRS[9][8] */
1714 Tempbx = Tempax ; /* Tempbx=CR07 */
1715 Tempax &= 0x04 ; /* Tempax[2]: CR07[2] VRS[8] */
1716 Tempax >>= 2;
1717 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x35 , ~0x01, Tempax ) ; /* SR35 D[0]->VRS D[8] */
1718 Tempcx |= (Tempax << 8) ; /* Tempcx[8] |= VRS[8] */
1719 Tempcx |= (Tempbx & 0x80)<<2; /* Tempcx[9] |= VRS[9] */
1720
1721
1722 Tempax = pVBInfo->StandTable[ StandTableIndex ].CRTC[ 17 ] ; /* CR11 VRE */
1723 Tempax &= 0x0F ; /* Tempax: VRE[3:0] */
1724 Tempbx = Tempcx ; /* Tempbx=Tempcx=VRS[9:0] */
1725 Tempbx &= 0x3F0 ; /* Tempbx[9:4]: VRS[9:4] */
1726 Tempbx |= Tempax ; /* Tempbx[9:0]: VRE[9:0] */
1727 if ( Tempax <= (Tempcx & 0x0F) ) /* VRE[3:0]<=VRS[3:0] */
1728 Tempbx |= 0x10 ; /* Tempbx: VRE + 0x10 */
1729 Tempax = (UCHAR)Tempbx & 0xFF; /* Tempax[7:0]: VRE[7:0] */
1730 Tempax <<= 2 ; /* Tempax << 2: VRE[5:0] */
1731 Tempcx = (Tempcx&0x600)>>8; /* Tempcx VRS[10:9] */
1732 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x3F , ~0xFC, Tempax ) ; /* SR3F D[7:2]->VRE D[5:0] */
1733 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x35 , ~0x06, Tempcx ) ; /* SR35 D[2:1]->VRS[10:9] */
1734 }
1735 else
1736 {
1737 index = pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_CRT1CRTC ;
1738 Tempax = pVBInfo->XGINEWUB_CRT1Table[ index ].CR[ 3 ] ; /* Tempax: CR4 HRS */
1739 Tempbx = Tempax ; /* Tempbx: HRS[7:0] */
1740 XGINew_SetReg1( pVBInfo->P3c4 , 0x2E , Tempax ) ; /* SR2E[7:0]->HRS */
1741
1742 Tempax = pVBInfo->XGINEWUB_CRT1Table[ index ].CR[ 5 ] ; /* SR0B */
1743 Tempax &= 0xC0 ; /* Tempax[7:6]: SR0B[7:6]: HRS[9:8]*/
1744 Tempbx |= (Tempax << 2); /* Tempbx: HRS[9:0] */
1745
1746 Tempax = pVBInfo->XGINEWUB_CRT1Table[ index ].CR[ 4 ] ; /* CR5 HRE */
1747 Tempax &= 0x1F ; /* Tempax[4:0]: HRE[4:0] */
1748 Tempcx = Tempax ; /* Tempcx: HRE[4:0] */
1749
1750 Tempax = pVBInfo->XGINEWUB_CRT1Table[ index ].CR[ 6 ] ; /* SRC */
1751 Tempax &= 0x04 ; /* Tempax[2]: HRE[5] */
1752 Tempax <<= 3 ; /* Tempax[5]: HRE[5] */
1753 Tempcx |= Tempax ; /* Tempcx[5:0]: HRE[5:0] */
1754
1755 Tempbx = Tempbx & 0x3C0 ; /* Tempbx[9:6]: HRS[9:6] */
1756 Tempbx |= Tempcx ; /* Tempbx: HRS[9:6]HRE[5:0] */
1757
1758 Tempax = pVBInfo->XGINEWUB_CRT1Table[ index ].CR[ 3 ] ; /* Tempax: CR4 HRS */
1759 Tempax &= 0x3F ; /* Tempax: HRS[5:0] */
1760 if( Tempcx <= Tempax ) /* HRE[5:0] < HRS[5:0] */
1761 Tempbx += 0x40 ; /* Tempbx= Tempbx + 0x40 : HRE[9:0]*/
1762
1763 Tempax = pVBInfo->XGINEWUB_CRT1Table[ index ].CR[ 5 ] ; /* SR0B */
1764 Tempax &= 0xC0 ; /* Tempax[7:6]: SR0B[7:6]: HRS[9:8]*/
1765 Tempax >>= 6; /* Tempax[1:0]: HRS[9:8]*/
1766 Tempax |= ((Tempbx << 2) & 0xFF); /* Tempax[7:2]: HRE[5:0] */
1767 XGINew_SetReg1( pVBInfo->P3c4 , 0x2F , Tempax ) ; /* SR2F [7:2][1:0]: HRE[5:0]HRS[9:8] */
1768 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x30 , 0xE3 , 00 ) ;
1769
1770 Tempax = pVBInfo->XGINEWUB_CRT1Table[ index ].CR[ 10 ] ; /* CR10 VRS */
1771 XGINew_SetReg1( pVBInfo->P3c4 , 0x34 , Tempax ) ; /* SR34[7:0]->VRS[7:0] */
1772
1773 Tempcx = Tempax ; /* Tempcx <= VRS[7:0] */
1774 Tempax = pVBInfo->XGINEWUB_CRT1Table[ index ].CR[ 9 ] ; /* CR7[7][2] VRS[9][8] */
1775 Tempbx = Tempax ; /* Tempbx <= CR07[7:0] */
1776 Tempax = Tempax & 0x04 ; /* Tempax[2]: CR7[2]: VRS[8] */
1777 Tempax >>= 2 ; /* Tempax[0]: VRS[8] */
1778 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x35 , ~0x01 , Tempax ) ; /* SR35[0]: VRS[8] */
1779 Tempcx |= (Tempax<<8) ; /* Tempcx <= VRS[8:0] */
1780 Tempcx |= ((Tempbx&0x80)<<2) ; /* Tempcx <= VRS[9:0] */
1781 Tempax = pVBInfo->XGINEWUB_CRT1Table[ index ].CR[ 14 ] ; /* Tempax: SR0A */
1782 Tempax &= 0x08; /* SR0A[3] VRS[10] */
1783 Tempcx |= (Tempax<<7) ; /* Tempcx <= VRS[10:0] */
1784
1785
1786 Tempax = pVBInfo->XGINEWUB_CRT1Table[ index ].CR[ 11 ] ; /* Tempax: CR11 VRE */
1787 Tempax &= 0x0F ; /* Tempax[3:0]: VRE[3:0] */
1788 Tempbx = pVBInfo->XGINEWUB_CRT1Table[ index ].CR[ 14 ] ; /* Tempbx: SR0A */
1789 Tempbx &= 0x20 ; /* Tempbx[5]: SR0A[5]: VRE[4] */
1790 Tempbx >>= 1 ; /* Tempbx[4]: VRE[4] */
1791 Tempax |= Tempbx ; /* Tempax[4:0]: VRE[4:0] */
1792 Tempbx = Tempcx ; /* Tempbx: VRS[10:0] */
1793 Tempbx &= 0x7E0 ; /* Tempbx[10:5]: VRS[10:5] */
1794 Tempbx |= Tempax ; /* Tempbx: VRS[10:5]VRE[4:0] */
1795
1796 if ( Tempbx <= Tempcx ) /* VRE <= VRS */
1797 Tempbx |= 0x20 ; /* VRE + 0x20 */
1798
1799 Tempax = (Tempbx<<2) & 0xFF ; /* Tempax: Tempax[7:0]; VRE[5:0]00 */
1800 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x3F , ~0xFC , Tempax ) ; /* SR3F[7:2]:VRE[5:0] */
1801 Tempax = Tempcx >> 8;
1802 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x35 , ~0x07 , Tempax ) ; /* SR35[2:0]:VRS[10:8] */
1803 }
1804}
1805
1806
1807/* --------------------------------------------------------------------- */
1808/* Function : XGI_SetXG21LCD */
1809/* Input : */
1810/* Output : FCLK duty cycle, FCLK delay compensation */
1811/* Description : All values set zero */
1812/* --------------------------------------------------------------------- */
1813void XGI_SetXG21LCD(PVB_DEVICE_INFO pVBInfo,USHORT RefreshRateTableIndex,USHORT ModeNo)
1814{
1815 USHORT Data , Temp , b3CC ;
1816 USHORT XGI_P3cc ;
1817
1818 XGI_P3cc = pVBInfo->P3cc ;
1819
1820 XGINew_SetReg1( pVBInfo->P3d4 , 0x2E , 0x00 ) ;
1821 XGINew_SetReg1( pVBInfo->P3d4 , 0x2F , 0x00 ) ;
1822 XGINew_SetReg1( pVBInfo->P3d4 , 0x46 , 0x00 ) ;
1823 XGINew_SetReg1( pVBInfo->P3d4 , 0x47 , 0x00 ) ;
1824 if ( ((*pVBInfo->pDVOSetting)&0xC0) == 0xC0 )
1825 {
1826 XGINew_SetReg1( pVBInfo->P3d4 , 0x2E , *pVBInfo->pCR2E ) ;
1827 XGINew_SetReg1( pVBInfo->P3d4 , 0x2F , *pVBInfo->pCR2F ) ;
1828 XGINew_SetReg1( pVBInfo->P3d4 , 0x46 , *pVBInfo->pCR46 ) ;
1829 XGINew_SetReg1( pVBInfo->P3d4 , 0x47 , *pVBInfo->pCR47 ) ;
1830 }
1831
1832 Temp = XGINew_GetReg1( pVBInfo->P3d4 , 0x37 ) ;
1833
1834 if ( Temp & 0x01 )
1835 {
1836 XGINew_SetRegOR( pVBInfo->P3c4 , 0x06 , 0x40 ) ; /* 18 bits FP */
1837 XGINew_SetRegOR( pVBInfo->P3c4 , 0x09 , 0x40 ) ;
1838 }
1839
1840 XGINew_SetRegOR( pVBInfo->P3c4 , 0x1E , 0x01 ) ; /* Negative blank polarity */
1841
1842 XGINew_SetRegAND( pVBInfo->P3c4 , 0x30 , ~0x20 ) ;
1843 XGINew_SetRegAND( pVBInfo->P3c4 , 0x35 , ~0x80 ) ;
1844
1845 if ( ModeNo <= 0x13 )
1846 {
1847 b3CC = (UCHAR) XGINew_GetReg2( XGI_P3cc ) ;
1848 if ( b3CC & 0x40 )
1849 XGINew_SetRegOR( pVBInfo->P3c4 , 0x30 , 0x20 ) ; /* Hsync polarity */
1850 if ( b3CC & 0x80 )
1851 XGINew_SetRegOR( pVBInfo->P3c4 , 0x35 , 0x80 ) ; /* Vsync polarity */
1852 }
1853 else
1854 {
1855 Data = pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_InfoFlag ;
1856 if ( Data & 0x4000 )
1857 XGINew_SetRegOR( pVBInfo->P3c4 , 0x30 , 0x20 ) ; /* Hsync polarity */
1858 if ( Data & 0x8000 )
1859 XGINew_SetRegOR( pVBInfo->P3c4 , 0x35 , 0x80 ) ; /* Vsync polarity */
1860 }
1861}
1862
1863void XGI_SetXG27LCD(PVB_DEVICE_INFO pVBInfo,USHORT RefreshRateTableIndex,USHORT ModeNo)
1864{
1865 USHORT Data , Temp , b3CC ;
1866 USHORT XGI_P3cc ;
1867
1868 XGI_P3cc = pVBInfo->P3cc ;
1869
1870 XGINew_SetReg1( pVBInfo->P3d4 , 0x2E , 0x00 ) ;
1871 XGINew_SetReg1( pVBInfo->P3d4 , 0x2F , 0x00 ) ;
1872 XGINew_SetReg1( pVBInfo->P3d4 , 0x46 , 0x00 ) ;
1873 XGINew_SetReg1( pVBInfo->P3d4 , 0x47 , 0x00 ) ;
1874
1875 Temp = XGINew_GetReg1( pVBInfo->P3d4 , 0x37 ) ;
1876 if ( ( Temp & 0x03 ) == 0 ) /* dual 12 */
1877 {
1878 XGINew_SetReg1( pVBInfo->P3d4 , 0x46 , 0x13 ) ;
1879 XGINew_SetReg1( pVBInfo->P3d4 , 0x47 , 0x13 ) ;
1880 }
1881
1882 if ( ((*pVBInfo->pDVOSetting)&0xC0) == 0xC0 )
1883 {
1884 XGINew_SetReg1( pVBInfo->P3d4 , 0x2E , *pVBInfo->pCR2E ) ;
1885 XGINew_SetReg1( pVBInfo->P3d4 , 0x2F , *pVBInfo->pCR2F ) ;
1886 XGINew_SetReg1( pVBInfo->P3d4 , 0x46 , *pVBInfo->pCR46 ) ;
1887 XGINew_SetReg1( pVBInfo->P3d4 , 0x47 , *pVBInfo->pCR47 ) ;
1888 }
1889
1890 XGI_SetXG27FPBits(pVBInfo);
1891
1892 XGINew_SetRegOR( pVBInfo->P3c4 , 0x1E , 0x01 ) ; /* Negative blank polarity */
1893
1894 XGINew_SetRegAND( pVBInfo->P3c4 , 0x30 , ~0x20 ) ; /* Hsync polarity */
1895 XGINew_SetRegAND( pVBInfo->P3c4 , 0x35 , ~0x80 ) ; /* Vsync polarity */
1896
1897 if ( ModeNo <= 0x13 )
1898 {
1899 b3CC = (UCHAR) XGINew_GetReg2( XGI_P3cc ) ;
1900 if ( b3CC & 0x40 )
1901 XGINew_SetRegOR( pVBInfo->P3c4 , 0x30 , 0x20 ) ; /* Hsync polarity */
1902 if ( b3CC & 0x80 )
1903 XGINew_SetRegOR( pVBInfo->P3c4 , 0x35 , 0x80 ) ; /* Vsync polarity */
1904 }
1905 else
1906 {
1907 Data = pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_InfoFlag ;
1908 if ( Data & 0x4000 )
1909 XGINew_SetRegOR( pVBInfo->P3c4 , 0x30 , 0x20 ) ; /* Hsync polarity */
1910 if ( Data & 0x8000 )
1911 XGINew_SetRegOR( pVBInfo->P3c4 , 0x35 , 0x80 ) ; /* Vsync polarity */
1912 }
1913}
1914
1915/* --------------------------------------------------------------------- */
1916/* Function : XGI_UpdateXG21CRTC */
1917/* Input : */
1918/* Output : CRT1 CRTC */
1919/* Description : Modify CRT1 Hsync/Vsync to fix LCD mode timing */
1920/* --------------------------------------------------------------------- */
1921void XGI_UpdateXG21CRTC( USHORT ModeNo , PVB_DEVICE_INFO pVBInfo , USHORT RefreshRateTableIndex )
1922{
1923 int i , index = -1;
1924
1925 XGINew_SetRegAND( pVBInfo->P3d4 , 0x11 , 0x7F ) ; /* Unlock CR0~7 */
1926 if ( ModeNo <= 0x13 )
1927 {
1928 for( i = 0 ; i < 12 ; i++ )
1929 {
1930 if ( ModeNo == pVBInfo->UpdateCRT1[ i ].ModeID )
1931 index = i ;
1932 }
1933 }
1934 else
1935 {
1936 if ( ModeNo == 0x2E && ( pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_CRT1CRTC == RES640x480x60 ) )
1937 index = 12 ;
1938 else if ( ModeNo == 0x2E && ( pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_CRT1CRTC == RES640x480x72 ) )
1939 index = 13 ;
1940 else if ( ModeNo == 0x2F )
1941 index = 14 ;
1942 else if ( ModeNo == 0x50 )
1943 index = 15 ;
1944 else if ( ModeNo == 0x59 )
1945 index = 16 ;
1946 }
1947
1948 if( index != -1 )
1949 {
1950 XGINew_SetReg1( pVBInfo->P3d4 , 0x02 , pVBInfo->UpdateCRT1[ index ].CR02 ) ;
1951 XGINew_SetReg1( pVBInfo->P3d4 , 0x03 , pVBInfo->UpdateCRT1[ index ].CR03 ) ;
1952 XGINew_SetReg1( pVBInfo->P3d4 , 0x15 , pVBInfo->UpdateCRT1[ index ].CR15 ) ;
1953 XGINew_SetReg1( pVBInfo->P3d4 , 0x16 , pVBInfo->UpdateCRT1[ index ].CR16 ) ;
1954 }
1955}
1956
1957
1958/* --------------------------------------------------------------------- */
1959/* Function : XGI_SetCRT1DE */
1960/* Input : */
1961/* Output : */
1962/* Description : */
1963/* --------------------------------------------------------------------- */
1964void XGI_SetCRT1DE( PXGI_HW_DEVICE_INFO HwDeviceExtension , USHORT ModeNo,USHORT ModeIdIndex , USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo )
1965{
1966 USHORT resindex ,
1967 tempax ,
1968 tempbx ,
1969 tempcx ,
1970 temp ,
1971 modeflag ;
1972
1973 UCHAR data ;
1974
1975 resindex = XGI_GetResInfo( ModeNo , ModeIdIndex, pVBInfo ) ;
1976
1977 if ( ModeNo <= 0x13 )
1978 {
1979 modeflag = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag ;
1980 tempax = pVBInfo->StResInfo[ resindex ].HTotal ;
1981 tempbx = pVBInfo->StResInfo[ resindex ].VTotal ;
1982 }
1983 else
1984 {
1985 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag ;
1986 tempax = pVBInfo->ModeResInfo[ resindex ].HTotal ;
1987 tempbx = pVBInfo->ModeResInfo[ resindex ].VTotal ;
1988 }
1989
1990 if ( modeflag & HalfDCLK )
1991 tempax = tempax >> 1 ;
1992
1993 if ( ModeNo > 0x13 )
1994 {
1995 if ( modeflag & HalfDCLK )
1996 tempax = tempax << 1 ;
1997
1998 temp = pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_InfoFlag ;
1999
2000 if ( temp & InterlaceMode )
2001 tempbx = tempbx >> 1 ;
2002
2003 if ( modeflag & DoubleScanMode )
2004 tempbx = tempbx << 1 ;
2005 }
2006
2007 tempcx = 8 ;
2008
2009 /* if ( !( modeflag & Charx8Dot ) ) */
2010 /* tempcx = 9 ; */
2011
2012 tempax /= tempcx ;
2013 tempax -= 1 ;
2014 tempbx -= 1 ;
2015 tempcx = tempax ;
2016 temp = ( UCHAR )XGINew_GetReg1( pVBInfo->P3d4 , 0x11 ) ;
2017 data = ( UCHAR )XGINew_GetReg1( pVBInfo->P3d4 , 0x11 ) ;
2018 data &= 0x7F ;
2019 XGINew_SetReg1( pVBInfo->P3d4 , 0x11 , data ) ; /* Unlock CRTC */
2020 XGINew_SetReg1( pVBInfo->P3d4 , 0x01 , ( USHORT )( tempcx & 0xff ) ) ;
2021 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x0b , ~0x0c , ( USHORT )( ( tempcx & 0x0ff00 ) >> 10 ) ) ;
2022 XGINew_SetReg1( pVBInfo->P3d4 , 0x12 , ( USHORT )( tempbx & 0xff ) ) ;
2023 tempax = 0 ;
2024 tempbx = tempbx >> 8 ;
2025
2026 if ( tempbx & 0x01 )
2027 tempax |= 0x02 ;
2028
2029 if ( tempbx & 0x02 )
2030 tempax |= 0x40 ;
2031
2032 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x07 , ~0x42 , tempax ) ;
2033 data =( UCHAR )XGINew_GetReg1( pVBInfo->P3d4 , 0x07 ) ;
2034 data &= 0xFF ;
2035 tempax = 0 ;
2036
2037 if ( tempbx & 0x04 )
2038 tempax |= 0x02 ;
2039
2040 XGINew_SetRegANDOR( pVBInfo->P3d4 ,0x0a , ~0x02 , tempax ) ;
2041 XGINew_SetReg1( pVBInfo->P3d4 , 0x11 , temp ) ;
2042}
2043
2044
2045/* --------------------------------------------------------------------- */
2046/* Function : XGI_GetResInfo */
2047/* Input : */
2048/* Output : */
2049/* Description : */
2050/* --------------------------------------------------------------------- */
2051USHORT XGI_GetResInfo(USHORT ModeNo , USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo )
2052{
2053 USHORT resindex ;
2054
2055 if ( ModeNo <= 0x13 )
2056 {
2057 resindex = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ResInfo ; /* si+St_ResInfo */
2058 }
2059 else
2060 {
2061 resindex = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_RESINFO ; /* si+Ext_ResInfo */
2062 }
2063 return( resindex ) ;
2064}
2065
2066
2067/* --------------------------------------------------------------------- */
2068/* Function : XGI_SetCRT1Offset */
2069/* Input : */
2070/* Output : */
2071/* Description : */
2072/* --------------------------------------------------------------------- */
2073void XGI_SetCRT1Offset( USHORT ModeNo , USHORT ModeIdIndex , USHORT RefreshRateTableIndex , PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo )
2074{
2075 USHORT temp ,
2076 ah ,
2077 al ,
2078 temp2 ,
2079 i ,
2080 DisplayUnit ;
2081
2082 /* GetOffset */
2083 temp = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeInfo ;
2084 temp = temp >> 8 ;
2085 temp = pVBInfo->ScreenOffset[ temp ] ;
2086
2087 temp2 = pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_InfoFlag ;
2088 temp2 &= InterlaceMode ;
2089
2090 if ( temp2 )
2091 temp = temp << 1;
2092
2093 temp2 = pVBInfo->ModeType - ModeEGA ;
2094
2095 switch( temp2 )
2096 {
2097 case 0:
2098 temp2 = 1 ;
2099 break ;
2100 case 1:
2101 temp2 = 2 ;
2102 break ;
2103 case 2:
2104 temp2 = 4 ;
2105 break ;
2106 case 3:
2107 temp2 = 4 ;
2108 break ;
2109 case 4:
2110 temp2 = 6 ;
2111 break;
2112 case 5:
2113 temp2 = 8 ;
2114 break ;
2115 default:
2116 break ;
2117 }
2118
2119 if ( ( ModeNo >= 0x26 ) && ( ModeNo <= 0x28 ) )
2120 temp = temp * temp2 + temp2 / 2 ;
2121 else
2122 temp *= temp2 ;
2123
2124 /* SetOffset */
2125 DisplayUnit = temp ;
2126 temp2 = temp ;
2127 temp = temp >> 8 ; /* ah */
2128 temp &= 0x0F ;
2129 i = XGINew_GetReg1( pVBInfo->P3c4 , 0x0E ) ;
2130 i &= 0xF0 ;
2131 i |= temp ;
2132 XGINew_SetReg1( pVBInfo->P3c4 , 0x0E , i ) ;
2133
2134 temp =( UCHAR )temp2 ;
2135 temp &= 0xFF ; /* al */
2136 XGINew_SetReg1( pVBInfo->P3d4 , 0x13 , temp ) ;
2137
2138 /* SetDisplayUnit */
2139 temp2 = pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_InfoFlag ;
2140 temp2 &= InterlaceMode ;
2141 if ( temp2 )
2142 DisplayUnit >>= 1 ;
2143
2144 DisplayUnit = DisplayUnit << 5 ;
2145 ah = ( DisplayUnit & 0xff00 ) >> 8 ;
2146 al = DisplayUnit & 0x00ff ;
2147 if ( al == 0 )
2148 ah += 1 ;
2149 else
2150 ah += 2 ;
2151
2152 if ( HwDeviceExtension->jChipType >= XG20 )
2153 if ( ( ModeNo == 0x4A ) | (ModeNo == 0x49 ) )
2154 ah -= 1 ;
2155
2156 XGINew_SetReg1( pVBInfo->P3c4 , 0x10 , ah ) ;
2157}
2158
2159
2160/* --------------------------------------------------------------------- */
2161/* Function : XGI_SetCRT1VCLK */
2162/* Input : */
2163/* Output : */
2164/* Description : */
2165/* --------------------------------------------------------------------- */
2166void XGI_SetCRT1VCLK( USHORT ModeNo , USHORT ModeIdIndex ,
2167 PXGI_HW_DEVICE_INFO HwDeviceExtension , USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo )
2168{
2169 UCHAR index , data ;
2170 USHORT vclkindex ;
2171
2172 if ( pVBInfo->IF_DEF_LVDS == 1 )
2173 {
2174 index = pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_CRTVCLK ;
2175 data = XGINew_GetReg1( pVBInfo->P3c4 , 0x31 ) & 0xCF ;
2176 XGINew_SetReg1( pVBInfo->P3c4 , 0x31 , data ) ;
2177 XGINew_SetReg1( pVBInfo->P3c4 , 0x2B , pVBInfo->VCLKData[ index ].SR2B ) ;
2178 XGINew_SetReg1( pVBInfo->P3c4 , 0x2C , pVBInfo->VCLKData[ index ].SR2C ) ;
2179 XGINew_SetReg1( pVBInfo->P3c4 , 0x2D , 0x01 ) ;
2180 }
2181 else if ( ( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) ) && ( pVBInfo->VBInfo & SetCRT2ToLCDA ) )
2182 {
2183 vclkindex = XGI_GetVCLK2Ptr( ModeNo , ModeIdIndex , RefreshRateTableIndex , HwDeviceExtension, pVBInfo ) ;
2184 data = XGINew_GetReg1( pVBInfo->P3c4 , 0x31 ) & 0xCF ;
2185 XGINew_SetReg1( pVBInfo->P3c4 , 0x31 , data ) ;
2186 data = pVBInfo->VBVCLKData[ vclkindex ].Part4_A ;
2187 XGINew_SetReg1( pVBInfo->P3c4 , 0x2B , data ) ;
2188 data = pVBInfo->VBVCLKData[ vclkindex ].Part4_B ;
2189 XGINew_SetReg1( pVBInfo->P3c4 , 0x2C , data ) ;
2190 XGINew_SetReg1( pVBInfo->P3c4 , 0x2D , 0x01 ) ;
2191 }
2192 else
2193 {
2194 index = pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_CRTVCLK ;
2195 data = XGINew_GetReg1( pVBInfo->P3c4 , 0x31 ) & 0xCF ;
2196 XGINew_SetReg1( pVBInfo->P3c4 , 0x31 , data ) ;
2197 XGINew_SetReg1( pVBInfo->P3c4 , 0x2B , pVBInfo->VCLKData[ index ].SR2B ) ;
2198 XGINew_SetReg1( pVBInfo->P3c4 , 0x2C , pVBInfo->VCLKData[ index ].SR2C ) ;
2199 XGINew_SetReg1( pVBInfo->P3c4 , 0x2D , 0x01 ) ;
2200 }
2201
2202 if ( HwDeviceExtension->jChipType >= XG20 )
2203 {
2204 if ( pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag & HalfDCLK )
2205 {
2206 data = XGINew_GetReg1( pVBInfo->P3c4 , 0x2B ) ;
2207 XGINew_SetReg1( pVBInfo->P3c4 , 0x2B , data ) ;
2208 data = XGINew_GetReg1( pVBInfo->P3c4 , 0x2C ) ;
2209 index = data ;
2210 index &= 0xE0 ;
2211 data &= 0x1F ;
2212 data = data << 1 ;
2213 data += 1 ;
2214 data |= index ;
2215 XGINew_SetReg1( pVBInfo->P3c4 , 0x2C , data ) ;
2216 }
2217 }
2218}
2219
2220
2221/* --------------------------------------------------------------------- */
2222/* Function : XGI_SetCRT1FIFO */
2223/* Input : */
2224/* Output : */
2225/* Description : */
2226/* --------------------------------------------------------------------- */
2227void XGI_SetCRT1FIFO( USHORT ModeNo , PXGI_HW_DEVICE_INFO HwDeviceExtension,PVB_DEVICE_INFO pVBInfo )
2228{
2229 USHORT data ;
2230
2231 data = XGINew_GetReg1( pVBInfo->P3c4 , 0x3D ) ;
2232 data &= 0xfe ;
2233 XGINew_SetReg1( pVBInfo->P3c4 , 0x3D , data ) ; /* diable auto-threshold */
2234
2235 if ( ModeNo > 0x13 )
2236 {
2237 XGINew_SetReg1( pVBInfo->P3c4 , 0x08 , 0x34 ) ;
2238 data = XGINew_GetReg1( pVBInfo->P3c4 , 0x09 ) ;
2239 data &= 0xC0 ;
2240 XGINew_SetReg1( pVBInfo->P3c4 , 0x09 , data | 0x30) ;
2241 data = XGINew_GetReg1( pVBInfo->P3c4 , 0x3D ) ;
2242 data |= 0x01 ;
2243 XGINew_SetReg1( pVBInfo->P3c4 , 0x3D , data ) ;
2244 }
2245 else
2246 {
2247 if (HwDeviceExtension->jChipType == XG27)
2248 {
2249 XGINew_SetReg1( pVBInfo->P3c4 , 0x08 , 0x0E ) ;
2250 data = XGINew_GetReg1( pVBInfo->P3c4 , 0x09 ) ;
2251 data &= 0xC0 ;
2252 XGINew_SetReg1( pVBInfo->P3c4 , 0x09 , data | 0x20 ) ;
2253 }
2254 else
2255 {
2256 XGINew_SetReg1( pVBInfo->P3c4 , 0x08 , 0xAE ) ;
2257 data = XGINew_GetReg1( pVBInfo->P3c4 , 0x09 ) ;
2258 data &= 0xF0 ;
2259 XGINew_SetReg1( pVBInfo->P3c4 , 0x09 , data ) ;
2260 }
2261 }
2262
2263 if (HwDeviceExtension->jChipType == XG21)
2264 {
2265 XGI_SetXG21FPBits(pVBInfo); /* Fix SR9[7:6] can't read back */
2266 }
2267}
2268
2269
2270/* --------------------------------------------------------------------- */
2271/* Function : XGI_SetCRT1ModeRegs */
2272/* Input : */
2273/* Output : */
2274/* Description : */
2275/* --------------------------------------------------------------------- */
2276void XGI_SetCRT1ModeRegs( PXGI_HW_DEVICE_INFO HwDeviceExtension ,
2277 USHORT ModeNo , USHORT ModeIdIndex , USHORT RefreshRateTableIndex,PVB_DEVICE_INFO pVBInfo )
2278{
2279 USHORT data ,
2280 data2 ,
2281 data3 ,
2282 infoflag = 0 ,
2283 modeflag ,
2284 resindex ,
2285 xres ;
2286
2287 if ( ModeNo > 0x13 )
2288 {
2289 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag ;
2290 infoflag = pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_InfoFlag ;
2291 }
2292 else
2293 modeflag = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag ; /* si+St_ModeFlag */
2294
2295 if ( XGINew_GetReg1( pVBInfo->P3d4 , 0x31 ) & 0x01 )
2296 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x1F , 0x3F , 0x00 ) ;
2297
2298 if ( ModeNo > 0x13 )
2299 data = infoflag ;
2300 else
2301 data = 0 ;
2302
2303 data2 = 0 ;
2304
2305 if ( ModeNo > 0x13 )
2306 {
2307 if ( pVBInfo->ModeType > 0x02 )
2308 {
2309 data2 |= 0x02 ;
2310 data3 = pVBInfo->ModeType - ModeVGA ;
2311 data3 = data3 << 2 ;
2312 data2 |= data3 ;
2313 }
2314 }
2315
2316 data &= InterlaceMode ;
2317
2318 if ( data )
2319 data2 |= 0x20 ;
2320
2321 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x06 , ~0x3F , data2 ) ;
2322 /* XGINew_SetReg1(pVBInfo->P3c4,0x06,data2); */
2323 resindex = XGI_GetResInfo( ModeNo , ModeIdIndex, pVBInfo ) ;
2324 if ( ModeNo <= 0x13 )
2325 xres = pVBInfo->StResInfo[ resindex ].HTotal ;
2326 else
2327 xres = pVBInfo->ModeResInfo[ resindex ].HTotal ; /* xres->ax */
2328
2329 data = 0x0000 ;
2330 if ( infoflag & InterlaceMode )
2331 {
2332 if ( xres == 1024 )
2333 data = 0x0035 ;
2334 else if ( xres == 1280 )
2335 data = 0x0048 ;
2336 }
2337
2338 data2 = data & 0x00FF ;
2339 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x19 , 0xFF , data2 ) ;
2340 data2 = ( data & 0xFF00 ) >> 8 ;
2341 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x19 , 0xFC , data2 ) ;
2342
2343 if( modeflag & HalfDCLK )
2344 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x01 , 0xF7 , 0x08 ) ;
2345
2346 data2 = 0 ;
2347
2348 if ( modeflag & LineCompareOff )
2349 data2 |= 0x08 ;
2350
2351 if ( ModeNo > 0x13 )
2352 {
2353 if ( pVBInfo->ModeType == ModeEGA )
2354 data2 |= 0x40 ;
2355 }
2356
2357 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x0F , ~0x48 , data2 ) ;
2358 data = 0x60 ;
2359 if ( pVBInfo->ModeType != ModeText )
2360 {
2361 data = data ^ 0x60 ;
2362 if ( pVBInfo->ModeType != ModeEGA )
2363 {
2364 data = data ^ 0xA0 ;
2365 }
2366 }
2367 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x21 , 0x1F , data ) ;
2368
2369 XGI_SetVCLKState( HwDeviceExtension , ModeNo , RefreshRateTableIndex, pVBInfo) ;
2370
2371 /* if(modeflag&HalfDCLK)//030305 fix lowresolution bug */
2372 /* if(XGINew_IF_DEF_NEW_LOWRES) */
2373 /* XGI_VesaLowResolution(ModeNo,ModeIdIndex);//030305 fix lowresolution bug */
2374
2375 data=XGINew_GetReg1( pVBInfo->P3d4 , 0x31 ) ;
2376
2377 if (HwDeviceExtension->jChipType == XG27 )
2378 {
2379 if ( data & 0x40 )
2380 data = 0x2c ;
2381 else
2382 data = 0x6c ;
2383 XGINew_SetReg1( pVBInfo->P3d4 , 0x52 , data ) ;
2384 XGINew_SetRegOR( pVBInfo->P3d4 , 0x51 , 0x10 ) ;
2385 }
2386 else
2387 if (HwDeviceExtension->jChipType >= XG20 )
2388 {
2389 if ( data & 0x40 )
2390 data = 0x33 ;
2391 else
2392 data = 0x73 ;
2393 XGINew_SetReg1( pVBInfo->P3d4 , 0x52 , data ) ;
2394 XGINew_SetReg1( pVBInfo->P3d4 , 0x51 , 0x02 ) ;
2395 }
2396 else
2397 {
2398 if ( data & 0x40 )
2399 data = 0x2c ;
2400 else
2401 data = 0x6c ;
2402 XGINew_SetReg1( pVBInfo->P3d4 , 0x52 , data ) ;
2403 }
2404
2405}
2406
2407
2408/* --------------------------------------------------------------------- */
2409/* Function : XGI_SetVCLKState */
2410/* Input : */
2411/* Output : */
2412/* Description : */
2413/* --------------------------------------------------------------------- */
2414void XGI_SetVCLKState( PXGI_HW_DEVICE_INFO HwDeviceExtension , USHORT ModeNo , USHORT RefreshRateTableIndex,PVB_DEVICE_INFO pVBInfo )
2415{
2416 USHORT data ,
2417 data2 = 0 ;
2418 SHORT VCLK ;
2419
2420 UCHAR index ;
2421
2422 if ( ModeNo <= 0x13 )
2423 VCLK = 0 ;
2424 else
2425 {
2426 index = pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_CRTVCLK ;
2427 index &= IndexMask ;
2428 VCLK = pVBInfo->VCLKData[ index ].CLOCK ;
2429 }
2430
2431 data = XGINew_GetReg1( pVBInfo->P3c4 , 0x32 ) ;
2432 data &= 0xf3 ;
2433 if ( VCLK >= 200 )
2434 data |= 0x0c ; /* VCLK > 200 */
2435
2436 if ( HwDeviceExtension->jChipType >= XG20 )
2437 data &= ~0x04 ; /* 2 pixel mode */
2438
2439 XGINew_SetReg1( pVBInfo->P3c4 , 0x32 , data ) ;
2440
2441 if ( HwDeviceExtension->jChipType < XG20 )
2442 {
2443 data = XGINew_GetReg1( pVBInfo->P3c4 , 0x1F ) ;
2444 data &= 0xE7 ;
2445 if ( VCLK < 200 )
2446 data |= 0x10 ;
2447 XGINew_SetReg1( pVBInfo->P3c4 , 0x1F , data ) ;
2448 }
2449
2450/* Jong for Adavantech LCD ripple issue
2451 if ( ( VCLK >= 0 ) && ( VCLK < 135 ) )
2452 data2 = 0x03 ;
2453 else if ( ( VCLK >= 135 ) && ( VCLK < 160 ) )
2454 data2 = 0x02 ;
2455 else if ( ( VCLK >= 160 ) && ( VCLK < 260 ) )
2456 data2 = 0x01 ;
2457 else if ( VCLK > 260 )
2458 data2 = 0x00 ;
2459*/
2460 data2 = 0x00 ;
2461
2462 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x07 , 0xFC , data2 ) ;
2463 if (HwDeviceExtension->jChipType >= XG27 )
2464 {
2465 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x40 , 0xFC , data2&0x03 ) ;
2466 }
2467
2468
2469}
2470
2471
2472/* --------------------------------------------------------------------- */
2473/* Function : XGI_VesaLowResolution */
2474/* Input : */
2475/* Output : */
2476/* Description : */
2477/* --------------------------------------------------------------------- */
2478/*void XGI_VesaLowResolution( USHORT ModeNo , USHORT ModeIdIndex ,PVB_DEVICE_INFO pVBInfo)
2479{
2480 USHORT modeflag;
2481
2482 if ( ModeNo > 0x13 )
2483 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag ;
2484 else
2485 modeflag = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag ;
2486
2487 if ( ModeNo > 0x13 )
2488 {
2489 if ( modeflag & DoubleScanMode )
2490 {
2491 if ( modeflag & HalfDCLK )
2492 {
2493 if ( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
2494 {
2495 if ( !( pVBInfo->VBInfo & SetCRT2ToRAMDAC ) )
2496 {
2497 if ( pVBInfo->VBInfo & SetInSlaveMode )
2498 {
2499 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x01 , 0xf7 , 0x00 ) ;
2500 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x0f , 0x7f , 0x00 ) ;
2501 return ;
2502 }
2503 }
2504 }
2505 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x0f , 0xff , 0x80 ) ;
2506 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x01 , 0xf7 , 0x00 ) ;
2507 return ;
2508 }
2509 }
2510 }
2511 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x0f , 0x7f , 0x00 ) ;
2512}
2513*/
2514
2515/* --------------------------------------------------------------------- */
2516/* Function : XGI_LoadDAC */
2517/* Input : */
2518/* Output : */
2519/* Description : */
2520/* --------------------------------------------------------------------- */
2521void XGI_LoadDAC( USHORT ModeNo , USHORT ModeIdIndex,PVB_DEVICE_INFO pVBInfo )
2522{
2523 USHORT data , data2 , time ,
2524 i , j , k , m , n , o ,
2525 si , di , bx , dl , al , ah , dh ,
2526 *table = NULL ;
2527
2528 if ( ModeNo <= 0x13 )
2529 data = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag ;
2530 else
2531 data = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag ;
2532
2533 data &= DACInfoFlag ;
2534 time = 64 ;
2535
2536 if ( data == 0x00 )
2537 table = XGINew_MDA_DAC ;
2538 else if ( data == 0x08 )
2539 table = XGINew_CGA_DAC ;
2540 else if ( data == 0x10 )
2541 table = XGINew_EGA_DAC ;
2542 else if ( data == 0x18 )
2543 {
2544 time = 256 ;
2545 table = XGINew_VGA_DAC ;
2546 }
2547
2548 if ( time == 256 )
2549 j = 16 ;
2550 else
2551 j = time ;
2552
2553 XGINew_SetReg3( pVBInfo->P3c6 , 0xFF ) ;
2554 XGINew_SetReg3( pVBInfo->P3c8 , 0x00 ) ;
2555
2556 for( i = 0 ; i < j ; i++ )
2557 {
2558 data = table[ i ] ;
2559
2560 for( k = 0 ; k < 3 ; k++ )
2561 {
2562 data2 = 0 ;
2563
2564 if ( data & 0x01 )
2565 data2 = 0x2A ;
2566
2567 if ( data & 0x02 )
2568 data2 += 0x15 ;
2569
2570 XGINew_SetReg3( pVBInfo->P3c9 , data2 ) ;
2571 data = data >> 2 ;
2572 }
2573 }
2574
2575 if ( time == 256 )
2576 {
2577 for( i = 16 ; i < 32 ; i++ )
2578 {
2579 data = table[ i ] ;
2580
2581 for( k = 0 ; k < 3 ; k++ )
2582 XGINew_SetReg3( pVBInfo->P3c9 , data ) ;
2583 }
2584
2585 si = 32 ;
2586
2587 for( m = 0 ; m < 9 ; m++ )
2588 {
2589 di = si ;
2590 bx = si + 0x04 ;
2591 dl = 0 ;
2592
2593 for( n = 0 ; n < 3 ; n++ )
2594 {
2595 for( o = 0 ; o < 5 ; o++ )
2596 {
2597 dh = table[ si ] ;
2598 ah = table[ di ] ;
2599 al = table[ bx ] ;
2600 si++ ;
2601 XGI_WriteDAC( dl , ah , al , dh, pVBInfo ) ;
2602 }
2603
2604 si -= 2 ;
2605
2606 for( o = 0 ; o < 3 ; o++ )
2607 {
2608 dh = table[ bx ] ;
2609 ah = table[ di ] ;
2610 al = table[ si ] ;
2611 si-- ;
2612 XGI_WriteDAC( dl , ah , al , dh, pVBInfo ) ;
2613 }
2614
2615 dl++ ;
2616 }
2617
2618 si += 5 ;
2619 }
2620 }
2621}
2622
2623
2624/* --------------------------------------------------------------------- */
2625/* Function : XGI_WriteDAC */
2626/* Input : */
2627/* Output : */
2628/* Description : */
2629/* --------------------------------------------------------------------- */
2630void XGI_WriteDAC( USHORT dl , USHORT ah , USHORT al , USHORT dh,PVB_DEVICE_INFO pVBInfo )
2631{
2632 USHORT temp , bh , bl ;
2633
2634 bh = ah ;
2635 bl = al ;
2636
2637 if ( dl != 0 )
2638 {
2639 temp = bh ;
2640 bh = dh ;
2641 dh = temp ;
2642 if ( dl == 1 )
2643 {
2644 temp = bl ;
2645 bl = dh ;
2646 dh = temp ;
2647 }
2648 else
2649 {
2650 temp = bl ;
2651 bl = bh ;
2652 bh = temp ;
2653 }
2654 }
2655 XGINew_SetReg3( pVBInfo->P3c9 , ( USHORT )dh ) ;
2656 XGINew_SetReg3( pVBInfo->P3c9 , ( USHORT )bh ) ;
2657 XGINew_SetReg3( pVBInfo->P3c9 , ( USHORT )bl ) ;
2658}
2659
2660#if 0
2661/* --------------------------------------------------------------------- */
2662/* Function : XGI_ClearBuffer */
2663/* Input : */
2664/* Output : */
2665/* Description : */
2666/* --------------------------------------------------------------------- */
2667void XGI_ClearBuffer( PXGI_HW_DEVICE_INFO HwDeviceExtension , USHORT ModeNo, PVB_DEVICE_INFO pVBInfo)
2668{
2669 PVOID VideoMemoryAddress = ( PVOID )HwDeviceExtension->pjVideoMemoryAddress ;
2670 ULONG AdapterMemorySize = ( ULONG )HwDeviceExtension->ulVideoMemorySize ;
2671 PUSHORT pBuffer ;
2672#ifndef LINUX_XF86
2673 int i ;
2674#endif
2675
2676 if ( pVBInfo->ModeType >= ModeEGA )
2677 {
2678 if ( ModeNo > 0x13 )
2679 {
2680 AdapterMemorySize = 0x40000 ; /* clear 256k */
2681 /* GetDRAMSize( HwDeviceExtension ) ; */
2682 XGI_SetMemory( VideoMemoryAddress , AdapterMemorySize , 0 ) ;
2683 }
2684 else
2685 {
2686/*
2687 pBuffer = VideoMemoryAddress ;
2688 for( i = 0 ; i < 0x4000 ; i++ )
2689 pBuffer[ i ] = 0x0000 ;
2690*/
2691 }
2692 }
2693 else
2694 {
2695 pBuffer = VideoMemoryAddress ;
2696 if ( pVBInfo->ModeType < ModeCGA )
2697 {
2698/*
2699 for ( i = 0 ; i < 0x4000 ; i++ )
2700 pBuffer[ i ] = 0x0720 ;
2701*/
2702 }
2703 else
2704 XGI_SetMemory( VideoMemoryAddress , 0x8000 , 0 ) ;
2705 }
2706}
2707
2708#endif
2709/* --------------------------------------------------------------------- */
2710/* Function : XGI_SetLCDAGroup */
2711/* Input : */
2712/* Output : */
2713/* Description : */
2714/* --------------------------------------------------------------------- */
2715void XGI_SetLCDAGroup( USHORT ModeNo , USHORT ModeIdIndex , PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo )
2716{
2717 USHORT RefreshRateTableIndex ;
2718 /* USHORT temp ; */
2719
2720 /* pVBInfo->SelectCRT2Rate = 0 ; */
2721
2722 pVBInfo->SetFlag |= ProgrammingCRT2 ;
2723 RefreshRateTableIndex = XGI_GetRatePtrCRT2( HwDeviceExtension, ModeNo , ModeIdIndex, pVBInfo ) ;
2724 XGI_GetLVDSResInfo( ModeNo , ModeIdIndex, pVBInfo ) ;
2725 XGI_GetLVDSData( ModeNo , ModeIdIndex , RefreshRateTableIndex, pVBInfo);
2726 XGI_ModCRT1Regs( ModeNo , ModeIdIndex , RefreshRateTableIndex , HwDeviceExtension, pVBInfo ) ;
2727 XGI_SetLVDSRegs( ModeNo , ModeIdIndex , RefreshRateTableIndex, pVBInfo ) ;
2728 XGI_SetCRT2ECLK( ModeNo , ModeIdIndex , RefreshRateTableIndex, pVBInfo ) ;
2729}
2730
2731
2732/* --------------------------------------------------------------------- */
2733/* Function : XGI_GetLVDSResInfo */
2734/* Input : */
2735/* Output : */
2736/* Description : */
2737/* --------------------------------------------------------------------- */
2738void XGI_GetLVDSResInfo( USHORT ModeNo , USHORT ModeIdIndex,PVB_DEVICE_INFO pVBInfo )
2739{
2740 USHORT resindex , xres , yres , modeflag ;
2741
2742 if ( ModeNo <= 0x13 )
2743 {
2744 modeflag = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ResInfo ; /* si+St_ResInfo */
2745 }
2746 else
2747 {
2748 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_RESINFO ; /* si+Ext_ResInfo */
2749 }
2750
2751
2752 /* if ( ModeNo > 0x13 ) */
2753 /* modeflag = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag ; */
2754 /* else */
2755 /* modeflag = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag ; */
2756
2757 if ( ModeNo <= 0x13 )
2758 {
2759 resindex = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ResInfo ; /* si+St_ResInfo */
2760 }
2761 else
2762 {
2763 resindex = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_RESINFO ; /* si+Ext_ResInfo */
2764 }
2765
2766 /* resindex = XGI_GetResInfo( ModeNo , ModeIdIndex, pVBInfo ) ; */
2767
2768 if ( ModeNo <= 0x13 )
2769 {
2770 xres = pVBInfo->StResInfo[ resindex ].HTotal ;
2771 yres = pVBInfo->StResInfo[ resindex ].VTotal ;
2772 }
2773 else
2774 {
2775 xres = pVBInfo->ModeResInfo[ resindex ].HTotal ;
2776 yres = pVBInfo->ModeResInfo[ resindex ].VTotal ;
2777 }
2778 if ( ModeNo > 0x13 )
2779 {
2780 if ( modeflag & HalfDCLK )
2781 xres = xres << 1 ;
2782
2783 if ( modeflag & DoubleScanMode )
2784 yres = yres << 1 ;
2785 }
2786 /* if ( modeflag & Charx8Dot ) */
2787 /* { */
2788
2789 if ( xres == 720 )
2790 xres = 640 ;
2791
2792 /* } */
2793 pVBInfo->VGAHDE = xres ;
2794 pVBInfo->HDE = xres ;
2795 pVBInfo->VGAVDE = yres ;
2796 pVBInfo->VDE = yres ;
2797}
2798
2799
2800/* --------------------------------------------------------------------- */
2801/* Function : XGI_GetLVDSData */
2802/* Input : */
2803/* Output : */
2804/* Description : */
2805/* --------------------------------------------------------------------- */
2806void XGI_GetLVDSData( USHORT ModeNo , USHORT ModeIdIndex , USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo )
2807{
2808 USHORT tempbx ;
2809 XGI330_LVDSDataStruct *LCDPtr = NULL ;
2810 XGI330_CHTVDataStruct *TVPtr = NULL ;
2811
2812 tempbx = 2 ;
2813
2814 if ( pVBInfo->VBInfo & ( SetCRT2ToLCD | SetCRT2ToLCDA ) )
2815 {
2816 LCDPtr = ( XGI330_LVDSDataStruct * )XGI_GetLcdPtr( tempbx, ModeNo , ModeIdIndex , RefreshRateTableIndex, pVBInfo) ;
2817 pVBInfo->VGAHT = LCDPtr->VGAHT ;
2818 pVBInfo->VGAVT = LCDPtr->VGAVT ;
2819 pVBInfo->HT = LCDPtr->LCDHT ;
2820 pVBInfo->VT = LCDPtr->LCDVT ;
2821 }
2822 if ( pVBInfo->IF_DEF_CH7017 == 1 )
2823 {
2824 if ( pVBInfo->VBInfo & SetCRT2ToTV )
2825 {
2826 TVPtr = ( XGI330_CHTVDataStruct * )XGI_GetTVPtr( tempbx , ModeNo , ModeIdIndex , RefreshRateTableIndex, pVBInfo ) ;
2827 pVBInfo->VGAHT = TVPtr->VGAHT ;
2828 pVBInfo->VGAVT = TVPtr->VGAVT ;
2829 pVBInfo->HT = TVPtr->LCDHT ;
2830 pVBInfo->VT = TVPtr->LCDVT ;
2831 }
2832 }
2833
2834 if ( pVBInfo->VBInfo & ( SetCRT2ToLCD | SetCRT2ToLCDA ) )
2835 {
2836 if ( !( pVBInfo->LCDInfo & ( SetLCDtoNonExpanding | EnableScalingLCD ) ) )
2837 {
2838 if ( ( pVBInfo->LCDResInfo == Panel1024x768 ) || ( pVBInfo->LCDResInfo == Panel1024x768x75 ) )
2839 {
2840 pVBInfo->HDE = 1024 ;
2841 pVBInfo->VDE = 768 ;
2842 }
2843 else if ( ( pVBInfo->LCDResInfo == Panel1280x1024 ) || ( pVBInfo->LCDResInfo == Panel1280x1024x75 ) )
2844 {
2845 pVBInfo->HDE = 1280 ;
2846 pVBInfo->VDE = 1024 ;
2847 }
2848 else if ( pVBInfo->LCDResInfo == Panel1400x1050 )
2849 {
2850 pVBInfo->HDE = 1400 ;
2851 pVBInfo->VDE = 1050 ;
2852 }
2853 else
2854 {
2855 pVBInfo->HDE = 1600 ;
2856 pVBInfo->VDE = 1200 ;
2857 }
2858 }
2859 }
2860}
2861
2862
2863/* --------------------------------------------------------------------- */
2864/* Function : XGI_ModCRT1Regs */
2865/* Input : */
2866/* Output : */
2867/* Description : */
2868/* --------------------------------------------------------------------- */
2869void XGI_ModCRT1Regs( USHORT ModeNo , USHORT ModeIdIndex ,
2870 USHORT RefreshRateTableIndex , PXGI_HW_DEVICE_INFO HwDeviceExtension,PVB_DEVICE_INFO pVBInfo )
2871{
2872 UCHAR index ;
2873 USHORT tempbx , i ;
2874 XGI_LVDSCRT1HDataStruct *LCDPtr = NULL ;
2875 XGI_LVDSCRT1VDataStruct *LCDPtr1 =NULL ;
2876 /* XGI330_CHTVDataStruct *TVPtr = NULL ; */
2877 XGI_CH7007TV_TimingHStruct *CH7007TV_TimingHPtr = NULL;
2878 XGI_CH7007TV_TimingVStruct *CH7007TV_TimingVPtr = NULL;
2879
2880 if( ModeNo <= 0x13 )
2881 index = pVBInfo->SModeIDTable[ ModeIdIndex ].St_CRT2CRTC ;
2882 else
2883 index = pVBInfo->RefIndex[RefreshRateTableIndex].Ext_CRT2CRTC;
2884
2885 index= index & IndexMask ;
2886
2887 if ( ( pVBInfo->IF_DEF_ScaleLCD == 0 ) || ( ( pVBInfo->IF_DEF_ScaleLCD == 1 ) && ( !( pVBInfo->LCDInfo & EnableScalingLCD ) ) ) )
2888 {
2889 tempbx = 0 ;
2890
2891 if ( pVBInfo->VBInfo & ( SetCRT2ToLCD | SetCRT2ToLCDA ) )
2892 {
2893 LCDPtr = ( XGI_LVDSCRT1HDataStruct * )XGI_GetLcdPtr( tempbx , ModeNo , ModeIdIndex , RefreshRateTableIndex, pVBInfo ) ;
2894
2895 for( i = 0 ; i < 8 ; i++ )
2896 pVBInfo->TimingH[ 0 ].data[ i ] = LCDPtr[ 0 ].Reg[ i ] ;
2897 }
2898
2899 if ( pVBInfo->IF_DEF_CH7007 == 1 )
2900 {
2901 if ( pVBInfo->VBInfo & SetCRT2ToTV )
2902 {
2903 CH7007TV_TimingHPtr = ( XGI_CH7007TV_TimingHStruct *)XGI_GetTVPtr( tempbx , ModeNo , ModeIdIndex , RefreshRateTableIndex, pVBInfo ) ;
2904
2905 for( i = 0 ; i < 8 ; i++ )
2906 pVBInfo->TimingH[ 0 ].data[ i ] = CH7007TV_TimingHPtr[ 0 ].data[ i ] ;
2907 }
2908 }
2909
2910 /* if ( pVBInfo->IF_DEF_CH7017 == 1 )
2911 {
2912 if ( pVBInfo->VBInfo & SetCRT2ToTV )
2913 TVPtr = ( XGI330_CHTVDataStruct *)XGI_GetTVPtr( tempbx , ModeNo , ModeIdIndex , RefreshRateTableIndex, pVBInfo ) ;
2914 } */
2915
2916 XGI_SetCRT1Timing_H(pVBInfo,HwDeviceExtension) ;
2917
2918 if ( pVBInfo->IF_DEF_CH7007 == 1 )
2919 {
2920 XGINew_SetReg1( pVBInfo->P3c4 , 0x2E , CH7007TV_TimingHPtr[ 0 ].data[ 8 ] ) ;
2921 XGINew_SetReg1( pVBInfo->P3c4 , 0x2F , CH7007TV_TimingHPtr[ 0 ].data[ 9 ] ) ;
2922 }
2923
2924 tempbx = 1 ;
2925
2926 if ( pVBInfo->VBInfo & ( SetCRT2ToLCD | SetCRT2ToLCDA ) )
2927 {
2928 LCDPtr1 = ( XGI_LVDSCRT1VDataStruct * )XGI_GetLcdPtr( tempbx , ModeNo , ModeIdIndex , RefreshRateTableIndex, pVBInfo ) ;
2929 for( i = 0 ; i < 7 ; i++ )
2930 pVBInfo->TimingV[ 0 ].data[ i ] = LCDPtr1[ 0 ].Reg[ i ] ;
2931 }
2932
2933 if ( pVBInfo->IF_DEF_CH7007 == 1 )
2934 {
2935 if ( pVBInfo->VBInfo & SetCRT2ToTV )
2936 {
2937 CH7007TV_TimingVPtr = ( XGI_CH7007TV_TimingVStruct *)XGI_GetTVPtr( tempbx , ModeNo , ModeIdIndex , RefreshRateTableIndex, pVBInfo ) ;
2938
2939 for( i = 0 ; i < 7 ; i++ )
2940 pVBInfo->TimingV[ 0 ].data[ i ] = CH7007TV_TimingVPtr[ 0 ].data[ i ] ;
2941 }
2942 }
2943 /* if ( pVBInfo->IF_DEF_CH7017 == 1 )
2944 {
2945 if ( pVBInfo->VBInfo & SetCRT2ToTV )
2946 TVPtr = ( XGI330_CHTVDataStruct *)XGI_GetTVPtr( tempbx , ModeNo , ModeIdIndex , RefreshRateTableIndex, pVBInfo ) ;
2947 } */
2948
2949 XGI_SetCRT1Timing_V( ModeIdIndex , ModeNo , pVBInfo) ;
2950
2951 if ( pVBInfo->IF_DEF_CH7007 == 1 )
2952 {
2953 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x33 , ~0x01 , CH7007TV_TimingVPtr[ 0 ].data[ 7 ]&0x01 ) ;
2954 XGINew_SetReg1( pVBInfo->P3c4 , 0x34 , CH7007TV_TimingVPtr[ 0 ].data[8 ] ) ;
2955 XGINew_SetReg1( pVBInfo->P3c4 , 0x3F , CH7007TV_TimingVPtr[ 0 ].data[9 ] ) ;
2956
2957 }
2958 }
2959}
2960
2961
2962
2963/* --------------------------------------------------------------------- */
2964/* Function : XGI_SetLVDSRegs */
2965/* Input : */
2966/* Output : */
2967/* Description : */
2968/* --------------------------------------------------------------------- */
2969void XGI_SetLVDSRegs( USHORT ModeNo , USHORT ModeIdIndex , USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo )
2970{
2971 USHORT tempbx , tempax , tempcx , tempdx , push1 , push2 , modeflag ;
2972 unsigned long temp , temp1 , temp2 , temp3 , push3 ;
2973 XGI330_LCDDataDesStruct *LCDPtr = NULL ;
2974 XGI330_LCDDataDesStruct2 *LCDPtr1 = NULL ;
2975
2976 if ( ModeNo > 0x13 )
2977 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag ;
2978 else
2979 modeflag = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag ;
2980
2981 if ( !( pVBInfo->SetFlag & Win9xDOSMode ) )
2982 {
2983 if ( ( pVBInfo->IF_DEF_CH7017 == 0 ) || ( pVBInfo->VBInfo & ( SetCRT2ToLCD | SetCRT2ToLCDA ) ) )
2984 {
2985 if ( pVBInfo->IF_DEF_OEMUtil == 1 )
2986 {
2987 tempbx = 8 ;
2988 LCDPtr = ( XGI330_LCDDataDesStruct * )XGI_GetLcdPtr( tempbx , ModeNo , ModeIdIndex , RefreshRateTableIndex, pVBInfo ) ;
2989 }
2990
2991 if ( ( pVBInfo->IF_DEF_OEMUtil == 0 ) || ( LCDPtr == 0 ) )
2992 {
2993 tempbx = 3 ;
2994 if ( pVBInfo->LCDInfo & EnableScalingLCD )
2995 LCDPtr1 = ( XGI330_LCDDataDesStruct2 * )XGI_GetLcdPtr( tempbx , ModeNo , ModeIdIndex , RefreshRateTableIndex, pVBInfo ) ;
2996 else
2997 LCDPtr = ( XGI330_LCDDataDesStruct * )XGI_GetLcdPtr( tempbx , ModeNo , ModeIdIndex , RefreshRateTableIndex, pVBInfo ) ;
2998 }
2999
3000 XGI_GetLCDSync( &tempax , &tempbx ,pVBInfo) ;
3001 push1 = tempbx ;
3002 push2 = tempax ;
3003
3004 /* GetLCDResInfo */
3005 if ( ( pVBInfo->LCDResInfo == Panel1024x768 ) || ( pVBInfo->LCDResInfo == Panel1024x768x75 ) )
3006 {
3007 tempax = 1024 ;
3008 tempbx = 768 ;
3009 }
3010 else if ( ( pVBInfo->LCDResInfo == Panel1280x1024 ) || ( pVBInfo->LCDResInfo == Panel1280x1024x75 ) )
3011 {
3012 tempax = 1280 ;
3013 tempbx = 1024 ;
3014 }
3015 else if ( pVBInfo->LCDResInfo == Panel1400x1050 )
3016 {
3017 tempax = 1400 ;
3018 tempbx = 1050 ;
3019 }
3020 else
3021 {
3022 tempax = 1600 ;
3023 tempbx = 1200 ;
3024 }
3025
3026 if ( pVBInfo->LCDInfo & SetLCDtoNonExpanding )
3027 {
3028 pVBInfo->HDE=tempax;
3029 pVBInfo->VDE=tempbx;
3030 pVBInfo->VGAHDE=tempax;
3031 pVBInfo->VGAVDE=tempbx;
3032 }
3033
3034 if ( ( pVBInfo->IF_DEF_ScaleLCD == 1 ) && ( pVBInfo->LCDInfo & EnableScalingLCD ) )
3035 {
3036 tempax=pVBInfo->HDE;
3037 tempbx=pVBInfo->VDE;
3038 }
3039
3040 tempax = pVBInfo->HT ;
3041
3042 if ( pVBInfo->LCDInfo & EnableScalingLCD )
3043 tempbx = LCDPtr1->LCDHDES ;
3044 else
3045 tempbx = LCDPtr->LCDHDES ;
3046
3047 tempcx = pVBInfo->HDE ;
3048 tempbx = tempbx & 0x0fff ;
3049 tempcx += tempbx ;
3050
3051 if ( tempcx >= tempax )
3052 tempcx -= tempax ;
3053
3054 XGINew_SetReg1( pVBInfo->Part1Port , 0x1A , tempbx & 0x07 ) ;
3055
3056 tempcx = tempcx >> 3 ;
3057 tempbx = tempbx >> 3 ;
3058
3059 XGINew_SetReg1( pVBInfo->Part1Port , 0x16 , ( USHORT )( tempbx & 0xff ) ) ;
3060 XGINew_SetReg1( pVBInfo->Part1Port , 0x17 , ( USHORT )( tempcx & 0xff ) ) ;
3061
3062 tempax = pVBInfo->HT ;
3063
3064 if ( pVBInfo->LCDInfo & EnableScalingLCD )
3065 tempbx = LCDPtr1->LCDHRS ;
3066 else
3067 tempbx = LCDPtr->LCDHRS ;
3068
3069 tempcx = push2 ;
3070
3071 if ( pVBInfo->LCDInfo & EnableScalingLCD )
3072 tempcx = LCDPtr1->LCDHSync ;
3073
3074 tempcx += tempbx ;
3075
3076 if ( tempcx >= tempax )
3077 tempcx -= tempax ;
3078
3079 tempax = tempbx & 0x07 ;
3080 tempax = tempax >> 5 ;
3081 tempcx = tempcx >> 3 ;
3082 tempbx = tempbx >> 3 ;
3083
3084 tempcx &= 0x1f ;
3085 tempax |= tempcx ;
3086
3087 XGINew_SetReg1( pVBInfo->Part1Port , 0x15 , tempax ) ;
3088 XGINew_SetReg1( pVBInfo->Part1Port , 0x14 , ( USHORT )( tempbx & 0xff ) ) ;
3089
3090 tempax = pVBInfo->VT ;
3091 if ( pVBInfo->LCDInfo & EnableScalingLCD )
3092 tempbx = LCDPtr1->LCDVDES ;
3093 else
3094 tempbx = LCDPtr->LCDVDES ;
3095 tempcx = pVBInfo->VDE ;
3096
3097 tempbx = tempbx & 0x0fff ;
3098 tempcx += tempbx ;
3099 if ( tempcx >= tempax )
3100 tempcx -= tempax ;
3101
3102 XGINew_SetReg1( pVBInfo->Part1Port , 0x1b , ( USHORT )( tempbx & 0xff ) ) ;
3103 XGINew_SetReg1( pVBInfo->Part1Port , 0x1c , ( USHORT )( tempcx & 0xff ) ) ;
3104
3105 tempbx = ( tempbx >> 8 ) & 0x07 ;
3106 tempcx = ( tempcx >> 8 ) & 0x07 ;
3107
3108 XGINew_SetReg1( pVBInfo->Part1Port , 0x1d , ( USHORT )( ( tempcx << 3 ) | tempbx ) ) ;
3109
3110 tempax = pVBInfo->VT ;
3111 if ( pVBInfo->LCDInfo & EnableScalingLCD )
3112 tempbx = LCDPtr1->LCDVRS ;
3113 else
3114 tempbx = LCDPtr->LCDVRS ;
3115
3116 /* tempbx = tempbx >> 4 ; */
3117 tempcx = push1 ;
3118
3119 if ( pVBInfo->LCDInfo & EnableScalingLCD )
3120 tempcx = LCDPtr1->LCDVSync ;
3121
3122 tempcx += tempbx ;
3123 if ( tempcx >= tempax )
3124 tempcx -= tempax ;
3125
3126 XGINew_SetReg1( pVBInfo->Part1Port , 0x18 , ( USHORT )( tempbx & 0xff ) ) ;
3127 XGINew_SetRegANDOR( pVBInfo->Part1Port , 0x19 , ~0x0f , ( USHORT )( tempcx & 0x0f ) ) ;
3128
3129 tempax = ( ( tempbx >> 8 ) & 0x07 ) << 3 ;
3130
3131 tempbx = pVBInfo->VGAVDE ;
3132 if ( tempbx != pVBInfo->VDE )
3133 tempax |= 0x40 ;
3134
3135 if ( pVBInfo->LCDInfo & EnableLVDSDDA )
3136 tempax |= 0x40 ;
3137
3138 XGINew_SetRegANDOR( pVBInfo->Part1Port , 0x1a , 0x07 , tempax ) ;
3139
3140 tempcx = pVBInfo->VGAVT ;
3141 tempbx = pVBInfo->VDE ;
3142 tempax = pVBInfo->VGAVDE ;
3143 tempcx -= tempax ;
3144
3145 temp = tempax ; /* 0430 ylshieh */
3146 temp1 = ( temp << 18 ) / tempbx ;
3147
3148 tempdx = ( USHORT )( ( temp << 18 ) % tempbx ) ;
3149
3150 if ( tempdx != 0 )
3151 temp1 += 1 ;
3152
3153 temp2 = temp1 ;
3154 push3 = temp2 ;
3155
3156 XGINew_SetReg1( pVBInfo->Part1Port , 0x37 , ( USHORT )( temp2 & 0xff ) ) ;
3157 XGINew_SetReg1( pVBInfo->Part1Port , 0x36 , ( USHORT )( ( temp2 >> 8 ) & 0xff ) ) ;
3158
3159 tempbx = ( USHORT )( temp2 >> 16 ) ;
3160 tempax = tempbx & 0x03 ;
3161
3162 tempbx = pVBInfo->VGAVDE ;
3163 if ( tempbx == pVBInfo->VDE )
3164 tempax |= 0x04 ;
3165
3166 XGINew_SetReg1( pVBInfo->Part1Port , 0x35 , tempax ) ;
3167
3168 if ( pVBInfo->VBType & VB_XGI301C )
3169 {
3170 temp2 = push3 ;
3171 XGINew_SetReg1( pVBInfo->Part4Port , 0x3c , ( USHORT )( temp2 & 0xff ) ) ;
3172 XGINew_SetReg1( pVBInfo->Part4Port , 0x3b , ( USHORT )( ( temp2 >> 8 ) & 0xff ) ) ;
3173 tempbx = ( USHORT )( temp2 >> 16 ) ;
3174 XGINew_SetRegANDOR( pVBInfo->Part4Port , 0x3a , ~0xc0 , ( USHORT )( ( tempbx & 0xff ) << 6 ) ) ;
3175
3176 tempcx = pVBInfo->VGAVDE ;
3177 if ( tempcx == pVBInfo->VDE )
3178 XGINew_SetRegANDOR( pVBInfo->Part4Port , 0x30 , ~0x0c , 0x00 ) ;
3179 else
3180 XGINew_SetRegANDOR( pVBInfo->Part4Port , 0x30 , ~0x0c , 0x08 ) ;
3181 }
3182
3183 tempcx = pVBInfo->VGAHDE ;
3184 tempbx = pVBInfo->HDE ;
3185
3186 temp1 = tempcx << 16 ;
3187
3188 tempax = ( USHORT )( temp1 / tempbx ) ;
3189
3190 if ( ( tempbx & 0xffff ) == ( tempcx & 0xffff ) )
3191 tempax = 65535 ;
3192
3193 temp3 = tempax ;
3194 temp1 = pVBInfo->VGAHDE << 16 ;
3195
3196 temp1 /= temp3 ;
3197 temp3 = temp3 << 16 ;
3198 temp1 -= 1 ;
3199
3200 temp3 = ( temp3 & 0xffff0000 ) + ( temp1 & 0xffff ) ;
3201
3202 tempax = ( USHORT )( temp3 & 0xff ) ;
3203 XGINew_SetReg1( pVBInfo->Part1Port , 0x1f , tempax ) ;
3204
3205 temp1 = pVBInfo->VGAVDE << 18 ;
3206 temp1 = temp1 / push3 ;
3207 tempbx = ( USHORT )( temp1 & 0xffff ) ;
3208
3209 if ( pVBInfo->LCDResInfo == Panel1024x768 )
3210 tempbx -= 1 ;
3211
3212 tempax = ( ( tempbx >> 8 ) & 0xff ) << 3 ;
3213 tempax |= ( USHORT )( ( temp3 >> 8 ) & 0x07 ) ;
3214 XGINew_SetReg1( pVBInfo->Part1Port , 0x20 , ( USHORT )( tempax & 0xff ) ) ;
3215 XGINew_SetReg1( pVBInfo->Part1Port , 0x21 , ( USHORT )( tempbx & 0xff ) ) ;
3216
3217 temp3 = temp3 >> 16 ;
3218
3219 if ( modeflag & HalfDCLK )
3220 temp3 = temp3 >> 1 ;
3221
3222 XGINew_SetReg1(pVBInfo->Part1Port , 0x22 , ( USHORT )( ( temp3 >> 8 ) & 0xff ) ) ;
3223 XGINew_SetReg1(pVBInfo->Part1Port , 0x23 , ( USHORT )( temp3 & 0xff ) ) ;
3224 }
3225 }
3226}
3227
3228
3229/* --------------------------------------------------------------------- */
3230/* Function : XGI_SetCRT2ECLK */
3231/* Input : */
3232/* Output : */
3233/* Description : */
3234/* --------------------------------------------------------------------- */
3235void XGI_SetCRT2ECLK( USHORT ModeNo , USHORT ModeIdIndex , USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo )
3236{
3237 UCHAR di_0 , di_1 , tempal ;
3238 int i ;
3239
3240 tempal = XGI_GetVCLKPtr( RefreshRateTableIndex , ModeNo , ModeIdIndex, pVBInfo ) ;
3241 XGI_GetVCLKLen( tempal , &di_0 , &di_1, pVBInfo ) ;
3242 XGI_GetLCDVCLKPtr( &di_0 , &di_1, pVBInfo ) ;
3243
3244 for( i = 0 ; i < 4 ; i++ )
3245 {
3246 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x31 , ~0x30 , ( USHORT )( 0x10 * i ) ) ;
3247 if ( pVBInfo->IF_DEF_CH7007 == 1 )
3248 {
3249 XGINew_SetReg1( pVBInfo->P3c4 , 0x2b , di_0 ) ;
3250 XGINew_SetReg1( pVBInfo->P3c4 , 0x2c , di_1 ) ;
3251 }
3252 else if ( ( !( pVBInfo->VBInfo & SetCRT2ToLCDA ) ) && ( !( pVBInfo->VBInfo & SetInSlaveMode ) ) )
3253 {
3254 XGINew_SetReg1( pVBInfo->P3c4 , 0x2e , di_0 ) ;
3255 XGINew_SetReg1( pVBInfo->P3c4 , 0x2f , di_1 ) ;
3256 }
3257 else
3258 {
3259 XGINew_SetReg1( pVBInfo->P3c4 , 0x2b , di_0 ) ;
3260 XGINew_SetReg1( pVBInfo->P3c4 , 0x2c , di_1 ) ;
3261 }
3262 }
3263}
3264
3265
3266/* --------------------------------------------------------------------- */
3267/* Function : XGI_UpdateModeInfo */
3268/* Input : */
3269/* Output : */
3270/* Description : */
3271/* --------------------------------------------------------------------- */
3272void XGI_UpdateModeInfo( PXGI_HW_DEVICE_INFO HwDeviceExtension,PVB_DEVICE_INFO pVBInfo )
3273{
3274 USHORT tempcl ,
3275 tempch ,
3276 temp ,
3277 tempbl ,
3278 tempax ;
3279
3280 if ( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
3281 {
3282 tempcl = 0 ;
3283 tempch = 0 ;
3284 temp = XGINew_GetReg1( pVBInfo->P3c4 , 0x01 ) ;
3285
3286 if ( !( temp & 0x20 ) )
3287 {
3288 temp = XGINew_GetReg1( pVBInfo->P3d4 , 0x17 ) ;
3289 if ( temp & 0x80 )
3290 {
3291 if ( ( HwDeviceExtension->jChipType >= XG20 ) || ( HwDeviceExtension->jChipType >= XG40 ) )
3292 temp = XGINew_GetReg1( pVBInfo->P3d4 , 0x53 ) ;
3293 else
3294 temp = XGINew_GetReg1( pVBInfo->P3d4 , 0x63 ) ;
3295
3296 if ( !( temp & 0x40 ) )
3297 tempcl |= ActiveCRT1 ;
3298 }
3299 }
3300
3301 temp = XGINew_GetReg1( pVBInfo->Part1Port , 0x2e ) ;
3302 temp &= 0x0f ;
3303
3304 if ( !( temp == 0x08 ) )
3305 {
3306 tempax = XGINew_GetReg1( pVBInfo->Part1Port , 0x13 ) ; /* Check ChannelA by Part1_13 [2003/10/03] */
3307 if ( tempax & 0x04 )
3308 tempcl = tempcl | ActiveLCD ;
3309
3310 temp &= 0x05 ;
3311
3312 if ( !( tempcl & ActiveLCD ) )
3313 if ( temp == 0x01 )
3314 tempcl |= ActiveCRT2 ;
3315
3316 if ( temp == 0x04 )
3317 tempcl |= ActiveLCD ;
3318
3319 if ( temp == 0x05 )
3320 {
3321 temp = XGINew_GetReg1( pVBInfo->Part2Port , 0x00 ) ;
3322
3323 if( !( temp & 0x08 ) )
3324 tempch |= ActiveAVideo ;
3325
3326 if ( !( temp & 0x04 ) )
3327 tempch |= ActiveSVideo ;
3328
3329 if ( temp & 0x02 )
3330 tempch |= ActiveSCART ;
3331
3332 if ( pVBInfo->VBInfo & SetCRT2ToHiVisionTV )
3333 {
3334 if ( temp & 0x01 )
3335 tempch |= ActiveHiTV ;
3336 }
3337
3338 if ( pVBInfo->VBInfo & SetCRT2ToYPbPr )
3339 {
3340 temp = XGINew_GetReg1( pVBInfo->Part2Port , 0x4d ) ;
3341
3342 if ( temp & 0x10 )
3343 tempch |= ActiveYPbPr ;
3344 }
3345
3346 if ( tempch != 0 )
3347 tempcl |= ActiveTV ;
3348 }
3349 }
3350
3351 temp = XGINew_GetReg1( pVBInfo->P3d4 , 0x3d ) ;
3352 if ( tempcl & ActiveLCD )
3353 {
3354 if ( ( pVBInfo->SetFlag & ReserveTVOption ) )
3355 {
3356 if ( temp & ActiveTV )
3357 tempcl |= ActiveTV ;
3358 }
3359 }
3360 temp = tempcl ;
3361 tempbl = ~ModeSwitchStatus ;
3362 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x3d , tempbl , temp ) ;
3363
3364 if ( !( pVBInfo->SetFlag & ReserveTVOption ) )
3365 XGINew_SetReg1( pVBInfo->P3d4 , 0x3e , tempch ) ;
3366 }
3367 else
3368 {
3369 return ;
3370 }
3371}
3372
3373
3374/* --------------------------------------------------------------------- */
3375/* Function : XGI_GetVGAType */
3376/* Input : */
3377/* Output : */
3378/* Description : */
3379/* --------------------------------------------------------------------- */
3380void XGI_GetVGAType( PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo)
3381{
3382 /*
3383 if ( HwDeviceExtension->jChipType >= XG20 )
3384 {
3385 pVBInfo->Set_VGAType = XG20;
3386 }
3387 else if ( HwDeviceExtension->jChipType >= XG40 )
3388 {
3389 pVBInfo->Set_VGAType = VGA_XGI340 ;
3390 }
3391 */
3392 pVBInfo->Set_VGAType = HwDeviceExtension->jChipType;
3393}
3394
3395
3396/* --------------------------------------------------------------------- */
3397/* Function : XGI_GetVBType */
3398/* Input : */
3399/* Output : */
3400/* Description : */
3401/* --------------------------------------------------------------------- */
3402void XGI_GetVBType(PVB_DEVICE_INFO pVBInfo)
3403{
3404 USHORT flag , tempbx , tempah ;
3405
3406 if ( pVBInfo->IF_DEF_CH7007 == 1 )
3407 {
3408 pVBInfo->VBType = VB_CH7007 ;
3409 return;
3410 }
3411 if ( pVBInfo->IF_DEF_LVDS == 0 )
3412 {
3413 tempbx = VB_XGI302B ;
3414 flag = XGINew_GetReg1( pVBInfo->Part4Port , 0x00 ) ;
3415 if ( flag != 0x02 )
3416 {
3417 tempbx = VB_XGI301 ;
3418 flag = XGINew_GetReg1( pVBInfo->Part4Port , 0x01 ) ;
3419 if ( flag >= 0xB0 )
3420 {
3421 tempbx = VB_XGI301B ;
3422 if ( flag >= 0xC0 )
3423 {
3424 tempbx = VB_XGI301C ;
3425 if ( flag >= 0xD0 )
3426 {
3427 tempbx = VB_XGI301LV ;
3428 if ( flag >= 0xE0 )
3429 {
3430 tempbx = VB_XGI302LV ;
3431 tempah = XGINew_GetReg1( pVBInfo->Part4Port , 0x39 ) ;
3432 if ( tempah != 0xFF )
3433 tempbx = VB_XGI301C ;
3434 }
3435 }
3436 }
3437
3438 if ( tempbx & ( VB_XGI301B | VB_XGI302B ) )
3439 {
3440 flag = XGINew_GetReg1( pVBInfo->Part4Port , 0x23 ) ;
3441
3442 if ( !( flag & 0x02 ) )
3443 tempbx = tempbx | VB_NoLCD ;
3444 }
3445 }
3446 }
3447 pVBInfo->VBType = tempbx ;
3448 }
3449/*
3450 else if ( pVBInfo->IF_DEF_CH7017 == 1 )
3451 pVBInfo->VBType = VB_CH7017 ;
3452 else //LVDS
3453 pVBInfo->VBType = VB_LVDS_NS ;
3454*/
3455
3456}
3457
3458
3459/* --------------------------------------------------------------------- */
3460/* Function : XGI_GetVBInfo */
3461/* Input : */
3462/* Output : */
3463/* Description : */
3464/* --------------------------------------------------------------------- */
3465void XGI_GetVBInfo( USHORT ModeNo , USHORT ModeIdIndex , PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo )
3466{
3467 USHORT tempax ,
3468 push ,
3469 tempbx ,
3470 temp ,
3471 modeflag ;
3472
3473 if ( ModeNo <= 0x13 )
3474 {
3475 modeflag = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag ;
3476 }
3477 else
3478 {
3479 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag ;
3480 }
3481
3482 pVBInfo->SetFlag = 0 ;
3483 pVBInfo->ModeType = modeflag & ModeInfoFlag ;
3484 tempbx = 0 ;
3485
3486 if ( pVBInfo->VBType & 0xFFFF )
3487 {
3488 temp = XGINew_GetReg1( pVBInfo->P3d4 , 0x30 ) ; /* Check Display Device */
3489 tempbx = tempbx | temp ;
3490 temp = XGINew_GetReg1( pVBInfo->P3d4 , 0x31 ) ;
3491 push = temp ;
3492 push = push << 8 ;
3493 tempax = temp << 8 ;
3494 tempbx = tempbx | tempax ;
3495 temp = ( SetCRT2ToDualEdge | SetCRT2ToYPbPr | SetCRT2ToLCDA | SetInSlaveMode | DisableCRT2Display ) ;
3496 temp = 0xFFFF ^ temp ;
3497 tempbx &= temp ;
3498
3499 temp = XGINew_GetReg1( pVBInfo->P3d4 , 0x38 ) ;
3500
3501 if ( pVBInfo->IF_DEF_LCDA == 1 )
3502 {
3503
3504 if ( ( pVBInfo->Set_VGAType >= XG20 ) || ( pVBInfo->Set_VGAType >= XG40 ))
3505 {
3506 if ( pVBInfo->IF_DEF_LVDS == 0 )
3507 {
3508 /* if ( ( pVBInfo->VBType & VB_XGI302B ) || ( pVBInfo->VBType & VB_XGI301LV ) || ( pVBInfo->VBType & VB_XGI302LV ) || ( pVBInfo->VBType & VB_XGI301C ) ) */
3509 if ( pVBInfo->VBType & ( VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
3510 {
3511 if ( temp & EnableDualEdge )
3512 {
3513 tempbx |= SetCRT2ToDualEdge ;
3514
3515 if ( temp & SetToLCDA )
3516 tempbx |= SetCRT2ToLCDA ;
3517 }
3518 }
3519 }
3520 else if ( pVBInfo->IF_DEF_CH7017 == 1 )
3521 {
3522 if ( pVBInfo->VBType & VB_CH7017 )
3523 {
3524 if ( temp & EnableDualEdge )
3525 {
3526 tempbx |= SetCRT2ToDualEdge ;
3527
3528 if ( temp & SetToLCDA )
3529 tempbx |= SetCRT2ToLCDA ;
3530 }
3531 }
3532 }
3533 }
3534 }
3535
3536 if ( pVBInfo->IF_DEF_YPbPr == 1 )
3537 {
3538 if ( ( ( pVBInfo->IF_DEF_LVDS == 0 ) && ( ( pVBInfo->VBType & VB_XGI301LV ) || ( pVBInfo->VBType & VB_XGI302LV ) || ( pVBInfo->VBType & VB_XGI301C ) ) )
3539 || ( ( pVBInfo->IF_DEF_CH7017 == 1 ) && ( pVBInfo->VBType&VB_CH7017 ) ) || ( (pVBInfo->IF_DEF_CH7007 == 1) && (pVBInfo->VBType&VB_CH7007) ) ) /* [Billy] 07/05/04 */
3540 {
3541 if ( temp & SetYPbPr ) /* temp = CR38 */
3542 {
3543 if ( pVBInfo->IF_DEF_HiVision == 1 )
3544 {
3545 temp = XGINew_GetReg1( pVBInfo->P3d4 , 0x35 ) ; /* shampoo add for new scratch */
3546 temp &= YPbPrMode ;
3547 tempbx |= SetCRT2ToHiVisionTV ;
3548
3549 if ( temp != YPbPrMode1080i ) {
3550 tempbx &= ( ~SetCRT2ToHiVisionTV ) ;
3551 tempbx |= SetCRT2ToYPbPr ; }
3552 }
3553
3554 /* tempbx |= SetCRT2ToYPbPr ; */
3555 }
3556 }
3557 }
3558
3559 tempax = push ; /* restore CR31 */
3560
3561 if ( pVBInfo->IF_DEF_LVDS == 0 )
3562 {
3563 if ( pVBInfo->IF_DEF_YPbPr == 1 )
3564 {
3565 if ( pVBInfo->IF_DEF_HiVision == 1 )
3566 temp = 0x09FC ;
3567 else
3568 temp = 0x097C ;
3569 }
3570 else
3571 {
3572 if ( pVBInfo->IF_DEF_HiVision == 1 )
3573 temp = 0x01FC ;
3574 else
3575 temp = 0x017C ;
3576 }
3577 }
3578 else /* 3nd party chip */
3579 {
3580 if ( pVBInfo->IF_DEF_CH7017 == 1 )
3581 temp = ( SetCRT2ToTV | SetCRT2ToLCD | SetCRT2ToLCDA ) ;
3582 else if ( pVBInfo->IF_DEF_CH7007 == 1 ) /* [Billy] 07/05/03 */
3583 {
3584 temp = SetCRT2ToTV ;
3585 }
3586 else
3587 temp = SetCRT2ToLCD ;
3588 }
3589
3590 if ( !( tempbx & temp ) )
3591 {
3592 tempax |= DisableCRT2Display ;
3593 tempbx = 0 ;
3594 }
3595
3596 if ( pVBInfo->IF_DEF_LCDA == 1 ) /* Select Display Device */
3597 {
3598 if ( !( pVBInfo->VBType & VB_NoLCD ) )
3599 {
3600 if ( tempbx & SetCRT2ToLCDA )
3601 {
3602 if ( tempbx & SetSimuScanMode )
3603 tempbx &= ( ~( SetCRT2ToLCD | SetCRT2ToRAMDAC | SwitchToCRT2 ) ) ;
3604 else
3605 tempbx &= ( ~( SetCRT2ToLCD | SetCRT2ToRAMDAC | SetCRT2ToTV | SwitchToCRT2 ) ) ;
3606 }
3607 }
3608 }
3609
3610 /* shampoo add */
3611 if ( !( tempbx & ( SwitchToCRT2 | SetSimuScanMode ) ) ) /* for driver abnormal */
3612 {
3613 if ( pVBInfo->IF_DEF_CRT2Monitor == 1 )
3614 {
3615 if ( tempbx & SetCRT2ToRAMDAC )
3616 {
3617 tempbx &= ( 0xFF00 | SetCRT2ToRAMDAC | SwitchToCRT2 | SetSimuScanMode ) ;
3618 tempbx &= ( 0x00FF | ( ~SetCRT2ToYPbPr ) ) ;
3619 }
3620 }
3621 else
3622 tempbx &= ( ~( SetCRT2ToRAMDAC | SetCRT2ToLCD | SetCRT2ToTV ) ) ;
3623 }
3624
3625 if ( !( pVBInfo->VBType & VB_NoLCD ) )
3626 {
3627 if ( tempbx & SetCRT2ToLCD )
3628 {
3629 tempbx &= ( 0xFF00 | SetCRT2ToLCD | SwitchToCRT2 | SetSimuScanMode ) ;
3630 tempbx &= ( 0x00FF | ( ~SetCRT2ToYPbPr ) ) ;
3631 }
3632 }
3633
3634 if ( tempbx & SetCRT2ToSCART )
3635 {
3636 tempbx &= ( 0xFF00 | SetCRT2ToSCART | SwitchToCRT2 | SetSimuScanMode ) ;
3637 tempbx &= ( 0x00FF | ( ~SetCRT2ToYPbPr ) ) ;
3638 }
3639
3640 if ( pVBInfo->IF_DEF_YPbPr == 1 )
3641 {
3642 if ( tempbx & SetCRT2ToYPbPr )
3643 tempbx &= ( 0xFF00 | SwitchToCRT2 | SetSimuScanMode ) ;
3644 }
3645
3646 if ( pVBInfo->IF_DEF_HiVision == 1 )
3647 {
3648 if ( tempbx & SetCRT2ToHiVisionTV )
3649 tempbx &= ( 0xFF00 | SetCRT2ToHiVisionTV | SwitchToCRT2 | SetSimuScanMode ) ;
3650 }
3651
3652 if ( tempax & DisableCRT2Display ) /* Set Display Device Info */
3653 {
3654 if ( !( tempbx & ( SwitchToCRT2 | SetSimuScanMode ) ) )
3655 tempbx = DisableCRT2Display ;
3656 }
3657
3658 if ( !( tempbx & DisableCRT2Display ) )
3659 {
3660 if ( ( !( tempbx & DriverMode ) ) || ( !( modeflag & CRT2Mode ) ) )
3661 {
3662 if ( pVBInfo->IF_DEF_LCDA == 1 )
3663 {
3664 if ( !( tempbx & SetCRT2ToLCDA ) )
3665 tempbx |= ( SetInSlaveMode | SetSimuScanMode ) ;
3666 }
3667
3668 if ( pVBInfo->IF_DEF_VideoCapture == 1 )
3669 {
3670 if ( ( ( HwDeviceExtension->jChipType == XG40 ) && ( pVBInfo->Set_VGAType == XG40 ) )
3671 || ( ( HwDeviceExtension->jChipType == XG41 ) && ( pVBInfo->Set_VGAType == XG41 ) )
3672 || ( ( HwDeviceExtension->jChipType == XG42 ) && ( pVBInfo->Set_VGAType == XG42 ) )
3673 || ( ( HwDeviceExtension->jChipType == XG45 ) && ( pVBInfo->Set_VGAType == XG45 ) ) )
3674 {
3675 if ( ModeNo <= 13 )
3676 {
3677 if ( !( tempbx & SetCRT2ToRAMDAC ) ) /*CRT2 not need to support*/
3678 {
3679 tempbx &= ( 0x00FF | ( ~SetInSlaveMode ) ) ;
3680 pVBInfo->SetFlag |= EnableVCMode ;
3681 }
3682 }
3683 }
3684 }
3685 }
3686
3687 /*LCD+TV can't support in slave mode (Force LCDA+TV->LCDB)*/
3688 if ( ( tempbx & SetInSlaveMode ) && ( tempbx & SetCRT2ToLCDA ) )
3689 {
3690 tempbx ^= ( SetCRT2ToLCD | SetCRT2ToLCDA | SetCRT2ToDualEdge ) ;
3691 pVBInfo->SetFlag |= ReserveTVOption ;
3692 }
3693 }
3694 }
3695
3696 pVBInfo->VBInfo = tempbx ;
3697}
3698
3699
3700/* --------------------------------------------------------------------- */
3701/* Function : XGI_GetTVInfo */
3702/* Input : */
3703/* Output : */
3704/* Description : */
3705/* --------------------------------------------------------------------- */
3706void XGI_GetTVInfo( USHORT ModeNo , USHORT ModeIdIndex ,PVB_DEVICE_INFO pVBInfo )
3707{
3708 USHORT temp ,
3709 tempbx = 0 ,
3710 resinfo = 0 ,
3711 modeflag ,
3712 index1 ;
3713
3714 tempbx = 0 ;
3715 resinfo = 0 ;
3716
3717 if ( pVBInfo->VBInfo & SetCRT2ToTV )
3718 {
3719 if ( ModeNo <= 0x13 )
3720 {
3721 modeflag = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag ; /* si+St_ModeFlag */
3722 resinfo = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ResInfo ; /* si+St_ResInfo */
3723 }
3724 else
3725 {
3726 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag ;
3727 resinfo = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_RESINFO ; /* si+Ext_ResInfo */
3728 }
3729
3730 if ( pVBInfo->VBInfo & SetCRT2ToTV )
3731 {
3732 temp = XGINew_GetReg1( pVBInfo->P3d4 , 0x35 ) ;
3733 tempbx = temp;
3734 if ( tempbx & SetPALTV )
3735 {
3736 tempbx &= ( SetCHTVOverScan | SetPALMTV | SetPALNTV | SetPALTV ) ;
3737 if ( tempbx & SetPALMTV )
3738 tempbx &= ~SetPALTV ; /* set to NTSC if PAL-M */
3739 }
3740 else
3741 tempbx &= ( SetCHTVOverScan | SetNTSCJ | SetPALTV ) ;
3742/*
3743 if ( pVBInfo->IF_DEF_LVDS == 0 )
3744 {
3745 index1 = XGINew_GetReg1( pVBInfo->P3d4 , 0x38 ) ; //PAL-M/PAL-N Info
3746 temp2 = ( index1 & 0xC0 ) >> 5 ; //00:PAL, 01:PAL-M, 10:PAL-N
3747 tempbx |= temp2 ;
3748 if ( temp2 & 0x02 ) //PAL-M
3749 tempbx &= ( ~SetPALTV ) ;
3750 }
3751*/
3752 }
3753
3754 if ( pVBInfo->IF_DEF_CH7017 == 1 )
3755 {
3756 tempbx = XGINew_GetReg1( pVBInfo->P3d4 , 0x35 ) ;
3757
3758 if ( tempbx & TVOverScan )
3759 tempbx |= SetCHTVOverScan ;
3760 }
3761
3762 if ( pVBInfo->IF_DEF_CH7007 == 1 ) /* [Billy] 07/05/04 */
3763 {
3764 tempbx = XGINew_GetReg1( pVBInfo->P3d4 , 0x35 ) ;
3765
3766 if ( tempbx & TVOverScan )
3767 {
3768 tempbx |= SetCHTVOverScan ;
3769 }
3770 }
3771
3772
3773 if ( pVBInfo->IF_DEF_LVDS == 0 )
3774 {
3775 if ( pVBInfo->VBInfo & SetCRT2ToSCART )
3776 tempbx |= SetPALTV ;
3777 }
3778
3779 if ( pVBInfo->IF_DEF_YPbPr == 1 )
3780 {
3781 if ( pVBInfo->VBInfo & SetCRT2ToYPbPr )
3782 {
3783 index1 = XGINew_GetReg1( pVBInfo->P3d4 , 0x35 ) ;
3784 index1 &= YPbPrMode ;
3785
3786 if ( index1 == YPbPrMode525i )
3787 tempbx |= SetYPbPrMode525i ;
3788
3789 if ( index1 == YPbPrMode525p )
3790 tempbx = tempbx | SetYPbPrMode525p;
3791 if ( index1 == YPbPrMode750p)
3792 tempbx = tempbx | SetYPbPrMode750p;
3793 }
3794 }
3795
3796 if ( pVBInfo->IF_DEF_HiVision == 1 )
3797 {
3798 if ( pVBInfo->VBInfo & SetCRT2ToHiVisionTV )
3799 {
3800 tempbx = tempbx | SetYPbPrMode1080i | SetPALTV ;
3801 }
3802 }
3803
3804 if ( pVBInfo->IF_DEF_LVDS == 0 )
3805 { /* shampoo */
3806 if ( ( pVBInfo->VBInfo & SetInSlaveMode ) && ( !( pVBInfo->VBInfo & SetNotSimuMode ) ) )
3807 tempbx |= TVSimuMode ;
3808
3809 if ( !( tempbx & SetPALTV ) && ( modeflag > 13 ) && ( resinfo == 8 ) ) /* NTSC 1024x768, */
3810 tempbx |= NTSC1024x768 ;
3811
3812 tempbx |= RPLLDIV2XO ;
3813
3814 if ( pVBInfo->VBInfo & SetCRT2ToHiVisionTV )
3815 {
3816 if ( pVBInfo->VBInfo & SetInSlaveMode )
3817 tempbx &=( ~RPLLDIV2XO ) ;
3818 }
3819 else
3820 {
3821 if ( tempbx & ( SetYPbPrMode525p | SetYPbPrMode750p ) )
3822 tempbx &= ( ~RPLLDIV2XO ) ;
3823 else if ( !( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) ) )
3824 {
3825 if ( tempbx & TVSimuMode )
3826 tempbx &= ( ~RPLLDIV2XO ) ;
3827 }
3828 }
3829 }
3830 }
3831 pVBInfo->TVInfo = tempbx ;
3832}
3833
3834
3835/* --------------------------------------------------------------------- */
3836/* Function : XGI_GetLCDInfo */
3837/* Input : */
3838/* Output : */
3839/* Description : */
3840/* --------------------------------------------------------------------- */
3841BOOLEAN XGI_GetLCDInfo( USHORT ModeNo , USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo)
3842{
3843 USHORT temp ,
3844 tempax ,
3845 tempbx ,
3846 modeflag ,
3847 resinfo = 0 ,
3848 LCDIdIndex ;
3849
3850 pVBInfo->LCDResInfo = 0 ;
3851 pVBInfo->LCDTypeInfo = 0 ;
3852 pVBInfo->LCDInfo = 0 ;
3853
3854 if ( ModeNo <= 0x13 )
3855 {
3856 modeflag = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag ; /* si+St_ModeFlag // */
3857 }
3858 else
3859 {
3860 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag ;
3861 resinfo = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_RESINFO ; /* si+Ext_ResInfo// */
3862 }
3863
3864 temp = XGINew_GetReg1( pVBInfo->P3d4 , 0x36 ) ; /* Get LCD Res.Info */
3865 tempbx = temp & 0x0F ;
3866
3867 if ( tempbx == 0 )
3868 tempbx = Panel1024x768 ; /* default */
3869
3870 /* LCD75 [2003/8/22] Vicent */
3871 if ( ( tempbx == Panel1024x768 ) || ( tempbx == Panel1280x1024 ) )
3872 {
3873 if ( pVBInfo->VBInfo & DriverMode )
3874 {
3875 tempax = XGINew_GetReg1( pVBInfo->P3d4 , 0x33 ) ;
3876 if ( pVBInfo->VBInfo & SetCRT2ToLCDA )
3877 tempax &= 0x0F ;
3878 else
3879 tempax = tempax >> 4 ;
3880
3881 if ( ( resinfo == 6 ) || ( resinfo == 9 ) )
3882 {
3883 if ( tempax >= 3 )
3884 tempbx |= PanelRef75Hz ;
3885 }
3886 else if ( ( resinfo == 7 ) || ( resinfo == 8 ) )
3887 {
3888 if ( tempax >= 4 )
3889 tempbx |= PanelRef75Hz ;
3890 }
3891 }
3892 }
3893
3894 pVBInfo->LCDResInfo = tempbx ;
3895
3896 /* End of LCD75 */
3897
3898 if( pVBInfo->IF_DEF_OEMUtil == 1 )
3899 {
3900 pVBInfo->LCDTypeInfo = ( temp & 0xf0 ) >> 4 ;
3901 }
3902
3903 if ( !( pVBInfo->VBInfo & ( SetCRT2ToLCD | SetCRT2ToLCDA ) ) )
3904 {
3905 return 0;
3906 }
3907
3908 tempbx = 0 ;
3909
3910 temp = XGINew_GetReg1( pVBInfo->P3d4 , 0x37 ) ;
3911
3912 temp &= ( ScalingLCD | LCDNonExpanding | LCDSyncBit | SetPWDEnable ) ;
3913
3914 if ( ( pVBInfo->IF_DEF_ScaleLCD == 1 ) && ( temp & LCDNonExpanding ) )
3915 temp &= ~EnableScalingLCD ;
3916
3917 tempbx |= temp ;
3918
3919 LCDIdIndex = XGI_GetLCDCapPtr1(pVBInfo) ;
3920
3921 tempax = pVBInfo->LCDCapList[ LCDIdIndex ].LCD_Capability ;
3922
3923 if ( pVBInfo->IF_DEF_LVDS == 0 ) /* shampoo */
3924 {
3925 if ( ( ( pVBInfo->VBType & VB_XGI302LV ) || ( pVBInfo->VBType & VB_XGI301C ) ) && ( tempax & LCDDualLink ) )
3926 {
3927 tempbx |= SetLCDDualLink ;
3928 }
3929 }
3930
3931 if ( pVBInfo->IF_DEF_CH7017 == 1 )
3932 {
3933 if ( tempax & LCDDualLink )
3934 {
3935 tempbx |= SetLCDDualLink ;
3936 }
3937 }
3938
3939 if ( pVBInfo->IF_DEF_LVDS == 0 )
3940 {
3941 if ( ( pVBInfo->LCDResInfo == Panel1400x1050 ) && ( pVBInfo->VBInfo & SetCRT2ToLCD ) && ( ModeNo > 0x13 ) && ( resinfo == 9 ) && ( !( tempbx & EnableScalingLCD ) ) )
3942 tempbx |= SetLCDtoNonExpanding ; /* set to center in 1280x1024 LCDB for Panel1400x1050 */
3943 }
3944
3945/*
3946 if ( tempax & LCDBToA )
3947 {
3948 tempbx |= SetLCDBToA ;
3949 }
3950*/
3951
3952 if ( pVBInfo->IF_DEF_ExpLink == 1 )
3953 {
3954 if ( modeflag & HalfDCLK )
3955 {
3956 /* if ( !( pVBInfo->LCDInfo&LCDNonExpanding ) ) */
3957 if ( !( tempbx & SetLCDtoNonExpanding ) )
3958 {
3959 tempbx |= EnableLVDSDDA ;
3960 }
3961 else
3962 {
3963 if ( ModeNo > 0x13 )
3964 {
3965 if ( pVBInfo->LCDResInfo == Panel1024x768 )
3966 {
3967 if ( resinfo == 4 )
3968 { /* 512x384 */
3969 tempbx |= EnableLVDSDDA ;
3970 }
3971 }
3972 }
3973 }
3974 }
3975 }
3976
3977 if ( pVBInfo->VBInfo & SetInSlaveMode )
3978 {
3979 if ( pVBInfo->VBInfo & SetNotSimuMode )
3980 {
3981 tempbx |= LCDVESATiming ;
3982 }
3983 }
3984 else
3985 {
3986 tempbx |= LCDVESATiming ;
3987 }
3988
3989 pVBInfo->LCDInfo = tempbx ;
3990
3991 if ( pVBInfo->IF_DEF_PWD == 1 )
3992 {
3993 if ( pVBInfo->LCDInfo & SetPWDEnable )
3994 {
3995 if ( ( pVBInfo->VBType & VB_XGI302LV ) || ( pVBInfo->VBType & VB_XGI301C ) )
3996 {
3997 if ( !( tempax & PWDEnable ) )
3998 {
3999 pVBInfo->LCDInfo &= ~SetPWDEnable ;
4000 }
4001 }
4002 }
4003 }
4004
4005 if ( pVBInfo->IF_DEF_LVDS == 0 )
4006 {
4007 if ( tempax & ( LockLCDBToA | StLCDBToA ) )
4008 {
4009 if ( pVBInfo->VBInfo & SetInSlaveMode )
4010 {
4011 if ( !( tempax & LockLCDBToA ) )
4012 {
4013 if ( ModeNo <= 0x13 )
4014 {
4015 pVBInfo->VBInfo &= ~( SetSimuScanMode | SetInSlaveMode | SetCRT2ToLCD ) ;
4016 pVBInfo->VBInfo |= SetCRT2ToLCDA | SetCRT2ToDualEdge ;
4017 }
4018 }
4019 }
4020 }
4021 }
4022
4023/*
4024 if ( pVBInfo->IF_DEF_LVDS == 0 )
4025 {
4026 if ( tempax & ( LockLCDBToA | StLCDBToA ) )
4027 {
4028 if ( pVBInfo->VBInfo & SetInSlaveMode )
4029 {
4030 if ( !( ( !( tempax & LockLCDBToA ) ) && ( ModeNo > 0x13 ) ) )
4031 {
4032 pVBInfo->VBInfo&=~(SetSimuScanMode|SetInSlaveMode|SetCRT2ToLCD);
4033 pVBInfo->VBInfo|=SetCRT2ToLCDA|SetCRT2ToDualEdge;
4034 }
4035 }
4036 }
4037 }
4038*/
4039
4040 return( 1 ) ;
4041}
4042
4043
4044/* --------------------------------------------------------------------- */
4045/* Function : XGI_SearchModeID */
4046/* Input : */
4047/* Output : */
4048/* Description : */
4049/* --------------------------------------------------------------------- */
4050BOOLEAN XGI_SearchModeID( USHORT ModeNo , USHORT *ModeIdIndex, PVB_DEVICE_INFO pVBInfo )
4051{
4052
4053#ifdef TC
4054
4055 if ( ModeNo <= 5 )
4056 ModeNo |= 1 ;
4057
4058 if ( ModeNo <= 0x13 )
4059 {
4060 /* for (*ModeIdIndex=0;*ModeIdIndex<sizeof(pVBInfo->SModeIDTable)/sizeof(XGI_StStruct);(*ModeIdIndex)++) */
4061 for( *ModeIdIndex = 0 ; ; ( *ModeIdIndex )++ )
4062 {
4063 if ( pVBInfo->SModeIDTable[ *ModeIdIndex ].St_ModeID == ModeNo )
4064 break ;
4065 if ( pVBInfo->SModeIDTable[ *ModeIdIndex ].St_ModeID == 0xFF )
4066 return( FALSE ) ;
4067 }
4068
4069 VGA_INFO = ( PUCHAR )MK_FP( 0 , 0x489 ) ;
4070
4071 if ( ModeNo == 0x07 )
4072 {
4073 if ( ( *VGA_INFO & 0x10 ) != 0 )
4074 ( *ModeIdIndex )++ ; /* 400 lines */
4075 /* else 350 lines */
4076 }
4077
4078 if ( ModeNo <= 3 )
4079 {
4080 if ( ( *VGA_INFO & 0x80 ) == 0 )
4081 {
4082 ( *ModeIdIndex )++ ;
4083 if ( ( *VGA_INFO & 0x10 ) != 0 )
4084 ( *ModeIdIndex )++ ; /* 400 lines */
4085 /* else 350 lines */
4086 }
4087 /* else 200 lines */
4088 }
4089 }
4090 else
4091 {
4092 /* for (*ModeIdIndex=0;*ModeIdIndex<sizeof(pVBInfo->EModeIDTable)/sizeof(XGI_ExtStruct);(*ModeIdIndex)++) */
4093 for( *ModeIdIndex = 0 ; ; ( *ModeIdIndex )++ )
4094 {
4095 if ( pVBInfo->EModeIDTable[ *ModeIdIndex ].Ext_ModeID == ModeNo )
4096 break ;
4097 if ( pVBInfo->EModeIDTable[ *ModeIdIndex ].Ext_ModeID == 0xFF )
4098 return( FALSE ) ;
4099 }
4100 }
4101
4102
4103#endif
4104
4105#ifdef WIN2000
4106
4107 if ( ModeNo <= 5 )
4108 ModeNo |= 1 ;
4109 if ( ModeNo <= 0x13 )
4110 {
4111 /* for (*ModeIdIndex=0;*ModeIdIndex<sizeof(pVBInfo->SModeIDTable)/sizeof(XGI_StStruct);(*ModeIdIndex)++) */
4112 for( *ModeIdIndex = 0 ; ; ( *ModeIdIndex )++ )
4113 {
4114 if ( pVBInfo->SModeIDTable[ *ModeIdIndex ].St_ModeID == ModeNo )
4115 break ;
4116 if ( pVBInfo->SModeIDTable[ *ModeIdIndex ].St_ModeID == 0xFF )
4117 return( FALSE ) ;
4118 }
4119
4120 if ( ModeNo == 0x07 )
4121 ( *ModeIdIndex )++ ; /* 400 lines */
4122
4123 if ( ModeNo <=3 )
4124 ( *ModeIdIndex ) += 2 ; /* 400 lines */
4125 /* else 350 lines */
4126 }
4127 else
4128 {
4129 /* for (*ModeIdIndex=0;*ModeIdIndex<sizeof(pVBInfo->EModeIDTable)/sizeof(XGI_ExtStruct);(*ModeIdIndex)++) */
4130 for( *ModeIdIndex = 0 ; ; ( *ModeIdIndex )++ )
4131 {
4132 if ( pVBInfo->EModeIDTable[ *ModeIdIndex ].Ext_ModeID == ModeNo )
4133 break ;
4134 if ( pVBInfo->EModeIDTable[ *ModeIdIndex ].Ext_ModeID == 0xFF )
4135 return( FALSE ) ;
4136 }
4137 }
4138
4139#endif
4140
4141#ifdef LINUX /* chiawen for linux solution */
4142
4143 if ( ModeNo <= 5 )
4144 ModeNo |= 1 ;
4145 if ( ModeNo <= 0x13 )
4146 {
4147 /* for (*ModeIdIndex=0;*ModeIdIndex<sizeof(pVBInfo->SModeIDTable)/sizeof(XGI_StStruct);(*ModeIdIndex)++) */
4148 for( *ModeIdIndex = 0 ; ; ( *ModeIdIndex )++ )
4149 {
4150 if ( pVBInfo->SModeIDTable[ *ModeIdIndex ].St_ModeID == ModeNo )
4151 break ;
4152 if ( pVBInfo->SModeIDTable[ *ModeIdIndex ].St_ModeID == 0xFF )
4153 return( FALSE ) ;
4154 }
4155
4156 if ( ModeNo == 0x07 )
4157 ( *ModeIdIndex )++ ; /* 400 lines */
4158
4159 if ( ModeNo <= 3 )
4160 ( *ModeIdIndex ) += 2 ; /* 400 lines */
4161 /* else 350 lines */
4162 }
4163 else
4164 {
4165 /* for (*ModeIdIndex=0;*ModeIdIndex<sizeof(pVBInfo->EModeIDTable)/sizeof(XGI_ExtStruct);(*ModeIdIndex)++) */
4166 for( *ModeIdIndex = 0 ; ; ( *ModeIdIndex )++ )
4167 {
4168 if ( pVBInfo->EModeIDTable[ *ModeIdIndex ].Ext_ModeID == ModeNo )
4169 break ;
4170 if ( pVBInfo->EModeIDTable[ *ModeIdIndex ].Ext_ModeID == 0xFF )
4171 return( FALSE ) ;
4172 }
4173 }
4174
4175#endif
4176
4177 return( TRUE ) ;
4178}
4179
4180
4181
4182
4183/* win2000 MM adapter not support standard mode! */
4184
4185/* --------------------------------------------------------------------- */
4186/* Function : */
4187/* Input : */
4188/* Output : */
4189/* Description : */
4190/* --------------------------------------------------------------------- */
4191BOOLEAN XGINew_CheckMemorySize(PXGI_HW_DEVICE_INFO HwDeviceExtension,USHORT ModeNo,USHORT ModeIdIndex,PVB_DEVICE_INFO pVBInfo)
4192{
4193 USHORT memorysize ,
4194 modeflag ,
4195 temp ,
4196 temp1 ,
4197 tmp ;
4198
4199/* if ( ( HwDeviceExtension->jChipType == XGI_650 ) ||
4200 ( HwDeviceExtension->jChipType == XGI_650M ) )
4201 {
4202 return( TRUE ) ;
4203 } */
4204
4205 if ( ModeNo <= 0x13 )
4206 {
4207 modeflag = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag ;
4208 }
4209 else {
4210 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag ;
4211 }
4212
4213 /* ModeType = modeflag&ModeInfoFlag ; // Get mode type */
4214
4215 memorysize = modeflag & MemoryInfoFlag ;
4216 memorysize = memorysize > MemorySizeShift ;
4217 memorysize++ ; /* Get memory size */
4218
4219 temp = XGINew_GetReg1( pVBInfo->P3c4 , 0x14 ) ; /* Get DRAM Size */
4220 tmp = temp ;
4221
4222 if ( HwDeviceExtension->jChipType == XG40 )
4223 {
4224 temp = 1 << ( ( temp & 0x0F0 ) >> 4 ) ; /* memory size per channel SR14[7:4] */
4225 if ( ( tmp & 0x0c ) == 0x0C ) /* Qual channels */
4226 {
4227 temp <<= 2 ;
4228 }
4229 else if ( ( tmp & 0x0c ) == 0x08 ) /* Dual channels */
4230 {
4231 temp <<= 1 ;
4232 }
4233 }
4234 else if ( HwDeviceExtension->jChipType == XG42 )
4235 {
4236 temp = 1 << ( ( temp & 0x0F0 ) >> 4 ) ; /* memory size per channel SR14[7:4] */
4237 if ( ( tmp & 0x04 ) == 0x04 ) /* Dual channels */
4238 {
4239 temp <<= 1 ;
4240 }
4241 }
4242 else if ( HwDeviceExtension->jChipType == XG45 )
4243 {
4244 temp = 1 << ( ( temp & 0x0F0 ) >> 4 ) ; /* memory size per channel SR14[7:4] */
4245 if ( ( tmp & 0x0c ) == 0x0C ) /* Qual channels */
4246 {
4247 temp <<= 2 ;
4248 }
4249 else if ( ( tmp & 0x0c ) == 0x08 ) /* triple channels */
4250 {
4251 temp1 = temp ;
4252 temp <<= 1 ;
4253 temp += temp1 ;
4254 }
4255 else if ( ( tmp & 0x0c ) == 0x04 ) /* Dual channels */
4256 {
4257 temp <<= 1 ;
4258 }
4259 }
4260 if ( temp < memorysize )
4261 return( FALSE ) ;
4262 else
4263 return( TRUE ) ;
4264}
4265
4266
4267/* --------------------------------------------------------------------- */
4268/* Function : XGINew_IsLowResolution */
4269/* Input : */
4270/* Output : */
4271/* Description : */
4272/* --------------------------------------------------------------------- */
4273/*void XGINew_IsLowResolution( USHORT ModeNo , USHORT ModeIdIndex, BOOLEAN XGINew_CheckMemorySize(PXGI_HW_DEVICE_INFO HwDeviceExtension,USHORT ModeNo,USHORT ModeIdIndex,PVB_DEVICE_INFO pVBInfo)
4274{
4275 USHORT data ;
4276 USHORT ModeFlag ;
4277
4278 data = XGINew_GetReg1( pVBInfo->P3c4 , 0x0F ) ;
4279 data &= 0x7F ;
4280 XGINew_SetReg1( pVBInfo->P3c4 , 0x0F , data ) ;
4281
4282 if ( ModeNo > 0x13 )
4283 {
4284 ModeFlag = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag ;
4285 if ( ( ModeFlag & HalfDCLK ) && ( ModeFlag & DoubleScanMode ) )
4286 {
4287 data = XGINew_GetReg1( pVBInfo->P3c4 , 0x0F ) ;
4288 data |= 0x80 ;
4289 XGINew_SetReg1( pVBInfo->P3c4 , 0x0F , data ) ;
4290 data = XGINew_GetReg1( pVBInfo->P3c4 , 0x01 ) ;
4291 data &= 0xF7 ;
4292 XGINew_SetReg1( pVBInfo->P3c4 , 0x01 , data ) ;
4293 }
4294 }
4295}
4296
4297*/
4298
4299/* --------------------------------------------------------------------- */
4300/* Function : XGI_DisplayOn */
4301/* Input : */
4302/* Output : */
4303/* Description : */
4304/* --------------------------------------------------------------------- */
4305void XGI_DisplayOn( PXGI_HW_DEVICE_INFO pXGIHWDE , PVB_DEVICE_INFO pVBInfo )
4306{
4307
4308 XGINew_SetRegANDOR(pVBInfo->P3c4,0x01,0xDF,0x00);
4309 if ( pXGIHWDE->jChipType == XG21 )
4310 {
4311 if ( pVBInfo->IF_DEF_LVDS == 1 )
4312 {
4313 if (!(XGI_XG21GetPSCValue( pVBInfo )&0x1))
4314 {
4315 XGI_XG21BLSignalVDD( 0x01 , 0x01, pVBInfo ) ; /* LVDS VDD on */
4316 XGI_XG21SetPanelDelay( 2,pVBInfo ) ;
4317 }
4318 if (!(XGI_XG21GetPSCValue( pVBInfo )&0x20))
4319 {
4320 XGI_XG21BLSignalVDD( 0x20 , 0x20, pVBInfo ) ; /* LVDS signal on */
4321 }
4322 XGI_XG21SetPanelDelay( 3,pVBInfo ) ;
4323 XGI_XG21BLSignalVDD( 0x02 , 0x02, pVBInfo ) ; /* LVDS backlight on */
4324 }
4325 else
4326 {
4327 XGI_XG21BLSignalVDD( 0x20 , 0x20, pVBInfo ) ; /* DVO/DVI signal on */
4328 }
4329
4330 }
4331
4332 if (pVBInfo->IF_DEF_CH7007 == 1) /* [Billy] 07/05/23 For CH7007 */
4333 {
4334#ifdef WIN2000
4335 if ( IsCH7007TVMode( pVBInfo ) )
4336 {
4337 TurnOnCH7007(pXGIHWDE->pDevice) ; /* 07/05/28 */
4338 }
4339#endif
4340
4341 }
4342
4343
4344 if ( pXGIHWDE->jChipType == XG27 )
4345 {
4346 if ( pVBInfo->IF_DEF_LVDS == 1 )
4347 {
4348 if (!(XGI_XG27GetPSCValue( pVBInfo )&0x1))
4349 {
4350 XGI_XG27BLSignalVDD( 0x01 , 0x01, pVBInfo ) ; /* LVDS VDD on */
4351 XGI_XG21SetPanelDelay( 2,pVBInfo ) ;
4352 }
4353 if (!(XGI_XG27GetPSCValue( pVBInfo )&0x20))
4354 {
4355 XGI_XG27BLSignalVDD( 0x20 , 0x20, pVBInfo ) ; /* LVDS signal on */
4356 }
4357 XGI_XG21SetPanelDelay( 3,pVBInfo ) ;
4358 XGI_XG27BLSignalVDD( 0x02 , 0x02, pVBInfo ) ; /* LVDS backlight on */
4359 }
4360 else
4361 {
4362 XGI_XG27BLSignalVDD( 0x20 , 0x20, pVBInfo ) ; /* DVO/DVI signal on */
4363 }
4364
4365 }
4366}
4367
4368
4369/* --------------------------------------------------------------------- */
4370/* Function : XGI_DisplayOff */
4371/* Input : */
4372/* Output : */
4373/* Description : */
4374/* --------------------------------------------------------------------- */
4375void XGI_DisplayOff( PXGI_HW_DEVICE_INFO pXGIHWDE , PVB_DEVICE_INFO pVBInfo )
4376{
4377
4378 if ( pXGIHWDE->jChipType == XG21 )
4379 {
4380 if ( pVBInfo->IF_DEF_LVDS == 1 )
4381 {
4382 XGI_XG21BLSignalVDD( 0x02 , 0x00, pVBInfo ) ; /* LVDS backlight off */
4383 XGI_XG21SetPanelDelay( 3,pVBInfo ) ;
4384 }
4385 else
4386 {
4387 XGI_XG21BLSignalVDD( 0x20 , 0x00, pVBInfo ) ; /* DVO/DVI signal off */
4388 }
4389 }
4390
4391 if (pVBInfo->IF_DEF_CH7007 == 1) /*[Billy] 07/05/23 For CH7007 */
4392 {
4393 /* if( IsCH7007TVMode( pVBInfo ) == 0 ) */
4394 {
4395#ifdef WIN2000
4396 TurnOffCH7007(pXGIHWDE->pDevice) ; /* 07/05/28 */
4397#endif
4398 }
4399 }
4400
4401
4402 if ( pXGIHWDE->jChipType == XG27 )
4403 {
4404 if ((XGI_XG27GetPSCValue( pVBInfo )&0x2))
4405 {
4406 XGI_XG27BLSignalVDD( 0x02 , 0x00, pVBInfo ) ; /* LVDS backlight off */
4407 XGI_XG21SetPanelDelay( 3,pVBInfo ) ;
4408 }
4409
4410 if ( pVBInfo->IF_DEF_LVDS == 0 )
4411 {
4412 XGI_XG27BLSignalVDD( 0x20 , 0x00, pVBInfo ) ; /* DVO/DVI signal off */
4413 }
4414 }
4415
4416 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x01 , 0xDF , 0x20 ) ;
4417}
4418
4419
4420/* --------------------------------------------------------------------- */
4421/* Function : XGI_WaitDisply */
4422/* Input : */
4423/* Output : */
4424/* Description : chiawen for sensecrt1 */
4425/* --------------------------------------------------------------------- */
4426void XGI_WaitDisply( PVB_DEVICE_INFO pVBInfo )
4427{
4428 while( ( XGINew_GetReg2( pVBInfo->P3da ) & 0x01 ) )
4429 break ;
4430
4431 while( !( XGINew_GetReg2( pVBInfo->P3da ) & 0x01 ) )
4432 break ;
4433}
4434
4435/* --------------------------------------------------------------------- */
4436/* Function : XGI_SenseCRT1 */
4437/* Input : */
4438/* Output : */
4439/* Description : */
4440/* --------------------------------------------------------------------- */
4441
4442void XGI_SenseCRT1( PVB_DEVICE_INFO pVBInfo )
4443{
4444 UCHAR CRTCData[ 17 ] = { 0x5F , 0x4F , 0x50 , 0x82 , 0x55 , 0x81 ,
4445 0x0B , 0x3E , 0xE9 , 0x0B , 0xDF , 0xE7 ,
4446 0x04 , 0x00 , 0x00 , 0x05 , 0x00 } ;
4447
4448 UCHAR SR01 = 0 , SR1F = 0 , SR07 = 0 , SR06 = 0 ;
4449
4450 UCHAR CR17 , CR63 , SR31 ;
4451 USHORT temp ;
4452 UCHAR DAC_TEST_PARMS[ 3 ] = { 0x0F , 0x0F , 0x0F } ;
4453
4454 int i ;
4455 XGINew_SetReg1( pVBInfo->P3c4 , 0x05 , 0x86 ) ;
4456
4457 /* [2004/05/06] Vicent to fix XG42 single LCD sense to CRT+LCD */
4458 XGINew_SetReg1( pVBInfo->P3d4 , 0x57 , 0x4A ) ;
4459 XGINew_SetReg1( pVBInfo->P3d4 , 0x53 , ( UCHAR )( XGINew_GetReg1( pVBInfo->P3d4 , 0x53 ) | 0x02 ) ) ;
4460
4461 SR31 = ( UCHAR )XGINew_GetReg1( pVBInfo->P3c4 , 0x31 ) ;
4462 CR63 = ( UCHAR )XGINew_GetReg1( pVBInfo->P3d4 , 0x63 ) ;
4463 SR01 = ( UCHAR )XGINew_GetReg1( pVBInfo->P3c4 , 0x01 ) ;
4464
4465 XGINew_SetReg1( pVBInfo->P3c4 , 0x01 , ( UCHAR )( SR01 & 0xDF ) ) ;
4466 XGINew_SetReg1( pVBInfo->P3d4 , 0x63 , ( UCHAR )( CR63 & 0xBF ) ) ;
4467
4468 CR17 = ( UCHAR )XGINew_GetReg1( pVBInfo->P3d4 , 0x17 ) ;
4469 XGINew_SetReg1( pVBInfo->P3d4 , 0x17 , ( UCHAR )( CR17 | 0x80 ) ) ;
4470
4471 SR1F = ( UCHAR )XGINew_GetReg1( pVBInfo->P3c4 , 0x1F ) ;
4472 XGINew_SetReg1( pVBInfo->P3c4 , 0x1F , ( UCHAR )( SR1F | 0x04 ) ) ;
4473
4474 SR07 = ( UCHAR )XGINew_GetReg1( pVBInfo->P3c4 , 0x07 ) ;
4475 XGINew_SetReg1( pVBInfo->P3c4 , 0x07 , ( UCHAR )( SR07 & 0xFB ) ) ;
4476 SR06 = ( UCHAR )XGINew_GetReg1( pVBInfo->P3c4 , 0x06 ) ;
4477 XGINew_SetReg1( pVBInfo->P3c4 , 0x06 , ( UCHAR )( SR06 & 0xC3 ) ) ;
4478
4479 XGINew_SetReg1( pVBInfo->P3d4 , 0x11 , 0x00 ) ;
4480
4481 for( i = 0 ; i < 8 ; i++ )
4482 XGINew_SetReg1( pVBInfo->P3d4 , ( USHORT )i , CRTCData[ i ] ) ;
4483
4484 for( i = 8 ; i < 11 ; i++ )
4485 XGINew_SetReg1( pVBInfo->P3d4 , ( USHORT )( i + 8 ) , CRTCData[ i ] ) ;
4486
4487 for( i = 11 ; i < 13 ; i++ )
4488 XGINew_SetReg1( pVBInfo->P3d4 , ( USHORT )( i + 4 ) , CRTCData[ i ] ) ;
4489
4490 for( i = 13 ; i < 16 ; i++ )
4491 XGINew_SetReg1( pVBInfo->P3c4 , ( USHORT )( i - 3 ) , CRTCData[ i ] ) ;
4492
4493 XGINew_SetReg1( pVBInfo->P3c4 , 0x0E , ( UCHAR )( CRTCData[ 16 ] & 0xE0 ) ) ;
4494
4495 XGINew_SetReg1( pVBInfo->P3c4 , 0x31 , 0x00 ) ;
4496 XGINew_SetReg1( pVBInfo->P3c4 , 0x2B , 0x1B ) ;
4497 XGINew_SetReg1( pVBInfo->P3c4 , 0x2C , 0xE1 ) ;
4498
4499 XGINew_SetReg3( pVBInfo->P3c8 , 0x00 ) ;
4500
4501 for( i = 0 ; i < 256 ; i++ )
4502 {
4503 XGINew_SetReg3( ( pVBInfo->P3c8 + 1 ) , ( UCHAR )DAC_TEST_PARMS[ 0 ] ) ;
4504 XGINew_SetReg3( ( pVBInfo->P3c8 + 1 ) , ( UCHAR )DAC_TEST_PARMS[ 1 ] ) ;
4505 XGINew_SetReg3( ( pVBInfo->P3c8 + 1 ) , ( UCHAR )DAC_TEST_PARMS[ 2 ] ) ;
4506 }
4507
4508 XGI_VBLongWait( pVBInfo ) ;
4509 XGI_VBLongWait( pVBInfo ) ;
4510 XGI_VBLongWait( pVBInfo ) ;
4511
4512 XGINew_LCD_Wait_Time( 0x01 , pVBInfo ) ;
4513
4514 XGI_WaitDisply( pVBInfo ) ;
4515 temp = XGINew_GetReg2( pVBInfo->P3c2 ) ;
4516
4517 if( temp & 0x10 )
4518 {
4519 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x32 , 0xDF , 0x20 ) ;
4520 }
4521 else
4522 {
4523 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x32 , 0xDF , 0x00 ) ;
4524 }
4525
4526 /* alan, avoid display something, set BLACK DAC if not restore DAC */
4527 XGINew_SetReg3( pVBInfo->P3c8 , 0x00 ) ;
4528
4529 for( i = 0 ; i < 256 ; i++ )
4530 {
4531 XGINew_SetReg3( ( pVBInfo->P3c8 + 1 ) , 0 ) ;
4532 XGINew_SetReg3( ( pVBInfo->P3c8 + 1 ) , 0 ) ;
4533 XGINew_SetReg3( ( pVBInfo->P3c8 + 1 ) , 0 ) ;
4534 }
4535
4536 XGINew_SetReg1( pVBInfo->P3c4 , 0x01 , SR01 ) ;
4537 XGINew_SetReg1( pVBInfo->P3d4 , 0x63 , CR63 ) ;
4538 XGINew_SetReg1( pVBInfo->P3c4 , 0x31 , SR31 ) ;
4539
4540 /* [2004/05/11] Vicent */
4541 XGINew_SetReg1( pVBInfo->P3d4 , 0x53 , ( UCHAR )( XGINew_GetReg1( pVBInfo->P3d4 , 0x53 ) & 0xFD ) ) ;
4542 XGINew_SetReg1( pVBInfo->P3c4 , 0x1F , ( UCHAR ) SR1F ) ;
4543}
4544
4545
4546
4547
4548
4549#ifdef TC
4550/* --------------------------------------------------------------------- */
4551/* Function : INT1AReturnCode */
4552/* Input : */
4553/* Output : */
4554/* Description : */
4555/* --------------------------------------------------------------------- */
4556int INT1AReturnCode( union REGS regs )
4557{
4558 if ( regs.x.cflag )
4559 {
4560 /* printf( "Error to find pci device!\n" ) ; */
4561 return( 1 ) ;
4562 }
4563
4564 switch(regs.h.ah)
4565 {
4566 case 0: return 0;
4567 break ;
4568 case 0x81:
4569 printf( "Function not support\n" ) ;
4570 break ;
4571 case 0x83:
4572 printf( "bad vendor id\n" ) ;
4573 break ;
4574 case 0x86:
4575 printf( "device not found\n" ) ;
4576 break ;
4577 case 0x87:
4578 printf( "bad register number\n" ) ;
4579 break ;
4580 case 0x88:
4581 printf( "set failed\n" ) ;
4582 break ;
4583 case 0x89:
4584 printf( "buffer too small" ) ;
4585 break ;
4586 default:
4587 break ;
4588 }
4589 return( 1 ) ;
4590}
4591
4592
4593/* --------------------------------------------------------------------- */
4594/* Function : FindPCIIOBase */
4595/* Input : */
4596/* Output : */
4597/* Description : */
4598/* --------------------------------------------------------------------- */
4599unsigned FindPCIIOBase( unsigned index , unsigned deviceid )
4600{
4601 union REGS regs ;
4602
4603 regs.h.ah = 0xb1 ; /* PCI_FUNCTION_ID */
4604 regs.h.al = 0x02 ; /* FIND_PCI_DEVICE */
4605 regs.x.cx = deviceid ;
4606 regs.x.dx = 0x1039 ;
4607 regs.x.si = index ; /* find n-th device */
4608
4609 int86( 0x1A , &regs , &regs ) ;
4610
4611 if ( INT1AReturnCode( regs ) != 0 )
4612 return( 0 ) ;
4613
4614 /* regs.h.bh bus number */
4615 /* regs.h.bl device number */
4616 regs.h.ah = 0xb1 ; /* PCI_FUNCTION_ID */
4617 regs.h.al = 0x09 ; /* READ_CONFIG_WORD */
4618 regs.x.cx = deviceid ;
4619 regs.x.dx = 0x1039 ;
4620 regs.x.di = 0x18 ; /* register number */
4621 int86( 0x1A , &regs , &regs ) ;
4622
4623 if ( INT1AReturnCode( regs ) != 0 )
4624 return( 0 ) ;
4625
4626 return( regs.x.cx ) ;
4627}
4628
4629#endif
4630
4631
4632
4633#ifdef TC
4634/* --------------------------------------------------------------------- */
4635/* Function : main */
4636/* Input : */
4637/* Output : */
4638/* Description : */
4639/* --------------------------------------------------------------------- */
4640void main(int argc, char *argv[])
4641{
4642 XGI_HW_DEVICE_INFO HwDeviceExtension ;
4643 USHORT temp ;
4644 USHORT ModeNo ;
4645
4646 /* HwDeviceExtension.pjVirtualRomBase =(PUCHAR) MK_FP(0xC000,0); */
4647 /* HwDeviceExtension.pjVideoMemoryAddress = (PUCHAR)MK_FP(0xA000,0); */
4648
4649
4650 HwDeviceExtension.pjIOAddress = ( FindPCIIOBase( 0 ,0x6300 ) & 0xFF80 ) + 0x30 ;
4651 HwDeviceExtension.jChipType = XGI_340 ;
4652
4653
4654
4655 /* HwDeviceExtension.pjIOAddress = ( FindPCIIOBase( 0 , 0x5315 ) & 0xFF80 ) + 0x30 ; */
4656
4657 HwDeviceExtension.pjIOAddress = ( FindPCIIOBase( 0 , 0x330 ) & 0xFF80 ) + 0x30 ;
4658 HwDeviceExtension.jChipType = XGI_340 ;
4659
4660
4661 HwDeviceExtension.ujVBChipID = VB_CHIP_301 ;
4662 StrCpy(HwDeviceExtension.szVBIOSVer , "0.84" ) ;
4663 HwDeviceExtension.bSkipDramSizing = FALSE ;
4664 HwDeviceExtension.ulVideoMemorySize = 0 ;
4665
4666 if ( argc == 2 )
4667 {
4668 ModeNo = atoi( argv[ 1 ] ) ;
4669 }
4670 else
4671 {
4672 ModeNo = 0x2e ;
4673 /* ModeNo = 0x37 ; 1024x768x 4bpp */
4674 /* ModeNo = 0x38 ; 1024x768x 8bpp */
4675 /* ModeNo = 0x4A ; 1024x768x 16bpp */
4676 /* ModeNo = 0x47 ; 800x600x 16bpp */
4677 }
4678
4679 /* XGIInitNew( &HwDeviceExtension ) ; */
4680 XGISetModeNew( &HwDeviceExtension , ModeNo ) ;
4681}
4682#endif
4683
4684
4685/* --------------------------------------------------------------------- */
4686/* Function : XGI_WaitDisplay */
4687/* Input : */
4688/* Output : */
4689/* Description : */
4690/* --------------------------------------------------------------------- */
4691void XGI_WaitDisplay( PVB_DEVICE_INFO pVBInfo )
4692{
4693 while( !( XGINew_GetReg2( pVBInfo->P3da ) & 0x01 ) ) ;
4694
4695 while( XGINew_GetReg2( pVBInfo->P3da ) & 0x01 ) ;
4696}
4697
4698
4699
4700
4701/* --------------------------------------------------------------------- */
4702/* Function : XGI_SetCRT2Group301 */
4703/* Input : */
4704/* Output : */
4705/* Description : */
4706/* --------------------------------------------------------------------- */
4707BOOLEAN XGI_SetCRT2Group301( USHORT ModeNo , PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo )
4708{
4709 USHORT tempbx ,
4710 ModeIdIndex ,
4711 RefreshRateTableIndex ;
4712
4713 tempbx=pVBInfo->VBInfo ;
4714 pVBInfo->SetFlag |= ProgrammingCRT2 ;
4715 XGI_SearchModeID( ModeNo , &ModeIdIndex, pVBInfo ) ;
4716 pVBInfo->SelectCRT2Rate = 4 ;
4717 RefreshRateTableIndex = XGI_GetRatePtrCRT2( HwDeviceExtension, ModeNo , ModeIdIndex, pVBInfo ) ;
4718 XGI_SaveCRT2Info( ModeNo, pVBInfo ) ;
4719 XGI_GetCRT2ResInfo( ModeNo , ModeIdIndex, pVBInfo) ;
4720 XGI_GetCRT2Data( ModeNo , ModeIdIndex , RefreshRateTableIndex, pVBInfo ) ;
4721 XGI_PreSetGroup1( ModeNo , ModeIdIndex , HwDeviceExtension , RefreshRateTableIndex, pVBInfo ) ;
4722 XGI_SetGroup1( ModeNo , ModeIdIndex , HwDeviceExtension , RefreshRateTableIndex, pVBInfo ) ;
4723 XGI_SetLockRegs( ModeNo , ModeIdIndex , HwDeviceExtension , RefreshRateTableIndex, pVBInfo ) ;
4724 XGI_SetGroup2( ModeNo , ModeIdIndex , RefreshRateTableIndex , HwDeviceExtension, pVBInfo ) ;
4725 XGI_SetLCDRegs(ModeNo , ModeIdIndex , HwDeviceExtension , RefreshRateTableIndex, pVBInfo ) ;
4726 XGI_SetTap4Regs(pVBInfo) ;
4727 XGI_SetGroup3(ModeNo, ModeIdIndex, pVBInfo);
4728 XGI_SetGroup4( ModeNo , ModeIdIndex , RefreshRateTableIndex , HwDeviceExtension, pVBInfo ) ;
4729 XGI_SetCRT2VCLK( ModeNo , ModeIdIndex , RefreshRateTableIndex, pVBInfo ) ;
4730 XGI_SetGroup5( ModeNo , ModeIdIndex, pVBInfo) ;
4731 XGI_AutoThreshold( pVBInfo) ;
4732 return 1 ;
4733}
4734
4735
4736/* --------------------------------------------------------------------- */
4737/* Function : XGI_AutoThreshold */
4738/* Input : */
4739/* Output : */
4740/* Description : */
4741/* --------------------------------------------------------------------- */
4742void XGI_AutoThreshold( PVB_DEVICE_INFO pVBInfo )
4743{
4744 if ( !( pVBInfo->SetFlag & Win9xDOSMode ) )
4745 XGINew_SetRegOR( pVBInfo->Part1Port , 0x01 , 0x40 ) ;
4746}
4747
4748
4749/* --------------------------------------------------------------------- */
4750/* Function : XGI_SaveCRT2Info */
4751/* Input : */
4752/* Output : */
4753/* Description : */
4754/* --------------------------------------------------------------------- */
4755void XGI_SaveCRT2Info( USHORT ModeNo , PVB_DEVICE_INFO pVBInfo)
4756{
4757 USHORT temp1 ,
4758 temp2 ;
4759
4760 XGINew_SetReg1( pVBInfo->P3d4 , 0x34 , ModeNo ) ; /* reserve CR34 for CRT1 Mode No */
4761 temp1 = ( pVBInfo->VBInfo&SetInSlaveMode ) >> 8 ;
4762 temp2 = ~( SetInSlaveMode >> 8 ) ;
4763 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x31 , temp2 , temp1 ) ;
4764}
4765
4766
4767/* --------------------------------------------------------------------- */
4768/* Function : XGI_GetCRT2ResInfo */
4769/* Input : */
4770/* Output : */
4771/* Description : */
4772/* --------------------------------------------------------------------- */
4773void XGI_GetCRT2ResInfo( USHORT ModeNo , USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo )
4774{
4775 USHORT xres ,
4776 yres ,
4777 modeflag ,
4778 resindex ;
4779
4780 resindex = XGI_GetResInfo( ModeNo , ModeIdIndex, pVBInfo) ;
4781 if ( ModeNo <= 0x13 )
4782 {
4783 xres = pVBInfo->StResInfo[ resindex ].HTotal ;
4784 yres = pVBInfo->StResInfo[ resindex ].VTotal ;
4785 /* modeflag = pVBInfo->SModeIDTable[ModeIdIndex].St_ModeFlag; si+St_ResInfo */
4786 }
4787 else
4788 {
4789 xres = pVBInfo->ModeResInfo[ resindex ].HTotal ; /* xres->ax */
4790 yres = pVBInfo->ModeResInfo[ resindex ].VTotal ; /* yres->bx */
4791 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex].Ext_ModeFlag ; /* si+St_ModeFlag */
4792
4793/* if ( pVBInfo->IF_DEF_FSTN )
4794 {
4795 xres *= 2 ;
4796 yres *= 2 ;
4797 }
4798 else
4799 {
4800*/
4801 if ( modeflag & HalfDCLK )
4802 xres *= 2;
4803
4804 if ( modeflag & DoubleScanMode )
4805 yres *= 2 ;
4806/* } */
4807 }
4808
4809 if ( pVBInfo->VBInfo & SetCRT2ToLCD )
4810 {
4811 if ( pVBInfo->IF_DEF_LVDS == 0 )
4812 {
4813 if ( pVBInfo->LCDResInfo == Panel1600x1200 )
4814 {
4815 if ( !( pVBInfo->LCDInfo & LCDVESATiming ) )
4816 {
4817 if ( yres == 1024 )
4818 yres = 1056 ;
4819 }
4820 }
4821
4822 if ( pVBInfo->LCDResInfo == Panel1280x1024 )
4823 {
4824 if ( yres == 400 )
4825 yres = 405 ;
4826 else if ( yres == 350 )
4827 yres = 360 ;
4828
4829 if ( pVBInfo->LCDInfo & LCDVESATiming )
4830 {
4831 if ( yres == 360 )
4832 yres = 375 ;
4833 }
4834 }
4835
4836 if ( pVBInfo->LCDResInfo == Panel1024x768 )
4837 {
4838 if ( !( pVBInfo->LCDInfo & LCDVESATiming ) )
4839 {
4840 if ( !( pVBInfo->LCDInfo & LCDNonExpanding ) )
4841 {
4842 if ( yres == 350 )
4843 yres = 357 ;
4844 else if ( yres == 400 )
4845 yres = 420 ;
4846 else if ( yres == 480 )
4847 yres = 525 ;
4848 }
4849 }
4850 }
4851 }
4852
4853 if ( xres == 720 )
4854 xres = 640 ;
4855 }
4856
4857 pVBInfo->VGAHDE = xres ;
4858 pVBInfo->HDE = xres ;
4859 pVBInfo->VGAVDE = yres ;
4860 pVBInfo->VDE = yres ;
4861}
4862
4863
4864/* --------------------------------------------------------------------- */
4865/* Function : XGI_IsLCDDualLink */
4866/* Input : */
4867/* Output : */
4868/* Description : */
4869/* --------------------------------------------------------------------- */
4870BOOLEAN XGI_IsLCDDualLink( PVB_DEVICE_INFO pVBInfo )
4871{
4872
4873 if ( ( ( ( pVBInfo->VBInfo & SetCRT2ToLCD ) | SetCRT2ToLCDA ) ) && ( pVBInfo->LCDInfo & SetLCDDualLink ) ) /* shampoo0129 */
4874 return ( 1 ) ;
4875
4876 return( 0 ) ;
4877}
4878
4879
4880/* --------------------------------------------------------------------- */
4881/* Function : XGI_GetCRT2Data */
4882/* Input : */
4883/* Output : */
4884/* Description : */
4885/* --------------------------------------------------------------------- */
4886void XGI_GetCRT2Data( USHORT ModeNo , USHORT ModeIdIndex , USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo )
4887{
4888 USHORT tempax = 0,
4889 tempbx ,
4890 modeflag ,
4891 resinfo ;
4892
4893 XGI_LCDDataStruct *LCDPtr = NULL ;
4894 XGI_TVDataStruct *TVPtr = NULL ;
4895
4896 if ( ModeNo <= 0x13 )
4897 {
4898 modeflag = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag ; /* si+St_ResInfo */
4899 resinfo = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ResInfo ;
4900 }
4901 else
4902 {
4903 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag ; /* si+Ext_ResInfo */
4904 resinfo = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_RESINFO ;
4905 }
4906
4907 pVBInfo->NewFlickerMode = 0 ;
4908 pVBInfo->RVBHRS = 50 ;
4909
4910 if ( pVBInfo->VBInfo & SetCRT2ToRAMDAC )
4911 {
4912 XGI_GetRAMDAC2DATA( ModeNo , ModeIdIndex , RefreshRateTableIndex,pVBInfo ) ;
4913 return ;
4914 }
4915
4916 tempbx = 4 ;
4917
4918 if ( pVBInfo->VBInfo & ( SetCRT2ToLCD | SetCRT2ToLCDA ) )
4919 {
4920 LCDPtr = (XGI_LCDDataStruct* )XGI_GetLcdPtr( tempbx, ModeNo , ModeIdIndex , RefreshRateTableIndex, pVBInfo ) ;
4921
4922 pVBInfo->RVBHCMAX = LCDPtr->RVBHCMAX ;
4923 pVBInfo->RVBHCFACT = LCDPtr->RVBHCFACT ;
4924 pVBInfo->VGAHT = LCDPtr->VGAHT ;
4925 pVBInfo->VGAVT = LCDPtr->VGAVT ;
4926 pVBInfo->HT = LCDPtr->LCDHT ;
4927 pVBInfo->VT = LCDPtr->LCDVT ;
4928
4929 if ( pVBInfo->LCDResInfo == Panel1024x768 )
4930 {
4931 tempax = 1024 ;
4932 tempbx = 768 ;
4933
4934 if ( !( pVBInfo->LCDInfo & LCDVESATiming ) )
4935 {
4936 if ( pVBInfo->VGAVDE == 357 )
4937 tempbx = 527 ;
4938 else if ( pVBInfo->VGAVDE == 420 )
4939 tempbx = 620 ;
4940 else if ( pVBInfo->VGAVDE == 525 )
4941 tempbx = 775 ;
4942 else if ( pVBInfo->VGAVDE == 600 )
4943 tempbx = 775 ;
4944 /* else if(pVBInfo->VGAVDE==350) tempbx=560; */
4945 /* else if(pVBInfo->VGAVDE==400) tempbx=640; */
4946 else
4947 tempbx = 768 ;
4948 }
4949 else
4950 tempbx = 768 ;
4951 }
4952 else if ( pVBInfo->LCDResInfo == Panel1024x768x75 )
4953 {
4954 tempax = 1024 ;
4955 tempbx = 768 ;
4956 }
4957 else if ( pVBInfo->LCDResInfo == Panel1280x1024 )
4958 {
4959 tempax = 1280 ;
4960 if ( pVBInfo->VGAVDE == 360 )
4961 tempbx = 768 ;
4962 else if ( pVBInfo->VGAVDE == 375 )
4963 tempbx = 800 ;
4964 else if ( pVBInfo->VGAVDE == 405 )
4965 tempbx = 864 ;
4966 else
4967 tempbx = 1024 ;
4968 }
4969 else if ( pVBInfo->LCDResInfo == Panel1280x1024x75 )
4970 {
4971 tempax = 1280 ;
4972 tempbx = 1024 ;
4973 }
4974 else if ( pVBInfo->LCDResInfo == Panel1280x960 )
4975 {
4976 tempax = 1280 ;
4977 if ( pVBInfo->VGAVDE == 350 )
4978 tempbx = 700 ;
4979 else if ( pVBInfo->VGAVDE == 400 )
4980 tempbx = 800 ;
4981 else if ( pVBInfo->VGAVDE == 1024 )
4982 tempbx = 960 ;
4983 else
4984 tempbx = 960 ;
4985 }
4986 else if ( pVBInfo->LCDResInfo == Panel1400x1050 )
4987 {
4988 tempax = 1400 ;
4989 tempbx = 1050 ;
4990
4991 if ( pVBInfo->VGAVDE == 1024 )
4992 {
4993 tempax = 1280 ;
4994 tempbx = 1024 ;
4995 }
4996 }
4997 else if ( pVBInfo->LCDResInfo == Panel1600x1200 )
4998 {
4999 tempax = 1600 ;
5000 tempbx = 1200 ; /* alan 10/14/2003 */
5001 if ( !( pVBInfo->LCDInfo & LCDVESATiming ) )
5002 {
5003 if ( pVBInfo->VGAVDE == 350 )
5004 tempbx = 875 ;
5005 else if ( pVBInfo->VGAVDE == 400 )
5006 tempbx = 1000 ;
5007 }
5008 }
5009
5010 if ( pVBInfo->LCDInfo & LCDNonExpanding )
5011 {
5012 tempax = pVBInfo->VGAHDE ;
5013 tempbx = pVBInfo->VGAVDE ;
5014 }
5015
5016 pVBInfo->HDE = tempax ;
5017 pVBInfo->VDE = tempbx ;
5018 return ;
5019 }
5020
5021 if ( pVBInfo->VBInfo & ( SetCRT2ToTV ) )
5022 {
5023 tempbx = 4 ;
5024 TVPtr = ( XGI_TVDataStruct * )XGI_GetTVPtr( tempbx , ModeNo , ModeIdIndex , RefreshRateTableIndex, pVBInfo ) ;
5025
5026 pVBInfo->RVBHCMAX = TVPtr->RVBHCMAX ;
5027 pVBInfo->RVBHCFACT = TVPtr->RVBHCFACT ;
5028 pVBInfo->VGAHT = TVPtr->VGAHT ;
5029 pVBInfo->VGAVT = TVPtr->VGAVT ;
5030 pVBInfo->HDE = TVPtr->TVHDE ;
5031 pVBInfo->VDE = TVPtr->TVVDE ;
5032 pVBInfo->RVBHRS = TVPtr->RVBHRS ;
5033 pVBInfo->NewFlickerMode = TVPtr->FlickerMode ;
5034
5035 if ( pVBInfo->VBInfo & SetCRT2ToHiVisionTV )
5036 {
5037 if ( resinfo == 0x08 )
5038 pVBInfo->NewFlickerMode = 0x40 ;
5039 else if ( resinfo == 0x09 )
5040 pVBInfo->NewFlickerMode = 0x40 ;
5041 else if ( resinfo == 0x12 )
5042 pVBInfo->NewFlickerMode = 0x40 ;
5043
5044 if ( pVBInfo->VGAVDE == 350 )
5045 pVBInfo->TVInfo |= TVSimuMode ;
5046
5047 tempax = ExtHiTVHT ;
5048 tempbx = ExtHiTVVT ;
5049
5050 if ( pVBInfo->VBInfo & SetInSlaveMode )
5051 {
5052 if ( pVBInfo->TVInfo & TVSimuMode )
5053 {
5054 tempax = StHiTVHT ;
5055 tempbx = StHiTVVT ;
5056
5057 if ( !( modeflag & Charx8Dot ) )
5058 {
5059 tempax = StHiTextTVHT ;
5060 tempbx = StHiTextTVVT ;
5061 }
5062 }
5063 }
5064 }
5065 else if ( pVBInfo->VBInfo & SetCRT2ToYPbPr )
5066 {
5067 if ( pVBInfo->TVInfo & SetYPbPrMode750p )
5068 {
5069 tempax = YPbPrTV750pHT ; /* Ext750pTVHT */
5070 tempbx = YPbPrTV750pVT ; /* Ext750pTVVT */
5071 }
5072
5073 if ( pVBInfo->TVInfo & SetYPbPrMode525p )
5074 {
5075 tempax = YPbPrTV525pHT ; /* Ext525pTVHT */
5076 tempbx = YPbPrTV525pVT ; /* Ext525pTVVT */
5077 }
5078 else if ( pVBInfo->TVInfo & SetYPbPrMode525i )
5079 {
5080 tempax = YPbPrTV525iHT ; /* Ext525iTVHT */
5081 tempbx = YPbPrTV525iVT ; /* Ext525iTVVT */
5082 if ( pVBInfo->TVInfo & NTSC1024x768 )
5083 tempax = NTSC1024x768HT ;
5084 }
5085 }
5086 else
5087 {
5088 tempax = PALHT ;
5089 tempbx = PALVT ;
5090 if ( !( pVBInfo->TVInfo & SetPALTV ) )
5091 {
5092 tempax = NTSCHT ;
5093 tempbx = NTSCVT ;
5094 if ( pVBInfo->TVInfo & NTSC1024x768 )
5095 tempax = NTSC1024x768HT ;
5096 }
5097 }
5098
5099 pVBInfo->HT = tempax ;
5100 pVBInfo->VT = tempbx ;
5101 return ;
5102 }
5103}
5104
5105
5106/* --------------------------------------------------------------------- */
5107/* Function : XGI_SetCRT2VCLK */
5108/* Input : */
5109/* Output : */
5110/* Description : */
5111/* --------------------------------------------------------------------- */
5112void XGI_SetCRT2VCLK( USHORT ModeNo , USHORT ModeIdIndex , USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo )
5113{
5114 UCHAR di_0 ,
5115 di_1 ,
5116 tempal ;
5117
5118 tempal = XGI_GetVCLKPtr( RefreshRateTableIndex , ModeNo , ModeIdIndex, pVBInfo ) ;
5119 XGI_GetVCLKLen( tempal, &di_0 , &di_1, pVBInfo ) ;
5120 XGI_GetLCDVCLKPtr( &di_0 , &di_1, pVBInfo ) ;
5121
5122 if ( pVBInfo->VBType & VB_XGI301 ) /* shampoo 0129 */
5123 { /* 301 */
5124 XGINew_SetReg1(pVBInfo->Part4Port , 0x0A , 0x10 ) ;
5125 XGINew_SetReg1(pVBInfo->Part4Port , 0x0B , di_1 ) ;
5126 XGINew_SetReg1(pVBInfo->Part4Port , 0x0A , di_0 ) ;
5127 }
5128 else
5129 { /* 301b/302b/301lv/302lv */
5130 XGINew_SetReg1( pVBInfo->Part4Port , 0x0A , di_0 ) ;
5131 XGINew_SetReg1( pVBInfo->Part4Port , 0x0B , di_1 ) ;
5132 }
5133
5134 XGINew_SetReg1( pVBInfo->Part4Port , 0x00 , 0x12 ) ;
5135
5136 if ( pVBInfo->VBInfo & SetCRT2ToRAMDAC )
5137 XGINew_SetRegOR( pVBInfo->Part4Port , 0x12 , 0x28 ) ;
5138 else
5139 XGINew_SetRegOR( pVBInfo->Part4Port , 0x12 , 0x08 ) ;
5140}
5141
5142
5143/* --------------------------------------------------------------------- */
5144/* Function : XGI_GETLCDVCLKPtr */
5145/* Input : */
5146/* Output : al -> VCLK Index */
5147/* Description : */
5148/* --------------------------------------------------------------------- */
5149void XGI_GetLCDVCLKPtr( UCHAR* di_0 , UCHAR *di_1, PVB_DEVICE_INFO pVBInfo )
5150{
5151 USHORT index ;
5152
5153 if ( pVBInfo->VBInfo & ( SetCRT2ToLCD | SetCRT2ToLCDA ) )
5154 {
5155 if ( pVBInfo->IF_DEF_ScaleLCD == 1 )
5156 {
5157 if ( pVBInfo->LCDInfo & EnableScalingLCD )
5158 return ;
5159 }
5160
5161 /* index = XGI_GetLCDCapPtr(pVBInfo) ; */
5162 index = XGI_GetLCDCapPtr1( pVBInfo) ;
5163
5164 if ( pVBInfo->VBInfo & SetCRT2ToLCD )
5165 { /* LCDB */
5166 *di_0 = pVBInfo->LCDCapList[ index ].LCUCHAR_VCLKData1 ;
5167 *di_1 = pVBInfo->LCDCapList[ index ].LCUCHAR_VCLKData2 ;
5168 }
5169 else
5170 { /* LCDA */
5171 *di_0 = pVBInfo->LCDCapList[ index ].LCDA_VCLKData1 ;
5172 *di_1 = pVBInfo->LCDCapList[ index ].LCDA_VCLKData2 ;
5173 }
5174 }
5175 return ;
5176}
5177
5178
5179/* --------------------------------------------------------------------- */
5180/* Function : XGI_GetVCLKPtr */
5181/* Input : */
5182/* Output : */
5183/* Description : */
5184/* --------------------------------------------------------------------- */
5185UCHAR XGI_GetVCLKPtr(USHORT RefreshRateTableIndex,USHORT ModeNo,USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo)
5186{
5187
5188 USHORT index ,
5189 modeflag ;
5190#ifndef LINUX_XF86
5191 USHORT tempbx ;
5192#endif
5193
5194 UCHAR tempal ;
5195 UCHAR *CHTVVCLKPtr = NULL ;
5196
5197 if ( ModeNo <= 0x13 )
5198 modeflag = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag ; /* si+St_ResInfo */
5199 else
5200 modeflag = pVBInfo->EModeIDTable[ModeIdIndex].Ext_ModeFlag; /* si+Ext_ResInfo */
5201
5202
5203 if ( ( pVBInfo->SetFlag & ProgrammingCRT2 ) && ( !( pVBInfo->LCDInfo & EnableScalingLCD ) ) )
5204 { /* {LCDA/LCDB} */
5205 index = XGI_GetLCDCapPtr(pVBInfo) ;
5206 tempal = pVBInfo->LCDCapList[ index ].LCD_VCLK ;
5207
5208 if ( pVBInfo->VBInfo & ( SetCRT2ToLCD | SetCRT2ToLCDA ) )
5209 return tempal ;
5210
5211 /* {TV} */
5212 if ( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV| VB_XGI302LV| VB_XGI301C ) )
5213 {
5214 if(pVBInfo->VBInfo&SetCRT2ToHiVisionTV)
5215 {
5216 tempal = HiTVVCLKDIV2;
5217 if(!(pVBInfo->TVInfo & RPLLDIV2XO))
5218 tempal = HiTVVCLK;
5219 if(pVBInfo->TVInfo & TVSimuMode)
5220 {
5221 tempal = HiTVSimuVCLK;
5222 if(!(modeflag & Charx8Dot))
5223 tempal = HiTVTextVCLK;
5224
5225 }
5226 return tempal;
5227 }
5228
5229 if ( pVBInfo->TVInfo & SetYPbPrMode750p )
5230 {
5231 tempal = YPbPr750pVCLK ;
5232 return tempal ;
5233 }
5234
5235 if ( pVBInfo->TVInfo & SetYPbPrMode525p )
5236 {
5237 tempal = YPbPr525pVCLK ;
5238 return tempal ;
5239 }
5240
5241 tempal = NTSC1024VCLK ;
5242
5243 if ( !( pVBInfo->TVInfo & NTSC1024x768 ) )
5244 {
5245 tempal = TVVCLKDIV2 ;
5246 if ( !( pVBInfo->TVInfo & RPLLDIV2XO ) )
5247 tempal = TVVCLK ;
5248 }
5249
5250 if ( pVBInfo->VBInfo & SetCRT2ToTV )
5251 return tempal ;
5252 }
5253 /*else
5254 if((pVBInfo->IF_DEF_CH7017==1)&&(pVBInfo->VBType&VB_CH7017))
5255 {
5256 if(ModeNo<=0x13)
5257 *tempal = pVBInfo->SModeIDTable[ModeIdIndex].St_CRT2CRTC;
5258 else
5259 *tempal = pVBInfo->RefIndex[RefreshRateTableIndex].Ext_CRT2CRTC;
5260 *tempal = *tempal & 0x1F;
5261
5262 tempbx = 0;
5263 if(pVBInfo->TVInfo & SetPALTV)
5264 tempbx = tempbx + 2;
5265 if(pVBInfo->TVInfo & SetCHTVOverScan)
5266 tempbx++;
5267 tempbx = tempbx << 1;
5268 } */
5269 } /* {End of VB} */
5270
5271 if((pVBInfo->IF_DEF_CH7007==1)&&(pVBInfo->VBType&VB_CH7007)) /* [Billy] 07/05/08 CH7007 */
5272 {
5273 /* VideoDebugPrint((0, "XGI_GetVCLKPtr: pVBInfo->IF_DEF_CH7007==1\n")); */
5274 if ( (pVBInfo->VBInfo & SetCRT2ToTV) )
5275 {
5276 if( ModeNo <= 0x13 )
5277 {
5278 tempal = pVBInfo->SModeIDTable[ ModeIdIndex ].St_CRT2CRTC ;
5279 }
5280 else
5281 {
5282 tempal = pVBInfo->RefIndex[RefreshRateTableIndex].Ext_CRT2CRTC;
5283 }
5284
5285 tempal = tempal & 0x0F;
5286 tempbx = 0;
5287
5288 if(pVBInfo->TVInfo & SetPALTV)
5289 {
5290 tempbx = tempbx + 2;
5291 }
5292 if(pVBInfo->TVInfo & SetCHTVOverScan)
5293 {
5294 tempbx++;
5295 }
5296 /** tempbx = tempbx << 1; CH7007 ? **/
5297
5298/*[Billy]07/05/29 CH7007*/
5299 if ( pVBInfo->IF_DEF_CH7007 == 1 )
5300 {
5301 switch( tempbx )
5302 {
5303 case 0:
5304 CHTVVCLKPtr = XGI7007_CHTVVCLKUNTSC ;
5305 break ;
5306 case 1:
5307 CHTVVCLKPtr = XGI7007_CHTVVCLKONTSC ;
5308 break ;
5309 case 2:
5310 CHTVVCLKPtr = XGI7007_CHTVVCLKUPAL ;
5311 break ;
5312 case 3:
5313 CHTVVCLKPtr = XGI7007_CHTVVCLKOPAL ;
5314 break ;
5315 default:
5316 break ;
5317
5318 }
5319 }
5320 /*else
5321 {
5322 switch( tempbx )
5323 {
5324 case 0:
5325 CHTVVCLKPtr = pVBInfo->CHTVVCLKUNTSC ;
5326 break ;
5327 case 1:
5328 CHTVVCLKPtr = pVBInfo->CHTVVCLKONTSC ;
5329 break ;
5330 case 2:
5331 CHTVVCLKPtr = pVBInfo->CHTVVCLKUPAL ;
5332 break ;
5333 case 3:
5334 CHTVVCLKPtr = pVBInfo->CHTVVCLKOPAL ;
5335 break ;
5336 default:
5337 break ;
5338 }
5339 }*/
5340
5341 tempal = CHTVVCLKPtr[ tempal ] ;
5342 return tempal ;
5343 }
5344
5345 }
5346
5347 tempal = ( UCHAR )XGINew_GetReg2( ( pVBInfo->P3ca + 0x02 ) ) ;
5348 tempal = tempal >> 2 ;
5349 tempal &= 0x03 ;
5350
5351 if ( ( pVBInfo->LCDInfo & EnableScalingLCD ) && ( modeflag & Charx8Dot ) ) /* for Dot8 Scaling LCD */
5352 tempal = tempal ^ tempal ; /* ; set to VCLK25MHz always */
5353
5354 if ( ModeNo <= 0x13 )
5355 return tempal ;
5356
5357 tempal = pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_CRTVCLK ;
5358 return tempal ;
5359}
5360
5361
5362/* --------------------------------------------------------------------- */
5363/* Function : XGI_GetVCLKLen */
5364/* Input : */
5365/* Output : */
5366/* Description : */
5367/* --------------------------------------------------------------------- */
5368void XGI_GetVCLKLen(UCHAR tempal,UCHAR* di_0,UCHAR* di_1, PVB_DEVICE_INFO pVBInfo)
5369{
5370 if ( pVBInfo->IF_DEF_CH7007 == 1 ) /* [Billy] 2007/05/16 */
5371 {
5372 /* VideoDebugPrint((0, "XGI_GetVCLKLen: pVBInfo->IF_DEF_CH7007==1\n")); */
5373 *di_0 = ( UCHAR )XGI_CH7007VCLKData[ tempal ].SR2B ;
5374 *di_1 = ( UCHAR )XGI_CH7007VCLKData[ tempal ].SR2C ;
5375 }
5376 else if ( pVBInfo->VBType & ( VB_XGI301 | VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
5377 {
5378 if ( ( !( pVBInfo->VBInfo & SetCRT2ToLCDA ) ) && ( pVBInfo->SetFlag & ProgrammingCRT2 ) )
5379 {
5380 *di_0 = ( UCHAR )XGI_VBVCLKData[ tempal ].SR2B ;
5381 *di_1 = XGI_VBVCLKData[ tempal ].SR2C ;
5382 }
5383 }
5384 else
5385 {
5386 *di_0 = XGI_VCLKData[ tempal ].SR2B ;
5387 *di_1 = XGI_VCLKData[ tempal ].SR2C ;
5388 }
5389}
5390
5391
5392/* --------------------------------------------------------------------- */
5393/* Function : XGI_SetCRT2Offset */
5394/* Input : */
5395/* Output : */
5396/* Description : */
5397/* --------------------------------------------------------------------- */
5398void XGI_SetCRT2Offset( USHORT ModeNo ,
5399 USHORT ModeIdIndex , USHORT RefreshRateTableIndex , PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo )
5400{
5401 USHORT offset ;
5402 UCHAR temp ;
5403
5404 if ( pVBInfo->VBInfo & SetInSlaveMode )
5405 {
5406 return ;
5407 }
5408
5409 offset = XGI_GetOffset( ModeNo , ModeIdIndex , RefreshRateTableIndex , HwDeviceExtension, pVBInfo ) ;
5410 temp = ( UCHAR )( offset & 0xFF ) ;
5411 XGINew_SetReg1( pVBInfo->Part1Port , 0x07 , temp ) ;
5412 temp =( UCHAR)( ( offset & 0xFF00 ) >> 8 ) ;
5413 XGINew_SetReg1( pVBInfo->Part1Port , 0x09 , temp ) ;
5414 temp =( UCHAR )( ( ( offset >> 3 ) & 0xFF ) + 1 ) ;
5415 XGINew_SetReg1( pVBInfo->Part1Port , 0x03 , temp ) ;
5416}
5417
5418
5419/* --------------------------------------------------------------------- */
5420/* Function : XGI_GetOffset */
5421/* Input : */
5422/* Output : */
5423/* Description : */
5424/* --------------------------------------------------------------------- */
5425USHORT XGI_GetOffset(USHORT ModeNo,USHORT ModeIdIndex,USHORT RefreshRateTableIndex,PXGI_HW_DEVICE_INFO HwDeviceExtension,PVB_DEVICE_INFO pVBInfo)
5426{
5427 USHORT temp ,
5428 colordepth ,
5429 modeinfo ,
5430 index ,
5431 infoflag ,
5432 ColorDepth[] = { 0x01 , 0x02 , 0x04 } ;
5433
5434 modeinfo = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeInfo ;
5435 if ( ModeNo <= 0x14 )
5436 infoflag = 0 ;
5437 else
5438 infoflag = pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_InfoFlag ;
5439
5440
5441 index = ( modeinfo >> 8 ) & 0xFF ;
5442
5443 temp = pVBInfo->ScreenOffset[ index ] ;
5444
5445 if ( infoflag & InterlaceMode )
5446 {
5447 temp = temp << 1 ;
5448 }
5449
5450 colordepth = XGI_GetColorDepth( ModeNo , ModeIdIndex, pVBInfo ) ;
5451
5452 if ( ( ModeNo >= 0x7C ) && ( ModeNo <= 0x7E ) )
5453 {
5454 temp = ModeNo - 0x7C ;
5455 colordepth = ColorDepth[ temp ] ;
5456 temp = 0x6B ;
5457 if ( infoflag & InterlaceMode )
5458 {
5459 temp = temp << 1 ;
5460 }
5461 return( temp * colordepth ) ;
5462 }
5463 else
5464 return( temp * colordepth ) ;
5465}
5466
5467
5468/* --------------------------------------------------------------------- */
5469/* Function : XGI_SetCRT2FIFO */
5470/* Input : */
5471/* Output : */
5472/* Description : */
5473/* --------------------------------------------------------------------- */
5474void XGI_SetCRT2FIFO( PVB_DEVICE_INFO pVBInfo)
5475{
5476 XGINew_SetReg1( pVBInfo->Part1Port , 0x01 , 0x3B ) ; /* threshold high ,disable auto threshold */
5477 XGINew_SetRegANDOR( pVBInfo->Part1Port , 0x02 , ~( 0x3F ) , 0x04 ) ; /* threshold low default 04h */
5478}
5479
5480
5481/* --------------------------------------------------------------------- */
5482/* Function : XGI_PreSetGroup1 */
5483/* Input : */
5484/* Output : */
5485/* Description : */
5486/* --------------------------------------------------------------------- */
5487void XGI_PreSetGroup1(USHORT ModeNo , USHORT ModeIdIndex ,PXGI_HW_DEVICE_INFO HwDeviceExtension,
5488 USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo )
5489{
5490 USHORT tempcx = 0 ,
5491 CRT1Index = 0 ,
5492 resinfo = 0 ;
5493
5494 if ( ModeNo > 0x13 )
5495 {
5496 CRT1Index = pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_CRT1CRTC ;
5497 CRT1Index &= IndexMask ;
5498 resinfo = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_RESINFO ;
5499 }
5500
5501 XGI_SetCRT2Offset( ModeNo , ModeIdIndex , RefreshRateTableIndex , HwDeviceExtension, pVBInfo ) ;
5502 XGI_SetCRT2FIFO(pVBInfo) ;
5503 /* XGI_SetCRT2Sync(ModeNo,RefreshRateTableIndex); */
5504
5505 for( tempcx = 4 ; tempcx < 7 ; tempcx++ )
5506 {
5507 XGINew_SetReg1( pVBInfo->Part1Port , tempcx , 0x0 ) ;
5508 }
5509
5510 XGINew_SetReg1( pVBInfo->Part1Port , 0x50 , 0x00 ) ;
5511 XGINew_SetReg1( pVBInfo->Part1Port , 0x02 , 0x44 ) ; /* temp 0206 */
5512}
5513
5514
5515/* --------------------------------------------------------------------- */
5516/* Function : XGI_SetGroup1 */
5517/* Input : */
5518/* Output : */
5519/* Description : */
5520/* --------------------------------------------------------------------- */
5521void XGI_SetGroup1( USHORT ModeNo , USHORT ModeIdIndex ,
5522 PXGI_HW_DEVICE_INFO HwDeviceExtension , USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo )
5523{
5524 USHORT temp = 0 ,
5525 tempax = 0 ,
5526 tempbx = 0 ,
5527 tempcx = 0 ,
5528 pushbx = 0 ,
5529 CRT1Index = 0 ,
5530 modeflag ,
5531 resinfo = 0 ;
5532
5533 if ( ModeNo > 0x13 )
5534 {
5535 CRT1Index = pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_CRT1CRTC ;
5536 CRT1Index &= IndexMask ;
5537 resinfo = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_RESINFO ;
5538 }
5539
5540 if ( ModeNo <= 0x13 )
5541 {
5542 modeflag = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag ;
5543 }
5544 else
5545 {
5546 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag ;
5547 }
5548
5549 /* bainy change table name */
5550 if ( modeflag & HalfDCLK )
5551 {
5552 temp = ( pVBInfo->VGAHT / 2 - 1 ) & 0x0FF ; /* BTVGA2HT 0x08,0x09 */
5553 XGINew_SetReg1( pVBInfo->Part1Port , 0x08 , temp ) ;
5554 temp = ( ( ( pVBInfo->VGAHT / 2 - 1 ) & 0xFF00 ) >> 8 ) << 4 ;
5555 XGINew_SetRegANDOR( pVBInfo->Part1Port , 0x09 , ~0x0F0 , temp ) ;
5556 temp = ( pVBInfo->VGAHDE / 2 + 16 ) & 0x0FF ; /* BTVGA2HDEE 0x0A,0x0C */
5557 XGINew_SetReg1( pVBInfo->Part1Port , 0x0A , temp ) ;
5558 tempcx = ( ( pVBInfo->VGAHT - pVBInfo->VGAHDE ) / 2 ) >> 2 ;
5559 pushbx = pVBInfo->VGAHDE / 2 + 16 ;
5560 tempcx = tempcx >> 1 ;
5561 tempbx = pushbx + tempcx ; /* bx BTVGA@HRS 0x0B,0x0C */
5562 tempcx += tempbx ;
5563
5564 if ( pVBInfo->VBInfo & SetCRT2ToRAMDAC )
5565 {
5566 tempbx = pVBInfo->XGINEWUB_CRT1Table[ CRT1Index ].CR[ 4 ] ;
5567 tempbx |= ( ( pVBInfo->XGINEWUB_CRT1Table[ CRT1Index ].CR[ 14 ] & 0xC0 ) << 2 ) ;
5568 tempbx = ( tempbx - 3 ) << 3 ; /* (VGAHRS-3)*8 */
5569 tempcx = pVBInfo->XGINEWUB_CRT1Table[CRT1Index].CR[ 5 ] ;
5570 tempcx &= 0x1F ;
5571 temp = pVBInfo->XGINEWUB_CRT1Table[ CRT1Index ].CR[ 15 ] ;
5572 temp = ( temp & 0x04 ) << ( 5 - 2 ) ; /* VGAHRE D[5] */
5573 tempcx = ( ( tempcx | temp ) - 3 ) << 3 ; /* (VGAHRE-3)*8 */
5574 }
5575
5576 tempbx += 4 ;
5577 tempcx += 4 ;
5578
5579 if ( tempcx > ( pVBInfo->VGAHT / 2 ) )
5580 tempcx = pVBInfo->VGAHT / 2 ;
5581
5582 temp = tempbx & 0x00FF ;
5583
5584 XGINew_SetReg1( pVBInfo->Part1Port , 0x0B , temp ) ;
5585 }
5586 else
5587 {
5588 temp = ( pVBInfo->VGAHT - 1 ) & 0x0FF ; /* BTVGA2HT 0x08,0x09 */
5589 XGINew_SetReg1( pVBInfo->Part1Port , 0x08 , temp ) ;
5590 temp = ( ( ( pVBInfo->VGAHT - 1 ) & 0xFF00 ) >> 8 ) << 4 ;
5591 XGINew_SetRegANDOR( pVBInfo->Part1Port , 0x09 , ~0x0F0 , temp ) ;
5592 temp = ( pVBInfo->VGAHDE + 16 ) & 0x0FF ; /* BTVGA2HDEE 0x0A,0x0C */
5593 XGINew_SetReg1( pVBInfo->Part1Port , 0x0A , temp ) ;
5594 tempcx = ( pVBInfo->VGAHT - pVBInfo->VGAHDE ) >> 2 ; /* cx */
5595 pushbx = pVBInfo->VGAHDE + 16 ;
5596 tempcx = tempcx >> 1 ;
5597 tempbx = pushbx + tempcx ; /* bx BTVGA@HRS 0x0B,0x0C */
5598 tempcx += tempbx ;
5599
5600 if ( pVBInfo->VBInfo & SetCRT2ToRAMDAC )
5601 {
5602 tempbx = pVBInfo->XGINEWUB_CRT1Table[ CRT1Index ].CR[ 3 ] ;
5603 tempbx |= ( ( pVBInfo->XGINEWUB_CRT1Table[ CRT1Index ].CR[ 5 ] & 0xC0 ) << 2 ) ;
5604 tempbx = ( tempbx - 3 ) << 3 ; /* (VGAHRS-3)*8 */
5605 tempcx = pVBInfo->XGINEWUB_CRT1Table[ CRT1Index ].CR[ 4 ] ;
5606 tempcx &= 0x1F ;
5607 temp = pVBInfo->XGINEWUB_CRT1Table[ CRT1Index ].CR[ 6 ] ;
5608 temp = ( temp & 0x04 ) << ( 5 - 2 ) ; /* VGAHRE D[5] */
5609 tempcx = ( ( tempcx | temp ) - 3 ) << 3 ; /* (VGAHRE-3)*8 */
5610 tempbx += 16 ;
5611 tempcx += 16 ;
5612 }
5613
5614 if ( tempcx > pVBInfo->VGAHT )
5615 tempcx = pVBInfo->VGAHT ;
5616
5617 temp = tempbx & 0x00FF ;
5618 XGINew_SetReg1( pVBInfo->Part1Port , 0x0B , temp ) ;
5619 }
5620
5621 tempax = ( tempax & 0x00FF ) | ( tempbx & 0xFF00 ) ;
5622 tempbx = pushbx ;
5623 tempbx = ( tempbx & 0x00FF ) | ( ( tempbx & 0xFF00 ) << 4 ) ;
5624 tempax |= ( tempbx & 0xFF00 ) ;
5625 temp = ( tempax & 0xFF00 ) >> 8 ;
5626 XGINew_SetReg1( pVBInfo->Part1Port , 0x0C , temp ) ;
5627 temp = tempcx & 0x00FF ;
5628 XGINew_SetReg1( pVBInfo->Part1Port , 0x0D , temp ) ;
5629 tempcx = ( pVBInfo->VGAVT - 1 ) ;
5630 temp = tempcx & 0x00FF ;
5631
5632 if ( pVBInfo->IF_DEF_CH7005 == 1 )
5633 {
5634 if ( pVBInfo->VBInfo & 0x0C )
5635 {
5636 temp-- ;
5637 }
5638 }
5639
5640 XGINew_SetReg1( pVBInfo->Part1Port , 0x0E , temp ) ;
5641 tempbx = pVBInfo->VGAVDE - 1 ;
5642 temp = tempbx & 0x00FF ;
5643 XGINew_SetReg1( pVBInfo->Part1Port , 0x0F , temp ) ;
5644 temp = ( ( tempbx & 0xFF00 ) << 3 ) >> 8 ;
5645 temp |= ( ( tempcx & 0xFF00 ) >> 8 ) ;
5646 XGINew_SetReg1( pVBInfo->Part1Port , 0x12 , temp ) ;
5647
5648 tempax = pVBInfo->VGAVDE ;
5649 tempbx = pVBInfo->VGAVDE ;
5650 tempcx = pVBInfo->VGAVT ;
5651 tempbx = ( pVBInfo->VGAVT + pVBInfo->VGAVDE ) >> 1 ; /* BTVGA2VRS 0x10,0x11 */
5652 tempcx = ( ( pVBInfo->VGAVT - pVBInfo->VGAVDE ) >> 4 ) + tempbx + 1 ; /* BTVGA2VRE 0x11 */
5653
5654 if ( pVBInfo->VBInfo & SetCRT2ToRAMDAC )
5655 {
5656 tempbx = pVBInfo->XGINEWUB_CRT1Table[ CRT1Index ].CR[ 10 ] ;
5657 temp = pVBInfo->XGINEWUB_CRT1Table[ CRT1Index ].CR[ 9 ] ;
5658
5659 if ( temp & 0x04 )
5660 tempbx |= 0x0100 ;
5661
5662 if ( temp & 0x080 )
5663 tempbx |= 0x0200 ;
5664
5665 temp = pVBInfo->XGINEWUB_CRT1Table[ CRT1Index ].CR[ 14 ] ;
5666
5667 if ( temp & 0x08 )
5668 tempbx |= 0x0400 ;
5669
5670 temp = pVBInfo->XGINEWUB_CRT1Table[ CRT1Index ].CR[ 11 ] ;
5671 tempcx = ( tempcx & 0xFF00 ) | ( temp & 0x00FF ) ;
5672 }
5673
5674 temp = tempbx & 0x00FF ;
5675 XGINew_SetReg1( pVBInfo->Part1Port , 0x10 , temp ) ;
5676 temp = ( ( tempbx & 0xFF00 ) >> 8 ) << 4 ;
5677 temp = ( ( tempcx & 0x000F ) | ( temp ) ) ;
5678 XGINew_SetReg1( pVBInfo->Part1Port , 0x11 , temp ) ;
5679 tempax = 0 ;
5680
5681 if ( modeflag & DoubleScanMode )
5682 tempax |= 0x80 ;
5683
5684 if ( modeflag & HalfDCLK )
5685 tempax |= 0x40 ;
5686
5687 XGINew_SetRegANDOR( pVBInfo->Part1Port , 0x2C , ~0x0C0 , tempax ) ;
5688}
5689
5690
5691/* --------------------------------------------------------------------- */
5692/* Function : XGI_SetLockRegs */
5693/* Input : */
5694/* Output : */
5695/* Description : */
5696/* --------------------------------------------------------------------- */
5697void XGI_SetLockRegs( USHORT ModeNo , USHORT ModeIdIndex ,
5698 PXGI_HW_DEVICE_INFO HwDeviceExtension , USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo )
5699{
5700 USHORT push1 ,
5701 push2 ,
5702 tempax ,
5703 tempbx = 0 ,
5704 tempcx ,
5705 temp ,
5706 resinfo ,
5707 modeflag ,
5708 CRT1Index ;
5709
5710 if ( ModeNo <= 0x13 )
5711 {
5712 modeflag = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag ; /* si+St_ResInfo */
5713 resinfo = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ResInfo ;
5714 }
5715 else
5716 {
5717 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag ; /* si+Ext_ResInfo */
5718 resinfo = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_RESINFO ;
5719 CRT1Index = pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_CRT1CRTC ;
5720 CRT1Index &= IndexMask;
5721 }
5722
5723 if ( !( pVBInfo->VBInfo & SetInSlaveMode ) )
5724 {
5725 return ;
5726 }
5727
5728 temp = 0xFF ; /* set MAX HT */
5729 XGINew_SetReg1( pVBInfo->Part1Port , 0x03 , temp ) ;
5730 /* if ( modeflag & Charx8Dot ) tempcx = 0x08 ; */
5731 /* else */
5732 tempcx=0x08;
5733
5734 if ( pVBInfo->VBType & ( VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
5735 modeflag |= Charx8Dot ;
5736
5737 tempax = pVBInfo->VGAHDE ; /* 0x04 Horizontal Display End */
5738
5739 if ( modeflag & HalfDCLK )
5740 tempax = tempax >> 1 ;
5741
5742 tempax = ( tempax / tempcx ) - 1 ;
5743 tempbx |= ( ( tempax & 0x00FF ) << 8 ) ;
5744 temp = tempax & 0x00FF ;
5745 XGINew_SetReg1( pVBInfo->Part1Port , 0x04 , temp ) ;
5746
5747 temp = ( tempbx & 0xFF00 ) >> 8 ;
5748
5749 if ( pVBInfo->VBInfo & SetCRT2ToTV )
5750 {
5751 if ( !( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) ) )
5752 temp += 2 ;
5753
5754 if ( pVBInfo->VBInfo & SetCRT2ToHiVisionTV )
5755 {
5756 if ( pVBInfo->VBType & VB_XGI301LV )
5757 {
5758 if ( pVBInfo->VBExtInfo == VB_YPbPr1080i )
5759 {
5760 if ( resinfo == 7 )
5761 temp -= 2 ;
5762 }
5763 }
5764 else
5765 if ( resinfo == 7 )
5766 temp -= 2 ;
5767 }
5768 }
5769
5770 XGINew_SetReg1( pVBInfo->Part1Port , 0x05 , temp ) ; /* 0x05 Horizontal Display Start */
5771 XGINew_SetReg1( pVBInfo->Part1Port , 0x06 , 0x03 ) ; /* 0x06 Horizontal Blank end */
5772
5773 if ( !( pVBInfo->VBInfo & DisableCRT2Display ) )
5774 { /* 030226 bainy */
5775 if ( pVBInfo->VBInfo & SetCRT2ToTV )
5776 tempax = pVBInfo->VGAHT ;
5777 else
5778 tempax = XGI_GetVGAHT2( pVBInfo) ;
5779 }
5780
5781 if ( tempax >= pVBInfo->VGAHT )
5782 {
5783 tempax = pVBInfo->VGAHT ;
5784 }
5785
5786 if ( modeflag & HalfDCLK )
5787 {
5788 tempax = tempax >> 1 ;
5789 }
5790
5791 tempax = ( tempax / tempcx ) - 5 ;
5792 tempcx = tempax ; /* 20030401 0x07 horizontal Retrace Start */
5793 if ( pVBInfo->VBInfo & SetCRT2ToHiVisionTV )
5794 {
5795 temp = ( tempbx & 0x00FF ) - 1 ;
5796 if ( !( modeflag & HalfDCLK ) )
5797 {
5798 temp -= 6 ;
5799 if ( pVBInfo->TVInfo & TVSimuMode )
5800 {
5801 temp -= 4 ;
5802 if ( ModeNo > 0x13 )
5803 temp -= 10 ;
5804 }
5805 }
5806 }
5807 else
5808 {
5809 /* tempcx = tempbx & 0x00FF ; */
5810 tempbx = ( tempbx & 0xFF00 ) >> 8 ;
5811 tempcx = ( tempcx + tempbx ) >> 1 ;
5812 temp = ( tempcx & 0x00FF ) + 2 ;
5813
5814 if ( pVBInfo->VBInfo & SetCRT2ToTV )
5815 {
5816 temp -= 1 ;
5817 if ( !( modeflag & HalfDCLK ) )
5818 {
5819 if ( ( modeflag & Charx8Dot ) )
5820 {
5821 temp += 4 ;
5822 if ( pVBInfo->VGAHDE >= 800 )
5823 {
5824 temp -= 6 ;
5825 }
5826 }
5827 }
5828 }
5829 else
5830 {
5831 if ( !( modeflag & HalfDCLK ) )
5832 {
5833 temp -= 4 ;
5834 if ( pVBInfo->LCDResInfo != Panel1280x960 )
5835 {
5836 if( pVBInfo->VGAHDE >= 800 )
5837 {
5838 temp -= 7 ;
5839 if ( pVBInfo->ModeType == ModeEGA )
5840 {
5841 if ( pVBInfo->VGAVDE == 1024 )
5842 {
5843 temp += 15 ;
5844 if ( pVBInfo->LCDResInfo != Panel1280x1024 )
5845 {
5846 temp += 7 ;
5847 }
5848 }
5849 }
5850
5851 if ( pVBInfo->VGAHDE >= 1280 )
5852 {
5853 if ( pVBInfo->LCDResInfo != Panel1280x960 )
5854 {
5855 if ( pVBInfo->LCDInfo & LCDNonExpanding )
5856 {
5857 temp += 28 ;
5858 }
5859 }
5860 }
5861 }
5862 }
5863 }
5864 }
5865 }
5866
5867 XGINew_SetReg1( pVBInfo->Part1Port , 0x07 , temp ) ; /* 0x07 Horizontal Retrace Start */
5868 XGINew_SetReg1( pVBInfo->Part1Port , 0x08 , 0 ) ; /* 0x08 Horizontal Retrace End */
5869
5870 if ( pVBInfo->VBInfo & SetCRT2ToTV )
5871 {
5872 if ( pVBInfo->TVInfo & TVSimuMode )
5873 {
5874 if ( ( ModeNo == 0x06 ) || ( ModeNo == 0x10 ) || ( ModeNo == 0x11 ) || ( ModeNo == 0x13 ) || ( ModeNo == 0x0F ) )
5875 {
5876 XGINew_SetReg1( pVBInfo->Part1Port , 0x07 , 0x5b ) ;
5877 XGINew_SetReg1( pVBInfo->Part1Port , 0x08 , 0x03 ) ;
5878 }
5879
5880 if ( ( ModeNo == 0x00 ) || ( ModeNo == 0x01 ) )
5881 {
5882 if ( pVBInfo->TVInfo & SetNTSCTV )
5883 {
5884 XGINew_SetReg1( pVBInfo->Part1Port , 0x07 , 0x2A ) ;
5885 XGINew_SetReg1( pVBInfo->Part1Port , 0x08 , 0x61 ) ;
5886 }
5887 else
5888 {
5889 XGINew_SetReg1( pVBInfo->Part1Port , 0x07 , 0x2A ) ;
5890 XGINew_SetReg1( pVBInfo->Part1Port , 0x08 , 0x41 ) ;
5891 XGINew_SetReg1( pVBInfo->Part1Port , 0x0C , 0xF0 ) ;
5892 }
5893 }
5894
5895 if ( ( ModeNo == 0x02 ) || ( ModeNo == 0x03 ) || ( ModeNo == 0x07 ) )
5896 {
5897 if ( pVBInfo->TVInfo & SetNTSCTV )
5898 {
5899 XGINew_SetReg1( pVBInfo->Part1Port , 0x07 , 0x54 ) ;
5900 XGINew_SetReg1( pVBInfo->Part1Port , 0x08 , 0x00 ) ;
5901 }
5902 else
5903 {
5904 XGINew_SetReg1( pVBInfo->Part1Port , 0x07 , 0x55 ) ;
5905 XGINew_SetReg1( pVBInfo->Part1Port , 0x08 , 0x00 ) ;
5906 XGINew_SetReg1( pVBInfo->Part1Port , 0x0C , 0xF0 ) ;
5907 }
5908 }
5909
5910 if ( ( ModeNo == 0x04 ) || ( ModeNo == 0x05 ) || ( ModeNo == 0x0D ) || ( ModeNo == 0x50 ) )
5911 {
5912 if ( pVBInfo->TVInfo & SetNTSCTV )
5913 {
5914 XGINew_SetReg1( pVBInfo->Part1Port , 0x07 , 0x30 ) ;
5915 XGINew_SetReg1( pVBInfo->Part1Port , 0x08 , 0x03 ) ;
5916 }
5917 else
5918 {
5919 XGINew_SetReg1( pVBInfo->Part1Port , 0x07 , 0x2f ) ;
5920 XGINew_SetReg1( pVBInfo->Part1Port , 0x08 , 0x02 ) ;
5921 }
5922 }
5923 }
5924 }
5925
5926 XGINew_SetReg1( pVBInfo->Part1Port , 0x18 , 0x03 ) ; /* 0x18 SR0B */
5927 XGINew_SetRegANDOR( pVBInfo->Part1Port , 0x19 , 0xF0 , 0x00 ) ;
5928 XGINew_SetReg1( pVBInfo->Part1Port , 0x09 , 0xFF ) ; /* 0x09 Set Max VT */
5929
5930 tempbx = pVBInfo->VGAVT ;
5931 push1 = tempbx ;
5932 tempcx = 0x121 ;
5933 tempbx = pVBInfo->VGAVDE ; /* 0x0E Virtical Display End */
5934
5935 if ( tempbx == 357 )
5936 tempbx = 350 ;
5937 if ( tempbx == 360 )
5938 tempbx =350 ;
5939 if ( tempbx == 375 )
5940 tempbx = 350 ;
5941 if ( tempbx == 405 )
5942 tempbx = 400 ;
5943 if ( tempbx == 525 )
5944 tempbx = 480 ;
5945
5946 push2 = tempbx ;
5947
5948 if ( pVBInfo->VBInfo & SetCRT2ToLCD )
5949 {
5950 if ( pVBInfo->LCDResInfo == Panel1024x768 )
5951 {
5952 if ( !( pVBInfo->LCDInfo & LCDVESATiming ) )
5953 {
5954 if ( tempbx == 350 )
5955 tempbx += 5 ;
5956 if ( tempbx == 480 )
5957 tempbx += 5 ;
5958 }
5959 }
5960 }
5961 tempbx-- ;
5962 temp = tempbx & 0x00FF ;
5963 tempbx-- ;
5964 temp = tempbx & 0x00FF ;
5965 XGINew_SetReg1( pVBInfo->Part1Port , 0x10 ,temp ) ; /* 0x10 vertical Blank Start */
5966 tempbx = push2 ;
5967 tempbx-- ;
5968 temp = tempbx & 0x00FF ;
5969 XGINew_SetReg1( pVBInfo->Part1Port , 0x0E , temp ) ;
5970
5971 if ( tempbx & 0x0100 )
5972 {
5973 tempcx |= 0x0002 ;
5974 }
5975
5976 tempax = 0x000B ;
5977
5978 if ( modeflag & DoubleScanMode )
5979 {
5980 tempax |= 0x08000 ;
5981 }
5982
5983 if ( tempbx & 0x0200 )
5984 {
5985 tempcx |= 0x0040 ;
5986 }
5987
5988 temp = ( tempax & 0xFF00 ) >> 8 ;
5989 XGINew_SetReg1( pVBInfo->Part1Port , 0x0B , temp ) ;
5990
5991 if ( tempbx & 0x0400 )
5992 {
5993 tempcx |= 0x0600 ;
5994 }
5995
5996 XGINew_SetReg1( pVBInfo->Part1Port , 0x11 , 0x00 ) ; /* 0x11 Vertival Blank End */
5997
5998 tempax = push1 ;
5999 tempax -= tempbx ; /* 0x0C Vertical Retrace Start */
6000 tempax = tempax >> 2 ;
6001 push1 = tempax ; /* push ax */
6002
6003 if ( resinfo != 0x09 )
6004 {
6005 tempax = tempax << 1 ;
6006 tempbx += tempax ;
6007 }
6008
6009 if ( pVBInfo->VBInfo & SetCRT2ToHiVisionTV )
6010 {
6011 if ( pVBInfo->VBType & VB_XGI301LV )
6012 {
6013 if ( pVBInfo->TVInfo & SetYPbPrMode1080i )
6014 tempbx -= 10 ;
6015 else
6016 {
6017 if ( pVBInfo->TVInfo & TVSimuMode )
6018 {
6019 if ( pVBInfo->TVInfo & SetPALTV )
6020 {
6021 if ( pVBInfo->VBType & VB_XGI301LV )
6022 {
6023 if ( !( pVBInfo->TVInfo & ( SetYPbPrMode525p | SetYPbPrMode750p | SetYPbPrMode1080i ) ) )
6024 tempbx += 40 ;
6025 }
6026 else
6027 tempbx += 40 ;
6028 }
6029 }
6030 }
6031 }
6032 else
6033 tempbx -= 10 ;
6034 }
6035 else
6036 {
6037 if ( pVBInfo->TVInfo & TVSimuMode )
6038 {
6039 if ( pVBInfo->TVInfo & SetPALTV )
6040 {
6041 if ( pVBInfo->VBType & VB_XGI301LV )
6042 {
6043 if ( !( pVBInfo->TVInfo & ( SetYPbPrMode525p | SetYPbPrMode750p | SetYPbPrMode1080i ) ) )
6044 tempbx += 40 ;
6045 }
6046 else
6047 tempbx += 40 ;
6048 }
6049 }
6050 }
6051 tempax = push1 ;
6052 tempax = tempax >> 2 ;
6053 tempax++ ;
6054 tempax += tempbx ;
6055 push1 = tempax ; /* push ax */
6056
6057 if ( ( pVBInfo->TVInfo & SetPALTV ) )
6058 {
6059 if ( tempbx <= 513 )
6060 {
6061 if ( tempax >= 513 )
6062 {
6063 tempbx = 513 ;
6064 }
6065 }
6066 }
6067
6068 temp = tempbx & 0x00FF ;
6069 XGINew_SetReg1( pVBInfo->Part1Port , 0x0C , temp ) ;
6070 tempbx-- ;
6071 temp = tempbx & 0x00FF ;
6072 XGINew_SetReg1( pVBInfo->Part1Port , 0x10 , temp ) ;
6073
6074 if ( tempbx & 0x0100 )
6075 {
6076 tempcx |= 0x0008 ;
6077 }
6078
6079 if ( tempbx & 0x0200 )
6080 {
6081 XGINew_SetRegANDOR( pVBInfo->Part1Port , 0x0B , 0x0FF , 0x20 ) ;
6082 }
6083
6084 tempbx++ ;
6085
6086 if ( tempbx & 0x0100 )
6087 {
6088 tempcx |= 0x0004 ;
6089 }
6090
6091 if ( tempbx & 0x0200 )
6092 {
6093 tempcx |= 0x0080 ;
6094 }
6095
6096 if ( tempbx & 0x0400 )
6097 {
6098 tempcx |= 0x0C00 ;
6099 }
6100
6101 tempbx = push1 ; /* pop ax */
6102 temp = tempbx & 0x00FF ;
6103 temp &= 0x0F ;
6104 XGINew_SetReg1( pVBInfo->Part1Port , 0x0D , temp ) ; /* 0x0D vertical Retrace End */
6105
6106 if ( tempbx & 0x0010 )
6107 {
6108 tempcx |= 0x2000 ;
6109 }
6110
6111 temp = tempcx & 0x00FF ;
6112 XGINew_SetReg1( pVBInfo->Part1Port , 0x0A , temp ) ; /* 0x0A CR07 */
6113 temp = ( tempcx & 0x0FF00 ) >> 8 ;
6114 XGINew_SetReg1( pVBInfo->Part1Port , 0x17 , temp ) ; /* 0x17 SR0A */
6115 tempax = modeflag ;
6116 temp = ( tempax & 0xFF00 ) >> 8 ;
6117
6118 temp = ( temp >> 1 ) & 0x09 ;
6119
6120 if ( pVBInfo->VBType & ( VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
6121 temp |= 0x01 ;
6122
6123 XGINew_SetReg1( pVBInfo->Part1Port , 0x16 , temp ) ; /* 0x16 SR01 */
6124 XGINew_SetReg1( pVBInfo->Part1Port , 0x0F , 0 ) ; /* 0x0F CR14 */
6125 XGINew_SetReg1( pVBInfo->Part1Port , 0x12 , 0 ) ; /* 0x12 CR17 */
6126
6127 if ( pVBInfo->LCDInfo & LCDRGB18Bit )
6128 temp = 0x80 ;
6129 else
6130 temp = 0x00 ;
6131
6132 XGINew_SetReg1( pVBInfo->Part1Port , 0x1A , temp ) ; /* 0x1A SR0E */
6133
6134 return ;
6135}
6136
6137
6138/* --------------------------------------------------------------------- */
6139/* Function : XGI_SetGroup2 */
6140/* Input : */
6141/* Output : */
6142/* Description : */
6143/* --------------------------------------------------------------------- */
6144void XGI_SetGroup2( USHORT ModeNo, USHORT ModeIdIndex, USHORT RefreshRateTableIndex,
6145 PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo )
6146{
6147 USHORT i ,
6148 j ,
6149 tempax ,
6150 tempbx ,
6151 tempcx ,
6152 temp ,
6153 push1 ,
6154 push2 ,
6155 modeflag ,
6156 resinfo ,
6157 crt2crtc ;
6158 UCHAR *TimingPoint ;
6159
6160 ULONG longtemp ,
6161 tempeax ,
6162 tempebx ,
6163 temp2 ,
6164 tempecx ;
6165
6166 if ( ModeNo <= 0x13 )
6167 {
6168 modeflag = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag ; /* si+St_ResInfo */
6169 resinfo = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ResInfo ;
6170 crt2crtc = pVBInfo->SModeIDTable[ ModeIdIndex ].St_CRT2CRTC ;
6171 }
6172 else
6173 {
6174 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag ; /* si+Ext_ResInfo */
6175 resinfo = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_RESINFO ;
6176 crt2crtc = pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_CRT2CRTC ;
6177 }
6178
6179 tempax = 0 ;
6180
6181 if ( !( pVBInfo->VBInfo & SetCRT2ToAVIDEO ) )
6182 tempax |= 0x0800 ;
6183
6184 if ( !( pVBInfo->VBInfo & SetCRT2ToSVIDEO ) )
6185 tempax |= 0x0400 ;
6186
6187 if ( pVBInfo->VBInfo & SetCRT2ToSCART )
6188 tempax |= 0x0200 ;
6189
6190 if ( !( pVBInfo->TVInfo & SetPALTV ) )
6191 tempax |= 0x1000 ;
6192
6193 if ( pVBInfo->VBInfo & SetCRT2ToHiVisionTV )
6194 tempax |= 0x0100 ;
6195
6196 if ( pVBInfo->TVInfo & ( SetYPbPrMode525p | SetYPbPrMode750p ) )
6197 tempax &= 0xfe00 ;
6198
6199 tempax = ( tempax & 0xff00 ) >> 8 ;
6200
6201 XGINew_SetReg1( pVBInfo->Part2Port , 0x0 , tempax ) ;
6202 TimingPoint = pVBInfo->NTSCTiming ;
6203
6204 if ( pVBInfo->TVInfo & SetPALTV )
6205 {
6206 TimingPoint = pVBInfo->PALTiming ;
6207 }
6208
6209 if ( pVBInfo->VBInfo & SetCRT2ToHiVisionTV )
6210 {
6211 TimingPoint = pVBInfo->HiTVExtTiming ;
6212
6213 if ( pVBInfo->VBInfo & SetInSlaveMode )
6214 TimingPoint = pVBInfo->HiTVSt2Timing ;
6215
6216 if ( pVBInfo->SetFlag & TVSimuMode )
6217 TimingPoint = pVBInfo->HiTVSt1Timing ;
6218
6219 if ( !(modeflag & Charx8Dot) )
6220 TimingPoint = pVBInfo->HiTVTextTiming ;
6221 }
6222
6223 if ( pVBInfo->VBInfo & SetCRT2ToYPbPr )
6224 {
6225 if ( pVBInfo->TVInfo & SetYPbPrMode525i )
6226 TimingPoint = pVBInfo->YPbPr525iTiming ;
6227
6228 if ( pVBInfo->TVInfo & SetYPbPrMode525p )
6229 TimingPoint = pVBInfo->YPbPr525pTiming ;
6230
6231 if ( pVBInfo->TVInfo & SetYPbPrMode750p )
6232 TimingPoint = pVBInfo->YPbPr750pTiming ;
6233 }
6234
6235 for( i = 0x01 , j = 0 ; i <= 0x2D ; i++ , j++ )
6236 {
6237 XGINew_SetReg1( pVBInfo->Part2Port , i , TimingPoint[ j ] ) ;
6238 }
6239
6240 for( i = 0x39 ; i <= 0x45 ; i++ , j++ )
6241 {
6242 XGINew_SetReg1( pVBInfo->Part2Port , i , TimingPoint[ j ] ) ; /* di->temp2[j] */
6243 }
6244
6245 if ( pVBInfo->VBInfo & SetCRT2ToTV )
6246 {
6247 XGINew_SetRegANDOR( pVBInfo->Part2Port , 0x3A , 0x1F , 0x00 ) ;
6248 }
6249
6250 temp = pVBInfo->NewFlickerMode ;
6251 temp &= 0x80 ;
6252 XGINew_SetRegANDOR( pVBInfo->Part2Port , 0x0A , 0xFF , temp ) ;
6253
6254 if ( pVBInfo->VBInfo & SetCRT2ToHiVisionTV )
6255 tempax = 950 ;
6256
6257 if ( pVBInfo->TVInfo & SetPALTV )
6258 tempax = 520 ;
6259 else
6260 tempax = 440 ;
6261
6262 if ( pVBInfo->VDE <= tempax )
6263 {
6264 tempax -= pVBInfo->VDE ;
6265 tempax = tempax >> 2 ;
6266 tempax = ( tempax & 0x00FF ) | ( ( tempax & 0x00FF ) << 8 ) ;
6267 push1 = tempax ;
6268 temp = ( tempax & 0xFF00 ) >> 8 ;
6269 temp += ( USHORT )TimingPoint[ 0 ] ;
6270
6271 if ( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
6272 {
6273 if ( pVBInfo->VBInfo & ( SetCRT2ToAVIDEO | SetCRT2ToSVIDEO | SetCRT2ToSCART | SetCRT2ToYPbPr ) )
6274 {
6275 tempcx=pVBInfo->VGAHDE;
6276 if ( tempcx >= 1024 )
6277 {
6278 temp = 0x17 ; /* NTSC */
6279 if ( pVBInfo->TVInfo & SetPALTV )
6280 temp = 0x19 ; /* PAL */
6281 }
6282 }
6283 }
6284
6285 XGINew_SetReg1( pVBInfo->Part2Port , 0x01 , temp ) ;
6286 tempax = push1 ;
6287 temp = ( tempax & 0xFF00 ) >> 8 ;
6288 temp += TimingPoint[ 1 ] ;
6289
6290 if ( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
6291 {
6292 if ( ( pVBInfo->VBInfo & ( SetCRT2ToAVIDEO | SetCRT2ToSVIDEO | SetCRT2ToSCART | SetCRT2ToYPbPr ) ) )
6293 {
6294 tempcx = pVBInfo->VGAHDE ;
6295 if ( tempcx >= 1024 )
6296 {
6297 temp = 0x1D ; /* NTSC */
6298 if ( pVBInfo->TVInfo & SetPALTV )
6299 temp = 0x52 ; /* PAL */
6300 }
6301 }
6302 }
6303 XGINew_SetReg1( pVBInfo->Part2Port , 0x02 , temp ) ;
6304 }
6305
6306 /* 301b */
6307 tempcx = pVBInfo->HT ;
6308
6309 if ( XGI_IsLCDDualLink( pVBInfo ) )
6310 tempcx = tempcx >> 1 ;
6311
6312 tempcx -= 2 ;
6313 temp = tempcx & 0x00FF ;
6314 XGINew_SetReg1( pVBInfo->Part2Port , 0x1B , temp ) ;
6315
6316 temp = ( tempcx & 0xFF00 ) >> 8 ;
6317 XGINew_SetRegANDOR( pVBInfo->Part2Port , 0x1D , ~0x0F , temp ) ;
6318
6319 tempcx = pVBInfo->HT >> 1 ;
6320 push1 = tempcx ; /* push cx */
6321 tempcx += 7 ;
6322
6323 if ( pVBInfo->VBInfo & SetCRT2ToHiVisionTV )
6324 {
6325 tempcx -= 4 ;
6326 }
6327
6328 temp = tempcx & 0x00FF ;
6329 temp = temp << 4 ;
6330 XGINew_SetRegANDOR( pVBInfo->Part2Port , 0x22 , 0x0F , temp ) ;
6331
6332 tempbx = TimingPoint[ j ] | ( ( TimingPoint[ j + 1 ] ) << 8 ) ;
6333 tempbx += tempcx ;
6334 push2 = tempbx ;
6335 temp = tempbx & 0x00FF ;
6336 XGINew_SetReg1( pVBInfo->Part2Port , 0x24 , temp ) ;
6337 temp = ( tempbx & 0xFF00 ) >> 8 ;
6338 temp = temp << 4 ;
6339 XGINew_SetRegANDOR(pVBInfo->Part2Port,0x25,0x0F,temp);
6340
6341 tempbx=push2;
6342 tempbx=tempbx+8;
6343 if ( pVBInfo->VBInfo & SetCRT2ToHiVisionTV )
6344 {
6345 tempbx=tempbx-4;
6346 tempcx=tempbx;
6347 }
6348
6349 temp = ( tempbx & 0x00FF ) << 4 ;
6350 XGINew_SetRegANDOR( pVBInfo->Part2Port , 0x29 , 0x0F , temp ) ;
6351
6352 j += 2 ;
6353 tempcx += ( TimingPoint[ j ] | ( ( TimingPoint[ j + 1 ] ) << 8 ) ) ;
6354 temp = tempcx & 0x00FF ;
6355 XGINew_SetReg1( pVBInfo->Part2Port , 0x27 , temp ) ;
6356 temp = ( ( tempcx & 0xFF00 ) >> 8 ) << 4 ;
6357 XGINew_SetRegANDOR( pVBInfo->Part2Port , 0x28 , 0x0F , temp ) ;
6358
6359 tempcx += 8 ;
6360 if ( pVBInfo->VBInfo & SetCRT2ToHiVisionTV )
6361 {
6362 tempcx -= 4 ;
6363 }
6364
6365 temp = tempcx & 0xFF ;
6366 temp = temp << 4 ;
6367 XGINew_SetRegANDOR( pVBInfo->Part2Port , 0x2A , 0x0F , temp ) ;
6368
6369 tempcx = push1 ; /* pop cx */
6370 j += 2 ;
6371 temp = TimingPoint[ j ] | ( ( TimingPoint[ j + 1 ] ) << 8 ) ;
6372 tempcx -= temp ;
6373 temp = tempcx & 0x00FF ;
6374 temp = temp << 4 ;
6375 XGINew_SetRegANDOR( pVBInfo->Part2Port , 0x2D , 0x0F ,temp ) ;
6376
6377 tempcx -= 11 ;
6378
6379 if ( !( pVBInfo->VBInfo & SetCRT2ToTV ) )
6380 {
6381 tempax = XGI_GetVGAHT2( pVBInfo) ;
6382 tempcx = tempax - 1 ;
6383 }
6384 temp = tempcx & 0x00FF ;
6385 XGINew_SetReg1( pVBInfo->Part2Port , 0x2E , temp ) ;
6386
6387 tempbx = pVBInfo->VDE ;
6388
6389 if ( pVBInfo->VGAVDE == 360 )
6390 tempbx = 746 ;
6391 if ( pVBInfo->VGAVDE == 375 )
6392 tempbx = 746 ;
6393 if ( pVBInfo->VGAVDE == 405 )
6394 tempbx = 853 ;
6395
6396 if ( pVBInfo->VBInfo & SetCRT2ToTV )
6397 {
6398 if ( pVBInfo->VBType & ( VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
6399 {
6400 if ( !( pVBInfo->TVInfo & ( SetYPbPrMode525p | SetYPbPrMode750p ) ) )
6401 tempbx = tempbx >> 1 ;
6402 }
6403 else
6404 tempbx = tempbx >> 1 ;
6405 }
6406
6407 tempbx -= 2 ;
6408 temp = tempbx & 0x00FF ;
6409
6410 if ( pVBInfo->VBInfo & SetCRT2ToHiVisionTV )
6411 {
6412 if ( pVBInfo->VBType & VB_XGI301LV )
6413 {
6414 if ( pVBInfo->TVInfo & SetYPbPrMode1080i )
6415 {
6416 if ( pVBInfo->VBInfo & SetInSlaveMode )
6417 {
6418 if ( ModeNo == 0x2f )
6419 temp += 1 ;
6420 }
6421 }
6422 }
6423 else
6424 {
6425 if ( pVBInfo->VBInfo & SetInSlaveMode )
6426 {
6427 if ( ModeNo == 0x2f )
6428 temp += 1 ;
6429 }
6430 }
6431 }
6432
6433 XGINew_SetReg1( pVBInfo->Part2Port , 0x2F , temp ) ;
6434
6435 temp = ( tempcx & 0xFF00 ) >> 8 ;
6436 temp |= ( ( tempbx & 0xFF00 ) >> 8 ) << 6 ;
6437
6438 if ( !( pVBInfo->VBInfo & SetCRT2ToHiVisionTV ) )
6439 {
6440 if ( pVBInfo->VBType & VB_XGI301LV )
6441 {
6442 if ( pVBInfo->TVInfo & SetYPbPrMode1080i )
6443 {
6444 temp |= 0x10 ;
6445
6446 if ( !( pVBInfo->VBInfo & SetCRT2ToSVIDEO ) )
6447 temp |= 0x20 ;
6448 }
6449 }
6450 else
6451 {
6452 temp |= 0x10 ;
6453 if ( !( pVBInfo->VBInfo & SetCRT2ToSVIDEO ) )
6454 temp |= 0x20 ;
6455 }
6456 }
6457
6458 XGINew_SetReg1( pVBInfo->Part2Port , 0x30 , temp ) ;
6459
6460 if ( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) ) /* TV gatingno */
6461 {
6462 tempbx = pVBInfo->VDE ;
6463 tempcx = tempbx - 2 ;
6464
6465 if ( pVBInfo->VBInfo & SetCRT2ToTV )
6466 {
6467 if ( !( pVBInfo->TVInfo & ( SetYPbPrMode525p | SetYPbPrMode750p ) ) )
6468 tempbx = tempbx >> 1 ;
6469 }
6470
6471 if ( pVBInfo->VBType & ( VB_XGI302LV | VB_XGI301C ) )
6472 {
6473 temp=0;
6474 if( tempcx & 0x0400 )
6475 temp |= 0x20 ;
6476
6477 if ( tempbx & 0x0400 )
6478 temp |= 0x40 ;
6479
6480 XGINew_SetReg1( pVBInfo->Part4Port , 0x10 , temp ) ;
6481 }
6482
6483 temp = ( ( ( tempbx - 3 ) & 0x0300 ) >> 8 ) << 5 ;
6484 XGINew_SetReg1( pVBInfo->Part2Port , 0x46 , temp ) ;
6485 temp = ( tempbx - 3 ) & 0x00FF ;
6486 XGINew_SetReg1( pVBInfo->Part2Port , 0x47 , temp ) ;
6487 }
6488
6489 tempbx = tempbx & 0x00FF ;
6490
6491 if ( !( modeflag & HalfDCLK ) )
6492 {
6493 tempcx = pVBInfo->VGAHDE ;
6494 if ( tempcx >= pVBInfo->HDE )
6495 {
6496 tempbx |= 0x2000 ;
6497 tempax &= 0x00FF ;
6498 }
6499 }
6500
6501 tempcx = 0x0101 ;
6502
6503 if( pVBInfo->VBInfo & SetCRT2ToTV ) { /*301b*/
6504 if(pVBInfo->VGAHDE>=1024)
6505 {
6506 tempcx=0x1920;
6507 if(pVBInfo->VGAHDE>=1280)
6508 {
6509 tempcx=0x1420;
6510 tempbx=tempbx&0xDFFF;
6511 }
6512 }
6513 }
6514
6515 if ( !( tempbx & 0x2000 ) )
6516 {
6517 if ( modeflag & HalfDCLK )
6518 {
6519 tempcx = ( tempcx & 0xFF00 ) | ( ( tempcx & 0x00FF ) << 1 ) ;
6520 }
6521
6522 push1 = tempbx ;
6523 tempeax = pVBInfo->VGAHDE ;
6524 tempebx = ( tempcx & 0xFF00 ) >> 8 ;
6525 longtemp = tempeax * tempebx ;
6526 tempecx = tempcx & 0x00FF ;
6527 longtemp = longtemp / tempecx ;
6528
6529 /* 301b */
6530 tempecx = 8 * 1024 ;
6531
6532 if ( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
6533 {
6534 tempecx = tempecx * 8 ;
6535 }
6536
6537 longtemp = longtemp * tempecx ;
6538 tempecx = pVBInfo->HDE ;
6539 temp2 = longtemp % tempecx ;
6540 tempeax = longtemp / tempecx ;
6541 if ( temp2 != 0 )
6542 {
6543 tempeax += 1 ;
6544 }
6545
6546 tempax = ( USHORT )tempeax ;
6547
6548 /* 301b */
6549 if ( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
6550 {
6551 tempcx = ( ( tempax & 0xFF00 ) >> 5 ) >> 8 ;
6552 }
6553 /* end 301b */
6554
6555 tempbx = push1 ;
6556 tempbx =( USHORT )( ( ( tempeax & 0x0000FF00 ) & 0x1F00 ) | ( tempbx & 0x00FF ) ) ;
6557 tempax =( USHORT )( ( ( tempeax & 0x000000FF ) << 8 ) | ( tempax & 0x00FF ) ) ;
6558 temp = ( tempax & 0xFF00 ) >> 8 ;
6559 }
6560 else
6561 {
6562 temp = ( tempax & 0x00FF ) >> 8 ;
6563 }
6564
6565 XGINew_SetReg1( pVBInfo->Part2Port , 0x44 , temp ) ;
6566 temp = ( tempbx & 0xFF00 ) >> 8 ;
6567 XGINew_SetRegANDOR( pVBInfo->Part2Port , 0x45 , ~0x03F , temp ) ;
6568 temp = tempcx & 0x00FF ;
6569
6570 if ( tempbx & 0x2000 )
6571 temp = 0 ;
6572
6573 if ( !( pVBInfo->VBInfo & SetCRT2ToLCD ) )
6574 temp |= 0x18 ;
6575
6576 XGINew_SetRegANDOR(pVBInfo->Part2Port,0x46,~0x1F,temp);
6577 if ( pVBInfo->TVInfo & SetPALTV )
6578 {
6579 tempbx = 0x0382 ;
6580 tempcx = 0x007e ;
6581 }
6582 else
6583 {
6584 tempbx = 0x0369 ;
6585 tempcx = 0x0061 ;
6586 }
6587
6588 temp = tempbx & 0x00FF ;
6589 XGINew_SetReg1( pVBInfo->Part2Port , 0x4b , temp ) ;
6590 temp = tempcx & 0x00FF ;
6591 XGINew_SetReg1( pVBInfo->Part2Port , 0x4c , temp ) ;
6592
6593 temp = ( ( tempcx & 0xFF00 ) >> 8 ) & 0x03 ;
6594 temp = temp << 2 ;
6595 temp |= ( ( tempbx & 0xFF00 ) >> 8 ) & 0x03 ;
6596
6597 if ( pVBInfo->VBInfo & SetCRT2ToYPbPr )
6598 {
6599 temp |= 0x10 ;
6600
6601 if ( pVBInfo->TVInfo & SetYPbPrMode525p )
6602 temp |= 0x20 ;
6603
6604 if ( pVBInfo->TVInfo & SetYPbPrMode750p )
6605 temp |= 0x60 ;
6606 }
6607
6608 XGINew_SetReg1( pVBInfo->Part2Port , 0x4d , temp ) ;
6609 temp=XGINew_GetReg1( pVBInfo->Part2Port , 0x43 ) ; /* 301b change */
6610 XGINew_SetReg1( pVBInfo->Part2Port , 0x43 , ( USHORT )( temp - 3 ) ) ;
6611
6612 if ( !( pVBInfo->TVInfo & ( SetYPbPrMode525p | SetYPbPrMode750p ) ) )
6613 {
6614 if ( pVBInfo->TVInfo & NTSC1024x768 )
6615 {
6616 TimingPoint = XGI_NTSC1024AdjTime ;
6617 for( i = 0x1c , j = 0 ; i <= 0x30 ; i++ , j++ )
6618 {
6619 XGINew_SetReg1( pVBInfo->Part2Port , i , TimingPoint[ j ] ) ;
6620 }
6621 XGINew_SetReg1( pVBInfo->Part2Port , 0x43 , 0x72 ) ;
6622 }
6623 }
6624
6625 /* [ycchen] 01/14/03 Modify for 301C PALM Support */
6626 if ( pVBInfo->VBType & VB_XGI301C )
6627 {
6628 if ( pVBInfo->TVInfo & SetPALMTV )
6629 XGINew_SetRegANDOR( pVBInfo->Part2Port , 0x4E , ~0x08 , 0x08 ) ; /* PALM Mode */
6630 }
6631
6632 if ( pVBInfo->TVInfo & SetPALMTV )
6633 {
6634 tempax = ( UCHAR )XGINew_GetReg1( pVBInfo->Part2Port , 0x01 ) ;
6635 tempax-- ;
6636 XGINew_SetRegAND( pVBInfo->Part2Port , 0x01 , tempax ) ;
6637
6638 /* if ( !( pVBInfo->VBType & VB_XGI301C ) ) */
6639 XGINew_SetRegAND( pVBInfo->Part2Port , 0x00 , 0xEF ) ;
6640 }
6641
6642 if ( pVBInfo->VBInfo & SetCRT2ToHiVisionTV )
6643 {
6644 if ( !( pVBInfo->VBInfo & SetInSlaveMode ) )
6645 {
6646 XGINew_SetReg1( pVBInfo->Part2Port , 0x0B , 0x00 ) ;
6647 }
6648 }
6649
6650 if ( pVBInfo->VBInfo & SetCRT2ToTV )
6651 {
6652 return ;
6653 }
6654}
6655
6656
6657/* --------------------------------------------------------------------- */
6658/* Function : XGI_SetLCDRegs */
6659/* Input : */
6660/* Output : */
6661/* Description : */
6662/* --------------------------------------------------------------------- */
6663void XGI_SetLCDRegs(USHORT ModeNo,USHORT ModeIdIndex, PXGI_HW_DEVICE_INFO HwDeviceExtension,USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo)
6664{
6665 USHORT push1 ,
6666 push2 ,
6667 pushbx ,
6668 tempax ,
6669 tempbx ,
6670 tempcx ,
6671 temp ,
6672 tempah ,
6673 tempbh ,
6674 tempch ,
6675 resinfo ,
6676 modeflag ,
6677 CRT1Index ;
6678
6679 XGI_LCDDesStruct *LCDBDesPtr = NULL ;
6680
6681
6682 if ( ModeNo <= 0x13 )
6683 {
6684 modeflag = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag ; /* si+St_ResInfo */
6685 resinfo = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ResInfo ;
6686 }
6687 else
6688 {
6689 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag ; /* si+Ext_ResInfo */
6690 resinfo = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_RESINFO ;
6691 CRT1Index = pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_CRT1CRTC ;
6692 CRT1Index &= IndexMask ;
6693 }
6694
6695 if ( !( pVBInfo->VBInfo & SetCRT2ToLCD ) )
6696 {
6697 return ;
6698 }
6699
6700 tempbx = pVBInfo->HDE ; /* RHACTE=HDE-1 */
6701
6702 if ( XGI_IsLCDDualLink( pVBInfo ) )
6703 tempbx = tempbx >> 1 ;
6704
6705 tempbx -= 1 ;
6706 temp = tempbx & 0x00FF ;
6707 XGINew_SetReg1( pVBInfo->Part2Port , 0x2C , temp ) ;
6708 temp = ( tempbx & 0xFF00 ) >> 8 ;
6709 temp = temp << 4 ;
6710 XGINew_SetRegANDOR( pVBInfo->Part2Port , 0x2B , 0x0F , temp ) ;
6711 temp = 0x01 ;
6712
6713 if ( pVBInfo->LCDResInfo == Panel1280x1024 )
6714 {
6715 if ( pVBInfo->ModeType == ModeEGA )
6716 {
6717 if ( pVBInfo->VGAHDE >= 1024 )
6718 {
6719 temp = 0x02 ;
6720 if ( pVBInfo->LCDInfo & LCDVESATiming )
6721 temp = 0x01 ;
6722 }
6723 }
6724 }
6725
6726 XGINew_SetReg1( pVBInfo->Part2Port , 0x0B , temp ) ;
6727 tempbx = pVBInfo->VDE ; /* RTVACTEO=(VDE-1)&0xFF */
6728 push1 = tempbx ;
6729 tempbx-- ;
6730 temp = tempbx & 0x00FF ;
6731 XGINew_SetReg1( pVBInfo->Part2Port , 0x03 , temp ) ;
6732 temp = ( ( tempbx & 0xFF00 ) >> 8 ) & 0x07 ;
6733 XGINew_SetRegANDOR( pVBInfo->Part2Port , 0x0C , ~0x07 , temp ) ;
6734
6735 tempcx = pVBInfo->VT - 1 ;
6736 push2 = tempcx + 1 ;
6737 temp = tempcx & 0x00FF ; /* RVTVT=VT-1 */
6738 XGINew_SetReg1( pVBInfo->Part2Port , 0x19 , temp ) ;
6739 temp = ( tempcx & 0xFF00 ) >> 8 ;
6740 temp = temp << 5 ;
6741 XGINew_SetReg1( pVBInfo->Part2Port , 0x1A , temp ) ;
6742 XGINew_SetRegANDOR( pVBInfo->Part2Port , 0x09 , 0xF0 , 0x00 ) ;
6743 XGINew_SetRegANDOR( pVBInfo->Part2Port , 0x0A , 0xF0 , 0x00 ) ;
6744 XGINew_SetRegANDOR( pVBInfo->Part2Port , 0x17 , 0xFB , 0x00 ) ;
6745 XGINew_SetRegANDOR( pVBInfo->Part2Port , 0x18 , 0xDF , 0x00 ) ;
6746
6747 /* Customized LCDB Des no add */
6748 tempbx = 5 ;
6749 LCDBDesPtr = ( XGI_LCDDesStruct * )XGI_GetLcdPtr( tempbx , ModeNo , ModeIdIndex , RefreshRateTableIndex, pVBInfo ) ;
6750 tempah = pVBInfo->LCDResInfo ;
6751 tempah &= PanelResInfo ;
6752
6753 if ( ( tempah == Panel1024x768 ) || ( tempah == Panel1024x768x75 ) )
6754 {
6755 tempbx = 1024 ;
6756 tempcx = 768 ;
6757 }
6758 else if ( ( tempah == Panel1280x1024 ) || ( tempah == Panel1280x1024x75 ) )
6759 {
6760 tempbx = 1280 ;
6761 tempcx = 1024 ;
6762 }
6763 else if ( tempah == Panel1400x1050 )
6764 {
6765 tempbx = 1400 ;
6766 tempcx = 1050 ;
6767 }
6768 else
6769 {
6770 tempbx = 1600 ;
6771 tempcx = 1200 ;
6772 }
6773
6774 if ( pVBInfo->LCDInfo & EnableScalingLCD )
6775 {
6776 tempbx = pVBInfo->HDE ;
6777 tempcx = pVBInfo->VDE ;
6778 }
6779
6780 pushbx = tempbx ;
6781 tempax = pVBInfo->VT ;
6782 pVBInfo->LCDHDES = LCDBDesPtr->LCDHDES ;
6783 pVBInfo->LCDHRS = LCDBDesPtr->LCDHRS ;
6784 pVBInfo->LCDVDES = LCDBDesPtr->LCDVDES ;
6785 pVBInfo->LCDVRS = LCDBDesPtr->LCDVRS ;
6786 tempbx = pVBInfo->LCDVDES ;
6787 tempcx += tempbx ;
6788
6789 if ( tempcx >= tempax )
6790 tempcx -= tempax ; /* lcdvdes */
6791
6792 temp = tempbx & 0x00FF ; /* RVEQ1EQ=lcdvdes */
6793 XGINew_SetReg1( pVBInfo->Part2Port , 0x05 , temp ) ;
6794 temp = tempcx & 0x00FF ;
6795 XGINew_SetReg1( pVBInfo->Part2Port , 0x06 , temp ) ;
6796 tempch = ( ( tempcx & 0xFF00 ) >> 8 ) & 0x07 ;
6797 tempbh = ( ( tempbx & 0xFF00 ) >> 8 ) & 0x07 ;
6798 tempah = tempch ;
6799 tempah = tempah << 3 ;
6800 tempah |= tempbh ;
6801 XGINew_SetReg1( pVBInfo->Part2Port , 0x02 , tempah ) ;
6802
6803 /* getlcdsync() */
6804 XGI_GetLCDSync( &tempax , &tempbx,pVBInfo ) ;
6805 tempcx = tempbx ;
6806 tempax = pVBInfo->VT ;
6807 tempbx = pVBInfo->LCDVRS ;
6808
6809 /* if ( SetLCD_Info & EnableScalingLCD ) */
6810 tempcx += tempbx ;
6811 if ( tempcx >= tempax )
6812 tempcx -= tempax ;
6813
6814 temp = tempbx & 0x00FF ; /* RTVACTEE=lcdvrs */
6815 XGINew_SetReg1( pVBInfo->Part2Port , 0x04 , temp ) ;
6816 temp = ( tempbx & 0xFF00 ) >> 8 ;
6817 temp = temp << 4 ;
6818 temp |= ( tempcx & 0x000F ) ;
6819 XGINew_SetReg1( pVBInfo->Part2Port , 0x01 , temp ) ;
6820 tempcx = pushbx ;
6821 tempax = pVBInfo->HT ;
6822 tempbx = pVBInfo->LCDHDES ;
6823 tempbx &= 0x0FFF ;
6824
6825 if ( XGI_IsLCDDualLink( pVBInfo ) )
6826 {
6827 tempax = tempax >> 1 ;
6828 tempbx = tempbx >> 1 ;
6829 tempcx = tempcx >> 1 ;
6830 }
6831
6832 if ( pVBInfo->VBType & VB_XGI302LV )
6833 tempbx += 1 ;
6834
6835 if ( pVBInfo->VBType & VB_XGI301C ) /* tap4 */
6836 tempbx += 1 ;
6837
6838 tempcx += tempbx ;
6839
6840 if ( tempcx >= tempax )
6841 tempcx -= tempax ;
6842
6843 temp = tempbx & 0x00FF ;
6844 XGINew_SetReg1( pVBInfo->Part2Port , 0x1F , temp ) ; /* RHBLKE=lcdhdes */
6845 temp = ( ( tempbx & 0xFF00 ) >> 8 ) << 4 ;
6846 XGINew_SetReg1( pVBInfo->Part2Port , 0x20 , temp ) ;
6847 temp = tempcx & 0x00FF ;
6848 XGINew_SetReg1( pVBInfo->Part2Port , 0x23 , temp ) ; /* RHEQPLE=lcdhdee */
6849 temp = ( tempcx & 0xFF00 ) >> 8 ;
6850 XGINew_SetReg1( pVBInfo->Part2Port , 0x25 , temp ) ;
6851
6852 /* getlcdsync() */
6853 XGI_GetLCDSync( &tempax , &tempbx ,pVBInfo) ;
6854 tempcx = tempax ;
6855 tempax = pVBInfo->HT ;
6856 tempbx = pVBInfo->LCDHRS ;
6857 /* if ( SetLCD_Info & EnableScalingLCD) */
6858 if ( XGI_IsLCDDualLink( pVBInfo) )
6859 {
6860 tempax = tempax >> 1 ;
6861 tempbx = tempbx >> 1 ;
6862 tempcx = tempcx >> 1 ;
6863 }
6864
6865 if ( pVBInfo->VBType & VB_XGI302LV )
6866 tempbx += 1 ;
6867
6868 tempcx += tempbx ;
6869
6870 if ( tempcx >= tempax )
6871 tempcx -= tempax ;
6872
6873 temp = tempbx & 0x00FF ; /* RHBURSTS=lcdhrs */
6874 XGINew_SetReg1( pVBInfo->Part2Port , 0x1C , temp ) ;
6875
6876 temp = ( tempbx & 0xFF00 ) >> 8 ;
6877 temp = temp << 4 ;
6878 XGINew_SetRegANDOR( pVBInfo->Part2Port , 0x1D , ~0x0F0 , temp ) ;
6879 temp = tempcx & 0x00FF ; /* RHSYEXP2S=lcdhre */
6880 XGINew_SetReg1( pVBInfo->Part2Port , 0x21 , temp ) ;
6881
6882 if ( !( pVBInfo->LCDInfo & LCDVESATiming ) )
6883 {
6884 if ( pVBInfo->VGAVDE == 525 )
6885 {
6886 if ( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
6887 {
6888 temp = 0xC6 ;
6889 }
6890 else
6891 temp = 0xC4 ;
6892
6893 XGINew_SetReg1( pVBInfo->Part2Port , 0x2f , temp ) ;
6894 XGINew_SetReg1( pVBInfo->Part2Port , 0x30 , 0xB3 ) ;
6895 }
6896
6897 if ( pVBInfo->VGAVDE == 420 )
6898 {
6899 if ( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
6900 {
6901 temp = 0x4F ;
6902 }
6903 else
6904 temp = 0x4E ;
6905 XGINew_SetReg1( pVBInfo->Part2Port , 0x2f , temp ) ;
6906 }
6907 }
6908}
6909
6910
6911/* --------------------------------------------------------------------- */
6912/* Function : XGI_GetTap4Ptr */
6913/* Input : */
6914/* Output : di -> Tap4 Reg. Setting Pointer */
6915/* Description : */
6916/* --------------------------------------------------------------------- */
6917XGI301C_Tap4TimingStruct* XGI_GetTap4Ptr(USHORT tempcx, PVB_DEVICE_INFO pVBInfo)
6918{
6919 USHORT tempax ,
6920 tempbx ,
6921 i ;
6922
6923 XGI301C_Tap4TimingStruct *Tap4TimingPtr ;
6924
6925 if ( tempcx == 0 )
6926 {
6927 tempax = pVBInfo->VGAHDE ;
6928 tempbx = pVBInfo->HDE ;
6929 }
6930 else
6931 {
6932 tempax = pVBInfo->VGAVDE ;
6933 tempbx = pVBInfo->VDE ;
6934 }
6935
6936 if ( tempax < tempbx )
6937 return &EnlargeTap4Timing[ 0 ] ;
6938 else if( tempax == tempbx )
6939 return &NoScaleTap4Timing[ 0 ] ; /* 1:1 */
6940 else
6941 Tap4TimingPtr = NTSCTap4Timing ; /* NTSC */
6942
6943 if ( pVBInfo->TVInfo & SetPALTV )
6944 Tap4TimingPtr = PALTap4Timing ;
6945
6946
6947 if ( pVBInfo->VBInfo & SetCRT2ToYPbPr )
6948 {
6949 if ( pVBInfo->TVInfo & SetYPbPrMode525i )
6950 Tap4TimingPtr = YPbPr525iTap4Timing ;
6951 if ( pVBInfo->TVInfo & SetYPbPrMode525p )
6952 Tap4TimingPtr = YPbPr525pTap4Timing ;
6953 if ( pVBInfo->TVInfo & SetYPbPrMode750p )
6954 Tap4TimingPtr = YPbPr750pTap4Timing ;
6955 }
6956
6957 if ( pVBInfo->VBInfo & SetCRT2ToHiVisionTV )
6958 Tap4TimingPtr = HiTVTap4Timing ;
6959
6960 i = 0 ;
6961 while( Tap4TimingPtr[ i ].DE != 0xFFFF )
6962 {
6963 if ( Tap4TimingPtr[ i ].DE == tempax )
6964 break ;
6965 i++ ;
6966 }
6967 return &Tap4TimingPtr[ i ] ;
6968}
6969
6970
6971/* --------------------------------------------------------------------- */
6972/* Function : XGI_SetTap4Regs */
6973/* Input : */
6974/* Output : */
6975/* Description : */
6976/* --------------------------------------------------------------------- */
6977void XGI_SetTap4Regs( PVB_DEVICE_INFO pVBInfo)
6978{
6979 USHORT i ,
6980 j ;
6981
6982 XGI301C_Tap4TimingStruct *Tap4TimingPtr ;
6983
6984 if ( !( pVBInfo->VBType & VB_XGI301C ) )
6985 return ;
6986
6987#ifndef Tap4
6988 XGINew_SetRegAND( pVBInfo->Part2Port , 0x4E , 0xEB ) ; /* Disable Tap4 */
6989#else /* Tap4 Setting */
6990
6991 Tap4TimingPtr = XGI_GetTap4Ptr( 0 , pVBInfo) ; /* Set Horizontal Scaling */
6992 for( i = 0x80 , j = 0 ; i <= 0xBF ; i++ , j++ )
6993 XGINew_SetReg1( pVBInfo->Part2Port , i , Tap4TimingPtr->Reg[ j ] ) ;
6994
6995 if ( ( pVBInfo->VBInfo & SetCRT2ToTV ) && ( !( pVBInfo->VBInfo & SetCRT2ToHiVisionTV ) ) )
6996 {
6997 Tap4TimingPtr = XGI_GetTap4Ptr( 1 , pVBInfo); /* Set Vertical Scaling */
6998 for( i = 0xC0 , j = 0 ; i < 0xFF ; i++ , j++ )
6999 XGINew_SetReg1( pVBInfo->Part2Port , i , Tap4TimingPtr->Reg[ j ] ) ;
7000 }
7001
7002 if ( ( pVBInfo->VBInfo & SetCRT2ToTV ) && ( !( pVBInfo->VBInfo & SetCRT2ToHiVisionTV ) ) )
7003 XGINew_SetRegANDOR( pVBInfo->Part2Port , 0x4E , ~0x14 , 0x04 ) ; /* Enable V.Scaling */
7004 else
7005 XGINew_SetRegANDOR( pVBInfo->Part2Port , 0x4E , ~0x14 , 0x10 ) ; /* Enable H.Scaling */
7006#endif
7007}
7008
7009/* --------------------------------------------------------------------- */
7010/* Function : XGI_SetGroup3 */
7011/* Input : */
7012/* Output : */
7013/* Description : */
7014/* --------------------------------------------------------------------- */
7015void XGI_SetGroup3(USHORT ModeNo,USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo)
7016{
7017 USHORT i;
7018 UCHAR *tempdi;
7019 USHORT modeflag;
7020
7021 if(ModeNo<=0x13)
7022 {
7023 modeflag = pVBInfo->SModeIDTable[ModeIdIndex].St_ModeFlag; /* si+St_ResInfo */
7024 }
7025 else
7026 {
7027 modeflag = pVBInfo->EModeIDTable[ModeIdIndex].Ext_ModeFlag; /* si+Ext_ResInfo */
7028 }
7029
7030
7031 XGINew_SetReg1(pVBInfo->Part3Port,0x00,0x00);
7032 if(pVBInfo->TVInfo&SetPALTV)
7033 {
7034 XGINew_SetReg1(pVBInfo->Part3Port,0x13,0xFA);
7035 XGINew_SetReg1(pVBInfo->Part3Port,0x14,0xC8);
7036 }
7037 else
7038 {
7039 XGINew_SetReg1(pVBInfo->Part3Port,0x13,0xF5);
7040 XGINew_SetReg1(pVBInfo->Part3Port,0x14,0xB7);
7041 }
7042
7043 if(!(pVBInfo->VBInfo&SetCRT2ToTV))
7044 {
7045 return;
7046 }
7047
7048 if(pVBInfo->TVInfo&SetPALMTV)
7049 {
7050 XGINew_SetReg1(pVBInfo->Part3Port,0x13,0xFA);
7051 XGINew_SetReg1(pVBInfo->Part3Port,0x14,0xC8);
7052 XGINew_SetReg1(pVBInfo->Part3Port,0x3D,0xA8);
7053 }
7054
7055 if((pVBInfo->VBInfo&SetCRT2ToHiVisionTV)|| (pVBInfo->VBInfo&SetCRT2ToYPbPr))
7056 {
7057 if(pVBInfo->TVInfo & SetYPbPrMode525i)
7058 {
7059 return;
7060 }
7061 tempdi=pVBInfo->HiTVGroup3Data;
7062 if(pVBInfo->SetFlag&TVSimuMode)
7063 {
7064 tempdi=pVBInfo->HiTVGroup3Simu;
7065 if(!(modeflag&Charx8Dot))
7066 {
7067 tempdi=pVBInfo->HiTVGroup3Text;
7068 }
7069 }
7070
7071 if(pVBInfo->TVInfo & SetYPbPrMode525p)
7072 {
7073 tempdi=pVBInfo->Ren525pGroup3;
7074 }
7075 if(pVBInfo->TVInfo & SetYPbPrMode750p)
7076 {
7077 tempdi=pVBInfo->Ren750pGroup3;
7078 }
7079
7080 for(i=0;i<=0x3E;i++)
7081 {
7082 XGINew_SetReg1(pVBInfo->Part3Port,i,tempdi[i]);
7083 }
7084 if(pVBInfo->VBType&VB_XGI301C) /* Marcovision */
7085 {
7086 if(pVBInfo->TVInfo & SetYPbPrMode525p)
7087 {
7088 XGINew_SetReg1(pVBInfo->Part3Port,0x28,0x3f);
7089 }
7090 }
7091 }
7092 return;
7093} /* {end of XGI_SetGroup3} */
7094
7095
7096/* --------------------------------------------------------------------- */
7097/* Function : XGI_SetGroup4 */
7098/* Input : */
7099/* Output : */
7100/* Description : */
7101/* --------------------------------------------------------------------- */
7102void XGI_SetGroup4(USHORT ModeNo,USHORT ModeIdIndex,USHORT RefreshRateTableIndex,PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo)
7103{
7104 USHORT tempax ,
7105 tempcx ,
7106 tempbx ,
7107 modeflag ,
7108 temp ,
7109 temp2 ;
7110
7111 ULONG tempebx ,
7112 tempeax ,
7113 templong ;
7114
7115
7116 if ( ModeNo <= 0x13 )
7117 {
7118 modeflag = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag ; /* si+St_ResInfo */
7119 }
7120 else
7121 {
7122 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag ; /* si+Ext_ResInfo */
7123 }
7124
7125 temp = pVBInfo->RVBHCFACT ;
7126 XGINew_SetReg1( pVBInfo->Part4Port , 0x13 , temp ) ;
7127
7128 tempbx = pVBInfo->RVBHCMAX ;
7129 temp = tempbx & 0x00FF ;
7130 XGINew_SetReg1( pVBInfo->Part4Port , 0x14 , temp ) ;
7131 temp2 = ( ( tempbx & 0xFF00 ) >> 8 ) << 7 ;
7132 tempcx = pVBInfo->VGAHT - 1 ;
7133 temp = tempcx & 0x00FF ;
7134 XGINew_SetReg1( pVBInfo->Part4Port , 0x16 , temp ) ;
7135
7136 temp =( ( tempcx & 0xFF00 ) >> 8 ) << 3 ;
7137 temp2 |= temp ;
7138
7139 tempcx = pVBInfo->VGAVT - 1 ;
7140 if ( !( pVBInfo->VBInfo & SetCRT2ToTV ) )
7141 {
7142 tempcx -= 5 ;
7143 }
7144
7145 temp = tempcx & 0x00FF ;
7146 XGINew_SetReg1( pVBInfo->Part4Port , 0x17 , temp ) ;
7147 temp = temp2 | ( ( tempcx & 0xFF00 ) >> 8 ) ;
7148 XGINew_SetReg1( pVBInfo->Part4Port , 0x15 , temp ) ;
7149 XGINew_SetRegOR( pVBInfo->Part4Port , 0x0D , 0x08 ) ;
7150 tempcx = pVBInfo->VBInfo ;
7151 tempbx = pVBInfo->VGAHDE ;
7152
7153 if ( modeflag & HalfDCLK )
7154 {
7155 tempbx = tempbx >> 1 ;
7156 }
7157
7158 if ( XGI_IsLCDDualLink( pVBInfo ) )
7159 tempbx = tempbx >> 1 ;
7160
7161 if(tempcx&SetCRT2ToHiVisionTV)
7162 {
7163 temp=0;
7164 if(tempbx<=1024)
7165 temp=0xA0;
7166 if(tempbx == 1280)
7167 temp = 0xC0;
7168 }
7169 else if(tempcx&SetCRT2ToTV)
7170 {
7171 temp=0xA0;
7172 if(tempbx <= 800)
7173 temp=0x80;
7174 }
7175 else
7176 {
7177 temp=0x80;
7178 if(pVBInfo->VBInfo&SetCRT2ToLCD)
7179 {
7180 temp=0;
7181 if(tempbx>800)
7182 temp=0x60;
7183 }
7184 }
7185
7186 if ( pVBInfo->TVInfo & ( SetYPbPrMode525p | SetYPbPrMode750p ) )
7187 {
7188 temp = 0x00 ;
7189 if ( pVBInfo->VGAHDE == 1280 )
7190 temp = 0x40 ;
7191 if ( pVBInfo->VGAHDE == 1024 )
7192 temp = 0x20 ;
7193 }
7194 XGINew_SetRegANDOR( pVBInfo->Part4Port , 0x0E , ~0xEF , temp ) ;
7195
7196 tempebx = pVBInfo->VDE ;
7197
7198 if ( tempcx & SetCRT2ToHiVisionTV )
7199 {
7200 if ( !( temp & 0xE000 ) )
7201 tempbx = tempbx >> 1 ;
7202 }
7203
7204 tempcx = pVBInfo->RVBHRS ;
7205 temp = tempcx & 0x00FF ;
7206 XGINew_SetReg1( pVBInfo->Part4Port , 0x18 , temp );
7207
7208 tempeax = pVBInfo->VGAVDE ;
7209 tempcx |= 0x04000 ;
7210
7211
7212 if ( tempeax <= tempebx )
7213 {
7214 tempcx=(tempcx&(~0x4000));
7215 tempeax = pVBInfo->VGAVDE ;
7216 }
7217 else
7218 {
7219 tempeax -= tempebx ;
7220 }
7221
7222
7223 templong = ( tempeax * 256 * 1024 ) % tempebx ;
7224 tempeax = ( tempeax * 256 * 1024 ) / tempebx ;
7225 tempebx = tempeax ;
7226
7227 if ( templong != 0 )
7228 {
7229 tempebx++ ;
7230 }
7231
7232
7233 temp = ( USHORT )( tempebx & 0x000000FF ) ;
7234 XGINew_SetReg1( pVBInfo->Part4Port , 0x1B , temp ) ;
7235
7236 temp = ( USHORT )( ( tempebx & 0x0000FF00 ) >> 8 ) ;
7237 XGINew_SetReg1( pVBInfo->Part4Port , 0x1A , temp ) ;
7238 tempbx = ( USHORT )( tempebx >> 16 ) ;
7239 temp = tempbx & 0x00FF ;
7240 temp = temp << 4 ;
7241 temp |= ( ( tempcx & 0xFF00 ) >> 8 ) ;
7242 XGINew_SetReg1( pVBInfo->Part4Port , 0x19 , temp ) ;
7243
7244 /* 301b */
7245 if ( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
7246 {
7247 temp = 0x0028 ;
7248 XGINew_SetReg1( pVBInfo->Part4Port , 0x1C , temp ) ;
7249 tempax = pVBInfo->VGAHDE ;
7250 if ( modeflag & HalfDCLK )
7251 {
7252 tempax = tempax >> 1 ;
7253 }
7254
7255 if ( XGI_IsLCDDualLink( pVBInfo ) )
7256 tempax = tempax >> 1 ;
7257
7258 /* if((pVBInfo->VBInfo&(SetCRT2ToLCD))||((pVBInfo->TVInfo&SetYPbPrMode525p)||(pVBInfo->TVInfo&SetYPbPrMode750p))) { */
7259 if ( pVBInfo->VBInfo & SetCRT2ToLCD )
7260 {
7261 if ( tempax > 800 )
7262 tempax -= 800 ;
7263 }
7264 else
7265 {
7266 if ( pVBInfo->VGAHDE > 800 )
7267 {
7268 if ( pVBInfo->VGAHDE == 1024 )
7269 tempax = ( tempax * 25 / 32 ) - 1 ;
7270 else
7271 tempax = ( tempax * 20 / 32 ) - 1 ;
7272 }
7273 }
7274 tempax -= 1 ;
7275
7276/*
7277 if ( pVBInfo->VBInfo & ( SetCRT2ToTV | SetCRT2ToHiVisionTV ) )
7278 {
7279 if ( pVBInfo->VBType & VB_XGI301LV )
7280 {
7281 if ( !( pVBInfo->TVInfo & ( SetYPbPrMode525p | SetYPbPrMode750p | SetYPbPrMode1080i ) ) )
7282 {
7283 if ( pVBInfo->VGAHDE > 800 )
7284 {
7285 if ( pVBInfo->VGAHDE == 1024 )
7286 tempax = ( tempax * 25 / 32 ) - 1 ;
7287 else
7288 tempax = ( tempax * 20 / 32 ) - 1 ;
7289 }
7290 }
7291 }
7292 else
7293 {
7294 if ( pVBInfo->VGAHDE > 800 )
7295 {
7296 if ( pVBInfo->VGAHDE == 1024 )
7297 tempax = ( tempax * 25 / 32 ) - 1 ;
7298 else
7299 tempax = ( tempax * 20 / 32 ) - 1 ;
7300 }
7301 }
7302 }
7303*/
7304
7305 temp = ( tempax & 0xFF00 ) >> 8 ;
7306 temp = ( ( temp & 0x0003 ) << 4 ) ;
7307 XGINew_SetReg1( pVBInfo->Part4Port , 0x1E , temp ) ;
7308 temp = ( tempax & 0x00FF ) ;
7309 XGINew_SetReg1( pVBInfo->Part4Port , 0x1D , temp ) ;
7310
7311 if ( pVBInfo->VBInfo & ( SetCRT2ToTV | SetCRT2ToHiVisionTV ) )
7312 {
7313 if ( pVBInfo->VGAHDE > 800 )
7314 {
7315 XGINew_SetRegOR( pVBInfo->Part4Port , 0x1E , 0x08 ) ;
7316 }
7317 }
7318 temp = 0x0036 ;
7319
7320 if ( pVBInfo->VBInfo & SetCRT2ToTV )
7321 {
7322 if ( !( pVBInfo->TVInfo & ( NTSC1024x768 | SetYPbPrMode525p | SetYPbPrMode750p | SetYPbPrMode1080i ) ) )
7323 {
7324 temp |= 0x0001 ;
7325 if ( ( pVBInfo->VBInfo & SetInSlaveMode ) && ( !( pVBInfo->TVInfo & TVSimuMode ) ) )
7326 temp &= ( ~0x0001 ) ;
7327 }
7328 }
7329
7330 XGINew_SetRegANDOR( pVBInfo->Part4Port , 0x1F , 0x00C0 , temp ) ;
7331 tempbx = pVBInfo->HT ;
7332 if ( XGI_IsLCDDualLink( pVBInfo ) )
7333 tempbx = tempbx >> 1 ;
7334 tempbx = ( tempbx >> 1 ) - 2 ;
7335 temp = ( ( tempbx & 0x0700 ) >> 8 ) << 3 ;
7336 XGINew_SetRegANDOR( pVBInfo->Part4Port , 0x21 , 0x00C0 , temp ) ;
7337 temp = tempbx & 0x00FF ;
7338 XGINew_SetReg1( pVBInfo->Part4Port , 0x22 , temp ) ;
7339 }
7340 /* end 301b */
7341
7342 if ( pVBInfo->ISXPDOS == 0 )
7343 XGI_SetCRT2VCLK( ModeNo , ModeIdIndex , RefreshRateTableIndex, pVBInfo ) ;
7344}
7345
7346
7347/* --------------------------------------------------------------------- */
7348/* Function : XGI_SetGroup5 */
7349/* Input : */
7350/* Output : */
7351/* Description : */
7352/* --------------------------------------------------------------------- */
7353void XGI_SetGroup5( USHORT ModeNo , USHORT ModeIdIndex , PVB_DEVICE_INFO pVBInfo)
7354{
7355 USHORT Pindex ,
7356 Pdata ;
7357
7358 Pindex = pVBInfo->Part5Port ;
7359 Pdata = pVBInfo->Part5Port + 1 ;
7360 if ( pVBInfo->ModeType == ModeVGA )
7361 {
7362 if ( !( pVBInfo->VBInfo & ( SetInSlaveMode | LoadDACFlag | CRT2DisplayFlag ) ) )
7363 {
7364 XGINew_EnableCRT2(pVBInfo) ;
7365 /* LoadDAC2(pVBInfo->Part5Port,ModeNo,ModeIdIndex); */
7366 }
7367 }
7368 return ;
7369}
7370
7371
7372/* --------------------------------------------------------------------- */
7373/* Function : XGI_GetLcdPtr */
7374/* Input : */
7375/* Output : */
7376/* Description : */
7377/* --------------------------------------------------------------------- */
7378void* XGI_GetLcdPtr( USHORT BX , USHORT ModeNo , USHORT ModeIdIndex , USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo )
7379{
7380 USHORT i ,
7381 tempdx ,
7382 tempcx ,
7383 tempbx ,
7384 tempal ,
7385 modeflag ,
7386 table ;
7387
7388 XGI330_LCDDataTablStruct *tempdi = 0 ;
7389
7390
7391 tempbx = BX;
7392
7393 if ( ModeNo <= 0x13 )
7394 {
7395 modeflag = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag ;
7396 tempal = pVBInfo->SModeIDTable[ ModeIdIndex ].St_CRT2CRTC ;
7397 }
7398 else
7399 {
7400 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag ;
7401 tempal = pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_CRT2CRTC ;
7402 }
7403
7404 tempal = tempal & 0x0f ;
7405
7406 if ( tempbx <= 1 ) /* ExpLink */
7407 {
7408 if ( ModeNo <= 0x13 )
7409 {
7410 tempal = pVBInfo->SModeIDTable[ ModeIdIndex ].St_CRT2CRTC ; /* find no Ext_CRT2CRTC2 */
7411 }
7412 else
7413 {
7414 tempal= pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_CRT2CRTC ;
7415 }
7416
7417 if ( pVBInfo->VBInfo & SetCRT2ToLCDA )
7418 {
7419 if ( ModeNo <= 0x13 )
7420 tempal = pVBInfo->SModeIDTable[ ModeIdIndex ].St_CRT2CRTC2 ;
7421 else
7422 tempal= pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_CRT2CRTC2 ;
7423 }
7424
7425 if ( tempbx & 0x01 )
7426 tempal = ( tempal >> 4 ) ;
7427
7428 tempal = ( tempal & 0x0f ) ;
7429 }
7430
7431 tempcx = LCDLenList[ tempbx ] ; /* mov cl,byte ptr cs:LCDLenList[bx] */
7432
7433 if ( pVBInfo->LCDInfo & EnableScalingLCD ) /* ScaleLCD */
7434 {
7435 if ( ( tempbx == 5 ) || ( tempbx ) == 7 )
7436 tempcx = LCDDesDataLen2 ;
7437 else if ( ( tempbx == 3 ) || ( tempbx == 8 ) )
7438 tempcx = LVDSDesDataLen2 ;
7439 }
7440 /* mov di, word ptr cs:LCDDataList[bx] */
7441 /* tempdi=pVideoMemory[LCDDataList+tempbx*2]|(pVideoMemory[LCDDataList+tempbx*2+1]<<8); */
7442
7443 switch( tempbx )
7444 {
7445 case 0:
7446 tempdi = XGI_EPLLCDCRT1Ptr_H ;
7447 break ;
7448 case 1:
7449 tempdi = XGI_EPLLCDCRT1Ptr_V ;
7450 break ;
7451 case 2:
7452 tempdi = XGI_EPLLCDDataPtr ;
7453 break ;
7454 case 3:
7455 tempdi = XGI_EPLLCDDesDataPtr ;
7456 break ;
7457 case 4:
7458 tempdi = XGI_LCDDataTable ;
7459 break ;
7460 case 5:
7461 tempdi = XGI_LCDDesDataTable ;
7462 break ;
7463 case 6:
7464 tempdi = XGI_EPLCHLCDRegPtr ;
7465 break ;
7466 case 7:
7467 case 8:
7468 case 9:
7469 tempdi = 0 ;
7470 break ;
7471 default:
7472 break ;
7473 }
7474
7475 if ( tempdi == 0x00 ) /* OEMUtil */
7476 return 0 ;
7477
7478 table = tempbx ;
7479 i = 0 ;
7480
7481 while( tempdi[ i ].PANELID != 0xff )
7482 {
7483 tempdx = pVBInfo->LCDResInfo ;
7484 if ( tempbx & 0x0080 ) /* OEMUtil */
7485 {
7486 tempbx &= ( ~0x0080 ) ;
7487 tempdx = pVBInfo->LCDTypeInfo ;
7488 }
7489
7490 if ( pVBInfo->LCDInfo & EnableScalingLCD )
7491 tempdx &= ( ~PanelResInfo ) ;
7492
7493 if ( tempdi[ i ].PANELID == tempdx )
7494 {
7495 tempbx = tempdi[ i ].MASK ;
7496 tempdx = pVBInfo->LCDInfo ;
7497
7498 if ( ModeNo <= 0x13 ) /* alan 09/10/2003 */
7499 tempdx |= SetLCDStdMode ;
7500
7501 if ( modeflag & HalfDCLK )
7502 tempdx |= SetLCDLowResolution ;
7503
7504 tempbx &= tempdx;
7505 if ( tempbx == tempdi[ i ].CAP )
7506 break ;
7507 }
7508 i++ ;
7509 }
7510
7511 if ( table == 0 )
7512 {
7513 switch( tempdi[ i ].DATAPTR )
7514 {
7515 case 0:
7516 return &XGI_LVDSCRT11024x768_1_H[ tempal ] ;
7517 break ;
7518 case 1:
7519 return &XGI_LVDSCRT11024x768_2_H[ tempal ] ;
7520 break ;
7521 case 2:
7522 return &XGI_LVDSCRT11280x1024_1_H[ tempal ] ;
7523 break ;
7524 case 3:
7525 return &XGI_LVDSCRT11280x1024_2_H[ tempal ] ;
7526 break ;
7527 case 4:
7528 return &XGI_LVDSCRT11400x1050_1_H[ tempal ] ;
7529 break ;
7530 case 5:
7531 return &XGI_LVDSCRT11400x1050_2_H[ tempal ] ;
7532 break ;
7533 case 6:
7534 return &XGI_LVDSCRT11600x1200_1_H[ tempal ] ;
7535 break ;
7536 case 7:
7537 return &XGI_LVDSCRT11024x768_1_Hx75[ tempal ] ;
7538 break ;
7539 case 8:
7540 return &XGI_LVDSCRT11024x768_2_Hx75[ tempal ] ;
7541 break ;
7542 case 9:
7543 return &XGI_LVDSCRT11280x1024_1_Hx75[ tempal ] ;
7544 break ;
7545 case 10:
7546 return &XGI_LVDSCRT11280x1024_2_Hx75[ tempal ] ;
7547 break ;
7548 default:
7549 break ;
7550 }
7551 }
7552 else if ( table == 1 )
7553 {
7554 switch( tempdi[ i ].DATAPTR )
7555 {
7556 case 0:
7557 return &XGI_LVDSCRT11024x768_1_V[ tempal ] ;
7558 break ;
7559 case 1:
7560 return &XGI_LVDSCRT11024x768_2_V[ tempal ] ;
7561 break ;
7562 case 2:
7563 return &XGI_LVDSCRT11280x1024_1_V[ tempal ] ;
7564 break ;
7565 case 3:
7566 return &XGI_LVDSCRT11280x1024_2_V[ tempal ] ;
7567 break ;
7568 case 4:
7569 return &XGI_LVDSCRT11400x1050_1_V[ tempal ] ;
7570 break ;
7571 case 5:
7572 return &XGI_LVDSCRT11400x1050_2_V[ tempal ] ;
7573 break ;
7574 case 6:
7575 return &XGI_LVDSCRT11600x1200_1_V[ tempal ] ;
7576 break ;
7577 case 7:
7578 return &XGI_LVDSCRT11024x768_1_Vx75[ tempal ] ;
7579 break ;
7580 case 8:
7581 return &XGI_LVDSCRT11024x768_2_Vx75[ tempal ] ;
7582 break ;
7583 case 9:
7584 return &XGI_LVDSCRT11280x1024_1_Vx75[ tempal ] ;
7585 break ;
7586 case 10:
7587 return &XGI_LVDSCRT11280x1024_2_Vx75[ tempal ] ;
7588 break ;
7589 default:
7590 break ;
7591 }
7592 }
7593 else if ( table == 2 )
7594 {
7595 switch( tempdi[ i ].DATAPTR )
7596 {
7597 case 0:
7598 return &XGI_LVDS1024x768Data_1[ tempal ] ;
7599 break ;
7600 case 1:
7601 return &XGI_LVDS1024x768Data_2[ tempal ] ;
7602 break ;
7603 case 2:
7604 return &XGI_LVDS1280x1024Data_1[ tempal ] ;
7605 break ;
7606 case 3:
7607 return &XGI_LVDS1280x1024Data_2[ tempal ] ;
7608 break ;
7609 case 4:
7610 return &XGI_LVDS1400x1050Data_1[ tempal ] ;
7611 break ;
7612 case 5:
7613 return &XGI_LVDS1400x1050Data_2[ tempal ] ;
7614 break ;
7615 case 6:
7616 return &XGI_LVDS1600x1200Data_1[ tempal ] ;
7617 break ;
7618 case 7:
7619 return &XGI_LVDSNoScalingData[ tempal ] ;
7620 break ;
7621 case 8:
7622 return &XGI_LVDS1024x768Data_1x75[ tempal ] ;
7623 break ;
7624 case 9:
7625 return &XGI_LVDS1024x768Data_2x75[ tempal ] ;
7626 break ;
7627 case 10:
7628 return &XGI_LVDS1280x1024Data_1x75[ tempal ] ;
7629 break ;
7630 case 11:
7631 return &XGI_LVDS1280x1024Data_2x75[ tempal ] ;
7632 break ;
7633 case 12:
7634 return &XGI_LVDSNoScalingDatax75[ tempal ] ;
7635 break ;
7636 default:
7637 break ;
7638 }
7639 }
7640 else if ( table == 3 )
7641 {
7642 switch( tempdi[ i ].DATAPTR )
7643 {
7644 case 0:
7645 return &XGI_LVDS1024x768Des_1[ tempal ] ;
7646 break ;
7647 case 1:
7648 return &XGI_LVDS1024x768Des_3[ tempal ] ;
7649 break ;
7650 case 2:
7651 return &XGI_LVDS1024x768Des_2[ tempal ] ;
7652 break ;
7653 case 3:
7654 return &XGI_LVDS1280x1024Des_1[ tempal ] ;
7655 break ;
7656 case 4:
7657 return &XGI_LVDS1280x1024Des_2[ tempal ] ;
7658 break ;
7659 case 5:
7660 return &XGI_LVDS1400x1050Des_1[ tempal ] ;
7661 break ;
7662 case 6:
7663 return &XGI_LVDS1400x1050Des_2[ tempal ] ;
7664 break ;
7665 case 7:
7666 return &XGI_LVDS1600x1200Des_1[ tempal ] ;
7667 break ;
7668 case 8:
7669 return &XGI_LVDSNoScalingDesData[ tempal ] ;
7670 break ;
7671 case 9:
7672 return &XGI_LVDS1024x768Des_1x75[ tempal ] ;
7673 break ;
7674 case 10:
7675 return &XGI_LVDS1024x768Des_3x75[ tempal ] ;
7676 break ;
7677 case 11:
7678 return &XGI_LVDS1024x768Des_2x75[ tempal ] ;
7679 break;
7680 case 12:
7681 return &XGI_LVDS1280x1024Des_1x75[ tempal ] ;
7682 break ;
7683 case 13:
7684 return &XGI_LVDS1280x1024Des_2x75[ tempal ] ;
7685 break ;
7686 case 14:
7687 return &XGI_LVDSNoScalingDesDatax75[ tempal ] ;
7688 break ;
7689 default:
7690 break ;
7691 }
7692 }
7693 else if ( table == 4 )
7694 {
7695 switch( tempdi[ i ].DATAPTR )
7696 {
7697 case 0:
7698 return &XGI_ExtLCD1024x768Data[ tempal ] ;
7699 break ;
7700 case 1:
7701 return &XGI_StLCD1024x768Data[ tempal ] ;
7702 break ;
7703 case 2:
7704 return &XGI_CetLCD1024x768Data[ tempal ] ;
7705 break ;
7706 case 3:
7707 return &XGI_ExtLCD1280x1024Data[ tempal ] ;
7708 break ;
7709 case 4:
7710 return &XGI_StLCD1280x1024Data[ tempal ] ;
7711 break ;
7712 case 5:
7713 return &XGI_CetLCD1280x1024Data[ tempal ] ;
7714 break ;
7715 case 6:
7716 return &XGI_ExtLCD1400x1050Data[ tempal ] ;
7717 break ;
7718 case 7:
7719 return &XGI_StLCD1400x1050Data[ tempal ] ;
7720 break ;
7721 case 8:
7722 return &XGI_CetLCD1400x1050Data[ tempal ] ;
7723 break ;
7724 case 9:
7725 return &XGI_ExtLCD1600x1200Data[ tempal ] ;
7726 break ;
7727 case 10:
7728 return &XGI_StLCD1600x1200Data[ tempal ] ;
7729 break ;
7730 case 11:
7731 return &XGI_NoScalingData[ tempal ] ;
7732 break ;
7733 case 12:
7734 return &XGI_ExtLCD1024x768x75Data[ tempal ] ;
7735 break ;
7736 case 13:
7737 return &XGI_ExtLCD1024x768x75Data[ tempal ] ;
7738 break ;
7739 case 14:
7740 return &XGI_CetLCD1024x768x75Data[ tempal ] ;
7741 break ;
7742 case 15:
7743 return &XGI_ExtLCD1280x1024x75Data[ tempal ] ;
7744 break ;
7745 case 16:
7746 return &XGI_StLCD1280x1024x75Data[ tempal ] ;
7747 break;
7748 case 17:
7749 return &XGI_CetLCD1280x1024x75Data[ tempal ] ;
7750 break;
7751 case 18:
7752 return &XGI_NoScalingDatax75[ tempal ] ;
7753 break ;
7754 default:
7755 break ;
7756 }
7757 }
7758 else if ( table == 5 )
7759 {
7760 switch( tempdi[ i ].DATAPTR )
7761 {
7762 case 0:
7763 return &XGI_ExtLCDDes1024x768Data[ tempal ] ;
7764 break ;
7765 case 1:
7766 return &XGI_StLCDDes1024x768Data[ tempal ] ;
7767 break ;
7768 case 2:
7769 return &XGI_CetLCDDes1024x768Data[ tempal ] ;
7770 break ;
7771 case 3:
7772 if ( ( pVBInfo->VBType & VB_XGI301LV ) || ( pVBInfo->VBType & VB_XGI302LV ) )
7773 return &XGI_ExtLCDDLDes1280x1024Data[ tempal ] ;
7774 else
7775 return &XGI_ExtLCDDes1280x1024Data[ tempal ] ;
7776 break ;
7777 case 4:
7778 if ( ( pVBInfo->VBType & VB_XGI301LV ) || ( pVBInfo->VBType & VB_XGI302LV ) )
7779 return &XGI_StLCDDLDes1280x1024Data[ tempal ] ;
7780 else
7781 return &XGI_StLCDDes1280x1024Data[ tempal ] ;
7782 break ;
7783 case 5:
7784 if ( ( pVBInfo->VBType & VB_XGI301LV ) || ( pVBInfo->VBType & VB_XGI302LV ) )
7785 return &XGI_CetLCDDLDes1280x1024Data[ tempal ] ;
7786 else
7787 return &XGI_CetLCDDes1280x1024Data[ tempal ] ;
7788 break ;
7789 case 6:
7790 if ( ( pVBInfo->VBType & VB_XGI301LV ) || ( pVBInfo->VBType & VB_XGI302LV ) )
7791 return &XGI_ExtLCDDLDes1400x1050Data[ tempal ] ;
7792 else
7793 return &XGI_ExtLCDDes1400x1050Data[ tempal ] ;
7794 break ;
7795 case 7:
7796 if ( ( pVBInfo->VBType & VB_XGI301LV ) || ( pVBInfo->VBType & VB_XGI302LV ) )
7797 return &XGI_StLCDDLDes1400x1050Data[ tempal ] ;
7798 else
7799 return &XGI_StLCDDes1400x1050Data[ tempal ] ;
7800 break ;
7801 case 8:
7802 return &XGI_CetLCDDes1400x1050Data[ tempal ] ;
7803 break ;
7804 case 9:
7805 return &XGI_CetLCDDes1400x1050Data2[ tempal ] ;
7806 break ;
7807 case 10:
7808 if ( ( pVBInfo->VBType & VB_XGI301LV ) || ( pVBInfo->VBType & VB_XGI302LV ) )
7809 return &XGI_ExtLCDDLDes1600x1200Data[ tempal ] ;
7810 else
7811 return &XGI_ExtLCDDes1600x1200Data[ tempal ] ;
7812 break ;
7813 case 11:
7814 if ( ( pVBInfo->VBType & VB_XGI301LV ) || ( pVBInfo->VBType & VB_XGI302LV ) )
7815 return &XGI_StLCDDLDes1600x1200Data[ tempal ] ;
7816 else
7817 return &XGI_StLCDDes1600x1200Data[ tempal ] ;
7818 break ;
7819 case 12:
7820 return &XGI_NoScalingDesData[ tempal ] ;
7821 break;
7822 case 13:
7823 return &XGI_ExtLCDDes1024x768x75Data[ tempal ] ;
7824 break ;
7825 case 14:
7826 return &XGI_StLCDDes1024x768x75Data[ tempal ] ;
7827 break ;
7828 case 15:
7829 return &XGI_CetLCDDes1024x768x75Data[ tempal ] ;
7830 break ;
7831 case 16:
7832 if ( ( pVBInfo->VBType & VB_XGI301LV ) || ( pVBInfo->VBType & VB_XGI302LV ) )
7833 return &XGI_ExtLCDDLDes1280x1024x75Data[ tempal ] ;
7834 else
7835 return &XGI_ExtLCDDes1280x1024x75Data[ tempal ] ;
7836 break ;
7837 case 17:
7838 if ( ( pVBInfo->VBType & VB_XGI301LV ) || ( pVBInfo->VBType & VB_XGI302LV ) )
7839 return &XGI_StLCDDLDes1280x1024x75Data[ tempal ] ;
7840 else
7841 return &XGI_StLCDDes1280x1024x75Data[ tempal ] ;
7842 break ;
7843 case 18:
7844 if ( ( pVBInfo->VBType & VB_XGI301LV ) || ( pVBInfo->VBType & VB_XGI302LV ) )
7845 return &XGI_CetLCDDLDes1280x1024x75Data[ tempal ] ;
7846 else
7847 return &XGI_CetLCDDes1280x1024x75Data[ tempal ] ;
7848 break ;
7849 case 19:
7850 return &XGI_NoScalingDesDatax75[ tempal ] ;
7851 break ;
7852 default:
7853 break ;
7854 }
7855 }
7856 else if ( table == 6 )
7857 {
7858 switch( tempdi[ i ].DATAPTR )
7859 {
7860 case 0:
7861 return &XGI_CH7017LV1024x768[ tempal ] ;
7862 break ;
7863 case 1:
7864 return &XGI_CH7017LV1400x1050[ tempal ] ;
7865 break ;
7866 default:
7867 break ;
7868 }
7869 }
7870 return 0 ;
7871}
7872
7873
7874/* --------------------------------------------------------------------- */
7875/* Function : XGI_GetTVPtr */
7876/* Input : */
7877/* Output : */
7878/* Description : */
7879/* --------------------------------------------------------------------- */
7880void* XGI_GetTVPtr (USHORT BX,USHORT ModeNo,USHORT ModeIdIndex,USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo )
7881{
7882 USHORT i , tempdx , tempbx , tempal , modeflag , table ;
7883 XGI330_TVDataTablStruct *tempdi = 0 ;
7884
7885 tempbx = BX ;
7886
7887 if ( ModeNo <= 0x13 )
7888 {
7889 modeflag = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag ;
7890 tempal = pVBInfo->SModeIDTable[ ModeIdIndex ].St_CRT2CRTC ;
7891 }
7892 else
7893 {
7894 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag ;
7895 tempal = pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_CRT2CRTC ;
7896 }
7897
7898 tempal = tempal & 0x3f ;
7899 table = tempbx ;
7900
7901 switch( tempbx )
7902 {
7903 case 0:
7904 tempdi = 0 ; /*EPLCHTVCRT1Ptr_H;*/
7905 if ( pVBInfo->IF_DEF_CH7007 == 1 )
7906 {
7907 tempdi = XGI_EPLCHTVCRT1Ptr;
7908 }
7909 break ;
7910 case 1:
7911 tempdi = 0 ; /*EPLCHTVCRT1Ptr_V;*/
7912 if ( pVBInfo->IF_DEF_CH7007 == 1 )
7913 {
7914 tempdi = XGI_EPLCHTVCRT1Ptr;
7915 }
7916 break ;
7917 case 2:
7918 tempdi = XGI_EPLCHTVDataPtr ;
7919 break ;
7920 case 3:
7921 tempdi = 0 ;
7922 break ;
7923 case 4:
7924 tempdi = XGI_TVDataTable ;
7925 break ;
7926 case 5:
7927 tempdi = 0 ;
7928 break ;
7929 case 6:
7930 tempdi = XGI_EPLCHTVRegPtr ;
7931 break ;
7932 default:
7933 break ;
7934 }
7935
7936 if ( tempdi == 0x00 ) /* OEMUtil */
7937 return( 0 ) ;
7938
7939 tempdx = pVBInfo->TVInfo ;
7940
7941 if ( pVBInfo->VBInfo & SetInSlaveMode )
7942 tempdx = tempdx | SetTVLockMode ;
7943
7944 if ( modeflag & HalfDCLK )
7945 tempdx = tempdx | SetTVLowResolution ;
7946
7947 i = 0 ;
7948
7949 while( tempdi[ i ].MASK != 0xffff )
7950 {
7951 if ( ( tempdx & tempdi[ i ].MASK ) == tempdi[ i ].CAP )
7952 break ;
7953 i++ ;
7954 }
7955
7956 if ( table == 0x00 ) /* 07/05/22 */
7957 {
7958#ifdef WIN2000
7959 if ( pVBInfo->IF_DEF_CH7007 == 1 )
7960 {
7961 switch( tempdi[ i ].DATAPTR )
7962 {
7963 case 0:
7964 return &CH7007TVCRT1UNTSC_H[ tempal ] ;
7965 break ;
7966 case 1:
7967 return &CH7007TVCRT1ONTSC_H[ tempal ] ;
7968 break ;
7969 case 2:
7970 return &CH7007TVCRT1UPAL_H[ tempal ] ;
7971 break ;
7972 case 3:
7973 return &CH7007TVCRT1OPAL_H[ tempal ] ;
7974 break ;
7975 default:
7976 break ;
7977 }
7978 }
7979#endif
7980 }
7981 else if ( table == 0x01 )
7982 {
7983#ifdef WIN2000
7984 if ( pVBInfo->IF_DEF_CH7007 == 1 )
7985 {
7986 switch( tempdi[ i ].DATAPTR )
7987 {
7988 case 0:
7989 return &CH7007TVCRT1UNTSC_V[ tempal ] ;
7990 break ;
7991 case 1:
7992 return &CH7007TVCRT1ONTSC_V[ tempal ] ;
7993 break ;
7994 case 2:
7995 return &CH7007TVCRT1UPAL_V[ tempal ] ;
7996 break ;
7997 case 3:
7998 return &CH7007TVCRT1OPAL_V[ tempal ] ;
7999 break ;
8000 default:
8001 break ;
8002 }
8003 }
8004#endif
8005 }
8006 else if ( table == 0x04 )
8007 {
8008 switch( tempdi[ i ].DATAPTR )
8009 {
8010 case 0:
8011 return &XGI_ExtPALData[ tempal ] ;
8012 break ;
8013 case 1:
8014 return &XGI_ExtNTSCData[ tempal ] ;
8015 break ;
8016 case 2:
8017 return &XGI_StPALData[ tempal ] ;
8018 break ;
8019 case 3:
8020 return &XGI_StNTSCData[ tempal ] ;
8021 break ;
8022 case 4:
8023 return &XGI_ExtHiTVData[ tempal ] ;
8024 break ;
8025 case 5:
8026 return &XGI_St2HiTVData[ tempal ] ;
8027 break ;
8028 case 6:
8029 return &XGI_ExtYPbPr525iData[ tempal ] ;
8030 break ;
8031 case 7:
8032 return &XGI_ExtYPbPr525pData[ tempal ] ;
8033 break ;
8034 case 8:
8035 return &XGI_ExtYPbPr750pData[ tempal ] ;
8036 break ;
8037 case 9:
8038 return &XGI_StYPbPr525iData[ tempal ] ;
8039 break ;
8040 case 10:
8041 return &XGI_StYPbPr525pData[ tempal ] ;
8042 break ;
8043 case 11:
8044 return &XGI_StYPbPr750pData[ tempal ] ;
8045 break;
8046 case 12: /* avoid system hang */
8047 return &XGI_ExtNTSCData[ tempal ] ;
8048 break ;
8049 case 13:
8050 return &XGI_St1HiTVData[ tempal ] ;
8051 break ;
8052 default:
8053 break ;
8054 }
8055 }
8056 else if( table == 0x02 )
8057 {
8058 switch( tempdi[ i ].DATAPTR )
8059 {
8060 case 0:
8061 return &XGI_CHTVUNTSCData[ tempal ] ;
8062 break ;
8063 case 1:
8064 return &XGI_CHTVONTSCData[ tempal ] ;
8065 break ;
8066 case 2:
8067 return &XGI_CHTVUPALData[ tempal ] ;
8068 break ;
8069 case 3:
8070 return &XGI_CHTVOPALData[ tempal ] ;
8071 break ;
8072 default:
8073 break ;
8074 }
8075 }
8076 else if( table == 0x06 )
8077 {
8078#ifdef WIN2000
8079 if ( pVBInfo->IF_DEF_CH7007 == 1 )
8080 {
8081 /* VideoDebugPrint((0, "XGI_GetTVPtr: pVBInfo->IF_DEF_CH7007==1\n")); */
8082 switch( tempdi[ i ].DATAPTR )
8083 {
8084 case 0:
8085 return &CH7007TVReg_UNTSC[ tempal ] ;
8086 break ;
8087 case 1:
8088 return &CH7007TVReg_ONTSC[ tempal ] ;
8089 break ;
8090 case 2:
8091 return &CH7007TVReg_UPAL[ tempal ] ;
8092 break ;
8093 case 3:
8094 return &CH7007TVReg_OPAL[ tempal ] ;
8095 break ;
8096 default:
8097 break ;
8098 }
8099 }
8100 else
8101 {
8102 switch( tempdi[ i ].DATAPTR )
8103 {
8104 case 0:
8105 return &XGI_CHTVRegUNTSC[ tempal ] ;
8106 break ;
8107 case 1:
8108 return &XGI_CHTVRegONTSC[ tempal ] ;
8109 break ;
8110 case 2:
8111 return &XGI_CHTVRegUPAL[ tempal ] ;
8112 break ;
8113 case 3:
8114 return &XGI_CHTVRegOPAL[ tempal ] ;
8115 break ;
8116 default:
8117 break ;
8118 }
8119 }
8120#endif
8121 }
8122 return( 0 ) ;
8123}
8124
8125
8126/* --------------------------------------------------------------------- */
8127/* Function : XGI_BacklightByDrv */
8128/* Input : */
8129/* Output : TRUE -> Skip backlight control */
8130/* Description : */
8131/* --------------------------------------------------------------------- */
8132BOOLEAN XGI_BacklightByDrv( PVB_DEVICE_INFO pVBInfo )
8133{
8134 UCHAR tempah ;
8135
8136 tempah = ( UCHAR )XGINew_GetReg1( pVBInfo->P3d4 , 0x3A ) ;
8137 if ( tempah & BacklightControlBit )
8138 return TRUE ;
8139 else
8140 return FALSE ;
8141}
8142
8143
8144/* --------------------------------------------------------------------- */
8145/* Function : XGI_FirePWDDisable */
8146/* Input : */
8147/* Output : */
8148/* Description : Turn off VDD & Backlight : Fire disable procedure */
8149/* --------------------------------------------------------------------- */
8150/*
8151void XGI_FirePWDDisable( PVB_DEVICE_INFO pVBInfo )
8152{
8153 XGINew_SetRegANDOR( pVBInfo->Part1Port , 0x26 , 0x00 , 0xFC ) ;
8154}
8155*/
8156
8157/* --------------------------------------------------------------------- */
8158/* Function : XGI_FirePWDEnable */
8159/* Input : */
8160/* Output : */
8161/* Description : Turn on VDD & Backlight : Fire enable procedure */
8162/* --------------------------------------------------------------------- */
8163void XGI_FirePWDEnable(PVB_DEVICE_INFO pVBInfo )
8164{
8165 XGINew_SetRegANDOR( pVBInfo->Part1Port , 0x26 , 0x03 , 0xFC ) ;
8166}
8167
8168
8169/* --------------------------------------------------------------------- */
8170/* Function : XGI_EnableGatingCRT */
8171/* Input : */
8172/* Output : */
8173/* Description : */
8174/* --------------------------------------------------------------------- */
8175void XGI_EnableGatingCRT(PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo)
8176{
8177 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x63 , 0xBF , 0x40 ) ;
8178}
8179
8180
8181/* --------------------------------------------------------------------- */
8182/* Function : XGI_DisableGatingCRT */
8183/* Input : */
8184/* Output : */
8185/* Description : */
8186/* --------------------------------------------------------------------- */
8187void XGI_DisableGatingCRT(PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo)
8188{
8189
8190 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x63 , 0xBF , 0x00 ) ;
8191}
8192
8193
8194/* --------------------------------------------------------------------- */
8195/* Function : XGI_SetPanelDelay */
8196/* Input : */
8197/* Output : */
8198/* Description : */
8199/* I/P : bl : 1 ; T1 : the duration between CPL on and signal on */
8200/* : bl : 2 ; T2 : the duration signal on and Vdd on */
8201/* : bl : 3 ; T3 : the duration between CPL off and signal off */
8202/* : bl : 4 ; T4 : the duration signal off and Vdd off */
8203/* --------------------------------------------------------------------- */
8204void XGI_SetPanelDelay(USHORT tempbl, PVB_DEVICE_INFO pVBInfo)
8205{
8206 USHORT index ;
8207
8208 index = XGI_GetLCDCapPtr(pVBInfo) ;
8209
8210 if ( tempbl == 1 )
8211 XGINew_LCD_Wait_Time( pVBInfo->LCDCapList[ index ].PSC_S1, pVBInfo ) ;
8212
8213 if ( tempbl == 2 )
8214 XGINew_LCD_Wait_Time( pVBInfo->LCDCapList[ index ].PSC_S2, pVBInfo ) ;
8215
8216 if ( tempbl == 3 )
8217 XGINew_LCD_Wait_Time( pVBInfo->LCDCapList[ index ].PSC_S3, pVBInfo ) ;
8218
8219 if ( tempbl == 4 )
8220 XGINew_LCD_Wait_Time( pVBInfo->LCDCapList[ index ].PSC_S4, pVBInfo ) ;
8221}
8222
8223
8224/* --------------------------------------------------------------------- */
8225/* Function : XGI_SetPanelPower */
8226/* Input : */
8227/* Output : */
8228/* Description : */
8229/* I/O : ah = 0011b = 03h ; Backlight on, Power on */
8230/* = 0111b = 07h ; Backlight on, Power off */
8231/* = 1011b = 0Bh ; Backlight off, Power on */
8232/* = 1111b = 0Fh ; Backlight off, Power off */
8233/* --------------------------------------------------------------------- */
8234void XGI_SetPanelPower(USHORT tempah,USHORT tempbl, PVB_DEVICE_INFO pVBInfo)
8235{
8236 if ( pVBInfo->VBType & ( VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
8237 XGINew_SetRegANDOR( pVBInfo->Part4Port , 0x26 , tempbl , tempah ) ;
8238 else
8239 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x11 , tempbl , tempah ) ;
8240}
8241
8242UCHAR XG21GPIODataTransfer(UCHAR ujDate)
8243{
8244 UCHAR ujRet = 0;
8245 UCHAR i = 0;
8246
8247 for (i=0; i<8; i++)
8248 {
8249 ujRet = ujRet << 1;
8250 /* ujRet |= GETBITS(ujDate >> i, 0:0); */
8251 ujRet |= (ujDate >> i) & 1;
8252 }
8253
8254 return ujRet;
8255}
8256
8257/*----------------------------------------------------------------------------*/
8258/* output */
8259/* bl[5] : LVDS signal */
8260/* bl[1] : LVDS backlight */
8261/* bl[0] : LVDS VDD */
8262/*----------------------------------------------------------------------------*/
8263UCHAR XGI_XG21GetPSCValue(PVB_DEVICE_INFO pVBInfo)
8264{
8265 UCHAR CR4A,temp;
8266
8267 CR4A = XGINew_GetReg1( pVBInfo->P3d4 , 0x4A ) ;
8268 XGINew_SetRegAND( pVBInfo->P3d4 , 0x4A , ~0x23 ) ; /* enable GPIO write */
8269
8270 temp = XGINew_GetReg1( pVBInfo->P3d4 , 0x48 ) ;
8271
8272 temp = XG21GPIODataTransfer(temp);
8273 temp &= 0x23;
8274 XGINew_SetReg1( pVBInfo->P3d4 , 0x4A , CR4A ) ;
8275 return temp;
8276}
8277
8278/*----------------------------------------------------------------------------*/
8279/* output */
8280/* bl[5] : LVDS signal */
8281/* bl[1] : LVDS backlight */
8282/* bl[0] : LVDS VDD */
8283/*----------------------------------------------------------------------------*/
8284UCHAR XGI_XG27GetPSCValue(PVB_DEVICE_INFO pVBInfo)
8285{
8286 UCHAR CR4A,CRB4,temp;
8287
8288 CR4A = XGINew_GetReg1( pVBInfo->P3d4 , 0x4A ) ;
8289 XGINew_SetRegAND( pVBInfo->P3d4 , 0x4A , ~0x0C ) ; /* enable GPIO write */
8290
8291 temp = XGINew_GetReg1( pVBInfo->P3d4 , 0x48 ) ;
8292
8293 temp &= 0x0C;
8294 temp >>= 2;
8295 XGINew_SetReg1( pVBInfo->P3d4 , 0x4A , CR4A ) ;
8296 CRB4 = XGINew_GetReg1( pVBInfo->P3d4 , 0xB4 ) ;
8297 temp |= ((CRB4&0x04)<<3);
8298 return temp;
8299}
8300/*----------------------------------------------------------------------------*/
8301/* input */
8302/* bl[5] : 1;LVDS signal on */
8303/* bl[1] : 1;LVDS backlight on */
8304/* bl[0] : 1:LVDS VDD on */
8305/* bh: 100000b : clear bit 5, to set bit5 */
8306/* 000010b : clear bit 1, to set bit1 */
8307/* 000001b : clear bit 0, to set bit0 */
8308/*----------------------------------------------------------------------------*/
8309void XGI_XG21BLSignalVDD(USHORT tempbh,USHORT tempbl, PVB_DEVICE_INFO pVBInfo)
8310{
8311 UCHAR CR4A,temp;
8312
8313 CR4A = XGINew_GetReg1( pVBInfo->P3d4 , 0x4A ) ;
8314 tempbh &= 0x23;
8315 tempbl &= 0x23;
8316 XGINew_SetRegAND( pVBInfo->P3d4 , 0x4A , ~tempbh ) ; /* enable GPIO write */
8317
8318 if (tempbh&0x20)
8319 {
8320 temp = (tempbl>>4)&0x02;
8321
8322 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0xB4 , ~0x02 , temp) ; /* CR B4[1] */
8323
8324 }
8325
8326 temp = XGINew_GetReg1( pVBInfo->P3d4 , 0x48 ) ;
8327
8328 temp = XG21GPIODataTransfer(temp);
8329 temp &= ~tempbh;
8330 temp |= tempbl;
8331 XGINew_SetReg1( pVBInfo->P3d4 , 0x48 , temp ) ;
8332}
8333
8334void XGI_XG27BLSignalVDD(USHORT tempbh,USHORT tempbl, PVB_DEVICE_INFO pVBInfo)
8335{
8336 UCHAR CR4A,temp;
8337 USHORT tempbh0,tempbl0;
8338
8339 tempbh0 = tempbh;
8340 tempbl0 = tempbl;
8341 tempbh0 &= 0x20;
8342 tempbl0 &= 0x20;
8343 tempbh0 >>= 3;
8344 tempbl0 >>= 3;
8345
8346 if (tempbh&0x20)
8347 {
8348 temp = (tempbl>>4)&0x02;
8349
8350 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0xB4 , ~0x02 , temp) ; /* CR B4[1] */
8351
8352 }
8353 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0xB4 , ~tempbh0 , tempbl0 ) ;
8354
8355 CR4A = XGINew_GetReg1( pVBInfo->P3d4 , 0x4A ) ;
8356 tempbh &= 0x03;
8357 tempbl &= 0x03;
8358 tempbh <<= 2;
8359 tempbl <<= 2; /* GPIOC,GPIOD */
8360 XGINew_SetRegAND( pVBInfo->P3d4 , 0x4A , ~tempbh ) ; /* enable GPIO write */
8361 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x48 , ~tempbh , tempbl ) ;
8362}
8363
8364/* --------------------------------------------------------------------- */
8365USHORT XGI_GetLVDSOEMTableIndex(PVB_DEVICE_INFO pVBInfo)
8366{
8367 USHORT index ;
8368
8369 index = XGINew_GetReg1( pVBInfo->P3d4 , 0x36 ) ;
8370 if (index<sizeof(XGI21_LCDCapList)/sizeof(XGI21_LVDSCapStruct))
8371 {
8372 return index;
8373 }
8374 return 0;
8375}
8376
8377/* --------------------------------------------------------------------- */
8378/* Function : XGI_XG21SetPanelDelay */
8379/* Input : */
8380/* Output : */
8381/* Description : */
8382/* I/P : bl : 1 ; T1 : the duration between CPL on and signal on */
8383/* : bl : 2 ; T2 : the duration signal on and Vdd on */
8384/* : bl : 3 ; T3 : the duration between CPL off and signal off */
8385/* : bl : 4 ; T4 : the duration signal off and Vdd off */
8386/* --------------------------------------------------------------------- */
8387void XGI_XG21SetPanelDelay(USHORT tempbl, PVB_DEVICE_INFO pVBInfo)
8388{
8389 USHORT index ;
8390
8391 index = XGI_GetLVDSOEMTableIndex( pVBInfo );
8392 if ( tempbl == 1 )
8393 XGINew_LCD_Wait_Time( pVBInfo->XG21_LVDSCapList[ index ].PSC_S1, pVBInfo ) ;
8394
8395 if ( tempbl == 2 )
8396 XGINew_LCD_Wait_Time( pVBInfo->XG21_LVDSCapList[ index ].PSC_S2, pVBInfo ) ;
8397
8398 if ( tempbl == 3 )
8399 XGINew_LCD_Wait_Time( pVBInfo->XG21_LVDSCapList[ index ].PSC_S3, pVBInfo ) ;
8400
8401 if ( tempbl == 4 )
8402 XGINew_LCD_Wait_Time( pVBInfo->XG21_LVDSCapList[ index ].PSC_S4, pVBInfo ) ;
8403}
8404
8405BOOLEAN XGI_XG21CheckLVDSMode(USHORT ModeNo,USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo )
8406{
8407 USHORT xres ,
8408 yres ,
8409 colordepth ,
8410 modeflag ,
8411 resindex ,
8412 lvdstableindex;
8413
8414 resindex = XGI_GetResInfo( ModeNo , ModeIdIndex, pVBInfo ) ;
8415 if ( ModeNo <= 0x13 )
8416 {
8417 xres = pVBInfo->StResInfo[ resindex ].HTotal ;
8418 yres = pVBInfo->StResInfo[ resindex ].VTotal ;
8419 modeflag = pVBInfo->SModeIDTable[ModeIdIndex].St_ModeFlag; /* si+St_ResInfo */
8420 }
8421 else
8422 {
8423 xres = pVBInfo->ModeResInfo[ resindex ].HTotal ; /* xres->ax */
8424 yres = pVBInfo->ModeResInfo[ resindex ].VTotal ; /* yres->bx */
8425 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex].Ext_ModeFlag ; /* si+St_ModeFlag */
8426 }
8427
8428 if ( !( modeflag & Charx8Dot ) )
8429 {
8430 xres /= 9;
8431 xres *= 8;
8432 }
8433
8434 if ( ModeNo > 0x13 )
8435 {
8436 if ( ( ModeNo>0x13 ) && ( modeflag & HalfDCLK ) )
8437 {
8438 xres *= 2 ;
8439 }
8440 if ( ( ModeNo>0x13 ) && ( modeflag & DoubleScanMode ) )
8441 {
8442 yres *= 2 ;
8443 }
8444 }
8445
8446 lvdstableindex = XGI_GetLVDSOEMTableIndex( pVBInfo );
8447 if ( xres > (pVBInfo->XG21_LVDSCapList[lvdstableindex].LVDSHDE) )
8448 return FALSE;
8449
8450 if ( yres > (pVBInfo->XG21_LVDSCapList[lvdstableindex].LVDSVDE) )
8451 return FALSE;
8452
8453 if ( ModeNo > 0x13 )
8454 {
8455 if ( ( xres != (pVBInfo->XG21_LVDSCapList[lvdstableindex].LVDSHDE) ) ||
8456 ( yres != (pVBInfo->XG21_LVDSCapList[lvdstableindex].LVDSVDE)) )
8457 {
8458 colordepth = XGI_GetColorDepth( ModeNo , ModeIdIndex, pVBInfo ) ;
8459 if ( colordepth > 2 )
8460 {
8461 return FALSE;
8462 }
8463 }
8464 }
8465 return TRUE;
8466}
8467
8468void XGI_SetXG21FPBits(PVB_DEVICE_INFO pVBInfo)
8469{
8470 UCHAR temp;
8471
8472 temp = XGINew_GetReg1( pVBInfo->P3d4 , 0x37 ) ; /* D[0] 1: 18bit */
8473 temp = ( temp & 1 ) << 6;
8474 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x06 , ~0x40 , temp ) ; /* SR06[6] 18bit Dither */
8475 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x09 , ~0xc0 , temp | 0x80 ) ; /* SR09[7] enable FP output, SR09[6] 1: sigle 18bits, 0: dual 12bits */
8476
8477}
8478
8479void XGI_SetXG27FPBits(PVB_DEVICE_INFO pVBInfo)
8480{
8481 UCHAR temp;
8482
8483 temp = XGINew_GetReg1( pVBInfo->P3d4 , 0x37 ) ; /* D[1:0] 01: 18bit, 00: dual 12, 10: single 24 */
8484 temp = ( temp & 3 ) << 6;
8485 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x06 , ~0xc0 , temp & 0x80 ) ; /* SR06[7]0: dual 12/1: single 24 [6] 18bit Dither <= 0 h/w recommend */
8486 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x09 , ~0xc0 , temp | 0x80 ) ; /* SR09[7] enable FP output, SR09[6] 1: sigle 18bits, 0: 24bits */
8487
8488}
8489
8490void XGI_SetXG21LVDSPara(USHORT ModeNo,USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo )
8491{
8492 UCHAR temp,Miscdata;
8493 USHORT xres ,
8494 yres ,
8495 modeflag ,
8496 resindex ,
8497 lvdstableindex ;
8498 USHORT LVDSHT,LVDSHBS,LVDSHRS,LVDSHRE,LVDSHBE;
8499 USHORT LVDSVT,LVDSVBS,LVDSVRS,LVDSVRE,LVDSVBE;
8500 USHORT value;
8501
8502 lvdstableindex = XGI_GetLVDSOEMTableIndex( pVBInfo );
8503
8504 temp = (UCHAR) ( ( pVBInfo->XG21_LVDSCapList[lvdstableindex].LVDS_Capability & (LCDPolarity << 8 ) ) >> 8 );
8505 temp &= LCDPolarity;
8506 Miscdata =(UCHAR) XGINew_GetReg2(pVBInfo->P3cc) ;
8507
8508 XGINew_SetReg3( pVBInfo->P3c2 , (Miscdata & 0x3F) | temp ) ;
8509
8510 temp = (UCHAR) ( pVBInfo->XG21_LVDSCapList[lvdstableindex].LVDS_Capability & LCDPolarity ) ;
8511 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x35 , ~0x80 , temp&0x80 ) ; /* SR35[7] FP VSync polarity */
8512 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x30 , ~0x20 , (temp&0x40)>>1 ) ; /* SR30[5] FP HSync polarity */
8513
8514 XGI_SetXG21FPBits(pVBInfo);
8515 resindex = XGI_GetResInfo( ModeNo , ModeIdIndex, pVBInfo ) ;
8516 if ( ModeNo <= 0x13 )
8517 {
8518 xres = pVBInfo->StResInfo[ resindex ].HTotal ;
8519 yres = pVBInfo->StResInfo[ resindex ].VTotal ;
8520 modeflag = pVBInfo->SModeIDTable[ModeIdIndex].St_ModeFlag; /* si+St_ResInfo */
8521 }
8522 else
8523 {
8524 xres = pVBInfo->ModeResInfo[ resindex ].HTotal ; /* xres->ax */
8525 yres = pVBInfo->ModeResInfo[ resindex ].VTotal ; /* yres->bx */
8526 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex].Ext_ModeFlag ; /* si+St_ModeFlag */
8527 }
8528
8529 if (!( modeflag & Charx8Dot ))
8530 xres = xres * 8 / 9;
8531
8532 LVDSHT = pVBInfo->XG21_LVDSCapList[lvdstableindex].LVDSHT;
8533
8534 LVDSHBS = xres + ( pVBInfo->XG21_LVDSCapList[lvdstableindex].LVDSHDE - xres ) / 2 ;
8535 if ( ( ModeNo<=0x13 ) && ( modeflag & HalfDCLK ) )
8536 {
8537 LVDSHBS -= xres/4 ;
8538 }
8539 if (LVDSHBS > LVDSHT) LVDSHBS -= LVDSHT ;
8540
8541 LVDSHRS = LVDSHBS + pVBInfo->XG21_LVDSCapList[lvdstableindex].LVDSHFP ;
8542 if (LVDSHRS > LVDSHT) LVDSHRS -= LVDSHT ;
8543
8544 LVDSHRE = LVDSHRS + pVBInfo->XG21_LVDSCapList[lvdstableindex].LVDSHSYNC ;
8545 if (LVDSHRE > LVDSHT) LVDSHRE -= LVDSHT ;
8546
8547 LVDSHBE = LVDSHBS + LVDSHT - pVBInfo->XG21_LVDSCapList[lvdstableindex].LVDSHDE ;
8548
8549 LVDSVT = pVBInfo->XG21_LVDSCapList[lvdstableindex].LVDSVT;
8550
8551 LVDSVBS = yres + ( pVBInfo->XG21_LVDSCapList[lvdstableindex].LVDSVDE - yres ) / 2 ;
8552 if ( ( ModeNo>0x13 ) && ( modeflag & DoubleScanMode ) )
8553 {
8554 LVDSVBS += yres/2 ;
8555 }
8556 if (LVDSVBS > LVDSVT) LVDSVBS -= LVDSVT ;
8557
8558 LVDSVRS = LVDSVBS + pVBInfo->XG21_LVDSCapList[lvdstableindex].LVDSVFP ;
8559 if (LVDSVRS > LVDSVT) LVDSVRS -= LVDSVT ;
8560
8561 LVDSVRE = LVDSVRS + pVBInfo->XG21_LVDSCapList[lvdstableindex].LVDSVSYNC ;
8562 if (LVDSVRE > LVDSVT) LVDSVRE -= LVDSVT ;
8563
8564 LVDSVBE = LVDSVBS + LVDSVT - pVBInfo->XG21_LVDSCapList[lvdstableindex].LVDSVDE ;
8565
8566 temp = ( UCHAR )XGINew_GetReg1( pVBInfo->P3d4 , 0x11 ) ;
8567 XGINew_SetReg1( pVBInfo->P3d4 , 0x11 , temp & 0x7f ) ; /* Unlock CRTC */
8568
8569 if (!( modeflag & Charx8Dot ))
8570 {
8571 XGINew_SetRegOR( pVBInfo->P3c4 , 0x1 , 0x1 ) ;
8572 }
8573
8574 /* HT SR0B[1:0] CR00 */
8575 value = ( LVDSHT >> 3 ) - 5;
8576 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x0B , ~0x03 , ( value & 0x300 ) >> 8 ) ;
8577 XGINew_SetReg1( pVBInfo->P3d4 , 0x0 , (value & 0xFF) ) ;
8578
8579 /* HBS SR0B[5:4] CR02 */
8580 value = ( LVDSHBS >> 3 ) - 1;
8581 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x0B , ~0x30 , ( value & 0x300 ) >> 4 ) ;
8582 XGINew_SetReg1( pVBInfo->P3d4 , 0x2 , (value & 0xFF) ) ;
8583
8584 /* HBE SR0C[1:0] CR05[7] CR03[4:0] */
8585 value = ( LVDSHBE >> 3 ) - 1;
8586 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x0C , ~0x03 , ( value & 0xC0 ) >> 6 ) ;
8587 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x05 , ~0x80 , ( value & 0x20 ) << 2 ) ;
8588 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x03 , ~0x1F , value & 0x1F ) ;
8589
8590 /* HRS SR0B[7:6] CR04 */
8591 value = ( LVDSHRS >> 3 ) + 2;
8592 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x0B , ~0xC0 , ( value & 0x300 ) >> 2 ) ;
8593 XGINew_SetReg1( pVBInfo->P3d4 , 0x4 , (value & 0xFF) ) ;
8594
8595 /* Panel HRS SR2F[1:0] SR2E[7:0] */
8596 value--;
8597 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x2F , ~0x03 , ( value & 0x300 ) >> 8 ) ;
8598 XGINew_SetReg1( pVBInfo->P3c4 , 0x2E , (value & 0xFF) ) ;
8599
8600 /* HRE SR0C[2] CR05[4:0] */
8601 value = ( LVDSHRE >> 3 ) + 2;
8602 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x0C , ~0x04 , ( value & 0x20 ) >> 3 ) ;
8603 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x05 , ~0x1F , value & 0x1F ) ;
8604
8605 /* Panel HRE SR2F[7:2] */
8606 value--;
8607 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x2F , ~0xFC , value << 2 ) ;
8608
8609 /* VT SR0A[0] CR07[5][0] CR06 */
8610 value = LVDSVT - 2 ;
8611 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x0A , ~0x01 , ( value & 0x400 ) >> 10 ) ;
8612 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x07 , ~0x20 , ( value & 0x200 ) >> 4 ) ;
8613 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x07 , ~0x01 , ( value & 0x100 ) >> 8 ) ;
8614 XGINew_SetReg1( pVBInfo->P3d4 , 0x06 , (value & 0xFF) ) ;
8615
8616 /* VBS SR0A[2] CR09[5] CR07[3] CR15 */
8617 value = LVDSVBS - 1 ;
8618 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x0A , ~0x04 , ( value & 0x400 ) >> 8 ) ;
8619 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x09 , ~0x20 , ( value & 0x200 ) >> 4 ) ;
8620 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x07 , ~0x08 , ( value & 0x100 ) >> 5 ) ;
8621 XGINew_SetReg1( pVBInfo->P3d4 , 0x15 , (value & 0xFF) ) ;
8622
8623 /* VBE SR0A[4] CR16 */
8624 value = LVDSVBE - 1;
8625 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x0A , ~0x10 , ( value & 0x100 ) >> 4 ) ;
8626 XGINew_SetReg1( pVBInfo->P3d4 , 0x16 , (value & 0xFF) ) ;
8627
8628 /* VRS SR0A[3] CR7[7][2] CR10 */
8629 value = LVDSVRS - 1 ;
8630 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x0A , ~0x08 , ( value & 0x400 ) >> 7 ) ;
8631 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x07 , ~0x80 , ( value & 0x200 ) >> 2 ) ;
8632 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x07 , ~0x04 , ( value & 0x100 ) >> 6 ) ;
8633 XGINew_SetReg1( pVBInfo->P3d4 , 0x10 , (value & 0xFF) ) ;
8634
8635 /* Panel VRS SR3F[1:0] SR34[7:0] SR33[0] */
8636 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x3F , ~0x03 , ( value & 0x600 ) >> 9 ) ;
8637 XGINew_SetReg1( pVBInfo->P3c4 , 0x34 , (value >> 1) & 0xFF ) ;
8638 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x33 , ~0x01 , value & 0x01 ) ;
8639
8640 /* VRE SR0A[5] CR11[3:0] */
8641 value = LVDSVRE - 1;
8642 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x0A , ~0x20 , ( value & 0x10 ) << 1 ) ;
8643 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x11 , ~0x0F , value & 0x0F ) ;
8644
8645 /* Panel VRE SR3F[7:2] */ /* SR3F[7] has to be 0, h/w bug */
8646 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x3F , ~0xFC , ( value << 2 ) & 0x7C ) ;
8647
8648 for ( temp=0, value = 0; temp < 3; temp++)
8649 {
8650
8651 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x31 , ~0x30 , value ) ;
8652 XGINew_SetReg1( pVBInfo->P3c4 , 0x2B , pVBInfo->XG21_LVDSCapList[lvdstableindex].VCLKData1) ;
8653 XGINew_SetReg1( pVBInfo->P3c4 , 0x2C , pVBInfo->XG21_LVDSCapList[lvdstableindex].VCLKData2) ;
8654 value += 0x10;
8655 }
8656
8657 if (!( modeflag & Charx8Dot ))
8658 {
8659 XGINew_GetReg2( pVBInfo->P3da ) ; /* reset 3da */
8660 XGINew_SetReg3( pVBInfo->P3c0 , 0x13 ) ; /* set index */
8661 XGINew_SetReg3( pVBInfo->P3c0 , 0x00 ) ; /* set data, panning = 0, shift left 1 dot*/
8662
8663 XGINew_GetReg2( pVBInfo->P3da ) ; /* Enable Attribute */
8664 XGINew_SetReg3( pVBInfo->P3c0 , 0x20 ) ;
8665
8666 XGINew_GetReg2( pVBInfo->P3da ) ; /* reset 3da */
8667 }
8668
8669
8670}
8671
8672/* no shadow case */
8673void XGI_SetXG27LVDSPara(USHORT ModeNo,USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo )
8674{
8675 UCHAR temp,Miscdata;
8676 USHORT xres ,
8677 yres ,
8678 modeflag ,
8679 resindex ,
8680 lvdstableindex ;
8681 USHORT LVDSHT,LVDSHBS,LVDSHRS,LVDSHRE,LVDSHBE;
8682 USHORT LVDSVT,LVDSVBS,LVDSVRS,LVDSVRE,LVDSVBE;
8683 USHORT value;
8684
8685 lvdstableindex = XGI_GetLVDSOEMTableIndex( pVBInfo );
8686 temp = (UCHAR) ( ( pVBInfo->XG21_LVDSCapList[lvdstableindex].LVDS_Capability & (LCDPolarity << 8 ) ) >> 8 );
8687 temp &= LCDPolarity;
8688 Miscdata =(UCHAR) XGINew_GetReg2(pVBInfo->P3cc) ;
8689
8690 XGINew_SetReg3( pVBInfo->P3c2 , (Miscdata & 0x3F) | temp ) ;
8691
8692 temp = (UCHAR) ( pVBInfo->XG21_LVDSCapList[lvdstableindex].LVDS_Capability & LCDPolarity ) ;
8693 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x35 , ~0x80 , temp&0x80 ) ; /* SR35[7] FP VSync polarity */
8694 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x30 , ~0x20 , (temp&0x40)>>1 ) ; /* SR30[5] FP HSync polarity */
8695
8696 XGI_SetXG27FPBits(pVBInfo);
8697 resindex = XGI_GetResInfo( ModeNo , ModeIdIndex, pVBInfo ) ;
8698 if ( ModeNo <= 0x13 )
8699 {
8700 xres = pVBInfo->StResInfo[ resindex ].HTotal ;
8701 yres = pVBInfo->StResInfo[ resindex ].VTotal ;
8702 modeflag = pVBInfo->SModeIDTable[ModeIdIndex].St_ModeFlag; /* si+St_ResInfo */
8703 }
8704 else
8705 {
8706 xres = pVBInfo->ModeResInfo[ resindex ].HTotal ; /* xres->ax */
8707 yres = pVBInfo->ModeResInfo[ resindex ].VTotal ; /* yres->bx */
8708 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex].Ext_ModeFlag ; /* si+St_ModeFlag */
8709 }
8710
8711 if (!( modeflag & Charx8Dot ))
8712 xres = xres * 8 / 9;
8713
8714 LVDSHT = pVBInfo->XG21_LVDSCapList[lvdstableindex].LVDSHT;
8715
8716 LVDSHBS = xres + ( pVBInfo->XG21_LVDSCapList[lvdstableindex].LVDSHDE - xres ) / 2 ;
8717 if ( ( ModeNo<=0x13 ) && ( modeflag & HalfDCLK ) )
8718 {
8719 LVDSHBS -= xres/4 ;
8720 }
8721 if (LVDSHBS > LVDSHT) LVDSHBS -= LVDSHT ;
8722
8723 LVDSHRS = LVDSHBS + pVBInfo->XG21_LVDSCapList[lvdstableindex].LVDSHFP ;
8724 if (LVDSHRS > LVDSHT) LVDSHRS -= LVDSHT ;
8725
8726 LVDSHRE = LVDSHRS + pVBInfo->XG21_LVDSCapList[lvdstableindex].LVDSHSYNC ;
8727 if (LVDSHRE > LVDSHT) LVDSHRE -= LVDSHT ;
8728
8729 LVDSHBE = LVDSHBS + LVDSHT - pVBInfo->XG21_LVDSCapList[lvdstableindex].LVDSHDE ;
8730
8731 LVDSVT = pVBInfo->XG21_LVDSCapList[lvdstableindex].LVDSVT;
8732
8733 LVDSVBS = yres + ( pVBInfo->XG21_LVDSCapList[lvdstableindex].LVDSVDE - yres ) / 2 ;
8734 if ( ( ModeNo>0x13 ) && ( modeflag & DoubleScanMode ) )
8735 {
8736 LVDSVBS += yres/2 ;
8737 }
8738 if (LVDSVBS > LVDSVT) LVDSVBS -= LVDSVT ;
8739
8740 LVDSVRS = LVDSVBS + pVBInfo->XG21_LVDSCapList[lvdstableindex].LVDSVFP ;
8741 if (LVDSVRS > LVDSVT) LVDSVRS -= LVDSVT ;
8742
8743 LVDSVRE = LVDSVRS + pVBInfo->XG21_LVDSCapList[lvdstableindex].LVDSVSYNC ;
8744 if (LVDSVRE > LVDSVT) LVDSVRE -= LVDSVT ;
8745
8746 LVDSVBE = LVDSVBS + LVDSVT - pVBInfo->XG21_LVDSCapList[lvdstableindex].LVDSVDE ;
8747
8748 temp = ( UCHAR )XGINew_GetReg1( pVBInfo->P3d4 , 0x11 ) ;
8749 XGINew_SetReg1( pVBInfo->P3d4 , 0x11 , temp & 0x7f ) ; /* Unlock CRTC */
8750
8751 if (!( modeflag & Charx8Dot ))
8752 {
8753 XGINew_SetRegOR( pVBInfo->P3c4 , 0x1 , 0x1 ) ;
8754 }
8755
8756 /* HT SR0B[1:0] CR00 */
8757 value = ( LVDSHT >> 3 ) - 5;
8758 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x0B , ~0x03 , ( value & 0x300 ) >> 8 ) ;
8759 XGINew_SetReg1( pVBInfo->P3d4 , 0x0 , (value & 0xFF) ) ;
8760
8761 /* HBS SR0B[5:4] CR02 */
8762 value = ( LVDSHBS >> 3 ) - 1;
8763 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x0B , ~0x30 , ( value & 0x300 ) >> 4 ) ;
8764 XGINew_SetReg1( pVBInfo->P3d4 , 0x2 , (value & 0xFF) ) ;
8765
8766 /* HBE SR0C[1:0] CR05[7] CR03[4:0] */
8767 value = ( LVDSHBE >> 3 ) - 1;
8768 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x0C , ~0x03 , ( value & 0xC0 ) >> 6 ) ;
8769 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x05 , ~0x80 , ( value & 0x20 ) << 2 ) ;
8770 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x03 , ~0x1F , value & 0x1F ) ;
8771
8772 /* HRS SR0B[7:6] CR04 */
8773 value = ( LVDSHRS >> 3 ) + 2;
8774 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x0B , ~0xC0 , ( value & 0x300 ) >> 2 ) ;
8775 XGINew_SetReg1( pVBInfo->P3d4 , 0x4 , (value & 0xFF) ) ;
8776
8777 /* Panel HRS SR2F[1:0] SR2E[7:0] */
8778 value--;
8779 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x2F , ~0x03 , ( value & 0x300 ) >> 8 ) ;
8780 XGINew_SetReg1( pVBInfo->P3c4 , 0x2E , (value & 0xFF) ) ;
8781
8782 /* HRE SR0C[2] CR05[4:0] */
8783 value = ( LVDSHRE >> 3 ) + 2;
8784 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x0C , ~0x04 , ( value & 0x20 ) >> 3 ) ;
8785 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x05 , ~0x1F , value & 0x1F ) ;
8786
8787 /* Panel HRE SR2F[7:2] */
8788 value--;
8789 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x2F , ~0xFC , value << 2 ) ;
8790
8791 /* VT SR0A[0] CR07[5][0] CR06 */
8792 value = LVDSVT - 2 ;
8793 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x0A , ~0x01 , ( value & 0x400 ) >> 10 ) ;
8794 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x07 , ~0x20 , ( value & 0x200 ) >> 4 ) ;
8795 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x07 , ~0x01 , ( value & 0x100 ) >> 8 ) ;
8796 XGINew_SetReg1( pVBInfo->P3d4 , 0x06 , (value & 0xFF) ) ;
8797
8798 /* VBS SR0A[2] CR09[5] CR07[3] CR15 */
8799 value = LVDSVBS - 1 ;
8800 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x0A , ~0x04 , ( value & 0x400 ) >> 8 ) ;
8801 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x09 , ~0x20 , ( value & 0x200 ) >> 4 ) ;
8802 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x07 , ~0x08 , ( value & 0x100 ) >> 5 ) ;
8803 XGINew_SetReg1( pVBInfo->P3d4 , 0x15 , (value & 0xFF) ) ;
8804
8805 /* VBE SR0A[4] CR16 */
8806 value = LVDSVBE - 1;
8807 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x0A , ~0x10 , ( value & 0x100 ) >> 4 ) ;
8808 XGINew_SetReg1( pVBInfo->P3d4 , 0x16 , (value & 0xFF) ) ;
8809
8810 /* VRS SR0A[3] CR7[7][2] CR10 */
8811 value = LVDSVRS - 1 ;
8812 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x0A , ~0x08 , ( value & 0x400 ) >> 7 ) ;
8813 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x07 , ~0x80 , ( value & 0x200 ) >> 2 ) ;
8814 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x07 , ~0x04 , ( value & 0x100 ) >> 6 ) ;
8815 XGINew_SetReg1( pVBInfo->P3d4 , 0x10 , (value & 0xFF) ) ;
8816
8817 /* Panel VRS SR35[2:0] SR34[7:0] */
8818 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x35 , ~0x07 , ( value & 0x700 ) >> 8 ) ;
8819 XGINew_SetReg1( pVBInfo->P3c4 , 0x34 , value & 0xFF ) ;
8820
8821 /* VRE SR0A[5] CR11[3:0] */
8822 value = LVDSVRE - 1;
8823 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x0A , ~0x20 , ( value & 0x10 ) << 1 ) ;
8824 XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x11 , ~0x0F , value & 0x0F ) ;
8825
8826 /* Panel VRE SR3F[7:2] */
8827 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x3F , ~0xFC , ( value << 2 ) & 0xFC ) ;
8828
8829 for ( temp=0, value = 0; temp < 3; temp++)
8830 {
8831
8832 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x31 , ~0x30 , value ) ;
8833 XGINew_SetReg1( pVBInfo->P3c4 , 0x2B , pVBInfo->XG21_LVDSCapList[lvdstableindex].VCLKData1) ;
8834 XGINew_SetReg1( pVBInfo->P3c4 , 0x2C , pVBInfo->XG21_LVDSCapList[lvdstableindex].VCLKData2) ;
8835 value += 0x10;
8836 }
8837
8838 if (!( modeflag & Charx8Dot ))
8839 {
8840 XGINew_GetReg2( pVBInfo->P3da ) ; /* reset 3da */
8841 XGINew_SetReg3( pVBInfo->P3c0 , 0x13 ) ; /* set index */
8842 XGINew_SetReg3( pVBInfo->P3c0 , 0x00 ) ; /* set data, panning = 0, shift left 1 dot*/
8843
8844 XGINew_GetReg2( pVBInfo->P3da ) ; /* Enable Attribute */
8845 XGINew_SetReg3( pVBInfo->P3c0 , 0x20 ) ;
8846
8847 XGINew_GetReg2( pVBInfo->P3da ) ; /* reset 3da */
8848 }
8849
8850
8851}
8852
8853/* --------------------------------------------------------------------- */
8854/* Function : XGI_IsLCDON */
8855/* Input : */
8856/* Output : FALSE : Skip PSC Control */
8857/* TRUE: Disable PSC */
8858/* Description : */
8859/* --------------------------------------------------------------------- */
8860BOOLEAN XGI_IsLCDON(PVB_DEVICE_INFO pVBInfo)
8861{
8862 USHORT tempax ;
8863
8864 tempax = pVBInfo->VBInfo ;
8865 if ( tempax & SetCRT2ToDualEdge )
8866 return FALSE ;
8867 else if ( tempax & ( DisableCRT2Display | SwitchToCRT2 | SetSimuScanMode ) )
8868 return TRUE ;
8869
8870 return FALSE ;
8871}
8872
8873
8874/* --------------------------------------------------------------------- */
8875/* Function : XGI_EnablePWD */
8876/* Input : */
8877/* Output : */
8878/* Description : */
8879/* --------------------------------------------------------------------- */
8880void XGI_EnablePWD( PVB_DEVICE_INFO pVBInfo )
8881{
8882 USHORT index ,
8883 temp ;
8884
8885 index = XGI_GetLCDCapPtr(pVBInfo) ;
8886 temp = pVBInfo->LCDCapList[ index ].PWD_2B ;
8887 XGINew_SetReg1( pVBInfo->Part4Port , 0x2B , temp ) ;
8888 XGINew_SetReg1( pVBInfo->Part4Port , 0x2C , pVBInfo->LCDCapList[ index ].PWD_2C ) ;
8889 XGINew_SetReg1( pVBInfo->Part4Port , 0x2D , pVBInfo->LCDCapList[ index ].PWD_2D ) ;
8890 XGINew_SetReg1( pVBInfo->Part4Port , 0x2E , pVBInfo->LCDCapList[ index ].PWD_2E ) ;
8891 XGINew_SetReg1( pVBInfo->Part4Port , 0x2F , pVBInfo->LCDCapList[ index ].PWD_2F ) ;
8892 XGINew_SetRegOR( pVBInfo->Part4Port , 0x27 , 0x80 ) ; /* enable PWD */
8893}
8894
8895
8896/* --------------------------------------------------------------------- */
8897/* Function : XGI_DisablePWD */
8898/* Input : */
8899/* Output : */
8900/* Description : */
8901/* --------------------------------------------------------------------- */
8902void XGI_DisablePWD( PVB_DEVICE_INFO pVBInfo )
8903{
8904 XGINew_SetRegAND( pVBInfo->Part4Port , 0x27 , 0x7F ) ; /* disable PWD */
8905}
8906
8907
8908/* --------------------------------------------------------------------- */
8909/* Function : XGI_DisableChISLCD */
8910/* Input : */
8911/* Output : FALSE -> Not LCD Mode */
8912/* Description : */
8913/* --------------------------------------------------------------------- */
8914BOOLEAN XGI_DisableChISLCD(PVB_DEVICE_INFO pVBInfo)
8915{
8916 USHORT tempbx ,
8917 tempah ;
8918
8919 tempbx = pVBInfo->SetFlag & ( DisableChA | DisableChB ) ;
8920 tempah = ~( ( USHORT )XGINew_GetReg1( pVBInfo->Part1Port , 0x2E ) ) ;
8921
8922 if ( tempbx & ( EnableChA | DisableChA ) )
8923 {
8924 if ( !( tempah & 0x08 ) ) /* Chk LCDA Mode */
8925 return FALSE ;
8926 }
8927
8928 if ( !( tempbx & ( EnableChB | DisableChB ) ) )
8929 return FALSE ;
8930
8931 if ( tempah & 0x01 ) /* Chk LCDB Mode */
8932 return TRUE ;
8933
8934 return FALSE ;
8935}
8936
8937
8938/* --------------------------------------------------------------------- */
8939/* Function : XGI_EnableChISLCD */
8940/* Input : */
8941/* Output : 0 -> Not LCD mode */
8942/* Description : */
8943/* --------------------------------------------------------------------- */
8944BOOLEAN XGI_EnableChISLCD(PVB_DEVICE_INFO pVBInfo)
8945{
8946 USHORT tempbx ,
8947 tempah ;
8948
8949
8950 tempbx = pVBInfo->SetFlag & ( EnableChA | EnableChB ) ;
8951 tempah = ~( ( USHORT )XGINew_GetReg1( pVBInfo->Part1Port , 0x2E ) ) ;
8952
8953 if ( tempbx & ( EnableChA | DisableChA ) )
8954 {
8955 if ( !( tempah & 0x08 ) ) /* Chk LCDA Mode */
8956 return FALSE ;
8957 }
8958
8959 if ( !( tempbx & ( EnableChB | DisableChB ) ) )
8960 return FALSE ;
8961
8962 if ( tempah & 0x01 ) /* Chk LCDB Mode */
8963 return TRUE ;
8964
8965 return FALSE ;
8966}
8967
8968
8969/* --------------------------------------------------------------------- */
8970/* Function : XGI_GetLCDCapPtr */
8971/* Input : */
8972/* Output : */
8973/* Description : */
8974/* --------------------------------------------------------------------- */
8975USHORT XGI_GetLCDCapPtr( PVB_DEVICE_INFO pVBInfo )
8976{
8977 UCHAR tempal ,
8978 tempah ,
8979 tempbl ,
8980 i ;
8981
8982 tempah = XGINew_GetReg1( pVBInfo->P3d4 , 0x36 ) ;
8983 tempal = tempah & 0x0F ;
8984 tempah = tempah & 0xF0 ;
8985 i = 0 ;
8986 tempbl = pVBInfo->LCDCapList[ i ].LCD_ID ;
8987
8988 while( tempbl != 0xFF )
8989 {
8990 if ( tempbl & 0x80 ) /* OEMUtil */
8991 {
8992 tempal = tempah ;
8993 tempbl = tempbl & ~( 0x80 ) ;
8994 }
8995
8996 if ( tempal == tempbl )
8997 break ;
8998
8999 i++ ;
9000
9001 tempbl = pVBInfo->LCDCapList[ i ].LCD_ID ;
9002 }
9003
9004 return i ;
9005}
9006
9007
9008/* --------------------------------------------------------------------- */
9009/* Function : XGI_GetLCDCapPtr1 */
9010/* Input : */
9011/* Output : */
9012/* Description : */
9013/* --------------------------------------------------------------------- */
9014USHORT XGI_GetLCDCapPtr1( PVB_DEVICE_INFO pVBInfo )
9015{
9016 USHORT tempah ,
9017 tempal ,
9018 tempbl ,
9019 i ;
9020
9021 tempal = pVBInfo->LCDResInfo ;
9022 tempah = pVBInfo->LCDTypeInfo ;
9023
9024 i = 0 ;
9025 tempbl = pVBInfo->LCDCapList[ i ].LCD_ID;
9026
9027 while( tempbl != 0xFF )
9028 {
9029 if ( ( tempbl & 0x80 ) && ( tempbl != 0x80 ) )
9030 {
9031 tempal = tempah ;
9032 tempbl &= ~0x80 ;
9033 }
9034
9035 if ( tempal == tempbl )
9036 break ;
9037
9038 i++ ;
9039 tempbl = pVBInfo->LCDCapList[ i ].LCD_ID ;
9040 }
9041
9042 if ( tempbl == 0xFF )
9043 {
9044 pVBInfo->LCDResInfo = Panel1024x768 ;
9045 pVBInfo->LCDTypeInfo = 0 ;
9046 i = 0 ;
9047 }
9048
9049 return i ;
9050}
9051
9052
9053/* --------------------------------------------------------------------- */
9054/* Function : XGI_GetLCDSync */
9055/* Input : */
9056/* Output : */
9057/* Description : */
9058/* --------------------------------------------------------------------- */
9059void XGI_GetLCDSync( USHORT* HSyncWidth , USHORT* VSyncWidth, PVB_DEVICE_INFO pVBInfo )
9060{
9061 USHORT Index ;
9062
9063 Index = XGI_GetLCDCapPtr(pVBInfo) ;
9064 *HSyncWidth = pVBInfo->LCDCapList[ Index ].LCD_HSyncWidth ;
9065 *VSyncWidth = pVBInfo->LCDCapList[ Index ].LCD_VSyncWidth ;
9066
9067 return ;
9068}
9069
9070
9071
9072/* --------------------------------------------------------------------- */
9073/* Function : XGI_EnableBridge */
9074/* Input : */
9075/* Output : */
9076/* Description : */
9077/* --------------------------------------------------------------------- */
9078void XGI_EnableBridge( PXGI_HW_DEVICE_INFO HwDeviceExtension , PVB_DEVICE_INFO pVBInfo)
9079{
9080 USHORT tempbl ,
9081 tempah ;
9082
9083 if ( pVBInfo->SetFlag == Win9xDOSMode )
9084 {
9085 if ( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
9086 {
9087 XGI_DisplayOn( HwDeviceExtension, pVBInfo) ;
9088 return ;
9089 }
9090 else /* LVDS or CH7017 */
9091 return ;
9092 }
9093
9094
9095 if ( HwDeviceExtension->jChipType < XG40 )
9096 {
9097 if ( !XGI_DisableChISLCD(pVBInfo) )
9098 {
9099 if ( ( XGI_EnableChISLCD(pVBInfo) ) || ( pVBInfo->VBInfo & ( SetCRT2ToLCD | SetCRT2ToLCDA ) ) )
9100 {
9101 if ( pVBInfo->LCDInfo & SetPWDEnable )
9102 {
9103 XGI_EnablePWD( pVBInfo);
9104 }
9105 else
9106 {
9107 pVBInfo->LCDInfo &= ( ~SetPWDEnable ) ;
9108 if ( pVBInfo->VBType & ( VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
9109 {
9110 tempbl = 0xFD ;
9111 tempah = 0x02 ;
9112 }
9113 else
9114 {
9115 tempbl = 0xFB ;
9116 tempah = 0x00 ;
9117 }
9118
9119 XGI_SetPanelPower( tempah , tempbl, pVBInfo ) ;
9120 XGI_SetPanelDelay( 1,pVBInfo ) ;
9121 }
9122 }
9123 }
9124 } /* Not 340 */
9125
9126
9127
9128 if ( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
9129 {
9130 if ( !( pVBInfo->SetFlag & DisableChA ) )
9131 {
9132 if ( pVBInfo->SetFlag & EnableChA )
9133 {
9134 XGINew_SetReg1( pVBInfo->Part1Port , 0x1E , 0x20 ) ; /* Power on */
9135 }
9136 else
9137 {
9138 if ( pVBInfo->VBInfo & SetCRT2ToDualEdge ) /* SetCRT2ToLCDA ) */
9139 {
9140 XGINew_SetReg1(pVBInfo->Part1Port,0x1E,0x20); /* Power on */
9141 }
9142 }
9143 }
9144
9145 if ( !( pVBInfo->SetFlag & DisableChB ) )
9146 {
9147 if ( ( pVBInfo->SetFlag & EnableChB ) || ( pVBInfo->VBInfo & ( SetCRT2ToLCD | SetCRT2ToTV | SetCRT2ToRAMDAC ) ) )
9148 {
9149 tempah = ( UCHAR )XGINew_GetReg1( pVBInfo->P3c4 , 0x32 ) ;
9150 tempah &= 0xDF;
9151 if ( pVBInfo->VBInfo & SetInSlaveMode )
9152 {
9153 if ( !( pVBInfo->VBInfo & SetCRT2ToRAMDAC ) )
9154 tempah |= 0x20 ;
9155 }
9156 XGINew_SetReg1( pVBInfo->P3c4 , 0x32 , tempah ) ;
9157 XGINew_SetRegOR( pVBInfo->P3c4 , 0x1E , 0x20 ) ;
9158
9159
9160 tempah = ( UCHAR )XGINew_GetReg1( pVBInfo->Part1Port , 0x2E ) ;
9161
9162 if ( !( tempah & 0x80 ) )
9163 XGINew_SetRegOR( pVBInfo->Part1Port , 0x2E , 0x80 ) ; /* BVBDOENABLE = 1 */
9164
9165 XGINew_SetRegAND( pVBInfo->Part1Port , 0x00 , 0x7F ) ; /* BScreenOFF = 0 */
9166 }
9167 }
9168
9169 if ( ( pVBInfo->SetFlag & ( EnableChA | EnableChB ) ) || ( !( pVBInfo->VBInfo & DisableCRT2Display ) ) )
9170 {
9171 XGINew_SetRegANDOR( pVBInfo->Part2Port , 0x00 , ~0xE0 , 0x20 ) ; /* shampoo 0129 */
9172 if ( pVBInfo->VBType & ( VB_XGI302LV | VB_XGI301C ) )
9173 {
9174 if ( !XGI_DisableChISLCD(pVBInfo) )
9175 {
9176 if ( XGI_EnableChISLCD( pVBInfo) || ( pVBInfo->VBInfo & ( SetCRT2ToLCD | SetCRT2ToLCDA ) ) )
9177 XGINew_SetRegAND( pVBInfo->Part4Port ,0x2A , 0x7F ) ; /* LVDS PLL power on */
9178 }
9179 XGINew_SetRegAND( pVBInfo->Part4Port , 0x30 , 0x7F ) ; /* LVDS Driver power on */
9180 }
9181 }
9182
9183 tempah = 0x00 ;
9184
9185 if ( !( pVBInfo->VBInfo & DisableCRT2Display ) )
9186 {
9187 tempah = 0xc0 ;
9188
9189 if ( !( pVBInfo->VBInfo & SetSimuScanMode ) )
9190 {
9191 if ( pVBInfo->VBInfo & SetCRT2ToLCDA )
9192 {
9193 if ( pVBInfo->VBInfo & SetCRT2ToDualEdge )
9194 {
9195 tempah = tempah & 0x40;
9196 if ( pVBInfo->VBInfo & SetCRT2ToLCDA )
9197 tempah = tempah ^ 0xC0 ;
9198
9199 if ( pVBInfo->SetFlag & DisableChB )
9200 tempah &= 0xBF ;
9201
9202 if ( pVBInfo->SetFlag & DisableChA )
9203 tempah &= 0x7F ;
9204
9205 if ( pVBInfo->SetFlag & EnableChB )
9206 tempah |= 0x40 ;
9207
9208 if ( pVBInfo->SetFlag & EnableChA )
9209 tempah |= 0x80 ;
9210 }
9211 }
9212 }
9213 }
9214
9215 XGINew_SetRegOR( pVBInfo->Part4Port , 0x1F , tempah ) ; /* EnablePart4_1F */
9216
9217 if ( pVBInfo->SetFlag & Win9xDOSMode )
9218 {
9219 XGI_DisplayOn( HwDeviceExtension, pVBInfo) ;
9220 return ;
9221 }
9222
9223 if ( !( pVBInfo->SetFlag & DisableChA ) )
9224 {
9225 XGI_VBLongWait( pVBInfo) ;
9226 if ( !( pVBInfo->SetFlag & GatingCRT ) )
9227 {
9228 XGI_DisableGatingCRT( HwDeviceExtension, pVBInfo ) ;
9229 XGI_DisplayOn( HwDeviceExtension, pVBInfo) ;
9230 XGI_VBLongWait( pVBInfo) ;
9231 }
9232 }
9233 } /* 301 */
9234 else /* LVDS */
9235 {
9236 if ( pVBInfo->VBInfo & ( SetCRT2ToTV | SetCRT2ToLCD | SetCRT2ToLCDA ) )
9237 XGINew_SetRegOR( pVBInfo->Part1Port , 0x1E , 0x20 ) ; /* enable CRT2 */
9238
9239
9240
9241 tempah = ( UCHAR )XGINew_GetReg1( pVBInfo->Part1Port , 0x2E ) ;
9242 if ( !( tempah & 0x80 ) )
9243 XGINew_SetRegOR( pVBInfo->Part1Port , 0x2E , 0x80 ) ; /* BVBDOENABLE = 1 */
9244
9245 XGINew_SetRegAND(pVBInfo->Part1Port,0x00,0x7F);
9246 XGI_DisplayOn( HwDeviceExtension, pVBInfo);
9247 } /* End of VB */
9248
9249
9250 if ( HwDeviceExtension->jChipType < XG40 )
9251 {
9252 if ( !XGI_EnableChISLCD(pVBInfo) )
9253 {
9254 if ( pVBInfo->VBInfo & ( SetCRT2ToLCD | SetCRT2ToLCDA ) )
9255 {
9256 if ( XGI_BacklightByDrv(pVBInfo) )
9257 return ;
9258 }
9259 else
9260 return ;
9261 }
9262
9263 if ( pVBInfo->LCDInfo & SetPWDEnable )
9264 {
9265 XGI_FirePWDEnable(pVBInfo) ;
9266 return ;
9267 }
9268
9269 XGI_SetPanelDelay( 2,pVBInfo ) ;
9270
9271 if ( pVBInfo->VBType & ( VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
9272 {
9273 tempah = 0x01 ;
9274 tempbl = 0xFE ; /* turn on backlght */
9275 }
9276 else
9277 {
9278 tempbl = 0xF7 ;
9279 tempah = 0x00 ;
9280 }
9281 XGI_SetPanelPower( tempah , tempbl , pVBInfo) ;
9282 }
9283}
9284
9285
9286/* --------------------------------------------------------------------- */
9287/* Function : XGI_DisableBridge */
9288/* Input : */
9289/* Output : */
9290/* Description : */
9291/* --------------------------------------------------------------------- */
9292void XGI_DisableBridge(PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo)
9293{
9294 USHORT tempax ,
9295 tempbx ,
9296 tempah = 0 ,
9297 tempbl = 0 ;
9298
9299 if ( pVBInfo->SetFlag == Win9xDOSMode )
9300 return ;
9301
9302
9303 if ( HwDeviceExtension->jChipType < XG40 )
9304 {
9305 if ( ( !( pVBInfo->VBInfo & ( SetCRT2ToLCD | SetCRT2ToLCDA ) ) ) || ( XGI_DisableChISLCD(pVBInfo) ) )
9306 {
9307 if ( !XGI_IsLCDON(pVBInfo) )
9308 {
9309 if ( pVBInfo->LCDInfo & SetPWDEnable )
9310 XGI_EnablePWD( pVBInfo) ;
9311 else
9312 {
9313 pVBInfo->LCDInfo &= ~SetPWDEnable ;
9314 XGI_DisablePWD(pVBInfo) ;
9315 if ( pVBInfo->VBType & ( VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
9316 {
9317 tempbx = 0xFE ; /* not 01h */
9318 tempax = 0 ;
9319 }
9320 else
9321 {
9322 tempbx = 0xF7 ; /* not 08h */
9323 tempax = 0x08 ;
9324 }
9325 XGI_SetPanelPower( tempax , tempbx , pVBInfo) ;
9326 XGI_SetPanelDelay( 3,pVBInfo ) ;
9327 }
9328 } /* end if(!XGI_IsLCDON(pVBInfo)) */
9329 }
9330 }
9331
9332/* if ( CH7017 )
9333 {
9334 if ( !( pVBInfo->VBInfo & ( SetCRT2ToLCD | SetCRT2toLCDA ) ) || ( XGI_DisableChISLCD(pVBInfo) ) )
9335 {
9336 if ( !XGI_IsLCDON(pVBInfo) )
9337 {
9338 if ( DISCHARGE )
9339 {
9340 tempbx = XGINew_GetCH7005( 0x61 ) ;
9341 if ( tempbx < 0x01 ) //first time we power up
9342 XGINew_SetCH7005( 0x0066 ) ; //and disable power sequence
9343 else
9344 XGINew_SetCH7005( 0x5f66 ) ; //leave VDD on - disable power
9345 }
9346 }
9347 }
9348 } */
9349
9350 if ( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B| VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
9351 {
9352 tempah = 0x3F ;
9353 if ( !( pVBInfo->VBInfo & ( DisableCRT2Display | SetSimuScanMode ) ) )
9354 {
9355 if ( pVBInfo->VBInfo & SetCRT2ToLCDA )
9356 {
9357 if ( pVBInfo->VBInfo & SetCRT2ToDualEdge )
9358 {
9359 tempah = 0x7F; /* Disable Channel A */
9360 if ( !( pVBInfo->VBInfo & SetCRT2ToLCDA ) )
9361 tempah = 0xBF ; /* Disable Channel B */
9362
9363 if ( pVBInfo->SetFlag & DisableChB )
9364 tempah &= 0xBF ; /* force to disable Cahnnel */
9365
9366 if ( pVBInfo->SetFlag & DisableChA )
9367 tempah &= 0x7F ; /* Force to disable Channel B */
9368 }
9369 }
9370 }
9371
9372 XGINew_SetRegAND( pVBInfo->Part4Port , 0x1F , tempah ) ; /* disable part4_1f */
9373
9374 if ( pVBInfo->VBType & ( VB_XGI302LV | VB_XGI301C ) )
9375 {
9376 if ( ( ( pVBInfo->VBInfo & ( SetCRT2ToLCD | SetCRT2ToLCDA ) ) ) || ( XGI_DisableChISLCD(pVBInfo) ) || ( XGI_IsLCDON(pVBInfo) ) )
9377 XGINew_SetRegOR( pVBInfo->Part4Port , 0x30 , 0x80 ) ; /* LVDS Driver power down */
9378 }
9379
9380 if ( ( pVBInfo->SetFlag & DisableChA ) || ( pVBInfo->VBInfo & ( DisableCRT2Display | SetCRT2ToLCDA | SetSimuScanMode ) ) )
9381 {
9382 if ( pVBInfo->SetFlag & GatingCRT )
9383 XGI_EnableGatingCRT( HwDeviceExtension, pVBInfo ) ;
9384 XGI_DisplayOff( HwDeviceExtension, pVBInfo) ;
9385 }
9386
9387 if ( pVBInfo->VBInfo & SetCRT2ToLCDA )
9388 {
9389 if ( ( pVBInfo->SetFlag & DisableChA ) || ( pVBInfo->VBInfo & SetCRT2ToLCDA ) )
9390 XGINew_SetRegAND( pVBInfo->Part1Port , 0x1e , 0xdf ) ; /* Power down */
9391 }
9392
9393 XGINew_SetRegAND( pVBInfo->P3c4 , 0x32 , 0xdf ) ; /* disable TV as primary VGA swap */
9394
9395 if ( ( pVBInfo->VBInfo & ( SetSimuScanMode | SetCRT2ToDualEdge ) ) )
9396 XGINew_SetRegAND(pVBInfo->Part2Port,0x00,0xdf);
9397
9398 if ( ( pVBInfo->SetFlag & DisableChB ) || ( pVBInfo->VBInfo & ( DisableCRT2Display | SetSimuScanMode ) )
9399 || ( ( !( pVBInfo->VBInfo & SetCRT2ToLCDA ) ) && ( pVBInfo->VBInfo & ( SetCRT2ToRAMDAC | SetCRT2ToLCD | SetCRT2ToTV ) ) ) )
9400 XGINew_SetRegOR( pVBInfo->Part1Port , 0x00 , 0x80 ) ; /* BScreenOff=1 */
9401
9402 if ( ( pVBInfo->SetFlag & DisableChB ) || ( pVBInfo->VBInfo & ( DisableCRT2Display | SetSimuScanMode ) )
9403 || ( !( pVBInfo->VBInfo & SetCRT2ToLCDA ) ) || ( pVBInfo->VBInfo & ( SetCRT2ToRAMDAC | SetCRT2ToLCD | SetCRT2ToTV ) ) )
9404 {
9405 tempah= XGINew_GetReg1( pVBInfo->Part1Port , 0x00 ) ; /* save Part1 index 0 */
9406 XGINew_SetRegOR( pVBInfo->Part1Port , 0x00 , 0x10 ) ; /* BTDAC = 1, avoid VB reset */
9407 XGINew_SetRegAND( pVBInfo->Part1Port , 0x1E , 0xDF ) ; /* disable CRT2 */
9408 XGINew_SetReg1( pVBInfo->Part1Port , 0x00 , tempah ) ; /* restore Part1 index 0 */
9409 }
9410 }
9411 else /* {301} */
9412 {
9413 if ( pVBInfo->VBInfo & ( SetCRT2ToLCD | SetCRT2ToTV ) )
9414 {
9415 XGINew_SetRegOR( pVBInfo->Part1Port , 0x00 , 0x80 ) ; /* BScreenOff=1 */
9416 XGINew_SetRegAND( pVBInfo->Part1Port , 0x1E , 0xDF ) ; /* Disable CRT2 */
9417 XGINew_SetRegAND( pVBInfo->P3c4 , 0x32 , 0xDF ) ; /* Disable TV asPrimary VGA swap */
9418 }
9419
9420 if ( pVBInfo->VBInfo & ( DisableCRT2Display | SetCRT2ToLCDA | SetSimuScanMode ) )
9421 XGI_DisplayOff( HwDeviceExtension, pVBInfo) ;
9422 }
9423
9424
9425
9426
9427 if ( HwDeviceExtension->jChipType < XG40 )
9428 {
9429 if ( !( pVBInfo->VBInfo & ( SetCRT2ToLCD | SetCRT2ToLCDA ) ) || ( XGI_DisableChISLCD(pVBInfo) ) || ( XGI_IsLCDON(pVBInfo) ) )
9430 {
9431 if ( pVBInfo->LCDInfo & SetPWDEnable )
9432 {
9433 if ( pVBInfo->LCDInfo & SetPWDEnable )
9434 XGI_BacklightByDrv(pVBInfo) ;
9435 else
9436 {
9437 XGI_SetPanelDelay( 4 ,pVBInfo) ;
9438 if ( pVBInfo->VBType & VB_XGI301LV )
9439 {
9440 tempbl = 0xFD ;
9441 tempah = 0x00 ;
9442 }
9443 else
9444 {
9445 tempbl = 0xFB ;
9446 tempah = 0x04 ;
9447 }
9448 }
9449 }
9450 XGI_SetPanelPower( tempah , tempbl , pVBInfo) ;
9451 }
9452 }
9453}
9454
9455
9456/* --------------------------------------------------------------------- */
9457/* Function : XGI_GetTVPtrIndex */
9458/* Input : */
9459/* Output : */
9460/* Description : bx 0 : ExtNTSC */
9461/* 1 : StNTSC */
9462/* 2 : ExtPAL */
9463/* 3 : StPAL */
9464/* 4 : ExtHiTV */
9465/* 5 : StHiTV */
9466/* 6 : Ext525i */
9467/* 7 : St525i */
9468/* 8 : Ext525p */
9469/* 9 : St525p */
9470/* A : Ext750p */
9471/* B : St750p */
9472/* --------------------------------------------------------------------- */
9473USHORT XGI_GetTVPtrIndex( PVB_DEVICE_INFO pVBInfo )
9474{
9475 USHORT tempbx = 0 ;
9476
9477 if ( pVBInfo->TVInfo & SetPALTV )
9478 tempbx = 2 ;
9479 if ( pVBInfo->TVInfo & SetYPbPrMode1080i )
9480 tempbx = 4 ;
9481 if ( pVBInfo->TVInfo & SetYPbPrMode525i )
9482 tempbx = 6 ;
9483 if ( pVBInfo->TVInfo & SetYPbPrMode525p )
9484 tempbx = 8 ;
9485 if ( pVBInfo->TVInfo & SetYPbPrMode750p )
9486 tempbx = 10 ;
9487 if ( pVBInfo->TVInfo & TVSimuMode )
9488 tempbx++ ;
9489
9490 return tempbx ;
9491}
9492
9493
9494/* --------------------------------------------------------------------- */
9495/* Function : XGI_OEM310Setting */
9496/* Input : */
9497/* Output : */
9498/* Description : Customized Param. for 301 */
9499/* --------------------------------------------------------------------- */
9500void XGI_OEM310Setting( USHORT ModeNo , USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo)
9501{
9502 if ( pVBInfo->SetFlag & Win9xDOSMode )
9503 return ;
9504
9505 /* GetPart1IO(); */
9506 XGI_SetDelayComp(pVBInfo) ;
9507
9508 if ( pVBInfo->VBInfo & ( SetCRT2ToLCD | SetCRT2ToLCDA ) )
9509 XGI_SetLCDCap(pVBInfo) ;
9510
9511 if ( pVBInfo->VBInfo & SetCRT2ToTV )
9512 {
9513 /* GetPart2IO() */
9514 XGI_SetPhaseIncr(pVBInfo) ;
9515 XGI_SetYFilter( ModeNo , ModeIdIndex,pVBInfo ) ;
9516 XGI_SetAntiFlicker( ModeNo , ModeIdIndex,pVBInfo ) ;
9517
9518 if ( pVBInfo->VBType&VB_XGI301)
9519 XGI_SetEdgeEnhance( ModeNo , ModeIdIndex ,pVBInfo) ;
9520 }
9521}
9522
9523
9524/* --------------------------------------------------------------------- */
9525/* Function : XGI_SetDelayComp */
9526/* Input : */
9527/* Output : */
9528/* Description : */
9529/* --------------------------------------------------------------------- */
9530void XGI_SetDelayComp( PVB_DEVICE_INFO pVBInfo )
9531{
9532 USHORT index ;
9533
9534 UCHAR tempah ,
9535 tempbl ,
9536 tempbh ;
9537
9538 if ( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
9539 {
9540 if ( pVBInfo->VBInfo & ( SetCRT2ToLCD | SetCRT2ToLCDA | SetCRT2ToTV | SetCRT2ToRAMDAC ) )
9541 {
9542 tempbl = 0;
9543 tempbh = 0;
9544
9545 index = XGI_GetTVPtrIndex(pVBInfo ) ; /* Get TV Delay */
9546 tempbl = pVBInfo->XGI_TVDelayList[ index ] ;
9547
9548 if ( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
9549 tempbl = pVBInfo->XGI_TVDelayList2[ index ] ;
9550
9551 if ( pVBInfo->VBInfo & SetCRT2ToDualEdge )
9552 tempbl = tempbl >> 4 ;
9553/*
9554 if ( pVBInfo->VBInfo & SetCRT2ToRAMDAC )
9555 tempbl = CRT2Delay1 ; // Get CRT2 Delay
9556
9557 if ( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
9558 tempbl = CRT2Delay2 ;
9559*/
9560 if ( pVBInfo->VBInfo & ( SetCRT2ToLCD | SetCRT2ToLCDA ) )
9561 {
9562 index = XGI_GetLCDCapPtr(pVBInfo) ; /* Get LCD Delay */
9563 tempbh=pVBInfo->LCDCapList[ index ].LCD_DelayCompensation ;
9564
9565 if ( !( pVBInfo->VBInfo & SetCRT2ToLCDA ) )
9566 tempbl = tempbh ;
9567 }
9568
9569 tempbl &= 0x0F ;
9570 tempbh &= 0xF0 ;
9571 tempah = XGINew_GetReg1( pVBInfo->Part1Port , 0x2D ) ;
9572
9573 if ( pVBInfo->VBInfo & ( SetCRT2ToRAMDAC | SetCRT2ToLCD | SetCRT2ToTV ) ) /* Channel B */
9574 {
9575 tempah &= 0xF0 ;
9576 tempah |= tempbl ;
9577 }
9578
9579 if ( pVBInfo->VBInfo & SetCRT2ToLCDA ) /* Channel A */
9580 {
9581 tempah &= 0x0F ;
9582 tempah |= tempbh ;
9583 }
9584 XGINew_SetReg1(pVBInfo->Part1Port,0x2D,tempah);
9585 }
9586 }
9587 else if ( pVBInfo->IF_DEF_LVDS == 1 )
9588 {
9589 tempbl = 0;
9590 tempbh = 0;
9591 if ( pVBInfo->VBInfo & SetCRT2ToLCD )
9592 {
9593 tempah = pVBInfo->LCDCapList[ XGI_GetLCDCapPtr(pVBInfo) ].LCD_DelayCompensation ; /* / Get LCD Delay */
9594 tempah &= 0x0f ;
9595 tempah = tempah << 4 ;
9596 XGINew_SetRegANDOR( pVBInfo->Part1Port , 0x2D , 0x0f , tempah ) ;
9597 }
9598 }
9599}
9600
9601
9602/* --------------------------------------------------------------------- */
9603/* Function : XGI_SetLCDCap */
9604/* Input : */
9605/* Output : */
9606/* Description : */
9607/* --------------------------------------------------------------------- */
9608void XGI_SetLCDCap( PVB_DEVICE_INFO pVBInfo )
9609{
9610 USHORT tempcx ;
9611
9612 tempcx = pVBInfo->LCDCapList[ XGI_GetLCDCapPtr(pVBInfo) ].LCD_Capability ;
9613
9614 if ( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
9615 {
9616 if ( pVBInfo->VBType & ( VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
9617 { /* 301LV/302LV only */
9618 /* Set 301LV Capability */
9619 XGINew_SetReg1( pVBInfo->Part4Port , 0x24 , ( UCHAR )( tempcx & 0x1F ) ) ;
9620 }
9621 /* VB Driving */
9622 XGINew_SetRegANDOR( pVBInfo->Part4Port , 0x0D , ~( ( EnableVBCLKDRVLOW | EnablePLLSPLOW ) >> 8 ) , ( USHORT )( ( tempcx & ( EnableVBCLKDRVLOW | EnablePLLSPLOW ) ) >> 8 ) ) ;
9623 }
9624
9625 if ( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
9626 {
9627 if ( pVBInfo->VBInfo & SetCRT2ToLCD )
9628 XGI_SetLCDCap_B( tempcx,pVBInfo ) ;
9629 else if ( pVBInfo->VBInfo & SetCRT2ToLCDA )
9630 XGI_SetLCDCap_A( tempcx,pVBInfo ) ;
9631
9632 if ( pVBInfo->VBType & ( VB_XGI302LV | VB_XGI301C ) )
9633 {
9634 if ( tempcx & EnableSpectrum )
9635 SetSpectrum( pVBInfo) ;
9636 }
9637 }
9638 else /* LVDS,CH7017 */
9639 XGI_SetLCDCap_A( tempcx, pVBInfo ) ;
9640}
9641
9642
9643/* --------------------------------------------------------------------- */
9644/* Function : XGI_SetLCDCap_A */
9645/* Input : */
9646/* Output : */
9647/* Description : */
9648/* --------------------------------------------------------------------- */
9649void XGI_SetLCDCap_A(USHORT tempcx,PVB_DEVICE_INFO pVBInfo)
9650{
9651 USHORT temp ;
9652
9653 temp = XGINew_GetReg1( pVBInfo->P3d4 , 0x37 ) ;
9654
9655 if ( temp & LCDRGB18Bit )
9656 {
9657 XGINew_SetRegANDOR( pVBInfo->Part1Port , 0x19 , 0x0F , ( USHORT )( 0x20 | ( tempcx & 0x00C0 ) ) ) ; /* Enable Dither */
9658 XGINew_SetRegANDOR( pVBInfo->Part1Port , 0x1A , 0x7F , 0x80 ) ;
9659 }
9660 else
9661 {
9662 XGINew_SetRegANDOR( pVBInfo->Part1Port , 0x19 , 0x0F , ( USHORT )( 0x30 | ( tempcx & 0x00C0 ) ) ) ;
9663 XGINew_SetRegANDOR( pVBInfo->Part1Port , 0x1A , 0x7F , 0x00 ) ;
9664 }
9665
9666/*
9667 if ( tempcx & EnableLCD24bpp ) // 24bits
9668 {
9669 XGINew_SetRegANDOR(pVBInfo->Part1Port,0x19, 0x0F,(USHORT)(0x30|(tempcx&0x00C0)) );
9670 XGINew_SetRegANDOR(pVBInfo->Part1Port,0x1A,0x7F,0x00);
9671 }
9672 else
9673 {
9674 XGINew_SetRegANDOR(pVBInfo->Part1Port,0x19, 0x0F,(USHORT)(0x20|(tempcx&0x00C0)) );//Enable Dither
9675 XGINew_SetRegANDOR(pVBInfo->Part1Port,0x1A,0x7F,0x80);
9676 }
9677*/
9678}
9679
9680
9681/* --------------------------------------------------------------------- */
9682/* Function : XGI_SetLCDCap_B */
9683/* Input : cx -> LCD Capability */
9684/* Output : */
9685/* Description : */
9686/* --------------------------------------------------------------------- */
9687void XGI_SetLCDCap_B(USHORT tempcx,PVB_DEVICE_INFO pVBInfo)
9688{
9689 if ( tempcx & EnableLCD24bpp ) /* 24bits */
9690 XGINew_SetRegANDOR( pVBInfo->Part2Port , 0x1A , 0xE0 , ( USHORT )( ( ( tempcx & 0x00ff ) >> 6 ) | 0x0c ) ) ;
9691 else
9692 XGINew_SetRegANDOR( pVBInfo->Part2Port , 0x1A , 0xE0 , ( USHORT )( ( ( tempcx & 0x00ff ) >> 6 ) | 0x18 ) ) ; /* Enable Dither */
9693}
9694
9695
9696/* --------------------------------------------------------------------- */
9697/* Function : SetSpectrum */
9698/* Input : */
9699/* Output : */
9700/* Description : */
9701/* --------------------------------------------------------------------- */
9702void SetSpectrum( PVB_DEVICE_INFO pVBInfo )
9703{
9704 USHORT index ;
9705
9706 index = XGI_GetLCDCapPtr(pVBInfo) ;
9707
9708 XGINew_SetRegAND( pVBInfo->Part4Port , 0x30 , 0x8F ) ; /* disable down spectrum D[4] */
9709 XGI_LongWait(pVBInfo) ;
9710 XGINew_SetRegOR( pVBInfo->Part4Port , 0x30 , 0x20 ) ; /* reset spectrum */
9711 XGI_LongWait(pVBInfo) ;
9712
9713 XGINew_SetReg1( pVBInfo->Part4Port , 0x31 , pVBInfo->LCDCapList[ index ].Spectrum_31 ) ;
9714 XGINew_SetReg1( pVBInfo->Part4Port , 0x32 , pVBInfo->LCDCapList[ index ].Spectrum_32 ) ;
9715 XGINew_SetReg1( pVBInfo->Part4Port , 0x33 , pVBInfo->LCDCapList[ index ].Spectrum_33 ) ;
9716 XGINew_SetReg1( pVBInfo->Part4Port , 0x34 , pVBInfo->LCDCapList[ index ].Spectrum_34 ) ;
9717 XGI_LongWait(pVBInfo) ;
9718 XGINew_SetRegOR( pVBInfo->Part4Port , 0x30 , 0x40 ) ; /* enable spectrum */
9719}
9720
9721
9722/* --------------------------------------------------------------------- */
9723/* Function : XGI_SetAntiFlicker */
9724/* Input : */
9725/* Output : */
9726/* Description : Set TV Customized Param. */
9727/* --------------------------------------------------------------------- */
9728void XGI_SetAntiFlicker( USHORT ModeNo , USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo )
9729{
9730 USHORT tempbx ,
9731 index ;
9732
9733 UCHAR tempah ;
9734
9735 if (pVBInfo->TVInfo & ( SetYPbPrMode525p | SetYPbPrMode750p ) )
9736 return ;
9737
9738 tempbx = XGI_GetTVPtrIndex(pVBInfo ) ;
9739 tempbx &= 0xFE ;
9740
9741 if ( ModeNo <= 0x13 )
9742 {
9743 index = pVBInfo->SModeIDTable[ ModeIdIndex ].VB_StTVFlickerIndex ;
9744 }
9745 else
9746 {
9747 index = pVBInfo->EModeIDTable[ ModeIdIndex ].VB_ExtTVFlickerIndex ;
9748 }
9749
9750 tempbx += index ;
9751 tempah = TVAntiFlickList[ tempbx ] ;
9752 tempah = tempah << 4 ;
9753
9754 XGINew_SetRegANDOR( pVBInfo->Part2Port , 0x0A , 0x8F , tempah ) ;
9755}
9756
9757
9758/* --------------------------------------------------------------------- */
9759/* Function : XGI_SetEdgeEnhance */
9760/* Input : */
9761/* Output : */
9762/* Description : */
9763/* --------------------------------------------------------------------- */
9764void XGI_SetEdgeEnhance( USHORT ModeNo , USHORT ModeIdIndex , PVB_DEVICE_INFO pVBInfo)
9765{
9766 USHORT tempbx ,
9767 index ;
9768
9769 UCHAR tempah ;
9770
9771
9772 tempbx = XGI_GetTVPtrIndex(pVBInfo ) ;
9773 tempbx &= 0xFE ;
9774
9775 if ( ModeNo <= 0x13 )
9776 {
9777 index = pVBInfo->SModeIDTable[ ModeIdIndex ].VB_StTVEdgeIndex ;
9778 }
9779 else
9780 {
9781 index = pVBInfo->EModeIDTable[ ModeIdIndex ].VB_ExtTVEdgeIndex ;
9782 }
9783
9784 tempbx += index ;
9785 tempah = TVEdgeList[ tempbx ] ;
9786 tempah = tempah << 5 ;
9787
9788 XGINew_SetRegANDOR( pVBInfo->Part2Port , 0x3A , 0x1F , tempah ) ;
9789}
9790
9791
9792/* --------------------------------------------------------------------- */
9793/* Function : XGI_SetPhaseIncr */
9794/* Input : */
9795/* Output : */
9796/* Description : */
9797/* --------------------------------------------------------------------- */
9798void XGI_SetPhaseIncr( PVB_DEVICE_INFO pVBInfo )
9799{
9800 USHORT tempbx ;
9801
9802 UCHAR tempcl ,
9803 tempch ;
9804
9805 ULONG tempData ;
9806
9807 XGI_GetTVPtrIndex2( &tempbx , &tempcl , &tempch, pVBInfo ) ; /* bx, cl, ch */
9808 tempData = TVPhaseList[ tempbx ] ;
9809
9810 XGINew_SetReg1( pVBInfo->Part2Port , 0x31 , ( USHORT )( tempData & 0x000000FF ) ) ;
9811 XGINew_SetReg1( pVBInfo->Part2Port , 0x32 , ( USHORT )( ( tempData & 0x0000FF00 ) >> 8 ) ) ;
9812 XGINew_SetReg1( pVBInfo->Part2Port , 0x33 , ( USHORT )( ( tempData & 0x00FF0000 ) >> 16 ) ) ;
9813 XGINew_SetReg1( pVBInfo->Part2Port , 0x34 , ( USHORT )( ( tempData & 0xFF000000 ) >> 24 ) ) ;
9814}
9815
9816
9817/* --------------------------------------------------------------------- */
9818/* Function : XGI_SetYFilter */
9819/* Input : */
9820/* Output : */
9821/* Description : */
9822/* --------------------------------------------------------------------- */
9823void XGI_SetYFilter( USHORT ModeNo , USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo)
9824{
9825 USHORT tempbx ,
9826 index ;
9827
9828 UCHAR tempcl ,
9829 tempch ,
9830 tempal ,
9831 *filterPtr ;
9832
9833 XGI_GetTVPtrIndex2( &tempbx , &tempcl , &tempch, pVBInfo ) ; /* bx, cl, ch */
9834
9835 switch( tempbx )
9836 {
9837 case 0x00:
9838 case 0x04:
9839 filterPtr = NTSCYFilter1 ;
9840 break ;
9841
9842 case 0x01:
9843 filterPtr = PALYFilter1 ;
9844 break ;
9845
9846 case 0x02:
9847 case 0x05:
9848 case 0x0D:
9849 filterPtr = PALMYFilter1 ;
9850 break ;
9851
9852 case 0x03:
9853 filterPtr = PALNYFilter1 ;
9854 break ;
9855
9856 case 0x08:
9857 case 0x0C:
9858 filterPtr = NTSCYFilter2 ;
9859 break ;
9860
9861 case 0x0A:
9862 filterPtr = PALMYFilter2 ;
9863 break ;
9864
9865 case 0x0B:
9866 filterPtr = PALNYFilter2 ;
9867 break ;
9868
9869 case 0x09:
9870 filterPtr = PALYFilter2 ;
9871 break ;
9872
9873 default:
9874 return ;
9875 }
9876
9877 if ( ModeNo <= 0x13 )
9878 tempal = pVBInfo->SModeIDTable[ ModeIdIndex ].VB_StTVYFilterIndex ;
9879 else
9880 tempal = pVBInfo->EModeIDTable[ ModeIdIndex ].VB_ExtTVYFilterIndex ;
9881
9882 if ( tempcl == 0 )
9883 index = tempal * 4;
9884 else
9885 index = tempal * 7;
9886
9887 if ( ( tempcl == 0 ) && ( tempch == 1 ) )
9888 {
9889 XGINew_SetReg1( pVBInfo->Part2Port , 0x35 , 0 ) ;
9890 XGINew_SetReg1( pVBInfo->Part2Port , 0x36 , 0 ) ;
9891 XGINew_SetReg1( pVBInfo->Part2Port , 0x37 , 0 ) ;
9892 XGINew_SetReg1( pVBInfo->Part2Port , 0x38 , filterPtr[ index++ ] ) ;
9893 }
9894 else
9895 {
9896 XGINew_SetReg1( pVBInfo->Part2Port , 0x35 , filterPtr[ index++ ] ) ;
9897 XGINew_SetReg1( pVBInfo->Part2Port , 0x36 , filterPtr[ index++ ] ) ;
9898 XGINew_SetReg1( pVBInfo->Part2Port , 0x37 , filterPtr[ index++ ] ) ;
9899 XGINew_SetReg1( pVBInfo->Part2Port , 0x38 , filterPtr[ index++ ] ) ;
9900 }
9901
9902 if ( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
9903 {
9904 XGINew_SetReg1( pVBInfo->Part2Port , 0x48 , filterPtr[ index++ ] ) ;
9905 XGINew_SetReg1( pVBInfo->Part2Port , 0x49 , filterPtr[ index++ ] ) ;
9906 XGINew_SetReg1( pVBInfo->Part2Port , 0x4A , filterPtr[ index++ ] ) ;
9907 }
9908}
9909
9910
9911/* --------------------------------------------------------------------- */
9912/* Function : XGI_GetTVPtrIndex2 */
9913/* Input : */
9914/* Output : bx 0 : NTSC */
9915/* 1 : PAL */
9916/* 2 : PALM */
9917/* 3 : PALN */
9918/* 4 : NTSC1024x768 */
9919/* 5 : PAL-M 1024x768 */
9920/* 6-7: reserved */
9921/* cl 0 : YFilter1 */
9922/* 1 : YFilter2 */
9923/* ch 0 : 301A */
9924/* 1 : 301B/302B/301LV/302LV */
9925/* Description : */
9926/* --------------------------------------------------------------------- */
9927void XGI_GetTVPtrIndex2(USHORT* tempbx,UCHAR* tempcl,UCHAR* tempch, PVB_DEVICE_INFO pVBInfo)
9928{
9929 *tempbx = 0 ;
9930 *tempcl = 0 ;
9931 *tempch = 0 ;
9932
9933 if ( pVBInfo->TVInfo & SetPALTV )
9934 *tempbx = 1 ;
9935
9936 if ( pVBInfo->TVInfo & SetPALMTV )
9937 *tempbx = 2 ;
9938
9939 if ( pVBInfo->TVInfo & SetPALNTV )
9940 *tempbx = 3 ;
9941
9942 if ( pVBInfo->TVInfo & NTSC1024x768 )
9943 {
9944 *tempbx = 4 ;
9945 if ( pVBInfo->TVInfo & SetPALMTV )
9946 *tempbx = 5 ;
9947 }
9948
9949 if ( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
9950 {
9951 if ( ( !( pVBInfo->VBInfo & SetInSlaveMode ) ) || ( pVBInfo->TVInfo & TVSimuMode ) )
9952 {
9953 *tempbx += 8 ;
9954 *tempcl += 1 ;
9955 }
9956 }
9957
9958 if ( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
9959 (*tempch)++ ;
9960}
9961
9962
9963/* --------------------------------------------------------------------- */
9964/* Function : XGI_SetCRT2ModeRegs */
9965/* Input : */
9966/* Output : */
9967/* Description : Origin code for crt2group */
9968/* --------------------------------------------------------------------- */
9969void XGI_SetCRT2ModeRegs(USHORT ModeNo,PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo)
9970{
9971 USHORT tempbl ;
9972 SHORT tempcl ;
9973
9974 UCHAR tempah ;
9975
9976 /* XGINew_SetReg1( pVBInfo->Part1Port , 0x03 , 0x00 ) ; // fix write part1 index 0 BTDRAM bit Bug */
9977 tempah=0;
9978 if ( !( pVBInfo->VBInfo & DisableCRT2Display ) )
9979 {
9980 tempah=XGINew_GetReg1( pVBInfo->Part1Port , 0x00 ) ;
9981 tempah &= ~0x10 ; /* BTRAMDAC */
9982 tempah |= 0x40 ; /* BTRAM */
9983
9984 if ( pVBInfo->VBInfo & ( SetCRT2ToRAMDAC | SetCRT2ToTV | SetCRT2ToLCD ) )
9985 {
9986 tempah=0x40; /* BTDRAM */
9987 if ( ModeNo > 0x13 )
9988 {
9989 tempcl = pVBInfo->ModeType ;
9990 tempcl -= ModeVGA ;
9991 if ( tempcl >= 0 )
9992 {
9993 tempah = ( 0x008 >> tempcl ) ; /* BT Color */
9994 if ( tempah == 0 )
9995 tempah = 1 ;
9996 tempah |= 0x040 ;
9997 }
9998 }
9999 if ( pVBInfo->VBInfo & SetInSlaveMode )
10000 tempah ^= 0x50 ; /* BTDAC */
10001 }
10002 }
10003
10004/* 0210 shampoo
10005 if ( pVBInfo->VBInfo & DisableCRT2Display )
10006 {
10007 tempah = 0 ;
10008 }
10009
10010 XGINew_SetReg1( pVBInfo->Part1Port , 0x00 , tempah ) ;
10011 if ( pVBInfo->VBInfo & ( SetCRT2ToRAMDAC | SetCRT2ToTV | SetCRT2ToLCD ) )
10012 {
10013 tempcl = pVBInfo->ModeType ;
10014 if ( ModeNo > 0x13 )
10015 {
10016 tempcl -= ModeVGA ;
10017 if ( ( tempcl > 0 ) || ( tempcl == 0 ) )
10018 {
10019 tempah=(0x008>>tempcl) ;
10020 if ( tempah == 0 )
10021 tempah = 1 ;
10022 tempah |= 0x040;
10023 }
10024 }
10025 else
10026 {
10027 tempah = 0x040 ;
10028 }
10029
10030 if ( pVBInfo->VBInfo & SetInSlaveMode )
10031 {
10032 tempah = ( tempah ^ 0x050 ) ;
10033 }
10034 }
10035*/
10036
10037 XGINew_SetReg1( pVBInfo->Part1Port , 0x00 , tempah ) ;
10038 tempah = 0x08 ;
10039 tempbl = 0xf0 ;
10040
10041 if ( pVBInfo->VBInfo & DisableCRT2Display )
10042 XGINew_SetRegANDOR( pVBInfo->Part1Port , 0x2e , tempbl , tempah ) ;
10043 else
10044 {
10045 tempah = 0x00 ;
10046 tempbl = 0xff ;
10047
10048 if ( pVBInfo->VBInfo & ( SetCRT2ToRAMDAC | SetCRT2ToTV | SetCRT2ToLCD | SetCRT2ToLCDA ) )
10049 {
10050 if ( ( pVBInfo->VBInfo & SetCRT2ToLCDA ) && ( !( pVBInfo->VBInfo & SetSimuScanMode ) ) )
10051 {
10052 tempbl &= 0xf7 ;
10053 tempah |= 0x01 ;
10054 XGINew_SetRegANDOR( pVBInfo->Part1Port , 0x2e , tempbl , tempah ) ;
10055 }
10056 else
10057 {
10058 if ( pVBInfo->VBInfo & SetCRT2ToLCDA )
10059 {
10060 tempbl &= 0xf7 ;
10061 tempah |= 0x01 ;
10062 }
10063
10064 if ( pVBInfo->VBInfo & ( SetCRT2ToRAMDAC | SetCRT2ToTV | SetCRT2ToLCD ) )
10065 {
10066 tempbl &= 0xf8 ;
10067 tempah = 0x01 ;
10068
10069 if ( !( pVBInfo->VBInfo & SetInSlaveMode ) )
10070 tempah |= 0x02 ;
10071
10072 if ( !( pVBInfo->VBInfo & SetCRT2ToRAMDAC ) )
10073 {
10074 tempah = tempah ^ 0x05 ;
10075 if ( !( pVBInfo->VBInfo & SetCRT2ToLCD ) )
10076 tempah = tempah ^ 0x01 ;
10077 }
10078
10079 if ( !( pVBInfo->VBInfo & SetCRT2ToDualEdge ) )
10080 tempah |= 0x08 ;
10081 XGINew_SetRegANDOR( pVBInfo->Part1Port , 0x2e , tempbl , tempah ) ;
10082 }
10083 else
10084 XGINew_SetRegANDOR( pVBInfo->Part1Port , 0x2e , tempbl , tempah ) ;
10085 }
10086 }
10087 else
10088 XGINew_SetRegANDOR( pVBInfo->Part1Port , 0x2e , tempbl , tempah ) ;
10089 }
10090
10091 if ( pVBInfo->VBInfo & ( SetCRT2ToRAMDAC | SetCRT2ToTV | SetCRT2ToLCD | SetCRT2ToLCDA ) )
10092 {
10093 tempah &= ( ~0x08 ) ;
10094 if ( ( pVBInfo->ModeType == ModeVGA ) && ( !( pVBInfo->VBInfo & SetInSlaveMode ) ) )
10095 {
10096 tempah |= 0x010 ;
10097 }
10098 tempah |= 0x080 ;
10099
10100 if ( pVBInfo->VBInfo & SetCRT2ToTV )
10101 {
10102 /* if ( !( pVBInfo->TVInfo & ( SetYPbPrMode525p | SetYPbPrMode750p ) ) ) */
10103 /* { */
10104 tempah |= 0x020 ;
10105 if ( ModeNo > 0x13 )
10106 {
10107 if ( pVBInfo->VBInfo & DriverMode )
10108 tempah = tempah ^ 0x20 ;
10109 }
10110 /* } */
10111 }
10112
10113 XGINew_SetRegANDOR( pVBInfo->Part4Port , 0x0D , ~0x0BF , tempah ) ;
10114 tempah = 0 ;
10115
10116 if ( pVBInfo->LCDInfo & SetLCDDualLink )
10117 tempah |= 0x40 ;
10118
10119 if ( pVBInfo->VBInfo & SetCRT2ToTV )
10120 {
10121 /* if ( ( !( pVBInfo->VBInfo & SetCRT2ToHiVisionTV ) ) && ( !( pVBInfo->TVInfo & ( SetYPbPrMode525p | SetYPbPrMode750p ) ) ) ) */
10122 /* { */
10123 if ( pVBInfo->TVInfo & RPLLDIV2XO )
10124 tempah |= 0x40 ;
10125 /* } */
10126 }
10127
10128 if ( ( pVBInfo->LCDResInfo == Panel1280x1024 ) || ( pVBInfo->LCDResInfo == Panel1280x1024x75 ) )
10129 tempah |= 0x80 ;
10130
10131 if ( pVBInfo->LCDResInfo == Panel1280x960 )
10132 tempah |= 0x80 ;
10133
10134 XGINew_SetReg1( pVBInfo->Part4Port , 0x0C , tempah ) ;
10135 }
10136
10137 if ( pVBInfo->VBType & ( VB_XGI301B | VB_XGI302B | VB_XGI301LV | VB_XGI302LV | VB_XGI301C ) )
10138 {
10139 tempah = 0 ;
10140 tempbl = 0xfb ;
10141
10142 if ( pVBInfo->VBInfo & SetCRT2ToDualEdge )
10143 {
10144 tempbl=0xff;
10145 if ( pVBInfo->VBInfo & SetCRT2ToLCDA )
10146 tempah |= 0x04 ; /* shampoo 0129 */
10147 }
10148
10149 XGINew_SetRegANDOR( pVBInfo->Part1Port , 0x13 , tempbl , tempah ) ;
10150 tempah = 0x00 ;
10151 tempbl = 0xcf ;
10152 if ( !( pVBInfo->VBInfo & DisableCRT2Display ) )
10153 {
10154 if ( pVBInfo->VBInfo & SetCRT2ToDualEdge )
10155 tempah |= 0x30 ;
10156 }
10157
10158 XGINew_SetRegANDOR( pVBInfo->Part1Port , 0x2c , tempbl , tempah ) ;
10159 tempah = 0 ;
10160 tempbl = 0x3f ;
10161
10162 if ( !( pVBInfo->VBInfo & DisableCRT2Display ) )
10163 {
10164 if ( pVBInfo->VBInfo & SetCRT2ToDualEdge )
10165 tempah |= 0xc0 ;
10166 }
10167 XGINew_SetRegANDOR( pVBInfo->Part4Port , 0x21 , tempbl , tempah ) ;
10168 }
10169
10170 tempah = 0 ;
10171 tempbl = 0x7f ;
10172 if ( !( pVBInfo->VBInfo & SetCRT2ToLCDA ) )
10173 {
10174 tempbl = 0xff ;
10175 if ( !( pVBInfo->VBInfo & SetCRT2ToDualEdge ) )
10176 tempah |= 0x80 ;
10177 }
10178
10179 XGINew_SetRegANDOR( pVBInfo->Part4Port , 0x23 , tempbl , tempah ) ;
10180
10181 if ( pVBInfo->VBType & ( VB_XGI302LV | VB_XGI301C ) )
10182 {
10183 if ( pVBInfo->LCDInfo & SetLCDDualLink )
10184 {
10185 XGINew_SetRegOR( pVBInfo->Part4Port , 0x27 , 0x20 ) ;
10186 XGINew_SetRegOR( pVBInfo->Part4Port , 0x34 , 0x10 ) ;
10187 }
10188 }
10189}
10190
10191
10192/* --------------------------------------------------------------------- */
10193/* Function : XGI_CloseCRTC */
10194/* Input : */
10195/* Output : */
10196/* Description : */
10197/* --------------------------------------------------------------------- */
10198void XGI_CloseCRTC( PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo )
10199{
10200 USHORT tempbx ;
10201
10202 tempbx = 0 ;
10203
10204 if ( pVBInfo->VBInfo & SetCRT2ToLCDA )
10205 tempbx = 0x08A0 ;
10206
10207
10208}
10209
10210
10211/* --------------------------------------------------------------------- */
10212/* Function : XGI_OpenCRTC */
10213/* Input : */
10214/* Output : */
10215/* Description : */
10216/* --------------------------------------------------------------------- */
10217void XGI_OpenCRTC( PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo )
10218{
10219 USHORT tempbx ;
10220
10221 tempbx = 0 ;
10222
10223
10224}
10225
10226
10227/* --------------------------------------------------------------------- */
10228/* Function : XGI_GetRAMDAC2DATA */
10229/* Input : */
10230/* Output : */
10231/* Description : */
10232/* --------------------------------------------------------------------- */
10233void XGI_GetRAMDAC2DATA(USHORT ModeNo , USHORT ModeIdIndex , USHORT RefreshRateTableIndex, PVB_DEVICE_INFO pVBInfo )
10234{
10235 USHORT tempax ,
10236 tempbx ,
10237 temp1 ,
10238 temp2 ,
10239 modeflag = 0 ,
10240 tempcx ,
10241 StandTableIndex ,
10242 CRT1Index ;
10243
10244 pVBInfo->RVBHCMAX = 1 ;
10245 pVBInfo->RVBHCFACT = 1 ;
10246
10247 if ( ModeNo <= 0x13 )
10248 {
10249 modeflag = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag ;
10250 StandTableIndex = XGI_GetModePtr( ModeNo , ModeIdIndex, pVBInfo ) ;
10251 tempax = pVBInfo->StandTable[ StandTableIndex ].CRTC[ 0 ] ;
10252 tempbx = pVBInfo->StandTable[StandTableIndex ].CRTC[ 6 ] ;
10253 temp1 = pVBInfo->StandTable[ StandTableIndex ].CRTC[ 7 ] ;
10254 }
10255 else
10256 {
10257 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag ;
10258 CRT1Index = pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_CRT1CRTC ;
10259 CRT1Index &= IndexMask ;
10260 temp1 = ( USHORT )pVBInfo->XGINEWUB_CRT1Table[ CRT1Index ].CR[ 0 ] ;
10261 temp2 = ( USHORT )pVBInfo->XGINEWUB_CRT1Table[ CRT1Index ].CR[ 5 ] ;
10262 tempax = ( temp1 & 0xFF ) | ( ( temp2 & 0x03 ) << 8 ) ;
10263 tempbx = ( USHORT )pVBInfo->XGINEWUB_CRT1Table[ CRT1Index ].CR[ 8 ] ;
10264 tempcx = ( USHORT )pVBInfo->XGINEWUB_CRT1Table[ CRT1Index ].CR[ 14 ] << 8 ;
10265 tempcx &= 0x0100 ;
10266 tempcx = tempcx << 2 ;
10267 tempbx |= tempcx;
10268 temp1 = ( USHORT )pVBInfo->XGINEWUB_CRT1Table[ CRT1Index ].CR[ 9 ] ;
10269 }
10270
10271 if ( temp1 & 0x01 )
10272 tempbx |= 0x0100 ;
10273
10274 if ( temp1 & 0x20 )
10275 tempbx |= 0x0200 ;
10276 tempax += 5 ;
10277
10278 if ( modeflag & Charx8Dot )
10279 tempax *= 8 ;
10280 else
10281 tempax *= 9 ;
10282
10283 pVBInfo->VGAHT = tempax ;
10284 pVBInfo->HT = tempax ;
10285 tempbx++ ;
10286 pVBInfo->VGAVT = tempbx ;
10287 pVBInfo->VT = tempbx ;
10288}
10289
10290
10291
10292/* --------------------------------------------------------------------- */
10293/* Function : XGI_GetColorDepth */
10294/* Input : */
10295/* Output : */
10296/* Description : */
10297/* --------------------------------------------------------------------- */
10298USHORT XGI_GetColorDepth(USHORT ModeNo , USHORT ModeIdIndex, PVB_DEVICE_INFO pVBInfo)
10299{
10300 USHORT ColorDepth[ 6 ] = { 1 , 2 , 4 , 4 , 6 , 8 } ;
10301 SHORT index ;
10302 USHORT modeflag ;
10303
10304 if ( ModeNo <= 0x13 )
10305 {
10306 modeflag = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag ;
10307 }
10308 else
10309 {
10310 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag ;
10311 }
10312
10313 index=(modeflag&ModeInfoFlag)-ModeEGA;
10314
10315 if ( index < 0 )
10316 index = 0 ;
10317
10318 return( ColorDepth[ index ] ) ;
10319}
10320
10321
10322
10323/* --------------------------------------------------------------------- */
10324/* Function : XGI_UnLockCRT2 */
10325/* Input : */
10326/* Output : */
10327/* Description : */
10328/* --------------------------------------------------------------------- */
10329void XGI_UnLockCRT2( PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo )
10330{
10331
10332 XGINew_SetRegANDOR( pVBInfo->Part1Port , 0x2f , 0xFF , 0x01 ) ;
10333
10334}
10335
10336
10337/* --------------------------------------------------------------------- */
10338/* Function : XGI_LockCRT2 */
10339/* Input : */
10340/* Output : */
10341/* Description : */
10342/* --------------------------------------------------------------------- */
10343void XGI_LockCRT2( PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo )
10344{
10345
10346 XGINew_SetRegANDOR( pVBInfo->Part1Port , 0x2F , 0xFE , 0x00 ) ;
10347
10348
10349}
10350
10351
10352/* --------------------------------------------------------------------- */
10353/* Function : XGINew_EnableCRT2 */
10354/* Input : */
10355/* Output : */
10356/* Description : */
10357/* --------------------------------------------------------------------- */
10358void XGINew_EnableCRT2( PVB_DEVICE_INFO pVBInfo)
10359{
10360 XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x1E , 0xFF , 0x20 ) ;
10361}
10362
10363
10364
10365/* --------------------------------------------------------------------- */
10366/* Function : */
10367/* Input : */
10368/* Output : */
10369/* Description : */
10370/* --------------------------------------------------------------------- */
10371void XGINew_LCD_Wait_Time(UCHAR DelayTime, PVB_DEVICE_INFO pVBInfo)
10372{
10373 USHORT i ,
10374 j ;
10375
10376 ULONG temp ,
10377 flag ;
10378
10379 flag = 0 ;
10380//printk("XGINew_LCD_Wait_Time");
10381//return;
10382 for( i = 0 ; i < DelayTime ; i++ )
10383 {
10384 for( j = 0 ; j < 66 ; j++ )
10385 {
10386
10387 temp = XGINew_GetReg3( 0x61 ) ;
10388
10389 //temp &= 0x10000000;
10390 temp &= 0x10;
10391 if ( temp == flag )
10392 continue ;
10393
10394 flag = temp ;
10395 }
10396 }
10397}
10398
10399
10400
10401
10402/* --------------------------------------------------------------------- */
10403/* Function : XGI_BridgeIsOn */
10404/* Input : */
10405/* Output : */
10406/* Description : */
10407/* --------------------------------------------------------------------- */
10408BOOLEAN XGI_BridgeIsOn( PVB_DEVICE_INFO pVBInfo )
10409{
10410 USHORT flag ;
10411
10412 if ( pVBInfo->IF_DEF_LVDS == 1 )
10413 {
10414 return( 1 ) ;
10415 }
10416 else
10417 {
10418 flag = XGINew_GetReg1( pVBInfo->Part4Port , 0x00 ) ;
10419 if ( ( flag == 1 ) || ( flag == 2 ) )
10420 return( 1 ) ; /* 301b */
10421 else
10422 return( 0 ) ;
10423 }
10424}
10425
10426
10427
10428/* --------------------------------------------------------------------- */
10429/* Function : XGI_LongWait */
10430/* Input : */
10431/* Output : */
10432/* Description : */
10433/* --------------------------------------------------------------------- */
10434void XGI_LongWait(PVB_DEVICE_INFO pVBInfo)
10435{
10436 USHORT i ;
10437
10438 i = XGINew_GetReg1( pVBInfo->P3c4 , 0x1F ) ;
10439
10440 if ( !( i & 0xC0 ) )
10441 {
10442 for( i = 0 ; i < 0xFFFF ; i++ )
10443 {
10444 if ( !( XGINew_GetReg2( pVBInfo->P3da ) & 0x08 ) )
10445 break ;
10446 }
10447
10448 for( i = 0 ; i < 0xFFFF ; i++ )
10449 {
10450 if ( ( XGINew_GetReg2( pVBInfo->P3da ) & 0x08 ) )
10451 break ;
10452 }
10453 }
10454}
10455
10456
10457/* --------------------------------------------------------------------- */
10458/* Function : XGI_VBLongWait */
10459/* Input : */
10460/* Output : */
10461/* Description : */
10462/* --------------------------------------------------------------------- */
10463void XGI_VBLongWait( PVB_DEVICE_INFO pVBInfo )
10464{
10465 USHORT tempal ,
10466 temp ,
10467 i ,
10468 j ;
10469return ;
10470 if ( !( pVBInfo->VBInfo & SetCRT2ToTV ) )
10471 {
10472 temp = 0 ;
10473 for( i = 0 ; i < 3 ; i++ )
10474 {
10475 for( j = 0 ; j < 100 ; j++ )
10476 {
10477 tempal = XGINew_GetReg2( pVBInfo->P3da ) ;
10478 if ( temp & 0x01 )
10479 { /* VBWaitMode2 */
10480 if ( ( tempal & 0x08 ) )
10481 {
10482 continue ;
10483 }
10484
10485 if ( !( tempal & 0x08 ) )
10486 {
10487 break ;
10488 }
10489 }
10490 else
10491 { /* VBWaitMode1 */
10492 if ( !( tempal & 0x08 ) )
10493 {
10494 continue ;
10495 }
10496
10497 if ( ( tempal & 0x08 ) )
10498 {
10499 break ;
10500 }
10501 }
10502 }
10503 temp = temp ^ 0x01 ;
10504 }
10505 }
10506 else
10507 {
10508 XGI_LongWait(pVBInfo) ;
10509 }
10510 return ;
10511}
10512
10513
10514
10515
10516/* --------------------------------------------------------------------- */
10517/* Function : XGI_GetVGAHT2 */
10518/* Input : */
10519/* Output : */
10520/* Description : */
10521/* --------------------------------------------------------------------- */
10522USHORT XGI_GetVGAHT2( PVB_DEVICE_INFO pVBInfo )
10523{
10524 ULONG tempax ,
10525 tempbx ;
10526
10527 tempbx = ( ( pVBInfo->VGAVT - pVBInfo->VGAVDE ) * pVBInfo->RVBHCMAX ) & 0xFFFF ;
10528 tempax = ( pVBInfo->VT - pVBInfo->VDE ) * pVBInfo->RVBHCFACT ;
10529 tempax = ( tempax * pVBInfo->HT ) /tempbx ;
10530
10531 return( ( USHORT )tempax ) ;
10532}
10533
10534
10535/* --------------------------------------------------------------------- */
10536/* Function : XGI_GetVCLK2Ptr */
10537/* Input : */
10538/* Output : */
10539/* Description : */
10540/* --------------------------------------------------------------------- */
10541USHORT XGI_GetVCLK2Ptr( USHORT ModeNo , USHORT ModeIdIndex , USHORT RefreshRateTableIndex , PXGI_HW_DEVICE_INFO HwDeviceExtension ,PVB_DEVICE_INFO pVBInfo)
10542{
10543 USHORT tempbx ;
10544
10545 USHORT LCDXlat1VCLK[ 4 ] = { VCLK65 + 2 , VCLK65 + 2 , VCLK65 + 2 , VCLK65 + 2 } ;
10546 USHORT LCDXlat2VCLK[ 4 ] = { VCLK108_2 + 5 , VCLK108_2 + 5 , VCLK108_2 + 5 , VCLK108_2 + 5 } ;
10547 USHORT LVDSXlat1VCLK[ 4 ] = { VCLK40 , VCLK40 , VCLK40 , VCLK40 } ;
10548 USHORT LVDSXlat2VCLK[ 4 ] = { VCLK65 + 2 , VCLK65 + 2 , VCLK65 + 2 , VCLK65 + 2 } ;
10549 USHORT LVDSXlat3VCLK[ 4 ] = { VCLK65 + 2 , VCLK65 + 2 , VCLK65 + 2 , VCLK65 + 2 } ;
10550
10551 USHORT CRT2Index , VCLKIndex ;
10552 USHORT modeflag , resinfo ;
10553 UCHAR *CHTVVCLKPtr = NULL ;
10554
10555 if ( ModeNo <= 0x13 )
10556 {
10557 modeflag = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ModeFlag ; /* si+St_ResInfo */
10558 resinfo = pVBInfo->SModeIDTable[ ModeIdIndex ].St_ResInfo ;
10559 CRT2Index = pVBInfo->SModeIDTable[ ModeIdIndex ].St_CRT2CRTC ;
10560 }
10561 else
10562 {
10563 modeflag = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_ModeFlag ; /* si+Ext_ResInfo */
10564 resinfo = pVBInfo->EModeIDTable[ ModeIdIndex ].Ext_RESINFO ;
10565 CRT2Index = pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_CRT2CRTC ;
10566 }
10567
10568 if ( pVBInfo->IF_DEF_LVDS == 0 )
10569 {
10570 CRT2Index = CRT2Index >> 6 ; /* for LCD */
10571 if ( ( ( pVBInfo->VBInfo & SetCRT2ToLCD ) | SetCRT2ToLCDA ) ) /*301b*/
10572 {
10573 if ( pVBInfo->LCDResInfo != Panel1024x768 )
10574 {
10575 VCLKIndex = LCDXlat2VCLK[ CRT2Index ] ;
10576 }
10577 else
10578 {
10579 VCLKIndex = LCDXlat1VCLK[ CRT2Index ] ;
10580 }
10581 }
10582 else /* for TV */
10583 {
10584 if ( pVBInfo->VBInfo & SetCRT2ToTV )
10585 {
10586 if ( pVBInfo->VBInfo & SetCRT2ToHiVisionTV )
10587 {
10588 if ( pVBInfo->SetFlag & RPLLDIV2XO )
10589 {
10590 VCLKIndex = HiTVVCLKDIV2 ;
10591
10592
10593 VCLKIndex += 25 ;
10594
10595 }
10596 else
10597 {
10598 VCLKIndex = HiTVVCLK ;
10599
10600
10601 VCLKIndex += 25 ;
10602
10603 }
10604
10605 if ( pVBInfo->SetFlag & TVSimuMode )
10606 {
10607 if( modeflag & Charx8Dot )
10608 {
10609 VCLKIndex = HiTVSimuVCLK ;
10610
10611
10612 VCLKIndex += 25 ;
10613
10614 }
10615 else
10616 {
10617 VCLKIndex = HiTVTextVCLK ;
10618
10619
10620 VCLKIndex += 25 ;
10621
10622 }
10623 }
10624
10625 if ( pVBInfo->VBType & VB_XGI301LV ) /* 301lv */
10626 {
10627 if ( !( pVBInfo->VBExtInfo == VB_YPbPr1080i ) )
10628 {
10629 VCLKIndex = YPbPr750pVCLK ;
10630 if ( !( pVBInfo->VBExtInfo == VB_YPbPr750p ) )
10631 {
10632 VCLKIndex = YPbPr525pVCLK ;
10633 if ( !( pVBInfo->VBExtInfo == VB_YPbPr525p ) )
10634 {
10635 VCLKIndex = YPbPr525iVCLK_2 ;
10636 if ( !( pVBInfo->SetFlag & RPLLDIV2XO ) )
10637 VCLKIndex = YPbPr525iVCLK ;
10638 }
10639 }
10640 }
10641 }
10642 }
10643 else
10644 {
10645 if ( pVBInfo->VBInfo & SetCRT2ToTV )
10646 {
10647 if ( pVBInfo->SetFlag & RPLLDIV2XO )
10648 {
10649 VCLKIndex = TVVCLKDIV2 ;
10650
10651
10652 VCLKIndex += 25 ;
10653
10654 }
10655 else
10656 {
10657 VCLKIndex = TVVCLK ;
10658
10659
10660 VCLKIndex += 25 ;
10661
10662 }
10663 }
10664 }
10665 }
10666 else
10667 { /* for CRT2 */
10668 VCLKIndex = ( UCHAR )XGINew_GetReg2( ( pVBInfo->P3ca + 0x02 ) ) ; /* Port 3cch */
10669 VCLKIndex = ( ( VCLKIndex >> 2 ) & 0x03 ) ;
10670 if ( ModeNo > 0x13 )
10671 {
10672 VCLKIndex = pVBInfo->RefIndex[ RefreshRateTableIndex ].Ext_CRTVCLK ; /* di+Ext_CRTVCLK */
10673 VCLKIndex &= IndexMask ;
10674 }
10675 }
10676 }
10677 }
10678 else
10679 { /* LVDS */
10680 if ( ModeNo <= 0x13 )
10681 VCLKIndex = CRT2Index ;
10682 else
10683 VCLKIndex = CRT2Index ;
10684
10685 if ( pVBInfo->IF_DEF_CH7005 == 1 )
10686 {
10687 if ( !( pVBInfo->VBInfo & SetCRT2ToLCD ) )
10688 {
10689 VCLKIndex &= 0x1f ;
10690 tempbx = 0 ;
10691
10692 if ( pVBInfo->VBInfo & SetPALTV )
10693 tempbx += 2 ;
10694
10695 if ( pVBInfo->VBInfo & SetCHTVOverScan )
10696 tempbx += 1 ;
10697
10698 switch( tempbx )
10699 {
10700 case 0:
10701 CHTVVCLKPtr = pVBInfo->CHTVVCLKUNTSC ;
10702 break ;
10703 case 1:
10704 CHTVVCLKPtr = pVBInfo->CHTVVCLKONTSC ;
10705 break;
10706 case 2:
10707 CHTVVCLKPtr = pVBInfo->CHTVVCLKUPAL ;
10708 break ;
10709 case 3:
10710 CHTVVCLKPtr = pVBInfo->CHTVVCLKOPAL ;
10711 break ;
10712 default:
10713 break ;
10714 }
10715
10716 VCLKIndex = CHTVVCLKPtr[ VCLKIndex ] ;
10717 }
10718 }
10719 else
10720 {
10721 VCLKIndex = VCLKIndex >> 6 ;
10722 if ( ( pVBInfo->LCDResInfo == Panel800x600 ) || ( pVBInfo->LCDResInfo == Panel320x480 ) )
10723 VCLKIndex = LVDSXlat1VCLK[ VCLKIndex ] ;
10724 else if ( ( pVBInfo->LCDResInfo == Panel1024x768 ) || ( pVBInfo->LCDResInfo == Panel1024x768x75 ) )
10725 VCLKIndex = LVDSXlat2VCLK[ VCLKIndex ] ;
10726 else
10727 VCLKIndex = LVDSXlat3VCLK[ VCLKIndex ] ;
10728 }
10729 }
10730 /* VCLKIndex = VCLKIndex&IndexMask ; */
10731
10732
10733
10734 return( VCLKIndex ) ;
10735}
10736
Clone of davem's net-next-2.6 tree