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