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