3 * Hardware accelerated Matrox Millennium I, II, Mystique, G100, G200 and G400
5 * (c) 1998,1999,2000 Petr Vandrovec <vandrove@vc.cvut.cz>
7 * Version: 1.50 2000/08/10
9 * MTRR stuff: 1998 Tom Rini <trini@kernel.crashing.org>
11 * Contributors: "menion?" <menion@mindless.com>
12 * Betatesting, fixes, ideas
14 * "Kurt Garloff" <garloff@suse.de>
15 * Betatesting, fixes, ideas, videomodes, videomodes timmings
17 * "Tom Rini" <trini@kernel.crashing.org>
18 * MTRR stuff, PPC cleanups, betatesting, fixes, ideas
20 * "Bibek Sahu" <scorpio@dodds.net>
21 * Access device through readb|w|l and write b|w|l
22 * Extensive debugging stuff
24 * "Daniel Haun" <haund@usa.net>
25 * Testing, hardware cursor fixes
27 * "Scott Wood" <sawst46+@pitt.edu>
30 * "Gerd Knorr" <kraxel@goldbach.isdn.cs.tu-berlin.de>
33 * "Kelly French" <targon@hazmat.com>
34 * "Fernando Herrera" <fherrera@eurielec.etsit.upm.es>
35 * Betatesting, bug reporting
37 * "Pablo Bianucci" <pbian@pccp.com.ar>
38 * Fixes, ideas, betatesting
40 * "Inaky Perez Gonzalez" <inaky@peloncho.fis.ucm.es>
41 * Fixes, enhandcements, ideas, betatesting
43 * "Ryuichi Oikawa" <roikawa@rr.iiij4u.or.jp>
44 * PPC betatesting, PPC support, backward compatibility
46 * "Paul Womar" <Paul@pwomar.demon.co.uk>
47 * "Owen Waller" <O.Waller@ee.qub.ac.uk>
50 * "Thomas Pornin" <pornin@bolet.ens.fr>
53 * "Pieter van Leuven" <pvl@iae.nl>
54 * "Ulf Jaenicke-Roessler" <ujr@physik.phy.tu-dresden.de>
57 * "H. Peter Arvin" <hpa@transmeta.com>
60 * "Cort Dougan" <cort@cs.nmt.edu>
61 * CHRP fixes and PReP cleanup
63 * "Mark Vojkovich" <mvojkovi@ucsd.edu>
66 * "Samuel Hocevar" <sam@via.ecp.fr>
69 * "Anton Altaparmakov" <AntonA@bigfoot.com>
70 * G400 MAX/non-MAX distinction
72 * "Ken Aaker" <kdaaker@rchland.vnet.ibm.com>
73 * memtype extension (needed for GXT130P RS/6000 adapter)
75 * (following author is not in any relation with this code, but his code
76 * is included in this driver)
78 * Based on framebuffer driver for VBE 2.0 compliant graphic boards
79 * (c) 1998 Gerd Knorr <kraxel@cs.tu-berlin.de>
81 * (following author is not in any relation with this code, but his ideas
82 * were used when writting this driver)
84 * FreeVBE/AF (Matrox), "Shawn Hargreaves" <shawn@talula.demon.co.uk>
88 /* make checkconfig does not check included files... */
89 #include <linux/config.h>
91 #include "matroxfb_base.h"
92 #include "matroxfb_misc.h"
93 #include "matroxfb_accel.h"
94 #include "matroxfb_DAC1064.h"
95 #include "matroxfb_Ti3026.h"
96 #include "matroxfb_maven.h"
97 #include "matroxfb_crtc2.h"
98 #include <linux/matroxfb.h>
99 #include <asm/uaccess.h>
102 unsigned char nvram_read_byte(int);
103 static int default_vmode
= VMODE_NVRAM
;
104 static int default_cmode
= CMODE_NVRAM
;
107 static void matroxfb_unregister_device(struct matrox_fb_info
* minfo
);
109 /* --------------------------------------------------------------------- */
115 /* --------------------------------------------------------------------- */
117 static struct fb_var_screeninfo vesafb_defined
= {
118 640,480,640,480,/* W,H, W, H (virtual) load xres,xres_virtual*/
119 0,0, /* virtual -> visible no offset */
120 8, /* depth -> load bits_per_pixel */
125 {0,0,0}, /* transparency */
126 0, /* standard pixel format */
129 FB_ACCELF_TEXT
, /* accel flags */
130 39721L,48L,16L,33L,10L,
131 96L,2L,~0, /* No sync info */
132 FB_VMODE_NONINTERLACED
,
138 /* --------------------------------------------------------------------- */
140 static void matrox_pan_var(WPMINFO
struct fb_var_screeninfo
*var
) {
142 unsigned short p0
, p1
, p2
;
143 #ifdef CONFIG_FB_MATROX_32MB
146 struct display
*disp
;
149 DBG("matrox_pan_var")
151 if (ACCESS_FBINFO(dead
))
154 disp
= ACCESS_FBINFO(currcon_display
);
155 if (disp
->type
== FB_TYPE_TEXT
) {
156 pos
= var
->yoffset
/ fontheight(disp
) * disp
->next_line
/ ACCESS_FBINFO(devflags
.textstep
) + var
->xoffset
/ (fontwidth(disp
)?fontwidth(disp
):8);
158 pos
= (var
->yoffset
* var
->xres_virtual
+ var
->xoffset
) * ACCESS_FBINFO(curr
.final_bppShift
) / 32;
159 pos
+= ACCESS_FBINFO(curr
.ydstorg
.chunks
);
161 p0
= ACCESS_FBINFO(currenthw
)->CRTC
[0x0D] = pos
& 0xFF;
162 p1
= ACCESS_FBINFO(currenthw
)->CRTC
[0x0C] = (pos
& 0xFF00) >> 8;
163 p2
= ACCESS_FBINFO(currenthw
)->CRTCEXT
[0] = (ACCESS_FBINFO(currenthw
)->CRTCEXT
[0] & 0xB0) | ((pos
>> 16) & 0x0F) | ((pos
>> 14) & 0x40);
164 #ifdef CONFIG_FB_MATROX_32MB
165 p3
= ACCESS_FBINFO(currenthw
)->CRTCEXT
[8] = pos
>> 21;
170 mga_setr(M_CRTC_INDEX
, 0x0D, p0
);
171 mga_setr(M_CRTC_INDEX
, 0x0C, p1
);
172 #ifdef CONFIG_FB_MATROX_32MB
173 if (ACCESS_FBINFO(devflags
.support32MB
))
174 mga_setr(M_EXTVGA_INDEX
, 0x08, p3
);
176 mga_setr(M_EXTVGA_INDEX
, 0x00, p2
);
181 static void matroxfb_remove(WPMINFO
int dummy
) {
182 /* Currently we are holding big kernel lock on all dead & usecount updates.
183 * Destroy everything after all users release it. Especially do not unregister
184 * framebuffer and iounmap memory, neither fbmem nor fbcon-cfb* does not check
185 * for device unplugged when in use.
186 * In future we should point mmio.vbase & video.vbase somewhere where we can
187 * write data without causing too much damage...
190 ACCESS_FBINFO(dead
) = 1;
191 if (ACCESS_FBINFO(usecount
)) {
192 /* destroy it later */
195 matroxfb_unregister_device(MINFO
);
196 unregister_framebuffer(&ACCESS_FBINFO(fbcon
));
197 del_timer_sync(&ACCESS_FBINFO(cursor
.timer
));
199 if (ACCESS_FBINFO(mtrr
.vram_valid
))
200 mtrr_del(ACCESS_FBINFO(mtrr
.vram
), ACCESS_FBINFO(video
.base
), ACCESS_FBINFO(video
.len
));
202 mga_iounmap(ACCESS_FBINFO(mmio
.vbase
));
203 mga_iounmap(ACCESS_FBINFO(video
.vbase
));
204 release_mem_region(ACCESS_FBINFO(video
.base
), ACCESS_FBINFO(video
.len_maximum
));
205 release_mem_region(ACCESS_FBINFO(mmio
.base
), 16384);
206 #ifdef CONFIG_FB_MATROX_MULTIHEAD
207 kfree(ACCESS_FBINFO(fbcon
.disp
));
213 * Open/Release the frame buffer device
216 static int matroxfb_open(struct fb_info
*info
, int user
)
218 #define minfo ((struct matrox_fb_info*)info)
219 DBG_LOOP("matroxfb_open")
221 if (ACCESS_FBINFO(dead
)) {
224 ACCESS_FBINFO(usecount
)++;
229 static int matroxfb_release(struct fb_info
*info
, int user
)
231 #define minfo ((struct matrox_fb_info*)info)
232 DBG_LOOP("matroxfb_release")
234 if (!(--ACCESS_FBINFO(usecount
)) && ACCESS_FBINFO(dead
)) {
235 matroxfb_remove(PMINFO
0);
241 static int matroxfb_pan_display(struct fb_var_screeninfo
*var
, int con
,
242 struct fb_info
* info
) {
243 #define minfo ((struct matrox_fb_info*)info)
245 DBG("matroxfb_pan_display")
247 if (var
->vmode
& FB_VMODE_YWRAP
) {
248 if (var
->yoffset
< 0 || var
->yoffset
>= fb_display
[con
].var
.yres_virtual
|| var
->xoffset
)
251 if (var
->xoffset
+fb_display
[con
].var
.xres
> fb_display
[con
].var
.xres_virtual
||
252 var
->yoffset
+fb_display
[con
].var
.yres
> fb_display
[con
].var
.yres_virtual
)
255 if (con
== ACCESS_FBINFO(currcon
))
256 matrox_pan_var(PMINFO var
);
257 fb_display
[con
].var
.xoffset
= var
->xoffset
;
258 fb_display
[con
].var
.yoffset
= var
->yoffset
;
259 if (var
->vmode
& FB_VMODE_YWRAP
)
260 fb_display
[con
].var
.vmode
|= FB_VMODE_YWRAP
;
262 fb_display
[con
].var
.vmode
&= ~FB_VMODE_YWRAP
;
267 static int matroxfb_updatevar(int con
, struct fb_info
*info
)
269 #define minfo ((struct matrox_fb_info*)info)
270 DBG("matroxfb_updatevar");
272 matrox_pan_var(PMINFO
&fb_display
[con
].var
);
277 static int matroxfb_get_final_bppShift(CPMINFO
int bpp
) {
280 DBG("matroxfb_get_final_bppShift")
286 if (isInterleave(MINFO
))
288 if (ACCESS_FBINFO(devflags
.video64bits
))
293 static int matroxfb_test_and_set_rounding(CPMINFO
int xres
, int bpp
) {
297 DBG("matroxfb_test_and_set_rounding")
301 case 4: rounding
= 128;
303 case 8: rounding
= 64; /* doc says 64; 32 is OK for G400 */
305 case 16: rounding
= 32;
307 case 24: rounding
= 64; /* doc says 64; 32 is OK for G400 */
309 default: rounding
= 16;
310 /* on G400, 16 really does not work */
311 if (ACCESS_FBINFO(devflags
.accelerator
) == FB_ACCEL_MATROX_MGAG400
)
315 if (isInterleave(MINFO
)) {
318 over
= xres
% rounding
;
320 xres
+= rounding
-over
;
324 static int matroxfb_pitch_adjust(CPMINFO
int xres
, int bpp
) {
328 DBG("matroxfb_pitch_adjust")
330 if (!bpp
) return xres
;
332 width
= ACCESS_FBINFO(capable
.vxres
);
334 if (ACCESS_FBINFO(devflags
.precise_width
)) {
336 if ((*width
>= xres
) && (matroxfb_test_and_set_rounding(PMINFO
*width
, bpp
) == *width
)) {
343 xres_new
= matroxfb_test_and_set_rounding(PMINFO xres
, bpp
);
345 if (!xres_new
) return 0;
346 if (xres
!= xres_new
) {
347 printk(KERN_INFO
"matroxfb: cannot set xres to %d, rounded up to %d\n", xres
, xres_new
);
352 static int matroxfb_get_cmap_len(struct fb_var_screeninfo
*var
) {
354 DBG("matroxfb_get_cmap_len")
356 switch (var
->bits_per_pixel
) {
357 #ifdef FBCON_HAS_VGATEXT
359 return 16; /* pseudocolor... 16 entries HW palette */
361 #ifdef FBCON_HAS_CFB4
363 return 16; /* pseudocolor... 16 entries HW palette */
365 #ifdef FBCON_HAS_CFB8
367 return 256; /* pseudocolor... 256 entries HW palette */
369 #ifdef FBCON_HAS_CFB16
371 return 16; /* directcolor... 16 entries SW palette */
372 /* Mystique: truecolor, 16 entries SW palette, HW palette hardwired into 1:1 mapping */
374 #ifdef FBCON_HAS_CFB24
376 return 16; /* directcolor... 16 entries SW palette */
377 /* Mystique: truecolor, 16 entries SW palette, HW palette hardwired into 1:1 mapping */
379 #ifdef FBCON_HAS_CFB32
381 return 16; /* directcolor... 16 entries SW palette */
382 /* Mystique: truecolor, 16 entries SW palette, HW palette hardwired into 1:1 mapping */
385 return 16; /* return something reasonable... or panic()? */
388 static int matroxfb_decode_var(CPMINFO
struct display
* p
, struct fb_var_screeninfo
*var
, int *visual
, int *video_cmap_len
, unsigned int* ydstorg
) {
389 unsigned int vramlen
;
392 DBG("matroxfb_decode_var")
394 switch (var
->bits_per_pixel
) {
395 #ifdef FBCON_HAS_VGATEXT
396 case 0: if (!ACCESS_FBINFO(capable
.text
)) return -EINVAL
;
399 #ifdef FBCON_HAS_CFB4
400 case 4: if (!ACCESS_FBINFO(capable
.cfb4
)) return -EINVAL
;
403 #ifdef FBCON_HAS_CFB8
406 #ifdef FBCON_HAS_CFB16
409 #ifdef FBCON_HAS_CFB24
412 #ifdef FBCON_HAS_CFB32
415 default: return -EINVAL
;
418 vramlen
= ACCESS_FBINFO(video
.len_usable
);
419 if (var
->yres_virtual
< var
->yres
)
420 var
->yres_virtual
= var
->yres
;
421 if (var
->xres_virtual
< var
->xres
)
422 var
->xres_virtual
= var
->xres
;
423 if (var
->bits_per_pixel
) {
424 var
->xres_virtual
= matroxfb_pitch_adjust(PMINFO var
->xres_virtual
, var
->bits_per_pixel
);
425 memlen
= var
->xres_virtual
* var
->bits_per_pixel
* var
->yres_virtual
/ 8;
426 if (memlen
> vramlen
) {
427 var
->yres_virtual
= vramlen
* 8 / (var
->xres_virtual
* var
->bits_per_pixel
);
428 memlen
= var
->xres_virtual
* var
->bits_per_pixel
* var
->yres_virtual
/ 8;
430 /* There is hardware bug that no line can cross 4MB boundary */
431 /* give up for CFB24, it is impossible to easy workaround it */
432 /* for other try to do something */
433 if (!ACCESS_FBINFO(capable
.cross4MB
) && (memlen
> 0x400000)) {
434 if (var
->bits_per_pixel
== 24) {
437 unsigned int linelen
;
438 unsigned int m1
= linelen
= var
->xres_virtual
* var
->bits_per_pixel
/ 8;
439 unsigned int m2
= PAGE_SIZE
; /* or 128 if you do not need PAGE ALIGNED address */
440 unsigned int max_yres
;
445 while (m2
>= m1
) m2
-= m1
;
450 m2
= linelen
* PAGE_SIZE
/ m2
;
451 *ydstorg
= m2
= 0x400000 % m2
;
452 max_yres
= (vramlen
- m2
) / linelen
;
453 if (var
->yres_virtual
> max_yres
)
454 var
->yres_virtual
= max_yres
;
458 matrox_text_round(PMINFO var
, p
);
460 /* we must limit pixclock by mclk...
461 Millennium I: 66 MHz = 15000
462 Millennium II: 61 MHz = 16300
463 Millennium G200: 83 MHz = 12000 */
464 if (var
->pixclock
< 15000)
465 var
->pixclock
= 15000; /* limit for "normal" gclk & mclk */
468 /* YDSTLEN contains only signed 16bit value */
469 if (var
->yres_virtual
> 32767)
470 var
->yres_virtual
= 32767;
471 /* we must round yres/xres down, we already rounded y/xres_virtual up
472 if it was possible. We should return -EINVAL, but I disagree */
473 if (var
->yres_virtual
< var
->yres
)
474 var
->yres
= var
->yres_virtual
;
475 if (var
->xres_virtual
< var
->xres
)
476 var
->xres
= var
->xres_virtual
;
477 if (var
->xoffset
+ var
->xres
> var
->xres_virtual
)
478 var
->xoffset
= var
->xres_virtual
- var
->xres
;
479 if (var
->yoffset
+ var
->yres
> var
->yres_virtual
)
480 var
->yoffset
= var
->yres_virtual
- var
->yres
;
482 if (var
->bits_per_pixel
== 0) {
485 var
->green
.offset
= 0;
486 var
->green
.length
= 6;
487 var
->blue
.offset
= 0;
488 var
->blue
.length
= 6;
489 var
->transp
.offset
= 0;
490 var
->transp
.length
= 0;
491 *visual
= MX_VISUAL_PSEUDOCOLOR
;
492 } else if (var
->bits_per_pixel
== 4) {
495 var
->green
.offset
= 0;
496 var
->green
.length
= 8;
497 var
->blue
.offset
= 0;
498 var
->blue
.length
= 8;
499 var
->transp
.offset
= 0;
500 var
->transp
.length
= 0;
501 *visual
= MX_VISUAL_PSEUDOCOLOR
;
502 } else if (var
->bits_per_pixel
<= 8) {
505 var
->green
.offset
= 0;
506 var
->green
.length
= 8;
507 var
->blue
.offset
= 0;
508 var
->blue
.length
= 8;
509 var
->transp
.offset
= 0;
510 var
->transp
.length
= 0;
511 *visual
= MX_VISUAL_PSEUDOCOLOR
;
513 if (var
->bits_per_pixel
<= 16) {
514 if (var
->green
.length
== 5) {
515 var
->red
.offset
= 10;
517 var
->green
.offset
= 5;
518 var
->green
.length
= 5;
519 var
->blue
.offset
= 0;
520 var
->blue
.length
= 5;
521 var
->transp
.offset
= 15;
522 var
->transp
.length
= 1;
524 var
->red
.offset
= 11;
526 var
->green
.offset
= 5;
527 var
->green
.length
= 6;
528 var
->blue
.offset
= 0;
529 var
->blue
.length
= 5;
530 var
->transp
.offset
= 0;
531 var
->transp
.length
= 0;
533 } else if (var
->bits_per_pixel
<= 24) {
534 var
->red
.offset
= 16;
536 var
->green
.offset
= 8;
537 var
->green
.length
= 8;
538 var
->blue
.offset
= 0;
539 var
->blue
.length
= 8;
540 var
->transp
.offset
= 0;
541 var
->transp
.length
= 0;
543 var
->red
.offset
= 16;
545 var
->green
.offset
= 8;
546 var
->green
.length
= 8;
547 var
->blue
.offset
= 0;
548 var
->blue
.length
= 8;
549 var
->transp
.offset
= 24;
550 var
->transp
.length
= 8;
552 dprintk("matroxfb: truecolor: "
553 "size=%d:%d:%d:%d, shift=%d:%d:%d:%d\n",
562 *visual
= MX_VISUAL_DIRECTCOLOR
;
564 *video_cmap_len
= matroxfb_get_cmap_len(var
);
565 dprintk(KERN_INFO
"requested %d*%d/%dbpp (%d*%d)\n", var
->xres
, var
->yres
, var
->bits_per_pixel
,
566 var
->xres_virtual
, var
->yres_virtual
);
570 static int matrox_setcolreg(unsigned regno
, unsigned red
, unsigned green
,
571 unsigned blue
, unsigned transp
,
572 struct fb_info
*fb_info
)
575 #ifdef CONFIG_FB_MATROX_MULTIHEAD
576 struct matrox_fb_info
* minfo
= (struct matrox_fb_info
*)fb_info
;
579 DBG("matrox_setcolreg")
582 * Set a single color register. The values supplied are
583 * already rounded down to the hardware's capabilities
584 * (according to the entries in the `var' structure). Return
585 * != 0 for invalid regno.
588 if (regno
>= ACCESS_FBINFO(curr
.cmap_len
))
591 ACCESS_FBINFO(palette
[regno
].red
) = red
;
592 ACCESS_FBINFO(palette
[regno
].green
) = green
;
593 ACCESS_FBINFO(palette
[regno
].blue
) = blue
;
594 ACCESS_FBINFO(palette
[regno
].transp
) = transp
;
596 p
= ACCESS_FBINFO(currcon_display
);
597 if (p
->var
.grayscale
) {
598 /* gray = 0.30*R + 0.59*G + 0.11*B */
599 red
= green
= blue
= (red
* 77 + green
* 151 + blue
* 28) >> 8;
602 red
= CNVT_TOHW(red
, p
->var
.red
.length
);
603 green
= CNVT_TOHW(green
, p
->var
.green
.length
);
604 blue
= CNVT_TOHW(blue
, p
->var
.blue
.length
);
605 transp
= CNVT_TOHW(transp
, p
->var
.transp
.length
);
607 switch (p
->var
.bits_per_pixel
) {
608 #if defined(FBCON_HAS_CFB8) || defined(FBCON_HAS_CFB4) || defined(FBCON_HAS_VGATEXT)
609 #ifdef FBCON_HAS_VGATEXT
612 #ifdef FBCON_HAS_CFB4
615 #ifdef FBCON_HAS_CFB8
618 mga_outb(M_DAC_REG
, regno
);
619 mga_outb(M_DAC_VAL
, red
);
620 mga_outb(M_DAC_VAL
, green
);
621 mga_outb(M_DAC_VAL
, blue
);
624 #ifdef FBCON_HAS_CFB16
626 ACCESS_FBINFO(cmap
.cfb16
[regno
]) =
627 (red
<< p
->var
.red
.offset
) |
628 (green
<< p
->var
.green
.offset
) |
629 (blue
<< p
->var
.blue
.offset
) |
630 (transp
<< p
->var
.transp
.offset
); /* for 1:5:5:5 */
633 #ifdef FBCON_HAS_CFB24
635 ACCESS_FBINFO(cmap
.cfb24
[regno
]) =
636 (red
<< p
->var
.red
.offset
) |
637 (green
<< p
->var
.green
.offset
) |
638 (blue
<< p
->var
.blue
.offset
);
641 #ifdef FBCON_HAS_CFB32
643 ACCESS_FBINFO(cmap
.cfb32
[regno
]) =
644 (red
<< p
->var
.red
.offset
) |
645 (green
<< p
->var
.green
.offset
) |
646 (blue
<< p
->var
.blue
.offset
) |
647 (transp
<< p
->var
.transp
.offset
); /* 8:8:8:8 */
654 static void do_install_cmap(WPMINFO
struct display
* dsp
)
656 DBG("do_install_cmap")
659 fb_set_cmap(&dsp
->cmap
, 1, matrox_setcolreg
, &ACCESS_FBINFO(fbcon
));
661 fb_set_cmap(fb_default_cmap(ACCESS_FBINFO(curr
.cmap_len
)),
662 1, matrox_setcolreg
, &ACCESS_FBINFO(fbcon
));
665 static int matroxfb_get_fix(struct fb_fix_screeninfo
*fix
, int con
,
666 struct fb_info
*info
)
669 DBG("matroxfb_get_fix")
671 #define minfo ((struct matrox_fb_info*)info)
673 if (ACCESS_FBINFO(dead
)) {
678 p
= fb_display
+ con
;
680 p
= ACCESS_FBINFO(fbcon
.disp
);
682 memset(fix
, 0, sizeof(struct fb_fix_screeninfo
));
683 strcpy(fix
->id
,"MATROX");
685 fix
->smem_start
= ACCESS_FBINFO(video
.base
) + ACCESS_FBINFO(curr
.ydstorg
.bytes
);
686 fix
->smem_len
= ACCESS_FBINFO(video
.len_usable
) - ACCESS_FBINFO(curr
.ydstorg
.bytes
);
688 fix
->type_aux
= p
->type_aux
;
689 fix
->visual
= p
->visual
;
690 fix
->xpanstep
= 8; /* 8 for 8bpp, 4 for 16bpp, 2 for 32bpp */
693 fix
->line_length
= p
->line_length
;
694 fix
->mmio_start
= ACCESS_FBINFO(mmio
.base
);
695 fix
->mmio_len
= ACCESS_FBINFO(mmio
.len
);
696 fix
->accel
= ACCESS_FBINFO(devflags
.accelerator
);
701 static int matroxfb_get_var(struct fb_var_screeninfo
*var
, int con
,
702 struct fb_info
*info
)
704 #define minfo ((struct matrox_fb_info*)info)
705 DBG("matroxfb_get_var")
708 *var
=ACCESS_FBINFO(fbcon
.disp
)->var
;
710 *var
=fb_display
[con
].var
;
715 static int matroxfb_set_var(struct fb_var_screeninfo
*var
, int con
,
716 struct fb_info
*info
)
718 #define minfo ((struct matrox_fb_info*)info)
722 unsigned int ydstorg
;
723 struct display
* display
;
726 DBG("matroxfb_set_var")
728 if (ACCESS_FBINFO(dead
)) {
733 display
= fb_display
+ con
;
735 display
= ACCESS_FBINFO(fbcon
.disp
);
736 if ((err
= matroxfb_decode_var(PMINFO display
, var
, &visual
, &cmap_len
, &ydstorg
)) != 0)
738 switch (var
->activate
& FB_ACTIVATE_MASK
) {
739 case FB_ACTIVATE_TEST
: return 0;
740 case FB_ACTIVATE_NXTOPEN
: /* ?? */
741 case FB_ACTIVATE_NOW
: break; /* continue */
742 default: return -EINVAL
; /* unknown */
745 chgvar
= ((display
->var
.xres
!= var
->xres
) ||
746 (display
->var
.yres
!= var
->yres
) ||
747 (display
->var
.xres_virtual
!= var
->xres_virtual
) ||
748 (display
->var
.yres_virtual
!= var
->yres_virtual
) ||
749 (display
->var
.bits_per_pixel
!= var
->bits_per_pixel
) ||
750 memcmp(&display
->var
.red
, &var
->red
, sizeof(var
->red
)) ||
751 memcmp(&display
->var
.green
, &var
->green
, sizeof(var
->green
)) ||
752 memcmp(&display
->var
.blue
, &var
->blue
, sizeof(var
->blue
)));
758 display
->screen_base
= vaddr_va(ACCESS_FBINFO(video
.vbase
)) + ydstorg
;
759 display
->visual
= visual
;
760 display
->ypanstep
= 1;
761 display
->ywrapstep
= 0;
762 if (var
->bits_per_pixel
) {
763 display
->type
= FB_TYPE_PACKED_PIXELS
;
764 display
->type_aux
= 0;
765 display
->next_line
= display
->line_length
= (var
->xres_virtual
* var
->bits_per_pixel
) >> 3;
767 display
->type
= FB_TYPE_TEXT
;
768 display
->type_aux
= ACCESS_FBINFO(devflags
.text_type_aux
);
769 display
->next_line
= display
->line_length
= (var
->xres_virtual
/ (fontwidth(display
)?fontwidth(display
):8)) * ACCESS_FBINFO(devflags
.textstep
);
771 display
->can_soft_blank
= 1;
772 display
->inverse
= ACCESS_FBINFO(devflags
.inverse
);
773 /* conp, fb_info, vrows, cursor_x, cursor_y, fgcol, bgcol */
774 /* next_plane, fontdata, _font*, userfont */
775 initMatrox(PMINFO display
); /* dispsw */
776 /* dispsw, scrollmode, yscroll */
777 /* fgshift, bgshift, charmask */
778 if (chgvar
&& info
&& info
->changevar
)
779 info
->changevar(con
);
780 if (con
== ACCESS_FBINFO(currcon
)) {
783 ACCESS_FBINFO(curr
.cmap_len
) = cmap_len
;
784 if (display
->type
== FB_TYPE_TEXT
) {
785 /* textmode must be in first megabyte, so no ydstorg allowed */
786 ACCESS_FBINFO(curr
.ydstorg
.bytes
) = 0;
787 ACCESS_FBINFO(curr
.ydstorg
.chunks
) = 0;
788 ACCESS_FBINFO(curr
.ydstorg
.pixels
) = 0;
790 ydstorg
+= ACCESS_FBINFO(devflags
.ydstorg
);
791 ACCESS_FBINFO(curr
.ydstorg
.bytes
) = ydstorg
;
792 ACCESS_FBINFO(curr
.ydstorg
.chunks
) = ydstorg
>> (isInterleave(MINFO
)?3:2);
793 if (var
->bits_per_pixel
== 4)
794 ACCESS_FBINFO(curr
.ydstorg
.pixels
) = ydstorg
;
796 ACCESS_FBINFO(curr
.ydstorg
.pixels
) = (ydstorg
* 8) / var
->bits_per_pixel
;
798 ACCESS_FBINFO(curr
.final_bppShift
) = matroxfb_get_final_bppShift(PMINFO var
->bits_per_pixel
);
799 if (visual
== MX_VISUAL_PSEUDOCOLOR
) {
802 for (i
= 0; i
< 16; i
++) {
806 ACCESS_FBINFO(palette
[i
].red
) = default_red
[j
];
807 ACCESS_FBINFO(palette
[i
].green
) = default_grn
[j
];
808 ACCESS_FBINFO(palette
[i
].blue
) = default_blu
[j
];
812 { struct my_timming mt
;
813 struct matrox_hw_state
* hw
;
814 struct matrox_hw_state
* ohw
;
816 matroxfb_var2my(var
, &mt
);
818 switch (var
->bits_per_pixel
) {
819 case 0: mt
.delay
= 31 + 0; break;
820 case 16: mt
.delay
= 21 + 8; break;
821 case 24: mt
.delay
= 17 + 8; break;
822 case 32: mt
.delay
= 16 + 8; break;
823 default: mt
.delay
= 31 + 8; break;
826 hw
= ACCESS_FBINFO(newhw
);
827 ohw
= ACCESS_FBINFO(currenthw
);
829 /* copy last setting... */
830 memcpy(hw
, ohw
, sizeof(*hw
));
832 del_timer_sync(&ACCESS_FBINFO(cursor
.timer
));
833 ACCESS_FBINFO(cursor
.state
) = CM_ERASE
;
835 ACCESS_FBINFO(hw_switch
->init(PMINFO hw
, &mt
, display
));
836 if (display
->type
== FB_TYPE_TEXT
) {
837 if (fontheight(display
))
838 pos
= var
->yoffset
/ fontheight(display
) * display
->next_line
/ ACCESS_FBINFO(devflags
.textstep
) + var
->xoffset
/ (fontwidth(display
)?fontwidth(display
):8);
842 pos
= (var
->yoffset
* var
->xres_virtual
+ var
->xoffset
) * ACCESS_FBINFO(curr
.final_bppShift
) / 32;
843 pos
+= ACCESS_FBINFO(curr
.ydstorg
.chunks
);
846 hw
->CRTC
[0x0D] = pos
& 0xFF;
847 hw
->CRTC
[0x0C] = (pos
& 0xFF00) >> 8;
848 hw
->CRTCEXT
[0] = (hw
->CRTCEXT
[0] & 0xF0) | ((pos
>> 16) & 0x0F) | ((pos
>> 14) & 0x40);
849 hw
->CRTCEXT
[8] = pos
>> 21;
850 if (ACCESS_FBINFO(output
.ph
) & (MATROXFB_OUTPUT_CONN_PRIMARY
| MATROXFB_OUTPUT_CONN_DFP
)) {
851 if (ACCESS_FBINFO(primout
))
852 ACCESS_FBINFO(primout
)->compute(MINFO
, &mt
, hw
);
854 if (ACCESS_FBINFO(output
.ph
) & MATROXFB_OUTPUT_CONN_SECONDARY
) {
855 down_read(&ACCESS_FBINFO(altout
.lock
));
856 if (ACCESS_FBINFO(altout
.output
))
857 ACCESS_FBINFO(altout
.output
)->compute(ACCESS_FBINFO(altout
.device
), &mt
, hw
);
858 up_read(&ACCESS_FBINFO(altout
.lock
));
860 ACCESS_FBINFO(hw_switch
->restore(PMINFO hw
, ohw
, display
));
861 if (ACCESS_FBINFO(output
.ph
) & (MATROXFB_OUTPUT_CONN_PRIMARY
| MATROXFB_OUTPUT_CONN_DFP
)) {
862 if (ACCESS_FBINFO(primout
))
863 ACCESS_FBINFO(primout
)->program(MINFO
, hw
);
865 if (ACCESS_FBINFO(output
.ph
) & MATROXFB_OUTPUT_CONN_SECONDARY
) {
866 down_read(&ACCESS_FBINFO(altout
.lock
));
867 if (ACCESS_FBINFO(altout
.output
))
868 ACCESS_FBINFO(altout
.output
)->program(ACCESS_FBINFO(altout
.device
), hw
);
869 up_read(&ACCESS_FBINFO(altout
.lock
));
871 ACCESS_FBINFO(cursor
.redraw
) = 1;
872 ACCESS_FBINFO(currenthw
) = hw
;
873 ACCESS_FBINFO(newhw
) = ohw
;
874 if (ACCESS_FBINFO(output
.ph
) & (MATROXFB_OUTPUT_CONN_PRIMARY
| MATROXFB_OUTPUT_CONN_DFP
)) {
875 if (ACCESS_FBINFO(primout
))
876 ACCESS_FBINFO(primout
)->start(MINFO
);
878 if (ACCESS_FBINFO(output
.ph
) & MATROXFB_OUTPUT_CONN_SECONDARY
) {
879 down_read(&ACCESS_FBINFO(altout
.lock
));
880 if (ACCESS_FBINFO(altout
.output
))
881 ACCESS_FBINFO(altout
.output
)->start(ACCESS_FBINFO(altout
.device
));
882 up_read(&ACCESS_FBINFO(altout
.lock
));
884 matrox_cfbX_init(PMINFO display
);
885 do_install_cmap(PMINFO display
);
886 #if defined(CONFIG_FB_COMPAT_XPMAC)
887 if (console_fb_info
== &ACCESS_FBINFO(fbcon
)) {
890 display_info
.width
= var
->xres
;
891 display_info
.height
= var
->yres
;
892 display_info
.depth
= var
->bits_per_pixel
;
893 display_info
.pitch
= (var
->xres_virtual
)*(var
->bits_per_pixel
)/8;
894 if (mac_var_to_vmode(var
, &vmode
, &cmode
))
895 display_info
.mode
= 0;
897 display_info
.mode
= vmode
;
898 strcpy(display_info
.name
, ACCESS_FBINFO(matrox_name
));
899 display_info
.fb_address
= ACCESS_FBINFO(video
.base
);
900 display_info
.cmap_adr_address
= 0;
901 display_info
.cmap_data_address
= 0;
902 display_info
.disp_reg_address
= ACCESS_FBINFO(mmio
.base
);
904 #endif /* CONFIG_FB_COMPAT_XPMAC */
911 static int matrox_getcolreg(unsigned regno
, unsigned *red
, unsigned *green
,
912 unsigned *blue
, unsigned *transp
,
913 struct fb_info
*info
)
916 DBG("matrox_getcolreg")
918 #define minfo ((struct matrox_fb_info*)info)
920 * Read a single color register and split it into colors/transparent.
921 * Return != 0 for invalid regno.
924 if (regno
>= ACCESS_FBINFO(curr
.cmap_len
))
927 *red
= ACCESS_FBINFO(palette
[regno
].red
);
928 *green
= ACCESS_FBINFO(palette
[regno
].green
);
929 *blue
= ACCESS_FBINFO(palette
[regno
].blue
);
930 *transp
= ACCESS_FBINFO(palette
[regno
].transp
);
935 static int matroxfb_get_cmap(struct fb_cmap
*cmap
, int kspc
, int con
,
936 struct fb_info
*info
)
938 #define minfo ((struct matrox_fb_info*)info)
939 struct display
* dsp
= (con
< 0) ? ACCESS_FBINFO(fbcon
.disp
)
942 DBG("matroxfb_get_cmap")
944 if (ACCESS_FBINFO(dead
)) {
948 if (con
== ACCESS_FBINFO(currcon
)) /* current console? */
949 return fb_get_cmap(cmap
, kspc
, matrox_getcolreg
, info
);
950 else if (dsp
->cmap
.len
) /* non default colormap? */
951 fb_copy_cmap(&dsp
->cmap
, cmap
, kspc
? 0 : 2);
953 fb_copy_cmap(fb_default_cmap(matroxfb_get_cmap_len(&dsp
->var
)),
959 static int matroxfb_set_cmap(struct fb_cmap
*cmap
, int kspc
, int con
,
960 struct fb_info
*info
)
962 unsigned int cmap_len
;
963 struct display
* dsp
= (con
< 0) ? info
->disp
: (fb_display
+ con
);
964 #define minfo ((struct matrox_fb_info*)info)
966 DBG("matroxfb_set_cmap")
968 if (ACCESS_FBINFO(dead
)) {
972 cmap_len
= matroxfb_get_cmap_len(&dsp
->var
);
973 if (dsp
->cmap
.len
!= cmap_len
) {
976 err
= fb_alloc_cmap(&dsp
->cmap
, cmap_len
, 0);
980 if (con
== ACCESS_FBINFO(currcon
)) { /* current console? */
981 return fb_set_cmap(cmap
, kspc
, matrox_setcolreg
, info
);
983 fb_copy_cmap(cmap
, &dsp
->cmap
, kspc
? 0 : 1);
988 static int matroxfb_switch(int con
, struct fb_info
*info
);
990 static int matroxfb_get_vblank(CPMINFO
struct fb_vblank
*vblank
)
994 memset(vblank
, 0, sizeof(*vblank
));
995 vblank
->flags
= FB_VBLANK_HAVE_VCOUNT
| FB_VBLANK_HAVE_VSYNC
|
996 FB_VBLANK_HAVE_VBLANK
| FB_VBLANK_HAVE_HBLANK
;
997 sts1
= mga_inb(M_INSTS1
);
998 vblank
->vcount
= mga_inl(M_VCOUNT
);
999 /* BTW, on my PIII/450 with G400, reading M_INSTS1
1000 byte makes this call about 12% slower (1.70 vs. 2.05 us
1003 vblank
->flags
|= FB_VBLANK_HBLANKING
;
1005 vblank
->flags
|= FB_VBLANK_VSYNCING
;
1006 if (vblank
->count
>= ACCESS_FBINFO(currcon_display
)->var
.yres
)
1007 vblank
->flags
|= FB_VBLANK_VBLANKING
;
1013 static int matroxfb_ioctl(struct inode
*inode
, struct file
*file
,
1014 unsigned int cmd
, unsigned long arg
, int con
,
1015 struct fb_info
*info
)
1017 #define minfo ((struct matrox_fb_info*)info)
1018 DBG("matroxfb_ioctl")
1020 if (ACCESS_FBINFO(dead
)) {
1025 case FBIOGET_VBLANK
:
1027 struct fb_vblank vblank
;
1030 err
= matroxfb_get_vblank(PMINFO
&vblank
);
1033 if (copy_to_user((struct fb_vblank
*)arg
, &vblank
, sizeof(vblank
)))
1037 case MATROXFB_SET_OUTPUT_MODE
:
1039 struct matroxioc_output_mode mom
;
1042 if (copy_from_user(&mom
, (struct matroxioc_output_mode
*)arg
, sizeof(mom
)))
1044 if (mom
.output
>= sizeof(u_int32_t
))
1046 switch (mom
.output
) {
1047 case MATROXFB_OUTPUT_PRIMARY
:
1048 if (mom
.mode
!= MATROXFB_OUTPUT_MODE_MONITOR
)
1050 /* mode did not change... */
1052 case MATROXFB_OUTPUT_SECONDARY
:
1054 down_read(&ACCESS_FBINFO(altout
.lock
));
1055 if (ACCESS_FBINFO(altout
.output
) && ACCESS_FBINFO(altout
.device
))
1056 val
= ACCESS_FBINFO(altout
.output
)->setmode(ACCESS_FBINFO(altout
.device
), mom
.mode
);
1057 up_read(&ACCESS_FBINFO(altout
.lock
));
1060 if (ACCESS_FBINFO(output
.ph
) & MATROXFB_OUTPUT_CONN_SECONDARY
)
1061 matroxfb_switch(ACCESS_FBINFO(currcon
), info
);
1062 if (ACCESS_FBINFO(output
.sh
) & MATROXFB_OUTPUT_CONN_SECONDARY
) {
1063 struct matroxfb_dh_fb_info
* crtc2
;
1065 down_read(&ACCESS_FBINFO(crtc2
.lock
));
1066 crtc2
= (struct matroxfb_dh_fb_info
*)(ACCESS_FBINFO(crtc2
.info
));
1068 crtc2
->fbcon
.switch_con(crtc2
->currcon
, &crtc2
->fbcon
);
1069 up_read(&ACCESS_FBINFO(crtc2
.lock
));
1072 case MATROXFB_OUTPUT_DFP
:
1073 if (!(ACCESS_FBINFO(output
.all
) & MATROXFB_OUTPUT_CONN_DFP
))
1075 if (mom
.mode
!= MATROXFB_OUTPUT_MODE_MONITOR
)
1077 /* mode did not change... */
1084 case MATROXFB_GET_OUTPUT_MODE
:
1086 struct matroxioc_output_mode mom
;
1089 if (copy_from_user(&mom
, (struct matroxioc_output_mode
*)arg
, sizeof(mom
)))
1091 if (mom
.output
>= sizeof(u_int32_t
))
1093 switch (mom
.output
) {
1094 case MATROXFB_OUTPUT_PRIMARY
:
1095 mom
.mode
= MATROXFB_OUTPUT_MODE_MONITOR
;
1097 case MATROXFB_OUTPUT_SECONDARY
:
1099 down_read(&ACCESS_FBINFO(altout
.lock
));
1100 if (ACCESS_FBINFO(altout
.output
) && ACCESS_FBINFO(altout
.device
))
1101 val
= ACCESS_FBINFO(altout
.output
)->getmode(ACCESS_FBINFO(altout
.device
), &mom
.mode
);
1102 up_read(&ACCESS_FBINFO(altout
.lock
));
1106 case MATROXFB_OUTPUT_DFP
:
1107 if (!(ACCESS_FBINFO(output
.all
) & MATROXFB_OUTPUT_CONN_DFP
))
1109 mom
.mode
= MATROXFB_OUTPUT_MODE_MONITOR
;
1114 if (copy_to_user((struct matroxioc_output_mode
*)arg
, &mom
, sizeof(mom
)))
1118 case MATROXFB_SET_OUTPUT_CONNECTION
:
1122 if (copy_from_user(&tmp
, (u_int32_t
*)arg
, sizeof(tmp
)))
1124 if (tmp
& ~ACCESS_FBINFO(output
.all
))
1126 if (tmp
& ACCESS_FBINFO(output
.sh
))
1128 if (tmp
& MATROXFB_OUTPUT_CONN_DFP
) {
1129 if (tmp
& MATROXFB_OUTPUT_CONN_SECONDARY
)
1131 if (ACCESS_FBINFO(output
.sh
))
1134 if (tmp
== ACCESS_FBINFO(output
.ph
))
1136 ACCESS_FBINFO(output
.ph
) = tmp
;
1137 matroxfb_switch(ACCESS_FBINFO(currcon
), info
);
1140 case MATROXFB_GET_OUTPUT_CONNECTION
:
1142 if (put_user(ACCESS_FBINFO(output
.ph
), (u_int32_t
*)arg
))
1146 case MATROXFB_GET_AVAILABLE_OUTPUTS
:
1150 tmp
= ACCESS_FBINFO(output
.all
) & ~ACCESS_FBINFO(output
.sh
);
1151 if (ACCESS_FBINFO(output
.ph
) & MATROXFB_OUTPUT_CONN_DFP
)
1152 tmp
&= ~MATROXFB_OUTPUT_CONN_SECONDARY
;
1153 if (ACCESS_FBINFO(output
.ph
) & MATROXFB_OUTPUT_CONN_SECONDARY
)
1154 tmp
&= ~MATROXFB_OUTPUT_CONN_DFP
;
1155 if (put_user(tmp
, (u_int32_t
*)arg
))
1159 case MATROXFB_GET_ALL_OUTPUTS
:
1161 if (put_user(ACCESS_FBINFO(output
.all
), (u_int32_t
*)arg
))
1170 static struct fb_ops matroxfb_ops
= {
1172 fb_open
: matroxfb_open
,
1173 fb_release
: matroxfb_release
,
1174 fb_get_fix
: matroxfb_get_fix
,
1175 fb_get_var
: matroxfb_get_var
,
1176 fb_set_var
: matroxfb_set_var
,
1177 fb_get_cmap
: matroxfb_get_cmap
,
1178 fb_set_cmap
: matroxfb_set_cmap
,
1179 fb_pan_display
: matroxfb_pan_display
,
1180 fb_ioctl
: matroxfb_ioctl
,
1183 static int matroxfb_switch(int con
, struct fb_info
*info
)
1185 #define minfo ((struct matrox_fb_info*)info)
1186 struct fb_cmap
* cmap
;
1189 DBG("matroxfb_switch");
1191 if (ACCESS_FBINFO(currcon
) >= 0) {
1192 /* Do we have to save the colormap? */
1193 cmap
= &(ACCESS_FBINFO(currcon_display
)->cmap
);
1194 dprintk(KERN_DEBUG
"switch1: con = %d, cmap.len = %d\n", ACCESS_FBINFO(currcon
), cmap
->len
);
1197 dprintk(KERN_DEBUG
"switch1a: %p %p %p %p\n", cmap
->red
, cmap
->green
, cmap
->blue
, cmap
->transp
);
1198 fb_get_cmap(cmap
, 1, matrox_getcolreg
, info
);
1201 dprintk(KERN_DEBUG
"switch1r: %X\n", cmap
->red
[0]);
1206 ACCESS_FBINFO(currcon
) = con
;
1208 p
= ACCESS_FBINFO(fbcon
.disp
);
1210 p
= fb_display
+ con
;
1211 ACCESS_FBINFO(currcon_display
) = p
;
1212 p
->var
.activate
= FB_ACTIVATE_NOW
;
1215 dprintk(KERN_DEBUG
"switch2: con = %d, cmap.len = %d\n", con
, cmap
->len
);
1216 dprintk(KERN_DEBUG
"switch2a: %p %p %p %p\n", cmap
->red
, cmap
->green
, cmap
->blue
, cmap
->transp
);
1218 dprintk(KERN_DEBUG
"switch2r: %X\n", cmap
->red
[0]);
1221 matroxfb_set_var(&p
->var
, con
, info
);
1223 dprintk(KERN_DEBUG
"switch3: con = %d, cmap.len = %d\n", con
, cmap
->len
);
1224 dprintk(KERN_DEBUG
"switch3a: %p %p %p %p\n", cmap
->red
, cmap
->green
, cmap
->blue
, cmap
->transp
);
1226 dprintk(KERN_DEBUG
"switch3r: %X\n", cmap
->red
[0]);
1233 /* 0 unblank, 1 blank, 2 no vsync, 3 no hsync, 4 off */
1235 static void matroxfb_blank(int blank
, struct fb_info
*info
)
1237 #define minfo ((struct matrox_fb_info*)info)
1242 DBG("matroxfb_blank")
1244 if (ACCESS_FBINFO(dead
))
1248 case 1: seq
= 0x20; crtc
= 0x00; break; /* works ??? */
1249 case 2: seq
= 0x20; crtc
= 0x10; break;
1250 case 3: seq
= 0x20; crtc
= 0x20; break;
1251 case 4: seq
= 0x20; crtc
= 0x30; break;
1252 default: seq
= 0x00; crtc
= 0x00; break;
1257 mga_outb(M_SEQ_INDEX
, 1);
1258 mga_outb(M_SEQ_DATA
, (mga_inb(M_SEQ_DATA
) & ~0x20) | seq
);
1259 mga_outb(M_EXTVGA_INDEX
, 1);
1260 mga_outb(M_EXTVGA_DATA
, (mga_inb(M_EXTVGA_DATA
) & ~0x30) | crtc
);
1267 #define RSDepth(X) (((X) >> 8) & 0x0F)
1277 static struct { struct fb_bitfield red
, green
, blue
, transp
; int bits_per_pixel
; } colors
[] = {
1278 { { 0, 8, 0}, { 0, 8, 0}, { 0, 8, 0}, { 0, 0, 0}, 8 },
1279 { { 10, 5, 0}, { 5, 5, 0}, { 0, 5, 0}, { 15, 1, 0}, 16 },
1280 { { 11, 5, 0}, { 5, 6, 0}, { 0, 5, 0}, { 0, 0, 0}, 16 },
1281 { { 16, 8, 0}, { 8, 8, 0}, { 0, 8, 0}, { 24, 8, 0}, 32 },
1282 { { 0, 8, 0}, { 0, 8, 0}, { 0, 8, 0}, { 0, 0, 0}, 4 },
1283 { { 16, 8, 0}, { 8, 8, 0}, { 0, 8, 0}, { 0, 0, 0}, 24 },
1284 { { 0, 6, 0}, { 0, 6, 0}, { 0, 6, 0}, { 0, 0, 0}, 0 }, /* textmode with (default) VGA8x16 */
1285 { { 0, 6, 0}, { 0, 6, 0}, { 0, 6, 0}, { 0, 0, 0}, 0 }, /* textmode hardwired to VGA8x8 */
1288 /* initialized by setup, see explanation at end of file (search for MODULE_PARM_DESC) */
1289 static unsigned int mem
; /* "matrox:mem:xxxxxM" */
1290 static int option_precise_width
= 1; /* cannot be changed, option_precise_width==0 must imply noaccel */
1291 static int inv24
; /* "matrox:inv24" */
1292 static int cross4MB
= -1; /* "matrox:cross4MB" */
1293 static int disabled
; /* "matrox:disabled" */
1294 static int noaccel
; /* "matrox:noaccel" */
1295 static int nopan
; /* "matrox:nopan" */
1296 static int no_pci_retry
; /* "matrox:nopciretry" */
1297 static int novga
; /* "matrox:novga" */
1298 static int nobios
; /* "matrox:nobios" */
1299 static int noinit
= 1; /* "matrox:init" */
1300 static int inverse
; /* "matrox:inverse" */
1301 static int hwcursor
= 1; /* "matrox:nohwcursor" */
1302 static int blink
= 1; /* "matrox:noblink" */
1303 static int sgram
; /* "matrox:sgram" */
1305 static int mtrr
= 1; /* "matrox:nomtrr" */
1307 static int grayscale
; /* "matrox:grayscale" */
1308 static unsigned int fastfont
; /* "matrox:fastfont:xxxxx" */
1309 static int dev
= -1; /* "matrox:dev:xxxxx" */
1310 static unsigned int vesa
= ~0; /* "matrox:vesa:xxxxx" */
1311 static int depth
= -1; /* "matrox:depth:xxxxx" */
1312 static unsigned int xres
; /* "matrox:xres:xxxxx" */
1313 static unsigned int yres
; /* "matrox:yres:xxxxx" */
1314 static unsigned int upper
= ~0; /* "matrox:upper:xxxxx" */
1315 static unsigned int lower
= ~0; /* "matrox:lower:xxxxx" */
1316 static unsigned int vslen
; /* "matrox:vslen:xxxxx" */
1317 static unsigned int left
= ~0; /* "matrox:left:xxxxx" */
1318 static unsigned int right
= ~0; /* "matrox:right:xxxxx" */
1319 static unsigned int hslen
; /* "matrox:hslen:xxxxx" */
1320 static unsigned int pixclock
; /* "matrox:pixclock:xxxxx" */
1321 static int sync
= -1; /* "matrox:sync:xxxxx" */
1322 static unsigned int fv
; /* "matrox:fv:xxxxx" */
1323 static unsigned int fh
; /* "matrox:fh:xxxxxk" */
1324 static unsigned int maxclk
; /* "matrox:maxclk:xxxxM" */
1325 static int dfp
; /* "matrox:dfp */
1326 static int memtype
= -1; /* "matrox:memtype:xxx" */
1327 static char fontname
[64]; /* "matrox:font:xxxxx" */
1330 static char videomode
[64]; /* "matrox:mode:xxxxx" or "matrox:xxxxx" */
1333 static int matroxfb_getmemory(WPMINFO
unsigned int maxSize
, unsigned int *realSize
){
1337 unsigned char store
;
1338 unsigned char bytes
[32];
1341 DBG("matroxfb_getmemory")
1343 vm
= ACCESS_FBINFO(video
.vbase
);
1344 maxSize
&= ~0x1FFFFF; /* must be X*2MB (really it must be 2 or X*4MB) */
1346 if (maxSize
< 0x0200000) return 0;
1347 if (maxSize
> 0x2000000) maxSize
= 0x2000000;
1349 mga_outb(M_EXTVGA_INDEX
, 0x03);
1350 mga_outb(M_EXTVGA_DATA
, mga_inb(M_EXTVGA_DATA
) | 0x80);
1352 store
= mga_readb(vm
, 0x1234);
1354 for (offs
= 0x100000; offs
< maxSize
; offs
+= 0x200000)
1355 *tmp
++ = mga_readb(vm
, offs
);
1356 for (offs
= 0x100000; offs
< maxSize
; offs
+= 0x200000)
1357 mga_writeb(vm
, offs
, 0x02);
1358 if (ACCESS_FBINFO(features
.accel
.has_cacheflush
))
1359 mga_outb(M_CACHEFLUSH
, 0x00);
1361 mga_writeb(vm
, 0x1234, 0x99);
1362 for (offs
= 0x100000; offs
< maxSize
; offs
+= 0x200000) {
1363 if (mga_readb(vm
, offs
) != 0x02)
1365 mga_writeb(vm
, offs
, mga_readb(vm
, offs
) - 0x02);
1366 if (mga_readb(vm
, offs
))
1370 for (offs2
= 0x100000; offs2
< maxSize
; offs2
+= 0x200000)
1371 mga_writeb(vm
, offs2
, *tmp
++);
1372 mga_writeb(vm
, 0x1234, store
);
1374 mga_outb(M_EXTVGA_INDEX
, 0x03);
1375 mga_outb(M_EXTVGA_DATA
, mga_inb(M_EXTVGA_DATA
) & ~0x80);
1377 *realSize
= offs
- 0x100000;
1378 #ifdef CONFIG_FB_MATROX_MILLENIUM
1379 ACCESS_FBINFO(interleave
) = !(!isMillenium(MINFO
) || ((offs
- 0x100000) & 0x3FFFFF));
1384 struct video_board
{
1388 struct matrox_switch
* lowlevel
;
1390 #ifdef CONFIG_FB_MATROX_MILLENIUM
1391 static struct video_board vbMillennium
= {0x0800000, 0x0800000, FB_ACCEL_MATROX_MGA2064W
, &matrox_millennium
};
1392 static struct video_board vbMillennium2
= {0x1000000, 0x0800000, FB_ACCEL_MATROX_MGA2164W
, &matrox_millennium
};
1393 static struct video_board vbMillennium2A
= {0x1000000, 0x0800000, FB_ACCEL_MATROX_MGA2164W_AGP
, &matrox_millennium
};
1394 #endif /* CONFIG_FB_MATROX_MILLENIUM */
1395 #ifdef CONFIG_FB_MATROX_MYSTIQUE
1396 static struct video_board vbMystique
= {0x0800000, 0x0800000, FB_ACCEL_MATROX_MGA1064SG
, &matrox_mystique
};
1397 #endif /* CONFIG_FB_MATROX_MYSTIQUE */
1398 #ifdef CONFIG_FB_MATROX_G100
1399 static struct video_board vbG100
= {0x0800000, 0x0800000, FB_ACCEL_MATROX_MGAG100
, &matrox_G100
};
1400 static struct video_board vbG200
= {0x1000000, 0x1000000, FB_ACCEL_MATROX_MGAG200
, &matrox_G100
};
1401 #ifdef CONFIG_FB_MATROX_32MB
1402 /* from doc it looks like that accelerator can draw only to low 16MB :-( Direct accesses & displaying are OK for
1404 static struct video_board vbG400
= {0x2000000, 0x1000000, FB_ACCEL_MATROX_MGAG400
, &matrox_G100
};
1406 static struct video_board vbG400
= {0x2000000, 0x1000000, FB_ACCEL_MATROX_MGAG400
, &matrox_G100
};
1410 #define DEVF_VIDEO64BIT 0x0001
1411 #define DEVF_SWAPS 0x0002
1412 #define DEVF_MILLENNIUM 0x0004
1413 #define DEVF_MILLENNIUM2 0x0008
1414 #define DEVF_CROSS4MB 0x0010
1415 #define DEVF_TEXT4B 0x0020
1416 #define DEVF_DDC_8_2 0x0040
1417 #define DEVF_DMA 0x0080
1418 #define DEVF_SUPPORT32MB 0x0100
1419 #define DEVF_ANY_VXRES 0x0200
1420 #define DEVF_TEXT16B 0x0400
1421 #define DEVF_CRTC2 0x0800
1422 #define DEVF_MAVEN_CAPABLE 0x1000
1423 #define DEVF_PANELLINK_CAPABLE 0x2000
1424 #define DEVF_G450DAC 0x4000
1426 #define DEVF_GCORE (DEVF_VIDEO64BIT | DEVF_SWAPS | DEVF_CROSS4MB | DEVF_DDC_8_2)
1427 #define DEVF_G2CORE (DEVF_GCORE | DEVF_ANY_VXRES | DEVF_MAVEN_CAPABLE | DEVF_PANELLINK_CAPABLE)
1428 #define DEVF_G100 (DEVF_GCORE) /* no doc, no vxres... */
1429 #define DEVF_G200 (DEVF_G2CORE)
1430 #define DEVF_G400 (DEVF_G2CORE | DEVF_SUPPORT32MB | DEVF_TEXT16B | DEVF_CRTC2)
1431 /* if you'll find how to drive DFP... */
1432 #define DEVF_G450 (DEVF_GCORE | DEVF_ANY_VXRES | DEVF_SUPPORT32MB | DEVF_TEXT16B | DEVF_CRTC2 | DEVF_G450DAC)
1434 static struct board
{
1435 unsigned short vendor
, device
, rev
, svid
, sid
;
1437 unsigned int maxclk
;
1438 struct video_board
* base
;
1441 #ifdef CONFIG_FB_MATROX_MILLENIUM
1442 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_MIL
, 0xFF,
1444 DEVF_MILLENNIUM
| DEVF_TEXT4B
,
1447 "Millennium (PCI)"},
1448 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_MIL_2
, 0xFF,
1450 DEVF_MILLENNIUM
| DEVF_MILLENNIUM2
| DEVF_SWAPS
,
1453 "Millennium II (PCI)"},
1454 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_MIL_2_AGP
, 0xFF,
1456 DEVF_MILLENNIUM
| DEVF_MILLENNIUM2
| DEVF_SWAPS
,
1459 "Millennium II (AGP)"},
1461 #ifdef CONFIG_FB_MATROX_MYSTIQUE
1462 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_MYS
, 0x02,
1468 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_MYS
, 0xFF,
1470 DEVF_VIDEO64BIT
| DEVF_SWAPS
,
1473 "Mystique 220 (PCI)"},
1475 #ifdef CONFIG_FB_MATROX_G100
1476 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_G100
, 0xFF,
1477 PCI_SS_VENDOR_ID_MATROX
, PCI_SS_ID_MATROX_MGA_G100_PCI
,
1482 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_G100
, 0xFF,
1487 "unknown G100 (PCI)"},
1488 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_G100_AGP
, 0xFF,
1489 PCI_SS_VENDOR_ID_MATROX
, PCI_SS_ID_MATROX_GENERIC
,
1494 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_G100_AGP
, 0xFF,
1495 PCI_SS_VENDOR_ID_MATROX
, PCI_SS_ID_MATROX_MGA_G100_AGP
,
1500 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_G100_AGP
, 0xFF,
1501 PCI_SS_VENDOR_ID_SIEMENS_NIXDORF
, PCI_SS_ID_SIEMENS_MGA_G100_AGP
,
1506 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_G100_AGP
, 0xFF,
1507 PCI_SS_VENDOR_ID_MATROX
, PCI_SS_ID_MATROX_PRODUCTIVA_G100_AGP
,
1511 "Productiva G100 (AGP)"},
1512 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_G100_AGP
, 0xFF,
1517 "unknown G100 (AGP)"},
1518 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_G200_PCI
, 0xFF,
1523 "unknown G200 (PCI)"},
1524 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_G200_AGP
, 0xFF,
1525 PCI_SS_VENDOR_ID_MATROX
, PCI_SS_ID_MATROX_GENERIC
,
1530 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_G200_AGP
, 0xFF,
1531 PCI_SS_VENDOR_ID_MATROX
, PCI_SS_ID_MATROX_MYSTIQUE_G200_AGP
,
1535 "Mystique G200 (AGP)"},
1536 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_G200_AGP
, 0xFF,
1537 PCI_SS_VENDOR_ID_MATROX
, PCI_SS_ID_MATROX_MILLENIUM_G200_AGP
,
1541 "Millennium G200 (AGP)"},
1542 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_G200_AGP
, 0xFF,
1543 PCI_SS_VENDOR_ID_MATROX
, PCI_SS_ID_MATROX_MARVEL_G200_AGP
,
1547 "Marvel G200 (AGP)"},
1548 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_G200_AGP
, 0xFF,
1549 PCI_SS_VENDOR_ID_SIEMENS_NIXDORF
, PCI_SS_ID_SIEMENS_MGA_G200_AGP
,
1554 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_G200_AGP
, 0xFF,
1559 "unknown G200 (AGP)"},
1560 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_G400_AGP
, 0x80,
1561 PCI_SS_VENDOR_ID_MATROX
, PCI_SS_ID_MATROX_MILLENNIUM_G400_MAX_AGP
,
1565 "Millennium G400 MAX (AGP)"},
1566 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_G400_AGP
, 0x80,
1571 "unknown G400 (AGP)"},
1572 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_G400_AGP
, 0xFF,
1575 500000, /* ??? vco goes up to 900MHz... */
1577 "unknown G450 (AGP)"},
1587 static struct fb_videomode defaultmode
= {
1588 /* 640x480 @ 60Hz, 31.5 kHz */
1589 NULL
, 60, 640, 480, 39721, 40, 24, 32, 11, 96, 2,
1590 0, FB_VMODE_NONINTERLACED
1592 #endif /* !MODULE */
1594 static int hotplug
= 0;
1596 static int initMatrox2(WPMINFO
struct display
* d
, struct board
* b
){
1597 unsigned long ctrlptr_phys
= 0;
1598 unsigned long video_base_phys
= 0;
1599 unsigned int memsize
;
1600 struct matrox_hw_state
* hw
= ACCESS_FBINFO(currenthw
);
1605 /* set default values... */
1606 vesafb_defined
.accel_flags
= FB_ACCELF_TEXT
;
1608 ACCESS_FBINFO(hw_switch
) = b
->base
->lowlevel
;
1609 ACCESS_FBINFO(devflags
.accelerator
) = b
->base
->accelID
;
1610 ACCESS_FBINFO(max_pixel_clock
) = b
->maxclk
;
1612 printk(KERN_INFO
"matroxfb: Matrox %s detected\n", b
->name
);
1613 ACCESS_FBINFO(capable
.plnwt
) = 1;
1614 ACCESS_FBINFO(devflags
.video64bits
) = b
->flags
& DEVF_VIDEO64BIT
;
1615 if (b
->flags
& DEVF_TEXT4B
) {
1616 ACCESS_FBINFO(devflags
.vgastep
) = 4;
1617 ACCESS_FBINFO(devflags
.textmode
) = 4;
1618 ACCESS_FBINFO(devflags
.text_type_aux
) = FB_AUX_TEXT_MGA_STEP16
;
1619 } else if (b
->flags
& DEVF_TEXT16B
) {
1620 ACCESS_FBINFO(devflags
.vgastep
) = 16;
1621 ACCESS_FBINFO(devflags
.textmode
) = 1;
1622 ACCESS_FBINFO(devflags
.text_type_aux
) = FB_AUX_TEXT_MGA_STEP16
;
1624 ACCESS_FBINFO(devflags
.vgastep
) = 8;
1625 ACCESS_FBINFO(devflags
.textmode
) = 1;
1626 ACCESS_FBINFO(devflags
.text_type_aux
) = FB_AUX_TEXT_MGA_STEP8
;
1628 #ifdef CONFIG_FB_MATROX_32MB
1629 ACCESS_FBINFO(devflags
.support32MB
) = b
->flags
& DEVF_SUPPORT32MB
;
1631 ACCESS_FBINFO(devflags
.precise_width
) = !(b
->flags
& DEVF_ANY_VXRES
);
1632 ACCESS_FBINFO(devflags
.crtc2
) = b
->flags
& DEVF_CRTC2
;
1633 ACCESS_FBINFO(devflags
.maven_capable
) = b
->flags
& DEVF_MAVEN_CAPABLE
;
1634 if (b
->flags
& DEVF_PANELLINK_CAPABLE
) {
1635 ACCESS_FBINFO(output
.all
) |= MATROXFB_OUTPUT_CONN_DFP
;
1637 ACCESS_FBINFO(output
.ph
) |= MATROXFB_OUTPUT_CONN_DFP
;
1639 ACCESS_FBINFO(devflags
.g450dac
) = b
->flags
& DEVF_G450DAC
;
1640 ACCESS_FBINFO(devflags
.textstep
) = ACCESS_FBINFO(devflags
.vgastep
) * ACCESS_FBINFO(devflags
.textmode
);
1641 ACCESS_FBINFO(devflags
.textvram
) = 65536 / ACCESS_FBINFO(devflags
.textmode
);
1643 if (ACCESS_FBINFO(capable
.cross4MB
) < 0)
1644 ACCESS_FBINFO(capable
.cross4MB
) = b
->flags
& DEVF_CROSS4MB
;
1645 if (b
->flags
& DEVF_SWAPS
) {
1646 ctrlptr_phys
= pci_resource_start(ACCESS_FBINFO(pcidev
), 1);
1647 video_base_phys
= pci_resource_start(ACCESS_FBINFO(pcidev
), 0);
1649 ctrlptr_phys
= pci_resource_start(ACCESS_FBINFO(pcidev
), 0);
1650 video_base_phys
= pci_resource_start(ACCESS_FBINFO(pcidev
), 1);
1653 if (!ctrlptr_phys
) {
1654 printk(KERN_ERR
"matroxfb: control registers are not available, matroxfb disabled\n");
1657 if (!video_base_phys
) {
1658 printk(KERN_ERR
"matroxfb: video RAM is not available in PCI address space, matroxfb disabled\n");
1661 memsize
= b
->base
->maxvram
;
1662 if (!request_mem_region(ctrlptr_phys
, 16384, "matroxfb MMIO")) {
1665 if (!request_mem_region(video_base_phys
, memsize
, "matroxfb FB")) {
1668 ACCESS_FBINFO(video
.len_maximum
) = memsize
;
1669 /* convert mem (autodetect k, M) */
1670 if (mem
< 1024) mem
*= 1024;
1671 if (mem
< 0x00100000) mem
*= 1024;
1673 if (mem
&& (mem
< memsize
))
1676 if (mga_ioremap(ctrlptr_phys
, 16384, MGA_IOREMAP_MMIO
, &ACCESS_FBINFO(mmio
.vbase
))) {
1677 printk(KERN_ERR
"matroxfb: cannot ioremap(%lX, 16384), matroxfb disabled\n", ctrlptr_phys
);
1680 ACCESS_FBINFO(mmio
.base
) = ctrlptr_phys
;
1681 ACCESS_FBINFO(mmio
.len
) = 16384;
1682 ACCESS_FBINFO(video
.base
) = video_base_phys
;
1683 if (mga_ioremap(video_base_phys
, memsize
, MGA_IOREMAP_FB
, &ACCESS_FBINFO(video
.vbase
))) {
1684 printk(KERN_ERR
"matroxfb: cannot ioremap(%lX, %d), matroxfb disabled\n",
1685 video_base_phys
, memsize
);
1690 u_int32_t mga_option
;
1692 pci_read_config_dword(ACCESS_FBINFO(pcidev
), PCI_OPTION_REG
, &mga_option
);
1693 pci_read_config_dword(ACCESS_FBINFO(pcidev
), PCI_COMMAND
, &cmd
);
1694 mga_option
&= 0x7FFFFFFF; /* clear BIG_ENDIAN */
1695 mga_option
|= MX_OPTION_BSWAP
;
1696 /* disable palette snooping */
1697 cmd
&= ~PCI_COMMAND_VGA_PALETTE
;
1698 if (pci_find_device(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_82437
, NULL
)) {
1699 if (!(mga_option
& 0x20000000) && !ACCESS_FBINFO(devflags
.nopciretry
)) {
1700 printk(KERN_WARNING
"matroxfb: Disabling PCI retries due to i82437 present\n");
1702 mga_option
|= 0x20000000;
1703 ACCESS_FBINFO(devflags
.nopciretry
) = 1;
1705 pci_write_config_dword(ACCESS_FBINFO(pcidev
), PCI_COMMAND
, cmd
);
1706 pci_write_config_dword(ACCESS_FBINFO(pcidev
), PCI_OPTION_REG
, mga_option
);
1707 hw
->MXoptionReg
= mga_option
;
1709 /* select non-DMA memory for PCI_MGA_DATA, otherwise dump of PCI cfg space can lock PCI bus */
1710 /* maybe preinit() candidate, but it is same... for all devices... at this time... */
1711 pci_write_config_dword(ACCESS_FBINFO(pcidev
), PCI_MGA_INDEX
, 0x00003C00);
1715 if (ACCESS_FBINFO(hw_switch
)->preinit(PMINFO hw
)) {
1720 if (!matroxfb_getmemory(PMINFO memsize
, &ACCESS_FBINFO(video
.len
)) || !ACCESS_FBINFO(video
.len
)) {
1721 printk(KERN_ERR
"matroxfb: cannot determine memory size\n");
1724 ACCESS_FBINFO(devflags
.ydstorg
) = 0;
1726 ACCESS_FBINFO(currcon
) = -1;
1727 ACCESS_FBINFO(currcon_display
) = d
;
1728 mga_iounmap(ACCESS_FBINFO(video
.vbase
));
1729 ACCESS_FBINFO(video
.base
) = video_base_phys
;
1730 if (mga_ioremap(video_base_phys
, ACCESS_FBINFO(video
.len
), MGA_IOREMAP_FB
, &ACCESS_FBINFO(video
.vbase
))) {
1731 printk(KERN_ERR
"matroxfb: cannot ioremap(%lX, %d), matroxfb disabled\n",
1732 video_base_phys
, ACCESS_FBINFO(video
.len
));
1735 ACCESS_FBINFO(video
.len_usable
) = ACCESS_FBINFO(video
.len
);
1736 if (ACCESS_FBINFO(video
.len_usable
) > b
->base
->maxdisplayable
)
1737 ACCESS_FBINFO(video
.len_usable
) = b
->base
->maxdisplayable
;
1740 ACCESS_FBINFO(mtrr
.vram
) = mtrr_add(video_base_phys
, ACCESS_FBINFO(video
.len
), MTRR_TYPE_WRCOMB
, 1);
1741 ACCESS_FBINFO(mtrr
.vram_valid
) = 1;
1742 printk(KERN_INFO
"matroxfb: MTRR's turned on\n");
1744 #endif /* CONFIG_MTRR */
1746 if (!ACCESS_FBINFO(devflags
.novga
))
1747 request_region(0x3C0, 32, "matrox");
1748 ACCESS_FBINFO(hw_switch
->reset(PMINFO hw
));
1750 ACCESS_FBINFO(fbcon
.monspecs
.hfmin
) = 0;
1751 ACCESS_FBINFO(fbcon
.monspecs
.hfmax
) = fh
;
1752 ACCESS_FBINFO(fbcon
.monspecs
.vfmin
) = 0;
1753 ACCESS_FBINFO(fbcon
.monspecs
.vfmax
) = fv
;
1754 ACCESS_FBINFO(fbcon
.monspecs
.dpms
) = 0; /* TBD */
1756 /* static settings */
1757 if ((depth
== RSText8
) && (!*ACCESS_FBINFO(fbcon
.fontname
))) {
1758 strcpy(ACCESS_FBINFO(fbcon
.fontname
), "VGA8x8");
1760 vesafb_defined
.red
= colors
[depth
-1].red
;
1761 vesafb_defined
.green
= colors
[depth
-1].green
;
1762 vesafb_defined
.blue
= colors
[depth
-1].blue
;
1763 vesafb_defined
.bits_per_pixel
= colors
[depth
-1].bits_per_pixel
;
1764 vesafb_defined
.grayscale
= grayscale
;
1765 vesafb_defined
.vmode
= 0;
1767 vesafb_defined
.accel_flags
&= ~FB_ACCELF_TEXT
;
1769 strcpy(ACCESS_FBINFO(fbcon
.modename
), "MATROX VGA");
1770 ACCESS_FBINFO(fbcon
.changevar
) = NULL
;
1771 ACCESS_FBINFO(fbcon
.node
) = -1;
1772 ACCESS_FBINFO(fbcon
.fbops
) = &matroxfb_ops
;
1773 ACCESS_FBINFO(fbcon
.disp
) = d
;
1774 ACCESS_FBINFO(fbcon
.switch_con
) = &matroxfb_switch
;
1775 ACCESS_FBINFO(fbcon
.updatevar
) = &matroxfb_updatevar
;
1776 ACCESS_FBINFO(fbcon
.blank
) = &matroxfb_blank
;
1777 /* after __init time we are like module... no logo */
1778 ACCESS_FBINFO(fbcon
.flags
) = hotplug
? FBINFO_FLAG_MODULE
: FBINFO_FLAG_DEFAULT
;
1779 ACCESS_FBINFO(video
.len_usable
) &= PAGE_MASK
;
1782 /* mode database is marked __init!!! */
1784 fb_find_mode(&vesafb_defined
, &ACCESS_FBINFO(fbcon
), videomode
[0]?videomode
:NULL
,
1785 NULL
, 0, &defaultmode
, vesafb_defined
.bits_per_pixel
);
1787 #endif /* !MODULE */
1789 /* mode modifiers */
1791 vesafb_defined
.hsync_len
= hslen
;
1793 vesafb_defined
.vsync_len
= vslen
;
1795 vesafb_defined
.left_margin
= left
;
1797 vesafb_defined
.right_margin
= right
;
1799 vesafb_defined
.upper_margin
= upper
;
1801 vesafb_defined
.lower_margin
= lower
;
1803 vesafb_defined
.xres
= xres
;
1805 vesafb_defined
.yres
= yres
;
1807 vesafb_defined
.sync
= sync
;
1808 else if (vesafb_defined
.sync
== ~0) {
1809 vesafb_defined
.sync
= 0;
1811 vesafb_defined
.sync
|= FB_SYNC_HOR_HIGH_ACT
;
1812 else if (yres
< 480)
1813 vesafb_defined
.sync
|= FB_SYNC_VERT_HIGH_ACT
;
1816 /* fv, fh, maxclk limits was specified */
1821 tmp
= fv
* (vesafb_defined
.upper_margin
+ vesafb_defined
.yres
1822 + vesafb_defined
.lower_margin
+ vesafb_defined
.vsync_len
);
1823 if ((tmp
< fh
) || (fh
== 0)) fh
= tmp
;
1826 tmp
= fh
* (vesafb_defined
.left_margin
+ vesafb_defined
.xres
1827 + vesafb_defined
.right_margin
+ vesafb_defined
.hsync_len
);
1828 if ((tmp
< maxclk
) || (maxclk
== 0)) maxclk
= tmp
;
1830 maxclk
= (maxclk
+ 499) / 500;
1832 tmp
= (2000000000 + maxclk
) / maxclk
;
1833 if (tmp
> pixclock
) pixclock
= tmp
;
1837 if (pixclock
< 2000) /* > 500MHz */
1838 pixclock
= 4000; /* 250MHz */
1839 if (pixclock
> 1000000)
1840 pixclock
= 1000000; /* 1MHz */
1841 vesafb_defined
.pixclock
= pixclock
;
1844 /* FIXME: Where to move this?! */
1845 #if defined(CONFIG_PPC)
1846 #if defined(CONFIG_FB_COMPAT_XPMAC)
1847 strcpy(ACCESS_FBINFO(matrox_name
), "MTRX,"); /* OpenFirmware naming convension */
1848 strncat(ACCESS_FBINFO(matrox_name
), b
->name
, 26);
1849 if (!console_fb_info
)
1850 console_fb_info
= &ACCESS_FBINFO(fbcon
);
1852 if ((xres
<= 640) && (yres
<= 480)) {
1853 struct fb_var_screeninfo var
;
1854 if (default_vmode
== VMODE_NVRAM
) {
1855 default_vmode
= nvram_read_byte(NV_VMODE
);
1856 if (default_vmode
<= 0 || default_vmode
> VMODE_MAX
)
1857 default_vmode
= VMODE_CHOOSE
;
1859 if (default_vmode
<= 0 || default_vmode
> VMODE_MAX
)
1860 default_vmode
= VMODE_640_480_60
;
1861 if (default_cmode
== CMODE_NVRAM
)
1862 default_cmode
= nvram_read_byte(NV_CMODE
);
1863 if (default_cmode
< CMODE_8
|| default_cmode
> CMODE_32
)
1864 default_cmode
= CMODE_8
;
1865 if (!mac_vmode_to_var(default_vmode
, default_cmode
, &var
)) {
1866 var
.accel_flags
= vesafb_defined
.accel_flags
;
1867 var
.xoffset
= var
.yoffset
= 0;
1868 vesafb_defined
= var
; /* Note: mac_vmode_to_var() doesnot set all parameters */
1871 #endif /* CONFIG_PPC */
1872 vesafb_defined
.xres_virtual
= vesafb_defined
.xres
;
1874 vesafb_defined
.yres_virtual
= vesafb_defined
.yres
;
1876 vesafb_defined
.yres_virtual
= 65536; /* large enough to be INF, but small enough
1877 to yres_virtual * xres_virtual < 2^32 */
1880 if (matroxfb_set_var(&vesafb_defined
, -2, &ACCESS_FBINFO(fbcon
))) {
1881 printk(KERN_ERR
"matroxfb: cannot set required parameters\n");
1885 printk(KERN_INFO
"matroxfb: %dx%dx%dbpp (virtual: %dx%d)\n",
1886 vesafb_defined
.xres
, vesafb_defined
.yres
, vesafb_defined
.bits_per_pixel
,
1887 vesafb_defined
.xres_virtual
, vesafb_defined
.yres_virtual
);
1888 printk(KERN_INFO
"matroxfb: framebuffer at 0x%lX, mapped to 0x%p, size %d\n",
1889 ACCESS_FBINFO(video
.base
), vaddr_va(ACCESS_FBINFO(video
.vbase
)), ACCESS_FBINFO(video
.len
));
1891 /* We do not have to set currcon to 0... register_framebuffer do it for us on first console
1892 * and we do not want currcon == 0 for subsequent framebuffers */
1894 if (register_framebuffer(&ACCESS_FBINFO(fbcon
)) < 0) {
1897 printk("fb%d: %s frame buffer device\n",
1898 GET_FB_IDX(ACCESS_FBINFO(fbcon
.node
)), ACCESS_FBINFO(fbcon
.modename
));
1899 if (ACCESS_FBINFO(currcon
) < 0) {
1900 /* there is no console on this fb... but we have to initialize hardware
1901 * until someone tells me what is proper thing to do */
1902 printk(KERN_INFO
"fb%d: initializing hardware\n",
1903 GET_FB_IDX(ACCESS_FBINFO(fbcon
.node
)));
1904 matroxfb_set_var(&vesafb_defined
, -1, &ACCESS_FBINFO(fbcon
));
1908 mga_iounmap(ACCESS_FBINFO(video
.vbase
));
1910 mga_iounmap(ACCESS_FBINFO(mmio
.vbase
));
1912 release_mem_region(video_base_phys
, ACCESS_FBINFO(video
.len_maximum
));
1914 release_mem_region(ctrlptr_phys
, 16384);
1919 LIST_HEAD(matroxfb_list
);
1920 LIST_HEAD(matroxfb_driver_list
);
1922 #define matroxfb_l(x) list_entry(x, struct matrox_fb_info, next_fb)
1923 #define matroxfb_driver_l(x) list_entry(x, struct matroxfb_driver, node)
1924 int matroxfb_register_driver(struct matroxfb_driver
* drv
) {
1925 struct matrox_fb_info
* minfo
;
1927 list_add(&drv
->node
, &matroxfb_driver_list
);
1928 for (minfo
= matroxfb_l(matroxfb_list
.next
);
1929 minfo
!= matroxfb_l(&matroxfb_list
);
1930 minfo
= matroxfb_l(minfo
->next_fb
.next
)) {
1933 if (minfo
->drivers_count
== MATROXFB_MAX_FB_DRIVERS
)
1935 p
= drv
->probe(minfo
);
1937 minfo
->drivers_data
[minfo
->drivers_count
] = p
;
1938 minfo
->drivers
[minfo
->drivers_count
++] = drv
;
1944 void matroxfb_unregister_driver(struct matroxfb_driver
* drv
) {
1945 struct matrox_fb_info
* minfo
;
1947 list_del(&drv
->node
);
1948 for (minfo
= matroxfb_l(matroxfb_list
.next
);
1949 minfo
!= matroxfb_l(&matroxfb_list
);
1950 minfo
= matroxfb_l(minfo
->next_fb
.next
)) {
1953 for (i
= 0; i
< minfo
->drivers_count
; ) {
1954 if (minfo
->drivers
[i
] == drv
) {
1955 if (drv
&& drv
->remove
)
1956 drv
->remove(minfo
, minfo
->drivers_data
[i
]);
1957 minfo
->drivers
[i
] = minfo
->drivers
[--minfo
->drivers_count
];
1958 minfo
->drivers_data
[i
] = minfo
->drivers_data
[minfo
->drivers_count
];
1965 static void matroxfb_register_device(struct matrox_fb_info
* minfo
) {
1966 struct matroxfb_driver
* drv
;
1968 list_add(&ACCESS_FBINFO(next_fb
), &matroxfb_list
);
1969 for (drv
= matroxfb_driver_l(matroxfb_driver_list
.next
);
1970 drv
!= matroxfb_driver_l(&matroxfb_driver_list
);
1971 drv
= matroxfb_driver_l(drv
->node
.next
)) {
1972 if (drv
&& drv
->probe
) {
1973 void *p
= drv
->probe(minfo
);
1975 minfo
->drivers_data
[i
] = p
;
1976 minfo
->drivers
[i
++] = drv
;
1977 if (i
== MATROXFB_MAX_FB_DRIVERS
)
1982 minfo
->drivers_count
= i
;
1985 static void matroxfb_unregister_device(struct matrox_fb_info
* minfo
) {
1988 list_del(&ACCESS_FBINFO(next_fb
));
1989 for (i
= 0; i
< minfo
->drivers_count
; i
++) {
1990 struct matroxfb_driver
* drv
= minfo
->drivers
[i
];
1992 if (drv
&& drv
->remove
)
1993 drv
->remove(minfo
, minfo
->drivers_data
[i
]);
1997 static int matroxfb_probe(struct pci_dev
* pdev
, const struct pci_device_id
* dummy
) {
2002 struct matrox_fb_info
* minfo
;
2006 #ifndef CONFIG_FB_MATROX_MULTIHEAD
2007 static int registered
= 0;
2009 DBG("matroxfb_probe")
2011 pci_read_config_byte(pdev
, PCI_REVISION_ID
, &rev
);
2012 svid
= pdev
->subsystem_vendor
;
2013 sid
= pdev
->subsystem_device
;
2014 for (b
= dev_list
; b
->vendor
; b
++) {
2015 if ((b
->vendor
!= pdev
->vendor
) || (b
->device
!= pdev
->device
) || (b
->rev
< rev
)) continue;
2017 if ((b
->svid
!= svid
) || (b
->sid
!= sid
)) continue;
2024 /* not requested one... */
2028 pci_read_config_dword(pdev
, PCI_COMMAND
, &cmd
);
2029 if (pci_enable_device(pdev
)) {
2033 #ifdef CONFIG_FB_MATROX_MULTIHEAD
2034 minfo
= (struct matrox_fb_info
*)kmalloc(sizeof(*minfo
), GFP_KERNEL
);
2037 d
= (struct display
*)kmalloc(sizeof(*d
), GFP_KERNEL
);
2043 if (registered
) /* singlehead driver... */
2045 minfo
= &matroxfb_global_mxinfo
;
2048 memset(MINFO
, 0, sizeof(*MINFO
));
2049 memset(d
, 0, sizeof(*d
));
2051 ACCESS_FBINFO(currenthw
) = &ACCESS_FBINFO(hw1
);
2052 ACCESS_FBINFO(newhw
) = &ACCESS_FBINFO(hw2
);
2053 ACCESS_FBINFO(pcidev
) = pdev
;
2054 ACCESS_FBINFO(dead
) = 0;
2055 ACCESS_FBINFO(usecount
) = 0;
2056 pdev
->driver_data
= MINFO
;
2058 memcpy(ACCESS_FBINFO(fbcon
.fontname
), fontname
, sizeof(ACCESS_FBINFO(fbcon
.fontname
)));
2060 ACCESS_FBINFO(devflags
.inverse
) = inverse
;
2061 ACCESS_FBINFO(devflags
.memtype
) = memtype
;
2064 if (cmd
& PCI_COMMAND_MEMORY
) {
2065 ACCESS_FBINFO(devflags
.novga
) = novga
;
2066 ACCESS_FBINFO(devflags
.nobios
) = nobios
;
2067 ACCESS_FBINFO(devflags
.noinit
) = noinit
;
2068 /* subsequent heads always needs initialization and must not enable BIOS */
2073 ACCESS_FBINFO(devflags
.novga
) = 1;
2074 ACCESS_FBINFO(devflags
.nobios
) = 1;
2075 ACCESS_FBINFO(devflags
.noinit
) = 0;
2078 ACCESS_FBINFO(devflags
.nopciretry
) = no_pci_retry
;
2079 ACCESS_FBINFO(devflags
.mga_24bpp_fix
) = inv24
;
2080 ACCESS_FBINFO(devflags
.precise_width
) = option_precise_width
;
2081 ACCESS_FBINFO(devflags
.hwcursor
) = hwcursor
;
2082 ACCESS_FBINFO(devflags
.blink
) = blink
;
2083 ACCESS_FBINFO(devflags
.sgram
) = sgram
;
2084 ACCESS_FBINFO(capable
.cross4MB
) = cross4MB
;
2086 ACCESS_FBINFO(fastfont
.size
) = fastfont
;
2088 ACCESS_FBINFO(cursor
.state
) = CM_ERASE
;
2089 init_timer (&ACCESS_FBINFO(cursor
.timer
));
2090 ACCESS_FBINFO(cursor
.timer
.data
) = (unsigned long)MINFO
;
2091 spin_lock_init(&ACCESS_FBINFO(lock
.DAC
));
2092 spin_lock_init(&ACCESS_FBINFO(lock
.accel
));
2093 init_rwsem(&ACCESS_FBINFO(crtc2
.lock
));
2094 init_rwsem(&ACCESS_FBINFO(altout
.lock
));
2096 ACCESS_FBINFO(output
.all
) = MATROXFB_OUTPUT_CONN_PRIMARY
;
2097 ACCESS_FBINFO(output
.ph
) = MATROXFB_OUTPUT_CONN_PRIMARY
;
2098 ACCESS_FBINFO(output
.sh
) = 0;
2100 err
= initMatrox2(PMINFO d
, b
);
2102 #ifndef CONFIG_FB_MATROX_MULTIHEAD
2105 matroxfb_register_device(MINFO
);
2108 #ifdef CONFIG_FB_MATROX_MULTIHEAD
2115 static void pci_remove_matrox(struct pci_dev
* pdev
) {
2116 struct matrox_fb_info
* minfo
;
2118 minfo
= pdev
->driver_data
;
2119 matroxfb_remove(PMINFO
1);
2122 static struct pci_device_id matroxfb_devices
[] __devinitdata
= {
2123 #ifdef CONFIG_FB_MATROX_MILLENIUM
2124 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_MIL
,
2125 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
2126 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_MIL_2
,
2127 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
2128 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_MIL_2_AGP
,
2129 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
2131 #ifdef CONFIG_FB_MATROX_MYSTIQUE
2132 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_MYS
,
2133 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
2135 #ifdef CONFIG_FB_MATROX_G100
2136 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_G100
,
2137 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
2138 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_G100_AGP
,
2139 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
2140 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_G200_PCI
,
2141 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
2142 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_G200_AGP
,
2143 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
2144 {PCI_VENDOR_ID_MATROX
, PCI_DEVICE_ID_MATROX_G400_AGP
,
2145 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
2151 MODULE_DEVICE_TABLE(pci
, matroxfb_devices
);
2153 static struct pci_driver matroxfb_driver
= {
2155 id_table
: matroxfb_devices
,
2156 probe
: matroxfb_probe
,
2157 remove
: pci_remove_matrox
,
2160 /* **************************** init-time only **************************** */
2162 #define RSResolution(X) ((X) & 0x0F)
2166 #define RS1024x768 4
2167 #define RS1280x1024 5
2168 #define RS1600x1200 6
2171 #define RS1152x864 9
2172 #define RS1408x1056 10
2173 #define RS640x350 11
2174 #define RS1056x344 12 /* 132 x 43 text */
2175 #define RS1056x400 13 /* 132 x 50 text */
2176 #define RS1056x480 14 /* 132 x 60 text */
2179 static struct { int xres
, yres
, left
, right
, upper
, lower
, hslen
, vslen
, vfreq
; } timmings
[] __initdata
= {
2180 { 640, 400, 48, 16, 39, 8, 96, 2, 70 },
2181 { 640, 480, 48, 16, 33, 10, 96, 2, 60 },
2182 { 800, 600, 144, 24, 28, 8, 112, 6, 60 },
2183 { 1024, 768, 160, 32, 30, 4, 128, 4, 60 },
2184 { 1280, 1024, 224, 32, 32, 4, 136, 4, 60 },
2185 { 1600, 1200, 272, 48, 32, 5, 152, 5, 60 },
2186 { 768, 576, 144, 16, 28, 6, 112, 4, 60 },
2187 { 960, 720, 144, 24, 28, 8, 112, 4, 60 },
2188 { 1152, 864, 192, 32, 30, 4, 128, 4, 60 },
2189 { 1408, 1056, 256, 40, 32, 5, 144, 5, 60 },
2190 { 640, 350, 48, 16, 39, 8, 96, 2, 70 },
2191 { 1056, 344, 96, 24, 59, 44, 160, 2, 70 },
2192 { 1056, 400, 96, 24, 39, 8, 160, 2, 70 },
2193 { 1056, 480, 96, 24, 36, 12, 160, 3, 60 },
2194 { 0, 0, ~0, ~0, ~0, ~0, 0, 0, 0 }
2197 #define RSCreate(X,Y) ((X) | ((Y) << 8))
2198 static struct { unsigned int vesa
; unsigned int info
; } *RSptr
, vesamap
[] __initdata
= {
2199 /* default must be first */
2200 #ifdef FBCON_HAS_CFB8
2201 { ~0, RSCreate(RSNoxNo
, RS8bpp
) },
2202 { 0x101, RSCreate(RS640x480
, RS8bpp
) },
2203 { 0x100, RSCreate(RS640x400
, RS8bpp
) },
2204 { 0x180, RSCreate(RS768x576
, RS8bpp
) },
2205 { 0x103, RSCreate(RS800x600
, RS8bpp
) },
2206 { 0x188, RSCreate(RS960x720
, RS8bpp
) },
2207 { 0x105, RSCreate(RS1024x768
, RS8bpp
) },
2208 { 0x190, RSCreate(RS1152x864
, RS8bpp
) },
2209 { 0x107, RSCreate(RS1280x1024
, RS8bpp
) },
2210 { 0x198, RSCreate(RS1408x1056
, RS8bpp
) },
2211 { 0x11C, RSCreate(RS1600x1200
, RS8bpp
) },
2213 #ifdef FBCON_HAS_CFB16
2214 { ~0, RSCreate(RSNoxNo
, RS15bpp
) },
2215 { 0x110, RSCreate(RS640x480
, RS15bpp
) },
2216 { 0x181, RSCreate(RS768x576
, RS15bpp
) },
2217 { 0x113, RSCreate(RS800x600
, RS15bpp
) },
2218 { 0x189, RSCreate(RS960x720
, RS15bpp
) },
2219 { 0x116, RSCreate(RS1024x768
, RS15bpp
) },
2220 { 0x191, RSCreate(RS1152x864
, RS15bpp
) },
2221 { 0x119, RSCreate(RS1280x1024
, RS15bpp
) },
2222 { 0x199, RSCreate(RS1408x1056
, RS15bpp
) },
2223 { 0x11D, RSCreate(RS1600x1200
, RS15bpp
) },
2224 { 0x111, RSCreate(RS640x480
, RS16bpp
) },
2225 { 0x182, RSCreate(RS768x576
, RS16bpp
) },
2226 { 0x114, RSCreate(RS800x600
, RS16bpp
) },
2227 { 0x18A, RSCreate(RS960x720
, RS16bpp
) },
2228 { 0x117, RSCreate(RS1024x768
, RS16bpp
) },
2229 { 0x192, RSCreate(RS1152x864
, RS16bpp
) },
2230 { 0x11A, RSCreate(RS1280x1024
, RS16bpp
) },
2231 { 0x19A, RSCreate(RS1408x1056
, RS16bpp
) },
2232 { 0x11E, RSCreate(RS1600x1200
, RS16bpp
) },
2234 #ifdef FBCON_HAS_CFB24
2235 { ~0, RSCreate(RSNoxNo
, RS24bpp
) },
2236 { 0x1B2, RSCreate(RS640x480
, RS24bpp
) },
2237 { 0x184, RSCreate(RS768x576
, RS24bpp
) },
2238 { 0x1B5, RSCreate(RS800x600
, RS24bpp
) },
2239 { 0x18C, RSCreate(RS960x720
, RS24bpp
) },
2240 { 0x1B8, RSCreate(RS1024x768
, RS24bpp
) },
2241 { 0x194, RSCreate(RS1152x864
, RS24bpp
) },
2242 { 0x1BB, RSCreate(RS1280x1024
, RS24bpp
) },
2243 { 0x19C, RSCreate(RS1408x1056
, RS24bpp
) },
2244 { 0x1BF, RSCreate(RS1600x1200
, RS24bpp
) },
2246 #ifdef FBCON_HAS_CFB32
2247 { ~0, RSCreate(RSNoxNo
, RS32bpp
) },
2248 { 0x112, RSCreate(RS640x480
, RS32bpp
) },
2249 { 0x183, RSCreate(RS768x576
, RS32bpp
) },
2250 { 0x115, RSCreate(RS800x600
, RS32bpp
) },
2251 { 0x18B, RSCreate(RS960x720
, RS32bpp
) },
2252 { 0x118, RSCreate(RS1024x768
, RS32bpp
) },
2253 { 0x193, RSCreate(RS1152x864
, RS32bpp
) },
2254 { 0x11B, RSCreate(RS1280x1024
, RS32bpp
) },
2255 { 0x19B, RSCreate(RS1408x1056
, RS32bpp
) },
2256 { 0x11F, RSCreate(RS1600x1200
, RS32bpp
) },
2258 #ifdef FBCON_HAS_VGATEXT
2259 { ~0, RSCreate(RSNoxNo
, RSText
) },
2260 { 0x002, RSCreate(RS640x400
, RSText
) }, /* 80x25 */
2261 { 0x003, RSCreate(RS640x400
, RSText
) }, /* 80x25 */
2262 { 0x007, RSCreate(RS640x400
, RSText
) }, /* 80x25 */
2263 { 0x1C0, RSCreate(RS640x400
, RSText8
) }, /* 80x50 */
2264 { 0x108, RSCreate(RS640x480
, RSText8
) }, /* 80x60 */
2265 { 0x109, RSCreate(RS1056x400
, RSText
) }, /* 132x25 */
2266 { 0x10A, RSCreate(RS1056x344
, RSText8
) }, /* 132x43 */
2267 { 0x10B, RSCreate(RS1056x400
, RSText8
) }, /* 132x50 */
2268 { 0x10C, RSCreate(RS1056x480
, RSText8
) }, /* 132x60 */
2270 #ifdef FBCON_HAS_CFB4
2271 { ~0, RSCreate(RSNoxNo
, RS4bpp
) },
2272 { 0x010, RSCreate(RS640x350
, RS4bpp
) },
2273 { 0x012, RSCreate(RS640x480
, RS4bpp
) },
2274 { 0x102, RSCreate(RS800x600
, RS4bpp
) },
2275 { 0x104, RSCreate(RS1024x768
, RS4bpp
) },
2276 { 0x106, RSCreate(RS1280x1024
, RS4bpp
) },
2280 static void __init
matroxfb_init_params(void) {
2281 /* fh from kHz to Hz */
2283 fh
*= 1000; /* 1kHz minimum */
2285 if (maxclk
< 1000) maxclk
*= 1000; /* kHz -> Hz, MHz -> kHz */
2286 if (maxclk
< 1000000) maxclk
*= 1000; /* kHz -> Hz, 1MHz minimum */
2287 /* fix VESA number */
2289 vesa
&= 0x1DFF; /* mask out clearscreen, acceleration and so on */
2291 /* static settings */
2292 for (RSptr
= vesamap
; RSptr
->vesa
; RSptr
++) {
2293 if (RSptr
->vesa
== vesa
) break;
2296 printk(KERN_ERR
"Invalid vesa mode 0x%04X\n", vesa
);
2300 int res
= RSResolution(RSptr
->info
)-1;
2302 left
= timmings
[res
].left
;
2304 xres
= timmings
[res
].xres
;
2306 right
= timmings
[res
].right
;
2308 hslen
= timmings
[res
].hslen
;
2310 upper
= timmings
[res
].upper
;
2312 yres
= timmings
[res
].yres
;
2314 lower
= timmings
[res
].lower
;
2316 vslen
= timmings
[res
].vslen
;
2317 if (!(fv
||fh
||maxclk
||pixclock
))
2318 fv
= timmings
[res
].vfreq
;
2320 depth
= RSDepth(RSptr
->info
);
2324 static void __init
matrox_init(void) {
2325 matroxfb_init_params();
2326 pci_register_driver(&matroxfb_driver
);
2327 dev
= -1; /* accept all new devices... */
2330 /* **************************** exit-time only **************************** */
2332 static void __exit
matrox_done(void) {
2333 pci_unregister_driver(&matroxfb_driver
);
2338 /* ************************* init in-kernel code ************************** */
2340 int __init
matroxfb_setup(char *options
) {
2343 DBG("matroxfb_setup")
2347 if (!options
|| !*options
)
2350 for(this_opt
=strtok(options
,","); this_opt
; this_opt
=strtok(NULL
,",")) {
2351 if (!*this_opt
) continue;
2353 dprintk("matroxfb_setup: option %s\n", this_opt
);
2355 if (!strncmp(this_opt
, "dev:", 4))
2356 dev
= simple_strtoul(this_opt
+4, NULL
, 0);
2357 else if (!strncmp(this_opt
, "depth:", 6)) {
2358 switch (simple_strtoul(this_opt
+6, NULL
, 0)) {
2359 case 0: depth
= RSText
; break;
2360 case 4: depth
= RS4bpp
; break;
2361 case 8: depth
= RS8bpp
; break;
2362 case 15:depth
= RS15bpp
; break;
2363 case 16:depth
= RS16bpp
; break;
2364 case 24:depth
= RS24bpp
; break;
2365 case 32:depth
= RS32bpp
; break;
2367 printk(KERN_ERR
"matroxfb: unsupported color depth\n");
2369 } else if (!strncmp(this_opt
, "xres:", 5))
2370 xres
= simple_strtoul(this_opt
+5, NULL
, 0);
2371 else if (!strncmp(this_opt
, "yres:", 5))
2372 yres
= simple_strtoul(this_opt
+5, NULL
, 0);
2373 else if (!strncmp(this_opt
, "vslen:", 6))
2374 vslen
= simple_strtoul(this_opt
+6, NULL
, 0);
2375 else if (!strncmp(this_opt
, "hslen:", 6))
2376 hslen
= simple_strtoul(this_opt
+6, NULL
, 0);
2377 else if (!strncmp(this_opt
, "left:", 5))
2378 left
= simple_strtoul(this_opt
+5, NULL
, 0);
2379 else if (!strncmp(this_opt
, "right:", 6))
2380 right
= simple_strtoul(this_opt
+6, NULL
, 0);
2381 else if (!strncmp(this_opt
, "upper:", 6))
2382 upper
= simple_strtoul(this_opt
+6, NULL
, 0);
2383 else if (!strncmp(this_opt
, "lower:", 6))
2384 lower
= simple_strtoul(this_opt
+6, NULL
, 0);
2385 else if (!strncmp(this_opt
, "pixclock:", 9))
2386 pixclock
= simple_strtoul(this_opt
+9, NULL
, 0);
2387 else if (!strncmp(this_opt
, "sync:", 5))
2388 sync
= simple_strtoul(this_opt
+5, NULL
, 0);
2389 else if (!strncmp(this_opt
, "vesa:", 5))
2390 vesa
= simple_strtoul(this_opt
+5, NULL
, 0);
2391 else if (!strncmp(this_opt
, "font:", 5))
2392 strncpy(fontname
, this_opt
+5, sizeof(fontname
)-1);
2393 else if (!strncmp(this_opt
, "maxclk:", 7))
2394 maxclk
= simple_strtoul(this_opt
+7, NULL
, 0);
2395 else if (!strncmp(this_opt
, "fh:", 3))
2396 fh
= simple_strtoul(this_opt
+3, NULL
, 0);
2397 else if (!strncmp(this_opt
, "fv:", 3))
2398 fv
= simple_strtoul(this_opt
+3, NULL
, 0);
2399 else if (!strncmp(this_opt
, "mem:", 4))
2400 mem
= simple_strtoul(this_opt
+4, NULL
, 0);
2401 else if (!strncmp(this_opt
, "mode:", 5))
2402 strncpy(videomode
, this_opt
+5, sizeof(videomode
)-1);
2404 else if (!strncmp(this_opt
, "vmode:", 6)) {
2405 unsigned int vmode
= simple_strtoul(this_opt
+6, NULL
, 0);
2406 if (vmode
> 0 && vmode
<= VMODE_MAX
)
2407 default_vmode
= vmode
;
2408 } else if (!strncmp(this_opt
, "cmode:", 6)) {
2409 unsigned int cmode
= simple_strtoul(this_opt
+6, NULL
, 0);
2413 default_cmode
= CMODE_8
;
2417 default_cmode
= CMODE_16
;
2421 default_cmode
= CMODE_32
;
2426 else if (!strncmp(this_opt
, "fastfont:", 9))
2427 fastfont
= simple_strtoul(this_opt
+9, NULL
, 0);
2428 else if (!strcmp(this_opt
, "nofastfont")) /* fastfont:N and nofastfont (nofastfont = fastfont:0) */
2430 else if (!strcmp(this_opt
, "disabled")) /* nodisabled does not exist */
2432 else if (!strcmp(this_opt
, "enabled")) /* noenabled does not exist */
2434 else if (!strcmp(this_opt
, "sgram")) /* nosgram == sdram */
2436 else if (!strcmp(this_opt
, "sdram"))
2438 else if (!strncmp(this_opt
, "memtype:", 8))
2439 memtype
= simple_strtoul(this_opt
+8, NULL
, 0);
2443 if (!strncmp(this_opt
, "no", 2)) {
2447 if (! strcmp(this_opt
, "inverse"))
2449 else if (!strcmp(this_opt
, "accel"))
2451 else if (!strcmp(this_opt
, "pan"))
2453 else if (!strcmp(this_opt
, "pciretry"))
2454 no_pci_retry
= !value
;
2455 else if (!strcmp(this_opt
, "vga"))
2457 else if (!strcmp(this_opt
, "bios"))
2459 else if (!strcmp(this_opt
, "init"))
2462 else if (!strcmp(this_opt
, "mtrr"))
2465 else if (!strcmp(this_opt
, "inv24"))
2467 else if (!strcmp(this_opt
, "cross4MB"))
2469 else if (!strcmp(this_opt
, "hwcursor"))
2471 else if (!strcmp(this_opt
, "blink"))
2473 else if (!strcmp(this_opt
, "grayscale"))
2475 else if (!strcmp(this_opt
, "dfp"))
2478 strncpy(videomode
, this_opt
, sizeof(videomode
)-1);
2485 static int __init initialized
= 0;
2487 int __init
matroxfb_init(void)
2489 DBG("matroxfb_init")
2497 /* never return failure, user can hotplug matrox later... */
2503 /* *************************** init module code **************************** */
2505 MODULE_AUTHOR("(c) 1998,1999 Petr Vandrovec <vandrove@vc.cvut.cz>");
2506 MODULE_DESCRIPTION("Accelerated FBDev driver for Matrox Millennium/Mystique/G100/G200/G400");
2507 MODULE_PARM(mem
, "i");
2508 MODULE_PARM_DESC(mem
, "Size of available memory in MB, KB or B (2,4,8,12,16MB, default=autodetect)");
2509 MODULE_PARM(disabled
, "i");
2510 MODULE_PARM_DESC(disabled
, "Disabled (0 or 1=disabled) (default=0)");
2511 MODULE_PARM(noaccel
, "i");
2512 MODULE_PARM_DESC(noaccel
, "Do not use accelerating engine (0 or 1=disabled) (default=0)");
2513 MODULE_PARM(nopan
, "i");
2514 MODULE_PARM_DESC(nopan
, "Disable pan on startup (0 or 1=disabled) (default=0)");
2515 MODULE_PARM(no_pci_retry
, "i");
2516 MODULE_PARM_DESC(no_pci_retry
, "PCI retries enabled (0 or 1=disabled) (default=0)");
2517 MODULE_PARM(novga
, "i");
2518 MODULE_PARM_DESC(novga
, "VGA I/O (0x3C0-0x3DF) disabled (0 or 1=disabled) (default=0)");
2519 MODULE_PARM(nobios
, "i");
2520 MODULE_PARM_DESC(nobios
, "Disables ROM BIOS (0 or 1=disabled) (default=do not change BIOS state)");
2521 MODULE_PARM(noinit
, "i");
2522 MODULE_PARM_DESC(noinit
, "Disables W/SG/SD-RAM and bus interface initialization (0 or 1=do not initialize) (default=0)");
2523 MODULE_PARM(memtype
, "i");
2524 MODULE_PARM_DESC(memtype
, "Memory type for G200/G400 (see Documentation/fb/matroxfb.txt for explanation) (default=3 for G200, 0 for G400)");
2525 MODULE_PARM(mtrr
, "i");
2526 MODULE_PARM_DESC(mtrr
, "This speeds up video memory accesses (0=disabled or 1) (default=1)");
2527 MODULE_PARM(sgram
, "i");
2528 MODULE_PARM_DESC(sgram
, "Indicates that G200/G400 has SGRAM memory (0=SDRAM, 1=SGRAM) (default=0)");
2529 MODULE_PARM(inv24
, "i");
2530 MODULE_PARM_DESC(inv24
, "Inverts clock polarity for 24bpp and loop frequency > 100MHz (default=do not invert polarity)");
2531 MODULE_PARM(inverse
, "i");
2532 MODULE_PARM_DESC(inverse
, "Inverse (0 or 1) (default=0)");
2533 #ifdef CONFIG_FB_MATROX_MULTIHEAD
2534 MODULE_PARM(dev
, "i");
2535 MODULE_PARM_DESC(dev
, "Multihead support, attach to device ID (0..N) (default=all working)");
2537 MODULE_PARM(dev
, "i");
2538 MODULE_PARM_DESC(dev
, "Multihead support, attach to device ID (0..N) (default=first working)");
2540 MODULE_PARM(vesa
, "i");
2541 MODULE_PARM_DESC(vesa
, "Startup videomode (0x000-0x1FF) (default=0x101)");
2542 MODULE_PARM(xres
, "i");
2543 MODULE_PARM_DESC(xres
, "Horizontal resolution (px), overrides xres from vesa (default=vesa)");
2544 MODULE_PARM(yres
, "i");
2545 MODULE_PARM_DESC(yres
, "Vertical resolution (scans), overrides yres from vesa (default=vesa)");
2546 MODULE_PARM(upper
, "i");
2547 MODULE_PARM_DESC(upper
, "Upper blank space (scans), overrides upper from vesa (default=vesa)");
2548 MODULE_PARM(lower
, "i");
2549 MODULE_PARM_DESC(lower
, "Lower blank space (scans), overrides lower from vesa (default=vesa)");
2550 MODULE_PARM(vslen
, "i");
2551 MODULE_PARM_DESC(vslen
, "Vertical sync length (scans), overrides lower from vesa (default=vesa)");
2552 MODULE_PARM(left
, "i");
2553 MODULE_PARM_DESC(left
, "Left blank space (px), overrides left from vesa (default=vesa)");
2554 MODULE_PARM(right
, "i");
2555 MODULE_PARM_DESC(right
, "Right blank space (px), overrides right from vesa (default=vesa)");
2556 MODULE_PARM(hslen
, "i");
2557 MODULE_PARM_DESC(hslen
, "Horizontal sync length (px), overrides hslen from vesa (default=vesa)");
2558 MODULE_PARM(pixclock
, "i");
2559 MODULE_PARM_DESC(pixclock
, "Pixelclock (ns), overrides pixclock from vesa (default=vesa)");
2560 MODULE_PARM(sync
, "i");
2561 MODULE_PARM_DESC(sync
, "Sync polarity, overrides sync from vesa (default=vesa)");
2562 MODULE_PARM(depth
, "i");
2563 MODULE_PARM_DESC(depth
, "Color depth (0=text,8,15,16,24,32) (default=vesa)");
2564 MODULE_PARM(maxclk
, "i");
2565 MODULE_PARM_DESC(maxclk
, "Startup maximal clock, 0-999MHz, 1000-999999kHz, 1000000-INF Hz");
2566 MODULE_PARM(fh
, "i");
2567 MODULE_PARM_DESC(fh
, "Startup horizontal frequency, 0-999kHz, 1000-INF Hz");
2568 MODULE_PARM(fv
, "i");
2569 MODULE_PARM_DESC(fv
, "Startup vertical frequency, 0-INF Hz\n"
2570 "You should specify \"fv:max_monitor_vsync,fh:max_monitor_hsync,maxclk:max_monitor_dotclock\"\n");
2571 MODULE_PARM(hwcursor
, "i");
2572 MODULE_PARM_DESC(hwcursor
, "Enables hardware cursor (0 or 1) (default=0)");
2573 MODULE_PARM(blink
, "i");
2574 MODULE_PARM_DESC(blink
, "Enables hardware cursor blinking (0 or 1) (default=1)");
2575 MODULE_PARM(fastfont
, "i");
2576 MODULE_PARM_DESC(fastfont
, "Specifies, how much memory should be used for font data (0, 1024-65536 are reasonable) (default=0)");
2577 MODULE_PARM(grayscale
, "i");
2578 MODULE_PARM_DESC(grayscale
, "Sets display into grayscale. Works perfectly with paletized videomode (4, 8bpp), some limitations apply to 16, 24 and 32bpp videomodes (default=nograyscale)");
2579 MODULE_PARM(cross4MB
, "i");
2580 MODULE_PARM_DESC(cross4MB
, "Specifies that 4MB boundary can be in middle of line. (default=autodetected)");
2581 MODULE_PARM(dfp
, "i");
2582 MODULE_PARM_DESC(dfp
, "Specifies whether to use digital flat panel interface of G200/G400 (0 or 1) (default=0)");
2584 MODULE_PARM(vmode
, "i");
2585 MODULE_PARM_DESC(vmode
, "Specify the vmode mode number that should be used (640x480 default)");
2586 MODULE_PARM(cmode
, "i");
2587 MODULE_PARM_DESC(cmode
, "Specify the video depth that should be used (8bit default)");
2590 int __init
init_module(void){
2599 else if (depth
== 4)
2601 else if (depth
== 8)
2603 else if (depth
== 15)
2605 else if (depth
== 16)
2607 else if (depth
== 24)
2609 else if (depth
== 32)
2611 else if (depth
!= -1) {
2612 printk(KERN_ERR
"matroxfb: depth %d is not supported, using default\n", depth
);
2616 /* never return failure; user can hotplug matrox later... */
2621 module_exit(matrox_done
);
2622 EXPORT_SYMBOL(matroxfb_register_driver
);
2623 EXPORT_SYMBOL(matroxfb_unregister_driver
);
2626 * Overrides for Emacs so that we follow Linus's tabbing style.
2627 * ---------------------------------------------------------------------------