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