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