2 * Frame buffer driver for Trident Blade and Image series
4 * Copyright 2001, 2002 - Jani Monoses <jani@iv.ro>
7 * CREDITS:(in order of appearance)
8 * skeletonfb.c by Geert Uytterhoeven and other fb code in drivers/video
9 * Special thanks ;) to Mattia Crivellini <tia@mclink.it>
10 * much inspired by the XFree86 4.x Trident driver sources
11 * by Alan Hourihane the FreeVGA project
12 * Francesco Salvestrini <salvestrini@users.sf.net> XP support,
15 * timing value tweaking so it looks good on every monitor in every mode
19 #include <linux/module.h>
21 #include <linux/init.h>
22 #include <linux/pci.h>
24 #include <linux/delay.h>
25 #include <video/trident.h>
27 #define VERSION "0.7.8-NEWAPI"
29 struct tridentfb_par
{
30 int vclk
; /* in MHz */
31 void __iomem
*io_virt
; /* iospace virtual memory address */
34 static unsigned char eng_oper
; /* engine operation... */
35 static struct fb_ops tridentfb_ops
;
37 static struct tridentfb_par default_par
;
39 /* FIXME:kmalloc these 3 instead */
40 static struct fb_info fb_info
;
41 static u32 pseudo_pal
[16];
43 static struct fb_var_screeninfo default_var
;
45 static struct fb_fix_screeninfo tridentfb_fix
= {
47 .type
= FB_TYPE_PACKED_PIXELS
,
49 .visual
= FB_VISUAL_PSEUDOCOLOR
,
50 .accel
= FB_ACCEL_NONE
,
55 static int defaultaccel
;
56 static int displaytype
;
58 /* defaults which are normally overriden by user values */
61 static char *mode_option __devinitdata
= "640x480";
76 module_param(mode_option
, charp
, 0);
77 MODULE_PARM_DESC(mode_option
, "Initial video mode e.g. '648x480-8@60'");
78 module_param(bpp
, int, 0);
79 module_param(center
, int, 0);
80 module_param(stretch
, int, 0);
81 module_param(noaccel
, int, 0);
82 module_param(memsize
, int, 0);
83 module_param(memdiff
, int, 0);
84 module_param(nativex
, int, 0);
85 module_param(fp
, int, 0);
86 module_param(crt
, int, 0);
91 static int is3Dchip(int id
)
93 return ((id
== BLADE3D
) || (id
== CYBERBLADEE4
) ||
94 (id
== CYBERBLADEi7
) || (id
== CYBERBLADEi7D
) ||
95 (id
== CYBER9397
) || (id
== CYBER9397DVD
) ||
96 (id
== CYBER9520
) || (id
== CYBER9525DVD
) ||
97 (id
== IMAGE975
) || (id
== IMAGE985
) ||
98 (id
== CYBERBLADEi1
) || (id
== CYBERBLADEi1D
) ||
99 (id
== CYBERBLADEAi1
) || (id
== CYBERBLADEAi1D
) ||
100 (id
== CYBERBLADEXPm8
) || (id
== CYBERBLADEXPm16
) ||
101 (id
== CYBERBLADEXPAi1
));
104 static int iscyber(int id
)
120 case CYBERBLADEXPAi1
:
128 case CYBERBLADEi7
: /* VIA MPV4 integrated version */
131 /* case CYBERBLDAEXPm8: Strange */
132 /* case CYBERBLDAEXPm16: Strange */
137 #define CRT 0x3D0 /* CRTC registers offset for color display */
140 #define TRIDENT_MMIO 1
144 #define t_outb(val, reg) writeb(val,((struct tridentfb_par *)(fb_info.par))->io_virt + reg)
145 #define t_inb(reg) readb(((struct tridentfb_par*)(fb_info.par))->io_virt + reg)
147 #define t_outb(val, reg) outb(val, reg)
148 #define t_inb(reg) inb(reg)
152 static struct accel_switch
{
153 void (*init_accel
) (int, int);
154 void (*wait_engine
) (void);
155 void (*fill_rect
) (u32
, u32
, u32
, u32
, u32
, u32
);
156 void (*copy_rect
) (u32
, u32
, u32
, u32
, u32
, u32
);
159 #define writemmr(r, v) writel(v, ((struct tridentfb_par *)fb_info.par)->io_virt + r)
160 #define readmmr(r) readl(((struct tridentfb_par *)fb_info.par)->io_virt + r)
163 * Blade specific acceleration.
166 #define point(x, y) ((y) << 16 | (x))
178 static void blade_init_accel(int pitch
, int bpp
)
180 int v1
= (pitch
>> 3) << 20;
197 v2
= v1
| (tmp
<< 29);
198 writemmr(0x21C0, v2
);
199 writemmr(0x21C4, v2
);
200 writemmr(0x21B8, v2
);
201 writemmr(0x21BC, v2
);
202 writemmr(0x21D0, v1
);
203 writemmr(0x21D4, v1
);
204 writemmr(0x21C8, v1
);
205 writemmr(0x21CC, v1
);
209 static void blade_wait_engine(void)
211 while (readmmr(STA
) & 0xFA800000) ;
214 static void blade_fill_rect(u32 x
, u32 y
, u32 w
, u32 h
, u32 c
, u32 rop
)
217 writemmr(ROP
, rop
? 0x66 : ROP_S
);
218 writemmr(CMD
, 0x20000000 | 1 << 19 | 1 << 4 | 2 << 2);
220 writemmr(DR1
, point(x
, y
));
221 writemmr(DR2
, point(x
+ w
- 1, y
+ h
- 1));
224 static void blade_copy_rect(u32 x1
, u32 y1
, u32 x2
, u32 y2
, u32 w
, u32 h
)
229 s2
= point(x1
+ w
- 1, y1
+ h
- 1);
231 d2
= point(x2
+ w
- 1, y2
+ h
- 1);
233 if ((y1
> y2
) || ((y1
== y2
) && (x1
> x2
)))
236 writemmr(ROP
, ROP_S
);
237 writemmr(CMD
, 0xE0000000 | 1 << 19 | 1 << 4 | 1 << 2 | direction
);
239 writemmr(SR1
, direction
? s2
: s1
);
240 writemmr(SR2
, direction
? s1
: s2
);
241 writemmr(DR1
, direction
? d2
: d1
);
242 writemmr(DR2
, direction
? d1
: d2
);
245 static struct accel_switch accel_blade
= {
253 * BladeXP specific acceleration functions
257 #define masked_point(x, y) ((y & 0xffff)<<16|(x & 0xffff))
259 static void xp_init_accel(int pitch
, int bpp
)
279 switch (pitch
<< (bpp
>> 3)) {
315 writemmr(0x2154, v1
);
316 writemmr(0x2150, v1
);
320 static void xp_wait_engine(void)
328 busy
= t_inb(STA
) & 0x80;
332 if (count
== 10000000) {
338 t_outb(0x00, 0x2120);
345 static void xp_fill_rect(u32 x
, u32 y
, u32 w
, u32 h
, u32 c
, u32 rop
)
347 writemmr(0x2127, ROP_P
);
349 writemmr(0x2128, 0x4000);
350 writemmr(0x2140, masked_point(h
, w
));
351 writemmr(0x2138, masked_point(y
, x
));
352 t_outb(0x01, 0x2124);
353 t_outb(eng_oper
, 0x2125);
356 static void xp_copy_rect(u32 x1
, u32 y1
, u32 x2
, u32 y2
, u32 w
, u32 h
)
359 u32 x1_tmp
, x2_tmp
, y1_tmp
, y2_tmp
;
363 if ((x1
< x2
) && (y1
== y2
)) {
381 writemmr(0x2128, direction
);
382 t_outb(ROP_S
, 0x2127);
383 writemmr(0x213C, masked_point(y1_tmp
, x1_tmp
));
384 writemmr(0x2138, masked_point(y2_tmp
, x2_tmp
));
385 writemmr(0x2140, masked_point(h
, w
));
386 t_outb(0x01, 0x2124);
389 static struct accel_switch accel_xp
= {
397 * Image specific acceleration functions
399 static void image_init_accel(int pitch
, int bpp
)
417 writemmr(0x2120, 0xF0000000);
418 writemmr(0x2120, 0x40000000 | tmp
);
419 writemmr(0x2120, 0x80000000);
420 writemmr(0x2144, 0x00000000);
421 writemmr(0x2148, 0x00000000);
422 writemmr(0x2150, 0x00000000);
423 writemmr(0x2154, 0x00000000);
424 writemmr(0x2120, 0x60000000 | (pitch
<< 16) | pitch
);
425 writemmr(0x216C, 0x00000000);
426 writemmr(0x2170, 0x00000000);
427 writemmr(0x217C, 0x00000000);
428 writemmr(0x2120, 0x10000000);
429 writemmr(0x2130, (2047 << 16) | 2047);
432 static void image_wait_engine(void)
434 while (readmmr(0x2164) & 0xF0000000) ;
437 static void image_fill_rect(u32 x
, u32 y
, u32 w
, u32 h
, u32 c
, u32 rop
)
439 writemmr(0x2120, 0x80000000);
440 writemmr(0x2120, 0x90000000 | ROP_S
);
444 writemmr(DR1
, point(x
, y
));
445 writemmr(DR2
, point(x
+ w
- 1, y
+ h
- 1));
447 writemmr(0x2124, 0x80000000 | 3 << 22 | 1 << 10 | 1 << 9);
450 static void image_copy_rect(u32 x1
, u32 y1
, u32 x2
, u32 y2
, u32 w
, u32 h
)
455 s2
= point(x1
+ w
- 1, y1
+ h
- 1);
457 d2
= point(x2
+ w
- 1, y2
+ h
- 1);
459 if ((y1
> y2
) || ((y1
== y2
) && (x1
> x2
)))
462 writemmr(0x2120, 0x80000000);
463 writemmr(0x2120, 0x90000000 | ROP_S
);
465 writemmr(SR1
, direction
? s2
: s1
);
466 writemmr(SR2
, direction
? s1
: s2
);
467 writemmr(DR1
, direction
? d2
: d1
);
468 writemmr(DR2
, direction
? d1
: d2
);
469 writemmr(0x2124, 0x80000000 | 1 << 22 | 1 << 10 | 1 << 7 | direction
);
472 static struct accel_switch accel_image
= {
480 * Accel functions called by the upper layers
482 #ifdef CONFIG_FB_TRIDENT_ACCEL
483 static void tridentfb_fillrect(struct fb_info
*info
,
484 const struct fb_fillrect
*fr
)
486 int bpp
= info
->var
.bits_per_pixel
;
497 col
= ((u32
*)(info
->pseudo_palette
))[fr
->color
];
500 col
= ((u32
*)(info
->pseudo_palette
))[fr
->color
];
504 acc
->fill_rect(fr
->dx
, fr
->dy
, fr
->width
, fr
->height
, col
, fr
->rop
);
507 static void tridentfb_copyarea(struct fb_info
*info
,
508 const struct fb_copyarea
*ca
)
510 acc
->copy_rect(ca
->sx
, ca
->sy
, ca
->dx
, ca
->dy
, ca
->width
, ca
->height
);
513 #else /* !CONFIG_FB_TRIDENT_ACCEL */
514 #define tridentfb_fillrect cfb_fillrect
515 #define tridentfb_copyarea cfb_copyarea
516 #endif /* CONFIG_FB_TRIDENT_ACCEL */
520 * Hardware access functions
523 static inline unsigned char read3X4(int reg
)
525 struct tridentfb_par
*par
= (struct tridentfb_par
*)fb_info
.par
;
526 writeb(reg
, par
->io_virt
+ CRT
+ 4);
527 return readb(par
->io_virt
+ CRT
+ 5);
530 static inline void write3X4(int reg
, unsigned char val
)
532 struct tridentfb_par
*par
= (struct tridentfb_par
*)fb_info
.par
;
533 writeb(reg
, par
->io_virt
+ CRT
+ 4);
534 writeb(val
, par
->io_virt
+ CRT
+ 5);
537 static inline unsigned char read3C4(int reg
)
543 static inline void write3C4(int reg
, unsigned char val
)
549 static inline unsigned char read3CE(int reg
)
555 static inline void writeAttr(int reg
, unsigned char val
)
557 readb(((struct tridentfb_par
*)fb_info
.par
)->io_virt
+ CRT
+ 0x0A); /* flip-flop to index */
562 static inline void write3CE(int reg
, unsigned char val
)
568 static void enable_mmio(void)
574 /* Unprotect registers */
575 outb(NewMode1
, 0x3C4);
580 outb(inb(0x3D5) | 0x01, 0x3D5);
583 static void disable_mmio(void)
589 /* Unprotect registers */
590 t_outb(NewMode1
, 0x3C4);
594 t_outb(PCIReg
, 0x3D4);
595 t_outb(t_inb(0x3D5) & ~0x01, 0x3D5);
598 #define crtc_unlock() write3X4(CRTVSyncEnd, read3X4(CRTVSyncEnd) & 0x7F)
600 /* Return flat panel's maximum x resolution */
601 static int __devinit
get_nativex(void)
608 tmp
= (read3CE(VertStretch
) >> 4) & 3;
629 output("%dx%d flat panel found\n", x
, y
);
634 static void set_lwidth(int width
)
636 write3X4(Offset
, width
& 0xFF);
638 (read3X4(AddColReg
) & 0xCF) | ((width
& 0x300) >> 4));
641 /* For resolutions smaller than FP resolution stretch */
642 static void screen_stretch(void)
644 if (chip_id
!= CYBERBLADEXPAi1
)
645 write3CE(BiosReg
, 0);
647 write3CE(BiosReg
, 8);
648 write3CE(VertStretch
, (read3CE(VertStretch
) & 0x7C) | 1);
649 write3CE(HorStretch
, (read3CE(HorStretch
) & 0x7C) | 1);
652 /* For resolutions smaller than FP resolution center */
653 static void screen_center(void)
655 write3CE(VertStretch
, (read3CE(VertStretch
) & 0x7C) | 0x80);
656 write3CE(HorStretch
, (read3CE(HorStretch
) & 0x7C) | 0x80);
659 /* Address of first shown pixel in display memory */
660 static void set_screen_start(int base
)
662 write3X4(StartAddrLow
, base
& 0xFF);
663 write3X4(StartAddrHigh
, (base
& 0xFF00) >> 8);
664 write3X4(CRTCModuleTest
,
665 (read3X4(CRTCModuleTest
) & 0xDF) | ((base
& 0x10000) >> 11));
667 (read3X4(CRTHiOrd
) & 0xF8) | ((base
& 0xE0000) >> 17));
670 /* Use 20.12 fixed-point for NTSC value and frequency calculation */
671 #define calc_freq(n, m, k) ( ((unsigned long)0xE517 * (n + 8) / ((m + 2) * (1 << k))) >> 12 )
673 /* Set dotclock frequency */
674 static void set_vclk(int freq
)
678 unsigned char lo
= 0, hi
= 0;
681 for (k
= 2; k
>= 0; k
--)
682 for (m
= 0; m
< 63; m
++)
683 for (n
= 0; n
< 128; n
++) {
684 fi
= calc_freq(n
, m
, k
);
685 if ((di
= abs(fi
- freq
)) < d
) {
693 write3C4(ClockHigh
, hi
);
694 write3C4(ClockLow
, lo
);
699 debug("VCLK = %X %X\n", hi
, lo
);
702 /* Set number of lines for flat panels*/
703 static void set_number_of_lines(int lines
)
705 int tmp
= read3CE(CyberEnhance
) & 0x8F;
708 else if (lines
> 768)
710 else if (lines
> 600)
712 else if (lines
> 480)
714 write3CE(CyberEnhance
, tmp
);
718 * If we see that FP is active we assume we have one.
719 * Otherwise we have a CRT display.User can override.
721 static unsigned int __devinit
get_displaytype(void)
725 if (crt
|| !chipcyber
)
727 return (read3CE(FPConfig
) & 0x10) ? DISPLAY_FP
: DISPLAY_CRT
;
730 /* Try detecting the video memory size */
731 static unsigned int __devinit
get_memsize(void)
733 unsigned char tmp
, tmp2
;
736 /* If memory size provided by user */
745 tmp
= read3X4(SPR
) & 0x0F;
761 k
= 10 * Mb
; /* XP */
767 k
= 12 * Mb
; /* XP */
770 k
= 14 * Mb
; /* XP */
773 k
= 16 * Mb
; /* XP */
777 tmp2
= read3C4(0xC1);
807 output("framebuffer size = %d Kb\n", k
/ Kb
);
811 /* See if we can handle the video mode described in var */
812 static int tridentfb_check_var(struct fb_var_screeninfo
*var
,
813 struct fb_info
*info
)
815 int bpp
= var
->bits_per_pixel
;
818 /* check color depth */
820 bpp
= var
->bits_per_pixel
= 32;
821 /* check whether resolution fits on panel and in memory */
822 if (flatpanel
&& nativex
&& var
->xres
> nativex
)
824 if (var
->xres
* var
->yres_virtual
* bpp
/ 8 > info
->fix
.smem_len
)
830 var
->green
.offset
= 0;
831 var
->blue
.offset
= 0;
833 var
->green
.length
= 6;
834 var
->blue
.length
= 6;
837 var
->red
.offset
= 11;
838 var
->green
.offset
= 5;
839 var
->blue
.offset
= 0;
841 var
->green
.length
= 6;
842 var
->blue
.length
= 5;
845 var
->red
.offset
= 16;
846 var
->green
.offset
= 8;
847 var
->blue
.offset
= 0;
849 var
->green
.length
= 8;
850 var
->blue
.length
= 8;
861 /* Pan the display */
862 static int tridentfb_pan_display(struct fb_var_screeninfo
*var
,
863 struct fb_info
*info
)
868 offset
= (var
->xoffset
+ (var
->yoffset
* var
->xres
))
869 * var
->bits_per_pixel
/ 32;
870 info
->var
.xoffset
= var
->xoffset
;
871 info
->var
.yoffset
= var
->yoffset
;
872 set_screen_start(offset
);
877 #define shadowmode_on() write3CE(CyberControl, read3CE(CyberControl) | 0x81)
878 #define shadowmode_off() write3CE(CyberControl, read3CE(CyberControl) & 0x7E)
880 /* Set the hardware to the requested video mode */
881 static int tridentfb_set_par(struct fb_info
*info
)
883 struct tridentfb_par
*par
= (struct tridentfb_par
*)(info
->par
);
884 u32 htotal
, hdispend
, hsyncstart
, hsyncend
, hblankstart
, hblankend
;
885 u32 vtotal
, vdispend
, vsyncstart
, vsyncend
, vblankstart
, vblankend
;
886 struct fb_var_screeninfo
*var
= &info
->var
;
887 int bpp
= var
->bits_per_pixel
;
890 hdispend
= var
->xres
/ 8 - 1;
891 hsyncstart
= (var
->xres
+ var
->right_margin
) / 8;
892 hsyncend
= var
->hsync_len
/ 8;
894 (var
->xres
+ var
->left_margin
+ var
->right_margin
+
895 var
->hsync_len
) / 8 - 10;
896 hblankstart
= hdispend
+ 1;
897 hblankend
= htotal
+ 5;
899 vdispend
= var
->yres
- 1;
900 vsyncstart
= var
->yres
+ var
->lower_margin
;
901 vsyncend
= var
->vsync_len
;
902 vtotal
= var
->upper_margin
+ vsyncstart
+ vsyncend
- 2;
903 vblankstart
= var
->yres
;
904 vblankend
= vtotal
+ 2;
908 write3CE(CyberControl
, 8);
910 if (flatpanel
&& var
->xres
< nativex
) {
912 * on flat panels with native size larger
913 * than requested resolution decide whether
914 * we stretch or center
927 write3CE(CyberControl
, 8);
930 /* vertical timing values */
931 write3X4(CRTVTotal
, vtotal
& 0xFF);
932 write3X4(CRTVDispEnd
, vdispend
& 0xFF);
933 write3X4(CRTVSyncStart
, vsyncstart
& 0xFF);
934 write3X4(CRTVSyncEnd
, (vsyncend
& 0x0F));
935 write3X4(CRTVBlankStart
, vblankstart
& 0xFF);
936 write3X4(CRTVBlankEnd
, 0 /* p->vblankend & 0xFF */ );
938 /* horizontal timing values */
939 write3X4(CRTHTotal
, htotal
& 0xFF);
940 write3X4(CRTHDispEnd
, hdispend
& 0xFF);
941 write3X4(CRTHSyncStart
, hsyncstart
& 0xFF);
942 write3X4(CRTHSyncEnd
, (hsyncend
& 0x1F) | ((hblankend
& 0x20) << 2));
943 write3X4(CRTHBlankStart
, hblankstart
& 0xFF);
944 write3X4(CRTHBlankEnd
, 0 /* (p->hblankend & 0x1F) */ );
946 /* higher bits of vertical timing values */
948 if (vtotal
& 0x100) tmp
|= 0x01;
949 if (vdispend
& 0x100) tmp
|= 0x02;
950 if (vsyncstart
& 0x100) tmp
|= 0x04;
951 if (vblankstart
& 0x100) tmp
|= 0x08;
953 if (vtotal
& 0x200) tmp
|= 0x20;
954 if (vdispend
& 0x200) tmp
|= 0x40;
955 if (vsyncstart
& 0x200) tmp
|= 0x80;
956 write3X4(CRTOverflow
, tmp
);
958 tmp
= read3X4(CRTHiOrd
) | 0x08; /* line compare bit 10 */
959 if (vtotal
& 0x400) tmp
|= 0x80;
960 if (vblankstart
& 0x400) tmp
|= 0x40;
961 if (vsyncstart
& 0x400) tmp
|= 0x20;
962 if (vdispend
& 0x400) tmp
|= 0x10;
963 write3X4(CRTHiOrd
, tmp
);
966 if (htotal
& 0x800) tmp
|= 0x800 >> 11;
967 if (hblankstart
& 0x800) tmp
|= 0x800 >> 7;
968 write3X4(HorizOverflow
, tmp
);
971 if (vblankstart
& 0x200) tmp
|= 0x20;
972 //FIXME if (info->var.vmode & FB_VMODE_DOUBLE) tmp |= 0x80; /* double scan for 200 line modes */
973 write3X4(CRTMaxScanLine
, tmp
);
975 write3X4(CRTLineCompare
, 0xFF);
976 write3X4(CRTPRowScan
, 0);
977 write3X4(CRTModeControl
, 0xC3);
979 write3X4(LinearAddReg
, 0x20); /* enable linear addressing */
981 tmp
= (info
->var
.vmode
& FB_VMODE_INTERLACED
) ? 0x84 : 0x80;
982 write3X4(CRTCModuleTest
, tmp
); /* enable access extended memory */
984 write3X4(GraphEngReg
, 0x80); /* enable GE for text acceleration */
986 #ifdef CONFIG_FB_TRIDENT_ACCEL
987 acc
->init_accel(info
->var
.xres
, bpp
);
1005 write3X4(PixelBusReg
, tmp
);
1010 write3X4(DRAMControl
, tmp
); /* both IO, linear enable */
1012 write3X4(InterfaceSel
, read3X4(InterfaceSel
) | 0x40);
1013 write3X4(Performance
, 0x92);
1014 write3X4(PCIReg
, 0x07); /* MMIO & PCI read and write burst enable */
1016 /* convert from picoseconds to MHz */
1017 par
->vclk
= 1000000 / info
->var
.pixclock
;
1020 set_vclk(par
->vclk
);
1023 write3C4(1, 1); /* set char clock 8 dots wide */
1024 write3C4(2, 0x0F); /* enable 4 maps because needed in chain4 mode */
1026 write3C4(4, 0x0E); /* memory mode enable bitmaps ?? */
1028 write3CE(MiscExtFunc
, (bpp
== 32) ? 0x1A : 0x12); /* divide clock by 2 if 32bpp */
1029 /* chain4 mode display and CPU path */
1030 write3CE(0x5, 0x40); /* no CGA compat, allow 256 col */
1031 write3CE(0x6, 0x05); /* graphics mode */
1032 write3CE(0x7, 0x0F); /* planes? */
1034 if (chip_id
== CYBERBLADEXPAi1
) {
1035 /* This fixes snow-effect in 32 bpp */
1036 write3X4(CRTHSyncStart
, 0x84);
1039 writeAttr(0x10, 0x41); /* graphics mode and support 256 color modes */
1040 writeAttr(0x12, 0x0F); /* planes */
1041 writeAttr(0x13, 0); /* horizontal pel panning */
1044 for (tmp
= 0; tmp
< 0x10; tmp
++)
1045 writeAttr(tmp
, tmp
);
1046 readb(par
->io_virt
+ CRT
+ 0x0A); /* flip-flop to index */
1047 t_outb(0x20, 0x3C0); /* enable attr */
1074 set_number_of_lines(info
->var
.yres
);
1075 set_lwidth(info
->var
.xres
* bpp
/ (4 * 16));
1076 info
->fix
.visual
= (bpp
== 8) ? FB_VISUAL_PSEUDOCOLOR
: FB_VISUAL_TRUECOLOR
;
1077 info
->fix
.line_length
= info
->var
.xres
* (bpp
>> 3);
1078 info
->cmap
.len
= (bpp
== 8) ? 256 : 16;
1083 /* Set one color register */
1084 static int tridentfb_setcolreg(unsigned regno
, unsigned red
, unsigned green
,
1085 unsigned blue
, unsigned transp
,
1086 struct fb_info
*info
)
1088 int bpp
= info
->var
.bits_per_pixel
;
1090 if (regno
>= info
->cmap
.len
)
1094 t_outb(0xFF, 0x3C6);
1095 t_outb(regno
, 0x3C8);
1097 t_outb(red
>> 10, 0x3C9);
1098 t_outb(green
>> 10, 0x3C9);
1099 t_outb(blue
>> 10, 0x3C9);
1101 } else if (regno
< 16) {
1102 if (bpp
== 16) { /* RGB 565 */
1105 col
= (red
& 0xF800) | ((green
& 0xFC00) >> 5) |
1106 ((blue
& 0xF800) >> 11);
1108 ((u32
*)(info
->pseudo_palette
))[regno
] = col
;
1109 } else if (bpp
== 32) /* ARGB 8888 */
1110 ((u32
*)info
->pseudo_palette
)[regno
] =
1111 ((transp
& 0xFF00) << 16) |
1112 ((red
& 0xFF00) << 8) |
1113 ((green
& 0xFF00)) |
1114 ((blue
& 0xFF00) >> 8);
1117 /* debug("exit\n"); */
1121 /* Try blanking the screen.For flat panels it does nothing */
1122 static int tridentfb_blank(int blank_mode
, struct fb_info
*info
)
1124 unsigned char PMCont
, DPMSCont
;
1129 t_outb(0x04, 0x83C8); /* Read DPMS Control */
1130 PMCont
= t_inb(0x83C6) & 0xFC;
1131 DPMSCont
= read3CE(PowerStatus
) & 0xFC;
1132 switch (blank_mode
) {
1133 case FB_BLANK_UNBLANK
:
1134 /* Screen: On, HSync: On, VSync: On */
1135 case FB_BLANK_NORMAL
:
1136 /* Screen: Off, HSync: On, VSync: On */
1140 case FB_BLANK_HSYNC_SUSPEND
:
1141 /* Screen: Off, HSync: Off, VSync: On */
1145 case FB_BLANK_VSYNC_SUSPEND
:
1146 /* Screen: Off, HSync: On, VSync: Off */
1150 case FB_BLANK_POWERDOWN
:
1151 /* Screen: Off, HSync: Off, VSync: Off */
1157 write3CE(PowerStatus
, DPMSCont
);
1159 t_outb(PMCont
, 0x83C6);
1163 /* let fbcon do a softblank for us */
1164 return (blank_mode
== FB_BLANK_NORMAL
) ? 1 : 0;
1167 static struct fb_ops tridentfb_ops
= {
1168 .owner
= THIS_MODULE
,
1169 .fb_setcolreg
= tridentfb_setcolreg
,
1170 .fb_pan_display
= tridentfb_pan_display
,
1171 .fb_blank
= tridentfb_blank
,
1172 .fb_check_var
= tridentfb_check_var
,
1173 .fb_set_par
= tridentfb_set_par
,
1174 .fb_fillrect
= tridentfb_fillrect
,
1175 .fb_copyarea
= tridentfb_copyarea
,
1176 .fb_imageblit
= cfb_imageblit
,
1179 static int __devinit
trident_pci_probe(struct pci_dev
* dev
,
1180 const struct pci_device_id
* id
)
1183 unsigned char revision
;
1185 err
= pci_enable_device(dev
);
1189 chip_id
= id
->device
;
1191 if (chip_id
== CYBERBLADEi1
)
1192 output("*** Please do use cyblafb, Cyberblade/i1 support "
1193 "will soon be removed from tridentfb!\n");
1196 /* If PCI id is 0x9660 then further detect chip type */
1198 if (chip_id
== TGUI9660
) {
1199 outb(RevisionID
, 0x3C4);
1200 revision
= inb(0x3C5);
1205 chip_id
= CYBER9397
;
1208 chip_id
= CYBER9397DVD
;
1217 chip_id
= CYBER9385
;
1220 chip_id
= CYBER9382
;
1223 chip_id
= CYBER9388
;
1230 chip3D
= is3Dchip(chip_id
);
1231 chipcyber
= iscyber(chip_id
);
1233 if (is_xp(chip_id
)) {
1235 } else if (is_blade(chip_id
)) {
1241 /* acceleration is on by default for 3D chips */
1242 defaultaccel
= chip3D
&& !noaccel
;
1244 fb_info
.par
= &default_par
;
1246 /* setup MMIO region */
1247 tridentfb_fix
.mmio_start
= pci_resource_start(dev
, 1);
1248 tridentfb_fix
.mmio_len
= chip3D
? 0x20000 : 0x10000;
1250 if (!request_mem_region(tridentfb_fix
.mmio_start
, tridentfb_fix
.mmio_len
, "tridentfb")) {
1251 debug("request_region failed!\n");
1255 default_par
.io_virt
= ioremap_nocache(tridentfb_fix
.mmio_start
, tridentfb_fix
.mmio_len
);
1257 if (!default_par
.io_virt
) {
1258 debug("ioremap failed\n");
1265 /* setup framebuffer memory */
1266 tridentfb_fix
.smem_start
= pci_resource_start(dev
, 0);
1267 tridentfb_fix
.smem_len
= get_memsize();
1269 if (!request_mem_region(tridentfb_fix
.smem_start
, tridentfb_fix
.smem_len
, "tridentfb")) {
1270 debug("request_mem_region failed!\n");
1276 fb_info
.screen_base
= ioremap_nocache(tridentfb_fix
.smem_start
,
1277 tridentfb_fix
.smem_len
);
1279 if (!fb_info
.screen_base
) {
1280 debug("ioremap failed\n");
1285 output("%s board found\n", pci_name(dev
));
1286 displaytype
= get_displaytype();
1289 nativex
= get_nativex();
1291 fb_info
.fix
= tridentfb_fix
;
1292 fb_info
.fbops
= &tridentfb_ops
;
1295 fb_info
.flags
= FBINFO_DEFAULT
| FBINFO_HWACCEL_YPAN
;
1296 #ifdef CONFIG_FB_TRIDENT_ACCEL
1297 fb_info
.flags
|= FBINFO_HWACCEL_COPYAREA
| FBINFO_HWACCEL_FILLRECT
;
1299 fb_info
.pseudo_palette
= pseudo_pal
;
1301 if (!fb_find_mode(&default_var
, &fb_info
,
1302 mode_option
, NULL
, 0, NULL
, bpp
)) {
1306 err
= fb_alloc_cmap(&fb_info
.cmap
, 256, 0);
1310 if (defaultaccel
&& acc
)
1311 default_var
.accel_flags
|= FB_ACCELF_TEXT
;
1313 default_var
.accel_flags
&= ~FB_ACCELF_TEXT
;
1314 default_var
.activate
|= FB_ACTIVATE_NOW
;
1315 fb_info
.var
= default_var
;
1316 fb_info
.device
= &dev
->dev
;
1317 if (register_framebuffer(&fb_info
) < 0) {
1318 printk(KERN_ERR
"tridentfb: could not register Trident framebuffer\n");
1319 fb_dealloc_cmap(&fb_info
.cmap
);
1323 output("fb%d: %s frame buffer device %dx%d-%dbpp\n",
1324 fb_info
.node
, fb_info
.fix
.id
, default_var
.xres
,
1325 default_var
.yres
, default_var
.bits_per_pixel
);
1329 if (fb_info
.screen_base
)
1330 iounmap(fb_info
.screen_base
);
1331 release_mem_region(tridentfb_fix
.smem_start
, tridentfb_fix
.smem_len
);
1334 if (default_par
.io_virt
)
1335 iounmap(default_par
.io_virt
);
1336 release_mem_region(tridentfb_fix
.mmio_start
, tridentfb_fix
.mmio_len
);
1340 static void __devexit
trident_pci_remove(struct pci_dev
*dev
)
1342 struct tridentfb_par
*par
= (struct tridentfb_par
*)fb_info
.par
;
1343 unregister_framebuffer(&fb_info
);
1344 iounmap(par
->io_virt
);
1345 iounmap(fb_info
.screen_base
);
1346 release_mem_region(tridentfb_fix
.smem_start
, tridentfb_fix
.smem_len
);
1347 release_mem_region(tridentfb_fix
.mmio_start
, tridentfb_fix
.mmio_len
);
1350 /* List of boards that we are trying to support */
1351 static struct pci_device_id trident_devices
[] = {
1352 {PCI_VENDOR_ID_TRIDENT
, BLADE3D
, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
1353 {PCI_VENDOR_ID_TRIDENT
, CYBERBLADEi7
, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
1354 {PCI_VENDOR_ID_TRIDENT
, CYBERBLADEi7D
, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
1355 {PCI_VENDOR_ID_TRIDENT
, CYBERBLADEi1
, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
1356 {PCI_VENDOR_ID_TRIDENT
, CYBERBLADEi1D
, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
1357 {PCI_VENDOR_ID_TRIDENT
, CYBERBLADEAi1
, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
1358 {PCI_VENDOR_ID_TRIDENT
, CYBERBLADEAi1D
, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
1359 {PCI_VENDOR_ID_TRIDENT
, CYBERBLADEE4
, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
1360 {PCI_VENDOR_ID_TRIDENT
, TGUI9660
, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
1361 {PCI_VENDOR_ID_TRIDENT
, IMAGE975
, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
1362 {PCI_VENDOR_ID_TRIDENT
, IMAGE985
, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
1363 {PCI_VENDOR_ID_TRIDENT
, CYBER9320
, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
1364 {PCI_VENDOR_ID_TRIDENT
, CYBER9388
, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
1365 {PCI_VENDOR_ID_TRIDENT
, CYBER9520
, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
1366 {PCI_VENDOR_ID_TRIDENT
, CYBER9525DVD
, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
1367 {PCI_VENDOR_ID_TRIDENT
, CYBER9397
, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
1368 {PCI_VENDOR_ID_TRIDENT
, CYBER9397DVD
, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
1369 {PCI_VENDOR_ID_TRIDENT
, CYBERBLADEXPAi1
, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
1370 {PCI_VENDOR_ID_TRIDENT
, CYBERBLADEXPm8
, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
1371 {PCI_VENDOR_ID_TRIDENT
, CYBERBLADEXPm16
, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
1375 MODULE_DEVICE_TABLE(pci
, trident_devices
);
1377 static struct pci_driver tridentfb_pci_driver
= {
1378 .name
= "tridentfb",
1379 .id_table
= trident_devices
,
1380 .probe
= trident_pci_probe
,
1381 .remove
= __devexit_p(trident_pci_remove
)
1385 * Parse user specified options (`video=trident:')
1387 * video=trident:800x600,bpp=16,noaccel
1390 static int __init
tridentfb_setup(char *options
)
1393 if (!options
|| !*options
)
1395 while ((opt
= strsep(&options
, ",")) != NULL
) {
1398 if (!strncmp(opt
, "noaccel", 7))
1400 else if (!strncmp(opt
, "fp", 2))
1401 displaytype
= DISPLAY_FP
;
1402 else if (!strncmp(opt
, "crt", 3))
1403 displaytype
= DISPLAY_CRT
;
1404 else if (!strncmp(opt
, "bpp=", 4))
1405 bpp
= simple_strtoul(opt
+ 4, NULL
, 0);
1406 else if (!strncmp(opt
, "center", 6))
1408 else if (!strncmp(opt
, "stretch", 7))
1410 else if (!strncmp(opt
, "memsize=", 8))
1411 memsize
= simple_strtoul(opt
+ 8, NULL
, 0);
1412 else if (!strncmp(opt
, "memdiff=", 8))
1413 memdiff
= simple_strtoul(opt
+ 8, NULL
, 0);
1414 else if (!strncmp(opt
, "nativex=", 8))
1415 nativex
= simple_strtoul(opt
+ 8, NULL
, 0);
1423 static int __init
tridentfb_init(void)
1426 char *option
= NULL
;
1428 if (fb_get_options("tridentfb", &option
))
1430 tridentfb_setup(option
);
1432 output("Trident framebuffer %s initializing\n", VERSION
);
1433 return pci_register_driver(&tridentfb_pci_driver
);
1436 static void __exit
tridentfb_exit(void)
1438 pci_unregister_driver(&tridentfb_pci_driver
);
1441 module_init(tridentfb_init
);
1442 module_exit(tridentfb_exit
);
1444 MODULE_AUTHOR("Jani Monoses <jani@iv.ro>");
1445 MODULE_DESCRIPTION("Framebuffer driver for Trident cards");
1446 MODULE_LICENSE("GPL");