]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - drivers/video/sis/sis_main.c
projects / mirror_ubuntu-jammy-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Remove obsolete #include <linux/config.h>
[mirror_ubuntu-jammy-kernel.git] / drivers / video / sis / sis_main.c
1 /*
2 * SiS 300/540/630[S]/730[S],
3 * SiS 315[E|PRO]/550/[M]65x/[M]66x[F|M|G]X/[M]74x[GX]/330/[M]76x[GX],
4 * XGI V3XT/V5/V8, Z7
5 * frame buffer driver for Linux kernels >= 2.4.14 and >=2.6.3
6 *
7 * Copyright (C) 2001-2005 Thomas Winischhofer, Vienna, Austria.
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the named License,
12 * or any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA
22 *
23 * Author: Thomas Winischhofer <thomas@winischhofer.net>
24 *
25 * Author of (practically wiped) code base:
26 * SiS (www.sis.com)
27 * Copyright (C) 1999 Silicon Integrated Systems, Inc.
28 *
29 * See http://www.winischhofer.net/ for more information and updates
30 *
31 * Originally based on the VBE 2.0 compliant graphic boards framebuffer driver,
32 * which is (c) 1998 Gerd Knorr <kraxel@goldbach.in-berlin.de>
33 *
34 */
35
36 #include <linux/version.h>
37 #include <linux/module.h>
38 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
39 #include <linux/moduleparam.h>
40 #endif
41 #include <linux/kernel.h>
42 #include <linux/smp_lock.h>
43 #include <linux/spinlock.h>
44 #include <linux/errno.h>
45 #include <linux/string.h>
46 #include <linux/mm.h>
47 #include <linux/tty.h>
48 #include <linux/slab.h>
49 #include <linux/fb.h>
50 #include <linux/selection.h>
51 #include <linux/ioport.h>
52 #include <linux/init.h>
53 #include <linux/pci.h>
54 #include <linux/vmalloc.h>
55 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
56 #include <linux/vt_kern.h>
57 #endif
58 #include <linux/capability.h>
59 #include <linux/fs.h>
60 #include <linux/types.h>
61 #include <asm/uaccess.h>
62 #include <asm/io.h>
63 #ifdef CONFIG_MTRR
64 #include <asm/mtrr.h>
65 #endif
66
67 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
68 #include <video/fbcon.h>
69 #include <video/fbcon-cfb8.h>
70 #include <video/fbcon-cfb16.h>
71 #include <video/fbcon-cfb24.h>
72 #include <video/fbcon-cfb32.h>
73 #endif
74
75 #include "sis.h"
76 #include "sis_main.h"
77
78 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
79 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,3)
80 #error "This version of sisfb requires at least 2.6.3"
81 #endif
82 #endif
83
84 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
85 #ifdef FBCON_HAS_CFB8
86 extern struct display_switch fbcon_sis8;
87 #endif
88 #ifdef FBCON_HAS_CFB16
89 extern struct display_switch fbcon_sis16;
90 #endif
91 #ifdef FBCON_HAS_CFB32
92 extern struct display_switch fbcon_sis32;
93 #endif
94 #endif
95
96 static void sisfb_handle_command(struct sis_video_info *ivideo,
97 struct sisfb_cmd *sisfb_command);
98
99 /* ------------------ Internal helper routines ----------------- */
100
101 static void __init
102 sisfb_setdefaultparms(void)
103 {
104 sisfb_off = 0;
105 sisfb_parm_mem = 0;
106 sisfb_accel = -1;
107 sisfb_ypan = -1;
108 sisfb_max = -1;
109 sisfb_userom = -1;
110 sisfb_useoem = -1;
111 #ifdef MODULE
112 /* Module: "None" for 2.4, default mode for 2.5+ */
113 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
114 sisfb_mode_idx = -1;
115 #else
116 sisfb_mode_idx = MODE_INDEX_NONE;
117 #endif
118 #else
119 /* Static: Default mode */
120 sisfb_mode_idx = -1;
121 #endif
122 sisfb_parm_rate = -1;
123 sisfb_crt1off = 0;
124 sisfb_forcecrt1 = -1;
125 sisfb_crt2type = -1;
126 sisfb_crt2flags = 0;
127 sisfb_pdc = 0xff;
128 sisfb_pdca = 0xff;
129 sisfb_scalelcd = -1;
130 sisfb_specialtiming = CUT_NONE;
131 sisfb_lvdshl = -1;
132 sisfb_dstn = 0;
133 sisfb_fstn = 0;
134 sisfb_tvplug = -1;
135 sisfb_tvstd = -1;
136 sisfb_tvxposoffset = 0;
137 sisfb_tvyposoffset = 0;
138 sisfb_nocrt2rate = 0;
139 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
140 sisfb_inverse = 0;
141 sisfb_fontname[0] = 0;
142 #endif
143 #if !defined(__i386__) && !defined(__x86_64__)
144 sisfb_resetcard = 0;
145 sisfb_videoram = 0;
146 #endif
147 }
148
149 /* ------------- Parameter parsing -------------- */
150
151 static void __devinit
152 sisfb_search_vesamode(unsigned int vesamode, BOOLEAN quiet)
153 {
154 int i = 0, j = 0;
155
156 /* We don't know the hardware specs yet and there is no ivideo */
157
158 if(vesamode == 0) {
159 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
160 sisfb_mode_idx = MODE_INDEX_NONE;
161 #else
162 if(!quiet)
163 printk(KERN_ERR "sisfb: Invalid mode. Using default.\n");
164
165 sisfb_mode_idx = DEFAULT_MODE;
166 #endif
167 return;
168 }
169
170 vesamode &= 0x1dff; /* Clean VESA mode number from other flags */
171
172 while(sisbios_mode[i++].mode_no[0] != 0) {
173 if( (sisbios_mode[i-1].vesa_mode_no_1 == vesamode) ||
174 (sisbios_mode[i-1].vesa_mode_no_2 == vesamode) ) {
175 if(sisfb_fstn) {
176 if(sisbios_mode[i-1].mode_no[1] == 0x50 ||
177 sisbios_mode[i-1].mode_no[1] == 0x56 ||
178 sisbios_mode[i-1].mode_no[1] == 0x53)
179 continue;
180 } else {
181 if(sisbios_mode[i-1].mode_no[1] == 0x5a ||
182 sisbios_mode[i-1].mode_no[1] == 0x5b)
183 continue;
184 }
185 sisfb_mode_idx = i - 1;
186 j = 1;
187 break;
188 }
189 }
190 if((!j) && !quiet)
191 printk(KERN_ERR "sisfb: Invalid VESA mode 0x%x'\n", vesamode);
192 }
193
194 static void __devinit
195 sisfb_search_mode(char *name, BOOLEAN quiet)
196 {
197 unsigned int j = 0, xres = 0, yres = 0, depth = 0, rate = 0;
198 int i = 0;
199 char strbuf[16], strbuf1[20];
200 char *nameptr = name;
201
202 /* We don't know the hardware specs yet and there is no ivideo */
203
204 if(name == NULL) {
205 if(!quiet)
206 printk(KERN_ERR "sisfb: Internal error, using default mode.\n");
207
208 sisfb_mode_idx = DEFAULT_MODE;
209 return;
210 }
211
212 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
213 if(!strnicmp(name, sisbios_mode[MODE_INDEX_NONE].name, strlen(name))) {
214 if(!quiet)
215 printk(KERN_ERR "sisfb: Mode 'none' not supported anymore. Using default.\n");
216
217 sisfb_mode_idx = DEFAULT_MODE;
218 return;
219 }
220 #endif
221 if(strlen(name) <= 19) {
222 strcpy(strbuf1, name);
223 for(i = 0; i < strlen(strbuf1); i++) {
224 if(strbuf1[i] < '0' || strbuf1[i] > '9') strbuf1[i] = ' ';
225 }
226
227 /* This does some fuzzy mode naming detection */
228 if(sscanf(strbuf1, "%u %u %u %u", &xres, &yres, &depth, &rate) == 4) {
229 if((rate <= 32) || (depth > 32)) {
230 j = rate; rate = depth; depth = j;
231 }
232 sprintf(strbuf, "%ux%ux%u", xres, yres, depth);
233 nameptr = strbuf;
234 sisfb_parm_rate = rate;
235 } else if(sscanf(strbuf1, "%u %u %u", &xres, &yres, &depth) == 3) {
236 sprintf(strbuf, "%ux%ux%u", xres, yres, depth);
237 nameptr = strbuf;
238 } else {
239 xres = 0;
240 if((sscanf(strbuf1, "%u %u", &xres, &yres) == 2) && (xres != 0)) {
241 sprintf(strbuf, "%ux%ux8", xres, yres);
242 nameptr = strbuf;
243 } else {
244 sisfb_search_vesamode(simple_strtoul(name, NULL, 0), quiet);
245 return;
246 }
247 }
248 }
249
250 i = 0; j = 0;
251 while(sisbios_mode[i].mode_no[0] != 0) {
252 if(!strnicmp(nameptr, sisbios_mode[i++].name, strlen(nameptr))) {
253 if(sisfb_fstn) {
254 if(sisbios_mode[i-1].mode_no[1] == 0x50 ||
255 sisbios_mode[i-1].mode_no[1] == 0x56 ||
256 sisbios_mode[i-1].mode_no[1] == 0x53)
257 continue;
258 } else {
259 if(sisbios_mode[i-1].mode_no[1] == 0x5a ||
260 sisbios_mode[i-1].mode_no[1] == 0x5b)
261 continue;
262 }
263 sisfb_mode_idx = i - 1;
264 j = 1;
265 break;
266 }
267 }
268
269 if((!j) && !quiet)
270 printk(KERN_ERR "sisfb: Invalid mode '%s'\n", nameptr);
271 }
272
273 #ifndef MODULE
274 static void __devinit
275 sisfb_get_vga_mode_from_kernel(void)
276 {
277 #ifdef CONFIG_X86
278 char mymode[32];
279 int mydepth = screen_info.lfb_depth;
280
281 if(screen_info.orig_video_isVGA != VIDEO_TYPE_VLFB) return;
282
283 if( (screen_info.lfb_width >= 320) && (screen_info.lfb_width <= 2048) &&
284 (screen_info.lfb_height >= 200) && (screen_info.lfb_height <= 1536) &&
285 (mydepth >= 8) && (mydepth <= 32) ) {
286
287 if(mydepth == 24) mydepth = 32;
288
289 sprintf(mymode, "%ux%ux%u", screen_info.lfb_width,
290 screen_info.lfb_height,
291 mydepth);
292
293 printk(KERN_DEBUG
294 "sisfb: Using vga mode %s pre-set by kernel as default\n",
295 mymode);
296
297 sisfb_search_mode(mymode, TRUE);
298 }
299 #endif
300 return;
301 }
302 #endif
303
304 static void __init
305 sisfb_search_crt2type(const char *name)
306 {
307 int i = 0;
308
309 /* We don't know the hardware specs yet and there is no ivideo */
310
311 if(name == NULL) return;
312
313 while(sis_crt2type[i].type_no != -1) {
314 if(!strnicmp(name, sis_crt2type[i].name, strlen(sis_crt2type[i].name))) {
315 sisfb_crt2type = sis_crt2type[i].type_no;
316 sisfb_tvplug = sis_crt2type[i].tvplug_no;
317 sisfb_crt2flags = sis_crt2type[i].flags;
318 break;
319 }
320 i++;
321 }
322
323 sisfb_dstn = (sisfb_crt2flags & FL_550_DSTN) ? 1 : 0;
324 sisfb_fstn = (sisfb_crt2flags & FL_550_FSTN) ? 1 : 0;
325
326 if(sisfb_crt2type < 0)
327 printk(KERN_ERR "sisfb: Invalid CRT2 type: %s\n", name);
328 }
329
330 static void __init
331 sisfb_search_tvstd(const char *name)
332 {
333 int i = 0;
334
335 /* We don't know the hardware specs yet and there is no ivideo */
336
337 if(name == NULL)
338 return;
339
340 while(sis_tvtype[i].type_no != -1) {
341 if(!strnicmp(name, sis_tvtype[i].name, strlen(sis_tvtype[i].name))) {
342 sisfb_tvstd = sis_tvtype[i].type_no;
343 break;
344 }
345 i++;
346 }
347 }
348
349 static void __init
350 sisfb_search_specialtiming(const char *name)
351 {
352 int i = 0;
353 BOOLEAN found = FALSE;
354
355 /* We don't know the hardware specs yet and there is no ivideo */
356
357 if(name == NULL)
358 return;
359
360 if(!strnicmp(name, "none", 4)) {
361 sisfb_specialtiming = CUT_FORCENONE;
362 printk(KERN_DEBUG "sisfb: Special timing disabled\n");
363 } else {
364 while(mycustomttable[i].chipID != 0) {
365 if(!strnicmp(name,mycustomttable[i].optionName,
366 strlen(mycustomttable[i].optionName))) {
367 sisfb_specialtiming = mycustomttable[i].SpecialID;
368 found = TRUE;
369 printk(KERN_INFO "sisfb: Special timing for %s %s forced (\"%s\")\n",
370 mycustomttable[i].vendorName,
371 mycustomttable[i].cardName,
372 mycustomttable[i].optionName);
373 break;
374 }
375 i++;
376 }
377 if(!found) {
378 printk(KERN_WARNING "sisfb: Invalid SpecialTiming parameter, valid are:");
379 printk(KERN_WARNING "\t\"none\" (to disable special timings)\n");
380 i = 0;
381 while(mycustomttable[i].chipID != 0) {
382 printk(KERN_WARNING "\t\"%s\" (for %s %s)\n",
383 mycustomttable[i].optionName,
384 mycustomttable[i].vendorName,
385 mycustomttable[i].cardName);
386 i++;
387 }
388 }
389 }
390 }
391
392 /* ----------- Various detection routines ----------- */
393
394 static void __devinit
395 sisfb_detect_custom_timing(struct sis_video_info *ivideo)
396 {
397 unsigned char *biosver = NULL;
398 unsigned char *biosdate = NULL;
399 BOOLEAN footprint;
400 u32 chksum = 0;
401 int i, j;
402
403 if(ivideo->SiS_Pr.UseROM) {
404 biosver = ivideo->SiS_Pr.VirtualRomBase + 0x06;
405 biosdate = ivideo->SiS_Pr.VirtualRomBase + 0x2c;
406 for(i = 0; i < 32768; i++)
407 chksum += ivideo->SiS_Pr.VirtualRomBase[i];
408 }
409
410 i = 0;
411 do {
412 if( (mycustomttable[i].chipID == ivideo->chip) &&
413 ((!strlen(mycustomttable[i].biosversion)) ||
414 (ivideo->SiS_Pr.UseROM &&
415 (!strncmp(mycustomttable[i].biosversion, biosver,
416 strlen(mycustomttable[i].biosversion))))) &&
417 ((!strlen(mycustomttable[i].biosdate)) ||
418 (ivideo->SiS_Pr.UseROM &&
419 (!strncmp(mycustomttable[i].biosdate, biosdate,
420 strlen(mycustomttable[i].biosdate))))) &&
421 ((!mycustomttable[i].bioschksum) ||
422 (ivideo->SiS_Pr.UseROM &&
423 (mycustomttable[i].bioschksum == chksum))) &&
424 (mycustomttable[i].pcisubsysvendor == ivideo->subsysvendor) &&
425 (mycustomttable[i].pcisubsyscard == ivideo->subsysdevice) ) {
426 footprint = TRUE;
427 for(j = 0; j < 5; j++) {
428 if(mycustomttable[i].biosFootprintAddr[j]) {
429 if(ivideo->SiS_Pr.UseROM) {
430 if(ivideo->SiS_Pr.VirtualRomBase[mycustomttable[i].biosFootprintAddr[j]] !=
431 mycustomttable[i].biosFootprintData[j]) {
432 footprint = FALSE;
433 }
434 } else
435 footprint = FALSE;
436 }
437 }
438 if(footprint) {
439 ivideo->SiS_Pr.SiS_CustomT = mycustomttable[i].SpecialID;
440 printk(KERN_DEBUG "sisfb: Identified [%s %s], special timing applies\n",
441 mycustomttable[i].vendorName,
442 mycustomttable[i].cardName);
443 printk(KERN_DEBUG "sisfb: [specialtiming parameter name: %s]\n",
444 mycustomttable[i].optionName);
445 break;
446 }
447 }
448 i++;
449 } while(mycustomttable[i].chipID);
450 }
451
452 static BOOLEAN __devinit
453 sisfb_interpret_edid(struct sisfb_monitor *monitor, u8 *buffer)
454 {
455 int i, j, xres, yres, refresh, index;
456 u32 emodes;
457
458 if(buffer[0] != 0x00 || buffer[1] != 0xff ||
459 buffer[2] != 0xff || buffer[3] != 0xff ||
460 buffer[4] != 0xff || buffer[5] != 0xff ||
461 buffer[6] != 0xff || buffer[7] != 0x00) {
462 printk(KERN_DEBUG "sisfb: Bad EDID header\n");
463 return FALSE;
464 }
465
466 if(buffer[0x12] != 0x01) {
467 printk(KERN_INFO "sisfb: EDID version %d not supported\n",
468 buffer[0x12]);
469 return FALSE;
470 }
471
472 monitor->feature = buffer[0x18];
473
474 if(!buffer[0x14] & 0x80) {
475 if(!(buffer[0x14] & 0x08)) {
476 printk(KERN_INFO
477 "sisfb: WARNING: Monitor does not support separate syncs\n");
478 }
479 }
480
481 if(buffer[0x13] >= 0x01) {
482 /* EDID V1 rev 1 and 2: Search for monitor descriptor
483 * to extract ranges
484 */
485 j = 0x36;
486 for(i=0; i<4; i++) {
487 if(buffer[j] == 0x00 && buffer[j + 1] == 0x00 &&
488 buffer[j + 2] == 0x00 && buffer[j + 3] == 0xfd &&
489 buffer[j + 4] == 0x00) {
490 monitor->hmin = buffer[j + 7];
491 monitor->hmax = buffer[j + 8];
492 monitor->vmin = buffer[j + 5];
493 monitor->vmax = buffer[j + 6];
494 monitor->dclockmax = buffer[j + 9] * 10 * 1000;
495 monitor->datavalid = TRUE;
496 break;
497 }
498 j += 18;
499 }
500 }
501
502 if(!monitor->datavalid) {
503 /* Otherwise: Get a range from the list of supported
504 * Estabished Timings. This is not entirely accurate,
505 * because fixed frequency monitors are not supported
506 * that way.
507 */
508 monitor->hmin = 65535; monitor->hmax = 0;
509 monitor->vmin = 65535; monitor->vmax = 0;
510 monitor->dclockmax = 0;
511 emodes = buffer[0x23] | (buffer[0x24] << 8) | (buffer[0x25] << 16);
512 for(i = 0; i < 13; i++) {
513 if(emodes & sisfb_ddcsmodes[i].mask) {
514 if(monitor->hmin > sisfb_ddcsmodes[i].h) monitor->hmin = sisfb_ddcsmodes[i].h;
515 if(monitor->hmax < sisfb_ddcsmodes[i].h) monitor->hmax = sisfb_ddcsmodes[i].h + 1;
516 if(monitor->vmin > sisfb_ddcsmodes[i].v) monitor->vmin = sisfb_ddcsmodes[i].v;
517 if(monitor->vmax < sisfb_ddcsmodes[i].v) monitor->vmax = sisfb_ddcsmodes[i].v;
518 if(monitor->dclockmax < sisfb_ddcsmodes[i].d) monitor->dclockmax = sisfb_ddcsmodes[i].d;
519 }
520 }
521 index = 0x26;
522 for(i = 0; i < 8; i++) {
523 xres = (buffer[index] + 31) * 8;
524 switch(buffer[index + 1] & 0xc0) {
525 case 0xc0: yres = (xres * 9) / 16; break;
526 case 0x80: yres = (xres * 4) / 5; break;
527 case 0x40: yres = (xres * 3) / 4; break;
528 default: yres = xres; break;
529 }
530 refresh = (buffer[index + 1] & 0x3f) + 60;
531 if((xres >= 640) && (yres >= 480)) {
532 for(j = 0; j < 8; j++) {
533 if((xres == sisfb_ddcfmodes[j].x) &&
534 (yres == sisfb_ddcfmodes[j].y) &&
535 (refresh == sisfb_ddcfmodes[j].v)) {
536 if(monitor->hmin > sisfb_ddcfmodes[j].h) monitor->hmin = sisfb_ddcfmodes[j].h;
537 if(monitor->hmax < sisfb_ddcfmodes[j].h) monitor->hmax = sisfb_ddcfmodes[j].h + 1;
538 if(monitor->vmin > sisfb_ddcsmodes[j].v) monitor->vmin = sisfb_ddcsmodes[j].v;
539 if(monitor->vmax < sisfb_ddcsmodes[j].v) monitor->vmax = sisfb_ddcsmodes[j].v;
540 if(monitor->dclockmax < sisfb_ddcsmodes[j].d) monitor->dclockmax = sisfb_ddcsmodes[j].d;
541 }
542 }
543 }
544 index += 2;
545 }
546 if((monitor->hmin <= monitor->hmax) && (monitor->vmin <= monitor->vmax)) {
547 monitor->datavalid = TRUE;
548 }
549 }
550
551 return monitor->datavalid;
552 }
553
554 static void __devinit
555 sisfb_handle_ddc(struct sis_video_info *ivideo, struct sisfb_monitor *monitor, int crtno)
556 {
557 unsigned short temp, i, realcrtno = crtno;
558 unsigned char buffer[256];
559
560 monitor->datavalid = FALSE;
561
562 if(crtno) {
563 if(ivideo->vbflags & CRT2_LCD) realcrtno = 1;
564 else if(ivideo->vbflags & CRT2_VGA) realcrtno = 2;
565 else return;
566 }
567
568 if((ivideo->sisfb_crt1off) && (!crtno))
569 return;
570
571 temp = SiS_HandleDDC(&ivideo->SiS_Pr, ivideo->vbflags, ivideo->sisvga_engine,
572 realcrtno, 0, &buffer[0], ivideo->vbflags2);
573 if((!temp) || (temp == 0xffff)) {
574 printk(KERN_INFO "sisfb: CRT%d DDC probing failed\n", crtno + 1);
575 return;
576 } else {
577 printk(KERN_INFO "sisfb: CRT%d DDC supported\n", crtno + 1);
578 printk(KERN_INFO "sisfb: CRT%d DDC level: %s%s%s%s\n",
579 crtno + 1,
580 (temp & 0x1a) ? "" : "[none of the supported]",
581 (temp & 0x02) ? "2 " : "",
582 (temp & 0x08) ? "D&P" : "",
583 (temp & 0x10) ? "FPDI-2" : "");
584 if(temp & 0x02) {
585 i = 3; /* Number of retrys */
586 do {
587 temp = SiS_HandleDDC(&ivideo->SiS_Pr, ivideo->vbflags, ivideo->sisvga_engine,
588 realcrtno, 1, &buffer[0], ivideo->vbflags2);
589 } while((temp) && i--);
590 if(!temp) {
591 if(sisfb_interpret_edid(monitor, &buffer[0])) {
592 printk(KERN_INFO "sisfb: Monitor range H %d-%dKHz, V %d-%dHz, Max. dotclock %dMHz\n",
593 monitor->hmin, monitor->hmax, monitor->vmin, monitor->vmax,
594 monitor->dclockmax / 1000);
595 } else {
596 printk(KERN_INFO "sisfb: CRT%d DDC EDID corrupt\n", crtno + 1);
597 }
598 } else {
599 printk(KERN_INFO "sisfb: CRT%d DDC reading failed\n", crtno + 1);
600 }
601 } else {
602 printk(KERN_INFO "sisfb: VESA D&P and FPDI-2 not supported yet\n");
603 }
604 }
605 }
606
607 /* -------------- Mode validation --------------- */
608
609 static BOOLEAN
610 sisfb_verify_rate(struct sis_video_info *ivideo, struct sisfb_monitor *monitor,
611 int mode_idx, int rate_idx, int rate)
612 {
613 int htotal, vtotal;
614 unsigned int dclock, hsync;
615
616 if(!monitor->datavalid)
617 return TRUE;
618
619 if(mode_idx < 0)
620 return FALSE;
621
622 /* Skip for 320x200, 320x240, 640x400 */
623 switch(sisbios_mode[mode_idx].mode_no[ivideo->mni]) {
624 case 0x59:
625 case 0x41:
626 case 0x4f:
627 case 0x50:
628 case 0x56:
629 case 0x53:
630 case 0x2f:
631 case 0x5d:
632 case 0x5e:
633 return TRUE;
634 #ifdef CONFIG_FB_SIS_315
635 case 0x5a:
636 case 0x5b:
637 if(ivideo->sisvga_engine == SIS_315_VGA) return TRUE;
638 #endif
639 }
640
641 if(rate < (monitor->vmin - 1))
642 return FALSE;
643 if(rate > (monitor->vmax + 1))
644 return FALSE;
645
646 if(sisfb_gettotalfrommode(&ivideo->SiS_Pr,
647 sisbios_mode[mode_idx].mode_no[ivideo->mni],
648 &htotal, &vtotal, rate_idx)) {
649 dclock = (htotal * vtotal * rate) / 1000;
650 if(dclock > (monitor->dclockmax + 1000))
651 return FALSE;
652 hsync = dclock / htotal;
653 if(hsync < (monitor->hmin - 1))
654 return FALSE;
655 if(hsync > (monitor->hmax + 1))
656 return FALSE;
657 } else {
658 return FALSE;
659 }
660 return TRUE;
661 }
662
663 static int
664 sisfb_validate_mode(struct sis_video_info *ivideo, int myindex, u32 vbflags)
665 {
666 u16 xres=0, yres, myres;
667
668 #ifdef CONFIG_FB_SIS_300
669 if(ivideo->sisvga_engine == SIS_300_VGA) {
670 if(!(sisbios_mode[myindex].chipset & MD_SIS300))
671 return -1 ;
672 }
673 #endif
674 #ifdef CONFIG_FB_SIS_315
675 if(ivideo->sisvga_engine == SIS_315_VGA) {
676 if(!(sisbios_mode[myindex].chipset & MD_SIS315))
677 return -1;
678 }
679 #endif
680
681 myres = sisbios_mode[myindex].yres;
682
683 switch(vbflags & VB_DISPTYPE_DISP2) {
684
685 case CRT2_LCD:
686 xres = ivideo->lcdxres; yres = ivideo->lcdyres;
687
688 if((ivideo->SiS_Pr.SiS_CustomT != CUT_PANEL848) &&
689 (ivideo->SiS_Pr.SiS_CustomT != CUT_PANEL856)) {
690 if(sisbios_mode[myindex].xres > xres)
691 return -1;
692 if(myres > yres)
693 return -1;
694 }
695
696 if(ivideo->sisfb_fstn) {
697 if(sisbios_mode[myindex].xres == 320) {
698 if(myres == 240) {
699 switch(sisbios_mode[myindex].mode_no[1]) {
700 case 0x50: myindex = MODE_FSTN_8; break;
701 case 0x56: myindex = MODE_FSTN_16; break;
702 case 0x53: return -1;
703 }
704 }
705 }
706 }
707
708 if(SiS_GetModeID_LCD(ivideo->sisvga_engine, vbflags, sisbios_mode[myindex].xres,
709 sisbios_mode[myindex].yres, 0, ivideo->sisfb_fstn,
710 ivideo->SiS_Pr.SiS_CustomT, xres, yres, ivideo->vbflags2) < 0x14) {
711 return -1;
712 }
713 break;
714
715 case CRT2_TV:
716 if(SiS_GetModeID_TV(ivideo->sisvga_engine, vbflags, sisbios_mode[myindex].xres,
717 sisbios_mode[myindex].yres, 0, ivideo->vbflags2) < 0x14) {
718 return -1;
719 }
720 break;
721
722 case CRT2_VGA:
723 if(SiS_GetModeID_VGA2(ivideo->sisvga_engine, vbflags, sisbios_mode[myindex].xres,
724 sisbios_mode[myindex].yres, 0, ivideo->vbflags2) < 0x14) {
725 return -1;
726 }
727 break;
728 }
729
730 return myindex;
731 }
732
733 static u8
734 sisfb_search_refresh_rate(struct sis_video_info *ivideo, unsigned int rate, int mode_idx)
735 {
736 int i = 0;
737 u16 xres = sisbios_mode[mode_idx].xres;
738 u16 yres = sisbios_mode[mode_idx].yres;
739
740 ivideo->rate_idx = 0;
741 while((sisfb_vrate[i].idx != 0) && (sisfb_vrate[i].xres <= xres)) {
742 if((sisfb_vrate[i].xres == xres) && (sisfb_vrate[i].yres == yres)) {
743 if(sisfb_vrate[i].refresh == rate) {
744 ivideo->rate_idx = sisfb_vrate[i].idx;
745 break;
746 } else if(sisfb_vrate[i].refresh > rate) {
747 if((sisfb_vrate[i].refresh - rate) <= 3) {
748 DPRINTK("sisfb: Adjusting rate from %d up to %d\n",
749 rate, sisfb_vrate[i].refresh);
750 ivideo->rate_idx = sisfb_vrate[i].idx;
751 ivideo->refresh_rate = sisfb_vrate[i].refresh;
752 } else if(((rate - sisfb_vrate[i-1].refresh) <= 2)
753 && (sisfb_vrate[i].idx != 1)) {
754 DPRINTK("sisfb: Adjusting rate from %d down to %d\n",
755 rate, sisfb_vrate[i-1].refresh);
756 ivideo->rate_idx = sisfb_vrate[i-1].idx;
757 ivideo->refresh_rate = sisfb_vrate[i-1].refresh;
758 }
759 break;
760 } else if((rate - sisfb_vrate[i].refresh) <= 2) {
761 DPRINTK("sisfb: Adjusting rate from %d down to %d\n",
762 rate, sisfb_vrate[i].refresh);
763 ivideo->rate_idx = sisfb_vrate[i].idx;
764 break;
765 }
766 }
767 i++;
768 }
769 if(ivideo->rate_idx > 0) {
770 return ivideo->rate_idx;
771 } else {
772 printk(KERN_INFO "sisfb: Unsupported rate %d for %dx%d\n",
773 rate, xres, yres);
774 return 0;
775 }
776 }
777
778 static BOOLEAN
779 sisfb_bridgeisslave(struct sis_video_info *ivideo)
780 {
781 unsigned char P1_00;
782
783 if(!(ivideo->vbflags2 & VB2_VIDEOBRIDGE))
784 return FALSE;
785
786 inSISIDXREG(SISPART1,0x00,P1_00);
787 if( ((ivideo->sisvga_engine == SIS_300_VGA) && (P1_00 & 0xa0) == 0x20) ||
788 ((ivideo->sisvga_engine == SIS_315_VGA) && (P1_00 & 0x50) == 0x10) ) {
789 return TRUE;
790 } else {
791 return FALSE;
792 }
793 }
794
795 static BOOLEAN
796 sisfballowretracecrt1(struct sis_video_info *ivideo)
797 {
798 u8 temp;
799
800 inSISIDXREG(SISCR,0x17,temp);
801 if(!(temp & 0x80))
802 return FALSE;
803
804 inSISIDXREG(SISSR,0x1f,temp);
805 if(temp & 0xc0)
806 return FALSE;
807
808 return TRUE;
809 }
810
811 static BOOLEAN
812 sisfbcheckvretracecrt1(struct sis_video_info *ivideo)
813 {
814 if(!sisfballowretracecrt1(ivideo))
815 return FALSE;
816
817 if(inSISREG(SISINPSTAT) & 0x08)
818 return TRUE;
819 else
820 return FALSE;
821 }
822
823 static void
824 sisfbwaitretracecrt1(struct sis_video_info *ivideo)
825 {
826 int watchdog;
827
828 if(!sisfballowretracecrt1(ivideo))
829 return;
830
831 watchdog = 65536;
832 while((!(inSISREG(SISINPSTAT) & 0x08)) && --watchdog);
833 watchdog = 65536;
834 while((inSISREG(SISINPSTAT) & 0x08) && --watchdog);
835 }
836
837 static BOOLEAN
838 sisfbcheckvretracecrt2(struct sis_video_info *ivideo)
839 {
840 unsigned char temp, reg;
841
842 switch(ivideo->sisvga_engine) {
843 case SIS_300_VGA: reg = 0x25; break;
844 case SIS_315_VGA: reg = 0x30; break;
845 default: return FALSE;
846 }
847
848 inSISIDXREG(SISPART1, reg, temp);
849 if(temp & 0x02)
850 return TRUE;
851 else
852 return FALSE;
853 }
854
855 static BOOLEAN
856 sisfb_CheckVBRetrace(struct sis_video_info *ivideo)
857 {
858 if(ivideo->currentvbflags & VB_DISPTYPE_DISP2) {
859 if(!sisfb_bridgeisslave(ivideo)) {
860 return sisfbcheckvretracecrt2(ivideo);
861 }
862 }
863 return sisfbcheckvretracecrt1(ivideo);
864 }
865
866 static u32
867 sisfb_setupvbblankflags(struct sis_video_info *ivideo, u32 *vcount, u32 *hcount)
868 {
869 u8 idx, reg1, reg2, reg3, reg4;
870 u32 ret = 0;
871
872 (*vcount) = (*hcount) = 0;
873
874 if((ivideo->currentvbflags & VB_DISPTYPE_DISP2) && (!(sisfb_bridgeisslave(ivideo)))) {
875
876 ret |= (FB_VBLANK_HAVE_VSYNC |
877 FB_VBLANK_HAVE_HBLANK |
878 FB_VBLANK_HAVE_VBLANK |
879 FB_VBLANK_HAVE_VCOUNT |
880 FB_VBLANK_HAVE_HCOUNT);
881 switch(ivideo->sisvga_engine) {
882 case SIS_300_VGA: idx = 0x25; break;
883 default:
884 case SIS_315_VGA: idx = 0x30; break;
885 }
886 inSISIDXREG(SISPART1,(idx+0),reg1); /* 30 */
887 inSISIDXREG(SISPART1,(idx+1),reg2); /* 31 */
888 inSISIDXREG(SISPART1,(idx+2),reg3); /* 32 */
889 inSISIDXREG(SISPART1,(idx+3),reg4); /* 33 */
890 if(reg1 & 0x01) ret |= FB_VBLANK_VBLANKING;
891 if(reg1 & 0x02) ret |= FB_VBLANK_VSYNCING;
892 if(reg4 & 0x80) ret |= FB_VBLANK_HBLANKING;
893 (*vcount) = reg3 | ((reg4 & 0x70) << 4);
894 (*hcount) = reg2 | ((reg4 & 0x0f) << 8);
895
896 } else if(sisfballowretracecrt1(ivideo)) {
897
898 ret |= (FB_VBLANK_HAVE_VSYNC |
899 FB_VBLANK_HAVE_VBLANK |
900 FB_VBLANK_HAVE_VCOUNT |
901 FB_VBLANK_HAVE_HCOUNT);
902 reg1 = inSISREG(SISINPSTAT);
903 if(reg1 & 0x08) ret |= FB_VBLANK_VSYNCING;
904 if(reg1 & 0x01) ret |= FB_VBLANK_VBLANKING;
905 inSISIDXREG(SISCR,0x20,reg1);
906 inSISIDXREG(SISCR,0x1b,reg1);
907 inSISIDXREG(SISCR,0x1c,reg2);
908 inSISIDXREG(SISCR,0x1d,reg3);
909 (*vcount) = reg2 | ((reg3 & 0x07) << 8);
910 (*hcount) = (reg1 | ((reg3 & 0x10) << 4)) << 3;
911 }
912
913 return ret;
914 }
915
916 static int
917 sisfb_myblank(struct sis_video_info *ivideo, int blank)
918 {
919 u8 sr01, sr11, sr1f, cr63=0, p2_0, p1_13;
920 BOOLEAN backlight = TRUE;
921
922 switch(blank) {
923 case FB_BLANK_UNBLANK: /* on */
924 sr01 = 0x00;
925 sr11 = 0x00;
926 sr1f = 0x00;
927 cr63 = 0x00;
928 p2_0 = 0x20;
929 p1_13 = 0x00;
930 backlight = TRUE;
931 break;
932 case FB_BLANK_NORMAL: /* blank */
933 sr01 = 0x20;
934 sr11 = 0x00;
935 sr1f = 0x00;
936 cr63 = 0x00;
937 p2_0 = 0x20;
938 p1_13 = 0x00;
939 backlight = TRUE;
940 break;
941 case FB_BLANK_VSYNC_SUSPEND: /* no vsync */
942 sr01 = 0x20;
943 sr11 = 0x08;
944 sr1f = 0x80;
945 cr63 = 0x40;
946 p2_0 = 0x40;
947 p1_13 = 0x80;
948 backlight = FALSE;
949 break;
950 case FB_BLANK_HSYNC_SUSPEND: /* no hsync */
951 sr01 = 0x20;
952 sr11 = 0x08;
953 sr1f = 0x40;
954 cr63 = 0x40;
955 p2_0 = 0x80;
956 p1_13 = 0x40;
957 backlight = FALSE;
958 break;
959 case FB_BLANK_POWERDOWN: /* off */
960 sr01 = 0x20;
961 sr11 = 0x08;
962 sr1f = 0xc0;
963 cr63 = 0x40;
964 p2_0 = 0xc0;
965 p1_13 = 0xc0;
966 backlight = FALSE;
967 break;
968 default:
969 return 1;
970 }
971
972 if(ivideo->currentvbflags & VB_DISPTYPE_CRT1) {
973
974 if( (!ivideo->sisfb_thismonitor.datavalid) ||
975 ((ivideo->sisfb_thismonitor.datavalid) &&
976 (ivideo->sisfb_thismonitor.feature & 0xe0))) {
977
978 if(ivideo->sisvga_engine == SIS_315_VGA) {
979 setSISIDXREG(SISCR, ivideo->SiS_Pr.SiS_MyCR63, 0xbf, cr63);
980 }
981
982 if(!(sisfb_bridgeisslave(ivideo))) {
983 setSISIDXREG(SISSR, 0x01, ~0x20, sr01);
984 setSISIDXREG(SISSR, 0x1f, 0x3f, sr1f);
985 }
986 }
987
988 }
989
990 if(ivideo->currentvbflags & CRT2_LCD) {
991
992 if(ivideo->vbflags2 & VB2_SISLVDSBRIDGE) {
993 if(backlight) {
994 SiS_SiS30xBLOn(&ivideo->SiS_Pr);
995 } else {
996 SiS_SiS30xBLOff(&ivideo->SiS_Pr);
997 }
998 } else if(ivideo->sisvga_engine == SIS_315_VGA) {
999 #ifdef CONFIG_FB_SIS_315
1000 if(ivideo->vbflags2 & VB2_CHRONTEL) {
1001 if(backlight) {
1002 SiS_Chrontel701xBLOn(&ivideo->SiS_Pr);
1003 } else {
1004 SiS_Chrontel701xBLOff(&ivideo->SiS_Pr);
1005 }
1006 }
1007 #endif
1008 }
1009
1010 if(((ivideo->sisvga_engine == SIS_300_VGA) &&
1011 (ivideo->vbflags2 & (VB2_301|VB2_30xBDH|VB2_LVDS))) ||
1012 ((ivideo->sisvga_engine == SIS_315_VGA) &&
1013 ((ivideo->vbflags2 & (VB2_LVDS | VB2_CHRONTEL)) == VB2_LVDS))) {
1014 setSISIDXREG(SISSR, 0x11, ~0x0c, sr11);
1015 }
1016
1017 if(ivideo->sisvga_engine == SIS_300_VGA) {
1018 if((ivideo->vbflags2 & VB2_30xB) &&
1019 (!(ivideo->vbflags2 & VB2_30xBDH))) {
1020 setSISIDXREG(SISPART1, 0x13, 0x3f, p1_13);
1021 }
1022 } else if(ivideo->sisvga_engine == SIS_315_VGA) {
1023 if((ivideo->vbflags2 & VB2_30xB) &&
1024 (!(ivideo->vbflags2 & VB2_30xBDH))) {
1025 setSISIDXREG(SISPART2, 0x00, 0x1f, p2_0);
1026 }
1027 }
1028
1029 } else if(ivideo->currentvbflags & CRT2_VGA) {
1030
1031 if(ivideo->vbflags2 & VB2_30xB) {
1032 setSISIDXREG(SISPART2, 0x00, 0x1f, p2_0);
1033 }
1034
1035 }
1036
1037 return 0;
1038 }
1039
1040 /* ------------- Callbacks from init.c/init301.c -------------- */
1041
1042 #ifdef CONFIG_FB_SIS_300
1043 unsigned int
1044 sisfb_read_nbridge_pci_dword(struct SiS_Private *SiS_Pr, int reg)
1045 {
1046 struct sis_video_info *ivideo = (struct sis_video_info *)SiS_Pr->ivideo;
1047 u32 val = 0;
1048
1049 pci_read_config_dword(ivideo->nbridge, reg, &val);
1050 return (unsigned int)val;
1051 }
1052
1053 void
1054 sisfb_write_nbridge_pci_dword(struct SiS_Private *SiS_Pr, int reg, unsigned int val)
1055 {
1056 struct sis_video_info *ivideo = (struct sis_video_info *)SiS_Pr->ivideo;
1057
1058 pci_write_config_dword(ivideo->nbridge, reg, (u32)val);
1059 }
1060
1061 unsigned int
1062 sisfb_read_lpc_pci_dword(struct SiS_Private *SiS_Pr, int reg)
1063 {
1064 struct sis_video_info *ivideo = (struct sis_video_info *)SiS_Pr->ivideo;
1065 u32 val = 0;
1066
1067 if(!ivideo->lpcdev) return 0;
1068
1069 pci_read_config_dword(ivideo->lpcdev, reg, &val);
1070 return (unsigned int)val;
1071 }
1072 #endif
1073
1074 #ifdef CONFIG_FB_SIS_315
1075 void
1076 sisfb_write_nbridge_pci_byte(struct SiS_Private *SiS_Pr, int reg, unsigned char val)
1077 {
1078 struct sis_video_info *ivideo = (struct sis_video_info *)SiS_Pr->ivideo;
1079
1080 pci_write_config_byte(ivideo->nbridge, reg, (u8)val);
1081 }
1082
1083 unsigned int
1084 sisfb_read_mio_pci_word(struct SiS_Private *SiS_Pr, int reg)
1085 {
1086 struct sis_video_info *ivideo = (struct sis_video_info *)SiS_Pr->ivideo;
1087 u16 val = 0;
1088
1089 if(!ivideo->lpcdev) return 0;
1090
1091 pci_read_config_word(ivideo->lpcdev, reg, &val);
1092 return (unsigned int)val;
1093 }
1094 #endif
1095
1096 /* ----------- FBDev related routines for all series ----------- */
1097
1098 static int
1099 sisfb_get_cmap_len(const struct fb_var_screeninfo *var)
1100 {
1101 return (var->bits_per_pixel == 8) ? 256 : 16;
1102 }
1103
1104 static void
1105 sisfb_set_vparms(struct sis_video_info *ivideo)
1106 {
1107 switch(ivideo->video_bpp) {
1108 case 8:
1109 ivideo->DstColor = 0x0000;
1110 ivideo->SiS310_AccelDepth = 0x00000000;
1111 ivideo->video_cmap_len = 256;
1112 break;
1113 case 16:
1114 ivideo->DstColor = 0x8000;
1115 ivideo->SiS310_AccelDepth = 0x00010000;
1116 ivideo->video_cmap_len = 16;
1117 break;
1118 case 32:
1119 ivideo->DstColor = 0xC000;
1120 ivideo->SiS310_AccelDepth = 0x00020000;
1121 ivideo->video_cmap_len = 16;
1122 break;
1123 default:
1124 ivideo->video_cmap_len = 16;
1125 printk(KERN_ERR "sisfb: Unsupported depth %d", ivideo->video_bpp);
1126 ivideo->accel = 0;
1127 }
1128 }
1129
1130 static int
1131 sisfb_calc_maxyres(struct sis_video_info *ivideo, struct fb_var_screeninfo *var)
1132 {
1133 int maxyres = ivideo->sisfb_mem / (var->xres_virtual * (var->bits_per_pixel >> 3));
1134
1135 if(maxyres > 32767) maxyres = 32767;
1136
1137 return maxyres;
1138 }
1139
1140 static void
1141 sisfb_calc_pitch(struct sis_video_info *ivideo, struct fb_var_screeninfo *var)
1142 {
1143 ivideo->video_linelength = var->xres_virtual * (var->bits_per_pixel >> 3);
1144 ivideo->scrnpitchCRT1 = ivideo->video_linelength;
1145 if(!(ivideo->currentvbflags & CRT1_LCDA)) {
1146 if((var->vmode & FB_VMODE_MASK) == FB_VMODE_INTERLACED) {
1147 ivideo->scrnpitchCRT1 <<= 1;
1148 }
1149 }
1150 }
1151
1152 static void
1153 sisfb_set_pitch(struct sis_video_info *ivideo)
1154 {
1155 BOOLEAN isslavemode = FALSE;
1156 unsigned short HDisplay1 = ivideo->scrnpitchCRT1 >> 3;
1157 unsigned short HDisplay2 = ivideo->video_linelength >> 3;
1158
1159 if(sisfb_bridgeisslave(ivideo)) isslavemode = TRUE;
1160
1161 /* We need to set pitch for CRT1 if bridge is in slave mode, too */
1162 if((ivideo->currentvbflags & VB_DISPTYPE_DISP1) || (isslavemode)) {
1163 outSISIDXREG(SISCR,0x13,(HDisplay1 & 0xFF));
1164 setSISIDXREG(SISSR,0x0E,0xF0,(HDisplay1 >> 8));
1165 }
1166
1167 /* We must not set the pitch for CRT2 if bridge is in slave mode */
1168 if((ivideo->currentvbflags & VB_DISPTYPE_DISP2) && (!isslavemode)) {
1169 orSISIDXREG(SISPART1,ivideo->CRT2_write_enable,0x01);
1170 outSISIDXREG(SISPART1,0x07,(HDisplay2 & 0xFF));
1171 setSISIDXREG(SISPART1,0x09,0xF0,(HDisplay2 >> 8));
1172 }
1173 }
1174
1175 static void
1176 sisfb_bpp_to_var(struct sis_video_info *ivideo, struct fb_var_screeninfo *var)
1177 {
1178 ivideo->video_cmap_len = sisfb_get_cmap_len(var);
1179
1180 switch(var->bits_per_pixel) {
1181 case 8:
1182 var->red.offset = var->green.offset = var->blue.offset = 0;
1183 var->red.length = var->green.length = var->blue.length = 6;
1184 break;
1185 case 16:
1186 var->red.offset = 11;
1187 var->red.length = 5;
1188 var->green.offset = 5;
1189 var->green.length = 6;
1190 var->blue.offset = 0;
1191 var->blue.length = 5;
1192 var->transp.offset = 0;
1193 var->transp.length = 0;
1194 break;
1195 case 32:
1196 var->red.offset = 16;
1197 var->red.length = 8;
1198 var->green.offset = 8;
1199 var->green.length = 8;
1200 var->blue.offset = 0;
1201 var->blue.length = 8;
1202 var->transp.offset = 24;
1203 var->transp.length = 8;
1204 break;
1205 }
1206 }
1207
1208 static int
1209 sisfb_set_mode(struct sis_video_info *ivideo, int clrscrn)
1210 {
1211 unsigned short modeno = ivideo->mode_no;
1212
1213 /* >=2.6.12's fbcon clears the screen anyway */
1214 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,12)
1215 if(!clrscrn) modeno |= 0x80;
1216 #else
1217 modeno |= 0x80;
1218 #endif
1219
1220 outSISIDXREG(SISSR, IND_SIS_PASSWORD, SIS_PASSWORD);
1221
1222 sisfb_pre_setmode(ivideo);
1223
1224 if(SiSSetMode(&ivideo->SiS_Pr, modeno) == 0) {
1225 printk(KERN_ERR "sisfb: Setting mode[0x%x] failed\n", ivideo->mode_no);
1226 return -EINVAL;
1227 }
1228
1229 outSISIDXREG(SISSR, IND_SIS_PASSWORD, SIS_PASSWORD);
1230
1231 sisfb_post_setmode(ivideo);
1232
1233 return 0;
1234 }
1235
1236
1237 static int
1238 sisfb_do_set_var(struct fb_var_screeninfo *var, int isactive, struct fb_info *info)
1239 {
1240 struct sis_video_info *ivideo = (struct sis_video_info *)info->par;
1241 unsigned int htotal = 0, vtotal = 0;
1242 unsigned int drate = 0, hrate = 0;
1243 int found_mode = 0, ret;
1244 int old_mode;
1245 u32 pixclock;
1246
1247 htotal = var->left_margin + var->xres + var->right_margin + var->hsync_len;
1248
1249 vtotal = var->upper_margin + var->lower_margin + var->vsync_len;
1250
1251 pixclock = var->pixclock;
1252
1253 if((var->vmode & FB_VMODE_MASK) == FB_VMODE_NONINTERLACED) {
1254 vtotal += var->yres;
1255 vtotal <<= 1;
1256 } else if((var->vmode & FB_VMODE_MASK) == FB_VMODE_DOUBLE) {
1257 vtotal += var->yres;
1258 vtotal <<= 2;
1259 } else if((var->vmode & FB_VMODE_MASK) == FB_VMODE_INTERLACED) {
1260 vtotal += var->yres;
1261 vtotal <<= 1;
1262 } else vtotal += var->yres;
1263
1264 if(!(htotal) || !(vtotal)) {
1265 DPRINTK("sisfb: Invalid 'var' information\n");
1266 return -EINVAL;
1267 }
1268
1269 if(pixclock && htotal && vtotal) {
1270 drate = 1000000000 / pixclock;
1271 hrate = (drate * 1000) / htotal;
1272 ivideo->refresh_rate = (unsigned int) (hrate * 2 / vtotal);
1273 } else {
1274 ivideo->refresh_rate = 60;
1275 }
1276
1277 old_mode = ivideo->sisfb_mode_idx;
1278 ivideo->sisfb_mode_idx = 0;
1279
1280 while( (sisbios_mode[ivideo->sisfb_mode_idx].mode_no[0] != 0) &&
1281 (sisbios_mode[ivideo->sisfb_mode_idx].xres <= var->xres) ) {
1282 if( (sisbios_mode[ivideo->sisfb_mode_idx].xres == var->xres) &&
1283 (sisbios_mode[ivideo->sisfb_mode_idx].yres == var->yres) &&
1284 (sisbios_mode[ivideo->sisfb_mode_idx].bpp == var->bits_per_pixel)) {
1285 ivideo->mode_no = sisbios_mode[ivideo->sisfb_mode_idx].mode_no[ivideo->mni];
1286 found_mode = 1;
1287 break;
1288 }
1289 ivideo->sisfb_mode_idx++;
1290 }
1291
1292 if(found_mode) {
1293 ivideo->sisfb_mode_idx = sisfb_validate_mode(ivideo,
1294 ivideo->sisfb_mode_idx, ivideo->currentvbflags);
1295 ivideo->mode_no = sisbios_mode[ivideo->sisfb_mode_idx].mode_no[ivideo->mni];
1296 } else {
1297 ivideo->sisfb_mode_idx = -1;
1298 }
1299
1300 if(ivideo->sisfb_mode_idx < 0) {
1301 printk(KERN_ERR "sisfb: Mode %dx%dx%d not supported\n", var->xres,
1302 var->yres, var->bits_per_pixel);
1303 ivideo->sisfb_mode_idx = old_mode;
1304 return -EINVAL;
1305 }
1306
1307 if(sisfb_search_refresh_rate(ivideo, ivideo->refresh_rate, ivideo->sisfb_mode_idx) == 0) {
1308 ivideo->rate_idx = sisbios_mode[ivideo->sisfb_mode_idx].rate_idx;
1309 ivideo->refresh_rate = 60;
1310 }
1311
1312 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
1313 if(ivideo->sisfb_thismonitor.datavalid) {
1314 if(!sisfb_verify_rate(ivideo, &ivideo->sisfb_thismonitor, ivideo->sisfb_mode_idx,
1315 ivideo->rate_idx, ivideo->refresh_rate)) {
1316 printk(KERN_INFO "sisfb: WARNING: Refresh rate exceeds monitor specs!\n");
1317 }
1318 }
1319 #endif
1320
1321 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
1322 if(((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW) && isactive) {
1323 #else
1324 if(isactive) {
1325 #endif
1326 /* If acceleration to be used? Need to know
1327 * before pre/post_set_mode()
1328 */
1329 ivideo->accel = 0;
1330 #if defined(FBINFO_HWACCEL_DISABLED) && defined(FBINFO_HWACCEL_XPAN)
1331 #ifdef STUPID_ACCELF_TEXT_SHIT
1332 if(var->accel_flags & FB_ACCELF_TEXT) {
1333 info->flags &= ~FBINFO_HWACCEL_DISABLED;
1334 } else {
1335 info->flags |= FBINFO_HWACCEL_DISABLED;
1336 }
1337 #endif
1338 if(!(info->flags & FBINFO_HWACCEL_DISABLED)) ivideo->accel = -1;
1339 #else
1340 if(var->accel_flags & FB_ACCELF_TEXT) ivideo->accel = -1;
1341 #endif
1342
1343 if((ret = sisfb_set_mode(ivideo, 1))) {
1344 return ret;
1345 }
1346
1347 ivideo->video_bpp = sisbios_mode[ivideo->sisfb_mode_idx].bpp;
1348 ivideo->video_width = sisbios_mode[ivideo->sisfb_mode_idx].xres;
1349 ivideo->video_height = sisbios_mode[ivideo->sisfb_mode_idx].yres;
1350
1351 sisfb_calc_pitch(ivideo, var);
1352 sisfb_set_pitch(ivideo);
1353
1354 sisfb_set_vparms(ivideo);
1355
1356 ivideo->current_width = ivideo->video_width;
1357 ivideo->current_height = ivideo->video_height;
1358 ivideo->current_bpp = ivideo->video_bpp;
1359 ivideo->current_htotal = htotal;
1360 ivideo->current_vtotal = vtotal;
1361 ivideo->current_linelength = ivideo->video_linelength;
1362 ivideo->current_pixclock = var->pixclock;
1363 ivideo->current_refresh_rate = ivideo->refresh_rate;
1364 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
1365 ivideo->sisfb_lastrates[ivideo->mode_no] = ivideo->refresh_rate;
1366 #endif
1367 }
1368
1369 return 0;
1370 }
1371
1372 static void
1373 sisfb_set_base_CRT1(struct sis_video_info *ivideo, unsigned int base)
1374 {
1375 outSISIDXREG(SISSR, IND_SIS_PASSWORD, SIS_PASSWORD);
1376
1377 outSISIDXREG(SISCR, 0x0D, base & 0xFF);
1378 outSISIDXREG(SISCR, 0x0C, (base >> 8) & 0xFF);
1379 outSISIDXREG(SISSR, 0x0D, (base >> 16) & 0xFF);
1380 if(ivideo->sisvga_engine == SIS_315_VGA) {
1381 setSISIDXREG(SISSR, 0x37, 0xFE, (base >> 24) & 0x01);
1382 }
1383 }
1384
1385 static void
1386 sisfb_set_base_CRT2(struct sis_video_info *ivideo, unsigned int base)
1387 {
1388 if(ivideo->currentvbflags & VB_DISPTYPE_DISP2) {
1389 orSISIDXREG(SISPART1, ivideo->CRT2_write_enable, 0x01);
1390 outSISIDXREG(SISPART1, 0x06, (base & 0xFF));
1391 outSISIDXREG(SISPART1, 0x05, ((base >> 8) & 0xFF));
1392 outSISIDXREG(SISPART1, 0x04, ((base >> 16) & 0xFF));
1393 if(ivideo->sisvga_engine == SIS_315_VGA) {
1394 setSISIDXREG(SISPART1, 0x02, 0x7F, ((base >> 24) & 0x01) << 7);
1395 }
1396 }
1397 }
1398
1399 static int
1400 sisfb_pan_var(struct sis_video_info *ivideo, struct fb_var_screeninfo *var)
1401 {
1402 if(var->xoffset > (var->xres_virtual - var->xres)) {
1403 return -EINVAL;
1404 }
1405 if(var->yoffset > (var->yres_virtual - var->yres)) {
1406 return -EINVAL;
1407 }
1408
1409 ivideo->current_base = (var->yoffset * var->xres_virtual) + var->xoffset;
1410
1411 /* calculate base bpp dep. */
1412 switch(var->bits_per_pixel) {
1413 case 32:
1414 break;
1415 case 16:
1416 ivideo->current_base >>= 1;
1417 break;
1418 case 8:
1419 default:
1420 ivideo->current_base >>= 2;
1421 break;
1422 }
1423
1424 ivideo->current_base += (ivideo->video_offset >> 2);
1425
1426 sisfb_set_base_CRT1(ivideo, ivideo->current_base);
1427 sisfb_set_base_CRT2(ivideo, ivideo->current_base);
1428
1429 return 0;
1430 }
1431
1432 /* ------------ FBDev related routines for 2.4 series ----------- */
1433
1434 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
1435
1436 #include "sisfb_fbdev_2_4.h"
1437
1438 #endif
1439
1440 /* ------------ FBDev related routines for 2.6 series ----------- */
1441
1442 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
1443
1444 static int
1445 sisfb_open(struct fb_info *info, int user)
1446 {
1447 return 0;
1448 }
1449
1450 static int
1451 sisfb_release(struct fb_info *info, int user)
1452 {
1453 return 0;
1454 }
1455
1456 static int
1457 sisfb_setcolreg(unsigned regno, unsigned red, unsigned green, unsigned blue,
1458 unsigned transp, struct fb_info *info)
1459 {
1460 struct sis_video_info *ivideo = (struct sis_video_info *)info->par;
1461
1462 if(regno >= sisfb_get_cmap_len(&info->var))
1463 return 1;
1464
1465 switch(info->var.bits_per_pixel) {
1466 case 8:
1467 outSISREG(SISDACA, regno);
1468 outSISREG(SISDACD, (red >> 10));
1469 outSISREG(SISDACD, (green >> 10));
1470 outSISREG(SISDACD, (blue >> 10));
1471 if(ivideo->currentvbflags & VB_DISPTYPE_DISP2) {
1472 outSISREG(SISDAC2A, regno);
1473 outSISREG(SISDAC2D, (red >> 8));
1474 outSISREG(SISDAC2D, (green >> 8));
1475 outSISREG(SISDAC2D, (blue >> 8));
1476 }
1477 break;
1478 case 16:
1479 ((u32 *)(info->pseudo_palette))[regno] =
1480 (red & 0xf800) |
1481 ((green & 0xfc00) >> 5) |
1482 ((blue & 0xf800) >> 11);
1483 break;
1484 case 32:
1485 red >>= 8;
1486 green >>= 8;
1487 blue >>= 8;
1488 ((u32 *)(info->pseudo_palette))[regno] =
1489 (red << 16) | (green << 8) | (blue);
1490 break;
1491 }
1492 return 0;
1493 }
1494
1495 static int
1496 sisfb_set_par(struct fb_info *info)
1497 {
1498 int err;
1499
1500 if((err = sisfb_do_set_var(&info->var, 1, info)))
1501 return err;
1502
1503 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10)
1504 sisfb_get_fix(&info->fix, info->currcon, info);
1505 #else
1506 sisfb_get_fix(&info->fix, -1, info);
1507 #endif
1508 return 0;
1509 }
1510
1511 static int
1512 sisfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
1513 {
1514 struct sis_video_info *ivideo = (struct sis_video_info *)info->par;
1515 unsigned int htotal = 0, vtotal = 0, myrateindex = 0;
1516 unsigned int drate = 0, hrate = 0, maxyres;
1517 int found_mode = 0;
1518 int refresh_rate, search_idx, tidx;
1519 BOOLEAN recalc_clock = FALSE;
1520 u32 pixclock;
1521
1522 htotal = var->left_margin + var->xres + var->right_margin + var->hsync_len;
1523
1524 vtotal = var->upper_margin + var->lower_margin + var->vsync_len;
1525
1526 pixclock = var->pixclock;
1527
1528 if((var->vmode & FB_VMODE_MASK) == FB_VMODE_NONINTERLACED) {
1529 vtotal += var->yres;
1530 vtotal <<= 1;
1531 } else if((var->vmode & FB_VMODE_MASK) == FB_VMODE_DOUBLE) {
1532 vtotal += var->yres;
1533 vtotal <<= 2;
1534 } else if((var->vmode & FB_VMODE_MASK) == FB_VMODE_INTERLACED) {
1535 vtotal += var->yres;
1536 vtotal <<= 1;
1537 } else
1538 vtotal += var->yres;
1539
1540 if(!(htotal) || !(vtotal)) {
1541 SISFAIL("sisfb: no valid timing data");
1542 }
1543
1544 search_idx = 0;
1545 while( (sisbios_mode[search_idx].mode_no[0] != 0) &&
1546 (sisbios_mode[search_idx].xres <= var->xres) ) {
1547 if( (sisbios_mode[search_idx].xres == var->xres) &&
1548 (sisbios_mode[search_idx].yres == var->yres) &&
1549 (sisbios_mode[search_idx].bpp == var->bits_per_pixel)) {
1550 if((tidx = sisfb_validate_mode(ivideo, search_idx,
1551 ivideo->currentvbflags)) > 0) {
1552 found_mode = 1;
1553 search_idx = tidx;
1554 break;
1555 }
1556 }
1557 search_idx++;
1558 }
1559
1560 if(!found_mode) {
1561 search_idx = 0;
1562 while(sisbios_mode[search_idx].mode_no[0] != 0) {
1563 if( (var->xres <= sisbios_mode[search_idx].xres) &&
1564 (var->yres <= sisbios_mode[search_idx].yres) &&
1565 (var->bits_per_pixel == sisbios_mode[search_idx].bpp) ) {
1566 if((tidx = sisfb_validate_mode(ivideo,search_idx,
1567 ivideo->currentvbflags)) > 0) {
1568 found_mode = 1;
1569 search_idx = tidx;
1570 break;
1571 }
1572 }
1573 search_idx++;
1574 }
1575 if(found_mode) {
1576 printk(KERN_DEBUG
1577 "sisfb: Adapted from %dx%dx%d to %dx%dx%d\n",
1578 var->xres, var->yres, var->bits_per_pixel,
1579 sisbios_mode[search_idx].xres,
1580 sisbios_mode[search_idx].yres,
1581 var->bits_per_pixel);
1582 var->xres = sisbios_mode[search_idx].xres;
1583 var->yres = sisbios_mode[search_idx].yres;
1584 } else {
1585 printk(KERN_ERR
1586 "sisfb: Failed to find supported mode near %dx%dx%d\n",
1587 var->xres, var->yres, var->bits_per_pixel);
1588 return -EINVAL;
1589 }
1590 }
1591
1592 if( ((ivideo->vbflags2 & VB2_LVDS) ||
1593 ((ivideo->vbflags2 & VB2_30xBDH) && (ivideo->currentvbflags & CRT2_LCD))) &&
1594 (var->bits_per_pixel == 8) ) {
1595 /* Slave modes on LVDS and 301B-DH */
1596 refresh_rate = 60;
1597 recalc_clock = TRUE;
1598 } else if( (ivideo->current_htotal == htotal) &&
1599 (ivideo->current_vtotal == vtotal) &&
1600 (ivideo->current_pixclock == pixclock) ) {
1601 /* x=x & y=y & c=c -> assume depth change */
1602 drate = 1000000000 / pixclock;
1603 hrate = (drate * 1000) / htotal;
1604 refresh_rate = (unsigned int) (hrate * 2 / vtotal);
1605 } else if( ( (ivideo->current_htotal != htotal) ||
1606 (ivideo->current_vtotal != vtotal) ) &&
1607 (ivideo->current_pixclock == var->pixclock) ) {
1608 /* x!=x | y!=y & c=c -> invalid pixclock */
1609 if(ivideo->sisfb_lastrates[sisbios_mode[search_idx].mode_no[ivideo->mni]]) {
1610 refresh_rate =
1611 ivideo->sisfb_lastrates[sisbios_mode[search_idx].mode_no[ivideo->mni]];
1612 } else if(ivideo->sisfb_parm_rate != -1) {
1613 /* Sic, sisfb_parm_rate - want to know originally desired rate here */
1614 refresh_rate = ivideo->sisfb_parm_rate;
1615 } else {
1616 refresh_rate = 60;
1617 }
1618 recalc_clock = TRUE;
1619 } else if((pixclock) && (htotal) && (vtotal)) {
1620 drate = 1000000000 / pixclock;
1621 hrate = (drate * 1000) / htotal;
1622 refresh_rate = (unsigned int) (hrate * 2 / vtotal);
1623 } else if(ivideo->current_refresh_rate) {
1624 refresh_rate = ivideo->current_refresh_rate;
1625 recalc_clock = TRUE;
1626 } else {
1627 refresh_rate = 60;
1628 recalc_clock = TRUE;
1629 }
1630
1631 myrateindex = sisfb_search_refresh_rate(ivideo, refresh_rate, search_idx);
1632
1633 /* Eventually recalculate timing and clock */
1634 if(recalc_clock) {
1635 if(!myrateindex) myrateindex = sisbios_mode[search_idx].rate_idx;
1636 var->pixclock = (u32) (1000000000 / sisfb_mode_rate_to_dclock(&ivideo->SiS_Pr,
1637 sisbios_mode[search_idx].mode_no[ivideo->mni],
1638 myrateindex));
1639 sisfb_mode_rate_to_ddata(&ivideo->SiS_Pr,
1640 sisbios_mode[search_idx].mode_no[ivideo->mni],
1641 myrateindex, var);
1642 if((var->vmode & FB_VMODE_MASK) == FB_VMODE_DOUBLE) {
1643 var->pixclock <<= 1;
1644 }
1645 }
1646
1647 if(ivideo->sisfb_thismonitor.datavalid) {
1648 if(!sisfb_verify_rate(ivideo, &ivideo->sisfb_thismonitor, search_idx,
1649 myrateindex, refresh_rate)) {
1650 printk(KERN_INFO
1651 "sisfb: WARNING: Refresh rate exceeds monitor specs!\n");
1652 }
1653 }
1654
1655 /* Adapt RGB settings */
1656 sisfb_bpp_to_var(ivideo, var);
1657
1658 /* Sanity check for offsets */
1659 if(var->xoffset < 0) var->xoffset = 0;
1660 if(var->yoffset < 0) var->yoffset = 0;
1661
1662 if(var->xres > var->xres_virtual)
1663 var->xres_virtual = var->xres;
1664
1665 if(ivideo->sisfb_ypan) {
1666 maxyres = sisfb_calc_maxyres(ivideo, var);
1667 if(ivideo->sisfb_max) {
1668 var->yres_virtual = maxyres;
1669 } else {
1670 if(var->yres_virtual > maxyres) {
1671 var->yres_virtual = maxyres;
1672 }
1673 }
1674 if(var->yres_virtual <= var->yres) {
1675 var->yres_virtual = var->yres;
1676 }
1677 } else {
1678 if(var->yres != var->yres_virtual) {
1679 var->yres_virtual = var->yres;
1680 }
1681 var->xoffset = 0;
1682 var->yoffset = 0;
1683 }
1684
1685 /* Truncate offsets to maximum if too high */
1686 if(var->xoffset > var->xres_virtual - var->xres) {
1687 var->xoffset = var->xres_virtual - var->xres - 1;
1688 }
1689
1690 if(var->yoffset > var->yres_virtual - var->yres) {
1691 var->yoffset = var->yres_virtual - var->yres - 1;
1692 }
1693
1694 /* Set everything else to 0 */
1695 var->red.msb_right =
1696 var->green.msb_right =
1697 var->blue.msb_right =
1698 var->transp.offset =
1699 var->transp.length =
1700 var->transp.msb_right = 0;
1701
1702 return 0;
1703 }
1704
1705 static int
1706 sisfb_pan_display(struct fb_var_screeninfo *var, struct fb_info* info)
1707 {
1708 struct sis_video_info *ivideo = (struct sis_video_info *)info->par;
1709 int err;
1710
1711 if(var->xoffset > (var->xres_virtual - var->xres))
1712 return -EINVAL;
1713
1714 if(var->yoffset > (var->yres_virtual - var->yres))
1715 return -EINVAL;
1716
1717 if(var->vmode & FB_VMODE_YWRAP)
1718 return -EINVAL;
1719
1720 if(var->xoffset + info->var.xres > info->var.xres_virtual ||
1721 var->yoffset + info->var.yres > info->var.yres_virtual)
1722 return -EINVAL;
1723
1724 if((err = sisfb_pan_var(ivideo, var)) < 0)
1725 return err;
1726
1727 info->var.xoffset = var->xoffset;
1728 info->var.yoffset = var->yoffset;
1729
1730 return 0;
1731 }
1732
1733 static int
1734 sisfb_blank(int blank, struct fb_info *info)
1735 {
1736 struct sis_video_info *ivideo = (struct sis_video_info *)info->par;
1737
1738 return sisfb_myblank(ivideo, blank);
1739 }
1740
1741 #endif
1742
1743 /* ----------- FBDev related routines for all series ---------- */
1744
1745 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15)
1746 static int sisfb_ioctl(struct fb_info *info, unsigned int cmd,
1747 unsigned long arg)
1748 #else
1749 static int sisfb_ioctl(struct inode *inode, struct file *file,
1750 unsigned int cmd, unsigned long arg,
1751 struct fb_info *info)
1752 #endif
1753 {
1754 struct sis_video_info *ivideo = (struct sis_video_info *)info->par;
1755 struct sis_memreq sismemreq;
1756 struct fb_vblank sisvbblank;
1757 u32 gpu32 = 0;
1758 #ifndef __user
1759 #define __user
1760 #endif
1761 u32 __user *argp = (u32 __user *)arg;
1762
1763 switch(cmd) {
1764 case FBIO_ALLOC:
1765 if(!capable(CAP_SYS_RAWIO))
1766 return -EPERM;
1767
1768 if(copy_from_user(&sismemreq, (void __user *)arg, sizeof(sismemreq)))
1769 return -EFAULT;
1770
1771 sis_malloc(&sismemreq);
1772
1773 if(copy_to_user((void __user *)arg, &sismemreq, sizeof(sismemreq))) {
1774 sis_free((u32)sismemreq.offset);
1775 return -EFAULT;
1776 }
1777 break;
1778
1779 case FBIO_FREE:
1780 if(!capable(CAP_SYS_RAWIO))
1781 return -EPERM;
1782
1783 if(get_user(gpu32, argp))
1784 return -EFAULT;
1785
1786 sis_free(gpu32);
1787 break;
1788
1789 case FBIOGET_VBLANK:
1790 sisvbblank.count = 0;
1791 sisvbblank.flags = sisfb_setupvbblankflags(ivideo, &sisvbblank.vcount, &sisvbblank.hcount);
1792
1793 if(copy_to_user((void __user *)arg, &sisvbblank, sizeof(sisvbblank)))
1794 return -EFAULT;
1795
1796 break;
1797
1798 case SISFB_GET_INFO_SIZE:
1799 return put_user(sizeof(struct sisfb_info), argp);
1800
1801 case SISFB_GET_INFO_OLD:
1802 if(ivideo->warncount++ < 10)
1803 printk(KERN_INFO
1804 "sisfb: Deprecated ioctl call received - update your application!\n");
1805 case SISFB_GET_INFO: /* For communication with X driver */
1806 ivideo->sisfb_infoblock.sisfb_id = SISFB_ID;
1807 ivideo->sisfb_infoblock.sisfb_version = VER_MAJOR;
1808 ivideo->sisfb_infoblock.sisfb_revision = VER_MINOR;
1809 ivideo->sisfb_infoblock.sisfb_patchlevel = VER_LEVEL;
1810 ivideo->sisfb_infoblock.chip_id = ivideo->chip_id;
1811 ivideo->sisfb_infoblock.sisfb_pci_vendor = ivideo->chip_vendor;
1812 ivideo->sisfb_infoblock.memory = ivideo->video_size / 1024;
1813 ivideo->sisfb_infoblock.heapstart = ivideo->heapstart / 1024;
1814 if(ivideo->modechanged) {
1815 ivideo->sisfb_infoblock.fbvidmode = ivideo->mode_no;
1816 } else {
1817 ivideo->sisfb_infoblock.fbvidmode = ivideo->modeprechange;
1818 }
1819 ivideo->sisfb_infoblock.sisfb_caps = ivideo->caps;
1820 ivideo->sisfb_infoblock.sisfb_tqlen = ivideo->cmdQueueSize / 1024;
1821 ivideo->sisfb_infoblock.sisfb_pcibus = ivideo->pcibus;
1822 ivideo->sisfb_infoblock.sisfb_pcislot = ivideo->pcislot;
1823 ivideo->sisfb_infoblock.sisfb_pcifunc = ivideo->pcifunc;
1824 ivideo->sisfb_infoblock.sisfb_lcdpdc = ivideo->detectedpdc;
1825 ivideo->sisfb_infoblock.sisfb_lcdpdca = ivideo->detectedpdca;
1826 ivideo->sisfb_infoblock.sisfb_lcda = ivideo->detectedlcda;
1827 ivideo->sisfb_infoblock.sisfb_vbflags = ivideo->vbflags;
1828 ivideo->sisfb_infoblock.sisfb_currentvbflags = ivideo->currentvbflags;
1829 ivideo->sisfb_infoblock.sisfb_scalelcd = ivideo->SiS_Pr.UsePanelScaler;
1830 ivideo->sisfb_infoblock.sisfb_specialtiming = ivideo->SiS_Pr.SiS_CustomT;
1831 ivideo->sisfb_infoblock.sisfb_haveemi = ivideo->SiS_Pr.HaveEMI ? 1 : 0;
1832 ivideo->sisfb_infoblock.sisfb_haveemilcd = ivideo->SiS_Pr.HaveEMILCD ? 1 : 0;
1833 ivideo->sisfb_infoblock.sisfb_emi30 = ivideo->SiS_Pr.EMI_30;
1834 ivideo->sisfb_infoblock.sisfb_emi31 = ivideo->SiS_Pr.EMI_31;
1835 ivideo->sisfb_infoblock.sisfb_emi32 = ivideo->SiS_Pr.EMI_32;
1836 ivideo->sisfb_infoblock.sisfb_emi33 = ivideo->SiS_Pr.EMI_33;
1837 ivideo->sisfb_infoblock.sisfb_tvxpos = (u16)(ivideo->tvxpos + 32);
1838 ivideo->sisfb_infoblock.sisfb_tvypos = (u16)(ivideo->tvypos + 32);
1839 ivideo->sisfb_infoblock.sisfb_heapsize = ivideo->sisfb_heap_size / 1024;
1840 ivideo->sisfb_infoblock.sisfb_videooffset = ivideo->video_offset;
1841 ivideo->sisfb_infoblock.sisfb_curfstn = ivideo->curFSTN;
1842 ivideo->sisfb_infoblock.sisfb_curdstn = ivideo->curDSTN;
1843 ivideo->sisfb_infoblock.sisfb_vbflags2 = ivideo->vbflags2;
1844 ivideo->sisfb_infoblock.sisfb_can_post = ivideo->sisfb_can_post ? 1 : 0;
1845 ivideo->sisfb_infoblock.sisfb_card_posted = ivideo->sisfb_card_posted ? 1 : 0;
1846 ivideo->sisfb_infoblock.sisfb_was_boot_device = ivideo->sisfb_was_boot_device ? 1 : 0;
1847
1848 if(copy_to_user((void __user *)arg, &ivideo->sisfb_infoblock,
1849 sizeof(ivideo->sisfb_infoblock)))
1850 return -EFAULT;
1851
1852 break;
1853
1854 case SISFB_GET_VBRSTATUS_OLD:
1855 if(ivideo->warncount++ < 10)
1856 printk(KERN_INFO
1857 "sisfb: Deprecated ioctl call received - update your application!\n");
1858 case SISFB_GET_VBRSTATUS:
1859 if(sisfb_CheckVBRetrace(ivideo))
1860 return put_user((u32)1, argp);
1861 else
1862 return put_user((u32)0, argp);
1863
1864 case SISFB_GET_AUTOMAXIMIZE_OLD:
1865 if(ivideo->warncount++ < 10)
1866 printk(KERN_INFO
1867 "sisfb: Deprecated ioctl call received - update your application!\n");
1868 case SISFB_GET_AUTOMAXIMIZE:
1869 if(ivideo->sisfb_max)
1870 return put_user((u32)1, argp);
1871 else
1872 return put_user((u32)0, argp);
1873
1874 case SISFB_SET_AUTOMAXIMIZE_OLD:
1875 if(ivideo->warncount++ < 10)
1876 printk(KERN_INFO
1877 "sisfb: Deprecated ioctl call received - update your application!\n");
1878 case SISFB_SET_AUTOMAXIMIZE:
1879 if(get_user(gpu32, argp))
1880 return -EFAULT;
1881
1882 ivideo->sisfb_max = (gpu32) ? 1 : 0;
1883 break;
1884
1885 case SISFB_SET_TVPOSOFFSET:
1886 if(get_user(gpu32, argp))
1887 return -EFAULT;
1888
1889 sisfb_set_TVxposoffset(ivideo, ((int)(gpu32 >> 16)) - 32);
1890 sisfb_set_TVyposoffset(ivideo, ((int)(gpu32 & 0xffff)) - 32);
1891 break;
1892
1893 case SISFB_GET_TVPOSOFFSET:
1894 return put_user((u32)(((ivideo->tvxpos+32)<<16)|((ivideo->tvypos+32)&0xffff)),
1895 argp);
1896
1897 case SISFB_COMMAND:
1898 if(copy_from_user(&ivideo->sisfb_command, (void __user *)arg,
1899 sizeof(struct sisfb_cmd)))
1900 return -EFAULT;
1901
1902 sisfb_handle_command(ivideo, &ivideo->sisfb_command);
1903
1904 if(copy_to_user((void __user *)arg, &ivideo->sisfb_command,
1905 sizeof(struct sisfb_cmd)))
1906 return -EFAULT;
1907
1908 break;
1909
1910 case SISFB_SET_LOCK:
1911 if(get_user(gpu32, argp))
1912 return -EFAULT;
1913
1914 ivideo->sisfblocked = (gpu32) ? 1 : 0;
1915 break;
1916
1917 default:
1918 #ifdef SIS_NEW_CONFIG_COMPAT
1919 return -ENOIOCTLCMD;
1920 #else
1921 return -EINVAL;
1922 #endif
1923 }
1924 return 0;
1925 }
1926
1927 static int
1928 sisfb_get_fix(struct fb_fix_screeninfo *fix, int con, struct fb_info *info)
1929 {
1930 struct sis_video_info *ivideo = (struct sis_video_info *)info->par;
1931
1932 memset(fix, 0, sizeof(struct fb_fix_screeninfo));
1933
1934 strcpy(fix->id, ivideo->myid);
1935
1936 fix->smem_start = ivideo->video_base + ivideo->video_offset;
1937 fix->smem_len = ivideo->sisfb_mem;
1938 fix->type = FB_TYPE_PACKED_PIXELS;
1939 fix->type_aux = 0;
1940 fix->visual = (ivideo->video_bpp == 8) ? FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_TRUECOLOR;
1941 fix->xpanstep = 1;
1942 fix->ypanstep = (ivideo->sisfb_ypan) ? 1 : 0;
1943 fix->ywrapstep = 0;
1944 fix->line_length = ivideo->video_linelength;
1945 fix->mmio_start = ivideo->mmio_base;
1946 fix->mmio_len = ivideo->mmio_size;
1947 if(ivideo->sisvga_engine == SIS_300_VGA) {
1948 fix->accel = FB_ACCEL_SIS_GLAMOUR;
1949 } else if((ivideo->chip == SIS_330) ||
1950 (ivideo->chip == SIS_760) ||
1951 (ivideo->chip == SIS_761)) {
1952 fix->accel = FB_ACCEL_SIS_XABRE;
1953 } else if(ivideo->chip == XGI_20) {
1954 fix->accel = FB_ACCEL_XGI_VOLARI_Z;
1955 } else if(ivideo->chip >= XGI_40) {
1956 fix->accel = FB_ACCEL_XGI_VOLARI_V;
1957 } else {
1958 fix->accel = FB_ACCEL_SIS_GLAMOUR_2;
1959 }
1960
1961 return 0;
1962 }
1963
1964 /* ---------------- fb_ops structures ----------------- */
1965
1966 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
1967 static struct fb_ops sisfb_ops = {
1968 .owner = THIS_MODULE,
1969 .fb_get_fix = sisfb_get_fix,
1970 .fb_get_var = sisfb_get_var,
1971 .fb_set_var = sisfb_set_var,
1972 .fb_get_cmap = sisfb_get_cmap,
1973 .fb_set_cmap = sisfb_set_cmap,
1974 .fb_pan_display = sisfb_pan_display,
1975 .fb_ioctl = sisfb_ioctl
1976 };
1977 #endif
1978
1979 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
1980 static struct fb_ops sisfb_ops = {
1981 .owner = THIS_MODULE,
1982 .fb_open = sisfb_open,
1983 .fb_release = sisfb_release,
1984 .fb_check_var = sisfb_check_var,
1985 .fb_set_par = sisfb_set_par,
1986 .fb_setcolreg = sisfb_setcolreg,
1987 .fb_pan_display = sisfb_pan_display,
1988 .fb_blank = sisfb_blank,
1989 .fb_fillrect = fbcon_sis_fillrect,
1990 .fb_copyarea = fbcon_sis_copyarea,
1991 .fb_imageblit = cfb_imageblit,
1992 #ifdef CONFIG_FB_SOFT_CURSOR
1993 .fb_cursor = soft_cursor,
1994 #endif
1995 .fb_sync = fbcon_sis_sync,
1996 #ifdef SIS_NEW_CONFIG_COMPAT
1997 .fb_compat_ioctl= sisfb_ioctl,
1998 #endif
1999 .fb_ioctl = sisfb_ioctl
2000 };
2001 #endif
2002
2003 /* ---------------- Chip generation dependent routines ---------------- */
2004
2005 static struct pci_dev * __devinit
2006 sisfb_get_northbridge(int basechipid)
2007 {
2008 struct pci_dev *pdev = NULL;
2009 int nbridgenum, nbridgeidx, i;
2010 static const unsigned short nbridgeids[] = {
2011 PCI_DEVICE_ID_SI_540, /* for SiS 540 VGA */
2012 PCI_DEVICE_ID_SI_630, /* for SiS 630/730 VGA */
2013 PCI_DEVICE_ID_SI_730,
2014 PCI_DEVICE_ID_SI_550, /* for SiS 550 VGA */
2015 PCI_DEVICE_ID_SI_650, /* for SiS 650/651/740 VGA */
2016 PCI_DEVICE_ID_SI_651,
2017 PCI_DEVICE_ID_SI_740,
2018 PCI_DEVICE_ID_SI_661, /* for SiS 661/741/660/760/761 VGA */
2019 PCI_DEVICE_ID_SI_741,
2020 PCI_DEVICE_ID_SI_660,
2021 PCI_DEVICE_ID_SI_760,
2022 PCI_DEVICE_ID_SI_761
2023 };
2024
2025 switch(basechipid) {
2026 #ifdef CONFIG_FB_SIS_300
2027 case SIS_540: nbridgeidx = 0; nbridgenum = 1; break;
2028 case SIS_630: nbridgeidx = 1; nbridgenum = 2; break;
2029 #endif
2030 #ifdef CONFIG_FB_SIS_315
2031 case SIS_550: nbridgeidx = 3; nbridgenum = 1; break;
2032 case SIS_650: nbridgeidx = 4; nbridgenum = 3; break;
2033 case SIS_660: nbridgeidx = 7; nbridgenum = 5; break;
2034 #endif
2035 default: return NULL;
2036 }
2037 for(i = 0; i < nbridgenum; i++) {
2038 if((pdev = SIS_PCI_GET_DEVICE(PCI_VENDOR_ID_SI,
2039 nbridgeids[nbridgeidx+i], NULL)))
2040 break;
2041 }
2042 return pdev;
2043 }
2044
2045 static int __devinit
2046 sisfb_get_dram_size(struct sis_video_info *ivideo)
2047 {
2048 #if defined(CONFIG_FB_SIS_300) || defined(CONFIG_FB_SIS_315)
2049 u8 reg;
2050 #endif
2051
2052 ivideo->video_size = 0;
2053 ivideo->UMAsize = ivideo->LFBsize = 0;
2054
2055 switch(ivideo->chip) {
2056 #ifdef CONFIG_FB_SIS_300
2057 case SIS_300:
2058 inSISIDXREG(SISSR, 0x14, reg);
2059 ivideo->video_size = ((reg & 0x3F) + 1) << 20;
2060 break;
2061 case SIS_540:
2062 case SIS_630:
2063 case SIS_730:
2064 if(!ivideo->nbridge)
2065 return -1;
2066 pci_read_config_byte(ivideo->nbridge, 0x63, &reg);
2067 ivideo->video_size = 1 << (((reg & 0x70) >> 4) + 21);
2068 break;
2069 #endif
2070 #ifdef CONFIG_FB_SIS_315
2071 case SIS_315H:
2072 case SIS_315PRO:
2073 case SIS_315:
2074 inSISIDXREG(SISSR, 0x14, reg);
2075 ivideo->video_size = (1 << ((reg & 0xf0) >> 4)) << 20;
2076 switch((reg >> 2) & 0x03) {
2077 case 0x01:
2078 case 0x03:
2079 ivideo->video_size <<= 1;
2080 break;
2081 case 0x02:
2082 ivideo->video_size += (ivideo->video_size/2);
2083 }
2084 break;
2085 case SIS_330:
2086 inSISIDXREG(SISSR, 0x14, reg);
2087 ivideo->video_size = (1 << ((reg & 0xf0) >> 4)) << 20;
2088 if(reg & 0x0c) ivideo->video_size <<= 1;
2089 break;
2090 case SIS_550:
2091 case SIS_650:
2092 case SIS_740:
2093 inSISIDXREG(SISSR, 0x14, reg);
2094 ivideo->video_size = (((reg & 0x3f) + 1) << 2) << 20;
2095 break;
2096 case SIS_661:
2097 case SIS_741:
2098 inSISIDXREG(SISCR, 0x79, reg);
2099 ivideo->video_size = (1 << ((reg & 0xf0) >> 4)) << 20;
2100 break;
2101 case SIS_660:
2102 case SIS_760:
2103 case SIS_761:
2104 inSISIDXREG(SISCR, 0x79, reg);
2105 reg = (reg & 0xf0) >> 4;
2106 if(reg) {
2107 ivideo->video_size = (1 << reg) << 20;
2108 ivideo->UMAsize = ivideo->video_size;
2109 }
2110 inSISIDXREG(SISCR, 0x78, reg);
2111 reg &= 0x30;
2112 if(reg) {
2113 if(reg == 0x10) {
2114 ivideo->LFBsize = (32 << 20);
2115 } else {
2116 ivideo->LFBsize = (64 << 20);
2117 }
2118 ivideo->video_size += ivideo->LFBsize;
2119 }
2120 break;
2121 case SIS_340:
2122 case XGI_20:
2123 case XGI_40:
2124 inSISIDXREG(SISSR, 0x14, reg);
2125 ivideo->video_size = (1 << ((reg & 0xf0) >> 4)) << 20;
2126 if(ivideo->chip != XGI_20) {
2127 reg = (reg & 0x0c) >> 2;
2128 if(ivideo->revision_id == 2) {
2129 if(reg & 0x01) reg = 0x02;
2130 else reg = 0x00;
2131 }
2132 if(reg == 0x02) ivideo->video_size <<= 1;
2133 else if(reg == 0x03) ivideo->video_size <<= 2;
2134 }
2135 break;
2136 #endif
2137 default:
2138 return -1;
2139 }
2140 return 0;
2141 }
2142
2143 /* -------------- video bridge device detection --------------- */
2144
2145 static void __devinit
2146 sisfb_detect_VB_connect(struct sis_video_info *ivideo)
2147 {
2148 u8 cr32, temp;
2149
2150 /* No CRT2 on XGI Z7 */
2151 if(ivideo->chip == XGI_20) {
2152 ivideo->sisfb_crt1off = 0;
2153 return;
2154 }
2155
2156 #ifdef CONFIG_FB_SIS_300
2157 if(ivideo->sisvga_engine == SIS_300_VGA) {
2158 inSISIDXREG(SISSR, 0x17, temp);
2159 if((temp & 0x0F) && (ivideo->chip != SIS_300)) {
2160 /* PAL/NTSC is stored on SR16 on such machines */
2161 if(!(ivideo->vbflags & (TV_PAL | TV_NTSC | TV_PALM | TV_PALN))) {
2162 inSISIDXREG(SISSR, 0x16, temp);
2163 if(temp & 0x20)
2164 ivideo->vbflags |= TV_PAL;
2165 else
2166 ivideo->vbflags |= TV_NTSC;
2167 }
2168 }
2169 }
2170 #endif
2171
2172 inSISIDXREG(SISCR, 0x32, cr32);
2173
2174 if(cr32 & SIS_CRT1) {
2175 ivideo->sisfb_crt1off = 0;
2176 } else {
2177 ivideo->sisfb_crt1off = (cr32 & 0xDF) ? 1 : 0;
2178 }
2179
2180 ivideo->vbflags &= ~(CRT2_TV | CRT2_LCD | CRT2_VGA);
2181
2182 if(cr32 & SIS_VB_TV) ivideo->vbflags |= CRT2_TV;
2183 if(cr32 & SIS_VB_LCD) ivideo->vbflags |= CRT2_LCD;
2184 if(cr32 & SIS_VB_CRT2) ivideo->vbflags |= CRT2_VGA;
2185
2186 /* Check given parms for hardware compatibility.
2187 * (Cannot do this in the search_xx routines since we don't
2188 * know what hardware we are running on then)
2189 */
2190
2191 if(ivideo->chip != SIS_550) {
2192 ivideo->sisfb_dstn = ivideo->sisfb_fstn = 0;
2193 }
2194
2195 if(ivideo->sisfb_tvplug != -1) {
2196 if( (ivideo->sisvga_engine != SIS_315_VGA) ||
2197 (!(ivideo->vbflags2 & VB2_SISYPBPRBRIDGE)) ) {
2198 if(ivideo->sisfb_tvplug & TV_YPBPR) {
2199 ivideo->sisfb_tvplug = -1;
2200 printk(KERN_ERR "sisfb: YPbPr not supported\n");
2201 }
2202 }
2203 }
2204 if(ivideo->sisfb_tvplug != -1) {
2205 if( (ivideo->sisvga_engine != SIS_315_VGA) ||
2206 (!(ivideo->vbflags2 & VB2_SISHIVISIONBRIDGE)) ) {
2207 if(ivideo->sisfb_tvplug & TV_HIVISION) {
2208 ivideo->sisfb_tvplug = -1;
2209 printk(KERN_ERR "sisfb: HiVision not supported\n");
2210 }
2211 }
2212 }
2213 if(ivideo->sisfb_tvstd != -1) {
2214 if( (!(ivideo->vbflags2 & VB2_SISBRIDGE)) &&
2215 (!((ivideo->sisvga_engine == SIS_315_VGA) &&
2216 (ivideo->vbflags2 & VB2_CHRONTEL))) ) {
2217 if(ivideo->sisfb_tvstd & (TV_PALN | TV_PALN | TV_NTSCJ)) {
2218 ivideo->sisfb_tvstd = -1;
2219 printk(KERN_ERR "sisfb: PALM/PALN/NTSCJ not supported\n");
2220 }
2221 }
2222 }
2223
2224 /* Detect/set TV plug & type */
2225 if(ivideo->sisfb_tvplug != -1) {
2226 ivideo->vbflags |= ivideo->sisfb_tvplug;
2227 } else {
2228 if(cr32 & SIS_VB_YPBPR) ivideo->vbflags |= (TV_YPBPR|TV_YPBPR525I); /* default: 480i */
2229 else if(cr32 & SIS_VB_HIVISION) ivideo->vbflags |= TV_HIVISION;
2230 else if(cr32 & SIS_VB_SCART) ivideo->vbflags |= TV_SCART;
2231 else {
2232 if(cr32 & SIS_VB_SVIDEO) ivideo->vbflags |= TV_SVIDEO;
2233 if(cr32 & SIS_VB_COMPOSITE) ivideo->vbflags |= TV_AVIDEO;
2234 }
2235 }
2236
2237 if(!(ivideo->vbflags & (TV_YPBPR | TV_HIVISION))) {
2238 if(ivideo->sisfb_tvstd != -1) {
2239 ivideo->vbflags &= ~(TV_NTSC | TV_PAL | TV_PALM | TV_PALN | TV_NTSCJ);
2240 ivideo->vbflags |= ivideo->sisfb_tvstd;
2241 }
2242 if(ivideo->vbflags & TV_SCART) {
2243 ivideo->vbflags &= ~(TV_NTSC | TV_PALM | TV_PALN | TV_NTSCJ);
2244 ivideo->vbflags |= TV_PAL;
2245 }
2246 if(!(ivideo->vbflags & (TV_PAL | TV_NTSC | TV_PALM | TV_PALN | TV_NTSCJ))) {
2247 if(ivideo->sisvga_engine == SIS_300_VGA) {
2248 inSISIDXREG(SISSR, 0x38, temp);
2249 if(temp & 0x01) ivideo->vbflags |= TV_PAL;
2250 else ivideo->vbflags |= TV_NTSC;
2251 } else if((ivideo->chip <= SIS_315PRO) || (ivideo->chip >= SIS_330)) {
2252 inSISIDXREG(SISSR, 0x38, temp);
2253 if(temp & 0x01) ivideo->vbflags |= TV_PAL;
2254 else ivideo->vbflags |= TV_NTSC;
2255 } else {
2256 inSISIDXREG(SISCR, 0x79, temp);
2257 if(temp & 0x20) ivideo->vbflags |= TV_PAL;
2258 else ivideo->vbflags |= TV_NTSC;
2259 }
2260 }
2261 }
2262
2263 /* Copy forceCRT1 option to CRT1off if option is given */
2264 if(ivideo->sisfb_forcecrt1 != -1) {
2265 ivideo->sisfb_crt1off = (ivideo->sisfb_forcecrt1) ? 0 : 1;
2266 }
2267 }
2268
2269 /* ------------------ Sensing routines ------------------ */
2270
2271 static BOOLEAN __devinit
2272 sisfb_test_DDC1(struct sis_video_info *ivideo)
2273 {
2274 unsigned short old;
2275 int count = 48;
2276
2277 old = SiS_ReadDDC1Bit(&ivideo->SiS_Pr);
2278 do {
2279 if(old != SiS_ReadDDC1Bit(&ivideo->SiS_Pr)) break;
2280 } while(count--);
2281 return (count == -1) ? FALSE : TRUE;
2282 }
2283
2284 static void __devinit
2285 sisfb_sense_crt1(struct sis_video_info *ivideo)
2286 {
2287 BOOLEAN mustwait = FALSE;
2288 u8 sr1F, cr17;
2289 #ifdef CONFIG_FB_SIS_315
2290 u8 cr63=0;
2291 #endif
2292 u16 temp = 0xffff;
2293 int i;
2294
2295 inSISIDXREG(SISSR,0x1F,sr1F);
2296 orSISIDXREG(SISSR,0x1F,0x04);
2297 andSISIDXREG(SISSR,0x1F,0x3F);
2298 if(sr1F & 0xc0) mustwait = TRUE;
2299
2300 #ifdef CONFIG_FB_SIS_315
2301 if(ivideo->sisvga_engine == SIS_315_VGA) {
2302 inSISIDXREG(SISCR,ivideo->SiS_Pr.SiS_MyCR63,cr63);
2303 cr63 &= 0x40;
2304 andSISIDXREG(SISCR,ivideo->SiS_Pr.SiS_MyCR63,0xBF);
2305 }
2306 #endif
2307
2308 inSISIDXREG(SISCR,0x17,cr17);
2309 cr17 &= 0x80;
2310 if(!cr17) {
2311 orSISIDXREG(SISCR,0x17,0x80);
2312 mustwait = TRUE;
2313 outSISIDXREG(SISSR, 0x00, 0x01);
2314 outSISIDXREG(SISSR, 0x00, 0x03);
2315 }
2316
2317 if(mustwait) {
2318 for(i=0; i < 10; i++) sisfbwaitretracecrt1(ivideo);
2319 }
2320
2321 #ifdef CONFIG_FB_SIS_315
2322 if(ivideo->chip >= SIS_330) {
2323 andSISIDXREG(SISCR,0x32,~0x20);
2324 if(ivideo->chip >= SIS_340) {
2325 outSISIDXREG(SISCR, 0x57, 0x4a);
2326 } else {
2327 outSISIDXREG(SISCR, 0x57, 0x5f);
2328 }
2329 orSISIDXREG(SISCR, 0x53, 0x02);
2330 while((inSISREG(SISINPSTAT)) & 0x01) break;
2331 while(!((inSISREG(SISINPSTAT)) & 0x01)) break;
2332 if((inSISREG(SISMISCW)) & 0x10) temp = 1;
2333 andSISIDXREG(SISCR, 0x53, 0xfd);
2334 andSISIDXREG(SISCR, 0x57, 0x00);
2335 }
2336 #endif
2337
2338 if(temp == 0xffff) {
2339 i = 3;
2340 do {
2341 temp = SiS_HandleDDC(&ivideo->SiS_Pr, ivideo->vbflags,
2342 ivideo->sisvga_engine, 0, 0, NULL, ivideo->vbflags2);
2343 } while(((temp == 0) || (temp == 0xffff)) && i--);
2344
2345 if((temp == 0) || (temp == 0xffff)) {
2346 if(sisfb_test_DDC1(ivideo)) temp = 1;
2347 }
2348 }
2349
2350 if((temp) && (temp != 0xffff)) {
2351 orSISIDXREG(SISCR,0x32,0x20);
2352 }
2353
2354 #ifdef CONFIG_FB_SIS_315
2355 if(ivideo->sisvga_engine == SIS_315_VGA) {
2356 setSISIDXREG(SISCR,ivideo->SiS_Pr.SiS_MyCR63,0xBF,cr63);
2357 }
2358 #endif
2359
2360 setSISIDXREG(SISCR,0x17,0x7F,cr17);
2361
2362 outSISIDXREG(SISSR,0x1F,sr1F);
2363 }
2364
2365 /* Determine and detect attached devices on SiS30x */
2366 static void __devinit
2367 SiS_SenseLCD(struct sis_video_info *ivideo)
2368 {
2369 unsigned char buffer[256];
2370 unsigned short temp, realcrtno, i;
2371 u8 reg, cr37 = 0, paneltype = 0;
2372 u16 xres, yres;
2373
2374 ivideo->SiS_Pr.PanelSelfDetected = FALSE;
2375
2376 /* LCD detection only for TMDS bridges */
2377 if(!(ivideo->vbflags2 & VB2_SISTMDSBRIDGE))
2378 return;
2379 if(ivideo->vbflags2 & VB2_30xBDH)
2380 return;
2381
2382 /* If LCD already set up by BIOS, skip it */
2383 inSISIDXREG(SISCR, 0x32, reg);
2384 if(reg & 0x08)
2385 return;
2386
2387 realcrtno = 1;
2388 if(ivideo->SiS_Pr.DDCPortMixup)
2389 realcrtno = 0;
2390
2391 /* Check DDC capabilities */
2392 temp = SiS_HandleDDC(&ivideo->SiS_Pr, ivideo->vbflags, ivideo->sisvga_engine,
2393 realcrtno, 0, &buffer[0], ivideo->vbflags2);
2394
2395 if((!temp) || (temp == 0xffff) || (!(temp & 0x02)))
2396 return;
2397
2398 /* Read DDC data */
2399 i = 3; /* Number of retrys */
2400 do {
2401 temp = SiS_HandleDDC(&ivideo->SiS_Pr, ivideo->vbflags,
2402 ivideo->sisvga_engine, realcrtno, 1,
2403 &buffer[0], ivideo->vbflags2);
2404 } while((temp) && i--);
2405
2406 if(temp)
2407 return;
2408
2409 /* No digital device */
2410 if(!(buffer[0x14] & 0x80))
2411 return;
2412
2413 /* First detailed timing preferred timing? */
2414 if(!(buffer[0x18] & 0x02))
2415 return;
2416
2417 xres = buffer[0x38] | ((buffer[0x3a] & 0xf0) << 4);
2418 yres = buffer[0x3b] | ((buffer[0x3d] & 0xf0) << 4);
2419
2420 switch(xres) {
2421 case 1024:
2422 if(yres == 768)
2423 paneltype = 0x02;
2424 break;
2425 case 1280:
2426 if(yres == 1024)
2427 paneltype = 0x03;
2428 break;
2429 case 1600:
2430 if((yres == 1200) && (ivideo->vbflags2 & VB2_30xC))
2431 paneltype = 0x0b;
2432 break;
2433 }
2434
2435 if(!paneltype)
2436 return;
2437
2438 if(buffer[0x23])
2439 cr37 |= 0x10;
2440
2441 if((buffer[0x47] & 0x18) == 0x18)
2442 cr37 |= ((((buffer[0x47] & 0x06) ^ 0x06) << 5) | 0x20);
2443 else
2444 cr37 |= 0xc0;
2445
2446 outSISIDXREG(SISCR, 0x36, paneltype);
2447 cr37 &= 0xf1;
2448 setSISIDXREG(SISCR, 0x37, 0x0c, cr37);
2449 orSISIDXREG(SISCR, 0x32, 0x08);
2450
2451 ivideo->SiS_Pr.PanelSelfDetected = TRUE;
2452 }
2453
2454 static int __devinit
2455 SISDoSense(struct sis_video_info *ivideo, u16 type, u16 test)
2456 {
2457 int temp, mytest, result, i, j;
2458
2459 for(j = 0; j < 10; j++) {
2460 result = 0;
2461 for(i = 0; i < 3; i++) {
2462 mytest = test;
2463 outSISIDXREG(SISPART4,0x11,(type & 0x00ff));
2464 temp = (type >> 8) | (mytest & 0x00ff);
2465 setSISIDXREG(SISPART4,0x10,0xe0,temp);
2466 SiS_DDC2Delay(&ivideo->SiS_Pr, 0x1500);
2467 mytest >>= 8;
2468 mytest &= 0x7f;
2469 inSISIDXREG(SISPART4,0x03,temp);
2470 temp ^= 0x0e;
2471 temp &= mytest;
2472 if(temp == mytest) result++;
2473 #if 1
2474 outSISIDXREG(SISPART4,0x11,0x00);
2475 andSISIDXREG(SISPART4,0x10,0xe0);
2476 SiS_DDC2Delay(&ivideo->SiS_Pr, 0x1000);
2477 #endif
2478 }
2479 if((result == 0) || (result >= 2)) break;
2480 }
2481 return result;
2482 }
2483
2484 static void __devinit
2485 SiS_Sense30x(struct sis_video_info *ivideo)
2486 {
2487 u8 backupP4_0d,backupP2_00,backupP2_4d,backupSR_1e,biosflag=0;
2488 u16 svhs=0, svhs_c=0;
2489 u16 cvbs=0, cvbs_c=0;
2490 u16 vga2=0, vga2_c=0;
2491 int myflag, result;
2492 char stdstr[] = "sisfb: Detected";
2493 char tvstr[] = "TV connected to";
2494
2495 if(ivideo->vbflags2 & VB2_301) {
2496 svhs = 0x00b9; cvbs = 0x00b3; vga2 = 0x00d1;
2497 inSISIDXREG(SISPART4,0x01,myflag);
2498 if(myflag & 0x04) {
2499 svhs = 0x00dd; cvbs = 0x00ee; vga2 = 0x00fd;
2500 }
2501 } else if(ivideo->vbflags2 & (VB2_301B | VB2_302B)) {
2502 svhs = 0x016b; cvbs = 0x0174; vga2 = 0x0190;
2503 } else if(ivideo->vbflags2 & (VB2_301LV | VB2_302LV)) {
2504 svhs = 0x0200; cvbs = 0x0100;
2505 } else if(ivideo->vbflags2 & (VB2_301C | VB2_302ELV | VB2_307T | VB2_307LV)) {
2506 svhs = 0x016b; cvbs = 0x0110; vga2 = 0x0190;
2507 } else
2508 return;
2509
2510 vga2_c = 0x0e08; svhs_c = 0x0404; cvbs_c = 0x0804;
2511 if(ivideo->vbflags & (VB2_301LV|VB2_302LV|VB2_302ELV|VB2_307LV)) {
2512 svhs_c = 0x0408; cvbs_c = 0x0808;
2513 }
2514
2515 biosflag = 2;
2516 if(ivideo->haveXGIROM) {
2517 biosflag = ivideo->bios_abase[0x58] & 0x03;
2518 } else if(ivideo->newrom) {
2519 if(ivideo->bios_abase[0x5d] & 0x04) biosflag |= 0x01;
2520 } else if(ivideo->sisvga_engine == SIS_300_VGA) {
2521 if(ivideo->bios_abase) {
2522 biosflag = ivideo->bios_abase[0xfe] & 0x03;
2523 }
2524 }
2525
2526 if(ivideo->chip == SIS_300) {
2527 inSISIDXREG(SISSR,0x3b,myflag);
2528 if(!(myflag & 0x01)) vga2 = vga2_c = 0;
2529 }
2530
2531 if(!(ivideo->vbflags2 & VB2_SISVGA2BRIDGE)) {
2532 vga2 = vga2_c = 0;
2533 }
2534
2535 inSISIDXREG(SISSR,0x1e,backupSR_1e);
2536 orSISIDXREG(SISSR,0x1e,0x20);
2537
2538 inSISIDXREG(SISPART4,0x0d,backupP4_0d);
2539 if(ivideo->vbflags2 & VB2_30xC) {
2540 setSISIDXREG(SISPART4,0x0d,~0x07,0x01);
2541 } else {
2542 orSISIDXREG(SISPART4,0x0d,0x04);
2543 }
2544 SiS_DDC2Delay(&ivideo->SiS_Pr, 0x2000);
2545
2546 inSISIDXREG(SISPART2,0x00,backupP2_00);
2547 outSISIDXREG(SISPART2,0x00,((backupP2_00 | 0x1c) & 0xfc));
2548
2549 inSISIDXREG(SISPART2,0x4d,backupP2_4d);
2550 if(ivideo->vbflags2 & VB2_SISYPBPRBRIDGE) {
2551 outSISIDXREG(SISPART2,0x4d,(backupP2_4d & ~0x10));
2552 }
2553
2554 if(!(ivideo->vbflags2 & VB2_30xCLV)) {
2555 SISDoSense(ivideo, 0, 0);
2556 }
2557
2558 andSISIDXREG(SISCR, 0x32, ~0x14);
2559
2560 if(vga2_c || vga2) {
2561 if(SISDoSense(ivideo, vga2, vga2_c)) {
2562 if(biosflag & 0x01) {
2563 printk(KERN_INFO "%s %s SCART output\n", stdstr, tvstr);
2564 orSISIDXREG(SISCR, 0x32, 0x04);
2565 } else {
2566 printk(KERN_INFO "%s secondary VGA connection\n", stdstr);
2567 orSISIDXREG(SISCR, 0x32, 0x10);
2568 }
2569 }
2570 }
2571
2572 andSISIDXREG(SISCR, 0x32, 0x3f);
2573
2574 if(ivideo->vbflags2 & VB2_30xCLV) {
2575 orSISIDXREG(SISPART4,0x0d,0x04);
2576 }
2577
2578 if((ivideo->sisvga_engine == SIS_315_VGA) && (ivideo->vbflags2 & VB2_SISYPBPRBRIDGE)) {
2579 outSISIDXREG(SISPART2,0x4d,(backupP2_4d | 0x10));
2580 SiS_DDC2Delay(&ivideo->SiS_Pr, 0x2000);
2581 if((result = SISDoSense(ivideo, svhs, 0x0604))) {
2582 if((result = SISDoSense(ivideo, cvbs, 0x0804))) {
2583 printk(KERN_INFO "%s %s YPbPr component output\n", stdstr, tvstr);
2584 orSISIDXREG(SISCR,0x32,0x80);
2585 }
2586 }
2587 outSISIDXREG(SISPART2,0x4d,backupP2_4d);
2588 }
2589
2590 andSISIDXREG(SISCR, 0x32, ~0x03);
2591
2592 if(!(ivideo->vbflags & TV_YPBPR)) {
2593 if((result = SISDoSense(ivideo, svhs, svhs_c))) {
2594 printk(KERN_INFO "%s %s SVIDEO output\n", stdstr, tvstr);
2595 orSISIDXREG(SISCR, 0x32, 0x02);
2596 }
2597 if((biosflag & 0x02) || (!result)) {
2598 if(SISDoSense(ivideo, cvbs, cvbs_c)) {
2599 printk(KERN_INFO "%s %s COMPOSITE output\n", stdstr, tvstr);
2600 orSISIDXREG(SISCR, 0x32, 0x01);
2601 }
2602 }
2603 }
2604
2605 SISDoSense(ivideo, 0, 0);
2606
2607 outSISIDXREG(SISPART2,0x00,backupP2_00);
2608 outSISIDXREG(SISPART4,0x0d,backupP4_0d);
2609 outSISIDXREG(SISSR,0x1e,backupSR_1e);
2610
2611 if(ivideo->vbflags2 & VB2_30xCLV) {
2612 inSISIDXREG(SISPART2,0x00,biosflag);
2613 if(biosflag & 0x20) {
2614 for(myflag = 2; myflag > 0; myflag--) {
2615 biosflag ^= 0x20;
2616 outSISIDXREG(SISPART2,0x00,biosflag);
2617 }
2618 }
2619 }
2620
2621 outSISIDXREG(SISPART2,0x00,backupP2_00);
2622 }
2623
2624 /* Determine and detect attached TV's on Chrontel */
2625 static void __devinit
2626 SiS_SenseCh(struct sis_video_info *ivideo)
2627 {
2628 #if defined(CONFIG_FB_SIS_300) || defined(CONFIG_FB_SIS_315)
2629 u8 temp1, temp2;
2630 char stdstr[] = "sisfb: Chrontel: Detected TV connected to";
2631 #endif
2632 #ifdef CONFIG_FB_SIS_300
2633 unsigned char test[3];
2634 int i;
2635 #endif
2636
2637 if(ivideo->chip < SIS_315H) {
2638
2639 #ifdef CONFIG_FB_SIS_300
2640 ivideo->SiS_Pr.SiS_IF_DEF_CH70xx = 1; /* Chrontel 700x */
2641 SiS_SetChrontelGPIO(&ivideo->SiS_Pr, 0x9c); /* Set general purpose IO for Chrontel communication */
2642 SiS_DDC2Delay(&ivideo->SiS_Pr, 1000);
2643 temp1 = SiS_GetCH700x(&ivideo->SiS_Pr, 0x25);
2644 /* See Chrontel TB31 for explanation */
2645 temp2 = SiS_GetCH700x(&ivideo->SiS_Pr, 0x0e);
2646 if(((temp2 & 0x07) == 0x01) || (temp2 & 0x04)) {
2647 SiS_SetCH700x(&ivideo->SiS_Pr, 0x0e, 0x0b);
2648 SiS_DDC2Delay(&ivideo->SiS_Pr, 300);
2649 }
2650 temp2 = SiS_GetCH700x(&ivideo->SiS_Pr, 0x25);
2651 if(temp2 != temp1) temp1 = temp2;
2652
2653 if((temp1 >= 0x22) && (temp1 <= 0x50)) {
2654 /* Read power status */
2655 temp1 = SiS_GetCH700x(&ivideo->SiS_Pr, 0x0e);
2656 if((temp1 & 0x03) != 0x03) {
2657 /* Power all outputs */
2658 SiS_SetCH700x(&ivideo->SiS_Pr, 0x0e,0x0b);
2659 SiS_DDC2Delay(&ivideo->SiS_Pr, 300);
2660 }
2661 /* Sense connected TV devices */
2662 for(i = 0; i < 3; i++) {
2663 SiS_SetCH700x(&ivideo->SiS_Pr, 0x10, 0x01);
2664 SiS_DDC2Delay(&ivideo->SiS_Pr, 0x96);
2665 SiS_SetCH700x(&ivideo->SiS_Pr, 0x10, 0x00);
2666 SiS_DDC2Delay(&ivideo->SiS_Pr, 0x96);
2667 temp1 = SiS_GetCH700x(&ivideo->SiS_Pr, 0x10);
2668 if(!(temp1 & 0x08)) test[i] = 0x02;
2669 else if(!(temp1 & 0x02)) test[i] = 0x01;
2670 else test[i] = 0;
2671 SiS_DDC2Delay(&ivideo->SiS_Pr, 0x96);
2672 }
2673
2674 if(test[0] == test[1]) temp1 = test[0];
2675 else if(test[0] == test[2]) temp1 = test[0];
2676 else if(test[1] == test[2]) temp1 = test[1];
2677 else {
2678 printk(KERN_INFO
2679 "sisfb: TV detection unreliable - test results varied\n");
2680 temp1 = test[2];
2681 }
2682 if(temp1 == 0x02) {
2683 printk(KERN_INFO "%s SVIDEO output\n", stdstr);
2684 ivideo->vbflags |= TV_SVIDEO;
2685 orSISIDXREG(SISCR, 0x32, 0x02);
2686 andSISIDXREG(SISCR, 0x32, ~0x05);
2687 } else if (temp1 == 0x01) {
2688 printk(KERN_INFO "%s CVBS output\n", stdstr);
2689 ivideo->vbflags |= TV_AVIDEO;
2690 orSISIDXREG(SISCR, 0x32, 0x01);
2691 andSISIDXREG(SISCR, 0x32, ~0x06);
2692 } else {
2693 SiS_SetCH70xxANDOR(&ivideo->SiS_Pr, 0x0e, 0x01, 0xF8);
2694 andSISIDXREG(SISCR, 0x32, ~0x07);
2695 }
2696 } else if(temp1 == 0) {
2697 SiS_SetCH70xxANDOR(&ivideo->SiS_Pr, 0x0e, 0x01, 0xF8);
2698 andSISIDXREG(SISCR, 0x32, ~0x07);
2699 }
2700 /* Set general purpose IO for Chrontel communication */
2701 SiS_SetChrontelGPIO(&ivideo->SiS_Pr, 0x00);
2702 #endif
2703
2704 } else {
2705
2706 #ifdef CONFIG_FB_SIS_315
2707 ivideo->SiS_Pr.SiS_IF_DEF_CH70xx = 2; /* Chrontel 7019 */
2708 temp1 = SiS_GetCH701x(&ivideo->SiS_Pr, 0x49);
2709 SiS_SetCH701x(&ivideo->SiS_Pr, 0x49, 0x20);
2710 SiS_DDC2Delay(&ivideo->SiS_Pr, 0x96);
2711 temp2 = SiS_GetCH701x(&ivideo->SiS_Pr, 0x20);
2712 temp2 |= 0x01;
2713 SiS_SetCH701x(&ivideo->SiS_Pr, 0x20, temp2);
2714 SiS_DDC2Delay(&ivideo->SiS_Pr, 0x96);
2715 temp2 ^= 0x01;
2716 SiS_SetCH701x(&ivideo->SiS_Pr, 0x20, temp2);
2717 SiS_DDC2Delay(&ivideo->SiS_Pr, 0x96);
2718 temp2 = SiS_GetCH701x(&ivideo->SiS_Pr, 0x20);
2719 SiS_SetCH701x(&ivideo->SiS_Pr, 0x49, temp1);
2720 temp1 = 0;
2721 if(temp2 & 0x02) temp1 |= 0x01;
2722 if(temp2 & 0x10) temp1 |= 0x01;
2723 if(temp2 & 0x04) temp1 |= 0x02;
2724 if( (temp1 & 0x01) && (temp1 & 0x02) ) temp1 = 0x04;
2725 switch(temp1) {
2726 case 0x01:
2727 printk(KERN_INFO "%s CVBS output\n", stdstr);
2728 ivideo->vbflags |= TV_AVIDEO;
2729 orSISIDXREG(SISCR, 0x32, 0x01);
2730 andSISIDXREG(SISCR, 0x32, ~0x06);
2731 break;
2732 case 0x02:
2733 printk(KERN_INFO "%s SVIDEO output\n", stdstr);
2734 ivideo->vbflags |= TV_SVIDEO;
2735 orSISIDXREG(SISCR, 0x32, 0x02);
2736 andSISIDXREG(SISCR, 0x32, ~0x05);
2737 break;
2738 case 0x04:
2739 printk(KERN_INFO "%s SCART output\n", stdstr);
2740 orSISIDXREG(SISCR, 0x32, 0x04);
2741 andSISIDXREG(SISCR, 0x32, ~0x03);
2742 break;
2743 default:
2744 andSISIDXREG(SISCR, 0x32, ~0x07);
2745 }
2746 #endif
2747 }
2748 }
2749
2750 static void __devinit
2751 sisfb_get_VB_type(struct sis_video_info *ivideo)
2752 {
2753 char stdstr[] = "sisfb: Detected";
2754 char bridgestr[] = "video bridge";
2755 u8 vb_chipid;
2756 u8 reg;
2757
2758 /* No CRT2 on XGI Z7 */
2759 if(ivideo->chip == XGI_20)
2760 return;
2761
2762 inSISIDXREG(SISPART4, 0x00, vb_chipid);
2763 switch(vb_chipid) {
2764 case 0x01:
2765 inSISIDXREG(SISPART4, 0x01, reg);
2766 if(reg < 0xb0) {
2767 ivideo->vbflags |= VB_301; /* Deprecated */
2768 ivideo->vbflags2 |= VB2_301;
2769 printk(KERN_INFO "%s SiS301 %s\n", stdstr, bridgestr);
2770 } else if(reg < 0xc0) {
2771 ivideo->vbflags |= VB_301B; /* Deprecated */
2772 ivideo->vbflags2 |= VB2_301B;
2773 inSISIDXREG(SISPART4,0x23,reg);
2774 if(!(reg & 0x02)) {
2775 ivideo->vbflags |= VB_30xBDH; /* Deprecated */
2776 ivideo->vbflags2 |= VB2_30xBDH;
2777 printk(KERN_INFO "%s SiS301B-DH %s\n", stdstr, bridgestr);
2778 } else {
2779 printk(KERN_INFO "%s SiS301B %s\n", stdstr, bridgestr);
2780 }
2781 } else if(reg < 0xd0) {
2782 ivideo->vbflags |= VB_301C; /* Deprecated */
2783 ivideo->vbflags2 |= VB2_301C;
2784 printk(KERN_INFO "%s SiS301C %s\n", stdstr, bridgestr);
2785 } else if(reg < 0xe0) {
2786 ivideo->vbflags |= VB_301LV; /* Deprecated */
2787 ivideo->vbflags2 |= VB2_301LV;
2788 printk(KERN_INFO "%s SiS301LV %s\n", stdstr, bridgestr);
2789 } else if(reg <= 0xe1) {
2790 inSISIDXREG(SISPART4,0x39,reg);
2791 if(reg == 0xff) {
2792 ivideo->vbflags |= VB_302LV; /* Deprecated */
2793 ivideo->vbflags2 |= VB2_302LV;
2794 printk(KERN_INFO "%s SiS302LV %s\n", stdstr, bridgestr);
2795 } else {
2796 ivideo->vbflags |= VB_301C; /* Deprecated */
2797 ivideo->vbflags2 |= VB2_301C;
2798 printk(KERN_INFO "%s SiS301C(P4) %s\n", stdstr, bridgestr);
2799 #if 0
2800 ivideo->vbflags |= VB_302ELV; /* Deprecated */
2801 ivideo->vbflags2 |= VB2_302ELV;
2802 printk(KERN_INFO "%s SiS302ELV %s\n", stdstr, bridgestr);
2803 #endif
2804 }
2805 }
2806 break;
2807 case 0x02:
2808 ivideo->vbflags |= VB_302B; /* Deprecated */
2809 ivideo->vbflags2 |= VB2_302B;
2810 printk(KERN_INFO "%s SiS302B %s\n", stdstr, bridgestr);
2811 break;
2812 }
2813
2814 if((!(ivideo->vbflags2 & VB2_VIDEOBRIDGE)) && (ivideo->chip != SIS_300)) {
2815 inSISIDXREG(SISCR, 0x37, reg);
2816 reg &= SIS_EXTERNAL_CHIP_MASK;
2817 reg >>= 1;
2818 if(ivideo->sisvga_engine == SIS_300_VGA) {
2819 #ifdef CONFIG_FB_SIS_300
2820 switch(reg) {
2821 case SIS_EXTERNAL_CHIP_LVDS:
2822 ivideo->vbflags |= VB_LVDS; /* Deprecated */
2823 ivideo->vbflags2 |= VB2_LVDS;
2824 break;
2825 case SIS_EXTERNAL_CHIP_TRUMPION:
2826 ivideo->vbflags |= (VB_LVDS | VB_TRUMPION); /* Deprecated */
2827 ivideo->vbflags2 |= (VB2_LVDS | VB2_TRUMPION);
2828 break;
2829 case SIS_EXTERNAL_CHIP_CHRONTEL:
2830 ivideo->vbflags |= VB_CHRONTEL; /* Deprecated */
2831 ivideo->vbflags2 |= VB2_CHRONTEL;
2832 break;
2833 case SIS_EXTERNAL_CHIP_LVDS_CHRONTEL:
2834 ivideo->vbflags |= (VB_LVDS | VB_CHRONTEL); /* Deprecated */
2835 ivideo->vbflags2 |= (VB2_LVDS | VB2_CHRONTEL);
2836 break;
2837 }
2838 if(ivideo->vbflags2 & VB2_CHRONTEL) ivideo->chronteltype = 1;
2839 #endif
2840 } else if(ivideo->chip < SIS_661) {
2841 #ifdef CONFIG_FB_SIS_315
2842 switch (reg) {
2843 case SIS310_EXTERNAL_CHIP_LVDS:
2844 ivideo->vbflags |= VB_LVDS; /* Deprecated */
2845 ivideo->vbflags2 |= VB2_LVDS;
2846 break;
2847 case SIS310_EXTERNAL_CHIP_LVDS_CHRONTEL:
2848 ivideo->vbflags |= (VB_LVDS | VB_CHRONTEL); /* Deprecated */
2849 ivideo->vbflags2 |= (VB2_LVDS | VB2_CHRONTEL);
2850 break;
2851 }
2852 if(ivideo->vbflags2 & VB2_CHRONTEL) ivideo->chronteltype = 2;
2853 #endif
2854 } else if(ivideo->chip >= SIS_661) {
2855 #ifdef CONFIG_FB_SIS_315
2856 inSISIDXREG(SISCR, 0x38, reg);
2857 reg >>= 5;
2858 switch(reg) {
2859 case 0x02:
2860 ivideo->vbflags |= VB_LVDS; /* Deprecated */
2861 ivideo->vbflags2 |= VB2_LVDS;
2862 break;
2863 case 0x03:
2864 ivideo->vbflags |= (VB_LVDS | VB_CHRONTEL); /* Deprecated */
2865 ivideo->vbflags2 |= (VB2_LVDS | VB2_CHRONTEL);
2866 break;
2867 case 0x04:
2868 ivideo->vbflags |= (VB_LVDS | VB_CONEXANT); /* Deprecated */
2869 ivideo->vbflags2 |= (VB2_LVDS | VB2_CONEXANT);
2870 break;
2871 }
2872 if(ivideo->vbflags2 & VB2_CHRONTEL) ivideo->chronteltype = 2;
2873 #endif
2874 }
2875 if(ivideo->vbflags2 & VB2_LVDS) {
2876 printk(KERN_INFO "%s LVDS transmitter\n", stdstr);
2877 }
2878 if((ivideo->sisvga_engine == SIS_300_VGA) && (ivideo->vbflags2 & VB2_TRUMPION)) {
2879 printk(KERN_INFO "%s Trumpion Zurac LCD scaler\n", stdstr);
2880 }
2881 if(ivideo->vbflags2 & VB2_CHRONTEL) {
2882 printk(KERN_INFO "%s Chrontel TV encoder\n", stdstr);
2883 }
2884 if((ivideo->chip >= SIS_661) && (ivideo->vbflags2 & VB2_CONEXANT)) {
2885 printk(KERN_INFO "%s Conexant external device\n", stdstr);
2886 }
2887 }
2888
2889 if(ivideo->vbflags2 & VB2_SISBRIDGE) {
2890 SiS_SenseLCD(ivideo);
2891 SiS_Sense30x(ivideo);
2892 } else if(ivideo->vbflags2 & VB2_CHRONTEL) {
2893 SiS_SenseCh(ivideo);
2894 }
2895 }
2896
2897 /* ---------- Engine initialization routines ------------ */
2898
2899 static void
2900 sisfb_engine_init(struct sis_video_info *ivideo)
2901 {
2902
2903 /* Initialize command queue (we use MMIO only) */
2904
2905 /* BEFORE THIS IS CALLED, THE ENGINES *MUST* BE SYNC'ED */
2906
2907 ivideo->caps &= ~(TURBO_QUEUE_CAP |
2908 MMIO_CMD_QUEUE_CAP |
2909 VM_CMD_QUEUE_CAP |
2910 AGP_CMD_QUEUE_CAP);
2911
2912 #ifdef CONFIG_FB_SIS_300
2913 if(ivideo->sisvga_engine == SIS_300_VGA) {
2914 u32 tqueue_pos;
2915 u8 tq_state;
2916
2917 tqueue_pos = (ivideo->video_size - ivideo->cmdQueueSize) / (64 * 1024);
2918
2919 inSISIDXREG(SISSR, IND_SIS_TURBOQUEUE_SET, tq_state);
2920 tq_state |= 0xf0;
2921 tq_state &= 0xfc;
2922 tq_state |= (u8)(tqueue_pos >> 8);
2923 outSISIDXREG(SISSR, IND_SIS_TURBOQUEUE_SET, tq_state);
2924
2925 outSISIDXREG(SISSR, IND_SIS_TURBOQUEUE_ADR, (u8)(tqueue_pos & 0xff));
2926
2927 ivideo->caps |= TURBO_QUEUE_CAP;
2928 }
2929 #endif
2930
2931 #ifdef CONFIG_FB_SIS_315
2932 if(ivideo->sisvga_engine == SIS_315_VGA) {
2933 u32 tempq = 0, templ;
2934 u8 temp;
2935
2936 if(ivideo->chip == XGI_20) {
2937 switch(ivideo->cmdQueueSize) {
2938 case (64 * 1024):
2939 temp = SIS_CMD_QUEUE_SIZE_Z7_64k;
2940 break;
2941 case (128 * 1024):
2942 default:
2943 temp = SIS_CMD_QUEUE_SIZE_Z7_128k;
2944 }
2945 } else {
2946 switch(ivideo->cmdQueueSize) {
2947 case (4 * 1024 * 1024):
2948 temp = SIS_CMD_QUEUE_SIZE_4M;
2949 break;
2950 case (2 * 1024 * 1024):
2951 temp = SIS_CMD_QUEUE_SIZE_2M;
2952 break;
2953 case (1 * 1024 * 1024):
2954 temp = SIS_CMD_QUEUE_SIZE_1M;
2955 break;
2956 default:
2957 case (512 * 1024):
2958 temp = SIS_CMD_QUEUE_SIZE_512k;
2959 }
2960 }
2961
2962 outSISIDXREG(SISSR, IND_SIS_CMDQUEUE_THRESHOLD, COMMAND_QUEUE_THRESHOLD);
2963 outSISIDXREG(SISSR, IND_SIS_CMDQUEUE_SET, SIS_CMD_QUEUE_RESET);
2964
2965 if((ivideo->chip >= XGI_40) && ivideo->modechanged) {
2966 /* Must disable dual pipe on XGI_40. Can't do
2967 * this in MMIO mode, because it requires
2968 * setting/clearing a bit in the MMIO fire trigger
2969 * register.
2970 */
2971 if(!((templ = MMIO_IN32(ivideo->mmio_vbase, 0x8240)) & (1 << 10))) {
2972
2973 MMIO_OUT32(ivideo->mmio_vbase, Q_WRITE_PTR, 0);
2974
2975 outSISIDXREG(SISSR, IND_SIS_CMDQUEUE_SET, (temp | SIS_VRAM_CMDQUEUE_ENABLE));
2976
2977 tempq = MMIO_IN32(ivideo->mmio_vbase, Q_READ_PTR);
2978 MMIO_OUT32(ivideo->mmio_vbase, Q_WRITE_PTR, tempq);
2979
2980 tempq = (u32)(ivideo->video_size - ivideo->cmdQueueSize);
2981 MMIO_OUT32(ivideo->mmio_vbase, Q_BASE_ADDR, tempq);
2982
2983 writel(0x16800000 + 0x8240, ivideo->video_vbase + tempq);
2984 writel(templ | (1 << 10), ivideo->video_vbase + tempq + 4);
2985 writel(0x168F0000, ivideo->video_vbase + tempq + 8);
2986 writel(0x168F0000, ivideo->video_vbase + tempq + 12);
2987
2988 MMIO_OUT32(ivideo->mmio_vbase, Q_WRITE_PTR, (tempq + 16));
2989
2990 sisfb_syncaccel(ivideo);
2991
2992 outSISIDXREG(SISSR, IND_SIS_CMDQUEUE_SET, SIS_CMD_QUEUE_RESET);
2993
2994 }
2995 }
2996
2997 tempq = MMIO_IN32(ivideo->mmio_vbase, MMIO_QUEUE_READPORT);
2998 MMIO_OUT32(ivideo->mmio_vbase, MMIO_QUEUE_WRITEPORT, tempq);
2999
3000 temp |= (SIS_MMIO_CMD_ENABLE | SIS_CMD_AUTO_CORR);
3001 outSISIDXREG(SISSR, IND_SIS_CMDQUEUE_SET, temp);
3002
3003 tempq = (u32)(ivideo->video_size - ivideo->cmdQueueSize);
3004 MMIO_OUT32(ivideo->mmio_vbase, MMIO_QUEUE_PHYBASE, tempq);
3005
3006 ivideo->caps |= MMIO_CMD_QUEUE_CAP;
3007 }
3008 #endif
3009
3010 ivideo->engineok = 1;
3011 }
3012
3013 static void __devinit
3014 sisfb_detect_lcd_type(struct sis_video_info *ivideo)
3015 {
3016 u8 reg;
3017 int i;
3018
3019 inSISIDXREG(SISCR, 0x36, reg);
3020 reg &= 0x0f;
3021 if(ivideo->sisvga_engine == SIS_300_VGA) {
3022 ivideo->CRT2LCDType = sis300paneltype[reg];
3023 } else if(ivideo->chip >= SIS_661) {
3024 ivideo->CRT2LCDType = sis661paneltype[reg];
3025 } else {
3026 ivideo->CRT2LCDType = sis310paneltype[reg];
3027 if((ivideo->chip == SIS_550) && (sisfb_fstn)) {
3028 if((ivideo->CRT2LCDType != LCD_320x240_2) &&
3029 (ivideo->CRT2LCDType != LCD_320x240_3)) {
3030 ivideo->CRT2LCDType = LCD_320x240;
3031 }
3032 }
3033 }
3034
3035 if(ivideo->CRT2LCDType == LCD_UNKNOWN) {
3036 /* For broken BIOSes: Assume 1024x768, RGB18 */
3037 ivideo->CRT2LCDType = LCD_1024x768;
3038 setSISIDXREG(SISCR,0x36,0xf0,0x02);
3039 setSISIDXREG(SISCR,0x37,0xee,0x01);
3040 printk(KERN_DEBUG "sisfb: Invalid panel ID (%02x), assuming 1024x768, RGB18\n", reg);
3041 }
3042
3043 for(i = 0; i < SIS_LCD_NUMBER; i++) {
3044 if(ivideo->CRT2LCDType == sis_lcd_data[i].lcdtype) {
3045 ivideo->lcdxres = sis_lcd_data[i].xres;
3046 ivideo->lcdyres = sis_lcd_data[i].yres;
3047 ivideo->lcddefmodeidx = sis_lcd_data[i].default_mode_idx;
3048 break;
3049 }
3050 }
3051
3052 #ifdef CONFIG_FB_SIS_300
3053 if(ivideo->SiS_Pr.SiS_CustomT == CUT_BARCO1366) {
3054 ivideo->lcdxres = 1360; ivideo->lcdyres = 1024;
3055 ivideo->lcddefmodeidx = DEFAULT_MODE_1360;
3056 } else if(ivideo->SiS_Pr.SiS_CustomT == CUT_PANEL848) {
3057 ivideo->lcdxres = 848; ivideo->lcdyres = 480;
3058 ivideo->lcddefmodeidx = DEFAULT_MODE_848;
3059 } else if(ivideo->SiS_Pr.SiS_CustomT == CUT_PANEL856) {
3060 ivideo->lcdxres = 856; ivideo->lcdyres = 480;
3061 ivideo->lcddefmodeidx = DEFAULT_MODE_856;
3062 }
3063 #endif
3064
3065 printk(KERN_DEBUG "sisfb: Detected %dx%d flat panel\n",
3066 ivideo->lcdxres, ivideo->lcdyres);
3067 }
3068
3069 static void __devinit
3070 sisfb_save_pdc_emi(struct sis_video_info *ivideo)
3071 {
3072 #ifdef CONFIG_FB_SIS_300
3073 /* Save the current PanelDelayCompensation if the LCD is currently used */
3074 if(ivideo->sisvga_engine == SIS_300_VGA) {
3075 if(ivideo->vbflags2 & (VB2_LVDS | VB2_30xBDH)) {
3076 int tmp;
3077 inSISIDXREG(SISCR,0x30,tmp);
3078 if(tmp & 0x20) {
3079 /* Currently on LCD? If yes, read current pdc */
3080 inSISIDXREG(SISPART1,0x13,ivideo->detectedpdc);
3081 ivideo->detectedpdc &= 0x3c;
3082 if(ivideo->SiS_Pr.PDC == -1) {
3083 /* Let option override detection */
3084 ivideo->SiS_Pr.PDC = ivideo->detectedpdc;
3085 }
3086 printk(KERN_INFO "sisfb: Detected LCD PDC 0x%02x\n",
3087 ivideo->detectedpdc);
3088 }
3089 if((ivideo->SiS_Pr.PDC != -1) &&
3090 (ivideo->SiS_Pr.PDC != ivideo->detectedpdc)) {
3091 printk(KERN_INFO "sisfb: Using LCD PDC 0x%02x\n",
3092 ivideo->SiS_Pr.PDC);
3093 }
3094 }
3095 }
3096 #endif
3097
3098 #ifdef CONFIG_FB_SIS_315
3099 if(ivideo->sisvga_engine == SIS_315_VGA) {
3100
3101 /* Try to find about LCDA */
3102 if(ivideo->vbflags2 & VB2_SISLCDABRIDGE) {
3103 int tmp;
3104 inSISIDXREG(SISPART1,0x13,tmp);
3105 if(tmp & 0x04) {
3106 ivideo->SiS_Pr.SiS_UseLCDA = TRUE;
3107 ivideo->detectedlcda = 0x03;
3108 }
3109 }
3110
3111 /* Save PDC */
3112 if(ivideo->vbflags2 & VB2_SISLVDSBRIDGE) {
3113 int tmp;
3114 inSISIDXREG(SISCR,0x30,tmp);
3115 if((tmp & 0x20) || (ivideo->detectedlcda != 0xff)) {
3116 /* Currently on LCD? If yes, read current pdc */
3117 u8 pdc;
3118 inSISIDXREG(SISPART1,0x2D,pdc);
3119 ivideo->detectedpdc = (pdc & 0x0f) << 1;
3120 ivideo->detectedpdca = (pdc & 0xf0) >> 3;
3121 inSISIDXREG(SISPART1,0x35,pdc);
3122 ivideo->detectedpdc |= ((pdc >> 7) & 0x01);
3123 inSISIDXREG(SISPART1,0x20,pdc);
3124 ivideo->detectedpdca |= ((pdc >> 6) & 0x01);
3125 if(ivideo->newrom) {
3126 /* New ROM invalidates other PDC resp. */
3127 if(ivideo->detectedlcda != 0xff) {
3128 ivideo->detectedpdc = 0xff;
3129 } else {
3130 ivideo->detectedpdca = 0xff;
3131 }
3132 }
3133 if(ivideo->SiS_Pr.PDC == -1) {
3134 if(ivideo->detectedpdc != 0xff) {
3135 ivideo->SiS_Pr.PDC = ivideo->detectedpdc;
3136 }
3137 }
3138 if(ivideo->SiS_Pr.PDCA == -1) {
3139 if(ivideo->detectedpdca != 0xff) {
3140 ivideo->SiS_Pr.PDCA = ivideo->detectedpdca;
3141 }
3142 }
3143 if(ivideo->detectedpdc != 0xff) {
3144 printk(KERN_INFO
3145 "sisfb: Detected LCD PDC 0x%02x (for LCD=CRT2)\n",
3146 ivideo->detectedpdc);
3147 }
3148 if(ivideo->detectedpdca != 0xff) {
3149 printk(KERN_INFO
3150 "sisfb: Detected LCD PDC1 0x%02x (for LCD=CRT1)\n",
3151 ivideo->detectedpdca);
3152 }
3153 }
3154
3155 /* Save EMI */
3156 if(ivideo->vbflags2 & VB2_SISEMIBRIDGE) {
3157 inSISIDXREG(SISPART4,0x30,ivideo->SiS_Pr.EMI_30);
3158 inSISIDXREG(SISPART4,0x31,ivideo->SiS_Pr.EMI_31);
3159 inSISIDXREG(SISPART4,0x32,ivideo->SiS_Pr.EMI_32);
3160 inSISIDXREG(SISPART4,0x33,ivideo->SiS_Pr.EMI_33);
3161 ivideo->SiS_Pr.HaveEMI = TRUE;
3162 if((tmp & 0x20) || (ivideo->detectedlcda != 0xff)) {
3163 ivideo->SiS_Pr.HaveEMILCD = TRUE;
3164 }
3165 }
3166 }
3167
3168 /* Let user override detected PDCs (all bridges) */
3169 if(ivideo->vbflags2 & VB2_30xBLV) {
3170 if((ivideo->SiS_Pr.PDC != -1) &&
3171 (ivideo->SiS_Pr.PDC != ivideo->detectedpdc)) {
3172 printk(KERN_INFO "sisfb: Using LCD PDC 0x%02x (for LCD=CRT2)\n",
3173 ivideo->SiS_Pr.PDC);
3174 }
3175 if((ivideo->SiS_Pr.PDCA != -1) &&
3176 (ivideo->SiS_Pr.PDCA != ivideo->detectedpdca)) {
3177 printk(KERN_INFO "sisfb: Using LCD PDC1 0x%02x (for LCD=CRT1)\n",
3178 ivideo->SiS_Pr.PDCA);
3179 }
3180 }
3181
3182 }
3183 #endif
3184 }
3185
3186 /* -------------------- Memory manager routines ---------------------- */
3187
3188 static u32 __devinit
3189 sisfb_getheapstart(struct sis_video_info *ivideo)
3190 {
3191 u32 ret = ivideo->sisfb_parm_mem * 1024;
3192 u32 maxoffs = ivideo->video_size - ivideo->hwcursor_size - ivideo->cmdQueueSize;
3193 u32 def;
3194
3195 /* Calculate heap start = end of memory for console
3196 *
3197 * CCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDHHHHQQQQQQQQQQ
3198 * C = console, D = heap, H = HWCursor, Q = cmd-queue
3199 *
3200 * On 76x in UMA+LFB mode, the layout is as follows:
3201 * DDDDDDDDDDDCCCCCCCCCCCCCCCCCCCCCCCCHHHHQQQQQQQQQQQ
3202 * where the heap is the entire UMA area, eventually
3203 * into the LFB area if the given mem parameter is
3204 * higher than the size of the UMA memory.
3205 *
3206 * Basically given by "mem" parameter
3207 *
3208 * maximum = videosize - cmd_queue - hwcursor
3209 * (results in a heap of size 0)
3210 * default = SiS 300: depends on videosize
3211 * SiS 315/330/340/XGI: 32k below max
3212 */
3213
3214 if(ivideo->sisvga_engine == SIS_300_VGA) {
3215 if(ivideo->video_size > 0x1000000) {
3216 def = 0xc00000;
3217 } else if(ivideo->video_size > 0x800000) {
3218 def = 0x800000;
3219 } else {
3220 def = 0x400000;
3221 }
3222 } else if(ivideo->UMAsize && ivideo->LFBsize) {
3223 ret = def = 0;
3224 } else {
3225 def = maxoffs - 0x8000;
3226 }
3227
3228 /* Use default for secondary card for now (FIXME) */
3229 if((!ret) || (ret > maxoffs) || (ivideo->cardnumber != 0))
3230 ret = def;
3231
3232 return ret;
3233 }
3234
3235 static u32 __devinit
3236 sisfb_getheapsize(struct sis_video_info *ivideo)
3237 {
3238 u32 max = ivideo->video_size - ivideo->hwcursor_size - ivideo->cmdQueueSize;
3239 u32 ret = 0;
3240
3241 if(ivideo->UMAsize && ivideo->LFBsize) {
3242 if( (!ivideo->sisfb_parm_mem) ||
3243 ((ivideo->sisfb_parm_mem * 1024) > max) ||
3244 ((max - (ivideo->sisfb_parm_mem * 1024)) < ivideo->UMAsize) ) {
3245 ret = ivideo->UMAsize;
3246 max -= ivideo->UMAsize;
3247 } else {
3248 ret = max - (ivideo->sisfb_parm_mem * 1024);
3249 max = ivideo->sisfb_parm_mem * 1024;
3250 }
3251 ivideo->video_offset = ret;
3252 ivideo->sisfb_mem = max;
3253 } else {
3254 ret = max - ivideo->heapstart;
3255 ivideo->sisfb_mem = ivideo->heapstart;
3256 }
3257
3258 return ret;
3259 }
3260
3261 static int __devinit
3262 sisfb_heap_init(struct sis_video_info *ivideo)
3263 {
3264 struct SIS_OH *poh;
3265
3266 ivideo->video_offset = 0;
3267 if(ivideo->sisfb_parm_mem) {
3268 if( (ivideo->sisfb_parm_mem < (2 * 1024 * 1024)) ||
3269 (ivideo->sisfb_parm_mem > ivideo->video_size) ) {
3270 ivideo->sisfb_parm_mem = 0;
3271 }
3272 }
3273
3274 ivideo->heapstart = sisfb_getheapstart(ivideo);
3275 ivideo->sisfb_heap_size = sisfb_getheapsize(ivideo);
3276
3277 ivideo->sisfb_heap_start = ivideo->video_vbase + ivideo->heapstart;
3278 ivideo->sisfb_heap_end = ivideo->sisfb_heap_start + ivideo->sisfb_heap_size;
3279
3280 printk(KERN_INFO "sisfb: Memory heap starting at %dK, size %dK\n",
3281 (int)(ivideo->heapstart / 1024), (int)(ivideo->sisfb_heap_size / 1024));
3282
3283 ivideo->sisfb_heap.vinfo = ivideo;
3284
3285 ivideo->sisfb_heap.poha_chain = NULL;
3286 ivideo->sisfb_heap.poh_freelist = NULL;
3287
3288 poh = sisfb_poh_new_node(&ivideo->sisfb_heap);
3289 if(poh == NULL)
3290 return 1;
3291
3292 poh->poh_next = &ivideo->sisfb_heap.oh_free;
3293 poh->poh_prev = &ivideo->sisfb_heap.oh_free;
3294 poh->size = ivideo->sisfb_heap_size;
3295 poh->offset = ivideo->heapstart;
3296
3297 ivideo->sisfb_heap.oh_free.poh_next = poh;
3298 ivideo->sisfb_heap.oh_free.poh_prev = poh;
3299 ivideo->sisfb_heap.oh_free.size = 0;
3300 ivideo->sisfb_heap.max_freesize = poh->size;
3301
3302 ivideo->sisfb_heap.oh_used.poh_next = &ivideo->sisfb_heap.oh_used;
3303 ivideo->sisfb_heap.oh_used.poh_prev = &ivideo->sisfb_heap.oh_used;
3304 ivideo->sisfb_heap.oh_used.size = SENTINEL;
3305
3306 if(ivideo->cardnumber == 0) {
3307 /* For the first card, make this heap the "global" one
3308 * for old DRM (which could handle only one card)
3309 */
3310 sisfb_heap = &ivideo->sisfb_heap;
3311 }
3312
3313 return 0;
3314 }
3315
3316 static struct SIS_OH *
3317 sisfb_poh_new_node(struct SIS_HEAP *memheap)
3318 {
3319 struct SIS_OHALLOC *poha;
3320 struct SIS_OH *poh;
3321 unsigned long cOhs;
3322 int i;
3323
3324 if(memheap->poh_freelist == NULL) {
3325 poha = kmalloc(SIS_OH_ALLOC_SIZE, GFP_KERNEL);
3326 if(!poha)
3327 return NULL;
3328
3329 poha->poha_next = memheap->poha_chain;
3330 memheap->poha_chain = poha;
3331
3332 cOhs = (SIS_OH_ALLOC_SIZE - sizeof(struct SIS_OHALLOC)) / sizeof(struct SIS_OH) + 1;
3333
3334 poh = &poha->aoh[0];
3335 for(i = cOhs - 1; i != 0; i--) {
3336 poh->poh_next = poh + 1;
3337 poh = poh + 1;
3338 }
3339
3340 poh->poh_next = NULL;
3341 memheap->poh_freelist = &poha->aoh[0];
3342 }
3343
3344 poh = memheap->poh_freelist;
3345 memheap->poh_freelist = poh->poh_next;
3346
3347 return poh;
3348 }
3349
3350 static struct SIS_OH *
3351 sisfb_poh_allocate(struct SIS_HEAP *memheap, u32 size)
3352 {
3353 struct SIS_OH *pohThis;
3354 struct SIS_OH *pohRoot;
3355 int bAllocated = 0;
3356
3357 if(size > memheap->max_freesize) {
3358 DPRINTK("sisfb: Can't allocate %dk video memory\n",
3359 (unsigned int) size / 1024);
3360 return NULL;
3361 }
3362
3363 pohThis = memheap->oh_free.poh_next;
3364
3365 while(pohThis != &memheap->oh_free) {
3366 if(size <= pohThis->size) {
3367 bAllocated = 1;
3368 break;
3369 }
3370 pohThis = pohThis->poh_next;
3371 }
3372
3373 if(!bAllocated) {
3374 DPRINTK("sisfb: Can't allocate %dk video memory\n",
3375 (unsigned int) size / 1024);
3376 return NULL;
3377 }
3378
3379 if(size == pohThis->size) {
3380 pohRoot = pohThis;
3381 sisfb_delete_node(pohThis);
3382 } else {
3383 pohRoot = sisfb_poh_new_node(memheap);
3384 if(pohRoot == NULL)
3385 return NULL;
3386
3387 pohRoot->offset = pohThis->offset;
3388 pohRoot->size = size;
3389
3390 pohThis->offset += size;
3391 pohThis->size -= size;
3392 }
3393
3394 memheap->max_freesize -= size;
3395
3396 pohThis = &memheap->oh_used;
3397 sisfb_insert_node(pohThis, pohRoot);
3398
3399 return pohRoot;
3400 }
3401
3402 static void
3403 sisfb_delete_node(struct SIS_OH *poh)
3404 {
3405 poh->poh_prev->poh_next = poh->poh_next;
3406 poh->poh_next->poh_prev = poh->poh_prev;
3407 }
3408
3409 static void
3410 sisfb_insert_node(struct SIS_OH *pohList, struct SIS_OH *poh)
3411 {
3412 struct SIS_OH *pohTemp = pohList->poh_next;
3413
3414 pohList->poh_next = poh;
3415 pohTemp->poh_prev = poh;
3416
3417 poh->poh_prev = pohList;
3418 poh->poh_next = pohTemp;
3419 }
3420
3421 static struct SIS_OH *
3422 sisfb_poh_free(struct SIS_HEAP *memheap, u32 base)
3423 {
3424 struct SIS_OH *pohThis;
3425 struct SIS_OH *poh_freed;
3426 struct SIS_OH *poh_prev;
3427 struct SIS_OH *poh_next;
3428 u32 ulUpper;
3429 u32 ulLower;
3430 int foundNode = 0;
3431
3432 poh_freed = memheap->oh_used.poh_next;
3433
3434 while(poh_freed != &memheap->oh_used) {
3435 if(poh_freed->offset == base) {
3436 foundNode = 1;
3437 break;
3438 }
3439
3440 poh_freed = poh_freed->poh_next;
3441 }
3442
3443 if(!foundNode)
3444 return NULL;
3445
3446 memheap->max_freesize += poh_freed->size;
3447
3448 poh_prev = poh_next = NULL;
3449 ulUpper = poh_freed->offset + poh_freed->size;
3450 ulLower = poh_freed->offset;
3451
3452 pohThis = memheap->oh_free.poh_next;
3453
3454 while(pohThis != &memheap->oh_free) {
3455 if(pohThis->offset == ulUpper) {
3456 poh_next = pohThis;
3457 } else if((pohThis->offset + pohThis->size) == ulLower) {
3458 poh_prev = pohThis;
3459 }
3460 pohThis = pohThis->poh_next;
3461 }
3462
3463 sisfb_delete_node(poh_freed);
3464
3465 if(poh_prev && poh_next) {
3466 poh_prev->size += (poh_freed->size + poh_next->size);
3467 sisfb_delete_node(poh_next);
3468 sisfb_free_node(memheap, poh_freed);
3469 sisfb_free_node(memheap, poh_next);
3470 return poh_prev;
3471 }
3472
3473 if(poh_prev) {
3474 poh_prev->size += poh_freed->size;
3475 sisfb_free_node(memheap, poh_freed);
3476 return poh_prev;
3477 }
3478
3479 if(poh_next) {
3480 poh_next->size += poh_freed->size;
3481 poh_next->offset = poh_freed->offset;
3482 sisfb_free_node(memheap, poh_freed);
3483 return poh_next;
3484 }
3485
3486 sisfb_insert_node(&memheap->oh_free, poh_freed);
3487
3488 return poh_freed;
3489 }
3490
3491 static void
3492 sisfb_free_node(struct SIS_HEAP *memheap, struct SIS_OH *poh)
3493 {
3494 if(poh == NULL)
3495 return;
3496
3497 poh->poh_next = memheap->poh_freelist;
3498 memheap->poh_freelist = poh;
3499 }
3500
3501 static void
3502 sis_int_malloc(struct sis_video_info *ivideo, struct sis_memreq *req)
3503 {
3504 struct SIS_OH *poh = NULL;
3505
3506 if((ivideo) && (ivideo->sisfb_id == SISFB_ID) && (!ivideo->havenoheap))
3507 poh = sisfb_poh_allocate(&ivideo->sisfb_heap, (u32)req->size);
3508
3509 if(poh == NULL) {
3510 req->offset = req->size = 0;
3511 DPRINTK("sisfb: Video RAM allocation failed\n");
3512 } else {
3513 req->offset = poh->offset;
3514 req->size = poh->size;
3515 DPRINTK("sisfb: Video RAM allocation succeeded: 0x%lx\n",
3516 (poh->offset + ivideo->video_vbase));
3517 }
3518 }
3519
3520 void
3521 sis_malloc(struct sis_memreq *req)
3522 {
3523 struct sis_video_info *ivideo = sisfb_heap->vinfo;
3524
3525 if(&ivideo->sisfb_heap == sisfb_heap)
3526 sis_int_malloc(ivideo, req);
3527 else
3528 req->offset = req->size = 0;
3529 }
3530
3531 void
3532 sis_malloc_new(struct pci_dev *pdev, struct sis_memreq *req)
3533 {
3534 struct sis_video_info *ivideo = pci_get_drvdata(pdev);
3535
3536 sis_int_malloc(ivideo, req);
3537 }
3538
3539 /* sis_free: u32 because "base" is offset inside video ram, can never be >4GB */
3540
3541 static void
3542 sis_int_free(struct sis_video_info *ivideo, u32 base)
3543 {
3544 struct SIS_OH *poh;
3545
3546 if((!ivideo) || (ivideo->sisfb_id != SISFB_ID) || (ivideo->havenoheap))
3547 return;
3548
3549 poh = sisfb_poh_free(&ivideo->sisfb_heap, base);
3550
3551 if(poh == NULL) {
3552 DPRINTK("sisfb: sisfb_poh_free() failed at base 0x%x\n",
3553 (unsigned int) base);
3554 }
3555 }
3556
3557 void
3558 sis_free(u32 base)
3559 {
3560 struct sis_video_info *ivideo = sisfb_heap->vinfo;
3561
3562 sis_int_free(ivideo, base);
3563 }
3564
3565 void
3566 sis_free_new(struct pci_dev *pdev, u32 base)
3567 {
3568 struct sis_video_info *ivideo = pci_get_drvdata(pdev);
3569
3570 sis_int_free(ivideo, base);
3571 }
3572
3573 /* --------------------- SetMode routines ------------------------- */
3574
3575 static void
3576 sisfb_check_engine_and_sync(struct sis_video_info *ivideo)
3577 {
3578 u8 cr30, cr31;
3579
3580 /* Check if MMIO and engines are enabled,
3581 * and sync in case they are. Can't use
3582 * ivideo->accel here, as this might have
3583 * been changed before this is called.
3584 */
3585 inSISIDXREG(SISSR, IND_SIS_PCI_ADDRESS_SET, cr30);
3586 inSISIDXREG(SISSR, IND_SIS_MODULE_ENABLE, cr31);
3587 /* MMIO and 2D/3D engine enabled? */
3588 if((cr30 & SIS_MEM_MAP_IO_ENABLE) && (cr31 & 0x42)) {
3589 #ifdef CONFIG_FB_SIS_300
3590 if(ivideo->sisvga_engine == SIS_300_VGA) {
3591 /* Don't care about TurboQueue. It's
3592 * enough to know that the engines
3593 * are enabled
3594 */
3595 sisfb_syncaccel(ivideo);
3596 }
3597 #endif
3598 #ifdef CONFIG_FB_SIS_315
3599 if(ivideo->sisvga_engine == SIS_315_VGA) {
3600 /* Check that any queue mode is
3601 * enabled, and that the queue
3602 * is not in the state of "reset"
3603 */
3604 inSISIDXREG(SISSR, 0x26, cr30);
3605 if((cr30 & 0xe0) && (!(cr30 & 0x01))) {
3606 sisfb_syncaccel(ivideo);
3607 }
3608 }
3609 #endif
3610 }
3611 }
3612
3613 static void
3614 sisfb_pre_setmode(struct sis_video_info *ivideo)
3615 {
3616 u8 cr30 = 0, cr31 = 0, cr33 = 0, cr35 = 0, cr38 = 0;
3617 int tvregnum = 0;
3618
3619 ivideo->currentvbflags &= (VB_VIDEOBRIDGE | VB_DISPTYPE_DISP2);
3620
3621 outSISIDXREG(SISSR, 0x05, 0x86);
3622
3623 inSISIDXREG(SISCR, 0x31, cr31);
3624 cr31 &= ~0x60;
3625 cr31 |= 0x04;
3626
3627 cr33 = ivideo->rate_idx & 0x0F;
3628
3629 #ifdef CONFIG_FB_SIS_315
3630 if(ivideo->sisvga_engine == SIS_315_VGA) {
3631 if(ivideo->chip >= SIS_661) {
3632 inSISIDXREG(SISCR, 0x38, cr38);
3633 cr38 &= ~0x07; /* Clear LCDA/DualEdge and YPbPr bits */
3634 } else {
3635 tvregnum = 0x38;
3636 inSISIDXREG(SISCR, tvregnum, cr38);
3637 cr38 &= ~0x3b; /* Clear LCDA/DualEdge and YPbPr bits */
3638 }
3639 }
3640 #endif
3641 #ifdef CONFIG_FB_SIS_300
3642 if(ivideo->sisvga_engine == SIS_300_VGA) {
3643 tvregnum = 0x35;
3644 inSISIDXREG(SISCR, tvregnum, cr38);
3645 }
3646 #endif
3647
3648 SiS_SetEnableDstn(&ivideo->SiS_Pr, FALSE);
3649 SiS_SetEnableFstn(&ivideo->SiS_Pr, FALSE);
3650 ivideo->curFSTN = ivideo->curDSTN = 0;
3651
3652 switch(ivideo->currentvbflags & VB_DISPTYPE_DISP2) {
3653
3654 case CRT2_TV:
3655 cr38 &= ~0xc0; /* Clear PAL-M / PAL-N bits */
3656 if((ivideo->vbflags & TV_YPBPR) && (ivideo->vbflags2 & VB2_SISYPBPRBRIDGE)) {
3657 #ifdef CONFIG_FB_SIS_315
3658 if(ivideo->chip >= SIS_661) {
3659 cr38 |= 0x04;
3660 if(ivideo->vbflags & TV_YPBPR525P) cr35 |= 0x20;
3661 else if(ivideo->vbflags & TV_YPBPR750P) cr35 |= 0x40;
3662 else if(ivideo->vbflags & TV_YPBPR1080I) cr35 |= 0x60;
3663 cr30 |= SIS_SIMULTANEOUS_VIEW_ENABLE;
3664 cr35 &= ~0x01;
3665 ivideo->currentvbflags |= (TV_YPBPR | (ivideo->vbflags & TV_YPBPRALL));
3666 } else if(ivideo->sisvga_engine == SIS_315_VGA) {
3667 cr30 |= (0x80 | SIS_SIMULTANEOUS_VIEW_ENABLE);
3668 cr38 |= 0x08;
3669 if(ivideo->vbflags & TV_YPBPR525P) cr38 |= 0x10;
3670 else if(ivideo->vbflags & TV_YPBPR750P) cr38 |= 0x20;
3671 else if(ivideo->vbflags & TV_YPBPR1080I) cr38 |= 0x30;
3672 cr31 &= ~0x01;
3673 ivideo->currentvbflags |= (TV_YPBPR | (ivideo->vbflags & TV_YPBPRALL));
3674 }
3675 #endif
3676 } else if((ivideo->vbflags & TV_HIVISION) &&
3677 (ivideo->vbflags2 & VB2_SISHIVISIONBRIDGE)) {
3678 if(ivideo->chip >= SIS_661) {
3679 cr38 |= 0x04;
3680 cr35 |= 0x60;
3681 } else {
3682 cr30 |= 0x80;
3683 }
3684 cr30 |= SIS_SIMULTANEOUS_VIEW_ENABLE;
3685 cr31 |= 0x01;
3686 cr35 |= 0x01;
3687 ivideo->currentvbflags |= TV_HIVISION;
3688 } else if(ivideo->vbflags & TV_SCART) {
3689 cr30 = (SIS_VB_OUTPUT_SCART | SIS_SIMULTANEOUS_VIEW_ENABLE);
3690 cr31 |= 0x01;
3691 cr35 |= 0x01;
3692 ivideo->currentvbflags |= TV_SCART;
3693 } else {
3694 if(ivideo->vbflags & TV_SVIDEO) {
3695 cr30 = (SIS_VB_OUTPUT_SVIDEO | SIS_SIMULTANEOUS_VIEW_ENABLE);
3696 ivideo->currentvbflags |= TV_SVIDEO;
3697 }
3698 if(ivideo->vbflags & TV_AVIDEO) {
3699 cr30 = (SIS_VB_OUTPUT_COMPOSITE | SIS_SIMULTANEOUS_VIEW_ENABLE);
3700 ivideo->currentvbflags |= TV_AVIDEO;
3701 }
3702 }
3703 cr31 |= SIS_DRIVER_MODE;
3704
3705 if(ivideo->vbflags & (TV_AVIDEO | TV_SVIDEO)) {
3706 if(ivideo->vbflags & TV_PAL) {
3707 cr31 |= 0x01; cr35 |= 0x01;
3708 ivideo->currentvbflags |= TV_PAL;
3709 if(ivideo->vbflags & TV_PALM) {
3710 cr38 |= 0x40; cr35 |= 0x04;
3711 ivideo->currentvbflags |= TV_PALM;
3712 } else if(ivideo->vbflags & TV_PALN) {
3713 cr38 |= 0x80; cr35 |= 0x08;
3714 ivideo->currentvbflags |= TV_PALN;
3715 }
3716 } else {
3717 cr31 &= ~0x01; cr35 &= ~0x01;
3718 ivideo->currentvbflags |= TV_NTSC;
3719 if(ivideo->vbflags & TV_NTSCJ) {
3720 cr38 |= 0x40; cr35 |= 0x02;
3721 ivideo->currentvbflags |= TV_NTSCJ;
3722 }
3723 }
3724 }
3725 break;
3726
3727 case CRT2_LCD:
3728 cr30 = (SIS_VB_OUTPUT_LCD | SIS_SIMULTANEOUS_VIEW_ENABLE);
3729 cr31 |= SIS_DRIVER_MODE;
3730 SiS_SetEnableDstn(&ivideo->SiS_Pr, ivideo->sisfb_dstn);
3731 SiS_SetEnableFstn(&ivideo->SiS_Pr, ivideo->sisfb_fstn);
3732 ivideo->curFSTN = ivideo->sisfb_fstn;
3733 ivideo->curDSTN = ivideo->sisfb_dstn;
3734 break;
3735
3736 case CRT2_VGA:
3737 cr30 = (SIS_VB_OUTPUT_CRT2 | SIS_SIMULTANEOUS_VIEW_ENABLE);
3738 cr31 |= SIS_DRIVER_MODE;
3739 if(ivideo->sisfb_nocrt2rate) {
3740 cr33 |= (sisbios_mode[ivideo->sisfb_mode_idx].rate_idx << 4);
3741 } else {
3742 cr33 |= ((ivideo->rate_idx & 0x0F) << 4);
3743 }
3744 break;
3745
3746 default: /* disable CRT2 */
3747 cr30 = 0x00;
3748 cr31 |= (SIS_DRIVER_MODE | SIS_VB_OUTPUT_DISABLE);
3749 }
3750
3751 outSISIDXREG(SISCR, 0x30, cr30);
3752 outSISIDXREG(SISCR, 0x33, cr33);
3753
3754 if(ivideo->chip >= SIS_661) {
3755 #ifdef CONFIG_FB_SIS_315
3756 cr31 &= ~0x01; /* Clear PAL flag (now in CR35) */
3757 setSISIDXREG(SISCR, 0x35, ~0x10, cr35); /* Leave overscan bit alone */
3758 cr38 &= 0x07; /* Use only LCDA and HiVision/YPbPr bits */
3759 setSISIDXREG(SISCR, 0x38, 0xf8, cr38);
3760 #endif
3761 } else if(ivideo->chip != SIS_300) {
3762 outSISIDXREG(SISCR, tvregnum, cr38);
3763 }
3764 outSISIDXREG(SISCR, 0x31, cr31);
3765
3766 ivideo->SiS_Pr.SiS_UseOEM = ivideo->sisfb_useoem;
3767
3768 sisfb_check_engine_and_sync(ivideo);
3769 }
3770
3771 /* Fix SR11 for 661 and later */
3772 #ifdef CONFIG_FB_SIS_315
3773 static void
3774 sisfb_fixup_SR11(struct sis_video_info *ivideo)
3775 {
3776 u8 tmpreg;
3777
3778 if(ivideo->chip >= SIS_661) {
3779 inSISIDXREG(SISSR,0x11,tmpreg);
3780 if(tmpreg & 0x20) {
3781 inSISIDXREG(SISSR,0x3e,tmpreg);
3782 tmpreg = (tmpreg + 1) & 0xff;
3783 outSISIDXREG(SISSR,0x3e,tmpreg);
3784 inSISIDXREG(SISSR,0x11,tmpreg);
3785 }
3786 if(tmpreg & 0xf0) {
3787 andSISIDXREG(SISSR,0x11,0x0f);
3788 }
3789 }
3790 }
3791 #endif
3792
3793 static void
3794 sisfb_set_TVxposoffset(struct sis_video_info *ivideo, int val)
3795 {
3796 if(val > 32) val = 32;
3797 if(val < -32) val = -32;
3798 ivideo->tvxpos = val;
3799
3800 if(ivideo->sisfblocked) return;
3801 if(!ivideo->modechanged) return;
3802
3803 if(ivideo->currentvbflags & CRT2_TV) {
3804
3805 if(ivideo->vbflags2 & VB2_CHRONTEL) {
3806
3807 int x = ivideo->tvx;
3808
3809 switch(ivideo->chronteltype) {
3810 case 1:
3811 x += val;
3812 if(x < 0) x = 0;
3813 outSISIDXREG(SISSR,0x05,0x86);
3814 SiS_SetCH700x(&ivideo->SiS_Pr, 0x0a, (x & 0xff));
3815 SiS_SetCH70xxANDOR(&ivideo->SiS_Pr, 0x08, ((x & 0x0100) >> 7), 0xFD);
3816 break;
3817 case 2:
3818 /* Not supported by hardware */
3819 break;
3820 }
3821
3822 } else if(ivideo->vbflags2 & VB2_SISBRIDGE) {
3823
3824 u8 p2_1f,p2_20,p2_2b,p2_42,p2_43;
3825 unsigned short temp;
3826
3827 p2_1f = ivideo->p2_1f;
3828 p2_20 = ivideo->p2_20;
3829 p2_2b = ivideo->p2_2b;
3830 p2_42 = ivideo->p2_42;
3831 p2_43 = ivideo->p2_43;
3832
3833 temp = p2_1f | ((p2_20 & 0xf0) << 4);
3834 temp += (val * 2);
3835 p2_1f = temp & 0xff;
3836 p2_20 = (temp & 0xf00) >> 4;
3837 p2_2b = ((p2_2b & 0x0f) + (val * 2)) & 0x0f;
3838 temp = p2_43 | ((p2_42 & 0xf0) << 4);
3839 temp += (val * 2);
3840 p2_43 = temp & 0xff;
3841 p2_42 = (temp & 0xf00) >> 4;
3842 outSISIDXREG(SISPART2,0x1f,p2_1f);
3843 setSISIDXREG(SISPART2,0x20,0x0F,p2_20);
3844 setSISIDXREG(SISPART2,0x2b,0xF0,p2_2b);
3845 setSISIDXREG(SISPART2,0x42,0x0F,p2_42);
3846 outSISIDXREG(SISPART2,0x43,p2_43);
3847 }
3848 }
3849 }
3850
3851 static void
3852 sisfb_set_TVyposoffset(struct sis_video_info *ivideo, int val)
3853 {
3854 if(val > 32) val = 32;
3855 if(val < -32) val = -32;
3856 ivideo->tvypos = val;
3857
3858 if(ivideo->sisfblocked) return;
3859 if(!ivideo->modechanged) return;
3860
3861 if(ivideo->currentvbflags & CRT2_TV) {
3862
3863 if(ivideo->vbflags2 & VB2_CHRONTEL) {
3864
3865 int y = ivideo->tvy;
3866
3867 switch(ivideo->chronteltype) {
3868 case 1:
3869 y -= val;
3870 if(y < 0) y = 0;
3871 outSISIDXREG(SISSR,0x05,0x86);
3872 SiS_SetCH700x(&ivideo->SiS_Pr, 0x0b, (y & 0xff));
3873 SiS_SetCH70xxANDOR(&ivideo->SiS_Pr, 0x08, ((y & 0x0100) >> 8), 0xFE);
3874 break;
3875 case 2:
3876 /* Not supported by hardware */
3877 break;
3878 }
3879
3880 } else if(ivideo->vbflags2 & VB2_SISBRIDGE) {
3881
3882 char p2_01, p2_02;
3883 val /= 2;
3884 p2_01 = ivideo->p2_01;
3885 p2_02 = ivideo->p2_02;
3886
3887 p2_01 += val;
3888 p2_02 += val;
3889 if(!(ivideo->currentvbflags & (TV_HIVISION | TV_YPBPR))) {
3890 while((p2_01 <= 0) || (p2_02 <= 0)) {
3891 p2_01 += 2;
3892 p2_02 += 2;
3893 }
3894 }
3895 outSISIDXREG(SISPART2,0x01,p2_01);
3896 outSISIDXREG(SISPART2,0x02,p2_02);
3897 }
3898 }
3899 }
3900
3901 static void
3902 sisfb_post_setmode(struct sis_video_info *ivideo)
3903 {
3904 BOOLEAN crt1isoff = FALSE;
3905 BOOLEAN doit = TRUE;
3906 #if defined(CONFIG_FB_SIS_300) || defined(CONFIG_FB_SIS_315)
3907 u8 reg;
3908 #endif
3909 #ifdef CONFIG_FB_SIS_315
3910 u8 reg1;
3911 #endif
3912
3913 outSISIDXREG(SISSR, 0x05, 0x86);
3914
3915 #ifdef CONFIG_FB_SIS_315
3916 sisfb_fixup_SR11(ivideo);
3917 #endif
3918
3919 /* Now we actually HAVE changed the display mode */
3920 ivideo->modechanged = 1;
3921
3922 /* We can't switch off CRT1 if bridge is in slave mode */
3923 if(ivideo->vbflags2 & VB2_VIDEOBRIDGE) {
3924 if(sisfb_bridgeisslave(ivideo)) doit = FALSE;
3925 } else
3926 ivideo->sisfb_crt1off = 0;
3927
3928 #ifdef CONFIG_FB_SIS_300
3929 if(ivideo->sisvga_engine == SIS_300_VGA) {
3930 if((ivideo->sisfb_crt1off) && (doit)) {
3931 crt1isoff = TRUE;
3932 reg = 0x00;
3933 } else {
3934 crt1isoff = FALSE;
3935 reg = 0x80;
3936 }
3937 setSISIDXREG(SISCR, 0x17, 0x7f, reg);
3938 }
3939 #endif
3940 #ifdef CONFIG_FB_SIS_315
3941 if(ivideo->sisvga_engine == SIS_315_VGA) {
3942 if((ivideo->sisfb_crt1off) && (doit)) {
3943 crt1isoff = TRUE;
3944 reg = 0x40;
3945 reg1 = 0xc0;
3946 } else {
3947 crt1isoff = FALSE;
3948 reg = 0x00;
3949 reg1 = 0x00;
3950 }
3951 setSISIDXREG(SISCR, ivideo->SiS_Pr.SiS_MyCR63, ~0x40, reg);
3952 setSISIDXREG(SISSR, 0x1f, ~0xc0, reg1);
3953 }
3954 #endif
3955
3956 if(crt1isoff) {
3957 ivideo->currentvbflags &= ~VB_DISPTYPE_CRT1;
3958 ivideo->currentvbflags |= VB_SINGLE_MODE;
3959 } else {
3960 ivideo->currentvbflags |= VB_DISPTYPE_CRT1;
3961 if(ivideo->currentvbflags & VB_DISPTYPE_CRT2) {
3962 ivideo->currentvbflags |= VB_MIRROR_MODE;
3963 } else {
3964 ivideo->currentvbflags |= VB_SINGLE_MODE;
3965 }
3966 }
3967
3968 andSISIDXREG(SISSR, IND_SIS_RAMDAC_CONTROL, ~0x04);
3969
3970 if(ivideo->currentvbflags & CRT2_TV) {
3971 if(ivideo->vbflags2 & VB2_SISBRIDGE) {
3972 inSISIDXREG(SISPART2,0x1f,ivideo->p2_1f);
3973 inSISIDXREG(SISPART2,0x20,ivideo->p2_20);
3974 inSISIDXREG(SISPART2,0x2b,ivideo->p2_2b);
3975 inSISIDXREG(SISPART2,0x42,ivideo->p2_42);
3976 inSISIDXREG(SISPART2,0x43,ivideo->p2_43);
3977 inSISIDXREG(SISPART2,0x01,ivideo->p2_01);
3978 inSISIDXREG(SISPART2,0x02,ivideo->p2_02);
3979 } else if(ivideo->vbflags2 & VB2_CHRONTEL) {
3980 if(ivideo->chronteltype == 1) {
3981 ivideo->tvx = SiS_GetCH700x(&ivideo->SiS_Pr, 0x0a);
3982 ivideo->tvx |= (((SiS_GetCH700x(&ivideo->SiS_Pr, 0x08) & 0x02) >> 1) << 8);
3983 ivideo->tvy = SiS_GetCH700x(&ivideo->SiS_Pr, 0x0b);
3984 ivideo->tvy |= ((SiS_GetCH700x(&ivideo->SiS_Pr, 0x08) & 0x01) << 8);
3985 }
3986 }
3987 }
3988
3989 if(ivideo->tvxpos) {
3990 sisfb_set_TVxposoffset(ivideo, ivideo->tvxpos);
3991 }
3992 if(ivideo->tvypos) {
3993 sisfb_set_TVyposoffset(ivideo, ivideo->tvypos);
3994 }
3995
3996 /* Eventually sync engines */
3997 sisfb_check_engine_and_sync(ivideo);
3998
3999 /* (Re-)Initialize chip engines */
4000 if(ivideo->accel) {
4001 sisfb_engine_init(ivideo);
4002 } else {
4003 ivideo->engineok = 0;
4004 }
4005 }
4006
4007 static int
4008 sisfb_reset_mode(struct sis_video_info *ivideo)
4009 {
4010 if(sisfb_set_mode(ivideo, 0))
4011 return 1;
4012
4013 sisfb_set_pitch(ivideo);
4014 sisfb_set_base_CRT1(ivideo, ivideo->current_base);
4015 sisfb_set_base_CRT2(ivideo, ivideo->current_base);
4016
4017 return 0;
4018 }
4019
4020 static void
4021 sisfb_handle_command(struct sis_video_info *ivideo, struct sisfb_cmd *sisfb_command)
4022 {
4023 int mycrt1off;
4024
4025 switch(sisfb_command->sisfb_cmd) {
4026 case SISFB_CMD_GETVBFLAGS:
4027 if(!ivideo->modechanged) {
4028 sisfb_command->sisfb_result[0] = SISFB_CMD_ERR_EARLY;
4029 } else {
4030 sisfb_command->sisfb_result[0] = SISFB_CMD_ERR_OK;
4031 sisfb_command->sisfb_result[1] = ivideo->currentvbflags;
4032 sisfb_command->sisfb_result[2] = ivideo->vbflags2;
4033 }
4034 break;
4035 case SISFB_CMD_SWITCHCRT1:
4036 /* arg[0]: 0 = off, 1 = on, 99 = query */
4037 if(!ivideo->modechanged) {
4038 sisfb_command->sisfb_result[0] = SISFB_CMD_ERR_EARLY;
4039 } else if(sisfb_command->sisfb_arg[0] == 99) {
4040 /* Query */
4041 sisfb_command->sisfb_result[1] = ivideo->sisfb_crt1off ? 0 : 1;
4042 sisfb_command->sisfb_result[0] = SISFB_CMD_ERR_OK;
4043 } else if(ivideo->sisfblocked) {
4044 sisfb_command->sisfb_result[0] = SISFB_CMD_ERR_LOCKED;
4045 } else if((!(ivideo->currentvbflags & CRT2_ENABLE)) &&
4046 (sisfb_command->sisfb_arg[0] == 0)) {
4047 sisfb_command->sisfb_result[0] = SISFB_CMD_ERR_NOCRT2;
4048 } else {
4049 sisfb_command->sisfb_result[0] = SISFB_CMD_ERR_OK;
4050 mycrt1off = sisfb_command->sisfb_arg[0] ? 0 : 1;
4051 if( ((ivideo->currentvbflags & VB_DISPTYPE_CRT1) && mycrt1off) ||
4052 ((!(ivideo->currentvbflags & VB_DISPTYPE_CRT1)) && !mycrt1off) ) {
4053 ivideo->sisfb_crt1off = mycrt1off;
4054 if(sisfb_reset_mode(ivideo)) {
4055 sisfb_command->sisfb_result[0] = SISFB_CMD_ERR_OTHER;
4056 }
4057 }
4058 sisfb_command->sisfb_result[1] = ivideo->sisfb_crt1off ? 0 : 1;
4059 }
4060 break;
4061 /* more to come */
4062 default:
4063 sisfb_command->sisfb_result[0] = SISFB_CMD_ERR_UNKNOWN;
4064 printk(KERN_ERR "sisfb: Unknown command 0x%x\n",
4065 sisfb_command->sisfb_cmd);
4066 }
4067 }
4068
4069 #ifndef MODULE
4070 SISINITSTATIC int __init
4071 sisfb_setup(char *options)
4072 {
4073 char *this_opt;
4074
4075 sisfb_setdefaultparms();
4076
4077 if(!options || !(*options))
4078 return 0;
4079
4080 while((this_opt = strsep(&options, ",")) != NULL) {
4081
4082 if(!(*this_opt)) continue;
4083
4084 if(!strnicmp(this_opt, "off", 3)) {
4085 sisfb_off = 1;
4086 } else if(!strnicmp(this_opt, "forcecrt2type:", 14)) {
4087 /* Need to check crt2 type first for fstn/dstn */
4088 sisfb_search_crt2type(this_opt + 14);
4089 } else if(!strnicmp(this_opt, "tvmode:",7)) {
4090 sisfb_search_tvstd(this_opt + 7);
4091 } else if(!strnicmp(this_opt, "tvstandard:",11)) {
4092 sisfb_search_tvstd(this_opt + 11);
4093 } else if(!strnicmp(this_opt, "mode:", 5)) {
4094 sisfb_search_mode(this_opt + 5, FALSE);
4095 } else if(!strnicmp(this_opt, "vesa:", 5)) {
4096 sisfb_search_vesamode(simple_strtoul(this_opt + 5, NULL, 0), FALSE);
4097 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
4098 } else if(!strnicmp(this_opt, "inverse", 7)) {
4099 sisfb_inverse = 1;
4100 /* fb_invert_cmaps(); */
4101 } else if(!strnicmp(this_opt, "font:", 5)) {
4102 if(strlen(this_opt + 5) < 40) {
4103 strncpy(sisfb_fontname, this_opt + 5, sizeof(sisfb_fontname) - 1);
4104 sisfb_fontname[sizeof(sisfb_fontname) - 1] = '\0';
4105 }
4106 #endif
4107 } else if(!strnicmp(this_opt, "rate:", 5)) {
4108 sisfb_parm_rate = simple_strtoul(this_opt + 5, NULL, 0);
4109 } else if(!strnicmp(this_opt, "forcecrt1:", 10)) {
4110 sisfb_forcecrt1 = (int)simple_strtoul(this_opt + 10, NULL, 0);
4111 } else if(!strnicmp(this_opt, "mem:",4)) {
4112 sisfb_parm_mem = simple_strtoul(this_opt + 4, NULL, 0);
4113 } else if(!strnicmp(this_opt, "pdc:", 4)) {
4114 sisfb_pdc = simple_strtoul(this_opt + 4, NULL, 0);
4115 } else if(!strnicmp(this_opt, "pdc1:", 5)) {
4116 sisfb_pdca = simple_strtoul(this_opt + 5, NULL, 0);
4117 } else if(!strnicmp(this_opt, "noaccel", 7)) {
4118 sisfb_accel = 0;
4119 } else if(!strnicmp(this_opt, "accel", 5)) {
4120 sisfb_accel = -1;
4121 } else if(!strnicmp(this_opt, "noypan", 6)) {
4122 sisfb_ypan = 0;
4123 } else if(!strnicmp(this_opt, "ypan", 4)) {
4124 sisfb_ypan = -1;
4125 } else if(!strnicmp(this_opt, "nomax", 5)) {
4126 sisfb_max = 0;
4127 } else if(!strnicmp(this_opt, "max", 3)) {
4128 sisfb_max = -1;
4129 } else if(!strnicmp(this_opt, "userom:", 7)) {
4130 sisfb_userom = (int)simple_strtoul(this_opt + 7, NULL, 0);
4131 } else if(!strnicmp(this_opt, "useoem:", 7)) {
4132 sisfb_useoem = (int)simple_strtoul(this_opt + 7, NULL, 0);
4133 } else if(!strnicmp(this_opt, "nocrt2rate", 10)) {
4134 sisfb_nocrt2rate = 1;
4135 } else if(!strnicmp(this_opt, "scalelcd:", 9)) {
4136 unsigned long temp = 2;
4137 temp = simple_strtoul(this_opt + 9, NULL, 0);
4138 if((temp == 0) || (temp == 1)) {
4139 sisfb_scalelcd = temp ^ 1;
4140 }
4141 } else if(!strnicmp(this_opt, "tvxposoffset:", 13)) {
4142 int temp = 0;
4143 temp = (int)simple_strtol(this_opt + 13, NULL, 0);
4144 if((temp >= -32) && (temp <= 32)) {
4145 sisfb_tvxposoffset = temp;
4146 }
4147 } else if(!strnicmp(this_opt, "tvyposoffset:", 13)) {
4148 int temp = 0;
4149 temp = (int)simple_strtol(this_opt + 13, NULL, 0);
4150 if((temp >= -32) && (temp <= 32)) {
4151 sisfb_tvyposoffset = temp;
4152 }
4153 } else if(!strnicmp(this_opt, "specialtiming:", 14)) {
4154 sisfb_search_specialtiming(this_opt + 14);
4155 } else if(!strnicmp(this_opt, "lvdshl:", 7)) {
4156 int temp = 4;
4157 temp = simple_strtoul(this_opt + 7, NULL, 0);
4158 if((temp >= 0) && (temp <= 3)) {
4159 sisfb_lvdshl = temp;
4160 }
4161 } else if(this_opt[0] >= '0' && this_opt[0] <= '9') {
4162 sisfb_search_mode(this_opt, TRUE);
4163 #if !defined(__i386__) && !defined(__x86_64__)
4164 } else if(!strnicmp(this_opt, "resetcard", 9)) {
4165 sisfb_resetcard = 1;
4166 } else if(!strnicmp(this_opt, "videoram:", 9)) {
4167 sisfb_videoram = simple_strtoul(this_opt + 9, NULL, 0);
4168 #endif
4169 } else {
4170 printk(KERN_INFO "sisfb: Invalid option %s\n", this_opt);
4171 }
4172
4173 }
4174
4175 return 0;
4176 }
4177 #endif
4178
4179 static int __devinit
4180 sisfb_check_rom(SIS_IOTYPE1 *rom_base, struct sis_video_info *ivideo)
4181 {
4182 SIS_IOTYPE1 *rom;
4183 int romptr;
4184
4185 if((readb(rom_base) != 0x55) || (readb(rom_base + 1) != 0xaa))
4186 return 0;
4187
4188 romptr = (readb(rom_base + 0x18) | (readb(rom_base + 0x19) << 8));
4189 if(romptr > (0x10000 - 8))
4190 return 0;
4191
4192 rom = rom_base + romptr;
4193
4194 if((readb(rom) != 'P') || (readb(rom + 1) != 'C') ||
4195 (readb(rom + 2) != 'I') || (readb(rom + 3) != 'R'))
4196 return 0;
4197
4198 if((readb(rom + 4) | (readb(rom + 5) << 8)) != ivideo->chip_vendor)
4199 return 0;
4200
4201 if((readb(rom + 6) | (readb(rom + 7) << 8)) != ivideo->chip_id)
4202 return 0;
4203
4204 return 1;
4205 }
4206
4207 static unsigned char * __devinit
4208 sisfb_find_rom(struct pci_dev *pdev)
4209 {
4210 struct sis_video_info *ivideo = pci_get_drvdata(pdev);
4211 SIS_IOTYPE1 *rom_base;
4212 unsigned char *myrombase = NULL;
4213 u32 temp;
4214 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,11)
4215 size_t romsize;
4216
4217 /* First, try the official pci ROM functions (except
4218 * on integrated chipsets which have no ROM).
4219 */
4220
4221 if(!ivideo->nbridge) {
4222
4223 if((rom_base = pci_map_rom(pdev, &romsize))) {
4224
4225 if(sisfb_check_rom(rom_base, ivideo)) {
4226
4227 if((myrombase = vmalloc(65536))) {
4228
4229 /* Work around bug in pci/rom.c: Folks forgot to check
4230 * whether the size retrieved from the BIOS image eventually
4231 * is larger than the mapped size
4232 */
4233 if(pci_resource_len(pdev, PCI_ROM_RESOURCE) < romsize)
4234 romsize = pci_resource_len(pdev, PCI_ROM_RESOURCE);
4235
4236 memcpy_fromio(myrombase, rom_base,
4237 (romsize > 65536) ? 65536 : romsize);
4238 }
4239 }
4240 pci_unmap_rom(pdev, rom_base);
4241 }
4242 }
4243
4244 if(myrombase) return myrombase;
4245 #endif
4246
4247 /* Otherwise do it the conventional way. */
4248
4249 #if defined(__i386__) || defined(__x86_64__)
4250
4251 for(temp = 0x000c0000; temp < 0x000f0000; temp += 0x00001000) {
4252
4253 rom_base = ioremap(temp, 65536);
4254 if(!rom_base)
4255 continue;
4256
4257 if(!sisfb_check_rom(rom_base, ivideo)) {
4258 iounmap(rom_base);
4259 continue;
4260 }
4261
4262 if((myrombase = vmalloc(65536)))
4263 memcpy_fromio(myrombase, rom_base, 65536);
4264
4265 iounmap(rom_base);
4266 break;
4267
4268 }
4269
4270 #else
4271
4272 pci_read_config_dword(pdev, PCI_ROM_ADDRESS, &temp);
4273 pci_write_config_dword(pdev, PCI_ROM_ADDRESS,
4274 (ivideo->video_base & PCI_ROM_ADDRESS_MASK) | PCI_ROM_ADDRESS_ENABLE);
4275
4276 rom_base = ioremap(ivideo->video_base, 65536);
4277 if(rom_base) {
4278 if(sisfb_check_rom(rom_base, ivideo)) {
4279 if((myrombase = vmalloc(65536)))
4280 memcpy_fromio(myrombase, rom_base, 65536);
4281 }
4282 iounmap(rom_base);
4283 }
4284
4285 pci_write_config_dword(pdev, PCI_ROM_ADDRESS, temp);
4286
4287 #endif
4288
4289 return myrombase;
4290 }
4291
4292 static void __devinit
4293 sisfb_post_map_vram(struct sis_video_info *ivideo, unsigned int *mapsize,
4294 unsigned int min)
4295 {
4296 ivideo->video_vbase = ioremap(ivideo->video_base, (*mapsize));
4297
4298 if(!ivideo->video_vbase) {
4299 printk(KERN_ERR
4300 "sisfb: Unable to map maximum video RAM for size detection\n");
4301 (*mapsize) >>= 1;
4302 while((!(ivideo->video_vbase = ioremap(ivideo->video_base, (*mapsize))))) {
4303 (*mapsize) >>= 1;
4304 if((*mapsize) < (min << 20))
4305 break;
4306 }
4307 if(ivideo->video_vbase) {
4308 printk(KERN_ERR
4309 "sisfb: Video RAM size detection limited to %dMB\n",
4310 (int)((*mapsize) >> 20));
4311 }
4312 }
4313 }
4314
4315 #ifdef CONFIG_FB_SIS_300
4316 static int __devinit
4317 sisfb_post_300_buswidth(struct sis_video_info *ivideo)
4318 {
4319 SIS_IOTYPE1 *FBAddress = ivideo->video_vbase;
4320 unsigned short temp;
4321 unsigned char reg;
4322 int i, j;
4323
4324 andSISIDXREG(SISSR, 0x15, 0xFB);
4325 orSISIDXREG(SISSR, 0x15, 0x04);
4326 outSISIDXREG(SISSR, 0x13, 0x00);
4327 outSISIDXREG(SISSR, 0x14, 0xBF);
4328
4329 for(i = 0; i < 2; i++) {
4330 temp = 0x1234;
4331 for(j = 0; j < 4; j++) {
4332 writew(temp, FBAddress);
4333 if(readw(FBAddress) == temp)
4334 break;
4335 orSISIDXREG(SISSR, 0x3c, 0x01);
4336 inSISIDXREG(SISSR, 0x05, reg);
4337 inSISIDXREG(SISSR, 0x05, reg);
4338 andSISIDXREG(SISSR, 0x3c, 0xfe);
4339 inSISIDXREG(SISSR, 0x05, reg);
4340 inSISIDXREG(SISSR, 0x05, reg);
4341 temp++;
4342 }
4343 }
4344
4345 writel(0x01234567L, FBAddress);
4346 writel(0x456789ABL, (FBAddress + 4));
4347 writel(0x89ABCDEFL, (FBAddress + 8));
4348 writel(0xCDEF0123L, (FBAddress + 12));
4349
4350 inSISIDXREG(SISSR, 0x3b, reg);
4351 if(reg & 0x01) {
4352 if(readl((FBAddress + 12)) == 0xCDEF0123L)
4353 return 4; /* Channel A 128bit */
4354 }
4355
4356 if(readl((FBAddress + 4)) == 0x456789ABL)
4357 return 2; /* Channel B 64bit */
4358
4359 return 1; /* 32bit */
4360 }
4361
4362 static int __devinit
4363 sisfb_post_300_rwtest(struct sis_video_info *ivideo, int iteration, int buswidth,
4364 int PseudoRankCapacity, int PseudoAdrPinCount,
4365 unsigned int mapsize)
4366 {
4367 SIS_IOTYPE1 *FBAddr = ivideo->video_vbase;
4368 unsigned short sr14;
4369 unsigned int k, RankCapacity, PageCapacity, BankNumHigh, BankNumMid;
4370 unsigned int PhysicalAdrOtherPage, PhysicalAdrHigh, PhysicalAdrHalfPage;
4371 static const unsigned short SiS_DRAMType[17][5] = {
4372 {0x0C,0x0A,0x02,0x40,0x39},
4373 {0x0D,0x0A,0x01,0x40,0x48},
4374 {0x0C,0x09,0x02,0x20,0x35},
4375 {0x0D,0x09,0x01,0x20,0x44},
4376 {0x0C,0x08,0x02,0x10,0x31},
4377 {0x0D,0x08,0x01,0x10,0x40},
4378 {0x0C,0x0A,0x01,0x20,0x34},
4379 {0x0C,0x09,0x01,0x08,0x32},
4380 {0x0B,0x08,0x02,0x08,0x21},
4381 {0x0C,0x08,0x01,0x08,0x30},
4382 {0x0A,0x08,0x02,0x04,0x11},
4383 {0x0B,0x0A,0x01,0x10,0x28},
4384 {0x09,0x08,0x02,0x02,0x01},
4385 {0x0B,0x09,0x01,0x08,0x24},
4386 {0x0B,0x08,0x01,0x04,0x20},
4387 {0x0A,0x08,0x01,0x02,0x10},
4388 {0x09,0x08,0x01,0x01,0x00}
4389 };
4390
4391 for(k = 0; k <= 16; k++) {
4392
4393 RankCapacity = buswidth * SiS_DRAMType[k][3];
4394
4395 if(RankCapacity != PseudoRankCapacity)
4396 continue;
4397
4398 if((SiS_DRAMType[k][2] + SiS_DRAMType[k][0]) > PseudoAdrPinCount)
4399 continue;
4400
4401 BankNumHigh = RankCapacity * 16 * iteration - 1;
4402 if(iteration == 3) { /* Rank No */
4403 BankNumMid = RankCapacity * 16 - 1;
4404 } else {
4405 BankNumMid = RankCapacity * 16 * iteration / 2 - 1;
4406 }
4407
4408 PageCapacity = (1 << SiS_DRAMType[k][1]) * buswidth * 4;
4409 PhysicalAdrHigh = BankNumHigh;
4410 PhysicalAdrHalfPage = (PageCapacity / 2 + PhysicalAdrHigh) % PageCapacity;
4411 PhysicalAdrOtherPage = PageCapacity * SiS_DRAMType[k][2] + PhysicalAdrHigh;
4412
4413 andSISIDXREG(SISSR, 0x15, 0xFB); /* Test */
4414 orSISIDXREG(SISSR, 0x15, 0x04); /* Test */
4415 sr14 = (SiS_DRAMType[k][3] * buswidth) - 1;
4416 if(buswidth == 4) sr14 |= 0x80;
4417 else if(buswidth == 2) sr14 |= 0x40;
4418 outSISIDXREG(SISSR, 0x13, SiS_DRAMType[k][4]);
4419 outSISIDXREG(SISSR, 0x14, sr14);
4420
4421 BankNumHigh <<= 16;
4422 BankNumMid <<= 16;
4423
4424 if((BankNumHigh + PhysicalAdrHigh >= mapsize) ||
4425 (BankNumMid + PhysicalAdrHigh >= mapsize) ||
4426 (BankNumHigh + PhysicalAdrHalfPage >= mapsize) ||
4427 (BankNumHigh + PhysicalAdrOtherPage >= mapsize))
4428 continue;
4429
4430 /* Write data */
4431 writew(((unsigned short)PhysicalAdrHigh),
4432 (FBAddr + BankNumHigh + PhysicalAdrHigh));
4433 writew(((unsigned short)BankNumMid),
4434 (FBAddr + BankNumMid + PhysicalAdrHigh));
4435 writew(((unsigned short)PhysicalAdrHalfPage),
4436 (FBAddr + BankNumHigh + PhysicalAdrHalfPage));
4437 writew(((unsigned short)PhysicalAdrOtherPage),
4438 (FBAddr + BankNumHigh + PhysicalAdrOtherPage));
4439
4440 /* Read data */
4441 if(readw(FBAddr + BankNumHigh + PhysicalAdrHigh) == PhysicalAdrHigh)
4442 return 1;
4443 }
4444
4445 return 0;
4446 }
4447
4448 static void __devinit
4449 sisfb_post_300_ramsize(struct pci_dev *pdev, unsigned int mapsize)
4450 {
4451 struct sis_video_info *ivideo = pci_get_drvdata(pdev);
4452 int i, j, buswidth;
4453 int PseudoRankCapacity, PseudoAdrPinCount;
4454
4455 buswidth = sisfb_post_300_buswidth(ivideo);
4456
4457 for(i = 6; i >= 0; i--) {
4458 PseudoRankCapacity = 1 << i;
4459 for(j = 4; j >= 1; j--) {
4460 PseudoAdrPinCount = 15 - j;
4461 if((PseudoRankCapacity * j) <= 64) {
4462 if(sisfb_post_300_rwtest(ivideo,
4463 j,
4464 buswidth,
4465 PseudoRankCapacity,
4466 PseudoAdrPinCount,
4467 mapsize))
4468 return;
4469 }
4470 }
4471 }
4472 }
4473
4474 static void __devinit
4475 sisfb_post_sis300(struct pci_dev *pdev)
4476 {
4477 struct sis_video_info *ivideo = pci_get_drvdata(pdev);
4478 unsigned char *bios = ivideo->SiS_Pr.VirtualRomBase;
4479 u8 reg, v1, v2, v3, v4, v5, v6, v7, v8;
4480 u16 index, rindex, memtype = 0;
4481 unsigned int mapsize;
4482
4483 if(!ivideo->SiS_Pr.UseROM)
4484 bios = NULL;
4485
4486 outSISIDXREG(SISSR, 0x05, 0x86);
4487
4488 if(bios) {
4489 if(bios[0x52] & 0x80) {
4490 memtype = bios[0x52];
4491 } else {
4492 inSISIDXREG(SISSR, 0x3a, memtype);
4493 }
4494 memtype &= 0x07;
4495 }
4496
4497 v3 = 0x80; v6 = 0x80;
4498 if(ivideo->revision_id <= 0x13) {
4499 v1 = 0x44; v2 = 0x42;
4500 v4 = 0x44; v5 = 0x42;
4501 } else {
4502 v1 = 0x68; v2 = 0x43; /* Assume 125Mhz MCLK */
4503 v4 = 0x68; v5 = 0x43; /* Assume 125Mhz ECLK */
4504 if(bios) {
4505 index = memtype * 5;
4506 rindex = index + 0x54;
4507 v1 = bios[rindex++];
4508 v2 = bios[rindex++];
4509 v3 = bios[rindex++];
4510 rindex = index + 0x7c;
4511 v4 = bios[rindex++];
4512 v5 = bios[rindex++];
4513 v6 = bios[rindex++];
4514 }
4515 }
4516 outSISIDXREG(SISSR, 0x28, v1);
4517 outSISIDXREG(SISSR, 0x29, v2);
4518 outSISIDXREG(SISSR, 0x2a, v3);
4519 outSISIDXREG(SISSR, 0x2e, v4);
4520 outSISIDXREG(SISSR, 0x2f, v5);
4521 outSISIDXREG(SISSR, 0x30, v6);
4522
4523 v1 = 0x10;
4524 if(bios)
4525 v1 = bios[0xa4];
4526 outSISIDXREG(SISSR, 0x07, v1); /* DAC speed */
4527
4528 outSISIDXREG(SISSR, 0x11, 0x0f); /* DDC, power save */
4529
4530 v1 = 0x01; v2 = 0x43; v3 = 0x1e; v4 = 0x2a;
4531 v5 = 0x06; v6 = 0x00; v7 = 0x00; v8 = 0x00;
4532 if(bios) {
4533 memtype += 0xa5;
4534 v1 = bios[memtype];
4535 v2 = bios[memtype + 8];
4536 v3 = bios[memtype + 16];
4537 v4 = bios[memtype + 24];
4538 v5 = bios[memtype + 32];
4539 v6 = bios[memtype + 40];
4540 v7 = bios[memtype + 48];
4541 v8 = bios[memtype + 56];
4542 }
4543 if(ivideo->revision_id >= 0x80)
4544 v3 &= 0xfd;
4545 outSISIDXREG(SISSR, 0x15, v1); /* Ram type (assuming 0, BIOS 0xa5 step 8) */
4546 outSISIDXREG(SISSR, 0x16, v2);
4547 outSISIDXREG(SISSR, 0x17, v3);
4548 outSISIDXREG(SISSR, 0x18, v4);
4549 outSISIDXREG(SISSR, 0x19, v5);
4550 outSISIDXREG(SISSR, 0x1a, v6);
4551 outSISIDXREG(SISSR, 0x1b, v7);
4552 outSISIDXREG(SISSR, 0x1c, v8); /* ---- */
4553 andSISIDXREG(SISSR, 0x15 ,0xfb);
4554 orSISIDXREG(SISSR, 0x15, 0x04);
4555 if(bios) {
4556 if(bios[0x53] & 0x02) {
4557 orSISIDXREG(SISSR, 0x19, 0x20);
4558 }
4559 }
4560 v1 = 0x04; /* DAC pedestal (BIOS 0xe5) */
4561 if(ivideo->revision_id >= 0x80)
4562 v1 |= 0x01;
4563 outSISIDXREG(SISSR, 0x1f, v1);
4564 outSISIDXREG(SISSR, 0x20, 0xa4); /* linear & relocated io & disable a0000 */
4565 v1 = 0xf6; v2 = 0x0d; v3 = 0x00;
4566 if(bios) {
4567 v1 = bios[0xe8];
4568 v2 = bios[0xe9];
4569 v3 = bios[0xea];
4570 }
4571 outSISIDXREG(SISSR, 0x23, v1);
4572 outSISIDXREG(SISSR, 0x24, v2);
4573 outSISIDXREG(SISSR, 0x25, v3);
4574 outSISIDXREG(SISSR, 0x21, 0x84);
4575 outSISIDXREG(SISSR, 0x22, 0x00);
4576 outSISIDXREG(SISCR, 0x37, 0x00);
4577 orSISIDXREG(SISPART1, 0x24, 0x01); /* unlock crt2 */
4578 outSISIDXREG(SISPART1, 0x00, 0x00);
4579 v1 = 0x40; v2 = 0x11;
4580 if(bios) {
4581 v1 = bios[0xec];
4582 v2 = bios[0xeb];
4583 }
4584 outSISIDXREG(SISPART1, 0x02, v1);
4585
4586 if(ivideo->revision_id >= 0x80)
4587 v2 &= ~0x01;
4588
4589 inSISIDXREG(SISPART4, 0x00, reg);
4590 if((reg == 1) || (reg == 2)) {
4591 outSISIDXREG(SISCR, 0x37, 0x02);
4592 outSISIDXREG(SISPART2, 0x00, 0x1c);
4593 v4 = 0x00; v5 = 0x00; v6 = 0x10;
4594 if(ivideo->SiS_Pr.UseROM) {
4595 v4 = bios[0xf5];
4596 v5 = bios[0xf6];
4597 v6 = bios[0xf7];
4598 }
4599 outSISIDXREG(SISPART4, 0x0d, v4);
4600 outSISIDXREG(SISPART4, 0x0e, v5);
4601 outSISIDXREG(SISPART4, 0x10, v6);
4602 outSISIDXREG(SISPART4, 0x0f, 0x3f);
4603 inSISIDXREG(SISPART4, 0x01, reg);
4604 if(reg >= 0xb0) {
4605 inSISIDXREG(SISPART4, 0x23, reg);
4606 reg &= 0x20;
4607 reg <<= 1;
4608 outSISIDXREG(SISPART4, 0x23, reg);
4609 }
4610 } else {
4611 v2 &= ~0x10;
4612 }
4613 outSISIDXREG(SISSR, 0x32, v2);
4614
4615 andSISIDXREG(SISPART1, 0x24, 0xfe); /* Lock CRT2 */
4616
4617 inSISIDXREG(SISSR, 0x16, reg);
4618 reg &= 0xc3;
4619 outSISIDXREG(SISCR, 0x35, reg);
4620 outSISIDXREG(SISCR, 0x83, 0x00);
4621 #if !defined(__i386__) && !defined(__x86_64__)
4622 if(sisfb_videoram) {
4623 outSISIDXREG(SISSR, 0x13, 0x28); /* ? */
4624 reg = ((sisfb_videoram >> 10) - 1) | 0x40;
4625 outSISIDXREG(SISSR, 0x14, reg);
4626 } else {
4627 #endif
4628 /* Need to map max FB size for finding out about RAM size */
4629 mapsize = 64 << 20;
4630 sisfb_post_map_vram(ivideo, &mapsize, 4);
4631
4632 if(ivideo->video_vbase) {
4633 sisfb_post_300_ramsize(pdev, mapsize);
4634 iounmap(ivideo->video_vbase);
4635 } else {
4636 printk(KERN_DEBUG
4637 "sisfb: Failed to map memory for size detection, assuming 8MB\n");
4638 outSISIDXREG(SISSR, 0x13, 0x28); /* ? */
4639 outSISIDXREG(SISSR, 0x14, 0x47); /* 8MB, 64bit default */
4640 }
4641 #if !defined(__i386__) && !defined(__x86_64__)
4642 }
4643 #endif
4644 if(bios) {
4645 v1 = bios[0xe6];
4646 v2 = bios[0xe7];
4647 } else {
4648 inSISIDXREG(SISSR, 0x3a, reg);
4649 if((reg & 0x30) == 0x30) {
4650 v1 = 0x04; /* PCI */
4651 v2 = 0x92;
4652 } else {
4653 v1 = 0x14; /* AGP */
4654 v2 = 0xb2;
4655 }
4656 }
4657 outSISIDXREG(SISSR, 0x21, v1);
4658 outSISIDXREG(SISSR, 0x22, v2);
4659
4660 /* Sense CRT1 */
4661 sisfb_sense_crt1(ivideo);
4662
4663 /* Set default mode, don't clear screen */
4664 ivideo->SiS_Pr.SiS_UseOEM = FALSE;
4665 SiS_SetEnableDstn(&ivideo->SiS_Pr, FALSE);
4666 SiS_SetEnableFstn(&ivideo->SiS_Pr, FALSE);
4667 ivideo->curFSTN = ivideo->curDSTN = 0;
4668 ivideo->SiS_Pr.VideoMemorySize = 8 << 20;
4669 SiSSetMode(&ivideo->SiS_Pr, 0x2e | 0x80);
4670
4671 outSISIDXREG(SISSR, 0x05, 0x86);
4672
4673 /* Display off */
4674 orSISIDXREG(SISSR, 0x01, 0x20);
4675
4676 /* Save mode number in CR34 */
4677 outSISIDXREG(SISCR, 0x34, 0x2e);
4678
4679 /* Let everyone know what the current mode is */
4680 ivideo->modeprechange = 0x2e;
4681 }
4682 #endif
4683
4684 #ifdef CONFIG_FB_SIS_315
4685 #if 0
4686 static void __devinit
4687 sisfb_post_sis315330(struct pci_dev *pdev)
4688 {
4689 /* TODO */
4690 }
4691 #endif
4692
4693 static void __devinit
4694 sisfb_post_xgi_delay(struct sis_video_info *ivideo, int delay)
4695 {
4696 unsigned int i;
4697 u8 reg;
4698
4699 for(i = 0; i <= (delay * 10 * 36); i++) {
4700 inSISIDXREG(SISSR, 0x05, reg);
4701 reg++;
4702 }
4703 }
4704
4705 static int __devinit
4706 sisfb_find_host_bridge(struct sis_video_info *ivideo, struct pci_dev *mypdev,
4707 unsigned short pcivendor)
4708 {
4709 struct pci_dev *pdev = NULL;
4710 unsigned short temp;
4711 int ret = 0;
4712
4713 while((pdev = SIS_PCI_GET_CLASS(PCI_CLASS_BRIDGE_HOST, pdev))) {
4714 temp = pdev->vendor;
4715 SIS_PCI_PUT_DEVICE(pdev);
4716 if(temp == pcivendor) {
4717 ret = 1;
4718 break;
4719 }
4720 }
4721
4722 return ret;
4723 }
4724
4725 static int __devinit
4726 sisfb_post_xgi_rwtest(struct sis_video_info *ivideo, int starta,
4727 unsigned int enda, unsigned int mapsize)
4728 {
4729 unsigned int pos;
4730 int i;
4731
4732 writel(0, ivideo->video_vbase);
4733
4734 for(i = starta; i <= enda; i++) {
4735 pos = 1 << i;
4736 if(pos < mapsize)
4737 writel(pos, ivideo->video_vbase + pos);
4738 }
4739
4740 sisfb_post_xgi_delay(ivideo, 150);
4741
4742 if(readl(ivideo->video_vbase) != 0)
4743 return 0;
4744
4745 for(i = starta; i <= enda; i++) {
4746 pos = 1 << i;
4747 if(pos < mapsize) {
4748 if(readl(ivideo->video_vbase + pos) != pos)
4749 return 0;
4750 } else
4751 return 0;
4752 }
4753
4754 return 1;
4755 }
4756
4757 static void __devinit
4758 sisfb_post_xgi_ramsize(struct sis_video_info *ivideo)
4759 {
4760 unsigned int buswidth, ranksize, channelab, mapsize;
4761 int i, j, k, l;
4762 u8 reg, sr14;
4763 static const u8 dramsr13[12 * 5] = {
4764 0x02, 0x0e, 0x0b, 0x80, 0x5d,
4765 0x02, 0x0e, 0x0a, 0x40, 0x59,
4766 0x02, 0x0d, 0x0b, 0x40, 0x4d,
4767 0x02, 0x0e, 0x09, 0x20, 0x55,
4768 0x02, 0x0d, 0x0a, 0x20, 0x49,
4769 0x02, 0x0c, 0x0b, 0x20, 0x3d,
4770 0x02, 0x0e, 0x08, 0x10, 0x51,
4771 0x02, 0x0d, 0x09, 0x10, 0x45,
4772 0x02, 0x0c, 0x0a, 0x10, 0x39,
4773 0x02, 0x0d, 0x08, 0x08, 0x41,
4774 0x02, 0x0c, 0x09, 0x08, 0x35,
4775 0x02, 0x0c, 0x08, 0x04, 0x31
4776 };
4777 static const u8 dramsr13_4[4 * 5] = {
4778 0x02, 0x0d, 0x09, 0x40, 0x45,
4779 0x02, 0x0c, 0x09, 0x20, 0x35,
4780 0x02, 0x0c, 0x08, 0x10, 0x31,
4781 0x02, 0x0b, 0x08, 0x08, 0x21
4782 };
4783
4784 /* Enable linear mode, disable 0xa0000 address decoding */
4785 /* We disable a0000 address decoding, because
4786 * - if running on x86, if the card is disabled, it means
4787 * that another card is in the system. We don't want
4788 * to interphere with that primary card's textmode.
4789 * - if running on non-x86, there usually is no VGA window
4790 * at a0000.
4791 */
4792 orSISIDXREG(SISSR, 0x20, (0x80 | 0x04));
4793
4794 /* Need to map max FB size for finding out about RAM size */
4795 mapsize = 256 << 20;
4796 sisfb_post_map_vram(ivideo, &mapsize, 32);
4797
4798 if(!ivideo->video_vbase) {
4799 printk(KERN_ERR "sisfb: Unable to detect RAM size. Setting default.\n");
4800 outSISIDXREG(SISSR, 0x13, 0x35);
4801 outSISIDXREG(SISSR, 0x14, 0x41);
4802 /* TODO */
4803 return;
4804 }
4805
4806 /* Non-interleaving */
4807 outSISIDXREG(SISSR, 0x15, 0x00);
4808 /* No tiling */
4809 outSISIDXREG(SISSR, 0x1c, 0x00);
4810
4811 if(ivideo->chip == XGI_20) {
4812
4813 channelab = 1;
4814 inSISIDXREG(SISCR, 0x97, reg);
4815 if(!(reg & 0x01)) { /* Single 32/16 */
4816 buswidth = 32;
4817 outSISIDXREG(SISSR, 0x13, 0xb1);
4818 outSISIDXREG(SISSR, 0x14, 0x52);
4819 sisfb_post_xgi_delay(ivideo, 1);
4820 sr14 = 0x02;
4821 if(sisfb_post_xgi_rwtest(ivideo, 23, 24, mapsize))
4822 goto bail_out;
4823
4824 outSISIDXREG(SISSR, 0x13, 0x31);
4825 outSISIDXREG(SISSR, 0x14, 0x42);
4826 sisfb_post_xgi_delay(ivideo, 1);
4827 if(sisfb_post_xgi_rwtest(ivideo, 23, 23, mapsize))
4828 goto bail_out;
4829
4830 buswidth = 16;
4831 outSISIDXREG(SISSR, 0x13, 0xb1);
4832 outSISIDXREG(SISSR, 0x14, 0x41);
4833 sisfb_post_xgi_delay(ivideo, 1);
4834 sr14 = 0x01;
4835 if(sisfb_post_xgi_rwtest(ivideo, 22, 23, mapsize))
4836 goto bail_out;
4837 else
4838 outSISIDXREG(SISSR, 0x13, 0x31);
4839 } else { /* Dual 16/8 */
4840 buswidth = 16;
4841 outSISIDXREG(SISSR, 0x13, 0xb1);
4842 outSISIDXREG(SISSR, 0x14, 0x41);
4843 sisfb_post_xgi_delay(ivideo, 1);
4844 sr14 = 0x01;
4845 if(sisfb_post_xgi_rwtest(ivideo, 22, 23, mapsize))
4846 goto bail_out;
4847
4848 outSISIDXREG(SISSR, 0x13, 0x31);
4849 outSISIDXREG(SISSR, 0x14, 0x31);
4850 sisfb_post_xgi_delay(ivideo, 1);
4851 if(sisfb_post_xgi_rwtest(ivideo, 22, 22, mapsize))
4852 goto bail_out;
4853
4854 buswidth = 8;
4855 outSISIDXREG(SISSR, 0x13, 0xb1);
4856 outSISIDXREG(SISSR, 0x14, 0x30);
4857 sisfb_post_xgi_delay(ivideo, 1);
4858 sr14 = 0x00;
4859 if(sisfb_post_xgi_rwtest(ivideo, 21, 22, mapsize))
4860 goto bail_out;
4861 else
4862 outSISIDXREG(SISSR, 0x13, 0x31);
4863 }
4864
4865 } else { /* XGI_40 */
4866
4867 inSISIDXREG(SISCR, 0x97, reg);
4868 if(!(reg & 0x10)) {
4869 inSISIDXREG(SISSR, 0x39, reg);
4870 reg >>= 1;
4871 }
4872
4873 if(reg & 0x01) { /* DDRII */
4874 buswidth = 32;
4875 if(ivideo->revision_id == 2) {
4876 channelab = 2;
4877 outSISIDXREG(SISSR, 0x13, 0xa1);
4878 outSISIDXREG(SISSR, 0x14, 0x44);
4879 sr14 = 0x04;
4880 sisfb_post_xgi_delay(ivideo, 1);
4881 if(sisfb_post_xgi_rwtest(ivideo, 23, 24, mapsize))
4882 goto bail_out;
4883
4884 outSISIDXREG(SISSR, 0x13, 0x21);
4885 outSISIDXREG(SISSR, 0x14, 0x34);
4886 if(sisfb_post_xgi_rwtest(ivideo, 22, 23, mapsize))
4887 goto bail_out;
4888
4889 channelab = 1;
4890 outSISIDXREG(SISSR, 0x13, 0xa1);
4891 outSISIDXREG(SISSR, 0x14, 0x40);
4892 sr14 = 0x00;
4893 if(sisfb_post_xgi_rwtest(ivideo, 22, 23, mapsize))
4894 goto bail_out;
4895
4896 outSISIDXREG(SISSR, 0x13, 0x21);
4897 outSISIDXREG(SISSR, 0x14, 0x30);
4898 } else {
4899 channelab = 3;
4900 outSISIDXREG(SISSR, 0x13, 0xa1);
4901 outSISIDXREG(SISSR, 0x14, 0x4c);
4902 sr14 = 0x0c;
4903 sisfb_post_xgi_delay(ivideo, 1);
4904 if(sisfb_post_xgi_rwtest(ivideo, 23, 25, mapsize))
4905 goto bail_out;
4906
4907 channelab = 2;
4908 outSISIDXREG(SISSR, 0x14, 0x48);
4909 sisfb_post_xgi_delay(ivideo, 1);
4910 sr14 = 0x08;
4911 if(sisfb_post_xgi_rwtest(ivideo, 23, 24, mapsize))
4912 goto bail_out;
4913
4914 outSISIDXREG(SISSR, 0x13, 0x21);
4915 outSISIDXREG(SISSR, 0x14, 0x3c);
4916 sr14 = 0x0c;
4917
4918 if(sisfb_post_xgi_rwtest(ivideo, 23, 24, mapsize)) {
4919 channelab = 3;
4920 } else {
4921 channelab = 2;
4922 outSISIDXREG(SISSR, 0x14, 0x38);
4923 sr14 = 0x08;
4924 }
4925 }
4926 sisfb_post_xgi_delay(ivideo, 1);
4927
4928 } else { /* DDR */
4929
4930 buswidth = 64;
4931 if(ivideo->revision_id == 2) {
4932 channelab = 1;
4933 outSISIDXREG(SISSR, 0x13, 0xa1);
4934 outSISIDXREG(SISSR, 0x14, 0x52);
4935 sisfb_post_xgi_delay(ivideo, 1);
4936 sr14 = 0x02;
4937 if(sisfb_post_xgi_rwtest(ivideo, 23, 24, mapsize))
4938 goto bail_out;
4939
4940 outSISIDXREG(SISSR, 0x13, 0x21);
4941 outSISIDXREG(SISSR, 0x14, 0x42);
4942 } else {
4943 channelab = 2;
4944 outSISIDXREG(SISSR, 0x13, 0xa1);
4945 outSISIDXREG(SISSR, 0x14, 0x5a);
4946 sisfb_post_xgi_delay(ivideo, 1);
4947 sr14 = 0x0a;
4948 if(sisfb_post_xgi_rwtest(ivideo, 24, 25, mapsize))
4949 goto bail_out;
4950
4951 outSISIDXREG(SISSR, 0x13, 0x21);
4952 outSISIDXREG(SISSR, 0x14, 0x4a);
4953 }
4954 sisfb_post_xgi_delay(ivideo, 1);
4955
4956 }
4957 }
4958
4959 bail_out:
4960 setSISIDXREG(SISSR, 0x14, 0xf0, sr14);
4961 sisfb_post_xgi_delay(ivideo, 1);
4962
4963 j = (ivideo->chip == XGI_20) ? 5 : 9;
4964 k = (ivideo->chip == XGI_20) ? 12 : 4;
4965
4966 for(i = 0; i < k; i++) {
4967
4968 reg = (ivideo->chip == XGI_20) ?
4969 dramsr13[(i * 5) + 4] : dramsr13_4[(i * 5) + 4];
4970 setSISIDXREG(SISSR, 0x13, 0x80, reg);
4971 sisfb_post_xgi_delay(ivideo, 50);
4972
4973 ranksize = (ivideo->chip == XGI_20) ?
4974 dramsr13[(i * 5) + 3] : dramsr13_4[(i * 5) + 3];
4975
4976 inSISIDXREG(SISSR, 0x13, reg);
4977 if(reg & 0x80) ranksize <<= 1;
4978
4979 if(ivideo->chip == XGI_20) {
4980 if(buswidth == 16) ranksize <<= 1;
4981 else if(buswidth == 32) ranksize <<= 2;
4982 } else {
4983 if(buswidth == 64) ranksize <<= 1;
4984 }
4985
4986 reg = 0;
4987 l = channelab;
4988 if(l == 3) l = 4;
4989 if((ranksize * l) <= 256) {
4990 while((ranksize >>= 1)) reg += 0x10;
4991 }
4992
4993 if(!reg) continue;
4994
4995 setSISIDXREG(SISSR, 0x14, 0x0f, (reg & 0xf0));
4996 sisfb_post_xgi_delay(ivideo, 1);
4997
4998 if(sisfb_post_xgi_rwtest(ivideo, j, ((reg >> 4) + channelab - 2 + 20), mapsize))
4999 break;
5000 }
5001
5002 iounmap(ivideo->video_vbase);
5003 }
5004
5005 static void __devinit
5006 sisfb_post_xgi_setclocks(struct sis_video_info *ivideo, u8 regb)
5007 {
5008 u8 v1, v2, v3;
5009 int index;
5010 static const u8 cs90[8 * 3] = {
5011 0x16, 0x01, 0x01,
5012 0x3e, 0x03, 0x01,
5013 0x7c, 0x08, 0x01,
5014 0x79, 0x06, 0x01,
5015 0x29, 0x01, 0x81,
5016 0x5c, 0x23, 0x01,
5017 0x5c, 0x23, 0x01,
5018 0x5c, 0x23, 0x01
5019 };
5020 static const u8 csb8[8 * 3] = {
5021 0x5c, 0x23, 0x01,
5022 0x29, 0x01, 0x01,
5023 0x7c, 0x08, 0x01,
5024 0x79, 0x06, 0x01,
5025 0x29, 0x01, 0x81,
5026 0x5c, 0x23, 0x01,
5027 0x5c, 0x23, 0x01,
5028 0x5c, 0x23, 0x01
5029 };
5030
5031 regb = 0; /* ! */
5032
5033 index = regb * 3;
5034 v1 = cs90[index]; v2 = cs90[index + 1]; v3 = cs90[index + 2];
5035 if(ivideo->haveXGIROM) {
5036 v1 = ivideo->bios_abase[0x90 + index];
5037 v2 = ivideo->bios_abase[0x90 + index + 1];
5038 v3 = ivideo->bios_abase[0x90 + index + 2];
5039 }
5040 outSISIDXREG(SISSR, 0x28, v1);
5041 outSISIDXREG(SISSR, 0x29, v2);
5042 outSISIDXREG(SISSR, 0x2a, v3);
5043 sisfb_post_xgi_delay(ivideo, 0x43);
5044 sisfb_post_xgi_delay(ivideo, 0x43);
5045 sisfb_post_xgi_delay(ivideo, 0x43);
5046 index = regb * 3;
5047 v1 = csb8[index]; v2 = csb8[index + 1]; v3 = csb8[index + 2];
5048 if(ivideo->haveXGIROM) {
5049 v1 = ivideo->bios_abase[0xb8 + index];
5050 v2 = ivideo->bios_abase[0xb8 + index + 1];
5051 v3 = ivideo->bios_abase[0xb8 + index + 2];
5052 }
5053 outSISIDXREG(SISSR, 0x2e, v1);
5054 outSISIDXREG(SISSR, 0x2f, v2);
5055 outSISIDXREG(SISSR, 0x30, v3);
5056 sisfb_post_xgi_delay(ivideo, 0x43);
5057 sisfb_post_xgi_delay(ivideo, 0x43);
5058 sisfb_post_xgi_delay(ivideo, 0x43);
5059 }
5060
5061 static int __devinit
5062 sisfb_post_xgi(struct pci_dev *pdev)
5063 {
5064 struct sis_video_info *ivideo = pci_get_drvdata(pdev);
5065 unsigned char *bios = ivideo->bios_abase;
5066 struct pci_dev *mypdev = NULL;
5067 const u8 *ptr, *ptr2;
5068 u8 v1, v2, v3, v4, v5, reg, ramtype;
5069 u32 rega, regb, regd;
5070 int i, j, k, index;
5071 static const u8 cs78[3] = { 0xf6, 0x0d, 0x00 };
5072 static const u8 cs76[2] = { 0xa3, 0xfb };
5073 static const u8 cs7b[3] = { 0xc0, 0x11, 0x00 };
5074 static const u8 cs158[8] = {
5075 0x88, 0xaa, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00
5076 };
5077 static const u8 cs160[8] = {
5078 0x44, 0x77, 0x77, 0x00, 0x00, 0x00, 0x00, 0x00
5079 };
5080 static const u8 cs168[8] = {
5081 0x48, 0x78, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00
5082 };
5083 static const u8 cs128[3 * 8] = {
5084 0x90, 0x28, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00,
5085 0x77, 0x44, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00,
5086 0x77, 0x44, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00
5087 };
5088 static const u8 cs148[2 * 8] = {
5089 0x55, 0x55, 0x55, 0x00, 0x00, 0x00, 0x00, 0x00,
5090 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
5091 };
5092 static const u8 cs31a[8 * 4] = {
5093 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
5094 0xaa, 0xaa, 0xaa, 0xaa, 0x00, 0x00, 0x00, 0x00,
5095 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5096 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
5097 };
5098 static const u8 cs33a[8 * 4] = {
5099 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5100 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5101 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5102 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
5103 };
5104 static const u8 cs45a[8 * 2] = {
5105 0x00, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0x00, 0x00,
5106 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
5107 };
5108 static const u8 cs170[7 * 8] = {
5109 0x54, 0x32, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00,
5110 0x54, 0x43, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00,
5111 0x0a, 0x05, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,
5112 0x44, 0x34, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00,
5113 0x10, 0x0a, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00,
5114 0x11, 0x0c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00,
5115 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00
5116 };
5117 static const u8 cs1a8[3 * 8] = {
5118 0xf0, 0xf0, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00,
5119 0x05, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
5120 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
5121 };
5122 static const u8 cs100[2 * 8] = {
5123 0xc4, 0x04, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5124 0xc4, 0x04, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00
5125 };
5126
5127 /* VGA enable */
5128 reg = inSISREG(SISVGAENABLE) | 0x01;
5129 outSISREG(SISVGAENABLE, reg);
5130
5131 /* Misc */
5132 reg = inSISREG(SISMISCR) | 0x01;
5133 outSISREG(SISMISCW, reg);
5134
5135 /* Unlock SR */
5136 outSISIDXREG(SISSR, 0x05, 0x86);
5137 inSISIDXREG(SISSR, 0x05, reg);
5138 if(reg != 0xa1)
5139 return 0;
5140
5141 /* Clear some regs */
5142 for(i = 0; i < 0x22; i++) {
5143 if(0x06 + i == 0x20) continue;
5144 outSISIDXREG(SISSR, 0x06 + i, 0x00);
5145 }
5146 for(i = 0; i < 0x0b; i++) {
5147 outSISIDXREG(SISSR, 0x31 + i, 0x00);
5148 }
5149 for(i = 0; i < 0x10; i++) {
5150 outSISIDXREG(SISCR, 0x30 + i, 0x00);
5151 }
5152
5153 ptr = cs78;
5154 if(ivideo->haveXGIROM) {
5155 ptr = (const u8 *)&bios[0x78];
5156 }
5157 for(i = 0; i < 3; i++) {
5158 outSISIDXREG(SISSR, 0x23 + i, ptr[i]);
5159 }
5160
5161 ptr = cs76;
5162 if(ivideo->haveXGIROM) {
5163 ptr = (const u8 *)&bios[0x76];
5164 }
5165 for(i = 0; i < 2; i++) {
5166 outSISIDXREG(SISSR, 0x21 + i, ptr[i]);
5167 }
5168
5169 v1 = 0x18; v2 = 0x00;
5170 if(ivideo->haveXGIROM) {
5171 v1 = bios[0x74];
5172 v2 = bios[0x75];
5173 }
5174 outSISIDXREG(SISSR, 0x07, v1);
5175 outSISIDXREG(SISSR, 0x11, 0x0f);
5176 outSISIDXREG(SISSR, 0x1f, v2);
5177 /* PCI linear mode, RelIO enabled, A0000 decoding disabled */
5178 outSISIDXREG(SISSR, 0x20, 0x80 | 0x20 | 0x04);
5179 outSISIDXREG(SISSR, 0x27, 0x74);
5180
5181 ptr = cs7b;
5182 if(ivideo->haveXGIROM) {
5183 ptr = (const u8 *)&bios[0x7b];
5184 }
5185 for(i = 0; i < 3; i++) {
5186 outSISIDXREG(SISSR, 0x31 + i, ptr[i]);
5187 }
5188
5189 if(ivideo->chip == XGI_40) {
5190 if(ivideo->revision_id == 2) {
5191 setSISIDXREG(SISSR, 0x3b, 0x3f, 0xc0);
5192 }
5193 outSISIDXREG(SISCR, 0x7d, 0xfe);
5194 outSISIDXREG(SISCR, 0x7e, 0x0f);
5195 }
5196 if(ivideo->revision_id == 0) { /* 40 *and* 20? */
5197 andSISIDXREG(SISCR, 0x58, 0xd7);
5198 inSISIDXREG(SISCR, 0xcb, reg);
5199 if(reg & 0x20) {
5200 setSISIDXREG(SISCR, 0x58, 0xd7, (reg & 0x10) ? 0x08 : 0x20); /* =0x28 Z7 ? */
5201 }
5202 }
5203
5204 reg = (ivideo->chip == XGI_40) ? 0x20 : 0x00;
5205 setSISIDXREG(SISCR, 0x38, 0x1f, reg);
5206
5207 if(ivideo->chip == XGI_20) {
5208 outSISIDXREG(SISSR, 0x36, 0x70);
5209 } else {
5210 outSISIDXREG(SISVID, 0x00, 0x86);
5211 outSISIDXREG(SISVID, 0x32, 0x00);
5212 outSISIDXREG(SISVID, 0x30, 0x00);
5213 outSISIDXREG(SISVID, 0x32, 0x01);
5214 outSISIDXREG(SISVID, 0x30, 0x00);
5215 andSISIDXREG(SISVID, 0x2f, 0xdf);
5216 andSISIDXREG(SISCAP, 0x00, 0x3f);
5217
5218 outSISIDXREG(SISPART1, 0x2f, 0x01);
5219 outSISIDXREG(SISPART1, 0x00, 0x00);
5220 outSISIDXREG(SISPART1, 0x02, bios[0x7e]);
5221 outSISIDXREG(SISPART1, 0x2e, 0x08);
5222 andSISIDXREG(SISPART1, 0x35, 0x7f);
5223 andSISIDXREG(SISPART1, 0x50, 0xfe);
5224
5225 inSISIDXREG(SISPART4, 0x00, reg);
5226 if(reg == 1 || reg == 2) {
5227 outSISIDXREG(SISPART2, 0x00, 0x1c);
5228 outSISIDXREG(SISPART4, 0x0d, bios[0x7f]);
5229 outSISIDXREG(SISPART4, 0x0e, bios[0x80]);
5230 outSISIDXREG(SISPART4, 0x10, bios[0x81]);
5231 andSISIDXREG(SISPART4, 0x0f, 0x3f);
5232
5233 inSISIDXREG(SISPART4, 0x01, reg);
5234 if((reg & 0xf0) >= 0xb0) {
5235 inSISIDXREG(SISPART4, 0x23, reg);
5236 if(reg & 0x20) reg |= 0x40;
5237 outSISIDXREG(SISPART4, 0x23, reg);
5238 reg = (reg & 0x20) ? 0x02 : 0x00;
5239 setSISIDXREG(SISPART1, 0x1e, 0xfd, reg);
5240 }
5241 }
5242
5243 v1 = bios[0x77];
5244
5245 inSISIDXREG(SISSR, 0x3b, reg);
5246 if(reg & 0x02) {
5247 inSISIDXREG(SISSR, 0x3a, reg);
5248 v2 = (reg & 0x30) >> 3;
5249 if(!(v2 & 0x04)) v2 ^= 0x02;
5250 inSISIDXREG(SISSR, 0x39, reg);
5251 if(reg & 0x80) v2 |= 0x80;
5252 v2 |= 0x01;
5253
5254 if((mypdev = SIS_PCI_GET_DEVICE(PCI_VENDOR_ID_SI, 0x0730, NULL))) {
5255 SIS_PCI_PUT_DEVICE(mypdev);
5256 if(((v2 & 0x06) == 2) || ((v2 & 0x06) == 4))
5257 v2 &= 0xf9;
5258 v2 |= 0x08;
5259 v1 &= 0xfe;
5260 } else {
5261 mypdev = SIS_PCI_GET_DEVICE(PCI_VENDOR_ID_SI, 0x0735, NULL);
5262 if(!mypdev)
5263 mypdev = SIS_PCI_GET_DEVICE(PCI_VENDOR_ID_SI, 0x0645, NULL);
5264 if(!mypdev)
5265 mypdev = SIS_PCI_GET_DEVICE(PCI_VENDOR_ID_SI, 0x0650, NULL);
5266 if(mypdev) {
5267 pci_read_config_dword(mypdev, 0x94, &regd);
5268 regd &= 0xfffffeff;
5269 pci_write_config_dword(mypdev, 0x94, regd);
5270 v1 &= 0xfe;
5271 SIS_PCI_PUT_DEVICE(mypdev);
5272 } else if(sisfb_find_host_bridge(ivideo, pdev, PCI_VENDOR_ID_SI)) {
5273 v1 &= 0xfe;
5274 } else if(sisfb_find_host_bridge(ivideo, pdev, 0x1106) ||
5275 sisfb_find_host_bridge(ivideo, pdev, 0x1022) ||
5276 sisfb_find_host_bridge(ivideo, pdev, 0x700e) ||
5277 sisfb_find_host_bridge(ivideo, pdev, 0x10de)) {
5278 if((v2 & 0x06) == 4)
5279 v2 ^= 0x06;
5280 v2 |= 0x08;
5281 }
5282 }
5283 setSISIDXREG(SISCR, 0x5f, 0xf0, v2);
5284 }
5285 outSISIDXREG(SISSR, 0x22, v1);
5286
5287 if(ivideo->revision_id == 2) {
5288 inSISIDXREG(SISSR, 0x3b, v1);
5289 inSISIDXREG(SISSR, 0x3a, v2);
5290 regd = bios[0x90 + 3] | (bios[0x90 + 4] << 8);
5291 if( (!(v1 & 0x02)) && (v2 & 0x30) && (regd < 0xcf) )
5292 setSISIDXREG(SISCR, 0x5f, 0xf1, 0x01);
5293
5294 if((mypdev = SIS_PCI_GET_DEVICE(0x10de, 0x01e0, NULL))) {
5295 /* TODO: set CR5f &0xf1 | 0x01 for version 6570
5296 * of nforce 2 ROM
5297 */
5298 if(0)
5299 setSISIDXREG(SISCR, 0x5f, 0xf1, 0x01);
5300 SIS_PCI_PUT_DEVICE(mypdev);
5301 }
5302 }
5303
5304 v1 = 0x30;
5305 inSISIDXREG(SISSR, 0x3b, reg);
5306 inSISIDXREG(SISCR, 0x5f, v2);
5307 if((!(reg & 0x02)) && (v2 & 0x0e))
5308 v1 |= 0x08;
5309 outSISIDXREG(SISSR, 0x27, v1);
5310
5311 if(bios[0x64] & 0x01) {
5312 setSISIDXREG(SISCR, 0x5f, 0xf0, bios[0x64]);
5313 }
5314
5315 v1 = bios[0x4f7];
5316 pci_read_config_dword(pdev, 0x50, &regd);
5317 regd = (regd >> 20) & 0x0f;
5318 if(regd == 1) {
5319 v1 &= 0xfc;
5320 orSISIDXREG(SISCR, 0x5f, 0x08);
5321 }
5322 outSISIDXREG(SISCR, 0x48, v1);
5323
5324 setSISIDXREG(SISCR, 0x47, 0x04, bios[0x4f6] & 0xfb);
5325 setSISIDXREG(SISCR, 0x49, 0xf0, bios[0x4f8] & 0x0f);
5326 setSISIDXREG(SISCR, 0x4a, 0x60, bios[0x4f9] & 0x9f);
5327 setSISIDXREG(SISCR, 0x4b, 0x08, bios[0x4fa] & 0xf7);
5328 setSISIDXREG(SISCR, 0x4c, 0x80, bios[0x4fb] & 0x7f);
5329 outSISIDXREG(SISCR, 0x70, bios[0x4fc]);
5330 setSISIDXREG(SISCR, 0x71, 0xf0, bios[0x4fd] & 0x0f);
5331 outSISIDXREG(SISCR, 0x74, 0xd0);
5332 setSISIDXREG(SISCR, 0x74, 0xcf, bios[0x4fe] & 0x30);
5333 setSISIDXREG(SISCR, 0x75, 0xe0, bios[0x4ff] & 0x1f);
5334 setSISIDXREG(SISCR, 0x76, 0xe0, bios[0x500] & 0x1f);
5335 v1 = bios[0x501];
5336 if((mypdev = SIS_PCI_GET_DEVICE(0x8086, 0x2530, NULL))) {
5337 v1 = 0xf0;
5338 SIS_PCI_PUT_DEVICE(mypdev);
5339 }
5340 outSISIDXREG(SISCR, 0x77, v1);
5341 }
5342
5343 /* RAM type */
5344
5345 regb = 0; /* ! */
5346
5347 v1 = 0xff;
5348 if(ivideo->haveXGIROM) {
5349 v1 = bios[0x140 + regb];
5350 }
5351 outSISIDXREG(SISCR, 0x6d, v1);
5352
5353 ptr = cs128;
5354 if(ivideo->haveXGIROM) {
5355 ptr = (const u8 *)&bios[0x128];
5356 }
5357 for(i = 0, j = 0; i < 3; i++, j += 8) {
5358 outSISIDXREG(SISCR, 0x68 + i, ptr[j + regb]);
5359 }
5360
5361 ptr = cs31a;
5362 ptr2 = cs33a;
5363 if(ivideo->haveXGIROM) {
5364 index = (ivideo->chip == XGI_20) ? 0x31a : 0x3a6;
5365 ptr = (const u8 *)&bios[index];
5366 ptr2 = (const u8 *)&bios[index + 0x20];
5367 }
5368 for(i = 0; i < 2; i++) {
5369 if(i == 0) {
5370 regd = le32_to_cpu(((u32 *)ptr)[regb]);
5371 rega = 0x6b;
5372 } else {
5373 regd = le32_to_cpu(((u32 *)ptr2)[regb]);
5374 rega = 0x6e;
5375 }
5376 reg = 0x00;
5377 for(j = 0; j < 16; j++) {
5378 reg &= 0xf3;
5379 if(regd & 0x01) reg |= 0x04;
5380 if(regd & 0x02) reg |= 0x08;
5381 regd >>= 2;
5382 outSISIDXREG(SISCR, rega, reg);
5383 inSISIDXREG(SISCR, rega, reg);
5384 inSISIDXREG(SISCR, rega, reg);
5385 reg += 0x10;
5386 }
5387 }
5388
5389 andSISIDXREG(SISCR, 0x6e, 0xfc);
5390
5391 ptr = NULL;
5392 if(ivideo->haveXGIROM) {
5393 index = (ivideo->chip == XGI_20) ? 0x35a : 0x3e6;
5394 ptr = (const u8 *)&bios[index];
5395 }
5396 for(i = 0; i < 4; i++) {
5397 setSISIDXREG(SISCR, 0x6e, 0xfc, i);
5398 reg = 0x00;
5399 for(j = 0; j < 2; j++) {
5400 regd = 0;
5401 if(ptr) {
5402 regd = le32_to_cpu(((u32 *)ptr)[regb * 8]);
5403 ptr += 4;
5404 }
5405 /* reg = 0x00; */
5406 for(k = 0; k < 16; k++) {
5407 reg &= 0xfc;
5408 if(regd & 0x01) reg |= 0x01;
5409 if(regd & 0x02) reg |= 0x02;
5410 regd >>= 2;
5411 outSISIDXREG(SISCR, 0x6f, reg);
5412 inSISIDXREG(SISCR, 0x6f, reg);
5413 inSISIDXREG(SISCR, 0x6f, reg);
5414 reg += 0x08;
5415 }
5416 }
5417 }
5418
5419 ptr = cs148;
5420 if(ivideo->haveXGIROM) {
5421 ptr = (const u8 *)&bios[0x148];
5422 }
5423 for(i = 0, j = 0; i < 2; i++, j += 8) {
5424 outSISIDXREG(SISCR, 0x80 + i, ptr[j + regb]);
5425 }
5426
5427 andSISIDXREG(SISCR, 0x89, 0x8f);
5428
5429 ptr = cs45a;
5430 if(ivideo->haveXGIROM) {
5431 index = (ivideo->chip == XGI_20) ? 0x45a : 0x4e6;
5432 ptr = (const u8 *)&bios[index];
5433 }
5434 regd = le16_to_cpu(((const u16 *)ptr)[regb]);
5435 reg = 0x80;
5436 for(i = 0; i < 5; i++) {
5437 reg &= 0xfc;
5438 if(regd & 0x01) reg |= 0x01;
5439 if(regd & 0x02) reg |= 0x02;
5440 regd >>= 2;
5441 outSISIDXREG(SISCR, 0x89, reg);
5442 inSISIDXREG(SISCR, 0x89, reg);
5443 inSISIDXREG(SISCR, 0x89, reg);
5444 reg += 0x10;
5445 }
5446
5447 v1 = 0xb5; v2 = 0x20; v3 = 0xf0; v4 = 0x13;
5448 if(ivideo->haveXGIROM) {
5449 v1 = bios[0x118 + regb];
5450 v2 = bios[0xf8 + regb];
5451 v3 = bios[0x120 + regb];
5452 v4 = bios[0x1ca];
5453 }
5454 outSISIDXREG(SISCR, 0x45, v1 & 0x0f);
5455 outSISIDXREG(SISCR, 0x99, (v1 >> 4) & 0x07);
5456 orSISIDXREG(SISCR, 0x40, v1 & 0x80);
5457 outSISIDXREG(SISCR, 0x41, v2);
5458
5459 ptr = cs170;
5460 if(ivideo->haveXGIROM) {
5461 ptr = (const u8 *)&bios[0x170];
5462 }
5463 for(i = 0, j = 0; i < 7; i++, j += 8) {
5464 outSISIDXREG(SISCR, 0x90 + i, ptr[j + regb]);
5465 }
5466
5467 outSISIDXREG(SISCR, 0x59, v3);
5468
5469 ptr = cs1a8;
5470 if(ivideo->haveXGIROM) {
5471 ptr = (const u8 *)&bios[0x1a8];
5472 }
5473 for(i = 0, j = 0; i < 3; i++, j += 8) {
5474 outSISIDXREG(SISCR, 0xc3 + i, ptr[j + regb]);
5475 }
5476
5477 ptr = cs100;
5478 if(ivideo->haveXGIROM) {
5479 ptr = (const u8 *)&bios[0x100];
5480 }
5481 for(i = 0, j = 0; i < 2; i++, j += 8) {
5482 outSISIDXREG(SISCR, 0x8a + i, ptr[j + regb]);
5483 }
5484
5485 outSISIDXREG(SISCR, 0xcf, v4);
5486
5487 outSISIDXREG(SISCR, 0x83, 0x09);
5488 outSISIDXREG(SISCR, 0x87, 0x00);
5489
5490 if(ivideo->chip == XGI_40) {
5491 if( (ivideo->revision_id == 1) ||
5492 (ivideo->revision_id == 2) ) {
5493 outSISIDXREG(SISCR, 0x8c, 0x87);
5494 }
5495 }
5496
5497 outSISIDXREG(SISSR, 0x17, 0x00);
5498 outSISIDXREG(SISSR, 0x1a, 0x87);
5499
5500 if(ivideo->chip == XGI_20) {
5501 outSISIDXREG(SISSR, 0x15, 0x00);
5502 outSISIDXREG(SISSR, 0x1c, 0x00);
5503 }
5504
5505 ramtype = 0x00; v1 = 0x10;
5506 if(ivideo->haveXGIROM) {
5507 ramtype = bios[0x62];
5508 v1 = bios[0x1d2];
5509 }
5510 if(!(ramtype & 0x80)) {
5511 if(ivideo->chip == XGI_20) {
5512 outSISIDXREG(SISCR, 0x97, v1);
5513 inSISIDXREG(SISCR, 0x97, reg);
5514 if(reg & 0x10) {
5515 ramtype = (reg & 0x01) << 1;
5516 }
5517 } else {
5518 inSISIDXREG(SISSR, 0x39, reg);
5519 ramtype = reg & 0x02;
5520 if(!(ramtype)) {
5521 inSISIDXREG(SISSR, 0x3a, reg);
5522 ramtype = (reg >> 1) & 0x01;
5523 }
5524 }
5525 }
5526 ramtype &= 0x07;
5527
5528 regb = 0; /* ! */
5529
5530 switch(ramtype) {
5531 case 0:
5532 sisfb_post_xgi_setclocks(ivideo, regb);
5533 if((ivideo->chip == XGI_20) ||
5534 (ivideo->revision_id == 1) ||
5535 (ivideo->revision_id == 2)) {
5536 v1 = cs158[regb]; v2 = cs160[regb]; v3 = cs168[regb];
5537 if(ivideo->haveXGIROM) {
5538 v1 = bios[regb + 0x158];
5539 v2 = bios[regb + 0x160];
5540 v3 = bios[regb + 0x168];
5541 }
5542 outSISIDXREG(SISCR, 0x82, v1);
5543 outSISIDXREG(SISCR, 0x85, v2);
5544 outSISIDXREG(SISCR, 0x86, v3);
5545 } else {
5546 outSISIDXREG(SISCR, 0x82, 0x88);
5547 outSISIDXREG(SISCR, 0x86, 0x00);
5548 inSISIDXREG(SISCR, 0x86, reg);
5549 outSISIDXREG(SISCR, 0x86, 0x88);
5550 inSISIDXREG(SISCR, 0x86, reg);
5551 outSISIDXREG(SISCR, 0x86, bios[regb + 0x168]);
5552 outSISIDXREG(SISCR, 0x82, 0x77);
5553 outSISIDXREG(SISCR, 0x85, 0x00);
5554 inSISIDXREG(SISCR, 0x85, reg);
5555 outSISIDXREG(SISCR, 0x85, 0x88);
5556 inSISIDXREG(SISCR, 0x85, reg);
5557 outSISIDXREG(SISCR, 0x85, bios[regb + 0x160]);
5558 outSISIDXREG(SISCR, 0x82, bios[regb + 0x158]);
5559 }
5560 if(ivideo->chip == XGI_40) {
5561 outSISIDXREG(SISCR, 0x97, 0x00);
5562 }
5563 outSISIDXREG(SISCR, 0x98, 0x01);
5564 outSISIDXREG(SISCR, 0x9a, 0x02);
5565
5566 outSISIDXREG(SISSR, 0x18, 0x01);
5567 if((ivideo->chip == XGI_20) ||
5568 (ivideo->revision_id == 2)) {
5569 outSISIDXREG(SISSR, 0x19, 0x40);
5570 } else {
5571 outSISIDXREG(SISSR, 0x19, 0x20);
5572 }
5573 outSISIDXREG(SISSR, 0x16, 0x00);
5574 outSISIDXREG(SISSR, 0x16, 0x80);
5575 if((ivideo->chip == XGI_20) || (bios[0x1cb] != 0x0c)) {
5576 sisfb_post_xgi_delay(ivideo, 0x43);
5577 sisfb_post_xgi_delay(ivideo, 0x43);
5578 sisfb_post_xgi_delay(ivideo, 0x43);
5579 outSISIDXREG(SISSR, 0x18, 0x00);
5580 if((ivideo->chip == XGI_20) ||
5581 (ivideo->revision_id == 2)) {
5582 outSISIDXREG(SISSR, 0x19, 0x40);
5583 } else {
5584 outSISIDXREG(SISSR, 0x19, 0x20);
5585 }
5586 } else if((ivideo->chip == XGI_40) && (bios[0x1cb] == 0x0c)) {
5587 /* outSISIDXREG(SISSR, 0x16, 0x0c); */ /* ? */
5588 }
5589 outSISIDXREG(SISSR, 0x16, 0x00);
5590 outSISIDXREG(SISSR, 0x16, 0x80);
5591 sisfb_post_xgi_delay(ivideo, 4);
5592 v1 = 0x31; v2 = 0x03; v3 = 0x83; v4 = 0x03; v5 = 0x83;
5593 if(ivideo->haveXGIROM) {
5594 v1 = bios[0xf0];
5595 index = (ivideo->chip == XGI_20) ? 0x4b2 : 0x53e;
5596 v2 = bios[index];
5597 v3 = bios[index + 1];
5598 v4 = bios[index + 2];
5599 v5 = bios[index + 3];
5600 }
5601 outSISIDXREG(SISSR, 0x18, v1);
5602 outSISIDXREG(SISSR, 0x19, ((ivideo->chip == XGI_20) ? 0x02 : 0x01));
5603 outSISIDXREG(SISSR, 0x16, v2);
5604 outSISIDXREG(SISSR, 0x16, v3);
5605 sisfb_post_xgi_delay(ivideo, 0x43);
5606 outSISIDXREG(SISSR, 0x1b, 0x03);
5607 sisfb_post_xgi_delay(ivideo, 0x22);
5608 outSISIDXREG(SISSR, 0x18, v1);
5609 outSISIDXREG(SISSR, 0x19, 0x00);
5610 outSISIDXREG(SISSR, 0x16, v4);
5611 outSISIDXREG(SISSR, 0x16, v5);
5612 outSISIDXREG(SISSR, 0x1b, 0x00);
5613 break;
5614 case 1:
5615 outSISIDXREG(SISCR, 0x82, 0x77);
5616 outSISIDXREG(SISCR, 0x86, 0x00);
5617 inSISIDXREG(SISCR, 0x86, reg);
5618 outSISIDXREG(SISCR, 0x86, 0x88);
5619 inSISIDXREG(SISCR, 0x86, reg);
5620 v1 = cs168[regb]; v2 = cs160[regb]; v3 = cs158[regb];
5621 if(ivideo->haveXGIROM) {
5622 v1 = bios[regb + 0x168];
5623 v2 = bios[regb + 0x160];
5624 v3 = bios[regb + 0x158];
5625 }
5626 outSISIDXREG(SISCR, 0x86, v1);
5627 outSISIDXREG(SISCR, 0x82, 0x77);
5628 outSISIDXREG(SISCR, 0x85, 0x00);
5629 inSISIDXREG(SISCR, 0x85, reg);
5630 outSISIDXREG(SISCR, 0x85, 0x88);
5631 inSISIDXREG(SISCR, 0x85, reg);
5632 outSISIDXREG(SISCR, 0x85, v2);
5633 outSISIDXREG(SISCR, 0x82, v3);
5634 outSISIDXREG(SISCR, 0x98, 0x01);
5635 outSISIDXREG(SISCR, 0x9a, 0x02);
5636
5637 outSISIDXREG(SISSR, 0x28, 0x64);
5638 outSISIDXREG(SISSR, 0x29, 0x63);
5639 sisfb_post_xgi_delay(ivideo, 15);
5640 outSISIDXREG(SISSR, 0x18, 0x00);
5641 outSISIDXREG(SISSR, 0x19, 0x20);
5642 outSISIDXREG(SISSR, 0x16, 0x00);
5643 outSISIDXREG(SISSR, 0x16, 0x80);
5644 outSISIDXREG(SISSR, 0x18, 0xc5);
5645 outSISIDXREG(SISSR, 0x19, 0x23);
5646 outSISIDXREG(SISSR, 0x16, 0x00);
5647 outSISIDXREG(SISSR, 0x16, 0x80);
5648 sisfb_post_xgi_delay(ivideo, 1);
5649 outSISIDXREG(SISCR, 0x97,0x11);
5650 sisfb_post_xgi_setclocks(ivideo, regb);
5651 sisfb_post_xgi_delay(ivideo, 0x46);
5652 outSISIDXREG(SISSR, 0x18, 0xc5);
5653 outSISIDXREG(SISSR, 0x19, 0x23);
5654 outSISIDXREG(SISSR, 0x16, 0x00);
5655 outSISIDXREG(SISSR, 0x16, 0x80);
5656 sisfb_post_xgi_delay(ivideo, 1);
5657 outSISIDXREG(SISSR, 0x1b, 0x04);
5658 sisfb_post_xgi_delay(ivideo, 1);
5659 outSISIDXREG(SISSR, 0x1b, 0x00);
5660 sisfb_post_xgi_delay(ivideo, 1);
5661 v1 = 0x31;
5662 if(ivideo->haveXGIROM) {
5663 v1 = bios[0xf0];
5664 }
5665 outSISIDXREG(SISSR, 0x18, v1);
5666 outSISIDXREG(SISSR, 0x19, 0x06);
5667 outSISIDXREG(SISSR, 0x16, 0x04);
5668 outSISIDXREG(SISSR, 0x16, 0x84);
5669 sisfb_post_xgi_delay(ivideo, 1);
5670 break;
5671 default:
5672 sisfb_post_xgi_setclocks(ivideo, regb);
5673 if((ivideo->chip == XGI_40) &&
5674 ((ivideo->revision_id == 1) ||
5675 (ivideo->revision_id == 2))) {
5676 outSISIDXREG(SISCR, 0x82, bios[regb + 0x158]);
5677 outSISIDXREG(SISCR, 0x85, bios[regb + 0x160]);
5678 outSISIDXREG(SISCR, 0x86, bios[regb + 0x168]);
5679 } else {
5680 outSISIDXREG(SISCR, 0x82, 0x88);
5681 outSISIDXREG(SISCR, 0x86, 0x00);
5682 inSISIDXREG(SISCR, 0x86, reg);
5683 outSISIDXREG(SISCR, 0x86, 0x88);
5684 outSISIDXREG(SISCR, 0x82, 0x77);
5685 outSISIDXREG(SISCR, 0x85, 0x00);
5686 inSISIDXREG(SISCR, 0x85, reg);
5687 outSISIDXREG(SISCR, 0x85, 0x88);
5688 inSISIDXREG(SISCR, 0x85, reg);
5689 v1 = cs160[regb]; v2 = cs158[regb];
5690 if(ivideo->haveXGIROM) {
5691 v1 = bios[regb + 0x160];
5692 v2 = bios[regb + 0x158];
5693 }
5694 outSISIDXREG(SISCR, 0x85, v1);
5695 outSISIDXREG(SISCR, 0x82, v2);
5696 }
5697 if(ivideo->chip == XGI_40) {
5698 outSISIDXREG(SISCR, 0x97, 0x11);
5699 }
5700 if((ivideo->chip == XGI_40) && (ivideo->revision_id == 2)) {
5701 outSISIDXREG(SISCR, 0x98, 0x01);
5702 } else {
5703 outSISIDXREG(SISCR, 0x98, 0x03);
5704 }
5705 outSISIDXREG(SISCR, 0x9a, 0x02);
5706
5707 if(ivideo->chip == XGI_40) {
5708 outSISIDXREG(SISSR, 0x18, 0x01);
5709 } else {
5710 outSISIDXREG(SISSR, 0x18, 0x00);
5711 }
5712 outSISIDXREG(SISSR, 0x19, 0x40);
5713 outSISIDXREG(SISSR, 0x16, 0x00);
5714 outSISIDXREG(SISSR, 0x16, 0x80);
5715 if((ivideo->chip == XGI_40) && (bios[0x1cb] != 0x0c)) {
5716 sisfb_post_xgi_delay(ivideo, 0x43);
5717 sisfb_post_xgi_delay(ivideo, 0x43);
5718 sisfb_post_xgi_delay(ivideo, 0x43);
5719 outSISIDXREG(SISSR, 0x18, 0x00);
5720 outSISIDXREG(SISSR, 0x19, 0x40);
5721 outSISIDXREG(SISSR, 0x16, 0x00);
5722 outSISIDXREG(SISSR, 0x16, 0x80);
5723 }
5724 sisfb_post_xgi_delay(ivideo, 4);
5725 v1 = 0x31;
5726 if(ivideo->haveXGIROM) {
5727 v1 = bios[0xf0];
5728 }
5729 outSISIDXREG(SISSR, 0x18, v1);
5730 outSISIDXREG(SISSR, 0x19, 0x01);
5731 if(ivideo->chip == XGI_40) {
5732 outSISIDXREG(SISSR, 0x16, bios[0x53e]);
5733 outSISIDXREG(SISSR, 0x16, bios[0x53f]);
5734 } else {
5735 outSISIDXREG(SISSR, 0x16, 0x05);
5736 outSISIDXREG(SISSR, 0x16, 0x85);
5737 }
5738 sisfb_post_xgi_delay(ivideo, 0x43);
5739 if(ivideo->chip == XGI_40) {
5740 outSISIDXREG(SISSR, 0x1b, 0x01);
5741 } else {
5742 outSISIDXREG(SISSR, 0x1b, 0x03);
5743 }
5744 sisfb_post_xgi_delay(ivideo, 0x22);
5745 outSISIDXREG(SISSR, 0x18, v1);
5746 outSISIDXREG(SISSR, 0x19, 0x00);
5747 if(ivideo->chip == XGI_40) {
5748 outSISIDXREG(SISSR, 0x16, bios[0x540]);
5749 outSISIDXREG(SISSR, 0x16, bios[0x541]);
5750 } else {
5751 outSISIDXREG(SISSR, 0x16, 0x05);
5752 outSISIDXREG(SISSR, 0x16, 0x85);
5753 }
5754 outSISIDXREG(SISSR, 0x1b, 0x00);
5755 }
5756
5757 regb = 0; /* ! */
5758 v1 = 0x03;
5759 if(ivideo->haveXGIROM) {
5760 v1 = bios[0x110 + regb];
5761 }
5762 outSISIDXREG(SISSR, 0x1b, v1);
5763
5764 /* RAM size */
5765 v1 = 0x00; v2 = 0x00;
5766 if(ivideo->haveXGIROM) {
5767 v1 = bios[0x62];
5768 v2 = bios[0x63];
5769 }
5770 regb = 0; /* ! */
5771 regd = 1 << regb;
5772 if((v1 & 0x40) && (v2 & regd) && ivideo->haveXGIROM) {
5773
5774 outSISIDXREG(SISSR, 0x13, bios[regb + 0xe0]);
5775 outSISIDXREG(SISSR, 0x14, bios[regb + 0xe0 + 8]);
5776
5777 } else {
5778
5779 /* Set default mode, don't clear screen */
5780 ivideo->SiS_Pr.SiS_UseOEM = FALSE;
5781 SiS_SetEnableDstn(&ivideo->SiS_Pr, FALSE);
5782 SiS_SetEnableFstn(&ivideo->SiS_Pr, FALSE);
5783 ivideo->curFSTN = ivideo->curDSTN = 0;
5784 ivideo->SiS_Pr.VideoMemorySize = 8 << 20;
5785 SiSSetMode(&ivideo->SiS_Pr, 0x2e | 0x80);
5786
5787 outSISIDXREG(SISSR, 0x05, 0x86);
5788
5789 /* Disable read-cache */
5790 andSISIDXREG(SISSR, 0x21, 0xdf);
5791 sisfb_post_xgi_ramsize(ivideo);
5792 /* Enable read-cache */
5793 orSISIDXREG(SISSR, 0x21, 0x20);
5794
5795 }
5796
5797 #if 0
5798 printk(KERN_DEBUG "-----------------\n");
5799 for(i = 0; i < 0xff; i++) {
5800 inSISIDXREG(SISCR, i, reg);
5801 printk(KERN_DEBUG "CR%02x(%x) = 0x%02x\n", i, SISCR, reg);
5802 }
5803 for(i = 0; i < 0x40; i++) {
5804 inSISIDXREG(SISSR, i, reg);
5805 printk(KERN_DEBUG "SR%02x(%x) = 0x%02x\n", i, SISSR, reg);
5806 }
5807 printk(KERN_DEBUG "-----------------\n");
5808 #endif
5809
5810 /* Sense CRT1 */
5811 if(ivideo->chip == XGI_20) {
5812 orSISIDXREG(SISCR, 0x32, 0x20);
5813 } else {
5814 inSISIDXREG(SISPART4, 0x00, reg);
5815 if((reg == 1) || (reg == 2)) {
5816 sisfb_sense_crt1(ivideo);
5817 } else {
5818 orSISIDXREG(SISCR, 0x32, 0x20);
5819 }
5820 }
5821
5822 /* Set default mode, don't clear screen */
5823 ivideo->SiS_Pr.SiS_UseOEM = FALSE;
5824 SiS_SetEnableDstn(&ivideo->SiS_Pr, FALSE);
5825 SiS_SetEnableFstn(&ivideo->SiS_Pr, FALSE);
5826 ivideo->curFSTN = ivideo->curDSTN = 0;
5827 SiSSetMode(&ivideo->SiS_Pr, 0x2e | 0x80);
5828
5829 outSISIDXREG(SISSR, 0x05, 0x86);
5830
5831 /* Display off */
5832 orSISIDXREG(SISSR, 0x01, 0x20);
5833
5834 /* Save mode number in CR34 */
5835 outSISIDXREG(SISCR, 0x34, 0x2e);
5836
5837 /* Let everyone know what the current mode is */
5838 ivideo->modeprechange = 0x2e;
5839
5840 if(ivideo->chip == XGI_40) {
5841 inSISIDXREG(SISCR, 0xca, reg);
5842 inSISIDXREG(SISCR, 0xcc, v1);
5843 if((reg & 0x10) && (!(v1 & 0x04))) {
5844 printk(KERN_ERR
5845 "sisfb: Please connect power to the card.\n");
5846 return 0;
5847 }
5848 }
5849
5850 return 1;
5851 }
5852 #endif
5853
5854 static int __devinit
5855 sisfb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
5856 {
5857 struct sisfb_chip_info *chipinfo = &sisfb_chip_info[ent->driver_data];
5858 struct sis_video_info *ivideo = NULL;
5859 struct fb_info *sis_fb_info = NULL;
5860 u16 reg16;
5861 u8 reg;
5862 int i, ret;
5863
5864 if(sisfb_off)
5865 return -ENXIO;
5866
5867 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,3))
5868 sis_fb_info = framebuffer_alloc(sizeof(*ivideo), &pdev->dev);
5869 if(!sis_fb_info)
5870 return -ENOMEM;
5871 #else
5872 sis_fb_info = kmalloc(sizeof(*sis_fb_info) + sizeof(*ivideo), GFP_KERNEL);
5873 if(!sis_fb_info)
5874 return -ENOMEM;
5875 memset(sis_fb_info, 0, sizeof(*sis_fb_info) + sizeof(*ivideo));
5876 sis_fb_info->par = ((char *)sis_fb_info + sizeof(*sis_fb_info));
5877 #endif
5878
5879 ivideo = (struct sis_video_info *)sis_fb_info->par;
5880 ivideo->memyselfandi = sis_fb_info;
5881
5882 ivideo->sisfb_id = SISFB_ID;
5883
5884 if(card_list == NULL) {
5885 ivideo->cardnumber = 0;
5886 } else {
5887 struct sis_video_info *countvideo = card_list;
5888 ivideo->cardnumber = 1;
5889 while((countvideo = countvideo->next) != 0)
5890 ivideo->cardnumber++;
5891 }
5892
5893 strncpy(ivideo->myid, chipinfo->chip_name, 30);
5894
5895 ivideo->warncount = 0;
5896 ivideo->chip_id = pdev->device;
5897 ivideo->chip_vendor = pdev->vendor;
5898 pci_read_config_byte(pdev, PCI_REVISION_ID, &ivideo->revision_id);
5899 ivideo->SiS_Pr.ChipRevision = ivideo->revision_id;
5900 pci_read_config_word(pdev, PCI_COMMAND, &reg16);
5901 ivideo->sisvga_enabled = reg16 & 0x01;
5902 ivideo->pcibus = pdev->bus->number;
5903 ivideo->pcislot = PCI_SLOT(pdev->devfn);
5904 ivideo->pcifunc = PCI_FUNC(pdev->devfn);
5905 ivideo->subsysvendor = pdev->subsystem_vendor;
5906 ivideo->subsysdevice = pdev->subsystem_device;
5907 #ifdef SIS_OLD_CONFIG_COMPAT
5908 ivideo->ioctl32registered = 0;
5909 #endif
5910
5911 #ifndef MODULE
5912 if(sisfb_mode_idx == -1) {
5913 sisfb_get_vga_mode_from_kernel();
5914 }
5915 #endif
5916
5917 ivideo->chip = chipinfo->chip;
5918 ivideo->sisvga_engine = chipinfo->vgaengine;
5919 ivideo->hwcursor_size = chipinfo->hwcursor_size;
5920 ivideo->CRT2_write_enable = chipinfo->CRT2_write_enable;
5921 ivideo->mni = chipinfo->mni;
5922
5923 ivideo->detectedpdc = 0xff;
5924 ivideo->detectedpdca = 0xff;
5925 ivideo->detectedlcda = 0xff;
5926
5927 ivideo->sisfb_thismonitor.datavalid = FALSE;
5928
5929 ivideo->current_base = 0;
5930
5931 ivideo->engineok = 0;
5932
5933 ivideo->sisfb_was_boot_device = 0;
5934 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12))
5935 if(pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW) {
5936 if(ivideo->sisvga_enabled)
5937 ivideo->sisfb_was_boot_device = 1;
5938 else {
5939 printk(KERN_DEBUG "sisfb: PCI device is disabled, "
5940 "but marked as boot video device ???\n");
5941 printk(KERN_DEBUG "sisfb: I will not accept this "
5942 "as the primary VGA device\n");
5943 }
5944 }
5945 #endif
5946
5947 ivideo->sisfb_parm_mem = sisfb_parm_mem;
5948 ivideo->sisfb_accel = sisfb_accel;
5949 ivideo->sisfb_ypan = sisfb_ypan;
5950 ivideo->sisfb_max = sisfb_max;
5951 ivideo->sisfb_userom = sisfb_userom;
5952 ivideo->sisfb_useoem = sisfb_useoem;
5953 ivideo->sisfb_mode_idx = sisfb_mode_idx;
5954 ivideo->sisfb_parm_rate = sisfb_parm_rate;
5955 ivideo->sisfb_crt1off = sisfb_crt1off;
5956 ivideo->sisfb_forcecrt1 = sisfb_forcecrt1;
5957 ivideo->sisfb_crt2type = sisfb_crt2type;
5958 ivideo->sisfb_crt2flags = sisfb_crt2flags;
5959 /* pdc(a), scalelcd, special timing, lvdshl handled below */
5960 ivideo->sisfb_dstn = sisfb_dstn;
5961 ivideo->sisfb_fstn = sisfb_fstn;
5962 ivideo->sisfb_tvplug = sisfb_tvplug;
5963 ivideo->sisfb_tvstd = sisfb_tvstd;
5964 ivideo->tvxpos = sisfb_tvxposoffset;
5965 ivideo->tvypos = sisfb_tvyposoffset;
5966 ivideo->sisfb_nocrt2rate = sisfb_nocrt2rate;
5967 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,0)
5968 ivideo->sisfb_inverse = sisfb_inverse;
5969 #endif
5970
5971 ivideo->refresh_rate = 0;
5972 if(ivideo->sisfb_parm_rate != -1) {
5973 ivideo->refresh_rate = ivideo->sisfb_parm_rate;
5974 }
5975
5976 ivideo->SiS_Pr.UsePanelScaler = sisfb_scalelcd;
5977 ivideo->SiS_Pr.CenterScreen = -1;
5978 ivideo->SiS_Pr.SiS_CustomT = sisfb_specialtiming;
5979 ivideo->SiS_Pr.LVDSHL = sisfb_lvdshl;
5980
5981 ivideo->SiS_Pr.SiS_Backup70xx = 0xff;
5982 ivideo->SiS_Pr.SiS_CHOverScan = -1;
5983 ivideo->SiS_Pr.SiS_ChSW = FALSE;
5984 ivideo->SiS_Pr.SiS_UseLCDA = FALSE;
5985 ivideo->SiS_Pr.HaveEMI = FALSE;
5986 ivideo->SiS_Pr.HaveEMILCD = FALSE;
5987 ivideo->SiS_Pr.OverruleEMI = FALSE;
5988 ivideo->SiS_Pr.SiS_SensibleSR11 = FALSE;
5989 ivideo->SiS_Pr.SiS_MyCR63 = 0x63;
5990 ivideo->SiS_Pr.PDC = -1;
5991 ivideo->SiS_Pr.PDCA = -1;
5992 ivideo->SiS_Pr.DDCPortMixup = FALSE;
5993 #ifdef CONFIG_FB_SIS_315
5994 if(ivideo->chip >= SIS_330) {
5995 ivideo->SiS_Pr.SiS_MyCR63 = 0x53;
5996 if(ivideo->chip >= SIS_661) {
5997 ivideo->SiS_Pr.SiS_SensibleSR11 = TRUE;
5998 }
5999 }
6000 #endif
6001
6002 memcpy(&ivideo->default_var, &my_default_var, sizeof(my_default_var));
6003
6004 pci_set_drvdata(pdev, ivideo);
6005
6006 /* Patch special cases */
6007 if((ivideo->nbridge = sisfb_get_northbridge(ivideo->chip))) {
6008 switch(ivideo->nbridge->device) {
6009 #ifdef CONFIG_FB_SIS_300
6010 case PCI_DEVICE_ID_SI_730:
6011 ivideo->chip = SIS_730;
6012 strcpy(ivideo->myid, "SiS 730");
6013 break;
6014 #endif
6015 #ifdef CONFIG_FB_SIS_315
6016 case PCI_DEVICE_ID_SI_651:
6017 /* ivideo->chip is ok */
6018 strcpy(ivideo->myid, "SiS 651");
6019 break;
6020 case PCI_DEVICE_ID_SI_740:
6021 ivideo->chip = SIS_740;
6022 strcpy(ivideo->myid, "SiS 740");
6023 break;
6024 case PCI_DEVICE_ID_SI_661:
6025 ivideo->chip = SIS_661;
6026 strcpy(ivideo->myid, "SiS 661");
6027 break;
6028 case PCI_DEVICE_ID_SI_741:
6029 ivideo->chip = SIS_741;
6030 strcpy(ivideo->myid, "SiS 741");
6031 break;
6032 case PCI_DEVICE_ID_SI_760:
6033 ivideo->chip = SIS_760;
6034 strcpy(ivideo->myid, "SiS 760");
6035 break;
6036 case PCI_DEVICE_ID_SI_761:
6037 ivideo->chip = SIS_761;
6038 strcpy(ivideo->myid, "SiS 761");
6039 break;
6040 #endif
6041 default:
6042 break;
6043 }
6044 }
6045
6046 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
6047 strcpy(sis_fb_info->modename, ivideo->myid);
6048 #endif
6049
6050 ivideo->SiS_Pr.ChipType = ivideo->chip;
6051
6052 ivideo->SiS_Pr.ivideo = (void *)ivideo;
6053
6054 #ifdef CONFIG_FB_SIS_315
6055 if((ivideo->SiS_Pr.ChipType == SIS_315PRO) ||
6056 (ivideo->SiS_Pr.ChipType == SIS_315)) {
6057 ivideo->SiS_Pr.ChipType = SIS_315H;
6058 }
6059 #endif
6060
6061 if(!ivideo->sisvga_enabled) {
6062 if(pci_enable_device(pdev)) {
6063 if(ivideo->nbridge) SIS_PCI_PUT_DEVICE(ivideo->nbridge);
6064 pci_set_drvdata(pdev, NULL);
6065 kfree(sis_fb_info);
6066 return -EIO;
6067 }
6068 }
6069
6070 ivideo->video_base = pci_resource_start(pdev, 0);
6071 ivideo->mmio_base = pci_resource_start(pdev, 1);
6072 ivideo->mmio_size = pci_resource_len(pdev, 1);
6073 ivideo->SiS_Pr.RelIO = pci_resource_start(pdev, 2) + 0x30;
6074 ivideo->SiS_Pr.IOAddress = ivideo->vga_base = ivideo->SiS_Pr.RelIO;
6075
6076 SiSRegInit(&ivideo->SiS_Pr, ivideo->SiS_Pr.IOAddress);
6077
6078 #ifdef CONFIG_FB_SIS_300
6079 /* Find PCI systems for Chrontel/GPIO communication setup */
6080 if(ivideo->chip == SIS_630) {
6081 i = 0;
6082 do {
6083 if(mychswtable[i].subsysVendor == ivideo->subsysvendor &&
6084 mychswtable[i].subsysCard == ivideo->subsysdevice) {
6085 ivideo->SiS_Pr.SiS_ChSW = TRUE;
6086 printk(KERN_DEBUG "sisfb: Identified [%s %s] "
6087 "requiring Chrontel/GPIO setup\n",
6088 mychswtable[i].vendorName,
6089 mychswtable[i].cardName);
6090 ivideo->lpcdev = SIS_PCI_GET_DEVICE(PCI_VENDOR_ID_SI, 0x0008, NULL);
6091 break;
6092 }
6093 i++;
6094 } while(mychswtable[i].subsysVendor != 0);
6095 }
6096 #endif
6097
6098 #ifdef CONFIG_FB_SIS_315
6099 if((ivideo->chip == SIS_760) && (ivideo->nbridge)) {
6100 ivideo->lpcdev = SIS_PCI_GET_SLOT(ivideo->nbridge->bus, (2 << 3));
6101 }
6102 #endif
6103
6104 outSISIDXREG(SISSR, 0x05, 0x86);
6105
6106 if( (!ivideo->sisvga_enabled)
6107 #if !defined(__i386__) && !defined(__x86_64__)
6108 || (sisfb_resetcard)
6109 #endif
6110 ) {
6111 for(i = 0x30; i <= 0x3f; i++) {
6112 outSISIDXREG(SISCR, i, 0x00);
6113 }
6114 }
6115
6116 /* Find out about current video mode */
6117 ivideo->modeprechange = 0x03;
6118 inSISIDXREG(SISCR, 0x34, reg);
6119 if(reg & 0x7f) {
6120 ivideo->modeprechange = reg & 0x7f;
6121 } else if(ivideo->sisvga_enabled) {
6122 #if defined(__i386__) || defined(__x86_64__)
6123 unsigned char SIS_IOTYPE2 *tt = ioremap(0x400, 0x100);
6124 if(tt) {
6125 ivideo->modeprechange = readb(tt + 0x49);
6126 iounmap(tt);
6127 }
6128 #endif
6129 }
6130
6131 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
6132 #ifdef MODULE
6133 if((reg & 0x80) && (reg != 0xff)) {
6134 if((sisbios_mode[ivideo->sisfb_mode_idx].mode_no[ivideo->mni])
6135 != 0xFF) {
6136 printk(KERN_INFO "sisfb: Cannot initialize display mode, "
6137 "X server is active\n");
6138 ret = -EBUSY;
6139 goto error_4;
6140 }
6141 }
6142 #endif
6143 #endif
6144
6145 /* Search and copy ROM image */
6146 ivideo->bios_abase = NULL;
6147 ivideo->SiS_Pr.VirtualRomBase = NULL;
6148 ivideo->SiS_Pr.UseROM = FALSE;
6149 ivideo->haveXGIROM = ivideo->SiS_Pr.SiS_XGIROM = FALSE;
6150 if(ivideo->sisfb_userom) {
6151 ivideo->SiS_Pr.VirtualRomBase = sisfb_find_rom(pdev);
6152 ivideo->bios_abase = ivideo->SiS_Pr.VirtualRomBase;
6153 ivideo->SiS_Pr.UseROM = (ivideo->SiS_Pr.VirtualRomBase) ? TRUE : FALSE;
6154 printk(KERN_INFO "sisfb: Video ROM %sfound\n",
6155 ivideo->SiS_Pr.UseROM ? "" : "not ");
6156 if((ivideo->SiS_Pr.UseROM) && (ivideo->chip >= XGI_20)) {
6157 ivideo->SiS_Pr.UseROM = FALSE;
6158 ivideo->haveXGIROM = ivideo->SiS_Pr.SiS_XGIROM = TRUE;
6159 if( (ivideo->revision_id == 2) &&
6160 (!(ivideo->bios_abase[0x1d1] & 0x01)) ) {
6161 ivideo->SiS_Pr.DDCPortMixup = TRUE;
6162 }
6163 }
6164 } else {
6165 printk(KERN_INFO "sisfb: Video ROM usage disabled\n");
6166 }
6167
6168 /* Find systems for special custom timing */
6169 if(ivideo->SiS_Pr.SiS_CustomT == CUT_NONE) {
6170 sisfb_detect_custom_timing(ivideo);
6171 }
6172
6173 /* POST card in case this has not been done by the BIOS */
6174 if( (!ivideo->sisvga_enabled)
6175 #if !defined(__i386__) && !defined(__x86_64__)
6176 || (sisfb_resetcard)
6177 #endif
6178 ) {
6179 #ifdef CONFIG_FB_SIS_300
6180 if(ivideo->sisvga_engine == SIS_300_VGA) {
6181 if(ivideo->chip == SIS_300) {
6182 sisfb_post_sis300(pdev);
6183 ivideo->sisfb_can_post = 1;
6184 }
6185 }
6186 #endif
6187
6188 #ifdef CONFIG_FB_SIS_315
6189 if(ivideo->sisvga_engine == SIS_315_VGA) {
6190 int result = 1;
6191 /* if((ivideo->chip == SIS_315H) ||
6192 (ivideo->chip == SIS_315) ||
6193 (ivideo->chip == SIS_315PRO) ||
6194 (ivideo->chip == SIS_330)) {
6195 sisfb_post_sis315330(pdev);
6196 } else */ if(ivideo->chip == XGI_20) {
6197 result = sisfb_post_xgi(pdev);
6198 ivideo->sisfb_can_post = 1;
6199 } else if((ivideo->chip == XGI_40) && ivideo->haveXGIROM) {
6200 result = sisfb_post_xgi(pdev);
6201 ivideo->sisfb_can_post = 1;
6202 } else {
6203 printk(KERN_INFO "sisfb: Card is not "
6204 "POSTed and sisfb can't do this either.\n");
6205 }
6206 if(!result) {
6207 printk(KERN_ERR "sisfb: Failed to POST card\n");
6208 ret = -ENODEV;
6209 goto error_3;
6210 }
6211 }
6212 #endif
6213 }
6214
6215 ivideo->sisfb_card_posted = 1;
6216
6217 /* Find out about RAM size */
6218 if(sisfb_get_dram_size(ivideo)) {
6219 printk(KERN_INFO "sisfb: Fatal error: Unable to determine VRAM size.\n");
6220 ret = -ENODEV;
6221 goto error_3;
6222 }
6223
6224
6225 /* Enable PCI addressing and MMIO */
6226 if((ivideo->sisfb_mode_idx < 0) ||
6227 ((sisbios_mode[ivideo->sisfb_mode_idx].mode_no[ivideo->mni]) != 0xFF)) {
6228 /* Enable PCI_LINEAR_ADDRESSING and MMIO_ENABLE */
6229 orSISIDXREG(SISSR, IND_SIS_PCI_ADDRESS_SET, (SIS_PCI_ADDR_ENABLE | SIS_MEM_MAP_IO_ENABLE));
6230 /* Enable 2D accelerator engine */
6231 orSISIDXREG(SISSR, IND_SIS_MODULE_ENABLE, SIS_ENABLE_2D);
6232 }
6233
6234 if(sisfb_pdc != 0xff) {
6235 if(ivideo->sisvga_engine == SIS_300_VGA)
6236 sisfb_pdc &= 0x3c;
6237 else
6238 sisfb_pdc &= 0x1f;
6239 ivideo->SiS_Pr.PDC = sisfb_pdc;
6240 }
6241 #ifdef CONFIG_FB_SIS_315
6242 if(ivideo->sisvga_engine == SIS_315_VGA) {
6243 if(sisfb_pdca != 0xff)
6244 ivideo->SiS_Pr.PDCA = sisfb_pdca & 0x1f;
6245 }
6246 #endif
6247
6248 if(!request_mem_region(ivideo->video_base, ivideo->video_size, "sisfb FB")) {
6249 printk(KERN_ERR "sisfb: Fatal error: Unable to reserve %dMB framebuffer memory\n",
6250 (int)(ivideo->video_size >> 20));
6251 printk(KERN_ERR "sisfb: Is there another framebuffer driver active?\n");
6252 ret = -ENODEV;
6253 goto error_3;
6254 }
6255
6256 if(!request_mem_region(ivideo->mmio_base, ivideo->mmio_size, "sisfb MMIO")) {
6257 printk(KERN_ERR "sisfb: Fatal error: Unable to reserve MMIO region\n");
6258 ret = -ENODEV;
6259 goto error_2;
6260 }
6261
6262 ivideo->video_vbase = ioremap(ivideo->video_base, ivideo->video_size);
6263 ivideo->SiS_Pr.VideoMemoryAddress = ivideo->video_vbase;
6264 if(!ivideo->video_vbase) {
6265 printk(KERN_ERR "sisfb: Fatal error: Unable to map framebuffer memory\n");
6266 ret = -ENODEV;
6267 goto error_1;
6268 }
6269
6270 ivideo->mmio_vbase = ioremap(ivideo->mmio_base, ivideo->mmio_size);
6271 if(!ivideo->mmio_vbase) {
6272 printk(KERN_ERR "sisfb: Fatal error: Unable to map MMIO region\n");
6273 ret = -ENODEV;
6274 error_0: iounmap(ivideo->video_vbase);
6275 error_1: release_mem_region(ivideo->video_base, ivideo->video_size);
6276 error_2: release_mem_region(ivideo->mmio_base, ivideo->mmio_size);
6277 error_3: vfree(ivideo->bios_abase);
6278 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
6279 error_4:
6280 #endif
6281 if(ivideo->lpcdev)
6282 SIS_PCI_PUT_DEVICE(ivideo->lpcdev);
6283 if(ivideo->nbridge)
6284 SIS_PCI_PUT_DEVICE(ivideo->nbridge);
6285 pci_set_drvdata(pdev, NULL);
6286 if(!ivideo->sisvga_enabled)
6287 pci_disable_device(pdev);
6288 kfree(sis_fb_info);
6289 return ret;
6290 }
6291
6292 printk(KERN_INFO "sisfb: Video RAM at 0x%lx, mapped to 0x%lx, size %ldk\n",
6293 ivideo->video_base, (unsigned long)ivideo->video_vbase, ivideo->video_size / 1024);
6294
6295 if(ivideo->video_offset) {
6296 printk(KERN_INFO "sisfb: Viewport offset %ldk\n",
6297 ivideo->video_offset / 1024);
6298 }
6299
6300 printk(KERN_INFO "sisfb: MMIO at 0x%lx, mapped to 0x%lx, size %ldk\n",
6301 ivideo->mmio_base, (unsigned long)ivideo->mmio_vbase, ivideo->mmio_size / 1024);
6302
6303
6304 /* Determine the size of the command queue */
6305 if(ivideo->sisvga_engine == SIS_300_VGA) {
6306 ivideo->cmdQueueSize = TURBO_QUEUE_AREA_SIZE;
6307 } else {
6308 if(ivideo->chip == XGI_20) {
6309 ivideo->cmdQueueSize = COMMAND_QUEUE_AREA_SIZE_Z7;
6310 } else {
6311 ivideo->cmdQueueSize = COMMAND_QUEUE_AREA_SIZE;
6312 }
6313 }
6314
6315 /* Engines are no longer initialized here; this is
6316 * now done after the first mode-switch (if the
6317 * submitted var has its acceleration flags set).
6318 */
6319
6320 /* Calculate the base of the (unused) hw cursor */
6321 ivideo->hwcursor_vbase = ivideo->video_vbase
6322 + ivideo->video_size
6323 - ivideo->cmdQueueSize
6324 - ivideo->hwcursor_size;
6325 ivideo->caps |= HW_CURSOR_CAP;
6326
6327 /* Initialize offscreen memory manager */
6328 if((ivideo->havenoheap = sisfb_heap_init(ivideo))) {
6329 printk(KERN_WARNING "sisfb: Failed to initialize offscreen memory heap\n");
6330 }
6331
6332 /* Used for clearing the screen only, therefore respect our mem limit */
6333 ivideo->SiS_Pr.VideoMemoryAddress += ivideo->video_offset;
6334 ivideo->SiS_Pr.VideoMemorySize = ivideo->sisfb_mem;
6335
6336 ivideo->mtrr = -1;
6337
6338 ivideo->vbflags = 0;
6339 ivideo->lcddefmodeidx = DEFAULT_LCDMODE;
6340 ivideo->tvdefmodeidx = DEFAULT_TVMODE;
6341 ivideo->defmodeidx = DEFAULT_MODE;
6342
6343 ivideo->newrom = 0;
6344 if(ivideo->chip < XGI_20) {
6345 if(ivideo->bios_abase) {
6346 ivideo->newrom = SiSDetermineROMLayout661(&ivideo->SiS_Pr);
6347 }
6348 }
6349
6350 if((ivideo->sisfb_mode_idx < 0) ||
6351 ((sisbios_mode[ivideo->sisfb_mode_idx].mode_no[ivideo->mni]) != 0xFF)) {
6352
6353 sisfb_sense_crt1(ivideo);
6354
6355 sisfb_get_VB_type(ivideo);
6356
6357 if(ivideo->vbflags2 & VB2_VIDEOBRIDGE) {
6358 sisfb_detect_VB_connect(ivideo);
6359 }
6360
6361 ivideo->currentvbflags = ivideo->vbflags & (VB_VIDEOBRIDGE | TV_STANDARD);
6362
6363 /* Decide on which CRT2 device to use */
6364 if(ivideo->vbflags2 & VB2_VIDEOBRIDGE) {
6365 if(ivideo->sisfb_crt2type != -1) {
6366 if((ivideo->sisfb_crt2type == CRT2_LCD) &&
6367 (ivideo->vbflags & CRT2_LCD)) {
6368 ivideo->currentvbflags |= CRT2_LCD;
6369 } else if(ivideo->sisfb_crt2type != CRT2_LCD) {
6370 ivideo->currentvbflags |= ivideo->sisfb_crt2type;
6371 }
6372 } else {
6373 /* Chrontel 700x TV detection often unreliable, therefore
6374 * use a different default order on such machines
6375 */
6376 if((ivideo->sisvga_engine == SIS_300_VGA) &&
6377 (ivideo->vbflags2 & VB2_CHRONTEL)) {
6378 if(ivideo->vbflags & CRT2_LCD)
6379 ivideo->currentvbflags |= CRT2_LCD;
6380 else if(ivideo->vbflags & CRT2_TV)
6381 ivideo->currentvbflags |= CRT2_TV;
6382 else if(ivideo->vbflags & CRT2_VGA)
6383 ivideo->currentvbflags |= CRT2_VGA;
6384 } else {
6385 if(ivideo->vbflags & CRT2_TV)
6386 ivideo->currentvbflags |= CRT2_TV;
6387 else if(ivideo->vbflags & CRT2_LCD)
6388 ivideo->currentvbflags |= CRT2_LCD;
6389 else if(ivideo->vbflags & CRT2_VGA)
6390 ivideo->currentvbflags |= CRT2_VGA;
6391 }
6392 }
6393 }
6394
6395 if(ivideo->vbflags & CRT2_LCD) {
6396 sisfb_detect_lcd_type(ivideo);
6397 }
6398
6399 sisfb_save_pdc_emi(ivideo);
6400
6401 if(!ivideo->sisfb_crt1off) {
6402 sisfb_handle_ddc(ivideo, &ivideo->sisfb_thismonitor, 0);
6403 } else {
6404 if((ivideo->vbflags2 & VB2_SISTMDSBRIDGE) &&
6405 (ivideo->vbflags & (CRT2_VGA | CRT2_LCD))) {
6406 sisfb_handle_ddc(ivideo, &ivideo->sisfb_thismonitor, 1);
6407 }
6408 }
6409
6410 if(ivideo->sisfb_mode_idx >= 0) {
6411 int bu = ivideo->sisfb_mode_idx;
6412 ivideo->sisfb_mode_idx = sisfb_validate_mode(ivideo,
6413 ivideo->sisfb_mode_idx, ivideo->currentvbflags);
6414 if(bu != ivideo->sisfb_mode_idx) {
6415 printk(KERN_ERR "Mode %dx%dx%d failed validation\n",
6416 sisbios_mode[bu].xres,
6417 sisbios_mode[bu].yres,
6418 sisbios_mode[bu].bpp);
6419 }
6420 }
6421
6422 if(ivideo->sisfb_mode_idx < 0) {
6423 switch(ivideo->currentvbflags & VB_DISPTYPE_DISP2) {
6424 case CRT2_LCD:
6425 ivideo->sisfb_mode_idx = ivideo->lcddefmodeidx;
6426 break;
6427 case CRT2_TV:
6428 ivideo->sisfb_mode_idx = ivideo->tvdefmodeidx;
6429 break;
6430 default:
6431 ivideo->sisfb_mode_idx = ivideo->defmodeidx;
6432 break;
6433 }
6434 }
6435
6436 ivideo->mode_no = sisbios_mode[ivideo->sisfb_mode_idx].mode_no[ivideo->mni];
6437
6438 if(ivideo->refresh_rate != 0) {
6439 sisfb_search_refresh_rate(ivideo, ivideo->refresh_rate,
6440 ivideo->sisfb_mode_idx);
6441 }
6442
6443 if(ivideo->rate_idx == 0) {
6444 ivideo->rate_idx = sisbios_mode[ivideo->sisfb_mode_idx].rate_idx;
6445 ivideo->refresh_rate = 60;
6446 }
6447
6448 if(ivideo->sisfb_thismonitor.datavalid) {
6449 if(!sisfb_verify_rate(ivideo, &ivideo->sisfb_thismonitor,
6450 ivideo->sisfb_mode_idx,
6451 ivideo->rate_idx,
6452 ivideo->refresh_rate)) {
6453 printk(KERN_INFO "sisfb: WARNING: Refresh rate "
6454 "exceeds monitor specs!\n");
6455 }
6456 }
6457
6458 ivideo->video_bpp = sisbios_mode[ivideo->sisfb_mode_idx].bpp;
6459 ivideo->video_width = sisbios_mode[ivideo->sisfb_mode_idx].xres;
6460 ivideo->video_height = sisbios_mode[ivideo->sisfb_mode_idx].yres;
6461
6462 sisfb_set_vparms(ivideo);
6463
6464 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
6465
6466 /* ---------------- For 2.4: Now switch the mode ------------------ */
6467
6468 printk(KERN_INFO "sisfb: Setting mode %dx%dx%d (%dHz)\n",
6469 ivideo->video_width, ivideo->video_height, ivideo->video_bpp,
6470 ivideo->refresh_rate);
6471
6472 /* Determine whether or not acceleration is to be
6473 * used. Need to know before pre/post_set_mode()
6474 */
6475 ivideo->accel = 0;
6476 ivideo->default_var.accel_flags &= ~FB_ACCELF_TEXT;
6477 if(ivideo->sisfb_accel) {
6478 ivideo->accel = -1;
6479 ivideo->default_var.accel_flags |= FB_ACCELF_TEXT;
6480 }
6481
6482 /* Now switch the mode */
6483 sisfb_pre_setmode(ivideo);
6484
6485 if(SiSSetMode(&ivideo->SiS_Pr, ivideo->mode_no) == 0) {
6486 printk(KERN_ERR "sisfb: Fatal error: Setting mode[0x%x] failed\n",
6487 ivideo->mode_no);
6488 ret = -EINVAL;
6489 iounmap(ivideo->mmio_vbase);
6490 goto error_0;
6491 }
6492
6493 outSISIDXREG(SISSR, IND_SIS_PASSWORD, SIS_PASSWORD);
6494
6495 sisfb_post_setmode(ivideo);
6496
6497 /* Maximize regardless of sisfb_max at startup */
6498 ivideo->default_var.yres_virtual = 32767;
6499
6500 /* Force reset of x virtual in crtc_to_var */
6501 ivideo->default_var.xres_virtual = 0;
6502
6503 /* Copy mode timing to var */
6504 sisfb_crtc_to_var(ivideo, &ivideo->default_var);
6505
6506 /* Find out about screen pitch */
6507 sisfb_calc_pitch(ivideo, &ivideo->default_var);
6508 sisfb_set_pitch(ivideo);
6509
6510 /* Init the accelerator (does nothing currently) */
6511 sisfb_initaccel(ivideo);
6512
6513 /* Init some fbinfo entries */
6514 sis_fb_info->node = -1;
6515 sis_fb_info->flags = FBINFO_FLAG_DEFAULT;
6516 sis_fb_info->fbops = &sisfb_ops;
6517 sis_fb_info->disp = &ivideo->sis_disp;
6518 sis_fb_info->blank = &sisfb_blank;
6519 sis_fb_info->switch_con = &sisfb_switch;
6520 sis_fb_info->updatevar = &sisfb_update_var;
6521 sis_fb_info->changevar = NULL;
6522 strcpy(sis_fb_info->fontname, sisfb_fontname);
6523
6524 sisfb_set_disp(-1, &ivideo->default_var, sis_fb_info);
6525
6526 #else /* --------- For 2.6: Setup a somewhat sane default var ------------ */
6527
6528 printk(KERN_INFO "sisfb: Default mode is %dx%dx%d (%dHz)\n",
6529 ivideo->video_width, ivideo->video_height, ivideo->video_bpp,
6530 ivideo->refresh_rate);
6531
6532 /* Set up the default var according to chosen default display mode */
6533 ivideo->default_var.xres = ivideo->default_var.xres_virtual = ivideo->video_width;
6534 ivideo->default_var.yres = ivideo->default_var.yres_virtual = ivideo->video_height;
6535 ivideo->default_var.bits_per_pixel = ivideo->video_bpp;
6536
6537 sisfb_bpp_to_var(ivideo, &ivideo->default_var);
6538
6539 ivideo->default_var.pixclock = (u32) (1000000000 /
6540 sisfb_mode_rate_to_dclock(&ivideo->SiS_Pr, ivideo->mode_no, ivideo->rate_idx));
6541
6542 if(sisfb_mode_rate_to_ddata(&ivideo->SiS_Pr, ivideo->mode_no,
6543 ivideo->rate_idx, &ivideo->default_var)) {
6544 if((ivideo->default_var.vmode & FB_VMODE_MASK) == FB_VMODE_DOUBLE) {
6545 ivideo->default_var.pixclock <<= 1;
6546 }
6547 }
6548
6549 if(ivideo->sisfb_ypan) {
6550 /* Maximize regardless of sisfb_max at startup */
6551 ivideo->default_var.yres_virtual =
6552 sisfb_calc_maxyres(ivideo, &ivideo->default_var);
6553 if(ivideo->default_var.yres_virtual < ivideo->default_var.yres) {
6554 ivideo->default_var.yres_virtual = ivideo->default_var.yres;
6555 }
6556 }
6557
6558 sisfb_calc_pitch(ivideo, &ivideo->default_var);
6559
6560 ivideo->accel = 0;
6561 if(ivideo->sisfb_accel) {
6562 ivideo->accel = -1;
6563 #ifdef STUPID_ACCELF_TEXT_SHIT
6564 ivideo->default_var.accel_flags |= FB_ACCELF_TEXT;
6565 #endif
6566 }
6567 sisfb_initaccel(ivideo);
6568
6569 #if defined(FBINFO_HWACCEL_DISABLED) && defined(FBINFO_HWACCEL_XPAN)
6570 sis_fb_info->flags = FBINFO_DEFAULT |
6571 FBINFO_HWACCEL_YPAN |
6572 FBINFO_HWACCEL_XPAN |
6573 FBINFO_HWACCEL_COPYAREA |
6574 FBINFO_HWACCEL_FILLRECT |
6575 ((ivideo->accel) ? 0 : FBINFO_HWACCEL_DISABLED);
6576 #else
6577 sis_fb_info->flags = FBINFO_FLAG_DEFAULT;
6578 #endif
6579 sis_fb_info->var = ivideo->default_var;
6580 sis_fb_info->fix = ivideo->sisfb_fix;
6581 sis_fb_info->screen_base = ivideo->video_vbase + ivideo->video_offset;
6582 sis_fb_info->fbops = &sisfb_ops;
6583
6584 sisfb_get_fix(&sis_fb_info->fix, -1, sis_fb_info);
6585 sis_fb_info->pseudo_palette = ivideo->pseudo_palette;
6586
6587 fb_alloc_cmap(&sis_fb_info->cmap, 256 , 0);
6588 #endif /* 2.6 */
6589
6590 printk(KERN_DEBUG "sisfb: Initial vbflags 0x%x\n", (int)ivideo->vbflags);
6591
6592 #ifdef CONFIG_MTRR
6593 ivideo->mtrr = mtrr_add(ivideo->video_base, ivideo->video_size,
6594 MTRR_TYPE_WRCOMB, 1);
6595 if(ivideo->mtrr < 0) {
6596 printk(KERN_DEBUG "sisfb: Failed to add MTRRs\n");
6597 }
6598 #endif
6599
6600 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
6601 vc_resize_con(1, 1, 0);
6602 #endif
6603
6604 if(register_framebuffer(sis_fb_info) < 0) {
6605 printk(KERN_ERR "sisfb: Fatal error: Failed to register framebuffer\n");
6606 ret = -EINVAL;
6607 iounmap(ivideo->mmio_vbase);
6608 goto error_0;
6609 }
6610
6611 ivideo->registered = 1;
6612
6613 /* Enlist us */
6614 ivideo->next = card_list;
6615 card_list = ivideo;
6616
6617 #ifdef SIS_OLD_CONFIG_COMPAT
6618 {
6619 int ret;
6620 /* Our ioctls are all "32/64bit compatible" */
6621 ret = register_ioctl32_conversion(FBIO_ALLOC, NULL);
6622 ret |= register_ioctl32_conversion(FBIO_FREE, NULL);
6623 ret |= register_ioctl32_conversion(FBIOGET_VBLANK, NULL);
6624 ret |= register_ioctl32_conversion(SISFB_GET_INFO_SIZE, NULL);
6625 ret |= register_ioctl32_conversion(SISFB_GET_INFO, NULL);
6626 ret |= register_ioctl32_conversion(SISFB_GET_TVPOSOFFSET, NULL);
6627 ret |= register_ioctl32_conversion(SISFB_SET_TVPOSOFFSET, NULL);
6628 ret |= register_ioctl32_conversion(SISFB_SET_LOCK, NULL);
6629 ret |= register_ioctl32_conversion(SISFB_GET_VBRSTATUS, NULL);
6630 ret |= register_ioctl32_conversion(SISFB_GET_AUTOMAXIMIZE, NULL);
6631 ret |= register_ioctl32_conversion(SISFB_SET_AUTOMAXIMIZE, NULL);
6632 ret |= register_ioctl32_conversion(SISFB_COMMAND, NULL);
6633 if(ret)
6634 printk(KERN_ERR
6635 "sisfb: Error registering ioctl32 translations\n");
6636 else
6637 ivideo->ioctl32registered = 1;
6638 }
6639 #endif
6640
6641 printk(KERN_INFO "sisfb: 2D acceleration is %s, y-panning %s\n",
6642 ivideo->sisfb_accel ? "enabled" : "disabled",
6643 ivideo->sisfb_ypan ?
6644 (ivideo->sisfb_max ? "enabled (auto-max)" :
6645 "enabled (no auto-max)") :
6646 "disabled");
6647
6648
6649 printk(KERN_INFO "fb%d: %s frame buffer device version %d.%d.%d\n",
6650 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
6651 GET_FB_IDX(sis_fb_info->node),
6652 #else
6653 sis_fb_info->node,
6654 #endif
6655 ivideo->myid, VER_MAJOR, VER_MINOR, VER_LEVEL);
6656
6657 printk(KERN_INFO "sisfb: Copyright (C) 2001-2005 Thomas Winischhofer\n");
6658
6659 } /* if mode = "none" */
6660
6661 return 0;
6662 }
6663
6664 /*****************************************************/
6665 /* PCI DEVICE HANDLING */
6666 /*****************************************************/
6667
6668 static void __devexit sisfb_remove(struct pci_dev *pdev)
6669 {
6670 struct sis_video_info *ivideo = pci_get_drvdata(pdev);
6671 struct fb_info *sis_fb_info = ivideo->memyselfandi;
6672 int registered = ivideo->registered;
6673 int modechanged = ivideo->modechanged;
6674
6675 #ifdef SIS_OLD_CONFIG_COMPAT
6676 if(ivideo->ioctl32registered) {
6677 int ret;
6678 ret = unregister_ioctl32_conversion(FBIO_ALLOC);
6679 ret |= unregister_ioctl32_conversion(FBIO_FREE);
6680 ret |= unregister_ioctl32_conversion(FBIOGET_VBLANK);
6681 ret |= unregister_ioctl32_conversion(SISFB_GET_INFO_SIZE);
6682 ret |= unregister_ioctl32_conversion(SISFB_GET_INFO);
6683 ret |= unregister_ioctl32_conversion(SISFB_GET_TVPOSOFFSET);
6684 ret |= unregister_ioctl32_conversion(SISFB_SET_TVPOSOFFSET);
6685 ret |= unregister_ioctl32_conversion(SISFB_SET_LOCK);
6686 ret |= unregister_ioctl32_conversion(SISFB_GET_VBRSTATUS);
6687 ret |= unregister_ioctl32_conversion(SISFB_GET_AUTOMAXIMIZE);
6688 ret |= unregister_ioctl32_conversion(SISFB_SET_AUTOMAXIMIZE);
6689 ret |= unregister_ioctl32_conversion(SISFB_COMMAND);
6690 if(ret)
6691 printk(KERN_ERR
6692 "sisfb: Error unregistering ioctl32 translations\n");
6693 }
6694 #endif
6695
6696 /* Unmap */
6697 iounmap(ivideo->mmio_vbase);
6698 iounmap(ivideo->video_vbase);
6699
6700 /* Release mem regions */
6701 release_mem_region(ivideo->video_base, ivideo->video_size);
6702 release_mem_region(ivideo->mmio_base, ivideo->mmio_size);
6703
6704 vfree(ivideo->bios_abase);
6705
6706 if(ivideo->lpcdev)
6707 SIS_PCI_PUT_DEVICE(ivideo->lpcdev);
6708
6709 if(ivideo->nbridge)
6710 SIS_PCI_PUT_DEVICE(ivideo->nbridge);
6711
6712 #ifdef CONFIG_MTRR
6713 /* Release MTRR region */
6714 if(ivideo->mtrr >= 0)
6715 mtrr_del(ivideo->mtrr, ivideo->video_base, ivideo->video_size);
6716 #endif
6717
6718 pci_set_drvdata(pdev, NULL);
6719
6720 /* If device was disabled when starting, disable
6721 * it when quitting.
6722 */
6723 if(!ivideo->sisvga_enabled)
6724 pci_disable_device(pdev);
6725
6726 /* Unregister the framebuffer */
6727 if(ivideo->registered) {
6728 unregister_framebuffer(sis_fb_info);
6729 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,3))
6730 framebuffer_release(sis_fb_info);
6731 #else
6732 kfree(sis_fb_info);
6733 #endif
6734 }
6735
6736 /* OK, our ivideo is gone for good from here. */
6737
6738 /* TODO: Restore the initial mode
6739 * This sounds easy but is as good as impossible
6740 * on many machines with SiS chip and video bridge
6741 * since text modes are always set up differently
6742 * from machine to machine. Depends on the type
6743 * of integration between chipset and bridge.
6744 */
6745 if(registered && modechanged)
6746 printk(KERN_INFO
6747 "sisfb: Restoring of text mode not supported yet\n");
6748 };
6749
6750 static struct pci_driver sisfb_driver = {
6751 .name = "sisfb",
6752 .id_table = sisfb_pci_table,
6753 .probe = sisfb_probe,
6754 .remove = __devexit_p(sisfb_remove)
6755 };
6756
6757 SISINITSTATIC int __init sisfb_init(void)
6758 {
6759 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,8)
6760 #ifndef MODULE
6761 char *options = NULL;
6762
6763 if(fb_get_options("sisfb", &options))
6764 return -ENODEV;
6765
6766 sisfb_setup(options);
6767 #endif
6768 #endif
6769 return pci_register_driver(&sisfb_driver);
6770 }
6771
6772 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,8)
6773 #ifndef MODULE
6774 module_init(sisfb_init);
6775 #endif
6776 #endif
6777
6778 /*****************************************************/
6779 /* MODULE */
6780 /*****************************************************/
6781
6782 #ifdef MODULE
6783
6784 static char *mode = NULL;
6785 static int vesa = -1;
6786 static unsigned int rate = 0;
6787 static unsigned int crt1off = 1;
6788 static unsigned int mem = 0;
6789 static char *forcecrt2type = NULL;
6790 static int forcecrt1 = -1;
6791 static int pdc = -1;
6792 static int pdc1 = -1;
6793 static int noaccel = -1;
6794 static int noypan = -1;
6795 static int nomax = -1;
6796 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
6797 static int inverse = 0;
6798 #endif
6799 static int userom = -1;
6800 static int useoem = -1;
6801 static char *tvstandard = NULL;
6802 static int nocrt2rate = 0;
6803 static int scalelcd = -1;
6804 static char *specialtiming = NULL;
6805 static int lvdshl = -1;
6806 static int tvxposoffset = 0, tvyposoffset = 0;
6807 #if !defined(__i386__) && !defined(__x86_64__)
6808 static int resetcard = 0;
6809 static int videoram = 0;
6810 #endif
6811
6812 static int __init sisfb_init_module(void)
6813 {
6814 sisfb_setdefaultparms();
6815
6816 if(rate)
6817 sisfb_parm_rate = rate;
6818
6819 if((scalelcd == 0) || (scalelcd == 1))
6820 sisfb_scalelcd = scalelcd ^ 1;
6821
6822 /* Need to check crt2 type first for fstn/dstn */
6823
6824 if(forcecrt2type)
6825 sisfb_search_crt2type(forcecrt2type);
6826
6827 if(tvstandard)
6828 sisfb_search_tvstd(tvstandard);
6829
6830 if(mode)
6831 sisfb_search_mode(mode, FALSE);
6832 else if(vesa != -1)
6833 sisfb_search_vesamode(vesa, FALSE);
6834
6835 sisfb_crt1off = (crt1off == 0) ? 1 : 0;
6836
6837 sisfb_forcecrt1 = forcecrt1;
6838 if(forcecrt1 == 1)
6839 sisfb_crt1off = 0;
6840 else if(forcecrt1 == 0)
6841 sisfb_crt1off = 1;
6842
6843 if(noaccel == 1)
6844 sisfb_accel = 0;
6845 else if(noaccel == 0)
6846 sisfb_accel = 1;
6847
6848 if(noypan == 1)
6849 sisfb_ypan = 0;
6850 else if(noypan == 0)
6851 sisfb_ypan = 1;
6852
6853 if(nomax == 1)
6854 sisfb_max = 0;
6855 else if(nomax == 0)
6856 sisfb_max = 1;
6857
6858 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
6859 if(inverse) sisfb_inverse = 1;
6860 #endif
6861
6862 if(mem)
6863 sisfb_parm_mem = mem;
6864
6865 if(userom != -1)
6866 sisfb_userom = userom;
6867
6868 if(useoem != -1)
6869 sisfb_useoem = useoem;
6870
6871 if(pdc != -1)
6872 sisfb_pdc = (pdc & 0x7f);
6873
6874 if(pdc1 != -1)
6875 sisfb_pdca = (pdc1 & 0x1f);
6876
6877 sisfb_nocrt2rate = nocrt2rate;
6878
6879 if(specialtiming)
6880 sisfb_search_specialtiming(specialtiming);
6881
6882 if((lvdshl >= 0) && (lvdshl <= 3))
6883 sisfb_lvdshl = lvdshl;
6884
6885 sisfb_tvxposoffset = tvxposoffset;
6886 sisfb_tvyposoffset = tvyposoffset;
6887
6888 #if !defined(__i386__) && !defined(__x86_64__)
6889 sisfb_resetcard = (resetcard) ? 1 : 0;
6890 if(videoram)
6891 sisfb_videoram = videoram;
6892 #endif
6893
6894 return sisfb_init();
6895 }
6896
6897 static void __exit sisfb_remove_module(void)
6898 {
6899 pci_unregister_driver(&sisfb_driver);
6900 printk(KERN_DEBUG "sisfb: Module unloaded\n");
6901 }
6902
6903 module_init(sisfb_init_module);
6904 module_exit(sisfb_remove_module);
6905
6906 MODULE_DESCRIPTION("SiS 300/540/630/730/315/55x/65x/661/74x/330/76x/34x, XGI V3XT/V5/V8/Z7 framebuffer device driver");
6907 MODULE_LICENSE("GPL");
6908 MODULE_AUTHOR("Thomas Winischhofer <thomas@winischhofer.net>, Others");
6909
6910 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
6911 MODULE_PARM(mem, "i");
6912 MODULE_PARM(noaccel, "i");
6913 MODULE_PARM(noypan, "i");
6914 MODULE_PARM(nomax, "i");
6915 MODULE_PARM(userom, "i");
6916 MODULE_PARM(useoem, "i");
6917 MODULE_PARM(mode, "s");
6918 MODULE_PARM(vesa, "i");
6919 MODULE_PARM(rate, "i");
6920 MODULE_PARM(forcecrt1, "i");
6921 MODULE_PARM(forcecrt2type, "s");
6922 MODULE_PARM(scalelcd, "i");
6923 MODULE_PARM(pdc, "i");
6924 MODULE_PARM(pdc1, "i");
6925 MODULE_PARM(specialtiming, "s");
6926 MODULE_PARM(lvdshl, "i");
6927 MODULE_PARM(tvstandard, "s");
6928 MODULE_PARM(tvxposoffset, "i");
6929 MODULE_PARM(tvyposoffset, "i");
6930 MODULE_PARM(nocrt2rate, "i");
6931 MODULE_PARM(inverse, "i");
6932 #if !defined(__i386__) && !defined(__x86_64__)
6933 MODULE_PARM(resetcard, "i");
6934 MODULE_PARM(videoram, "i");
6935 #endif
6936 #endif
6937
6938 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
6939 module_param(mem, int, 0);
6940 module_param(noaccel, int, 0);
6941 module_param(noypan, int, 0);
6942 module_param(nomax, int, 0);
6943 module_param(userom, int, 0);
6944 module_param(useoem, int, 0);
6945 module_param(mode, charp, 0);
6946 module_param(vesa, int, 0);
6947 module_param(rate, int, 0);
6948 module_param(forcecrt1, int, 0);
6949 module_param(forcecrt2type, charp, 0);
6950 module_param(scalelcd, int, 0);
6951 module_param(pdc, int, 0);
6952 module_param(pdc1, int, 0);
6953 module_param(specialtiming, charp, 0);
6954 module_param(lvdshl, int, 0);
6955 module_param(tvstandard, charp, 0);
6956 module_param(tvxposoffset, int, 0);
6957 module_param(tvyposoffset, int, 0);
6958 module_param(nocrt2rate, int, 0);
6959 #if !defined(__i386__) && !defined(__x86_64__)
6960 module_param(resetcard, int, 0);
6961 module_param(videoram, int, 0);
6962 #endif
6963 #endif
6964
6965 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
6966 MODULE_PARM_DESC(mem,
6967 "\nDetermines the beginning of the video memory heap in KB. This heap is used\n"
6968 "for video RAM management for eg. DRM/DRI. On 300 series, the default depends\n"
6969 "on the amount of video RAM available. If 8MB of video RAM or less is available,\n"
6970 "the heap starts at 4096KB, if between 8 and 16MB are available at 8192KB,\n"
6971 "otherwise at 12288KB. On 315/330/340 series, the heap size is 32KB by default.\n"
6972 "The value is to be specified without 'KB' and must match the MaxXFBMem setting\n"
6973 "for XFree86 4.x/X.org 6.7 and later.\n");
6974 #else
6975 MODULE_PARM_DESC(mem,
6976 "\nDetermines the beginning of the video memory heap in KB. This heap is used\n"
6977 "for video RAM management for eg. DRM/DRI. On 300 series, the default depends\n"
6978 "on the amount of video RAM available. If 8MB of video RAM or less is available,\n"
6979 "the heap starts at 4096KB, if between 8 and 16MB are available at 8192KB,\n"
6980 "otherwise at 12288KB. On 315/330/340 series, the heap size is 32KB by default.\n"
6981 "The value is to be specified without 'KB'.\n");
6982 #endif
6983
6984 MODULE_PARM_DESC(noaccel,
6985 "\nIf set to anything other than 0, 2D acceleration will be disabled.\n"
6986 "(default: 0)\n");
6987
6988 MODULE_PARM_DESC(noypan,
6989 "\nIf set to anything other than 0, y-panning will be disabled and scrolling\n"
6990 "will be performed by redrawing the screen. (default: 0)\n");
6991
6992 MODULE_PARM_DESC(nomax,
6993 "\nIf y-panning is enabled, sisfb will by default use the entire available video\n"
6994 "memory for the virtual screen in order to optimize scrolling performance. If\n"
6995 "this is set to anything other than 0, sisfb will not do this and thereby \n"
6996 "enable the user to positively specify a virtual Y size of the screen using\n"
6997 "fbset. (default: 0)\n");
6998
6999 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
7000 MODULE_PARM_DESC(mode,
7001 "\nSelects the desired display mode in the format [X]x[Y]x[Depth], eg.\n"
7002 "1024x768x16. Other formats supported include XxY-Depth and\n"
7003 "XxY-Depth@Rate. If the parameter is only one (decimal or hexadecimal)\n"
7004 "number, it will be interpreted as a VESA mode number. (default: none if\n"
7005 "sisfb is a module; this leaves the console untouched and the driver will\n"
7006 "only do the video memory management for eg. DRM/DRI; 800x600x8 if sisfb\n"
7007 "is in the kernel)\n");
7008 MODULE_PARM_DESC(vesa,
7009 "\nSelects the desired display mode by VESA defined mode number, eg. 0x117\n"
7010 "(default: 0x0000 if sisfb is a module; this leaves the console untouched\n"
7011 "and the driver will only do the video memory management for eg. DRM/DRI;\n"
7012 "0x0103 if sisfb is in the kernel)\n");
7013 #endif
7014
7015 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
7016 MODULE_PARM_DESC(mode,
7017 "\nSelects the desired default display mode in the format XxYxDepth,\n"
7018 "eg. 1024x768x16. Other formats supported include XxY-Depth and\n"
7019 "XxY-Depth@Rate. If the parameter is only one (decimal or hexadecimal)\n"
7020 "number, it will be interpreted as a VESA mode number. (default: 800x600x8)\n");
7021
7022 MODULE_PARM_DESC(vesa,
7023 "\nSelects the desired default display mode by VESA defined mode number, eg.\n"
7024 "0x117 (default: 0x0103)\n");
7025 #endif
7026
7027 MODULE_PARM_DESC(rate,
7028 "\nSelects the desired vertical refresh rate for CRT1 (external VGA) in Hz.\n"
7029 "If the mode is specified in the format XxY-Depth@Rate, this parameter\n"
7030 "will be ignored (default: 60)\n");
7031
7032 MODULE_PARM_DESC(forcecrt1,
7033 "\nNormally, the driver autodetects whether or not CRT1 (external VGA) is \n"
7034 "connected. With this option, the detection can be overridden (1=CRT1 ON,\n"
7035 "0=CRT1 OFF) (default: [autodetected])\n");
7036
7037 MODULE_PARM_DESC(forcecrt2type,
7038 "\nIf this option is omitted, the driver autodetects CRT2 output devices, such as\n"
7039 "LCD, TV or secondary VGA. With this option, this autodetection can be\n"
7040 "overridden. Possible parameters are LCD, TV, VGA or NONE. NONE disables CRT2.\n"
7041 "On systems with a SiS video bridge, parameters SVIDEO, COMPOSITE or SCART can\n"
7042 "be used instead of TV to override the TV detection. Furthermore, on systems\n"
7043 "with a SiS video bridge, SVIDEO+COMPOSITE, HIVISION, YPBPR480I, YPBPR480P,\n"
7044 "YPBPR720P and YPBPR1080I are understood. However, whether or not these work\n"
7045 "depends on the very hardware in use. (default: [autodetected])\n");
7046
7047 MODULE_PARM_DESC(scalelcd,
7048 "\nSetting this to 1 will force the driver to scale the LCD image to the panel's\n"
7049 "native resolution. Setting it to 0 will disable scaling; LVDS panels will\n"
7050 "show black bars around the image, TMDS panels will probably do the scaling\n"
7051 "themselves. Default: 1 on LVDS panels, 0 on TMDS panels\n");
7052
7053 MODULE_PARM_DESC(pdc,
7054 "\nThis is for manually selecting the LCD panel delay compensation. The driver\n"
7055 "should detect this correctly in most cases; however, sometimes this is not\n"
7056 "possible. If you see 'small waves' on the LCD, try setting this to 4, 32 or 24\n"
7057 "on a 300 series chipset; 6 on other chipsets. If the problem persists, try\n"
7058 "other values (on 300 series: between 4 and 60 in steps of 4; otherwise: any\n"
7059 "value from 0 to 31). (default: autodetected, if LCD is active during start)\n");
7060
7061 #ifdef CONFIG_FB_SIS_315
7062 MODULE_PARM_DESC(pdc1,
7063 "\nThis is same as pdc, but for LCD-via CRT1. Hence, this is for the 315/330/340\n"
7064 "series only. (default: autodetected if LCD is in LCD-via-CRT1 mode during\n"
7065 "startup) - Note: currently, this has no effect because LCD-via-CRT1 is not\n"
7066 "implemented yet.\n");
7067 #endif
7068
7069 MODULE_PARM_DESC(specialtiming,
7070 "\nPlease refer to documentation for more information on this option.\n");
7071
7072 MODULE_PARM_DESC(lvdshl,
7073 "\nPlease refer to documentation for more information on this option.\n");
7074
7075 MODULE_PARM_DESC(tvstandard,
7076 "\nThis allows overriding the BIOS default for the TV standard. Valid choices are\n"
7077 "pal, ntsc, palm and paln. (default: [auto; pal or ntsc only])\n");
7078
7079 MODULE_PARM_DESC(tvxposoffset,
7080 "\nRelocate TV output horizontally. Possible parameters: -32 through 32.\n"
7081 "Default: 0\n");
7082
7083 MODULE_PARM_DESC(tvyposoffset,
7084 "\nRelocate TV output vertically. Possible parameters: -32 through 32.\n"
7085 "Default: 0\n");
7086
7087 MODULE_PARM_DESC(nocrt2rate,
7088 "\nSetting this to 1 will force the driver to use the default refresh rate for\n"
7089 "CRT2 if CRT2 type is VGA. (default: 0, use same rate as CRT1)\n");
7090
7091 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
7092 MODULE_PARM_DESC(inverse,
7093 "\nSetting this to anything but 0 should invert the display colors, but this\n"
7094 "does not seem to work. (default: 0)\n");
7095 #endif
7096
7097 #if !defined(__i386__) && !defined(__x86_64__)
7098 #ifdef CONFIG_FB_SIS_300
7099 MODULE_PARM_DESC(resetcard,
7100 "\nSet this to 1 in order to reset (POST) the card on non-x86 machines where\n"
7101 "the BIOS did not POST the card (only supported for SiS 300/305 and XGI cards\n"
7102 "currently). Default: 0\n");
7103
7104 MODULE_PARM_DESC(videoram,
7105 "\nSet this to the amount of video RAM (in kilobyte) the card has. Required on\n"
7106 "some non-x86 architectures where the memory auto detection fails. Only\n"
7107 "relevant if resetcard is set, too. SiS300/305 only. Default: [auto-detect]\n");
7108 #endif
7109 #endif
7110
7111 #endif /* /MODULE */
7112
7113 /* _GPL only for new symbols. */
7114 EXPORT_SYMBOL(sis_malloc);
7115 EXPORT_SYMBOL(sis_free);
7116 EXPORT_SYMBOL_GPL(sis_malloc_new);
7117 EXPORT_SYMBOL_GPL(sis_free_new);
7118
7119
7120
Ubuntu Jammy Linux kernel mirror