1 #include <linux/delay.h>
2 #include <linux/vmalloc.h>
7 #include "vb_setmode.h"
9 static const unsigned short XGINew_DDRDRAM_TYPE340[4][2] = {
15 static const unsigned short XGINew_DDRDRAM_TYPE20[12][2] = {
29 #define XGIFB_ROM_SIZE 65536
32 XGINew_GetXG20DRAMType(struct xgi_hw_device_info *HwDeviceExtension,
33 struct vb_device_info *pVBInfo)
35 unsigned char data, temp;
37 if (HwDeviceExtension->jChipType < XG20) {
38 data = xgifb_reg_get(pVBInfo->P3c4, 0x39) & 0x02;
40 data = (xgifb_reg_get(pVBInfo->P3c4, 0x3A) &
43 } else if (HwDeviceExtension->jChipType == XG27) {
44 temp = xgifb_reg_get(pVBInfo->P3c4, 0x3B);
45 /* SR3B[7][3]MAA15 MAA11 (Power on Trapping) */
46 if (((temp & 0x88) == 0x80) || ((temp & 0x88) == 0x08))
51 } else if (HwDeviceExtension->jChipType == XG21) {
52 /* Independent GPIO control */
53 xgifb_reg_and(pVBInfo->P3d4, 0xB4, ~0x02);
55 xgifb_reg_or(pVBInfo->P3d4, 0x4A, 0x80); /* Enable GPIOH read */
56 /* GPIOF 0:DVI 1:DVO */
57 temp = xgifb_reg_get(pVBInfo->P3d4, 0x48);
59 /* for current XG20 & XG21, GPIOH is floating, driver will
60 * fix DDR temporarily */
61 if (temp & 0x01) /* DVI read GPIOH */
65 /* ~HOTPLUG_SUPPORT */
66 xgifb_reg_or(pVBInfo->P3d4, 0xB4, 0x02);
69 data = xgifb_reg_get(pVBInfo->P3d4, 0x97) & 0x01;
78 static void XGINew_DDR1x_MRS_340(unsigned long P3c4,
79 struct vb_device_info *pVBInfo)
81 xgifb_reg_set(P3c4, 0x18, 0x01);
82 xgifb_reg_set(P3c4, 0x19, 0x20);
83 xgifb_reg_set(P3c4, 0x16, 0x00);
84 xgifb_reg_set(P3c4, 0x16, 0x80);
87 xgifb_reg_set(P3c4, 0x18, 0x00);
88 xgifb_reg_set(P3c4, 0x19, 0x20);
89 xgifb_reg_set(P3c4, 0x16, 0x00);
90 xgifb_reg_set(P3c4, 0x16, 0x80);
95 pVBInfo->SR15[2][pVBInfo->ram_type]); /* SR18 */
96 xgifb_reg_set(P3c4, 0x19, 0x01);
97 xgifb_reg_set(P3c4, 0x16, 0x03);
98 xgifb_reg_set(P3c4, 0x16, 0x83);
100 xgifb_reg_set(P3c4, 0x1B, 0x03);
104 pVBInfo->SR15[2][pVBInfo->ram_type]); /* SR18 */
105 xgifb_reg_set(P3c4, 0x19, 0x00);
106 xgifb_reg_set(P3c4, 0x16, 0x03);
107 xgifb_reg_set(P3c4, 0x16, 0x83);
108 xgifb_reg_set(P3c4, 0x1B, 0x00);
111 static void XGINew_SetMemoryClock(struct xgi_hw_device_info *HwDeviceExtension,
112 struct vb_device_info *pVBInfo)
115 xgifb_reg_set(pVBInfo->P3c4,
117 pVBInfo->MCLKData[pVBInfo->ram_type].SR28);
118 xgifb_reg_set(pVBInfo->P3c4,
120 pVBInfo->MCLKData[pVBInfo->ram_type].SR29);
121 xgifb_reg_set(pVBInfo->P3c4,
123 pVBInfo->MCLKData[pVBInfo->ram_type].SR2A);
125 xgifb_reg_set(pVBInfo->P3c4,
127 XGI340_ECLKData[pVBInfo->ram_type].SR2E);
128 xgifb_reg_set(pVBInfo->P3c4,
130 XGI340_ECLKData[pVBInfo->ram_type].SR2F);
131 xgifb_reg_set(pVBInfo->P3c4,
133 XGI340_ECLKData[pVBInfo->ram_type].SR30);
135 /* When XG42 ECLK = MCLK = 207MHz, Set SR32 D[1:0] = 10b */
136 /* Modify SR32 value, when MCLK=207MHZ, ELCK=250MHz,
137 * Set SR32 D[1:0] = 10b */
138 if (HwDeviceExtension->jChipType == XG42) {
139 if ((pVBInfo->MCLKData[pVBInfo->ram_type].SR28 == 0x1C) &&
140 (pVBInfo->MCLKData[pVBInfo->ram_type].SR29 == 0x01) &&
141 (((XGI340_ECLKData[pVBInfo->ram_type].SR2E == 0x1C) &&
142 (XGI340_ECLKData[pVBInfo->ram_type].SR2F == 0x01)) ||
143 ((XGI340_ECLKData[pVBInfo->ram_type].SR2E == 0x22) &&
144 (XGI340_ECLKData[pVBInfo->ram_type].SR2F == 0x01))))
145 xgifb_reg_set(pVBInfo->P3c4,
147 ((unsigned char) xgifb_reg_get(
148 pVBInfo->P3c4, 0x32) & 0xFC) | 0x02);
152 static void XGINew_DDRII_Bootup_XG27(
153 struct xgi_hw_device_info *HwDeviceExtension,
154 unsigned long P3c4, struct vb_device_info *pVBInfo)
156 unsigned long P3d4 = P3c4 + 0x10;
157 pVBInfo->ram_type = XGINew_GetXG20DRAMType(HwDeviceExtension, pVBInfo);
158 XGINew_SetMemoryClock(HwDeviceExtension, pVBInfo);
160 /* Set Double Frequency */
161 xgifb_reg_set(P3d4, 0x97, pVBInfo->XGINew_CR97); /* CR97 */
165 xgifb_reg_set(P3c4, 0x18, 0x00); /* Set SR18 */ /* EMRS2 */
166 xgifb_reg_set(P3c4, 0x19, 0x80); /* Set SR19 */
167 xgifb_reg_set(P3c4, 0x16, 0x20); /* Set SR16 */
169 xgifb_reg_set(P3c4, 0x16, 0xA0); /* Set SR16 */
172 xgifb_reg_set(P3c4, 0x18, 0x00); /* Set SR18 */ /* EMRS3 */
173 xgifb_reg_set(P3c4, 0x19, 0xC0); /* Set SR19 */
174 xgifb_reg_set(P3c4, 0x16, 0x20); /* Set SR16 */
176 xgifb_reg_set(P3c4, 0x16, 0xA0); /* Set SR16 */
179 xgifb_reg_set(P3c4, 0x18, 0x00); /* Set SR18 */ /* EMRS1 */
180 xgifb_reg_set(P3c4, 0x19, 0x40); /* Set SR19 */
181 xgifb_reg_set(P3c4, 0x16, 0x20); /* Set SR16 */
183 xgifb_reg_set(P3c4, 0x16, 0xA0); /* Set SR16 */
186 xgifb_reg_set(P3c4, 0x18, 0x42); /* Set SR18 */ /* MRS, DLL Enable */
187 xgifb_reg_set(P3c4, 0x19, 0x0A); /* Set SR19 */
188 xgifb_reg_set(P3c4, 0x16, 0x00); /* Set SR16 */
190 xgifb_reg_set(P3c4, 0x16, 0x00); /* Set SR16 */
191 xgifb_reg_set(P3c4, 0x16, 0x80); /* Set SR16 */
193 xgifb_reg_set(P3c4, 0x1B, 0x04); /* Set SR1B */
195 xgifb_reg_set(P3c4, 0x1B, 0x00); /* Set SR1B */
197 xgifb_reg_set(P3c4, 0x18, 0x42); /* Set SR18 */ /* MRS, DLL Reset */
198 xgifb_reg_set(P3c4, 0x19, 0x08); /* Set SR19 */
199 xgifb_reg_set(P3c4, 0x16, 0x00); /* Set SR16 */
202 xgifb_reg_set(P3c4, 0x16, 0x83); /* Set SR16 */
205 xgifb_reg_set(P3c4, 0x18, 0x80); /* Set SR18 */ /* MRS, ODT */
206 xgifb_reg_set(P3c4, 0x19, 0x46); /* Set SR19 */
207 xgifb_reg_set(P3c4, 0x16, 0x20); /* Set SR16 */
209 xgifb_reg_set(P3c4, 0x16, 0xA0); /* Set SR16 */
212 xgifb_reg_set(P3c4, 0x18, 0x00); /* Set SR18 */ /* EMRS */
213 xgifb_reg_set(P3c4, 0x19, 0x40); /* Set SR19 */
214 xgifb_reg_set(P3c4, 0x16, 0x20); /* Set SR16 */
216 xgifb_reg_set(P3c4, 0x16, 0xA0); /* Set SR16 */
219 /* Set SR1B refresh control 000:close; 010:open */
220 xgifb_reg_set(P3c4, 0x1B, 0x04);
225 static void XGINew_DDR2_MRS_XG20(struct xgi_hw_device_info *HwDeviceExtension,
226 unsigned long P3c4, struct vb_device_info *pVBInfo)
228 unsigned long P3d4 = P3c4 + 0x10;
230 pVBInfo->ram_type = XGINew_GetXG20DRAMType(HwDeviceExtension, pVBInfo);
231 XGINew_SetMemoryClock(HwDeviceExtension, pVBInfo);
233 xgifb_reg_set(P3d4, 0x97, 0x11); /* CR97 */
236 xgifb_reg_set(P3c4, 0x18, 0x00); /* EMRS2 */
237 xgifb_reg_set(P3c4, 0x19, 0x80);
238 xgifb_reg_set(P3c4, 0x16, 0x05);
239 xgifb_reg_set(P3c4, 0x16, 0x85);
241 xgifb_reg_set(P3c4, 0x18, 0x00); /* EMRS3 */
242 xgifb_reg_set(P3c4, 0x19, 0xC0);
243 xgifb_reg_set(P3c4, 0x16, 0x05);
244 xgifb_reg_set(P3c4, 0x16, 0x85);
246 xgifb_reg_set(P3c4, 0x18, 0x00); /* EMRS1 */
247 xgifb_reg_set(P3c4, 0x19, 0x40);
248 xgifb_reg_set(P3c4, 0x16, 0x05);
249 xgifb_reg_set(P3c4, 0x16, 0x85);
251 xgifb_reg_set(P3c4, 0x18, 0x42); /* MRS1 */
252 xgifb_reg_set(P3c4, 0x19, 0x02);
253 xgifb_reg_set(P3c4, 0x16, 0x05);
254 xgifb_reg_set(P3c4, 0x16, 0x85);
257 xgifb_reg_set(P3c4, 0x1B, 0x04); /* SR1B */
259 xgifb_reg_set(P3c4, 0x1B, 0x00); /* SR1B */
262 xgifb_reg_set(P3c4, 0x18, 0x42); /* MRS1 */
263 xgifb_reg_set(P3c4, 0x19, 0x00);
264 xgifb_reg_set(P3c4, 0x16, 0x05);
265 xgifb_reg_set(P3c4, 0x16, 0x85);
270 static void XGINew_DDR1x_MRS_XG20(unsigned long P3c4,
271 struct vb_device_info *pVBInfo)
273 xgifb_reg_set(P3c4, 0x18, 0x01);
274 xgifb_reg_set(P3c4, 0x19, 0x40);
275 xgifb_reg_set(P3c4, 0x16, 0x00);
276 xgifb_reg_set(P3c4, 0x16, 0x80);
279 xgifb_reg_set(P3c4, 0x18, 0x00);
280 xgifb_reg_set(P3c4, 0x19, 0x40);
281 xgifb_reg_set(P3c4, 0x16, 0x00);
282 xgifb_reg_set(P3c4, 0x16, 0x80);
286 pVBInfo->SR15[2][pVBInfo->ram_type]); /* SR18 */
287 xgifb_reg_set(P3c4, 0x19, 0x01);
288 xgifb_reg_set(P3c4, 0x16, 0x03);
289 xgifb_reg_set(P3c4, 0x16, 0x83);
291 xgifb_reg_set(P3c4, 0x1B, 0x03);
295 pVBInfo->SR15[2][pVBInfo->ram_type]); /* SR18 */
296 xgifb_reg_set(P3c4, 0x19, 0x00);
297 xgifb_reg_set(P3c4, 0x16, 0x03);
298 xgifb_reg_set(P3c4, 0x16, 0x83);
299 xgifb_reg_set(P3c4, 0x1B, 0x00);
302 static void XGINew_DDR1x_DefaultRegister(
303 struct xgi_hw_device_info *HwDeviceExtension,
304 unsigned long Port, struct vb_device_info *pVBInfo)
306 unsigned long P3d4 = Port, P3c4 = Port - 0x10;
308 if (HwDeviceExtension->jChipType >= XG20) {
309 XGINew_SetMemoryClock(HwDeviceExtension, pVBInfo);
312 pVBInfo->CR40[11][pVBInfo->ram_type]); /* CR82 */
315 pVBInfo->CR40[12][pVBInfo->ram_type]); /* CR85 */
318 pVBInfo->CR40[13][pVBInfo->ram_type]); /* CR86 */
320 xgifb_reg_set(P3d4, 0x98, 0x01);
321 xgifb_reg_set(P3d4, 0x9A, 0x02);
323 XGINew_DDR1x_MRS_XG20(P3c4, pVBInfo);
325 XGINew_SetMemoryClock(HwDeviceExtension, pVBInfo);
327 switch (HwDeviceExtension->jChipType) {
332 pVBInfo->CR40[11][pVBInfo->ram_type]);
336 pVBInfo->CR40[12][pVBInfo->ram_type]);
340 pVBInfo->CR40[13][pVBInfo->ram_type]);
343 xgifb_reg_set(P3d4, 0x82, 0x88);
344 xgifb_reg_set(P3d4, 0x86, 0x00);
345 /* Insert read command for delay */
346 xgifb_reg_get(P3d4, 0x86);
347 xgifb_reg_set(P3d4, 0x86, 0x88);
348 xgifb_reg_get(P3d4, 0x86);
351 pVBInfo->CR40[13][pVBInfo->ram_type]);
352 xgifb_reg_set(P3d4, 0x82, 0x77);
353 xgifb_reg_set(P3d4, 0x85, 0x00);
355 /* Insert read command for delay */
356 xgifb_reg_get(P3d4, 0x85);
357 xgifb_reg_set(P3d4, 0x85, 0x88);
359 /* Insert read command for delay */
360 xgifb_reg_get(P3d4, 0x85);
364 pVBInfo->CR40[12][pVBInfo->ram_type]);
368 pVBInfo->CR40[11][pVBInfo->ram_type]);
372 xgifb_reg_set(P3d4, 0x97, 0x00);
373 xgifb_reg_set(P3d4, 0x98, 0x01);
374 xgifb_reg_set(P3d4, 0x9A, 0x02);
375 XGINew_DDR1x_MRS_340(P3c4, pVBInfo);
379 static void XGINew_DDR2_DefaultRegister(
380 struct xgi_hw_device_info *HwDeviceExtension,
381 unsigned long Port, struct vb_device_info *pVBInfo)
383 unsigned long P3d4 = Port, P3c4 = Port - 0x10;
385 /* keep following setting sequence, each setting in
386 * the same reg insert idle */
387 xgifb_reg_set(P3d4, 0x82, 0x77);
388 xgifb_reg_set(P3d4, 0x86, 0x00);
389 xgifb_reg_get(P3d4, 0x86); /* Insert read command for delay */
390 xgifb_reg_set(P3d4, 0x86, 0x88);
391 xgifb_reg_get(P3d4, 0x86); /* Insert read command for delay */
393 xgifb_reg_set(P3d4, 0x86, pVBInfo->CR40[13][pVBInfo->ram_type]);
394 xgifb_reg_set(P3d4, 0x82, 0x77);
395 xgifb_reg_set(P3d4, 0x85, 0x00);
396 xgifb_reg_get(P3d4, 0x85); /* Insert read command for delay */
397 xgifb_reg_set(P3d4, 0x85, 0x88);
398 xgifb_reg_get(P3d4, 0x85); /* Insert read command for delay */
401 pVBInfo->CR40[12][pVBInfo->ram_type]); /* CR85 */
402 if (HwDeviceExtension->jChipType == XG27)
404 xgifb_reg_set(P3d4, 0x82, pVBInfo->CR40[11][pVBInfo->ram_type]);
406 xgifb_reg_set(P3d4, 0x82, 0xA8); /* CR82 */
408 xgifb_reg_set(P3d4, 0x98, 0x01);
409 xgifb_reg_set(P3d4, 0x9A, 0x02);
410 if (HwDeviceExtension->jChipType == XG27)
411 XGINew_DDRII_Bootup_XG27(HwDeviceExtension, P3c4, pVBInfo);
413 XGINew_DDR2_MRS_XG20(HwDeviceExtension, P3c4, pVBInfo);
416 static void XGI_SetDRAM_Helper(unsigned long P3d4, u8 seed, u8 temp2, u8 reg,
417 u8 shift_factor, u8 mask1, u8 mask2)
420 for (j = 0; j < 4; j++) {
421 temp2 |= (((seed >> (2 * j)) & 0x03) << shift_factor);
422 xgifb_reg_set(P3d4, reg, temp2);
423 xgifb_reg_get(P3d4, reg);
429 static void XGINew_SetDRAMDefaultRegister340(
430 struct xgi_hw_device_info *HwDeviceExtension,
431 unsigned long Port, struct vb_device_info *pVBInfo)
433 unsigned char temp, temp1, temp2, temp3, i, j, k;
435 unsigned long P3d4 = Port, P3c4 = Port - 0x10;
437 xgifb_reg_set(P3d4, 0x6D, pVBInfo->CR40[8][pVBInfo->ram_type]);
438 xgifb_reg_set(P3d4, 0x68, pVBInfo->CR40[5][pVBInfo->ram_type]);
439 xgifb_reg_set(P3d4, 0x69, pVBInfo->CR40[6][pVBInfo->ram_type]);
440 xgifb_reg_set(P3d4, 0x6A, pVBInfo->CR40[7][pVBInfo->ram_type]);
442 /* CR6B DQS fine tune delay */
443 temp = (pVBInfo->ram_type <= 2) ? 0xaa : 0x00;
444 XGI_SetDRAM_Helper(P3d4, temp, 0, 0x6B, 2, 0xF0, 0x10);
446 /* CR6E DQM fine tune delay */
447 XGI_SetDRAM_Helper(P3d4, 0, 0, 0x6E, 2, 0xF0, 0x10);
450 for (k = 0; k < 4; k++) {
451 /* CR6E_D[1:0] select channel */
452 xgifb_reg_and_or(P3d4, 0x6E, 0xFC, temp3);
453 XGI_SetDRAM_Helper(P3d4, 0, 0, 0x6F, 0, 0xF8, 0x08);
459 pVBInfo->CR40[9][pVBInfo->ram_type]); /* CR80 */
462 pVBInfo->CR40[10][pVBInfo->ram_type]); /* CR81 */
465 /* CR89 terminator type select */
466 XGI_SetDRAM_Helper(P3d4, 0, temp2, 0x89, 0, 0xF0, 0x10);
471 xgifb_reg_set(P3d4, 0x89, temp2);
473 temp = pVBInfo->CR40[3][pVBInfo->ram_type];
475 temp2 = (temp >> 4) & 0x07;
477 xgifb_reg_set(P3d4, 0x45, temp1); /* CR45 */
478 xgifb_reg_set(P3d4, 0x99, temp2); /* CR99 */
479 xgifb_reg_or(P3d4, 0x40, temp3); /* CR40_D[7] */
482 pVBInfo->CR40[0][pVBInfo->ram_type]); /* CR41 */
484 if (HwDeviceExtension->jChipType == XG27)
485 xgifb_reg_set(P3d4, 0x8F, XG27_CR8F); /* CR8F */
487 for (j = 0; j <= 6; j++) /* CR90 - CR96 */
488 xgifb_reg_set(P3d4, (0x90 + j),
489 pVBInfo->CR40[14 + j][pVBInfo->ram_type]);
491 for (j = 0; j <= 2; j++) /* CRC3 - CRC5 */
492 xgifb_reg_set(P3d4, (0xC3 + j),
493 pVBInfo->CR40[21 + j][pVBInfo->ram_type]);
495 for (j = 0; j < 2; j++) /* CR8A - CR8B */
496 xgifb_reg_set(P3d4, (0x8A + j),
497 pVBInfo->CR40[1 + j][pVBInfo->ram_type]);
499 if (HwDeviceExtension->jChipType == XG42)
500 xgifb_reg_set(P3d4, 0x8C, 0x87);
504 pVBInfo->CR40[4][pVBInfo->ram_type]); /* CR59 */
506 xgifb_reg_set(P3d4, 0x83, 0x09); /* CR83 */
507 xgifb_reg_set(P3d4, 0x87, 0x00); /* CR87 */
508 xgifb_reg_set(P3d4, 0xCF, XG40_CRCF); /* CRCF */
509 if (pVBInfo->ram_type) {
510 xgifb_reg_set(P3c4, 0x17, 0x80); /* SR17 DDRII */
511 if (HwDeviceExtension->jChipType == XG27)
512 xgifb_reg_set(P3c4, 0x17, 0x02); /* SR17 DDRII */
515 xgifb_reg_set(P3c4, 0x17, 0x00); /* SR17 DDR */
517 xgifb_reg_set(P3c4, 0x1A, 0x87); /* SR1A */
519 temp = XGINew_GetXG20DRAMType(HwDeviceExtension, pVBInfo);
521 XGINew_DDR1x_DefaultRegister(HwDeviceExtension, P3d4, pVBInfo);
523 xgifb_reg_set(P3d4, 0xB0, 0x80); /* DDRII Dual frequency mode */
524 XGINew_DDR2_DefaultRegister(HwDeviceExtension, P3d4, pVBInfo);
528 pVBInfo->SR15[3][pVBInfo->ram_type]); /* SR1B */
532 static unsigned short XGINew_SetDRAMSize20Reg(
533 unsigned short dram_size,
534 struct vb_device_info *pVBInfo)
536 unsigned short data = 0, memsize = 0;
538 unsigned char ChannelNo;
540 RankSize = dram_size * pVBInfo->ram_bus / 8;
541 data = xgifb_reg_get(pVBInfo->P3c4, 0x13);
549 if (pVBInfo->ram_channel == 3)
552 ChannelNo = pVBInfo->ram_channel;
554 if (ChannelNo * RankSize <= 256) {
555 while ((RankSize >>= 1) > 0)
560 /* Fix DRAM Sizing Error */
561 xgifb_reg_set(pVBInfo->P3c4,
563 (xgifb_reg_get(pVBInfo->P3c4, 0x14) & 0x0F) |
570 static int XGINew_ReadWriteRest(unsigned short StopAddr,
571 unsigned short StartAddr, struct vb_device_info *pVBInfo)
574 unsigned long Position = 0;
575 void __iomem *fbaddr = pVBInfo->FBAddr;
577 writel(Position, fbaddr + Position);
579 for (i = StartAddr; i <= StopAddr; i++) {
581 writel(Position, fbaddr + Position);
584 udelay(500); /* Fix #1759 Memory Size error in Multi-Adapter. */
588 if (readl(fbaddr + Position) != Position)
591 for (i = StartAddr; i <= StopAddr; i++) {
593 if (readl(fbaddr + Position) != Position)
599 static unsigned char XGINew_CheckFrequence(struct vb_device_info *pVBInfo)
603 data = xgifb_reg_get(pVBInfo->P3d4, 0x97);
605 if ((data & 0x10) == 0) {
606 data = xgifb_reg_get(pVBInfo->P3c4, 0x39);
607 data = (data & 0x02) >> 1;
614 static void XGINew_CheckChannel(struct xgi_hw_device_info *HwDeviceExtension,
615 struct vb_device_info *pVBInfo)
619 switch (HwDeviceExtension->jChipType) {
622 data = xgifb_reg_get(pVBInfo->P3d4, 0x97);
624 pVBInfo->ram_channel = 1; /* XG20 "JUST" one channel */
626 if (data == 0) { /* Single_32_16 */
628 if ((HwDeviceExtension->ulVideoMemorySize - 1)
631 pVBInfo->ram_bus = 32; /* 32 bits */
632 /* 22bit + 2 rank + 32bit */
633 xgifb_reg_set(pVBInfo->P3c4, 0x13, 0xB1);
634 xgifb_reg_set(pVBInfo->P3c4, 0x14, 0x52);
637 if (XGINew_ReadWriteRest(24, 23, pVBInfo) == 1)
640 if ((HwDeviceExtension->ulVideoMemorySize - 1) >
642 /* 22bit + 1 rank + 32bit */
643 xgifb_reg_set(pVBInfo->P3c4,
646 xgifb_reg_set(pVBInfo->P3c4,
651 if (XGINew_ReadWriteRest(23,
658 if ((HwDeviceExtension->ulVideoMemorySize - 1) >
660 pVBInfo->ram_bus = 16; /* 16 bits */
661 /* 22bit + 2 rank + 16bit */
662 xgifb_reg_set(pVBInfo->P3c4, 0x13, 0xB1);
663 xgifb_reg_set(pVBInfo->P3c4, 0x14, 0x41);
666 if (XGINew_ReadWriteRest(23, 22, pVBInfo) == 1)
669 xgifb_reg_set(pVBInfo->P3c4,
675 } else { /* Dual_16_8 */
676 if ((HwDeviceExtension->ulVideoMemorySize - 1) >
678 pVBInfo->ram_bus = 16; /* 16 bits */
679 /* (0x31:12x8x2) 22bit + 2 rank */
680 xgifb_reg_set(pVBInfo->P3c4, 0x13, 0xB1);
682 xgifb_reg_set(pVBInfo->P3c4, 0x14, 0x41);
685 if (XGINew_ReadWriteRest(23, 22, pVBInfo) == 1)
688 if ((HwDeviceExtension->ulVideoMemorySize - 1) >
690 /* (0x31:12x8x2) 22bit + 1 rank */
691 xgifb_reg_set(pVBInfo->P3c4,
695 xgifb_reg_set(pVBInfo->P3c4,
700 if (XGINew_ReadWriteRest(22,
707 if ((HwDeviceExtension->ulVideoMemorySize - 1) >
709 pVBInfo->ram_bus = 8; /* 8 bits */
710 /* (0x31:12x8x2) 22bit + 2 rank */
711 xgifb_reg_set(pVBInfo->P3c4, 0x13, 0xB1);
713 xgifb_reg_set(pVBInfo->P3c4, 0x14, 0x30);
716 if (XGINew_ReadWriteRest(22, 21, pVBInfo) == 1)
718 else /* (0x31:12x8x2) 22bit + 1 rank */
719 xgifb_reg_set(pVBInfo->P3c4,
728 pVBInfo->ram_bus = 16; /* 16 bits */
729 pVBInfo->ram_channel = 1; /* Single channel */
730 xgifb_reg_set(pVBInfo->P3c4, 0x14, 0x51); /* 32Mx16 bit*/
734 XG42 SR14 D[3] Reserve
735 D[2] = 1, Dual Channel
738 It's Different from Other XG40 Series.
740 if (XGINew_CheckFrequence(pVBInfo) == 1) { /* DDRII, DDR2x */
741 pVBInfo->ram_bus = 32; /* 32 bits */
742 pVBInfo->ram_channel = 2; /* 2 Channel */
743 xgifb_reg_set(pVBInfo->P3c4, 0x13, 0xA1);
744 xgifb_reg_set(pVBInfo->P3c4, 0x14, 0x44);
746 if (XGINew_ReadWriteRest(24, 23, pVBInfo) == 1)
749 xgifb_reg_set(pVBInfo->P3c4, 0x13, 0x21);
750 xgifb_reg_set(pVBInfo->P3c4, 0x14, 0x34);
751 if (XGINew_ReadWriteRest(23, 22, pVBInfo) == 1)
754 pVBInfo->ram_channel = 1; /* Single Channel */
755 xgifb_reg_set(pVBInfo->P3c4, 0x13, 0xA1);
756 xgifb_reg_set(pVBInfo->P3c4, 0x14, 0x40);
758 if (XGINew_ReadWriteRest(23, 22, pVBInfo) == 1)
761 xgifb_reg_set(pVBInfo->P3c4, 0x13, 0x21);
762 xgifb_reg_set(pVBInfo->P3c4, 0x14, 0x30);
765 pVBInfo->ram_bus = 64; /* 64 bits */
766 pVBInfo->ram_channel = 1; /* 1 channels */
767 xgifb_reg_set(pVBInfo->P3c4, 0x13, 0xA1);
768 xgifb_reg_set(pVBInfo->P3c4, 0x14, 0x52);
770 if (XGINew_ReadWriteRest(24, 23, pVBInfo) == 1)
773 xgifb_reg_set(pVBInfo->P3c4, 0x13, 0x21);
774 xgifb_reg_set(pVBInfo->P3c4, 0x14, 0x42);
782 if (XGINew_CheckFrequence(pVBInfo) == 1) { /* DDRII */
783 pVBInfo->ram_bus = 32; /* 32 bits */
784 pVBInfo->ram_channel = 3;
785 xgifb_reg_set(pVBInfo->P3c4, 0x13, 0xA1);
786 xgifb_reg_set(pVBInfo->P3c4, 0x14, 0x4C);
788 if (XGINew_ReadWriteRest(25, 23, pVBInfo) == 1)
791 pVBInfo->ram_channel = 2; /* 2 channels */
792 xgifb_reg_set(pVBInfo->P3c4, 0x14, 0x48);
794 if (XGINew_ReadWriteRest(24, 23, pVBInfo) == 1)
797 xgifb_reg_set(pVBInfo->P3c4, 0x13, 0x21);
798 xgifb_reg_set(pVBInfo->P3c4, 0x14, 0x3C);
800 if (XGINew_ReadWriteRest(24, 23, pVBInfo) == 1) {
801 pVBInfo->ram_channel = 3; /* 4 channels */
803 pVBInfo->ram_channel = 2; /* 2 channels */
804 xgifb_reg_set(pVBInfo->P3c4, 0x14, 0x38);
807 pVBInfo->ram_bus = 64; /* 64 bits */
808 pVBInfo->ram_channel = 2; /* 2 channels */
809 xgifb_reg_set(pVBInfo->P3c4, 0x13, 0xA1);
810 xgifb_reg_set(pVBInfo->P3c4, 0x14, 0x5A);
812 if (XGINew_ReadWriteRest(25, 24, pVBInfo) == 1) {
815 xgifb_reg_set(pVBInfo->P3c4, 0x13, 0x21);
816 xgifb_reg_set(pVBInfo->P3c4, 0x14, 0x4A);
823 static int XGINew_DDRSizing340(struct xgi_hw_device_info *HwDeviceExtension,
824 struct vb_device_info *pVBInfo)
827 unsigned short memsize, start_addr;
828 const unsigned short (*dram_table)[2];
830 xgifb_reg_set(pVBInfo->P3c4, 0x15, 0x00); /* noninterleaving */
831 xgifb_reg_set(pVBInfo->P3c4, 0x1C, 0x00); /* nontiling */
832 XGINew_CheckChannel(HwDeviceExtension, pVBInfo);
834 if (HwDeviceExtension->jChipType >= XG20) {
835 dram_table = XGINew_DDRDRAM_TYPE20;
836 size = ARRAY_SIZE(XGINew_DDRDRAM_TYPE20);
839 dram_table = XGINew_DDRDRAM_TYPE340;
840 size = ARRAY_SIZE(XGINew_DDRDRAM_TYPE340);
844 for (i = 0; i < size; i++) {
845 /* SetDRAMSizingType */
846 xgifb_reg_and_or(pVBInfo->P3c4, 0x13, 0x80, dram_table[i][1]);
847 udelay(15); /* should delay 50 ns */
849 memsize = XGINew_SetDRAMSize20Reg(dram_table[i][0], pVBInfo);
854 memsize += (pVBInfo->ram_channel - 2) + 20;
855 if ((HwDeviceExtension->ulVideoMemorySize - 1) <
856 (unsigned long) (1 << memsize))
859 if (XGINew_ReadWriteRest(memsize, start_addr, pVBInfo) == 1)
865 static void XGINew_SetDRAMSize_340(struct xgifb_video_info *xgifb_info,
866 struct xgi_hw_device_info *HwDeviceExtension,
867 struct vb_device_info *pVBInfo)
871 pVBInfo->FBAddr = HwDeviceExtension->pjVideoMemoryAddress;
873 XGISetModeNew(xgifb_info, HwDeviceExtension, 0x2e);
875 data = xgifb_reg_get(pVBInfo->P3c4, 0x21);
876 /* disable read cache */
877 xgifb_reg_set(pVBInfo->P3c4, 0x21, (unsigned short) (data & 0xDF));
878 XGI_DisplayOff(xgifb_info, HwDeviceExtension, pVBInfo);
880 XGINew_DDRSizing340(HwDeviceExtension, pVBInfo);
881 data = xgifb_reg_get(pVBInfo->P3c4, 0x21);
882 /* enable read cache */
883 xgifb_reg_set(pVBInfo->P3c4, 0x21, (unsigned short) (data | 0x20));
886 static u8 *xgifb_copy_rom(struct pci_dev *dev, size_t *rom_size)
888 void __iomem *rom_address;
891 rom_address = pci_map_rom(dev, rom_size);
892 if (rom_address == NULL)
895 rom_copy = vzalloc(XGIFB_ROM_SIZE);
896 if (rom_copy == NULL)
899 *rom_size = min_t(size_t, *rom_size, XGIFB_ROM_SIZE);
900 memcpy_fromio(rom_copy, rom_address, *rom_size);
903 pci_unmap_rom(dev, rom_address);
907 static void xgifb_read_vbios(struct pci_dev *pdev,
908 struct vb_device_info *pVBInfo)
910 struct xgifb_video_info *xgifb_info = pci_get_drvdata(pdev);
914 struct XGI21_LVDSCapStruct *lvds;
918 if (xgifb_info->chip != XG21)
920 pVBInfo->IF_DEF_LVDS = 0;
921 vbios = xgifb_copy_rom(pdev, &vbios_size);
923 dev_err(&pdev->dev, "Video BIOS not available\n");
926 if (vbios_size <= 0x65)
929 * The user can ignore the LVDS bit in the BIOS and force the display
932 if (!(vbios[0x65] & 0x1) &&
933 (!xgifb_info->display2_force ||
934 xgifb_info->display2 != XGIFB_DISP_LCD)) {
938 if (vbios_size <= 0x317)
940 i = vbios[0x316] | (vbios[0x317] << 8);
941 if (vbios_size <= i - 1)
949 * Read the LVDS table index scratch register set by the BIOS.
951 entry = xgifb_reg_get(xgifb_info->dev_info.P3d4, 0x36);
955 lvds = &xgifb_info->lvds_data;
956 if (vbios_size <= i + 24)
958 lvds->LVDS_Capability = vbios[i] | (vbios[i + 1] << 8);
959 lvds->LVDSHT = vbios[i + 2] | (vbios[i + 3] << 8);
960 lvds->LVDSVT = vbios[i + 4] | (vbios[i + 5] << 8);
961 lvds->LVDSHDE = vbios[i + 6] | (vbios[i + 7] << 8);
962 lvds->LVDSVDE = vbios[i + 8] | (vbios[i + 9] << 8);
963 lvds->LVDSHFP = vbios[i + 10] | (vbios[i + 11] << 8);
964 lvds->LVDSVFP = vbios[i + 12] | (vbios[i + 13] << 8);
965 lvds->LVDSHSYNC = vbios[i + 14] | (vbios[i + 15] << 8);
966 lvds->LVDSVSYNC = vbios[i + 16] | (vbios[i + 17] << 8);
967 lvds->VCLKData1 = vbios[i + 18];
968 lvds->VCLKData2 = vbios[i + 19];
969 lvds->PSC_S1 = vbios[i + 20];
970 lvds->PSC_S2 = vbios[i + 21];
971 lvds->PSC_S3 = vbios[i + 22];
972 lvds->PSC_S4 = vbios[i + 23];
973 lvds->PSC_S5 = vbios[i + 24];
975 pVBInfo->IF_DEF_LVDS = 1;
978 dev_err(&pdev->dev, "Video BIOS corrupted\n");
982 static void XGINew_ChkSenseStatus(struct xgi_hw_device_info *HwDeviceExtension,
983 struct vb_device_info *pVBInfo)
985 unsigned short tempbx = 0, temp, tempcx, CR3CData;
987 temp = xgifb_reg_get(pVBInfo->P3d4, 0x32);
989 if (temp & Monitor1Sense)
990 tempbx |= ActiveCRT1;
993 if (temp & Monitor2Sense)
994 tempbx |= ActiveCRT2;
995 if (temp & TVSense) {
997 if (temp & AVIDEOSense)
998 tempbx |= (ActiveAVideo << 8);
999 if (temp & SVIDEOSense)
1000 tempbx |= (ActiveSVideo << 8);
1001 if (temp & SCARTSense)
1002 tempbx |= (ActiveSCART << 8);
1003 if (temp & HiTVSense)
1004 tempbx |= (ActiveHiTV << 8);
1005 if (temp & YPbPrSense)
1006 tempbx |= (ActiveYPbPr << 8);
1009 tempcx = xgifb_reg_get(pVBInfo->P3d4, 0x3d);
1010 tempcx |= (xgifb_reg_get(pVBInfo->P3d4, 0x3e) << 8);
1012 if (tempbx & tempcx) {
1013 CR3CData = xgifb_reg_get(pVBInfo->P3d4, 0x3c);
1014 if (!(CR3CData & DisplayDeviceFromCMOS))
1021 xgifb_reg_set(pVBInfo->P3d4, 0x3d, (tempbx & 0x00FF));
1022 xgifb_reg_set(pVBInfo->P3d4, 0x3e, ((tempbx & 0xFF00) >> 8));
1025 static void XGINew_SetModeScratch(struct xgi_hw_device_info *HwDeviceExtension,
1026 struct vb_device_info *pVBInfo)
1028 unsigned short temp, tempcl = 0, tempch = 0, CR31Data, CR38Data;
1030 temp = xgifb_reg_get(pVBInfo->P3d4, 0x3d);
1031 temp |= xgifb_reg_get(pVBInfo->P3d4, 0x3e) << 8;
1032 temp |= (xgifb_reg_get(pVBInfo->P3d4, 0x31) & (DriverMode >> 8)) << 8;
1034 if (pVBInfo->IF_DEF_CRT2Monitor == 1) {
1035 if (temp & ActiveCRT2)
1036 tempcl = SetCRT2ToRAMDAC;
1039 if (temp & ActiveLCD) {
1040 tempcl |= SetCRT2ToLCD;
1041 if (temp & DriverMode) {
1042 if (temp & ActiveTV) {
1043 tempch = SetToLCDA | EnableDualEdge;
1044 temp ^= SetCRT2ToLCD;
1046 if ((temp >> 8) & ActiveAVideo)
1047 tempcl |= SetCRT2ToAVIDEO;
1048 if ((temp >> 8) & ActiveSVideo)
1049 tempcl |= SetCRT2ToSVIDEO;
1050 if ((temp >> 8) & ActiveSCART)
1051 tempcl |= SetCRT2ToSCART;
1053 if (pVBInfo->IF_DEF_HiVision == 1) {
1054 if ((temp >> 8) & ActiveHiTV)
1055 tempcl |= SetCRT2ToHiVision;
1058 if (pVBInfo->IF_DEF_YPbPr == 1) {
1059 if ((temp >> 8) & ActiveYPbPr)
1065 if ((temp >> 8) & ActiveAVideo)
1066 tempcl |= SetCRT2ToAVIDEO;
1067 if ((temp >> 8) & ActiveSVideo)
1068 tempcl |= SetCRT2ToSVIDEO;
1069 if ((temp >> 8) & ActiveSCART)
1070 tempcl |= SetCRT2ToSCART;
1072 if (pVBInfo->IF_DEF_HiVision == 1) {
1073 if ((temp >> 8) & ActiveHiTV)
1074 tempcl |= SetCRT2ToHiVision;
1077 if (pVBInfo->IF_DEF_YPbPr == 1) {
1078 if ((temp >> 8) & ActiveYPbPr)
1083 tempcl |= SetSimuScanMode;
1084 if ((!(temp & ActiveCRT1)) && ((temp & ActiveLCD) || (temp & ActiveTV)
1085 || (temp & ActiveCRT2)))
1086 tempcl ^= (SetSimuScanMode | SwitchCRT2);
1087 if ((temp & ActiveLCD) && (temp & ActiveTV))
1088 tempcl ^= (SetSimuScanMode | SwitchCRT2);
1089 xgifb_reg_set(pVBInfo->P3d4, 0x30, tempcl);
1091 CR31Data = xgifb_reg_get(pVBInfo->P3d4, 0x31);
1092 CR31Data &= ~(SetNotSimuMode >> 8);
1093 if (!(temp & ActiveCRT1))
1094 CR31Data |= (SetNotSimuMode >> 8);
1095 CR31Data &= ~(DisableCRT2Display >> 8);
1096 if (!((temp & ActiveLCD) || (temp & ActiveTV) || (temp & ActiveCRT2)))
1097 CR31Data |= (DisableCRT2Display >> 8);
1098 xgifb_reg_set(pVBInfo->P3d4, 0x31, CR31Data);
1100 CR38Data = xgifb_reg_get(pVBInfo->P3d4, 0x38);
1101 CR38Data &= ~SetYPbPr;
1103 xgifb_reg_set(pVBInfo->P3d4, 0x38, CR38Data);
1107 static unsigned short XGINew_SenseLCD(struct xgi_hw_device_info
1109 struct vb_device_info *pVBInfo)
1111 unsigned short temp;
1114 if (HwDeviceExtension->ulCRT2LCDType == LCD_UNKNOWN) {
1117 temp = (unsigned short) HwDeviceExtension->ulCRT2LCDType;
1118 switch (HwDeviceExtension->ulCRT2LCDType) {
1146 xgifb_reg_and_or(pVBInfo->P3d4, 0x36, 0xF0, temp);
1151 static void XGINew_GetXG21Sense(struct xgi_hw_device_info *HwDeviceExtension,
1152 struct vb_device_info *pVBInfo)
1156 if (pVBInfo->IF_DEF_LVDS) { /* For XG21 LVDS */
1157 xgifb_reg_or(pVBInfo->P3d4, 0x32, LCDSense);
1159 xgifb_reg_and_or(pVBInfo->P3d4, 0x38, ~0xE0, 0xC0);
1161 /* Enable GPIOA/B read */
1162 xgifb_reg_and_or(pVBInfo->P3d4, 0x4A, ~0x03, 0x03);
1163 Temp = xgifb_reg_get(pVBInfo->P3d4, 0x48) & 0xC0;
1164 if (Temp == 0xC0) { /* DVI & DVO GPIOA/B pull high */
1165 XGINew_SenseLCD(HwDeviceExtension, pVBInfo);
1166 xgifb_reg_or(pVBInfo->P3d4, 0x32, LCDSense);
1167 /* Enable read GPIOF */
1168 xgifb_reg_and_or(pVBInfo->P3d4, 0x4A, ~0x20, 0x20);
1169 Temp = xgifb_reg_get(pVBInfo->P3d4, 0x48) & 0x04;
1171 xgifb_reg_and_or(pVBInfo->P3d4,
1174 0x80); /* TMDS on chip */
1176 xgifb_reg_and_or(pVBInfo->P3d4,
1179 0xA0); /* Only DVO on chip */
1180 /* Disable read GPIOF */
1181 xgifb_reg_and(pVBInfo->P3d4, 0x4A, ~0x20);
1186 static void XGINew_GetXG27Sense(struct xgi_hw_device_info *HwDeviceExtension,
1187 struct vb_device_info *pVBInfo)
1189 unsigned char Temp, bCR4A;
1191 pVBInfo->IF_DEF_LVDS = 0;
1192 bCR4A = xgifb_reg_get(pVBInfo->P3d4, 0x4A);
1193 /* Enable GPIOA/B/C read */
1194 xgifb_reg_and_or(pVBInfo->P3d4, 0x4A, ~0x07, 0x07);
1195 Temp = xgifb_reg_get(pVBInfo->P3d4, 0x48) & 0x07;
1196 xgifb_reg_set(pVBInfo->P3d4, 0x4A, bCR4A);
1200 xgifb_reg_and_or(pVBInfo->P3d4, 0x38, ~0xE0, 0xC0);
1201 xgifb_reg_set(pVBInfo->P3d4, 0x30, 0x21);
1203 /* TMDS/DVO setting */
1204 xgifb_reg_and_or(pVBInfo->P3d4, 0x38, ~0xE0, 0xA0);
1206 xgifb_reg_or(pVBInfo->P3d4, 0x32, LCDSense);
1210 static unsigned char GetXG21FPBits(struct vb_device_info *pVBInfo)
1212 unsigned char CR38, CR4A, temp;
1214 CR4A = xgifb_reg_get(pVBInfo->P3d4, 0x4A);
1215 /* enable GPIOE read */
1216 xgifb_reg_and_or(pVBInfo->P3d4, 0x4A, ~0x10, 0x10);
1217 CR38 = xgifb_reg_get(pVBInfo->P3d4, 0x38);
1219 if ((CR38 & 0xE0) > 0x80) {
1220 temp = xgifb_reg_get(pVBInfo->P3d4, 0x48);
1225 xgifb_reg_set(pVBInfo->P3d4, 0x4A, CR4A);
1230 static unsigned char GetXG27FPBits(struct vb_device_info *pVBInfo)
1232 unsigned char CR4A, temp;
1234 CR4A = xgifb_reg_get(pVBInfo->P3d4, 0x4A);
1235 /* enable GPIOA/B/C read */
1236 xgifb_reg_and_or(pVBInfo->P3d4, 0x4A, ~0x03, 0x03);
1237 temp = xgifb_reg_get(pVBInfo->P3d4, 0x48);
1241 temp = ((temp & 0x04) >> 1) | ((~temp) & 0x01);
1243 xgifb_reg_set(pVBInfo->P3d4, 0x4A, CR4A);
1248 unsigned char XGIInitNew(struct pci_dev *pdev)
1250 struct xgifb_video_info *xgifb_info = pci_get_drvdata(pdev);
1251 struct xgi_hw_device_info *HwDeviceExtension = &xgifb_info->hw_info;
1252 struct vb_device_info VBINF;
1253 struct vb_device_info *pVBInfo = &VBINF;
1254 unsigned char i, temp = 0, temp1;
1256 pVBInfo->FBAddr = HwDeviceExtension->pjVideoMemoryAddress;
1258 if (pVBInfo->FBAddr == NULL) {
1259 dev_dbg(&pdev->dev, "pVBInfo->FBAddr == 0\n");
1263 XGIRegInit(pVBInfo, xgifb_info->vga_base);
1265 outb(0x67, pVBInfo->P3c2);
1267 if (HwDeviceExtension->jChipType < XG20)
1268 /* Run XGI_GetVBType before InitTo330Pointer */
1269 XGI_GetVBType(pVBInfo);
1271 InitTo330Pointer(HwDeviceExtension->jChipType, pVBInfo);
1273 xgifb_read_vbios(pdev, pVBInfo);
1276 xgifb_reg_set(pVBInfo->P3c4, 0x05, 0x86);
1278 /* GetXG21Sense (GPIO) */
1279 if (HwDeviceExtension->jChipType == XG21)
1280 XGINew_GetXG21Sense(HwDeviceExtension, pVBInfo);
1282 if (HwDeviceExtension->jChipType == XG27)
1283 XGINew_GetXG27Sense(HwDeviceExtension, pVBInfo);
1285 /* Reset Extended register */
1287 for (i = 0x06; i < 0x20; i++)
1288 xgifb_reg_set(pVBInfo->P3c4, i, 0);
1290 for (i = 0x21; i <= 0x27; i++)
1291 xgifb_reg_set(pVBInfo->P3c4, i, 0);
1293 for (i = 0x31; i <= 0x3B; i++)
1294 xgifb_reg_set(pVBInfo->P3c4, i, 0);
1296 /* Auto over driver for XG42 */
1297 if (HwDeviceExtension->jChipType == XG42)
1298 xgifb_reg_set(pVBInfo->P3c4, 0x3B, 0xC0);
1300 for (i = 0x79; i <= 0x7C; i++)
1301 xgifb_reg_set(pVBInfo->P3d4, i, 0);
1303 if (HwDeviceExtension->jChipType >= XG20)
1304 xgifb_reg_set(pVBInfo->P3d4, 0x97, pVBInfo->XGINew_CR97);
1306 /* SetDefExt1Regs begin */
1307 xgifb_reg_set(pVBInfo->P3c4, 0x07, XGI330_SR07);
1308 if (HwDeviceExtension->jChipType == XG27) {
1309 xgifb_reg_set(pVBInfo->P3c4, 0x40, XG27_SR40);
1310 xgifb_reg_set(pVBInfo->P3c4, 0x41, XG27_SR41);
1312 xgifb_reg_set(pVBInfo->P3c4, 0x11, 0x0F);
1313 xgifb_reg_set(pVBInfo->P3c4, 0x1F, XGI330_SR1F);
1314 /* Frame buffer can read/write SR20 */
1315 xgifb_reg_set(pVBInfo->P3c4, 0x20, 0xA0);
1316 /* H/W request for slow corner chip */
1317 xgifb_reg_set(pVBInfo->P3c4, 0x36, 0x70);
1318 if (HwDeviceExtension->jChipType == XG27)
1319 xgifb_reg_set(pVBInfo->P3c4, 0x36, XG27_SR36);
1321 if (HwDeviceExtension->jChipType < XG20) {
1324 /* Set AGP customize registers (in SetDefAGPRegs) Start */
1325 for (i = 0x47; i <= 0x4C; i++)
1326 xgifb_reg_set(pVBInfo->P3d4,
1328 XGI340_AGPReg[i - 0x47]);
1330 for (i = 0x70; i <= 0x71; i++)
1331 xgifb_reg_set(pVBInfo->P3d4,
1333 XGI340_AGPReg[6 + i - 0x70]);
1335 for (i = 0x74; i <= 0x77; i++)
1336 xgifb_reg_set(pVBInfo->P3d4,
1338 XGI340_AGPReg[8 + i - 0x74]);
1340 pci_read_config_dword(pdev, 0x50, &Temp);
1345 xgifb_reg_set(pVBInfo->P3d4, 0x48, 0x20); /* CR48 */
1349 xgifb_reg_set(pVBInfo->P3c4, 0x23, XGI330_SR23);
1350 xgifb_reg_set(pVBInfo->P3c4, 0x24, XGI330_SR24);
1351 xgifb_reg_set(pVBInfo->P3c4, 0x25, 0);
1353 if (HwDeviceExtension->jChipType < XG20) {
1355 XGI_UnLockCRT2(HwDeviceExtension, pVBInfo);
1356 /* disable VideoCapture */
1357 xgifb_reg_and_or(pVBInfo->Part0Port, 0x3F, 0xEF, 0x00);
1358 xgifb_reg_set(pVBInfo->Part1Port, 0x00, 0x00);
1359 /* chk if BCLK>=100MHz */
1360 temp1 = (unsigned char) xgifb_reg_get(pVBInfo->P3d4, 0x7B);
1361 temp = (unsigned char) ((temp1 >> 4) & 0x0F);
1363 xgifb_reg_set(pVBInfo->Part1Port,
1364 0x02, XGI330_CRT2Data_1_2);
1366 xgifb_reg_set(pVBInfo->Part1Port, 0x2E, 0x08); /* use VB */
1369 xgifb_reg_set(pVBInfo->P3c4, 0x27, 0x1F);
1371 if ((HwDeviceExtension->jChipType == XG42) &&
1372 XGINew_GetXG20DRAMType(HwDeviceExtension, pVBInfo) != 0) {
1374 xgifb_reg_set(pVBInfo->P3c4,
1376 (XGI330_SR31 & 0x3F) | 0x40);
1377 xgifb_reg_set(pVBInfo->P3c4,
1379 (XGI330_SR32 & 0xFC) | 0x01);
1381 xgifb_reg_set(pVBInfo->P3c4, 0x31, XGI330_SR31);
1382 xgifb_reg_set(pVBInfo->P3c4, 0x32, XGI330_SR32);
1384 xgifb_reg_set(pVBInfo->P3c4, 0x33, XGI330_SR33);
1386 if (HwDeviceExtension->jChipType < XG20) {
1387 if (XGI_BridgeIsOn(pVBInfo) == 1) {
1388 if (pVBInfo->IF_DEF_LVDS == 0) {
1389 xgifb_reg_set(pVBInfo->Part2Port, 0x00, 0x1C);
1390 xgifb_reg_set(pVBInfo->Part4Port,
1391 0x0D, XGI330_CRT2Data_4_D);
1392 xgifb_reg_set(pVBInfo->Part4Port,
1393 0x0E, XGI330_CRT2Data_4_E);
1394 xgifb_reg_set(pVBInfo->Part4Port,
1395 0x10, XGI330_CRT2Data_4_10);
1396 xgifb_reg_set(pVBInfo->Part4Port, 0x0F, 0x3F);
1399 XGI_LockCRT2(HwDeviceExtension, pVBInfo);
1403 XGI_SenseCRT1(pVBInfo);
1405 if (HwDeviceExtension->jChipType == XG21) {
1407 xgifb_reg_and_or(pVBInfo->P3d4,
1410 Monitor1Sense); /* Z9 default has CRT */
1411 temp = GetXG21FPBits(pVBInfo);
1412 xgifb_reg_and_or(pVBInfo->P3d4, 0x37, ~0x01, temp);
1415 if (HwDeviceExtension->jChipType == XG27) {
1416 xgifb_reg_and_or(pVBInfo->P3d4,
1419 Monitor1Sense); /* Z9 default has CRT */
1420 temp = GetXG27FPBits(pVBInfo);
1421 xgifb_reg_and_or(pVBInfo->P3d4, 0x37, ~0x03, temp);
1424 pVBInfo->ram_type = XGINew_GetXG20DRAMType(HwDeviceExtension, pVBInfo);
1426 XGINew_SetDRAMDefaultRegister340(HwDeviceExtension,
1430 XGINew_SetDRAMSize_340(xgifb_info, HwDeviceExtension, pVBInfo);
1432 xgifb_reg_set(pVBInfo->P3c4, 0x22, 0xfa);
1433 xgifb_reg_set(pVBInfo->P3c4, 0x21, 0xa3);
1435 XGINew_ChkSenseStatus(HwDeviceExtension, pVBInfo);
1436 XGINew_SetModeScratch(HwDeviceExtension, pVBInfo);
1438 xgifb_reg_set(pVBInfo->P3d4, 0x8c, 0x87);