?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
usb: dwc3: ep0: add handling for unaligned OUT transfers
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / staging / xgifb / XGI_main_26.c
blob4403e5f8059713d5062a8be65a574513c030c8f6
1 /*
2 * XG20, XG21, XG40, XG42 frame buffer device
3 * for Linux kernels 2.5.x, 2.6.x
4 * Base on TW's sis fbdev code.
5 */
6
7 /* #include <linux/config.h> */
8 #include <linux/module.h>
9 #include <linux/moduleparam.h>
10 #include <linux/kernel.h>
11 #include <linux/spinlock.h>
12 #include <linux/errno.h>
13 #include <linux/string.h>
14 #include <linux/mm.h>
15 #include <linux/tty.h>
16 #include <linux/slab.h>
17 #include <linux/delay.h>
18 #include <linux/fb.h>
19 #include <linux/console.h>
20 #include <linux/selection.h>
21 #include <linux/ioport.h>
22 #include <linux/init.h>
23 #include <linux/pci.h>
24 #include <linux/vmalloc.h>
25 #include <linux/vt_kern.h>
26 #include <linux/capability.h>
27 #include <linux/fs.h>
28 #include <linux/types.h>
29 #include <linux/proc_fs.h>
30
31 #ifndef XGIFB_PAN
32 #define XGIFB_PAN
33 #endif
34
35 #include <linux/io.h>
36 #ifdef CONFIG_MTRR
37 #include <asm/mtrr.h>
38 #endif
39
40 #include "XGIfb.h"
41 #include "vgatypes.h"
42 #include "XGI_main.h"
43 #include "vb_init.h"
44 #include "vb_util.h"
45 #include "vb_setmode.h"
46
47 #define Index_CR_GPIO_Reg1 0x48
48 #define Index_CR_GPIO_Reg2 0x49
49 #define Index_CR_GPIO_Reg3 0x4a
50
51 #define GPIOG_EN (1<<6)
52 #define GPIOG_WRITE (1<<6)
53 #define GPIOG_READ (1<<1)
54
55 #define XGIFB_ROM_SIZE 65536
56
57 /* -------------------- Macro definitions ---------------------------- */
58
59 #undef XGIFBDEBUG
60
61 #ifdef XGIFBDEBUG
62 #define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt, __FUNCTION__ , ## args)
63 #else
64 #define DPRINTK(fmt, args...)
65 #endif
66
67 #ifdef XGIFBDEBUG
68 static void dumpVGAReg(void)
69 {
70 u8 i, reg;
71
72 xgifb_reg_set(XGISR, 0x05, 0x86);
73 /*
74 xgifb_reg_set(XGISR, 0x08, 0x4f);
75 xgifb_reg_set(XGISR, 0x0f, 0x20);
76 xgifb_reg_set(XGISR, 0x11, 0x4f);
77 xgifb_reg_set(XGISR, 0x13, 0x45);
78 xgifb_reg_set(XGISR, 0x14, 0x51);
79 xgifb_reg_set(XGISR, 0x1e, 0x41);
80 xgifb_reg_set(XGISR, 0x1f, 0x0);
81 xgifb_reg_set(XGISR, 0x20, 0xa1);
82 xgifb_reg_set(XGISR, 0x22, 0xfb);
83 xgifb_reg_set(XGISR, 0x26, 0x22);
84 xgifb_reg_set(XGISR, 0x3e, 0x07);
85 */
86
87 /* xgifb_reg_set(XGICR, 0x19, 0x00); */
88 /* xgifb_reg_set(XGICR, 0x1a, 0x3C); */
89 /* xgifb_reg_set(XGICR, 0x22, 0xff); */
90 /* xgifb_reg_set(XGICR, 0x3D, 0x10); */
91
92 /* xgifb_reg_set(XGICR, 0x4a, 0xf3); */
93
94 /* xgifb_reg_set(XGICR, 0x57, 0x0); */
95 /* xgifb_reg_set(XGICR, 0x7a, 0x2c); */
96
97 /* xgifb_reg_set(XGICR, 0x82, 0xcc); */
98 /* xgifb_reg_set(XGICR, 0x8c, 0x0); */
99 /*
100 xgifb_reg_set(XGICR, 0x99, 0x1);
101 xgifb_reg_set(XGICR, 0x41, 0x40);
102 */
103
104 for (i = 0; i < 0x4f; i++) {
105 reg = xgifb_reg_get(XGISR, i);
106 printk("\no 3c4 %x", i);
107 printk("\ni 3c5 => %x", reg);
108 }
109
110 for (i = 0; i < 0xF0; i++) {
111 reg = xgifb_reg_get(XGICR, i);
112 printk("\no 3d4 %x", i);
113 printk("\ni 3d5 => %x", reg);
114 }
115 /*
116 xgifb_reg_set(XGIPART1,0x2F,1);
117 for (i=1; i < 0x50; i++) {
118 reg = xgifb_reg_get(XGIPART1, i);
119 printk("\no d004 %x", i);
120 printk("\ni d005 => %x", reg);
121 }
122
123 for (i=0; i < 0x50; i++) {
124 reg = xgifb_reg_get(XGIPART2, i);
125 printk("\no d010 %x", i);
126 printk("\ni d011 => %x", reg);
127 }
128 for (i=0; i < 0x50; i++) {
129 reg = xgifb_reg_get(XGIPART3, i);
130 printk("\no d012 %x",i);
131 printk("\ni d013 => %x",reg);
132 }
133 for (i=0; i < 0x50; i++) {
134 reg = xgifb_reg_get(XGIPART4, i);
135 printk("\no d014 %x",i);
136 printk("\ni d015 => %x",reg);
137 }
138 */
139 }
140 #else
141 static inline void dumpVGAReg(void)
142 {
143 }
144 #endif
145
146 /* data for XGI components */
147 struct video_info xgi_video_info;
148
149 #if 1
150 #define DEBUGPRN(x)
151 #else
152 #define DEBUGPRN(x) printk(KERN_INFO x "\n");
153 #endif
154
155 /* --------------- Hardware Access Routines -------------------------- */
156
157 static int XGIfb_mode_rate_to_dclock(struct vb_device_info *XGI_Pr,
158 struct xgi_hw_device_info *HwDeviceExtension,
159 unsigned char modeno, unsigned char rateindex)
160 {
161 unsigned short ModeNo = modeno;
162 unsigned short ModeIdIndex = 0, ClockIndex = 0;
163 unsigned short RefreshRateTableIndex = 0;
164
165 /* unsigned long temp = 0; */
166 int Clock;
167 XGI_Pr->ROMAddr = HwDeviceExtension->pjVirtualRomBase;
168 InitTo330Pointer(HwDeviceExtension->jChipType, XGI_Pr);
169
170 RefreshRateTableIndex = XGI_GetRatePtrCRT2(HwDeviceExtension, ModeNo,
171 ModeIdIndex, XGI_Pr);
172
173 /*
174 temp = XGI_SearchModeID(ModeNo , &ModeIdIndex, XGI_Pr) ;
175 if (!temp) {
176 printk(KERN_ERR "Could not find mode %x\n", ModeNo);
177 return 65000;
178 }
179
180 RefreshRateTableIndex = XGI_Pr->EModeIDTable[ModeIdIndex].REFindex;
181 RefreshRateTableIndex += (rateindex - 1);
182
183 */
184 ClockIndex = XGI_Pr->RefIndex[RefreshRateTableIndex].Ext_CRTVCLK;
185
186 Clock = XGI_Pr->VCLKData[ClockIndex].CLOCK * 1000;
187
188 return Clock;
189 }
190
191 static int XGIfb_mode_rate_to_ddata(struct vb_device_info *XGI_Pr,
192 struct xgi_hw_device_info *HwDeviceExtension,
193 unsigned char modeno, unsigned char rateindex,
194 u32 *left_margin, u32 *right_margin, u32 *upper_margin,
195 u32 *lower_margin, u32 *hsync_len, u32 *vsync_len, u32 *sync,
196 u32 *vmode)
197 {
198 unsigned short ModeNo = modeno;
199 unsigned short ModeIdIndex = 0, index = 0;
200 unsigned short RefreshRateTableIndex = 0;
201
202 unsigned short VRE, VBE, VRS, VBS, VDE, VT;
203 unsigned short HRE, HBE, HRS, HBS, HDE, HT;
204 unsigned char sr_data, cr_data, cr_data2;
205 unsigned long cr_data3;
206 int A, B, C, D, E, F, temp, j;
207 XGI_Pr->ROMAddr = HwDeviceExtension->pjVirtualRomBase;
208 InitTo330Pointer(HwDeviceExtension->jChipType, XGI_Pr);
209 RefreshRateTableIndex = XGI_GetRatePtrCRT2(HwDeviceExtension, ModeNo,
210 ModeIdIndex, XGI_Pr);
211 /*
212 temp = XGI_SearchModeID(ModeNo, &ModeIdIndex, XGI_Pr);
213 if (!temp)
214 return 0;
215
216 RefreshRateTableIndex = XGI_Pr->EModeIDTable[ModeIdIndex].REFindex;
217 RefreshRateTableIndex += (rateindex - 1);
218 */
219 index = XGI_Pr->RefIndex[RefreshRateTableIndex].Ext_CRT1CRTC;
220
221 sr_data = XGI_Pr->XGINEWUB_CRT1Table[index].CR[5];
222
223 cr_data = XGI_Pr->XGINEWUB_CRT1Table[index].CR[0];
224
225 /* Horizontal total */
226 HT = (cr_data & 0xff) | ((unsigned short) (sr_data & 0x03) << 8);
227 A = HT + 5;
228
229 /*
230 cr_data = XGI_Pr->XGINEWUB_CRT1Table[index].CR[1];
231
232 Horizontal display enable end
233 HDE = (cr_data & 0xff) | ((unsigned short) (sr_data & 0x0C) << 6);
234 */
235 HDE = (XGI_Pr->RefIndex[RefreshRateTableIndex].XRes >> 3) - 1;
236 E = HDE + 1;
237
238 cr_data = XGI_Pr->XGINEWUB_CRT1Table[index].CR[3];
239
240 /* Horizontal retrace (=sync) start */
241 HRS = (cr_data & 0xff) | ((unsigned short) (sr_data & 0xC0) << 2);
242 F = HRS - E - 3;
243
244 cr_data = XGI_Pr->XGINEWUB_CRT1Table[index].CR[1];
245
246 /* Horizontal blank start */
247 HBS = (cr_data & 0xff) | ((unsigned short) (sr_data & 0x30) << 4);
248
249 sr_data = XGI_Pr->XGINEWUB_CRT1Table[index].CR[6];
250
251 cr_data = XGI_Pr->XGINEWUB_CRT1Table[index].CR[2];
252
253 cr_data2 = XGI_Pr->XGINEWUB_CRT1Table[index].CR[4];
254
255 /* Horizontal blank end */
256 HBE = (cr_data & 0x1f) | ((unsigned short) (cr_data2 & 0x80) >> 2)
257 | ((unsigned short) (sr_data & 0x03) << 6);
258
259 /* Horizontal retrace (=sync) end */
260 HRE = (cr_data2 & 0x1f) | ((sr_data & 0x04) << 3);
261
262 temp = HBE - ((E - 1) & 255);
263 B = (temp > 0) ? temp : (temp + 256);
264
265 temp = HRE - ((E + F + 3) & 63);
266 C = (temp > 0) ? temp : (temp + 64);
267
268 D = B - F - C;
269
270 *left_margin = D * 8;
271 *right_margin = F * 8;
272 *hsync_len = C * 8;
273
274 sr_data = XGI_Pr->XGINEWUB_CRT1Table[index].CR[14];
275
276 cr_data = XGI_Pr->XGINEWUB_CRT1Table[index].CR[8];
277
278 cr_data2 = XGI_Pr->XGINEWUB_CRT1Table[index].CR[9];
279
280 /* Vertical total */
281 VT = (cr_data & 0xFF) | ((unsigned short) (cr_data2 & 0x01) << 8)
282 | ((unsigned short) (cr_data2 & 0x20) << 4)
283 | ((unsigned short) (sr_data & 0x01) << 10);
284 A = VT + 2;
285
286 /* cr_data = XGI_Pr->XGINEWUB_CRT1Table[index].CR[10]; */
287
288 /* Vertical display enable end */
289 /*
290 VDE = (cr_data & 0xff) |
291 ((unsigned short) (cr_data2 & 0x02) << 7) |
292 ((unsigned short) (cr_data2 & 0x40) << 3) |
293 ((unsigned short) (sr_data & 0x02) << 9);
294 */
295 VDE = XGI_Pr->RefIndex[RefreshRateTableIndex].YRes - 1;
296 E = VDE + 1;
297
298 cr_data = XGI_Pr->XGINEWUB_CRT1Table[index].CR[10];
299
300 /* Vertical retrace (=sync) start */
301 VRS = (cr_data & 0xff) | ((unsigned short) (cr_data2 & 0x04) << 6)
302 | ((unsigned short) (cr_data2 & 0x80) << 2)
303 | ((unsigned short) (sr_data & 0x08) << 7);
304 F = VRS + 1 - E;
305
306 cr_data = XGI_Pr->XGINEWUB_CRT1Table[index].CR[12];
307
308 cr_data3 = (XGI_Pr->XGINEWUB_CRT1Table[index].CR[14] & 0x80) << 5;
309
310 /* Vertical blank start */
311 VBS = (cr_data & 0xff) | ((unsigned short) (cr_data2 & 0x08) << 5)
312 | ((unsigned short) (cr_data3 & 0x20) << 4)
313 | ((unsigned short) (sr_data & 0x04) << 8);
314
315 cr_data = XGI_Pr->XGINEWUB_CRT1Table[index].CR[13];
316
317 /* Vertical blank end */
318 VBE = (cr_data & 0xff) | ((unsigned short) (sr_data & 0x10) << 4);
319 temp = VBE - ((E - 1) & 511);
320 B = (temp > 0) ? temp : (temp + 512);
321
322 cr_data = XGI_Pr->XGINEWUB_CRT1Table[index].CR[11];
323
324 /* Vertical retrace (=sync) end */
325 VRE = (cr_data & 0x0f) | ((sr_data & 0x20) >> 1);
326 temp = VRE - ((E + F - 1) & 31);
327 C = (temp > 0) ? temp : (temp + 32);
328
329 D = B - F - C;
330
331 *upper_margin = D;
332 *lower_margin = F;
333 *vsync_len = C;
334
335 if (XGI_Pr->RefIndex[RefreshRateTableIndex].Ext_InfoFlag & 0x8000)
336 *sync &= ~FB_SYNC_VERT_HIGH_ACT;
337 else
338 *sync |= FB_SYNC_VERT_HIGH_ACT;
339
340 if (XGI_Pr->RefIndex[RefreshRateTableIndex].Ext_InfoFlag & 0x4000)
341 *sync &= ~FB_SYNC_HOR_HIGH_ACT;
342 else
343 *sync |= FB_SYNC_HOR_HIGH_ACT;
344
345 *vmode = FB_VMODE_NONINTERLACED;
346 if (XGI_Pr->RefIndex[RefreshRateTableIndex].Ext_InfoFlag & 0x0080)
347 *vmode = FB_VMODE_INTERLACED;
348 else {
349 j = 0;
350 while (XGI_Pr->EModeIDTable[j].Ext_ModeID != 0xff) {
351 if (XGI_Pr->EModeIDTable[j].Ext_ModeID ==
352 XGI_Pr->RefIndex[RefreshRateTableIndex].ModeID) {
353 if (XGI_Pr->EModeIDTable[j].Ext_ModeFlag &
354 DoubleScanMode) {
355 *vmode = FB_VMODE_DOUBLE;
356 }
357 break;
358 }
359 j++;
360 }
361 }
362
363 return 1;
364 }
365
366 static void XGIRegInit(struct vb_device_info *XGI_Pr, unsigned long BaseAddr)
367 {
368 XGI_Pr->RelIO = BaseAddr;
369 XGI_Pr->P3c4 = BaseAddr + 0x14;
370 XGI_Pr->P3d4 = BaseAddr + 0x24;
371 XGI_Pr->P3c0 = BaseAddr + 0x10;
372 XGI_Pr->P3ce = BaseAddr + 0x1e;
373 XGI_Pr->P3c2 = BaseAddr + 0x12;
374 XGI_Pr->P3ca = BaseAddr + 0x1a;
375 XGI_Pr->P3c6 = BaseAddr + 0x16;
376 XGI_Pr->P3c7 = BaseAddr + 0x17;
377 XGI_Pr->P3c8 = BaseAddr + 0x18;
378 XGI_Pr->P3c9 = BaseAddr + 0x19;
379 XGI_Pr->P3da = BaseAddr + 0x2A;
380 /* Digital video interface registers (LCD) */
381 XGI_Pr->Part1Port = BaseAddr + XGI_CRT2_PORT_04;
382 /* 301 TV Encoder registers */
383 XGI_Pr->Part2Port = BaseAddr + XGI_CRT2_PORT_10;
384 /* 301 Macrovision registers */
385 XGI_Pr->Part3Port = BaseAddr + XGI_CRT2_PORT_12;
386 /* 301 VGA2 (and LCD) registers */
387 XGI_Pr->Part4Port = BaseAddr + XGI_CRT2_PORT_14;
388 /* 301 palette address port registers */
389 XGI_Pr->Part5Port = BaseAddr + XGI_CRT2_PORT_14 + 2;
390
391 }
392
393 /* ------------ Interface for init & mode switching code ------------- */
394
395 static unsigned char XGIfb_query_VGA_config_space(
396 struct xgi_hw_device_info *pXGIhw_ext, unsigned long offset,
397 unsigned long set, unsigned long *value)
398 {
399 static struct pci_dev *pdev = NULL;
400 static unsigned char init = 0, valid_pdev = 0;
401
402 if (!set)
403 DPRINTK("XGIfb: Get VGA offset 0x%lx\n", offset);
404 else
405 DPRINTK("XGIfb: Set offset 0x%lx to 0x%lx\n", offset, *value);
406
407 if (!init) {
408 init = 1;
409 pdev = pci_get_device(PCI_VENDOR_ID_XG, xgi_video_info.chip_id,
410 pdev);
411 if (pdev) {
412 valid_pdev = 1;
413 pci_dev_put(pdev);
414 }
415 }
416
417 if (!valid_pdev) {
418 printk(KERN_DEBUG "XGIfb: Can't find XGI %d VGA device.\n",
419 xgi_video_info.chip_id);
420 return 0;
421 }
422
423 if (set == 0)
424 pci_read_config_dword(pdev, offset, (u32 *) value);
425 else
426 pci_write_config_dword(pdev, offset, (u32)(*value));
427
428 return 1;
429 }
430
431 /* ------------------ Internal helper routines ----------------- */
432
433 static int XGIfb_GetXG21DefaultLVDSModeIdx(void)
434 {
435
436 int found_mode = 0;
437 int XGIfb_mode_idx = 0;
438
439 found_mode = 0;
440 while ((XGIbios_mode[XGIfb_mode_idx].mode_no != 0)
441 && (XGIbios_mode[XGIfb_mode_idx].xres
442 <= XGI21_LCDCapList[0].LVDSHDE)) {
443 if ((XGIbios_mode[XGIfb_mode_idx].xres
444 == XGI21_LCDCapList[0].LVDSHDE)
445 && (XGIbios_mode[XGIfb_mode_idx].yres
446 == XGI21_LCDCapList[0].LVDSVDE)
447 && (XGIbios_mode[XGIfb_mode_idx].bpp == 8)) {
448 XGIfb_mode_no = XGIbios_mode[XGIfb_mode_idx].mode_no;
449 found_mode = 1;
450 break;
451 }
452 XGIfb_mode_idx++;
453 }
454 if (!found_mode)
455 XGIfb_mode_idx = 0;
456
457 return XGIfb_mode_idx;
458 }
459
460 static void XGIfb_search_mode(const char *name)
461 {
462 int i = 0, j = 0, l;
463
464 if (name == NULL) {
465 printk(KERN_ERR "XGIfb: Internal error, using default mode.\n");
466 xgifb_mode_idx = DEFAULT_MODE;
467 if ((xgi_video_info.chip == XG21)
468 && ((xgi_video_info.disp_state & DISPTYPE_DISP2)
469 == DISPTYPE_LCD)) {
470 xgifb_mode_idx = XGIfb_GetXG21DefaultLVDSModeIdx();
471 }
472 return;
473 }
474
475 if (!strcmp(name, XGIbios_mode[MODE_INDEX_NONE].name)) {
476 printk(KERN_ERR "XGIfb: Mode 'none' not supported anymore. Using default.\n");
477 xgifb_mode_idx = DEFAULT_MODE;
478 if ((xgi_video_info.chip == XG21)
479 && ((xgi_video_info.disp_state & DISPTYPE_DISP2)
480 == DISPTYPE_LCD)) {
481 xgifb_mode_idx = XGIfb_GetXG21DefaultLVDSModeIdx();
482 }
483 return;
484 }
485
486 while (XGIbios_mode[i].mode_no != 0) {
487 l = min(strlen(name), strlen(XGIbios_mode[i].name));
488 if (!strncmp(name, XGIbios_mode[i].name, l)) {
489 xgifb_mode_idx = i;
490 j = 1;
491 break;
492 }
493 i++;
494 }
495 if (!j)
496 printk(KERN_INFO "XGIfb: Invalid mode '%s'\n", name);
497 }
498
499 static void XGIfb_search_vesamode(unsigned int vesamode)
500 {
501 int i = 0, j = 0;
502
503 if (vesamode == 0) {
504
505 printk(KERN_ERR "XGIfb: Mode 'none' not supported anymore. Using default.\n");
506 xgifb_mode_idx = DEFAULT_MODE;
507 if ((xgi_video_info.chip == XG21)
508 && ((xgi_video_info.disp_state & DISPTYPE_DISP2)
509 == DISPTYPE_LCD)) {
510 xgifb_mode_idx = XGIfb_GetXG21DefaultLVDSModeIdx();
511 }
512 return;
513 }
514
515 vesamode &= 0x1dff; /* Clean VESA mode number from other flags */
516
517 while (XGIbios_mode[i].mode_no != 0) {
518 if ((XGIbios_mode[i].vesa_mode_no_1 == vesamode) ||
519 (XGIbios_mode[i].vesa_mode_no_2 == vesamode)) {
520 xgifb_mode_idx = i;
521 j = 1;
522 break;
523 }
524 i++;
525 }
526 if (!j)
527 printk(KERN_INFO "XGIfb: Invalid VESA mode 0x%x'\n", vesamode);
528 }
529
530 static int XGIfb_GetXG21LVDSData(void)
531 {
532 u8 tmp;
533 unsigned char *pData;
534 int i, j, k;
535
536 tmp = xgifb_reg_get(XGISR, 0x1e);
537 xgifb_reg_set(XGISR, 0x1e, tmp | 4);
538
539 pData = xgi_video_info.mmio_vbase + 0x20000;
540 if ((pData[0x0] == 0x55) &&
541 (pData[0x1] == 0xAA) &&
542 (pData[0x65] & 0x1)) {
543 i = pData[0x316] | (pData[0x317] << 8);
544 j = pData[i - 1];
545 if (j == 0xff)
546 j = 1;
547
548 k = 0;
549 do {
550 XGI21_LCDCapList[k].LVDS_Capability = pData[i]
551 | (pData[i + 1] << 8);
552 XGI21_LCDCapList[k].LVDSHT = pData[i + 2] | (pData[i
553 + 3] << 8);
554 XGI21_LCDCapList[k].LVDSVT = pData[i + 4] | (pData[i
555 + 5] << 8);
556 XGI21_LCDCapList[k].LVDSHDE = pData[i + 6] | (pData[i
557 + 7] << 8);
558 XGI21_LCDCapList[k].LVDSVDE = pData[i + 8] | (pData[i
559 + 9] << 8);
560 XGI21_LCDCapList[k].LVDSHFP = pData[i + 10] | (pData[i
561 + 11] << 8);
562 XGI21_LCDCapList[k].LVDSVFP = pData[i + 12] | (pData[i
563 + 13] << 8);
564 XGI21_LCDCapList[k].LVDSHSYNC = pData[i + 14]
565 | (pData[i + 15] << 8);
566 XGI21_LCDCapList[k].LVDSVSYNC = pData[i + 16]
567 | (pData[i + 17] << 8);
568 XGI21_LCDCapList[k].VCLKData1 = pData[i + 18];
569 XGI21_LCDCapList[k].VCLKData2 = pData[i + 19];
570 XGI21_LCDCapList[k].PSC_S1 = pData[i + 20];
571 XGI21_LCDCapList[k].PSC_S2 = pData[i + 21];
572 XGI21_LCDCapList[k].PSC_S3 = pData[i + 22];
573 XGI21_LCDCapList[k].PSC_S4 = pData[i + 23];
574 XGI21_LCDCapList[k].PSC_S5 = pData[i + 24];
575 i += 25;
576 j--;
577 k++;
578 } while ((j > 0) && (k < (sizeof(XGI21_LCDCapList)
579 / sizeof(struct XGI21_LVDSCapStruct))));
580 return 1;
581 }
582 return 0;
583 }
584
585 static int XGIfb_validate_mode(int myindex)
586 {
587 u16 xres, yres;
588
589 if (xgi_video_info.chip == XG21) {
590 if ((xgi_video_info.disp_state & DISPTYPE_DISP2)
591 == DISPTYPE_LCD) {
592 xres = XGI21_LCDCapList[0].LVDSHDE;
593 yres = XGI21_LCDCapList[0].LVDSVDE;
594 if (XGIbios_mode[myindex].xres > xres)
595 return -1;
596 if (XGIbios_mode[myindex].yres > yres)
597 return -1;
598 if ((XGIbios_mode[myindex].xres < xres) &&
599 (XGIbios_mode[myindex].yres < yres)) {
600 if (XGIbios_mode[myindex].bpp > 8)
601 return -1;
602 }
603
604 }
605 return myindex;
606
607 }
608
609 /* FIXME: for now, all is valid on XG27 */
610 if (xgi_video_info.chip == XG27)
611 return myindex;
612
613 if (!(XGIbios_mode[myindex].chipset & MD_XGI315))
614 return -1;
615
616 switch (xgi_video_info.disp_state & DISPTYPE_DISP2) {
617 case DISPTYPE_LCD:
618 switch (XGIhw_ext.ulCRT2LCDType) {
619 case LCD_640x480:
620 xres = 640;
621 yres = 480;
622 break;
623 case LCD_800x600:
624 xres = 800;
625 yres = 600;
626 break;
627 case LCD_1024x600:
628 xres = 1024;
629 yres = 600;
630 break;
631 case LCD_1024x768:
632 xres = 1024;
633 yres = 768;
634 break;
635 case LCD_1152x768:
636 xres = 1152;
637 yres = 768;
638 break;
639 case LCD_1280x960:
640 xres = 1280;
641 yres = 960;
642 break;
643 case LCD_1280x768:
644 xres = 1280;
645 yres = 768;
646 break;
647 case LCD_1280x1024:
648 xres = 1280;
649 yres = 1024;
650 break;
651 case LCD_1400x1050:
652 xres = 1400;
653 yres = 1050;
654 break;
655 case LCD_1600x1200:
656 xres = 1600;
657 yres = 1200;
658 break;
659 /* case LCD_320x480: */ /* TW: FSTN */
660 /*
661 xres = 320;
662 yres = 480;
663 break;
664 */
665 default:
666 xres = 0;
667 yres = 0;
668 break;
669 }
670 if (XGIbios_mode[myindex].xres > xres)
671 return -1;
672 if (XGIbios_mode[myindex].yres > yres)
673 return -1;
674 if ((XGIhw_ext.ulExternalChip == 0x01) || /* LVDS */
675 (XGIhw_ext.ulExternalChip == 0x05)) { /* LVDS+Chrontel */
676 switch (XGIbios_mode[myindex].xres) {
677 case 512:
678 if (XGIbios_mode[myindex].yres != 512)
679 return -1;
680 if (XGIhw_ext.ulCRT2LCDType == LCD_1024x600)
681 return -1;
682 break;
683 case 640:
684 if ((XGIbios_mode[myindex].yres != 400)
685 && (XGIbios_mode[myindex].yres
686 != 480))
687 return -1;
688 break;
689 case 800:
690 if (XGIbios_mode[myindex].yres != 600)
691 return -1;
692 break;
693 case 1024:
694 if ((XGIbios_mode[myindex].yres != 600) &&
695 (XGIbios_mode[myindex].yres != 768))
696 return -1;
697 if ((XGIbios_mode[myindex].yres == 600) &&
698 (XGIhw_ext.ulCRT2LCDType != LCD_1024x600))
699 return -1;
700 break;
701 case 1152:
702 if ((XGIbios_mode[myindex].yres) != 768)
703 return -1;
704 if (XGIhw_ext.ulCRT2LCDType != LCD_1152x768)
705 return -1;
706 break;
707 case 1280:
708 if ((XGIbios_mode[myindex].yres != 768) &&
709 (XGIbios_mode[myindex].yres != 1024))
710 return -1;
711 if ((XGIbios_mode[myindex].yres == 768) &&
712 (XGIhw_ext.ulCRT2LCDType != LCD_1280x768))
713 return -1;
714 break;
715 case 1400:
716 if (XGIbios_mode[myindex].yres != 1050)
717 return -1;
718 break;
719 case 1600:
720 if (XGIbios_mode[myindex].yres != 1200)
721 return -1;
722 break;
723 default:
724 return -1;
725 }
726 } else {
727 switch (XGIbios_mode[myindex].xres) {
728 case 512:
729 if (XGIbios_mode[myindex].yres != 512)
730 return -1;
731 break;
732 case 640:
733 if ((XGIbios_mode[myindex].yres != 400) &&
734 (XGIbios_mode[myindex].yres != 480))
735 return -1;
736 break;
737 case 800:
738 if (XGIbios_mode[myindex].yres != 600)
739 return -1;
740 break;
741 case 1024:
742 if (XGIbios_mode[myindex].yres != 768)
743 return -1;
744 break;
745 case 1280:
746 if ((XGIbios_mode[myindex].yres != 960) &&
747 (XGIbios_mode[myindex].yres != 1024))
748 return -1;
749 if (XGIbios_mode[myindex].yres == 960) {
750 if (XGIhw_ext.ulCRT2LCDType ==
751 LCD_1400x1050)
752 return -1;
753 }
754 break;
755 case 1400:
756 if (XGIbios_mode[myindex].yres != 1050)
757 return -1;
758 break;
759 case 1600:
760 if (XGIbios_mode[myindex].yres != 1200)
761 return -1;
762 break;
763 default:
764 return -1;
765 }
766 }
767 break;
768 case DISPTYPE_TV:
769 switch (XGIbios_mode[myindex].xres) {
770 case 512:
771 case 640:
772 case 800:
773 break;
774 case 720:
775 if (xgi_video_info.TV_type == TVMODE_NTSC) {
776 if (XGIbios_mode[myindex].yres != 480)
777 return -1;
778 } else if (xgi_video_info.TV_type == TVMODE_PAL) {
779 if (XGIbios_mode[myindex].yres != 576)
780 return -1;
781 }
782 /* TW: LVDS/CHRONTEL does not support 720 */
783 if (xgi_video_info.hasVB == HASVB_LVDS_CHRONTEL ||
784 xgi_video_info.hasVB == HASVB_CHRONTEL) {
785 return -1;
786 }
787 break;
788 case 1024:
789 if (xgi_video_info.TV_type == TVMODE_NTSC) {
790 if (XGIbios_mode[myindex].bpp == 32)
791 return -1;
792 }
793 break;
794 default:
795 return -1;
796 }
797 break;
798 case DISPTYPE_CRT2:
799 if (XGIbios_mode[myindex].xres > 1280)
800 return -1;
801 break;
802 }
803 return myindex;
804
805 }
806
807 static void XGIfb_search_crt2type(const char *name)
808 {
809 int i = 0;
810
811 if (name == NULL)
812 return;
813
814 while (XGI_crt2type[i].type_no != -1) {
815 if (!strcmp(name, XGI_crt2type[i].name)) {
816 XGIfb_crt2type = XGI_crt2type[i].type_no;
817 XGIfb_tvplug = XGI_crt2type[i].tvplug_no;
818 break;
819 }
820 i++;
821 }
822 if (XGIfb_crt2type < 0)
823 printk(KERN_INFO "XGIfb: Invalid CRT2 type: %s\n", name);
824 }
825
826 static u8 XGIfb_search_refresh_rate(unsigned int rate)
827 {
828 u16 xres, yres;
829 int i = 0;
830
831 xres = XGIbios_mode[xgifb_mode_idx].xres;
832 yres = XGIbios_mode[xgifb_mode_idx].yres;
833
834 XGIfb_rate_idx = 0;
835 while ((XGIfb_vrate[i].idx != 0) && (XGIfb_vrate[i].xres <= xres)) {
836 if ((XGIfb_vrate[i].xres == xres) &&
837 (XGIfb_vrate[i].yres == yres)) {
838 if (XGIfb_vrate[i].refresh == rate) {
839 XGIfb_rate_idx = XGIfb_vrate[i].idx;
840 break;
841 } else if (XGIfb_vrate[i].refresh > rate) {
842 if ((XGIfb_vrate[i].refresh - rate) <= 3) {
843 DPRINTK("XGIfb: Adjusting rate from %d up to %d\n",
844 rate, XGIfb_vrate[i].refresh);
845 XGIfb_rate_idx = XGIfb_vrate[i].idx;
846 xgi_video_info.refresh_rate =
847 XGIfb_vrate[i].refresh;
848 } else if (((rate - XGIfb_vrate[i - 1].refresh)
849 <= 2) && (XGIfb_vrate[i].idx
850 != 1)) {
851 DPRINTK("XGIfb: Adjusting rate from %d down to %d\n",
852 rate, XGIfb_vrate[i-1].refresh);
853 XGIfb_rate_idx = XGIfb_vrate[i - 1].idx;
854 xgi_video_info.refresh_rate =
855 XGIfb_vrate[i - 1].refresh;
856 }
857 break;
858 } else if ((rate - XGIfb_vrate[i].refresh) <= 2) {
859 DPRINTK("XGIfb: Adjusting rate from %d down to %d\n",
860 rate, XGIfb_vrate[i].refresh);
861 XGIfb_rate_idx = XGIfb_vrate[i].idx;
862 break;
863 }
864 }
865 i++;
866 }
867 if (XGIfb_rate_idx > 0) {
868 return XGIfb_rate_idx;
869 } else {
870 printk(KERN_INFO "XGIfb: Unsupported rate %d for %dx%d\n",
871 rate, xres, yres);
872 return 0;
873 }
874 }
875
876 static void XGIfb_search_tvstd(const char *name)
877 {
878 int i = 0;
879
880 if (name == NULL)
881 return;
882
883 while (XGI_tvtype[i].type_no != -1) {
884 if (!strcmp(name, XGI_tvtype[i].name)) {
885 XGIfb_tvmode = XGI_tvtype[i].type_no;
886 break;
887 }
888 i++;
889 }
890 }
891
892 /* ----------- FBDev related routines for all series ----------- */
893
894 static void XGIfb_bpp_to_var(struct fb_var_screeninfo *var)
895 {
896 switch (var->bits_per_pixel) {
897 case 8:
898 var->red.offset = var->green.offset = var->blue.offset = 0;
899 var->red.length = var->green.length = var->blue.length = 6;
900 xgi_video_info.video_cmap_len = 256;
901 break;
902 case 16:
903 var->red.offset = 11;
904 var->red.length = 5;
905 var->green.offset = 5;
906 var->green.length = 6;
907 var->blue.offset = 0;
908 var->blue.length = 5;
909 var->transp.offset = 0;
910 var->transp.length = 0;
911 xgi_video_info.video_cmap_len = 16;
912 break;
913 case 32:
914 var->red.offset = 16;
915 var->red.length = 8;
916 var->green.offset = 8;
917 var->green.length = 8;
918 var->blue.offset = 0;
919 var->blue.length = 8;
920 var->transp.offset = 24;
921 var->transp.length = 8;
922 xgi_video_info.video_cmap_len = 16;
923 break;
924 }
925 }
926
927 /* --------------------- SetMode routines ------------------------- */
928
929 static void XGIfb_pre_setmode(void)
930 {
931 u8 cr30 = 0, cr31 = 0;
932
933 cr31 = xgifb_reg_get(XGICR, 0x31);
934 cr31 &= ~0x60;
935
936 switch (xgi_video_info.disp_state & DISPTYPE_DISP2) {
937 case DISPTYPE_CRT2:
938 cr30 = (XGI_VB_OUTPUT_CRT2 | XGI_SIMULTANEOUS_VIEW_ENABLE);
939 cr31 |= XGI_DRIVER_MODE;
940 break;
941 case DISPTYPE_LCD:
942 cr30 = (XGI_VB_OUTPUT_LCD | XGI_SIMULTANEOUS_VIEW_ENABLE);
943 cr31 |= XGI_DRIVER_MODE;
944 break;
945 case DISPTYPE_TV:
946 if (xgi_video_info.TV_type == TVMODE_HIVISION)
947 cr30 = (XGI_VB_OUTPUT_HIVISION
948 | XGI_SIMULTANEOUS_VIEW_ENABLE);
949 else if (xgi_video_info.TV_plug == TVPLUG_SVIDEO)
950 cr30 = (XGI_VB_OUTPUT_SVIDEO
951 | XGI_SIMULTANEOUS_VIEW_ENABLE);
952 else if (xgi_video_info.TV_plug == TVPLUG_COMPOSITE)
953 cr30 = (XGI_VB_OUTPUT_COMPOSITE
954 | XGI_SIMULTANEOUS_VIEW_ENABLE);
955 else if (xgi_video_info.TV_plug == TVPLUG_SCART)
956 cr30 = (XGI_VB_OUTPUT_SCART
957 | XGI_SIMULTANEOUS_VIEW_ENABLE);
958 cr31 |= XGI_DRIVER_MODE;
959
960 if (XGIfb_tvmode == 1 || xgi_video_info.TV_type == TVMODE_PAL)
961 cr31 |= 0x01;
962 else
963 cr31 &= ~0x01;
964 break;
965 default: /* disable CRT2 */
966 cr30 = 0x00;
967 cr31 |= (XGI_DRIVER_MODE | XGI_VB_OUTPUT_DISABLE);
968 }
969
970 xgifb_reg_set(XGICR, IND_XGI_SCRATCH_REG_CR30, cr30);
971 xgifb_reg_set(XGICR, IND_XGI_SCRATCH_REG_CR31, cr31);
972 xgifb_reg_set(XGICR, IND_XGI_SCRATCH_REG_CR33, (XGIfb_rate_idx & 0x0F));
973 }
974
975 static void XGIfb_post_setmode(void)
976 {
977 u8 reg;
978 unsigned char doit = 1;
979 /*
980 xgifb_reg_set(XGISR,IND_XGI_PASSWORD,XGI_PASSWORD);
981 xgifb_reg_set(XGICR, 0x13, 0x00);
982 xgifb_reg_and_or(XGISR,0x0E, 0xF0, 0x01);
983 *test*
984 */
985 if (xgi_video_info.video_bpp == 8) {
986 /* TW: We can't switch off CRT1 on LVDS/Chrontel
987 * in 8bpp Modes */
988 if ((xgi_video_info.hasVB == HASVB_LVDS) ||
989 (xgi_video_info.hasVB == HASVB_LVDS_CHRONTEL)) {
990 doit = 0;
991 }
992 /* TW: We can't switch off CRT1 on 301B-DH
993 * in 8bpp Modes if using LCD */
994 if (xgi_video_info.disp_state & DISPTYPE_LCD)
995 doit = 0;
996 }
997
998 /* TW: We can't switch off CRT1 if bridge is in slave mode */
999 if (xgi_video_info.hasVB != HASVB_NONE) {
1000 reg = xgifb_reg_get(XGIPART1, 0x00);
1001
1002 if ((reg & 0x50) == 0x10)
1003 doit = 0;
1004
1005 } else {
1006 XGIfb_crt1off = 0;
1007 }
1008
1009 reg = xgifb_reg_get(XGICR, 0x17);
1010 if ((XGIfb_crt1off) && (doit))
1011 reg &= ~0x80;
1012 else
1013 reg |= 0x80;
1014 xgifb_reg_set(XGICR, 0x17, reg);
1015
1016 xgifb_reg_and(XGISR, IND_XGI_RAMDAC_CONTROL, ~0x04);
1017
1018 if ((xgi_video_info.disp_state & DISPTYPE_TV) && (xgi_video_info.hasVB
1019 == HASVB_301)) {
1020
1021 reg = xgifb_reg_get(XGIPART4, 0x01);
1022
1023 if (reg < 0xB0) { /* Set filter for XGI301 */
1024 switch (xgi_video_info.video_width) {
1025 case 320:
1026 filter_tb = (xgi_video_info.TV_type ==
1027 TVMODE_NTSC) ? 4 : 12;
1028 break;
1029 case 640:
1030 filter_tb = (xgi_video_info.TV_type ==
1031 TVMODE_NTSC) ? 5 : 13;
1032 break;
1033 case 720:
1034 filter_tb = (xgi_video_info.TV_type ==
1035 TVMODE_NTSC) ? 6 : 14;
1036 break;
1037 case 800:
1038 filter_tb = (xgi_video_info.TV_type ==
1039 TVMODE_NTSC) ? 7 : 15;
1040 break;
1041 default:
1042 filter = -1;
1043 break;
1044 }
1045 xgifb_reg_or(XGIPART1, XGIfb_CRT2_write_enable, 0x01);
1046
1047 if (xgi_video_info.TV_type == TVMODE_NTSC) {
1048
1049 xgifb_reg_and(XGIPART2, 0x3a, 0x1f);
1050
1051 if (xgi_video_info.TV_plug == TVPLUG_SVIDEO) {
1052
1053 xgifb_reg_and(XGIPART2, 0x30, 0xdf);
1054
1055 } else if (xgi_video_info.TV_plug
1056 == TVPLUG_COMPOSITE) {
1057
1058 xgifb_reg_or(XGIPART2, 0x30, 0x20);
1059
1060 switch (xgi_video_info.video_width) {
1061 case 640:
1062 xgifb_reg_set(XGIPART2,
1063 0x35,
1064 0xEB);
1065 xgifb_reg_set(XGIPART2,
1066 0x36,
1067 0x04);
1068 xgifb_reg_set(XGIPART2,
1069 0x37,
1070 0x25);
1071 xgifb_reg_set(XGIPART2,
1072 0x38,
1073 0x18);
1074 break;
1075 case 720:
1076 xgifb_reg_set(XGIPART2,
1077 0x35,
1078 0xEE);
1079 xgifb_reg_set(XGIPART2,
1080 0x36,
1081 0x0C);
1082 xgifb_reg_set(XGIPART2,
1083 0x37,
1084 0x22);
1085 xgifb_reg_set(XGIPART2,
1086 0x38,
1087 0x08);
1088 break;
1089 case 800:
1090 xgifb_reg_set(XGIPART2,
1091 0x35,
1092 0xEB);
1093 xgifb_reg_set(XGIPART2,
1094 0x36,
1095 0x15);
1096 xgifb_reg_set(XGIPART2,
1097 0x37,
1098 0x25);
1099 xgifb_reg_set(XGIPART2,
1100 0x38,
1101 0xF6);
1102 break;
1103 }
1104 }
1105
1106 } else if (xgi_video_info.TV_type == TVMODE_PAL) {
1107
1108 xgifb_reg_and(XGIPART2, 0x3A, 0x1F);
1109
1110 if (xgi_video_info.TV_plug == TVPLUG_SVIDEO) {
1111
1112 xgifb_reg_and(XGIPART2, 0x30, 0xDF);
1113
1114 } else if (xgi_video_info.TV_plug
1115 == TVPLUG_COMPOSITE) {
1116
1117 xgifb_reg_or(XGIPART2, 0x30, 0x20);
1118
1119 switch (xgi_video_info.video_width) {
1120 case 640:
1121 xgifb_reg_set(XGIPART2,
1122 0x35,
1123 0xF1);
1124 xgifb_reg_set(XGIPART2,
1125 0x36,
1126 0xF7);
1127 xgifb_reg_set(XGIPART2,
1128 0x37,
1129 0x1F);
1130 xgifb_reg_set(XGIPART2,
1131 0x38,
1132 0x32);
1133 break;
1134 case 720:
1135 xgifb_reg_set(XGIPART2,
1136 0x35,
1137 0xF3);
1138 xgifb_reg_set(XGIPART2,
1139 0x36,
1140 0x00);
1141 xgifb_reg_set(XGIPART2,
1142 0x37,
1143 0x1D);
1144 xgifb_reg_set(XGIPART2,
1145 0x38,
1146 0x20);
1147 break;
1148 case 800:
1149 xgifb_reg_set(XGIPART2,
1150 0x35,
1151 0xFC);
1152 xgifb_reg_set(XGIPART2,
1153 0x36,
1154 0xFB);
1155 xgifb_reg_set(XGIPART2,
1156 0x37,
1157 0x14);
1158 xgifb_reg_set(XGIPART2,
1159 0x38,
1160 0x2A);
1161 break;
1162 }
1163 }
1164 }
1165
1166 if ((filter >= 0) && (filter <= 7)) {
1167 DPRINTK("FilterTable[%d]-%d: %02x %02x %02x %02x\n",
1168 filter_tb, filter,
1169 XGI_TV_filter[filter_tb].
1170 filter[filter][0],
1171 XGI_TV_filter[filter_tb].
1172 filter[filter][1],
1173 XGI_TV_filter[filter_tb].
1174 filter[filter][2],
1175 XGI_TV_filter[filter_tb].
1176 filter[filter][3]
1177 );
1178 xgifb_reg_set(
1179 XGIPART2,
1180 0x35,
1181 (XGI_TV_filter[filter_tb].
1182 filter[filter][0]));
1183 xgifb_reg_set(
1184 XGIPART2,
1185 0x36,
1186 (XGI_TV_filter[filter_tb].
1187 filter[filter][1]));
1188 xgifb_reg_set(
1189 XGIPART2,
1190 0x37,
1191 (XGI_TV_filter[filter_tb].
1192 filter[filter][2]));
1193 xgifb_reg_set(
1194 XGIPART2,
1195 0x38,
1196 (XGI_TV_filter[filter_tb].
1197 filter[filter][3]));
1198 }
1199 }
1200 }
1201 }
1202
1203 static int XGIfb_do_set_var(struct fb_var_screeninfo *var, int isactive,
1204 struct fb_info *info)
1205 {
1206
1207 unsigned int htotal = var->left_margin + var->xres + var->right_margin
1208 + var->hsync_len;
1209 unsigned int vtotal = var->upper_margin + var->yres + var->lower_margin
1210 + var->vsync_len;
1211 #if defined(__powerpc__)
1212 u8 sr_data, cr_data;
1213 #endif
1214 unsigned int drate = 0, hrate = 0;
1215 int found_mode = 0;
1216 int old_mode;
1217 /* unsigned char reg, reg1; */
1218
1219 DEBUGPRN("Inside do_set_var");
1220 /* printk(KERN_DEBUG "XGIfb:var->yres=%d, var->upper_margin=%d, var->lower_margin=%d, var->vsync_len=%d\n", var->yres, var->upper_margin, var->lower_margin, var->vsync_len); */
1221
1222 info->var.xres_virtual = var->xres_virtual;
1223 info->var.yres_virtual = var->yres_virtual;
1224 info->var.bits_per_pixel = var->bits_per_pixel;
1225
1226 if ((var->vmode & FB_VMODE_MASK) == FB_VMODE_NONINTERLACED)
1227 vtotal <<= 1;
1228 else if ((var->vmode & FB_VMODE_MASK) == FB_VMODE_DOUBLE)
1229 vtotal <<= 2;
1230 else if ((var->vmode & FB_VMODE_MASK) == FB_VMODE_INTERLACED) {
1231 /* vtotal <<= 1; */
1232 /* var->yres <<= 1; */
1233 }
1234
1235 if (!htotal || !vtotal) {
1236 DPRINTK("XGIfb: Invalid 'var' information\n");
1237 return -EINVAL;
1238 } printk(KERN_DEBUG "XGIfb: var->pixclock=%d, htotal=%d, vtotal=%d\n",
1239 var->pixclock, htotal, vtotal);
1240
1241 if (var->pixclock && htotal && vtotal) {
1242 drate = 1000000000 / var->pixclock;
1243 hrate = (drate * 1000) / htotal;
1244 xgi_video_info.refresh_rate = (unsigned int) (hrate * 2
1245 / vtotal);
1246 } else {
1247 xgi_video_info.refresh_rate = 60;
1248 }
1249
1250 printk(KERN_DEBUG "XGIfb: Change mode to %dx%dx%d-%dHz\n",
1251 var->xres,
1252 var->yres,
1253 var->bits_per_pixel,
1254 xgi_video_info.refresh_rate);
1255
1256 old_mode = xgifb_mode_idx;
1257 xgifb_mode_idx = 0;
1258
1259 while ((XGIbios_mode[xgifb_mode_idx].mode_no != 0)
1260 && (XGIbios_mode[xgifb_mode_idx].xres <= var->xres)) {
1261 if ((XGIbios_mode[xgifb_mode_idx].xres == var->xres)
1262 && (XGIbios_mode[xgifb_mode_idx].yres
1263 == var->yres)
1264 && (XGIbios_mode[xgifb_mode_idx].bpp
1265 == var->bits_per_pixel)) {
1266 XGIfb_mode_no = XGIbios_mode[xgifb_mode_idx].mode_no;
1267 found_mode = 1;
1268 break;
1269 }
1270 xgifb_mode_idx++;
1271 }
1272
1273 if (found_mode)
1274 xgifb_mode_idx = XGIfb_validate_mode(xgifb_mode_idx);
1275 else
1276 xgifb_mode_idx = -1;
1277
1278 if (xgifb_mode_idx < 0) {
1279 printk(KERN_ERR "XGIfb: Mode %dx%dx%d not supported\n",
1280 var->xres, var->yres, var->bits_per_pixel);
1281 xgifb_mode_idx = old_mode;
1282 return -EINVAL;
1283 }
1284
1285 if (XGIfb_search_refresh_rate(xgi_video_info.refresh_rate) == 0) {
1286 XGIfb_rate_idx = XGIbios_mode[xgifb_mode_idx].rate_idx;
1287 xgi_video_info.refresh_rate = 60;
1288 }
1289
1290 if (isactive) {
1291
1292 XGIfb_pre_setmode();
1293 if (XGISetModeNew(&XGIhw_ext, XGIfb_mode_no) == 0) {
1294 printk(KERN_ERR "XGIfb: Setting mode[0x%x] failed\n",
1295 XGIfb_mode_no);
1296 return -EINVAL;
1297 }
1298 info->fix.line_length = ((info->var.xres_virtual
1299 * info->var.bits_per_pixel) >> 6);
1300
1301 xgifb_reg_set(XGISR, IND_XGI_PASSWORD, XGI_PASSWORD);
1302
1303 xgifb_reg_set(XGICR, 0x13, (info->fix.line_length & 0x00ff));
1304 xgifb_reg_set(XGISR,
1305 0x0E,
1306 (info->fix.line_length & 0xff00) >> 8);
1307
1308 XGIfb_post_setmode();
1309
1310 DPRINTK("XGIfb: Set new mode: %dx%dx%d-%d\n",
1311 XGIbios_mode[xgifb_mode_idx].xres,
1312 XGIbios_mode[xgifb_mode_idx].yres,
1313 XGIbios_mode[xgifb_mode_idx].bpp,
1314 xgi_video_info.refresh_rate);
1315
1316 xgi_video_info.video_bpp = XGIbios_mode[xgifb_mode_idx].bpp;
1317 xgi_video_info.video_vwidth = info->var.xres_virtual;
1318 xgi_video_info.video_width = XGIbios_mode[xgifb_mode_idx].xres;
1319 xgi_video_info.video_vheight = info->var.yres_virtual;
1320 xgi_video_info.video_height = XGIbios_mode[xgifb_mode_idx].yres;
1321 xgi_video_info.org_x = xgi_video_info.org_y = 0;
1322 xgi_video_info.video_linelength = info->var.xres_virtual
1323 * (xgi_video_info.video_bpp >> 3);
1324 switch (xgi_video_info.video_bpp) {
1325 case 8:
1326 xgi_video_info.DstColor = 0x0000;
1327 xgi_video_info.XGI310_AccelDepth = 0x00000000;
1328 xgi_video_info.video_cmap_len = 256;
1329 #if defined(__powerpc__)
1330 cr_data = xgifb_reg_get(XGICR, 0x4D);
1331 xgifb_reg_set(XGICR, 0x4D, (cr_data & 0xE0));
1332 #endif
1333 break;
1334 case 16:
1335 xgi_video_info.DstColor = 0x8000;
1336 xgi_video_info.XGI310_AccelDepth = 0x00010000;
1337 #if defined(__powerpc__)
1338 cr_data = xgifb_reg_get(XGICR, 0x4D);
1339 xgifb_reg_set(XGICR, 0x4D, ((cr_data & 0xE0) | 0x0B));
1340 #endif
1341 xgi_video_info.video_cmap_len = 16;
1342 break;
1343 case 32:
1344 xgi_video_info.DstColor = 0xC000;
1345 xgi_video_info.XGI310_AccelDepth = 0x00020000;
1346 xgi_video_info.video_cmap_len = 16;
1347 #if defined(__powerpc__)
1348 cr_data = xgifb_reg_get(XGICR, 0x4D);
1349 xgifb_reg_set(XGICR, 0x4D, ((cr_data & 0xE0) | 0x15));
1350 #endif
1351 break;
1352 default:
1353 xgi_video_info.video_cmap_len = 16;
1354 printk(KERN_ERR "XGIfb: Unsupported depth %d",
1355 xgi_video_info.video_bpp);
1356 break;
1357 }
1358 }
1359 XGIfb_bpp_to_var(var); /*update ARGB info*/
1360 DEBUGPRN("End of do_set_var");
1361
1362 dumpVGAReg();
1363 return 0;
1364 }
1365
1366 #ifdef XGIFB_PAN
1367 static int XGIfb_pan_var(struct fb_var_screeninfo *var)
1368 {
1369 unsigned int base;
1370
1371 /* printk("Inside pan_var"); */
1372
1373 if (var->xoffset > (var->xres_virtual - var->xres)) {
1374 /* printk("Pan: xo: %d xv %d xr %d\n",
1375 var->xoffset, var->xres_virtual, var->xres); */
1376 return -EINVAL;
1377 }
1378 if (var->yoffset > (var->yres_virtual - var->yres)) {
1379 /* printk("Pan: yo: %d yv %d yr %d\n",
1380 var->yoffset, var->yres_virtual, var->yres); */
1381 return -EINVAL;
1382 }
1383 base = var->yoffset * var->xres_virtual + var->xoffset;
1384
1385 /* calculate base bpp dep. */
1386 switch (var->bits_per_pixel) {
1387 case 16:
1388 base >>= 1;
1389 break;
1390 case 32:
1391 break;
1392 case 8:
1393 default:
1394 base >>= 2;
1395 break;
1396 }
1397
1398 xgifb_reg_set(XGISR, IND_XGI_PASSWORD, XGI_PASSWORD);
1399
1400 xgifb_reg_set(XGICR, 0x0D, base & 0xFF);
1401 xgifb_reg_set(XGICR, 0x0C, (base >> 8) & 0xFF);
1402 xgifb_reg_set(XGISR, 0x0D, (base >> 16) & 0xFF);
1403 xgifb_reg_set(XGISR, 0x37, (base >> 24) & 0x03);
1404 xgifb_reg_and_or(XGISR, 0x37, 0xDF, (base >> 21) & 0x04);
1405
1406 if (xgi_video_info.disp_state & DISPTYPE_DISP2) {
1407 xgifb_reg_or(XGIPART1, XGIfb_CRT2_write_enable, 0x01);
1408 xgifb_reg_set(XGIPART1, 0x06, (base & 0xFF));
1409 xgifb_reg_set(XGIPART1, 0x05, ((base >> 8) & 0xFF));
1410 xgifb_reg_set(XGIPART1, 0x04, ((base >> 16) & 0xFF));
1411 xgifb_reg_and_or(XGIPART1,
1412 0x02,
1413 0x7F,
1414 ((base >> 24) & 0x01) << 7);
1415 }
1416 /* printk("End of pan_var"); */
1417 return 0;
1418 }
1419 #endif
1420
1421 static int XGIfb_open(struct fb_info *info, int user)
1422 {
1423 return 0;
1424 }
1425
1426 static int XGIfb_release(struct fb_info *info, int user)
1427 {
1428 return 0;
1429 }
1430
1431 static int XGIfb_get_cmap_len(const struct fb_var_screeninfo *var)
1432 {
1433 int rc = 16;
1434
1435 switch (var->bits_per_pixel) {
1436 case 8:
1437 rc = 256;
1438 break;
1439 case 16:
1440 rc = 16;
1441 break;
1442 case 32:
1443 rc = 16;
1444 break;
1445 }
1446 return rc;
1447 }
1448
1449 static int XGIfb_setcolreg(unsigned regno, unsigned red, unsigned green,
1450 unsigned blue, unsigned transp, struct fb_info *info)
1451 {
1452 if (regno >= XGIfb_get_cmap_len(&info->var))
1453 return 1;
1454
1455 switch (info->var.bits_per_pixel) {
1456 case 8:
1457 outb(regno, XGIDACA);
1458 outb((red >> 10), XGIDACD);
1459 outb((green >> 10), XGIDACD);
1460 outb((blue >> 10), XGIDACD);
1461 if (xgi_video_info.disp_state & DISPTYPE_DISP2) {
1462 outb(regno, XGIDAC2A);
1463 outb((red >> 8), XGIDAC2D);
1464 outb((green >> 8), XGIDAC2D);
1465 outb((blue >> 8), XGIDAC2D);
1466 }
1467 break;
1468 case 16:
1469 ((u32 *) (info->pseudo_palette))[regno] = ((red & 0xf800))
1470 | ((green & 0xfc00) >> 5) | ((blue & 0xf800)
1471 >> 11);
1472 break;
1473 case 32:
1474 red >>= 8;
1475 green >>= 8;
1476 blue >>= 8;
1477 ((u32 *) (info->pseudo_palette))[regno] = (red << 16) | (green
1478 << 8) | (blue);
1479 break;
1480 }
1481 return 0;
1482 }
1483
1484 /* ----------- FBDev related routines for all series ---------- */
1485
1486 static int XGIfb_get_fix(struct fb_fix_screeninfo *fix, int con,
1487 struct fb_info *info)
1488 {
1489 DEBUGPRN("inside get_fix");
1490 memset(fix, 0, sizeof(struct fb_fix_screeninfo));
1491
1492 strcpy(fix->id, myid);
1493
1494 fix->smem_start = xgi_video_info.video_base;
1495
1496 fix->smem_len = xgi_video_info.video_size;
1497
1498 fix->type = video_type;
1499 fix->type_aux = 0;
1500 if (xgi_video_info.video_bpp == 8)
1501 fix->visual = FB_VISUAL_PSEUDOCOLOR;
1502 else
1503 fix->visual = FB_VISUAL_DIRECTCOLOR;
1504 fix->xpanstep = 0;
1505 #ifdef XGIFB_PAN
1506 if (XGIfb_ypan)
1507 fix->ypanstep = 1;
1508 #endif
1509 fix->ywrapstep = 0;
1510 fix->line_length = xgi_video_info.video_linelength;
1511 fix->mmio_start = xgi_video_info.mmio_base;
1512 fix->mmio_len = xgi_video_info.mmio_size;
1513 fix->accel = FB_ACCEL_XGI_XABRE;
1514
1515 DEBUGPRN("end of get_fix");
1516 return 0;
1517 }
1518
1519 static int XGIfb_set_par(struct fb_info *info)
1520 {
1521 int err;
1522
1523 /* printk("XGIfb: inside set_par\n"); */
1524 err = XGIfb_do_set_var(&info->var, 1, info);
1525 if (err)
1526 return err;
1527 XGIfb_get_fix(&info->fix, -1, info);
1528 /* printk("XGIfb: end of set_par\n"); */
1529 return 0;
1530 }
1531
1532 static int XGIfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
1533 {
1534 unsigned int htotal = var->left_margin + var->xres + var->right_margin
1535 + var->hsync_len;
1536 unsigned int vtotal = 0;
1537 unsigned int drate = 0, hrate = 0;
1538 int found_mode = 0;
1539 int refresh_rate, search_idx;
1540
1541 DEBUGPRN("Inside check_var");
1542
1543 if ((var->vmode & FB_VMODE_MASK) == FB_VMODE_NONINTERLACED) {
1544 vtotal = var->upper_margin + var->yres + var->lower_margin
1545 + var->vsync_len;
1546 vtotal <<= 1;
1547 } else if ((var->vmode & FB_VMODE_MASK) == FB_VMODE_DOUBLE) {
1548 vtotal = var->upper_margin + var->yres + var->lower_margin
1549 + var->vsync_len;
1550 vtotal <<= 2;
1551 } else if ((var->vmode & FB_VMODE_MASK) == FB_VMODE_INTERLACED) {
1552 vtotal = var->upper_margin + (var->yres / 2)
1553 + var->lower_margin + var->vsync_len;
1554 } else
1555 vtotal = var->upper_margin + var->yres + var->lower_margin
1556 + var->vsync_len;
1557
1558 if (!(htotal) || !(vtotal))
1559 XGIFAIL("XGIfb: no valid timing data");
1560
1561 if (var->pixclock && htotal && vtotal) {
1562 drate = 1000000000 / var->pixclock;
1563 hrate = (drate * 1000) / htotal;
1564 xgi_video_info.refresh_rate =
1565 (unsigned int) (hrate * 2 / vtotal);
1566 printk(KERN_DEBUG
1567 "%s: pixclock = %d ,htotal=%d, vtotal=%d\n"
1568 "%s: drate=%d, hrate=%d, refresh_rate=%d\n",
1569 __func__, var->pixclock, htotal, vtotal,
1570 __func__, drate, hrate, xgi_video_info.refresh_rate);
1571 } else {
1572 xgi_video_info.refresh_rate = 60;
1573 }
1574
1575 /*
1576 if ((var->pixclock) && (htotal)) {
1577 drate = 1E12 / var->pixclock;
1578 hrate = drate / htotal;
1579 refresh_rate = (unsigned int) (hrate / vtotal * 2 + 0.5);
1580 } else {
1581 refresh_rate = 60;
1582 }
1583 */
1584 /* TW: Calculation wrong for 1024x600 - force it to 60Hz */
1585 if ((var->xres == 1024) && (var->yres == 600))
1586 refresh_rate = 60;
1587
1588 search_idx = 0;
1589 while ((XGIbios_mode[search_idx].mode_no != 0) &&
1590 (XGIbios_mode[search_idx].xres <= var->xres)) {
1591 if ((XGIbios_mode[search_idx].xres == var->xres) &&
1592 (XGIbios_mode[search_idx].yres == var->yres) &&
1593 (XGIbios_mode[search_idx].bpp == var->bits_per_pixel)) {
1594 if (XGIfb_validate_mode(search_idx) > 0) {
1595 found_mode = 1;
1596 break;
1597 }
1598 }
1599 search_idx++;
1600 }
1601
1602 if (!found_mode) {
1603
1604 printk(KERN_ERR "XGIfb: %dx%dx%d is no valid mode\n",
1605 var->xres, var->yres, var->bits_per_pixel);
1606 search_idx = 0;
1607 while (XGIbios_mode[search_idx].mode_no != 0) {
1608 if ((var->xres <= XGIbios_mode[search_idx].xres) &&
1609 (var->yres <= XGIbios_mode[search_idx].yres) &&
1610 (var->bits_per_pixel ==
1611 XGIbios_mode[search_idx].bpp)) {
1612 if (XGIfb_validate_mode(search_idx) > 0) {
1613 found_mode = 1;
1614 break;
1615 }
1616 }
1617 search_idx++;
1618 }
1619 if (found_mode) {
1620 var->xres = XGIbios_mode[search_idx].xres;
1621 var->yres = XGIbios_mode[search_idx].yres;
1622 printk(KERN_DEBUG "XGIfb: Adapted to mode %dx%dx%d\n",
1623 var->xres, var->yres, var->bits_per_pixel);
1624
1625 } else {
1626 printk(KERN_ERR "XGIfb: Failed to find similar mode to %dx%dx%d\n",
1627 var->xres, var->yres, var->bits_per_pixel);
1628 return -EINVAL;
1629 }
1630 }
1631
1632 /* TW: TODO: Check the refresh rate */
1633
1634 /* Adapt RGB settings */
1635 XGIfb_bpp_to_var(var);
1636
1637 /* Sanity check for offsets */
1638 if (var->xoffset < 0)
1639 var->xoffset = 0;
1640 if (var->yoffset < 0)
1641 var->yoffset = 0;
1642
1643 if (!XGIfb_ypan) {
1644 if (var->xres != var->xres_virtual)
1645 var->xres_virtual = var->xres;
1646 if (var->yres != var->yres_virtual)
1647 var->yres_virtual = var->yres;
1648 } /* else { */
1649 /* TW: Now patch yres_virtual if we use panning */
1650 /* May I do this? */
1651 /* var->yres_virtual = xgi_video_info.heapstart /
1652 (var->xres * (var->bits_per_pixel >> 3)); */
1653 /* if (var->yres_virtual <= var->yres) { */
1654 /* TW: Paranoia check */
1655 /* var->yres_virtual = var->yres; */
1656 /* } */
1657 /* } */
1658
1659 /* Truncate offsets to maximum if too high */
1660 if (var->xoffset > var->xres_virtual - var->xres)
1661 var->xoffset = var->xres_virtual - var->xres - 1;
1662
1663 if (var->yoffset > var->yres_virtual - var->yres)
1664 var->yoffset = var->yres_virtual - var->yres - 1;
1665
1666 /* Set everything else to 0 */
1667 var->red.msb_right =
1668 var->green.msb_right =
1669 var->blue.msb_right =
1670 var->transp.offset = var->transp.length = var->transp.msb_right = 0;
1671
1672 DEBUGPRN("end of check_var");
1673 return 0;
1674 }
1675
1676 #ifdef XGIFB_PAN
1677 static int XGIfb_pan_display(struct fb_var_screeninfo *var,
1678 struct fb_info *info)
1679 {
1680 int err;
1681
1682 /* printk("\nInside pan_display:\n"); */
1683
1684 if (var->xoffset > (var->xres_virtual - var->xres))
1685 return -EINVAL;
1686 if (var->yoffset > (var->yres_virtual - var->yres))
1687 return -EINVAL;
1688
1689 if (var->vmode & FB_VMODE_YWRAP) {
1690 if (var->yoffset < 0 || var->yoffset >= info->var.yres_virtual
1691 || var->xoffset)
1692 return -EINVAL;
1693 } else {
1694 if (var->xoffset + info->var.xres > info->var.xres_virtual
1695 || var->yoffset + info->var.yres
1696 > info->var.yres_virtual)
1697 return -EINVAL;
1698 }
1699 err = XGIfb_pan_var(var);
1700 if (err < 0)
1701 return err;
1702
1703 info->var.xoffset = var->xoffset;
1704 info->var.yoffset = var->yoffset;
1705 if (var->vmode & FB_VMODE_YWRAP)
1706 info->var.vmode |= FB_VMODE_YWRAP;
1707 else
1708 info->var.vmode &= ~FB_VMODE_YWRAP;
1709
1710 /* printk("End of pan_display\n"); */
1711 return 0;
1712 }
1713 #endif
1714
1715 static int XGIfb_blank(int blank, struct fb_info *info)
1716 {
1717 u8 reg;
1718
1719 reg = xgifb_reg_get(XGICR, 0x17);
1720
1721 if (blank > 0)
1722 reg &= 0x7f;
1723 else
1724 reg |= 0x80;
1725
1726 xgifb_reg_set(XGICR, 0x17, reg);
1727 xgifb_reg_set(XGISR, 0x00, 0x01); /* Synchronous Reset */
1728 xgifb_reg_set(XGISR, 0x00, 0x03); /* End Reset */
1729 return 0;
1730 }
1731
1732 static struct fb_ops XGIfb_ops = {
1733 .owner = THIS_MODULE,
1734 .fb_open = XGIfb_open,
1735 .fb_release = XGIfb_release,
1736 .fb_check_var = XGIfb_check_var,
1737 .fb_set_par = XGIfb_set_par,
1738 .fb_setcolreg = XGIfb_setcolreg,
1739 #ifdef XGIFB_PAN
1740 .fb_pan_display = XGIfb_pan_display,
1741 #endif
1742 .fb_blank = XGIfb_blank,
1743 .fb_fillrect = cfb_fillrect,
1744 .fb_copyarea = cfb_copyarea,
1745 .fb_imageblit = cfb_imageblit,
1746 /* .fb_mmap = XGIfb_mmap, */
1747 };
1748
1749 /* ---------------- Chip generation dependent routines ---------------- */
1750
1751 /* for XGI 315/550/650/740/330 */
1752
1753 static int XGIfb_get_dram_size(void)
1754 {
1755
1756 u8 ChannelNum, tmp;
1757 u8 reg = 0;
1758
1759 /* xorg driver sets 32MB * 1 channel */
1760 if (xgi_video_info.chip == XG27)
1761 xgifb_reg_set(XGISR, IND_XGI_DRAM_SIZE, 0x51);
1762
1763 reg = xgifb_reg_get(XGISR, IND_XGI_DRAM_SIZE);
1764 switch ((reg & XGI_DRAM_SIZE_MASK) >> 4) {
1765 case XGI_DRAM_SIZE_1MB:
1766 xgi_video_info.video_size = 0x100000;
1767 break;
1768 case XGI_DRAM_SIZE_2MB:
1769 xgi_video_info.video_size = 0x200000;
1770 break;
1771 case XGI_DRAM_SIZE_4MB:
1772 xgi_video_info.video_size = 0x400000;
1773 break;
1774 case XGI_DRAM_SIZE_8MB:
1775 xgi_video_info.video_size = 0x800000;
1776 break;
1777 case XGI_DRAM_SIZE_16MB:
1778 xgi_video_info.video_size = 0x1000000;
1779 break;
1780 case XGI_DRAM_SIZE_32MB:
1781 xgi_video_info.video_size = 0x2000000;
1782 break;
1783 case XGI_DRAM_SIZE_64MB:
1784 xgi_video_info.video_size = 0x4000000;
1785 break;
1786 case XGI_DRAM_SIZE_128MB:
1787 xgi_video_info.video_size = 0x8000000;
1788 break;
1789 case XGI_DRAM_SIZE_256MB:
1790 xgi_video_info.video_size = 0x10000000;
1791 break;
1792 default:
1793 return -1;
1794 }
1795
1796 tmp = (reg & 0x0c) >> 2;
1797 switch (xgi_video_info.chip) {
1798 case XG20:
1799 case XG21:
1800 case XG27:
1801 ChannelNum = 1;
1802 break;
1803
1804 case XG42:
1805 if (reg & 0x04)
1806 ChannelNum = 2;
1807 else
1808 ChannelNum = 1;
1809 break;
1810
1811 case XG45:
1812 if (tmp == 1)
1813 ChannelNum = 2;
1814 else if (tmp == 2)
1815 ChannelNum = 3;
1816 else if (tmp == 3)
1817 ChannelNum = 4;
1818 else
1819 ChannelNum = 1;
1820 break;
1821
1822 case XG40:
1823 default:
1824 if (tmp == 2)
1825 ChannelNum = 2;
1826 else if (tmp == 3)
1827 ChannelNum = 3;
1828 else
1829 ChannelNum = 1;
1830 break;
1831 }
1832
1833 xgi_video_info.video_size = xgi_video_info.video_size * ChannelNum;
1834 /* PLiad fixed for benchmarking and fb set */
1835 /* xgi_video_info.video_size = 0x200000; */ /* 1024x768x16 */
1836 /* xgi_video_info.video_size = 0x1000000; */ /* benchmark */
1837
1838 printk("XGIfb: SR14=%x DramSzie %x ChannelNum %x\n",
1839 reg,
1840 xgi_video_info.video_size, ChannelNum);
1841 return 0;
1842
1843 }
1844
1845 static void XGIfb_detect_VB(void)
1846 {
1847 u8 cr32, temp = 0;
1848
1849 xgi_video_info.TV_plug = xgi_video_info.TV_type = 0;
1850
1851 switch (xgi_video_info.hasVB) {
1852 case HASVB_LVDS_CHRONTEL:
1853 case HASVB_CHRONTEL:
1854 break;
1855 case HASVB_301:
1856 case HASVB_302:
1857 /* XGI_Sense30x(); */ /* Yi-Lin TV Sense? */
1858 break;
1859 }
1860
1861 cr32 = xgifb_reg_get(XGICR, IND_XGI_SCRATCH_REG_CR32);
1862
1863 if ((cr32 & XGI_CRT1) && !XGIfb_crt1off)
1864 XGIfb_crt1off = 0;
1865 else {
1866 if (cr32 & 0x5F)
1867 XGIfb_crt1off = 1;
1868 else
1869 XGIfb_crt1off = 0;
1870 }
1871
1872 if (XGIfb_crt2type != -1)
1873 /* TW: Override with option */
1874 xgi_video_info.disp_state = XGIfb_crt2type;
1875 else if (cr32 & XGI_VB_TV)
1876 xgi_video_info.disp_state = DISPTYPE_TV;
1877 else if (cr32 & XGI_VB_LCD)
1878 xgi_video_info.disp_state = DISPTYPE_LCD;
1879 else if (cr32 & XGI_VB_CRT2)
1880 xgi_video_info.disp_state = DISPTYPE_CRT2;
1881 else
1882 xgi_video_info.disp_state = 0;
1883
1884 if (XGIfb_tvplug != -1)
1885 /* PR/TW: Override with option */
1886 xgi_video_info.TV_plug = XGIfb_tvplug;
1887 else if (cr32 & XGI_VB_HIVISION) {
1888 xgi_video_info.TV_type = TVMODE_HIVISION;
1889 xgi_video_info.TV_plug = TVPLUG_SVIDEO;
1890 } else if (cr32 & XGI_VB_SVIDEO)
1891 xgi_video_info.TV_plug = TVPLUG_SVIDEO;
1892 else if (cr32 & XGI_VB_COMPOSITE)
1893 xgi_video_info.TV_plug = TVPLUG_COMPOSITE;
1894 else if (cr32 & XGI_VB_SCART)
1895 xgi_video_info.TV_plug = TVPLUG_SCART;
1896
1897 if (xgi_video_info.TV_type == 0) {
1898 temp = xgifb_reg_get(XGICR, 0x38);
1899 if (temp & 0x10)
1900 xgi_video_info.TV_type = TVMODE_PAL;
1901 else
1902 xgi_video_info.TV_type = TVMODE_NTSC;
1903 }
1904
1905 /* TW: Copy forceCRT1 option to CRT1off if option is given */
1906 if (XGIfb_forcecrt1 != -1) {
1907 if (XGIfb_forcecrt1)
1908 XGIfb_crt1off = 0;
1909 else
1910 XGIfb_crt1off = 1;
1911 }
1912 }
1913
1914 static int XGIfb_has_VB(void)
1915 {
1916 u8 vb_chipid;
1917
1918 vb_chipid = xgifb_reg_get(XGIPART4, 0x00);
1919 switch (vb_chipid) {
1920 case 0x01:
1921 xgi_video_info.hasVB = HASVB_301;
1922 break;
1923 case 0x02:
1924 xgi_video_info.hasVB = HASVB_302;
1925 break;
1926 default:
1927 xgi_video_info.hasVB = HASVB_NONE;
1928 return 0;
1929 }
1930 return 1;
1931 }
1932
1933 static void XGIfb_get_VB_type(void)
1934 {
1935 u8 reg;
1936
1937 if (!XGIfb_has_VB()) {
1938 reg = xgifb_reg_get(XGICR, IND_XGI_SCRATCH_REG_CR37);
1939 switch ((reg & XGI_EXTERNAL_CHIP_MASK) >> 1) {
1940 case XGI310_EXTERNAL_CHIP_LVDS:
1941 xgi_video_info.hasVB = HASVB_LVDS;
1942 break;
1943 case XGI310_EXTERNAL_CHIP_LVDS_CHRONTEL:
1944 xgi_video_info.hasVB = HASVB_LVDS_CHRONTEL;
1945 break;
1946 default:
1947 break;
1948 }
1949 }
1950 }
1951
1952 XGIINITSTATIC int __init XGIfb_setup(char *options)
1953 {
1954 char *this_opt;
1955
1956 xgi_video_info.refresh_rate = 0;
1957
1958 printk(KERN_INFO "XGIfb: Options %s\n", options);
1959
1960 if (!options || !*options)
1961 return 0;
1962
1963 while ((this_opt = strsep(&options, ",")) != NULL) {
1964
1965 if (!*this_opt)
1966 continue;
1967
1968 if (!strncmp(this_opt, "mode:", 5)) {
1969 XGIfb_search_mode(this_opt + 5);
1970 } else if (!strncmp(this_opt, "vesa:", 5)) {
1971 XGIfb_search_vesamode(simple_strtoul(
1972 this_opt + 5, NULL, 0));
1973 } else if (!strncmp(this_opt, "mode:", 5)) {
1974 XGIfb_search_mode(this_opt + 5);
1975 } else if (!strncmp(this_opt, "vesa:", 5)) {
1976 XGIfb_search_vesamode(simple_strtoul(
1977 this_opt + 5, NULL, 0));
1978 } else if (!strncmp(this_opt, "vrate:", 6)) {
1979 xgi_video_info.refresh_rate = simple_strtoul(
1980 this_opt + 6, NULL, 0);
1981 } else if (!strncmp(this_opt, "rate:", 5)) {
1982 xgi_video_info.refresh_rate = simple_strtoul(
1983 this_opt + 5, NULL, 0);
1984 } else if (!strncmp(this_opt, "off", 3)) {
1985 XGIfb_off = 1;
1986 } else if (!strncmp(this_opt, "crt1off", 7)) {
1987 XGIfb_crt1off = 1;
1988 } else if (!strncmp(this_opt, "filter:", 7)) {
1989 filter = (int)simple_strtoul(this_opt + 7, NULL, 0);
1990 } else if (!strncmp(this_opt, "forcecrt2type:", 14)) {
1991 XGIfb_search_crt2type(this_opt + 14);
1992 } else if (!strncmp(this_opt, "forcecrt1:", 10)) {
1993 XGIfb_forcecrt1 = (int)simple_strtoul(
1994 this_opt + 10, NULL, 0);
1995 } else if (!strncmp(this_opt, "tvmode:", 7)) {
1996 XGIfb_search_tvstd(this_opt + 7);
1997 } else if (!strncmp(this_opt, "tvstandard:", 11)) {
1998 XGIfb_search_tvstd(this_opt + 7);
1999 } else if (!strncmp(this_opt, "dstn", 4)) {
2000 enable_dstn = 1;
2001 /* TW: DSTN overrules forcecrt2type */
2002 XGIfb_crt2type = DISPTYPE_LCD;
2003 } else if (!strncmp(this_opt, "pdc:", 4)) {
2004 XGIfb_pdc = simple_strtoul(this_opt + 4, NULL, 0);
2005 if (XGIfb_pdc & ~0x3c) {
2006 printk(KERN_INFO "XGIfb: Illegal pdc parameter\n");
2007 XGIfb_pdc = 0;
2008 }
2009 } else if (!strncmp(this_opt, "noypan", 6)) {
2010 XGIfb_ypan = 0;
2011 } else if (!strncmp(this_opt, "userom:", 7)) {
2012 XGIfb_userom = (int)simple_strtoul(
2013 this_opt + 7, NULL, 0);
2014 /* } else if (!strncmp(this_opt, "useoem:", 7)) { */
2015 /* XGIfb_useoem = (int)simple_strtoul(
2016 this_opt + 7, NULL, 0); */
2017 } else {
2018 XGIfb_search_mode(this_opt);
2019 /* printk(KERN_INFO "XGIfb: Invalid option %s\n",
2020 this_opt); */
2021 }
2022
2023 /* TW: Panning only with acceleration */
2024 XGIfb_ypan = 0;
2025
2026 }
2027 printk("\nxgifb: outa xgifb_setup 3450");
2028 return 0;
2029 }
2030
2031 static unsigned char *xgifb_copy_rom(struct pci_dev *dev)
2032 {
2033 void __iomem *rom_address;
2034 unsigned char *rom_copy;
2035 size_t rom_size;
2036
2037 rom_address = pci_map_rom(dev, &rom_size);
2038 if (rom_address == NULL)
2039 return NULL;
2040
2041 rom_copy = vzalloc(XGIFB_ROM_SIZE);
2042 if (rom_copy == NULL)
2043 goto done;
2044
2045 rom_size = min_t(size_t, rom_size, XGIFB_ROM_SIZE);
2046 memcpy_fromio(rom_copy, rom_address, rom_size);
2047
2048 done:
2049 pci_unmap_rom(dev, rom_address);
2050 return rom_copy;
2051 }
2052
2053 static int __devinit xgifb_probe(struct pci_dev *pdev,
2054 const struct pci_device_id *ent)
2055 {
2056 u8 reg, reg1;
2057 u8 CR48, CR38;
2058 int ret;
2059
2060 if (XGIfb_off)
2061 return -ENXIO;
2062
2063 XGIfb_registered = 0;
2064
2065 memset(&XGIhw_ext, 0, sizeof(struct xgi_hw_device_info));
2066 fb_info = framebuffer_alloc(sizeof(struct fb_info), &pdev->dev);
2067 if (!fb_info)
2068 return -ENOMEM;
2069
2070 xgi_video_info.chip_id = pdev->device;
2071 pci_read_config_byte(pdev,
2072 PCI_REVISION_ID,
2073 &xgi_video_info.revision_id);
2074 XGIhw_ext.jChipRevision = xgi_video_info.revision_id;
2075
2076 xgi_video_info.pcibus = pdev->bus->number;
2077 xgi_video_info.pcislot = PCI_SLOT(pdev->devfn);
2078 xgi_video_info.pcifunc = PCI_FUNC(pdev->devfn);
2079 xgi_video_info.subsysvendor = pdev->subsystem_vendor;
2080 xgi_video_info.subsysdevice = pdev->subsystem_device;
2081
2082 xgi_video_info.video_base = pci_resource_start(pdev, 0);
2083 xgi_video_info.mmio_base = pci_resource_start(pdev, 1);
2084 xgi_video_info.mmio_size = pci_resource_len(pdev, 1);
2085 xgi_video_info.vga_base = pci_resource_start(pdev, 2) + 0x30;
2086 XGIhw_ext.pjIOAddress = (unsigned char *)xgi_video_info.vga_base;
2087 /* XGI_Pr.RelIO = ioremap(pci_resource_start(pdev, 2), 128) + 0x30; */
2088 printk("XGIfb: Relocate IO address: %lx [%08lx]\n",
2089 (unsigned long)pci_resource_start(pdev, 2), XGI_Pr.RelIO);
2090
2091 if (pci_enable_device(pdev)) {
2092 ret = -EIO;
2093 goto error;
2094 }
2095
2096 XGIRegInit(&XGI_Pr, (unsigned long)XGIhw_ext.pjIOAddress);
2097
2098 xgifb_reg_set(XGISR, IND_XGI_PASSWORD, XGI_PASSWORD);
2099 reg1 = xgifb_reg_get(XGISR, IND_XGI_PASSWORD);
2100
2101 if (reg1 != 0xa1) { /*I/O error */
2102 printk("\nXGIfb: I/O error!!!");
2103 ret = -EIO;
2104 goto error;
2105 }
2106
2107 switch (xgi_video_info.chip_id) {
2108 case PCI_DEVICE_ID_XG_20:
2109 xgifb_reg_or(XGICR, Index_CR_GPIO_Reg3, GPIOG_EN);
2110 CR48 = xgifb_reg_get(XGICR, Index_CR_GPIO_Reg1);
2111 if (CR48&GPIOG_READ)
2112 xgi_video_info.chip = XG21;
2113 else
2114 xgi_video_info.chip = XG20;
2115 XGIfb_CRT2_write_enable = IND_XGI_CRT2_WRITE_ENABLE_315;
2116 break;
2117 case PCI_DEVICE_ID_XG_40:
2118 xgi_video_info.chip = XG40;
2119 XGIfb_CRT2_write_enable = IND_XGI_CRT2_WRITE_ENABLE_315;
2120 break;
2121 case PCI_DEVICE_ID_XG_41:
2122 xgi_video_info.chip = XG41;
2123 XGIfb_CRT2_write_enable = IND_XGI_CRT2_WRITE_ENABLE_315;
2124 break;
2125 case PCI_DEVICE_ID_XG_42:
2126 xgi_video_info.chip = XG42;
2127 XGIfb_CRT2_write_enable = IND_XGI_CRT2_WRITE_ENABLE_315;
2128 break;
2129 case PCI_DEVICE_ID_XG_27:
2130 xgi_video_info.chip = XG27;
2131 XGIfb_CRT2_write_enable = IND_XGI_CRT2_WRITE_ENABLE_315;
2132 break;
2133 default:
2134 ret = -ENODEV;
2135 goto error;
2136 }
2137
2138 printk("XGIfb:chipid = %x\n", xgi_video_info.chip);
2139 XGIhw_ext.jChipType = xgi_video_info.chip;
2140
2141 if ((xgi_video_info.chip == XG21) || (XGIfb_userom)) {
2142 XGIhw_ext.pjVirtualRomBase = xgifb_copy_rom(pdev);
2143 if (XGIhw_ext.pjVirtualRomBase)
2144 printk(KERN_INFO "XGIfb: Video ROM found and mapped to %p\n",
2145 XGIhw_ext.pjVirtualRomBase);
2146 else
2147 printk(KERN_INFO "XGIfb: Video ROM not found\n");
2148 } else {
2149 XGIhw_ext.pjVirtualRomBase = NULL;
2150 printk(KERN_INFO "XGIfb: Video ROM usage disabled\n");
2151 }
2152 XGIhw_ext.pQueryVGAConfigSpace = &XGIfb_query_VGA_config_space;
2153
2154 if (XGIfb_get_dram_size()) {
2155 printk(KERN_INFO "XGIfb: Fatal error: Unable to determine RAM size.\n");
2156 ret = -ENODEV;
2157 goto error;
2158 }
2159
2160 if ((xgifb_mode_idx < 0) ||
2161 ((XGIbios_mode[xgifb_mode_idx].mode_no) != 0xFF)) {
2162 /* Enable PCI_LINEAR_ADDRESSING and MMIO_ENABLE */
2163 xgifb_reg_or(XGISR,
2164 IND_XGI_PCI_ADDRESS_SET,
2165 (XGI_PCI_ADDR_ENABLE | XGI_MEM_MAP_IO_ENABLE));
2166 /* Enable 2D accelerator engine */
2167 xgifb_reg_or(XGISR, IND_XGI_MODULE_ENABLE, XGI_ENABLE_2D);
2168 }
2169
2170 XGIhw_ext.ulVideoMemorySize = xgi_video_info.video_size;
2171
2172 if (!request_mem_region(xgi_video_info.video_base,
2173 xgi_video_info.video_size,
2174 "XGIfb FB")) {
2175 printk("unable request memory size %x",
2176 xgi_video_info.video_size);
2177 printk(KERN_ERR "XGIfb: Fatal error: Unable to reserve frame buffer memory\n");
2178 printk(KERN_ERR "XGIfb: Is there another framebuffer driver active?\n");
2179 ret = -ENODEV;
2180 goto error;
2181 }
2182
2183 if (!request_mem_region(xgi_video_info.mmio_base,
2184 xgi_video_info.mmio_size,
2185 "XGIfb MMIO")) {
2186 printk(KERN_ERR "XGIfb: Fatal error: Unable to reserve MMIO region\n");
2187 ret = -ENODEV;
2188 goto error_0;
2189 }
2190
2191 xgi_video_info.video_vbase = XGIhw_ext.pjVideoMemoryAddress =
2192 ioremap(xgi_video_info.video_base, xgi_video_info.video_size);
2193 xgi_video_info.mmio_vbase = ioremap(xgi_video_info.mmio_base,
2194 xgi_video_info.mmio_size);
2195
2196 printk(KERN_INFO "XGIfb: Framebuffer at 0x%lx, mapped to 0x%p, size %dk\n",
2197 xgi_video_info.video_base,
2198 xgi_video_info.video_vbase,
2199 xgi_video_info.video_size / 1024);
2200
2201 printk(KERN_INFO "XGIfb: MMIO at 0x%lx, mapped to 0x%p, size %ldk\n",
2202 xgi_video_info.mmio_base, xgi_video_info.mmio_vbase,
2203 xgi_video_info.mmio_size / 1024);
2204 printk("XGIfb: XGIInitNew() ...");
2205 if (XGIInitNew(&XGIhw_ext))
2206 printk("OK\n");
2207 else
2208 printk("Fail\n");
2209
2210 xgi_video_info.mtrr = (unsigned int) 0;
2211
2212 if ((xgifb_mode_idx < 0) ||
2213 ((XGIbios_mode[xgifb_mode_idx].mode_no) != 0xFF)) {
2214 xgi_video_info.hasVB = HASVB_NONE;
2215 if ((xgi_video_info.chip == XG20) ||
2216 (xgi_video_info.chip == XG27)) {
2217 xgi_video_info.hasVB = HASVB_NONE;
2218 } else if (xgi_video_info.chip == XG21) {
2219 CR38 = xgifb_reg_get(XGICR, 0x38);
2220 if ((CR38&0xE0) == 0xC0) {
2221 xgi_video_info.disp_state = DISPTYPE_LCD;
2222 if (!XGIfb_GetXG21LVDSData()) {
2223 int m;
2224 for (m = 0; m < sizeof(XGI21_LCDCapList)/sizeof(struct XGI21_LVDSCapStruct); m++) {
2225 if ((XGI21_LCDCapList[m].LVDSHDE == XGIbios_mode[xgifb_mode_idx].xres) &&
2226 (XGI21_LCDCapList[m].LVDSVDE == XGIbios_mode[xgifb_mode_idx].yres)) {
2227 xgifb_reg_set(XGI_Pr.P3d4, 0x36, m);
2228 }
2229 }
2230 }
2231 } else if ((CR38&0xE0) == 0x60) {
2232 xgi_video_info.hasVB = HASVB_CHRONTEL;
2233 } else {
2234 xgi_video_info.hasVB = HASVB_NONE;
2235 }
2236 } else {
2237 XGIfb_get_VB_type();
2238 }
2239
2240 XGIhw_ext.ujVBChipID = VB_CHIP_UNKNOWN;
2241
2242 XGIhw_ext.ulExternalChip = 0;
2243
2244 switch (xgi_video_info.hasVB) {
2245 case HASVB_301:
2246 reg = xgifb_reg_get(XGIPART4, 0x01);
2247 if (reg >= 0xE0) {
2248 XGIhw_ext.ujVBChipID = VB_CHIP_302LV;
2249 printk(KERN_INFO "XGIfb: XGI302LV bridge detected (revision 0x%02x)\n", reg);
2250 } else if (reg >= 0xD0) {
2251 XGIhw_ext.ujVBChipID = VB_CHIP_301LV;
2252 printk(KERN_INFO "XGIfb: XGI301LV bridge detected (revision 0x%02x)\n", reg);
2253 }
2254 /* else if (reg >= 0xB0) {
2255 XGIhw_ext.ujVBChipID = VB_CHIP_301B;
2256 reg1 = xgifb_reg_get(XGIPART4, 0x23);
2257 printk("XGIfb: XGI301B bridge detected\n");
2258 } */
2259 else {
2260 XGIhw_ext.ujVBChipID = VB_CHIP_301;
2261 printk("XGIfb: XGI301 bridge detected\n");
2262 }
2263 break;
2264 case HASVB_302:
2265 reg = xgifb_reg_get(XGIPART4, 0x01);
2266 if (reg >= 0xE0) {
2267 XGIhw_ext.ujVBChipID = VB_CHIP_302LV;
2268 printk(KERN_INFO "XGIfb: XGI302LV bridge detected (revision 0x%02x)\n", reg);
2269 } else if (reg >= 0xD0) {
2270 XGIhw_ext.ujVBChipID = VB_CHIP_301LV;
2271 printk(KERN_INFO "XGIfb: XGI302LV bridge detected (revision 0x%02x)\n", reg);
2272 } else if (reg >= 0xB0) {
2273 reg1 = xgifb_reg_get(XGIPART4, 0x23);
2274
2275 XGIhw_ext.ujVBChipID = VB_CHIP_302B;
2276
2277 } else {
2278 XGIhw_ext.ujVBChipID = VB_CHIP_302;
2279 printk(KERN_INFO "XGIfb: XGI302 bridge detected\n");
2280 }
2281 break;
2282 case HASVB_LVDS:
2283 XGIhw_ext.ulExternalChip = 0x1;
2284 printk(KERN_INFO "XGIfb: LVDS transmitter detected\n");
2285 break;
2286 case HASVB_TRUMPION:
2287 XGIhw_ext.ulExternalChip = 0x2;
2288 printk(KERN_INFO "XGIfb: Trumpion Zurac LVDS scaler detected\n");
2289 break;
2290 case HASVB_CHRONTEL:
2291 XGIhw_ext.ulExternalChip = 0x4;
2292 printk(KERN_INFO "XGIfb: Chrontel TV encoder detected\n");
2293 break;
2294 case HASVB_LVDS_CHRONTEL:
2295 XGIhw_ext.ulExternalChip = 0x5;
2296 printk(KERN_INFO "XGIfb: LVDS transmitter and Chrontel TV encoder detected\n");
2297 break;
2298 default:
2299 printk(KERN_INFO "XGIfb: No or unknown bridge type detected\n");
2300 break;
2301 }
2302
2303 if (xgi_video_info.hasVB != HASVB_NONE)
2304 XGIfb_detect_VB();
2305
2306 if (xgi_video_info.disp_state & DISPTYPE_DISP2) {
2307 if (XGIfb_crt1off)
2308 xgi_video_info.disp_state |= DISPMODE_SINGLE;
2309 else
2310 xgi_video_info.disp_state |= (DISPMODE_MIRROR |
2311 DISPTYPE_CRT1);
2312 } else {
2313 xgi_video_info.disp_state = DISPMODE_SINGLE |
2314 DISPTYPE_CRT1;
2315 }
2316
2317 if (xgi_video_info.disp_state & DISPTYPE_LCD) {
2318 if (!enable_dstn) {
2319 reg = xgifb_reg_get(XGICR, IND_XGI_LCD_PANEL);
2320 reg &= 0x0f;
2321 XGIhw_ext.ulCRT2LCDType = XGI310paneltype[reg];
2322
2323 } else {
2324 /* TW: FSTN/DSTN */
2325 XGIhw_ext.ulCRT2LCDType = LCD_320x480;
2326 }
2327 }
2328
2329 XGIfb_detectedpdc = 0;
2330
2331 XGIfb_detectedlcda = 0xff;
2332
2333 /* TW: Try to find about LCDA */
2334
2335 if ((XGIhw_ext.ujVBChipID == VB_CHIP_302B) ||
2336 (XGIhw_ext.ujVBChipID == VB_CHIP_301LV) ||
2337 (XGIhw_ext.ujVBChipID == VB_CHIP_302LV)) {
2338 int tmp;
2339 tmp = xgifb_reg_get(XGICR, 0x34);
2340 if (tmp <= 0x13) {
2341 /* Currently on LCDA?
2342 *(Some BIOSes leave CR38) */
2343 tmp = xgifb_reg_get(XGICR, 0x38);
2344 if ((tmp & 0x03) == 0x03) {
2345 /* XGI_Pr.XGI_UseLCDA = 1; */
2346 } else {
2347 /* Currently on LCDA?
2348 *(Some newer BIOSes set D0 in CR35) */
2349 tmp = xgifb_reg_get(XGICR, 0x35);
2350 if (tmp & 0x01) {
2351 /* XGI_Pr.XGI_UseLCDA = 1; */
2352 } else {
2353 tmp = xgifb_reg_get(XGICR,
2354 0x30);
2355 if (tmp & 0x20) {
2356 tmp = xgifb_reg_get(
2357 XGIPART1, 0x13);
2358 if (tmp & 0x04) {
2359 /* XGI_Pr.XGI_UseLCDA = 1; */
2360 }
2361 }
2362 }
2363 }
2364 }
2365
2366 }
2367
2368 if (xgifb_mode_idx >= 0)
2369 xgifb_mode_idx = XGIfb_validate_mode(xgifb_mode_idx);
2370
2371 if (xgifb_mode_idx < 0) {
2372 switch (xgi_video_info.disp_state & DISPTYPE_DISP2) {
2373 case DISPTYPE_LCD:
2374 xgifb_mode_idx = DEFAULT_LCDMODE;
2375 if (xgi_video_info.chip == XG21)
2376 xgifb_mode_idx =
2377 XGIfb_GetXG21DefaultLVDSModeIdx();
2378 break;
2379 case DISPTYPE_TV:
2380 xgifb_mode_idx = DEFAULT_TVMODE;
2381 break;
2382 default:
2383 xgifb_mode_idx = DEFAULT_MODE;
2384 break;
2385 }
2386 }
2387
2388 XGIfb_mode_no = XGIbios_mode[xgifb_mode_idx].mode_no;
2389
2390 /* yilin set default refresh rate */
2391 if (xgi_video_info.refresh_rate == 0)
2392 xgi_video_info.refresh_rate = 60;
2393 if (XGIfb_search_refresh_rate(
2394 xgi_video_info.refresh_rate) == 0) {
2395 XGIfb_rate_idx = XGIbios_mode[xgifb_mode_idx].rate_idx;
2396 xgi_video_info.refresh_rate = 60;
2397 }
2398
2399 xgi_video_info.video_bpp = XGIbios_mode[xgifb_mode_idx].bpp;
2400 xgi_video_info.video_vwidth =
2401 xgi_video_info.video_width =
2402 XGIbios_mode[xgifb_mode_idx].xres;
2403 xgi_video_info.video_vheight =
2404 xgi_video_info.video_height =
2405 XGIbios_mode[xgifb_mode_idx].yres;
2406 xgi_video_info.org_x = xgi_video_info.org_y = 0;
2407 xgi_video_info.video_linelength =
2408 xgi_video_info.video_width *
2409 (xgi_video_info.video_bpp >> 3);
2410 switch (xgi_video_info.video_bpp) {
2411 case 8:
2412 xgi_video_info.DstColor = 0x0000;
2413 xgi_video_info.XGI310_AccelDepth = 0x00000000;
2414 xgi_video_info.video_cmap_len = 256;
2415 break;
2416 case 16:
2417 xgi_video_info.DstColor = 0x8000;
2418 xgi_video_info.XGI310_AccelDepth = 0x00010000;
2419 xgi_video_info.video_cmap_len = 16;
2420 break;
2421 case 32:
2422 xgi_video_info.DstColor = 0xC000;
2423 xgi_video_info.XGI310_AccelDepth = 0x00020000;
2424 xgi_video_info.video_cmap_len = 16;
2425 break;
2426 default:
2427 xgi_video_info.video_cmap_len = 16;
2428 printk(KERN_INFO "XGIfb: Unsupported depth %d",
2429 xgi_video_info.video_bpp);
2430 break;
2431 }
2432
2433 printk(KERN_INFO "XGIfb: Default mode is %dx%dx%d (%dHz)\n",
2434 xgi_video_info.video_width,
2435 xgi_video_info.video_height,
2436 xgi_video_info.video_bpp,
2437 xgi_video_info.refresh_rate);
2438
2439 default_var.xres =
2440 default_var.xres_virtual =
2441 xgi_video_info.video_width;
2442 default_var.yres =
2443 default_var.yres_virtual =
2444 xgi_video_info.video_height;
2445 default_var.bits_per_pixel = xgi_video_info.video_bpp;
2446
2447 XGIfb_bpp_to_var(&default_var);
2448
2449 default_var.pixclock = (u32) (1000000000 /
2450 XGIfb_mode_rate_to_dclock(&XGI_Pr, &XGIhw_ext,
2451 XGIfb_mode_no, XGIfb_rate_idx));
2452
2453 if (XGIfb_mode_rate_to_ddata(&XGI_Pr, &XGIhw_ext,
2454 XGIfb_mode_no, XGIfb_rate_idx,
2455 &default_var.left_margin, &default_var.right_margin,
2456 &default_var.upper_margin, &default_var.lower_margin,
2457 &default_var.hsync_len, &default_var.vsync_len,
2458 &default_var.sync, &default_var.vmode)) {
2459
2460 if ((default_var.vmode & FB_VMODE_MASK) ==
2461 FB_VMODE_INTERLACED) {
2462 default_var.yres <<= 1;
2463 default_var.yres_virtual <<= 1;
2464 } else if ((default_var.vmode & FB_VMODE_MASK) ==
2465 FB_VMODE_DOUBLE) {
2466 default_var.pixclock >>= 1;
2467 default_var.yres >>= 1;
2468 default_var.yres_virtual >>= 1;
2469 }
2470
2471 }
2472
2473 fb_info->flags = FBINFO_FLAG_DEFAULT;
2474 fb_info->var = default_var;
2475 fb_info->fix = XGIfb_fix;
2476 fb_info->par = &xgi_video_info;
2477 fb_info->screen_base = xgi_video_info.video_vbase;
2478 fb_info->fbops = &XGIfb_ops;
2479 XGIfb_get_fix(&fb_info->fix, -1, fb_info);
2480 fb_info->pseudo_palette = pseudo_palette;
2481
2482 fb_alloc_cmap(&fb_info->cmap, 256 , 0);
2483
2484 #ifdef CONFIG_MTRR
2485 xgi_video_info.mtrr = mtrr_add(
2486 (unsigned int) xgi_video_info.video_base,
2487 (unsigned int) xgi_video_info.video_size,
2488 MTRR_TYPE_WRCOMB, 1);
2489 if (xgi_video_info.mtrr)
2490 printk(KERN_INFO "XGIfb: Added MTRRs\n");
2491 #endif
2492
2493 if (register_framebuffer(fb_info) < 0) {
2494 ret = -EINVAL;
2495 goto error_1;
2496 }
2497
2498 XGIfb_registered = 1;
2499
2500 printk(KERN_INFO "fb%d: %s frame buffer device, Version %d.%d.%02d\n",
2501 fb_info->node, myid, VER_MAJOR, VER_MINOR, VER_LEVEL);
2502
2503 }
2504
2505 dumpVGAReg();
2506
2507 return 0;
2508
2509 error_1:
2510 iounmap(xgi_video_info.mmio_vbase);
2511 iounmap(xgi_video_info.video_vbase);
2512 release_mem_region(xgi_video_info.mmio_base, xgi_video_info.mmio_size);
2513 error_0:
2514 release_mem_region(xgi_video_info.video_base,
2515 xgi_video_info.video_size);
2516 error:
2517 vfree(XGIhw_ext.pjVirtualRomBase);
2518 framebuffer_release(fb_info);
2519 return ret;
2520 }
2521
2522 /*****************************************************/
2523 /* PCI DEVICE HANDLING */
2524 /*****************************************************/
2525
2526 static void __devexit xgifb_remove(struct pci_dev *pdev)
2527 {
2528 unregister_framebuffer(fb_info);
2529 iounmap(xgi_video_info.mmio_vbase);
2530 iounmap(xgi_video_info.video_vbase);
2531 release_mem_region(xgi_video_info.mmio_base, xgi_video_info.mmio_size);
2532 release_mem_region(xgi_video_info.video_base,
2533 xgi_video_info.video_size);
2534 vfree(XGIhw_ext.pjVirtualRomBase);
2535 framebuffer_release(fb_info);
2536 pci_set_drvdata(pdev, NULL);
2537 }
2538
2539 static struct pci_driver xgifb_driver = {
2540 .name = "xgifb",
2541 .id_table = xgifb_pci_table,
2542 .probe = xgifb_probe,
2543 .remove = __devexit_p(xgifb_remove)
2544 };
2545
2546 XGIINITSTATIC int __init xgifb_init(void)
2547 {
2548 char *option = NULL;
2549
2550 if (fb_get_options("xgifb", &option))
2551 return -ENODEV;
2552 XGIfb_setup(option);
2553
2554 return pci_register_driver(&xgifb_driver);
2555 }
2556
2557 #ifndef MODULE
2558 module_init(xgifb_init);
2559 #endif
2560
2561 /*****************************************************/
2562 /* MODULE */
2563 /*****************************************************/
2564
2565 #ifdef MODULE
2566
2567 static char *mode = NULL;
2568 static int vesa = 0;
2569 static unsigned int rate = 0;
2570 static unsigned int mem = 0;
2571 static char *forcecrt2type = NULL;
2572 static int forcecrt1 = -1;
2573 static int pdc = -1;
2574 static int pdc1 = -1;
2575 static int noypan = -1;
2576 static int userom = -1;
2577 static int useoem = -1;
2578 static char *tvstandard = NULL;
2579 static int nocrt2rate = 0;
2580 static int scalelcd = -1;
2581 static char *specialtiming = NULL;
2582 static int lvdshl = -1;
2583 static int tvxposoffset = 0, tvyposoffset = 0;
2584 #if !defined(__i386__) && !defined(__x86_64__)
2585 static int resetcard = 0;
2586 static int videoram = 0;
2587 #endif
2588
2589 MODULE_DESCRIPTION("Z7 Z9 Z9S Z11 framebuffer device driver");
2590 MODULE_LICENSE("GPL");
2591 MODULE_AUTHOR("XGITECH , Others");
2592
2593 module_param(mem, int, 0);
2594 module_param(noypan, int, 0);
2595 module_param(userom, int, 0);
2596 module_param(useoem, int, 0);
2597 module_param(mode, charp, 0);
2598 module_param(vesa, int, 0);
2599 module_param(rate, int, 0);
2600 module_param(forcecrt1, int, 0);
2601 module_param(forcecrt2type, charp, 0);
2602 module_param(scalelcd, int, 0);
2603 module_param(pdc, int, 0);
2604 module_param(pdc1, int, 0);
2605 module_param(specialtiming, charp, 0);
2606 module_param(lvdshl, int, 0);
2607 module_param(tvstandard, charp, 0);
2608 module_param(tvxposoffset, int, 0);
2609 module_param(tvyposoffset, int, 0);
2610 module_param(filter, int, 0);
2611 module_param(nocrt2rate, int, 0);
2612 #if !defined(__i386__) && !defined(__x86_64__)
2613 module_param(resetcard, int, 0);
2614 module_param(videoram, int, 0);
2615 #endif
2616
2617 MODULE_PARM_DESC(noypan,
2618 "\nIf set to anything other than 0, y-panning will be disabled and scrolling\n"
2619 "will be performed by redrawing the screen. (default: 0)\n");
2620
2621 MODULE_PARM_DESC(mode,
2622 "\nSelects the desired default display mode in the format XxYxDepth,\n"
2623 "eg. 1024x768x16. Other formats supported include XxY-Depth and\n"
2624 "XxY-Depth@Rate. If the parameter is only one (decimal or hexadecimal)\n"
2625 "number, it will be interpreted as a VESA mode number. (default: 800x600x8)\n");
2626
2627 MODULE_PARM_DESC(vesa,
2628 "\nSelects the desired default display mode by VESA defined mode number, eg.\n"
2629 "0x117 (default: 0x0103)\n");
2630
2631 MODULE_PARM_DESC(rate,
2632 "\nSelects the desired vertical refresh rate for CRT1 (external VGA) in Hz.\n"
2633 "If the mode is specified in the format XxY-Depth@Rate, this parameter\n"
2634 "will be ignored (default: 60)\n");
2635
2636 MODULE_PARM_DESC(forcecrt1,
2637 "\nNormally, the driver autodetects whether or not CRT1 (external VGA) is\n"
2638 "connected. With this option, the detection can be overridden (1=CRT1 ON,\n"
2639 "0=CRT1 OFF) (default: [autodetected])\n");
2640
2641 MODULE_PARM_DESC(forcecrt2type,
2642 "\nIf this option is omitted, the driver autodetects CRT2 output devices, such as\n"
2643 "LCD, TV or secondary VGA. With this option, this autodetection can be\n"
2644 "overridden. Possible parameters are LCD, TV, VGA or NONE. NONE disables CRT2.\n"
2645 "On systems with a SiS video bridge, parameters SVIDEO, COMPOSITE or SCART can\n"
2646 "be used instead of TV to override the TV detection. Furthermore, on systems\n"
2647 "with a SiS video bridge, SVIDEO+COMPOSITE, HIVISION, YPBPR480I, YPBPR480P,\n"
2648 "YPBPR720P and YPBPR1080I are understood. However, whether or not these work\n"
2649 "depends on the very hardware in use. (default: [autodetected])\n");
2650
2651 MODULE_PARM_DESC(scalelcd,
2652 "\nSetting this to 1 will force the driver to scale the LCD image to the panel's\n"
2653 "native resolution. Setting it to 0 will disable scaling; LVDS panels will\n"
2654 "show black bars around the image, TMDS panels will probably do the scaling\n"
2655 "themselves. Default: 1 on LVDS panels, 0 on TMDS panels\n");
2656
2657 MODULE_PARM_DESC(pdc,
2658 "\nThis is for manually selecting the LCD panel delay compensation. The driver\n"
2659 "should detect this correctly in most cases; however, sometimes this is not\n"
2660 "possible. If you see 'small waves' on the LCD, try setting this to 4, 32 or 24\n"
2661 "on a 300 series chipset; 6 on a 315 series chipset. If the problem persists,\n"
2662 "try other values (on 300 series: between 4 and 60 in steps of 4; on 315 series:\n"
2663 "any value from 0 to 31). (default: autodetected, if LCD is active during start)\n");
2664
2665 MODULE_PARM_DESC(pdc1,
2666 "\nThis is same as pdc, but for LCD-via CRT1. Hence, this is for the 315/330\n"
2667 "series only. (default: autodetected if LCD is in LCD-via-CRT1 mode during\n"
2668 "startup) - Note: currently, this has no effect because LCD-via-CRT1 is not\n"
2669 "implemented yet.\n");
2670
2671 MODULE_PARM_DESC(specialtiming,
2672 "\nPlease refer to documentation for more information on this option.\n");
2673
2674 MODULE_PARM_DESC(lvdshl,
2675 "\nPlease refer to documentation for more information on this option.\n");
2676
2677 MODULE_PARM_DESC(tvstandard,
2678 "\nThis allows overriding the BIOS default for the TV standard. Valid choices are\n"
2679 "pal, ntsc, palm and paln. (default: [auto; pal or ntsc only])\n");
2680
2681 MODULE_PARM_DESC(tvxposoffset,
2682 "\nRelocate TV output horizontally. Possible parameters: -32 through 32.\n"
2683 "Default: 0\n");
2684
2685 MODULE_PARM_DESC(tvyposoffset,
2686 "\nRelocate TV output vertically. Possible parameters: -32 through 32.\n"
2687 "Default: 0\n");
2688
2689 MODULE_PARM_DESC(filter,
2690 "\nSelects TV flicker filter type (only for systems with a SiS301 video bridge).\n"
2691 "(Possible values 0-7, default: [no filter])\n");
2692
2693 MODULE_PARM_DESC(nocrt2rate,
2694 "\nSetting this to 1 will force the driver to use the default refresh rate for\n"
2695 "CRT2 if CRT2 type is VGA. (default: 0, use same rate as CRT1)\n");
2696
2697 static int __init xgifb_init_module(void)
2698 {
2699 printk("\nXGIfb_init_module");
2700 if (mode)
2701 XGIfb_search_mode(mode);
2702 else if (vesa != -1)
2703 XGIfb_search_vesamode(vesa);
2704
2705 return xgifb_init();
2706 }
2707
2708 static void __exit xgifb_remove_module(void)
2709 {
2710 pci_unregister_driver(&xgifb_driver);
2711 printk(KERN_DEBUG "xgifb: Module unloaded\n");
2712 }
2713
2714 module_init(xgifb_init_module);
2715 module_exit(xgifb_remove_module);
2716
2717 #endif /* /MODULE */
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree