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