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