5 * Author: Hannu Mallat <hmallat@cc.hut.fi>
7 * Copyright © 1999 Hannu Mallat
10 * Created : Thu Sep 23 18:17:43 1999, hmallat
11 * Last modified: Tue Nov 2 21:19:47 1999, hmallat
13 * I2C part copied from the i2c-voodoo3.c driver by:
14 * Frodo Looijaard <frodol@dds.nl>,
15 * Philip Edelbrock <phil@netroedge.com>,
16 * Ralph Metzler <rjkm@thp.uni-koeln.de>, and
17 * Mark D. Studebaker <mdsxyz123@yahoo.com>
19 * Lots of the information here comes from the Daryll Strauss' Banshee
20 * patches to the XF86 server, and the rest comes from the 3dfx
21 * Banshee specification. I'm very much indebted to Daryll for his
22 * work on the X server.
24 * Voodoo3 support was contributed Harold Oga. Lots of additions
25 * (proper acceleration, 24 bpp, hardware cursor) and bug fixes by Attila
26 * Kesmarki. Thanks guys!
28 * Voodoo1 and Voodoo2 support aren't relevant to this driver as they
29 * behave very differently from the Voodoo3/4/5. For anyone wanting to
30 * use frame buffer on the Voodoo1/2, see the sstfb driver (which is
31 * located at http://www.sourceforge.net/projects/sstfb).
33 * While I _am_ grateful to 3Dfx for releasing the specs for Banshee,
34 * I do wish the next version is a bit more complete. Without the XF86
35 * patches I couldn't have gotten even this far... for instance, the
36 * extensions to the VGA register set go completely unmentioned in the
37 * spec! Also, lots of references are made to the 'SST core', but no
38 * spec is publicly available, AFAIK.
40 * The structure of this driver comes pretty much from the Permedia
41 * driver by Ilario Nardinocchi, which in turn is based on skeletonfb.
44 * - multihead support (basically need to support an array of fb_infos)
45 * - support other architectures (PPC, Alpha); does the fact that the VGA
46 * core can be accessed only thru I/O (not memory mapped) complicate
51 * 0.1.4 (released 2002-05-28) ported over to new fbdev api by James Simmons
53 * 0.1.3 (released 1999-11-02) added Attila's panning support, code
54 * reorg, hwcursor address page size alignment
55 * (for mmaping both frame buffer and regs),
56 * and my changes to get rid of hardcoded
57 * VGA i/o register locations (uses PCI
58 * configuration info now)
59 * 0.1.2 (released 1999-10-19) added Attila Kesmarki's bug fixes and
61 * 0.1.1 (released 1999-10-07) added Voodoo3 support by Harold Oga.
62 * 0.1.0 (released 1999-10-06) initial version
66 #include <linux/module.h>
67 #include <linux/kernel.h>
68 #include <linux/errno.h>
69 #include <linux/string.h>
71 #include <linux/slab.h>
73 #include <linux/init.h>
74 #include <linux/pci.h>
77 #include <video/tdfx.h>
79 #define DPRINTK(a, b...) pr_debug("fb: %s: " a, __func__ , ## b)
84 /* duplicate asm/mtrr.h defines to work on archs without mtrr */
85 #define MTRR_TYPE_WRCOMB 1
87 static inline int mtrr_add(unsigned long base
, unsigned long size
,
88 unsigned int type
, char increment
)
92 static inline int mtrr_del(int reg
, unsigned long base
,
99 #define BANSHEE_MAX_PIXCLOCK 270000
100 #define VOODOO3_MAX_PIXCLOCK 300000
101 #define VOODOO5_MAX_PIXCLOCK 350000
103 static struct fb_fix_screeninfo tdfx_fix __devinitdata
= {
104 .type
= FB_TYPE_PACKED_PIXELS
,
105 .visual
= FB_VISUAL_PSEUDOCOLOR
,
108 .accel
= FB_ACCEL_3DFX_BANSHEE
111 static struct fb_var_screeninfo tdfx_var __devinitdata
= {
112 /* "640x480, 8 bpp @ 60 Hz */
116 .yres_virtual
= 1024,
121 .activate
= FB_ACTIVATE_NOW
,
124 .accel_flags
= FB_ACCELF_TEXT
,
132 .vmode
= FB_VMODE_NONINTERLACED
136 * PCI driver prototypes
138 static int __devinit
tdfxfb_probe(struct pci_dev
*pdev
,
139 const struct pci_device_id
*id
);
140 static void __devexit
tdfxfb_remove(struct pci_dev
*pdev
);
142 static struct pci_device_id tdfxfb_id_table
[] = {
143 { PCI_VENDOR_ID_3DFX
, PCI_DEVICE_ID_3DFX_BANSHEE
,
144 PCI_ANY_ID
, PCI_ANY_ID
, PCI_BASE_CLASS_DISPLAY
<< 16,
146 { PCI_VENDOR_ID_3DFX
, PCI_DEVICE_ID_3DFX_VOODOO3
,
147 PCI_ANY_ID
, PCI_ANY_ID
, PCI_BASE_CLASS_DISPLAY
<< 16,
149 { PCI_VENDOR_ID_3DFX
, PCI_DEVICE_ID_3DFX_VOODOO5
,
150 PCI_ANY_ID
, PCI_ANY_ID
, PCI_BASE_CLASS_DISPLAY
<< 16,
155 static struct pci_driver tdfxfb_driver
= {
157 .id_table
= tdfxfb_id_table
,
158 .probe
= tdfxfb_probe
,
159 .remove
= __devexit_p(tdfxfb_remove
),
162 MODULE_DEVICE_TABLE(pci
, tdfxfb_id_table
);
168 static int nowrap
= 1; /* not implemented (yet) */
169 static int hwcursor
= 1;
170 static char *mode_option __devinitdata
;
172 static int nomtrr __devinitdata
;
174 /* -------------------------------------------------------------------------
175 * Hardware-specific funcions
176 * ------------------------------------------------------------------------- */
178 static inline u8
vga_inb(struct tdfx_par
*par
, u32 reg
)
180 return inb(par
->iobase
+ reg
- 0x300);
183 static inline void vga_outb(struct tdfx_par
*par
, u32 reg
, u8 val
)
185 outb(val
, par
->iobase
+ reg
- 0x300);
188 static inline void gra_outb(struct tdfx_par
*par
, u32 idx
, u8 val
)
190 vga_outb(par
, GRA_I
, idx
);
192 vga_outb(par
, GRA_D
, val
);
196 static inline void seq_outb(struct tdfx_par
*par
, u32 idx
, u8 val
)
198 vga_outb(par
, SEQ_I
, idx
);
200 vga_outb(par
, SEQ_D
, val
);
204 static inline u8
seq_inb(struct tdfx_par
*par
, u32 idx
)
206 vga_outb(par
, SEQ_I
, idx
);
208 return vga_inb(par
, SEQ_D
);
211 static inline void crt_outb(struct tdfx_par
*par
, u32 idx
, u8 val
)
213 vga_outb(par
, CRT_I
, idx
);
215 vga_outb(par
, CRT_D
, val
);
219 static inline u8
crt_inb(struct tdfx_par
*par
, u32 idx
)
221 vga_outb(par
, CRT_I
, idx
);
223 return vga_inb(par
, CRT_D
);
226 static inline void att_outb(struct tdfx_par
*par
, u32 idx
, u8 val
)
230 tmp
= vga_inb(par
, IS1_R
);
231 vga_outb(par
, ATT_IW
, idx
);
232 vga_outb(par
, ATT_IW
, val
);
235 static inline void vga_disable_video(struct tdfx_par
*par
)
239 s
= seq_inb(par
, 0x01) | 0x20;
240 seq_outb(par
, 0x00, 0x01);
241 seq_outb(par
, 0x01, s
);
242 seq_outb(par
, 0x00, 0x03);
245 static inline void vga_enable_video(struct tdfx_par
*par
)
249 s
= seq_inb(par
, 0x01) & 0xdf;
250 seq_outb(par
, 0x00, 0x01);
251 seq_outb(par
, 0x01, s
);
252 seq_outb(par
, 0x00, 0x03);
255 static inline void vga_enable_palette(struct tdfx_par
*par
)
259 vga_outb(par
, ATT_IW
, 0x20);
262 static inline u32
tdfx_inl(struct tdfx_par
*par
, unsigned int reg
)
264 return readl(par
->regbase_virt
+ reg
);
267 static inline void tdfx_outl(struct tdfx_par
*par
, unsigned int reg
, u32 val
)
269 writel(val
, par
->regbase_virt
+ reg
);
272 static inline void banshee_make_room(struct tdfx_par
*par
, int size
)
274 /* Note: The Voodoo3's onboard FIFO has 32 slots. This loop
275 * won't quit if you ask for more. */
276 while ((tdfx_inl(par
, STATUS
) & 0x1f) < size
- 1)
280 static int banshee_wait_idle(struct fb_info
*info
)
282 struct tdfx_par
*par
= info
->par
;
285 banshee_make_room(par
, 1);
286 tdfx_outl(par
, COMMAND_3D
, COMMAND_3D_NOP
);
289 if ((tdfx_inl(par
, STATUS
) & STATUS_BUSY
) == 0)
297 * Set the color of a palette entry in 8bpp mode
299 static inline void do_setpalentry(struct tdfx_par
*par
, unsigned regno
, u32 c
)
301 banshee_make_room(par
, 2);
302 tdfx_outl(par
, DACADDR
, regno
);
303 /* read after write makes it working */
304 tdfx_inl(par
, DACADDR
);
305 tdfx_outl(par
, DACDATA
, c
);
308 static u32
do_calc_pll(int freq
, int *freq_out
)
310 int m
, n
, k
, best_m
, best_n
, best_k
, best_error
;
314 best_n
= best_m
= best_k
= 0;
316 for (k
= 3; k
>= 0; k
--) {
317 for (m
= 63; m
>= 0; m
--) {
319 * Estimate value of n that produces target frequency
320 * with current m and k
322 int n_estimated
= ((freq
* (m
+ 2) << k
) / fref
) - 2;
324 /* Search neighborhood of estimated n */
325 for (n
= max(0, n_estimated
);
326 n
<= min(255, n_estimated
+ 1);
329 * Calculate PLL freqency with current m, k and
332 int f
= (fref
* (n
+ 2) / (m
+ 2)) >> k
;
333 int error
= abs(f
- freq
);
336 * If this is the closest we've come to the
337 * target frequency then remember n, m and k
339 if (error
< best_error
) {
352 *freq_out
= (fref
* (n
+ 2) / (m
+ 2)) >> k
;
354 return (n
<< 8) | (m
<< 2) | k
;
357 static void do_write_regs(struct fb_info
*info
, struct banshee_reg
*reg
)
359 struct tdfx_par
*par
= info
->par
;
362 banshee_wait_idle(info
);
364 tdfx_outl(par
, MISCINIT1
, tdfx_inl(par
, MISCINIT1
) | 0x01);
366 crt_outb(par
, 0x11, crt_inb(par
, 0x11) & 0x7f); /* CRT unprotect */
368 banshee_make_room(par
, 3);
369 tdfx_outl(par
, VGAINIT1
, reg
->vgainit1
& 0x001FFFFF);
370 tdfx_outl(par
, VIDPROCCFG
, reg
->vidcfg
& ~0x00000001);
372 tdfx_outl(par
, PLLCTRL1
, reg
->mempll
);
373 tdfx_outl(par
, PLLCTRL2
, reg
->gfxpll
);
375 tdfx_outl(par
, PLLCTRL0
, reg
->vidpll
);
377 vga_outb(par
, MISC_W
, reg
->misc
[0x00] | 0x01);
379 for (i
= 0; i
< 5; i
++)
380 seq_outb(par
, i
, reg
->seq
[i
]);
382 for (i
= 0; i
< 25; i
++)
383 crt_outb(par
, i
, reg
->crt
[i
]);
385 for (i
= 0; i
< 9; i
++)
386 gra_outb(par
, i
, reg
->gra
[i
]);
388 for (i
= 0; i
< 21; i
++)
389 att_outb(par
, i
, reg
->att
[i
]);
391 crt_outb(par
, 0x1a, reg
->ext
[0]);
392 crt_outb(par
, 0x1b, reg
->ext
[1]);
394 vga_enable_palette(par
);
395 vga_enable_video(par
);
397 banshee_make_room(par
, 9);
398 tdfx_outl(par
, VGAINIT0
, reg
->vgainit0
);
399 tdfx_outl(par
, DACMODE
, reg
->dacmode
);
400 tdfx_outl(par
, VIDDESKSTRIDE
, reg
->stride
);
401 tdfx_outl(par
, HWCURPATADDR
, reg
->curspataddr
);
403 tdfx_outl(par
, VIDSCREENSIZE
, reg
->screensize
);
404 tdfx_outl(par
, VIDDESKSTART
, reg
->startaddr
);
405 tdfx_outl(par
, VIDPROCCFG
, reg
->vidcfg
);
406 tdfx_outl(par
, VGAINIT1
, reg
->vgainit1
);
407 tdfx_outl(par
, MISCINIT0
, reg
->miscinit0
);
409 banshee_make_room(par
, 8);
410 tdfx_outl(par
, SRCBASE
, reg
->startaddr
);
411 tdfx_outl(par
, DSTBASE
, reg
->startaddr
);
412 tdfx_outl(par
, COMMANDEXTRA_2D
, 0);
413 tdfx_outl(par
, CLIP0MIN
, 0);
414 tdfx_outl(par
, CLIP0MAX
, 0x0fff0fff);
415 tdfx_outl(par
, CLIP1MIN
, 0);
416 tdfx_outl(par
, CLIP1MAX
, 0x0fff0fff);
417 tdfx_outl(par
, SRCXY
, 0);
419 banshee_wait_idle(info
);
422 static unsigned long do_lfb_size(struct tdfx_par
*par
, unsigned short dev_id
)
424 u32 draminit0
= tdfx_inl(par
, DRAMINIT0
);
425 u32 draminit1
= tdfx_inl(par
, DRAMINIT1
);
427 int num_chips
= (draminit0
& DRAMINIT0_SGRAM_NUM
) ? 8 : 4;
428 int chip_size
; /* in MB */
429 int has_sgram
= draminit1
& DRAMINIT1_MEM_SDRAM
;
431 if (dev_id
< PCI_DEVICE_ID_3DFX_VOODOO5
) {
432 /* Banshee/Voodoo3 */
434 if (has_sgram
&& !(draminit0
& DRAMINIT0_SGRAM_TYPE
))
439 chip_size
= draminit0
& DRAMINIT0_SGRAM_TYPE_MASK
;
440 chip_size
= 1 << (chip_size
>> DRAMINIT0_SGRAM_TYPE_SHIFT
);
443 /* disable block writes for SDRAM */
444 miscinit1
= tdfx_inl(par
, MISCINIT1
);
445 miscinit1
|= has_sgram
? 0 : MISCINIT1_2DBLOCK_DIS
;
446 miscinit1
|= MISCINIT1_CLUT_INV
;
448 banshee_make_room(par
, 1);
449 tdfx_outl(par
, MISCINIT1
, miscinit1
);
450 return num_chips
* chip_size
* 1024l * 1024;
453 /* ------------------------------------------------------------------------- */
455 static int tdfxfb_check_var(struct fb_var_screeninfo
*var
, struct fb_info
*info
)
457 struct tdfx_par
*par
= info
->par
;
460 if (var
->bits_per_pixel
!= 8 && var
->bits_per_pixel
!= 16 &&
461 var
->bits_per_pixel
!= 24 && var
->bits_per_pixel
!= 32) {
462 DPRINTK("depth not supported: %u\n", var
->bits_per_pixel
);
466 if (var
->xres
!= var
->xres_virtual
)
467 var
->xres_virtual
= var
->xres
;
469 if (var
->yres
> var
->yres_virtual
)
470 var
->yres_virtual
= var
->yres
;
473 DPRINTK("xoffset not supported\n");
479 * Banshee doesn't support interlace, but Voodoo4/5 and probably
481 * no direct information about device id now?
482 * use max_pixclock for this...
484 if (((var
->vmode
& FB_VMODE_MASK
) == FB_VMODE_INTERLACED
) &&
485 (par
->max_pixclock
< VOODOO3_MAX_PIXCLOCK
)) {
486 DPRINTK("interlace not supported\n");
490 var
->xres
= (var
->xres
+ 15) & ~15; /* could sometimes be 8 */
491 lpitch
= var
->xres
* ((var
->bits_per_pixel
+ 7) >> 3);
493 if (var
->xres
< 320 || var
->xres
> 2048) {
494 DPRINTK("width not supported: %u\n", var
->xres
);
498 if (var
->yres
< 200 || var
->yres
> 2048) {
499 DPRINTK("height not supported: %u\n", var
->yres
);
503 if (lpitch
* var
->yres_virtual
> info
->fix
.smem_len
) {
504 var
->yres_virtual
= info
->fix
.smem_len
/ lpitch
;
505 if (var
->yres_virtual
< var
->yres
) {
506 DPRINTK("no memory for screen (%ux%ux%u)\n",
507 var
->xres
, var
->yres_virtual
,
508 var
->bits_per_pixel
);
513 if (PICOS2KHZ(var
->pixclock
) > par
->max_pixclock
) {
514 DPRINTK("pixclock too high (%ldKHz)\n",
515 PICOS2KHZ(var
->pixclock
));
519 var
->transp
.offset
= 0;
520 var
->transp
.length
= 0;
521 switch (var
->bits_per_pixel
) {
525 var
->green
= var
->red
;
526 var
->blue
= var
->red
;
529 var
->red
.offset
= 11;
531 var
->green
.offset
= 5;
532 var
->green
.length
= 6;
533 var
->blue
.offset
= 0;
534 var
->blue
.length
= 5;
537 var
->transp
.offset
= 24;
538 var
->transp
.length
= 8;
540 var
->red
.offset
= 16;
541 var
->green
.offset
= 8;
542 var
->blue
.offset
= 0;
543 var
->red
.length
= var
->green
.length
= var
->blue
.length
= 8;
549 var
->accel_flags
= FB_ACCELF_TEXT
;
551 DPRINTK("Checking graphics mode at %dx%d depth %d\n",
552 var
->xres
, var
->yres
, var
->bits_per_pixel
);
556 static int tdfxfb_set_par(struct fb_info
*info
)
558 struct tdfx_par
*par
= info
->par
;
559 u32 hdispend
= info
->var
.xres
;
560 u32 hsyncsta
= hdispend
+ info
->var
.right_margin
;
561 u32 hsyncend
= hsyncsta
+ info
->var
.hsync_len
;
562 u32 htotal
= hsyncend
+ info
->var
.left_margin
;
563 u32 hd
, hs
, he
, ht
, hbs
, hbe
;
564 u32 vd
, vs
, ve
, vt
, vbs
, vbe
;
565 struct banshee_reg reg
;
568 u32 cpp
= (info
->var
.bits_per_pixel
+ 7) >> 3;
570 memset(®
, 0, sizeof(reg
));
572 reg
.vidcfg
= VIDCFG_VIDPROC_ENABLE
| VIDCFG_DESK_ENABLE
|
574 ((cpp
- 1) << VIDCFG_PIXFMT_SHIFT
) |
575 (cpp
!= 1 ? VIDCFG_CLUT_BYPASS
: 0);
578 freq
= PICOS2KHZ(info
->var
.pixclock
);
580 reg
.vidcfg
&= ~VIDCFG_2X
;
582 if (freq
> par
->max_pixclock
/ 2) {
583 freq
= freq
> par
->max_pixclock
? par
->max_pixclock
: freq
;
584 reg
.dacmode
|= DACMODE_2X
;
585 reg
.vidcfg
|= VIDCFG_2X
;
592 wd
= (hdispend
>> 3) - 1;
594 hs
= (hsyncsta
>> 3) - 1;
595 he
= (hsyncend
>> 3) - 1;
596 ht
= (htotal
>> 3) - 1;
600 if ((info
->var
.vmode
& FB_VMODE_MASK
) == FB_VMODE_DOUBLE
) {
601 vd
= (info
->var
.yres
<< 1) - 1;
602 vs
= vd
+ (info
->var
.lower_margin
<< 1);
603 ve
= vs
+ (info
->var
.vsync_len
<< 1);
604 vt
= ve
+ (info
->var
.upper_margin
<< 1) - 1;
605 reg
.screensize
= info
->var
.xres
| (info
->var
.yres
<< 13);
606 reg
.vidcfg
|= VIDCFG_HALF_MODE
;
607 reg
.crt
[0x09] = 0x80;
609 vd
= info
->var
.yres
- 1;
610 vs
= vd
+ info
->var
.lower_margin
;
611 ve
= vs
+ info
->var
.vsync_len
;
612 vt
= ve
+ info
->var
.upper_margin
- 1;
613 reg
.screensize
= info
->var
.xres
| (info
->var
.yres
<< 12);
614 reg
.vidcfg
&= ~VIDCFG_HALF_MODE
;
619 /* this is all pretty standard VGA register stuffing */
620 reg
.misc
[0x00] = 0x0f |
621 (info
->var
.xres
< 400 ? 0xa0 :
622 info
->var
.xres
< 480 ? 0x60 :
623 info
->var
.xres
< 768 ? 0xe0 : 0x20);
625 reg
.gra
[0x05] = 0x40;
626 reg
.gra
[0x06] = 0x05;
627 reg
.gra
[0x07] = 0x0f;
628 reg
.gra
[0x08] = 0xff;
630 reg
.att
[0x00] = 0x00;
631 reg
.att
[0x01] = 0x01;
632 reg
.att
[0x02] = 0x02;
633 reg
.att
[0x03] = 0x03;
634 reg
.att
[0x04] = 0x04;
635 reg
.att
[0x05] = 0x05;
636 reg
.att
[0x06] = 0x06;
637 reg
.att
[0x07] = 0x07;
638 reg
.att
[0x08] = 0x08;
639 reg
.att
[0x09] = 0x09;
640 reg
.att
[0x0a] = 0x0a;
641 reg
.att
[0x0b] = 0x0b;
642 reg
.att
[0x0c] = 0x0c;
643 reg
.att
[0x0d] = 0x0d;
644 reg
.att
[0x0e] = 0x0e;
645 reg
.att
[0x0f] = 0x0f;
646 reg
.att
[0x10] = 0x41;
647 reg
.att
[0x12] = 0x0f;
649 reg
.seq
[0x00] = 0x03;
650 reg
.seq
[0x01] = 0x01; /* fixme: clkdiv2? */
651 reg
.seq
[0x02] = 0x0f;
652 reg
.seq
[0x03] = 0x00;
653 reg
.seq
[0x04] = 0x0e;
655 reg
.crt
[0x00] = ht
- 4;
658 reg
.crt
[0x03] = 0x80 | (hbe
& 0x1f);
660 reg
.crt
[0x05] = ((hbe
& 0x20) << 2) | (he
& 0x1f);
662 reg
.crt
[0x07] = ((vs
& 0x200) >> 2) |
663 ((vd
& 0x200) >> 3) |
664 ((vt
& 0x200) >> 4) | 0x10 |
665 ((vbs
& 0x100) >> 5) |
666 ((vs
& 0x100) >> 6) |
667 ((vd
& 0x100) >> 7) |
669 reg
.crt
[0x09] |= 0x40 | ((vbs
& 0x200) >> 4);
671 reg
.crt
[0x11] = (ve
& 0x0f) | 0x20;
675 reg
.crt
[0x16] = vbe
+ 1;
676 reg
.crt
[0x17] = 0xc3;
677 reg
.crt
[0x18] = 0xff;
679 /* Banshee's nonvga stuff */
680 reg
.ext
[0x00] = (((ht
& 0x100) >> 8) |
681 ((hd
& 0x100) >> 6) |
682 ((hbs
& 0x100) >> 4) |
683 ((hbe
& 0x40) >> 1) |
684 ((hs
& 0x100) >> 2) |
686 reg
.ext
[0x01] = (((vt
& 0x400) >> 10) |
687 ((vd
& 0x400) >> 8) |
688 ((vbs
& 0x400) >> 6) |
689 ((vbe
& 0x400) >> 4));
691 reg
.vgainit0
= VGAINIT0_8BIT_DAC
|
692 VGAINIT0_EXT_ENABLE
|
693 VGAINIT0_WAKEUP_3C3
|
694 VGAINIT0_ALT_READBACK
|
695 VGAINIT0_EXTSHIFTOUT
;
696 reg
.vgainit1
= tdfx_inl(par
, VGAINIT1
) & 0x1fffff;
699 reg
.curspataddr
= info
->fix
.smem_len
;
704 reg
.cursc1
= 0xffffff;
706 reg
.stride
= info
->var
.xres
* cpp
;
707 reg
.startaddr
= info
->var
.yoffset
* reg
.stride
708 + info
->var
.xoffset
* cpp
;
710 reg
.vidpll
= do_calc_pll(freq
, &fout
);
712 reg
.mempll
= do_calc_pll(..., &fout
);
713 reg
.gfxpll
= do_calc_pll(..., &fout
);
716 if ((info
->var
.vmode
& FB_VMODE_MASK
) == FB_VMODE_INTERLACED
)
717 reg
.vidcfg
|= VIDCFG_INTERLACE
;
718 reg
.miscinit0
= tdfx_inl(par
, MISCINIT0
);
720 #if defined(__BIG_ENDIAN)
721 switch (info
->var
.bits_per_pixel
) {
724 reg
.miscinit0
&= ~(1 << 30);
725 reg
.miscinit0
&= ~(1 << 31);
728 reg
.miscinit0
|= (1 << 30);
729 reg
.miscinit0
|= (1 << 31);
732 reg
.miscinit0
|= (1 << 30);
733 reg
.miscinit0
&= ~(1 << 31);
737 do_write_regs(info
, ®
);
739 /* Now change fb_fix_screeninfo according to changes in par */
740 info
->fix
.line_length
= reg
.stride
;
741 info
->fix
.visual
= (info
->var
.bits_per_pixel
== 8)
742 ? FB_VISUAL_PSEUDOCOLOR
743 : FB_VISUAL_TRUECOLOR
;
744 DPRINTK("Graphics mode is now set at %dx%d depth %d\n",
745 info
->var
.xres
, info
->var
.yres
, info
->var
.bits_per_pixel
);
749 /* A handy macro shamelessly pinched from matroxfb */
750 #define CNVT_TOHW(val, width) ((((val) << (width)) + 0x7FFF - (val)) >> 16)
752 static int tdfxfb_setcolreg(unsigned regno
, unsigned red
, unsigned green
,
753 unsigned blue
, unsigned transp
,
754 struct fb_info
*info
)
756 struct tdfx_par
*par
= info
->par
;
759 if (regno
>= info
->cmap
.len
|| regno
> 255)
762 /* grayscale works only partially under directcolor */
763 if (info
->var
.grayscale
) {
764 /* grayscale = 0.30*R + 0.59*G + 0.11*B */
765 blue
= (red
* 77 + green
* 151 + blue
* 28) >> 8;
770 switch (info
->fix
.visual
) {
771 case FB_VISUAL_PSEUDOCOLOR
:
772 rgbcol
= (((u32
)red
& 0xff00) << 8) |
773 (((u32
)green
& 0xff00) << 0) |
774 (((u32
)blue
& 0xff00) >> 8);
775 do_setpalentry(par
, regno
, rgbcol
);
777 /* Truecolor has no hardware color palettes. */
778 case FB_VISUAL_TRUECOLOR
:
780 rgbcol
= (CNVT_TOHW(red
, info
->var
.red
.length
) <<
781 info
->var
.red
.offset
) |
782 (CNVT_TOHW(green
, info
->var
.green
.length
) <<
783 info
->var
.green
.offset
) |
784 (CNVT_TOHW(blue
, info
->var
.blue
.length
) <<
785 info
->var
.blue
.offset
) |
786 (CNVT_TOHW(transp
, info
->var
.transp
.length
) <<
787 info
->var
.transp
.offset
);
788 par
->palette
[regno
] = rgbcol
;
793 DPRINTK("bad depth %u\n", info
->var
.bits_per_pixel
);
800 /* 0 unblank, 1 blank, 2 no vsync, 3 no hsync, 4 off */
801 static int tdfxfb_blank(int blank
, struct fb_info
*info
)
803 struct tdfx_par
*par
= info
->par
;
805 u32 dacmode
= tdfx_inl(par
, DACMODE
);
807 dacmode
&= ~(BIT(1) | BIT(3));
810 case FB_BLANK_UNBLANK
: /* Screen: On; HSync: On, VSync: On */
813 case FB_BLANK_NORMAL
: /* Screen: Off; HSync: On, VSync: On */
815 case FB_BLANK_VSYNC_SUSPEND
: /* Screen: Off; HSync: On, VSync: Off */
818 case FB_BLANK_HSYNC_SUSPEND
: /* Screen: Off; HSync: Off, VSync: On */
821 case FB_BLANK_POWERDOWN
: /* Screen: Off; HSync: Off, VSync: Off */
822 dacmode
|= BIT(1) | BIT(3);
826 banshee_make_room(par
, 1);
827 tdfx_outl(par
, DACMODE
, dacmode
);
829 vga_disable_video(par
);
831 vga_enable_video(par
);
836 * Set the starting position of the visible screen to var->yoffset
838 static int tdfxfb_pan_display(struct fb_var_screeninfo
*var
,
839 struct fb_info
*info
)
841 struct tdfx_par
*par
= info
->par
;
842 u32 addr
= var
->yoffset
* info
->fix
.line_length
;
844 if (nopan
|| var
->xoffset
)
847 banshee_make_room(par
, 1);
848 tdfx_outl(par
, VIDDESKSTART
, addr
);
853 #ifdef CONFIG_FB_3DFX_ACCEL
855 * FillRect 2D command (solidfill or invert (via ROP_XOR))
857 static void tdfxfb_fillrect(struct fb_info
*info
,
858 const struct fb_fillrect
*rect
)
860 struct tdfx_par
*par
= info
->par
;
861 u32 bpp
= info
->var
.bits_per_pixel
;
862 u32 stride
= info
->fix
.line_length
;
863 u32 fmt
= stride
| ((bpp
+ ((bpp
== 8) ? 0 : 8)) << 13);
869 if (rect
->rop
== ROP_COPY
)
870 tdfx_rop
= TDFX_ROP_COPY
;
872 tdfx_rop
= TDFX_ROP_XOR
;
874 /* asume always rect->height < 4096 */
875 if (dy
+ rect
->height
> 4095) {
876 dstbase
= stride
* dy
;
879 /* asume always rect->width < 4096 */
880 if (dx
+ rect
->width
> 4095) {
881 dstbase
+= dx
* bpp
>> 3;
884 banshee_make_room(par
, 6);
885 tdfx_outl(par
, DSTFORMAT
, fmt
);
886 if (info
->fix
.visual
== FB_VISUAL_PSEUDOCOLOR
) {
887 tdfx_outl(par
, COLORFORE
, rect
->color
);
888 } else { /* FB_VISUAL_TRUECOLOR */
889 tdfx_outl(par
, COLORFORE
, par
->palette
[rect
->color
]);
891 tdfx_outl(par
, COMMAND_2D
, COMMAND_2D_FILLRECT
| (tdfx_rop
<< 24));
892 tdfx_outl(par
, DSTBASE
, dstbase
);
893 tdfx_outl(par
, DSTSIZE
, rect
->width
| (rect
->height
<< 16));
894 tdfx_outl(par
, LAUNCH_2D
, dx
| (dy
<< 16));
898 * Screen-to-Screen BitBlt 2D command (for the bmove fb op.)
900 static void tdfxfb_copyarea(struct fb_info
*info
,
901 const struct fb_copyarea
*area
)
903 struct tdfx_par
*par
= info
->par
;
904 u32 sx
= area
->sx
, sy
= area
->sy
, dx
= area
->dx
, dy
= area
->dy
;
905 u32 bpp
= info
->var
.bits_per_pixel
;
906 u32 stride
= info
->fix
.line_length
;
907 u32 blitcmd
= COMMAND_2D_S2S_BITBLT
| (TDFX_ROP_COPY
<< 24);
908 u32 fmt
= stride
| ((bpp
+ ((bpp
== 8) ? 0 : 8)) << 13);
912 /* asume always area->height < 4096 */
913 if (sy
+ area
->height
> 4095) {
914 srcbase
= stride
* sy
;
917 /* asume always area->width < 4096 */
918 if (sx
+ area
->width
> 4095) {
919 srcbase
+= sx
* bpp
>> 3;
922 /* asume always area->height < 4096 */
923 if (dy
+ area
->height
> 4095) {
924 dstbase
= stride
* dy
;
927 /* asume always area->width < 4096 */
928 if (dx
+ area
->width
> 4095) {
929 dstbase
+= dx
* bpp
>> 3;
933 if (area
->sx
<= area
->dx
) {
936 sx
+= area
->width
- 1;
937 dx
+= area
->width
- 1;
939 if (area
->sy
<= area
->dy
) {
942 sy
+= area
->height
- 1;
943 dy
+= area
->height
- 1;
946 banshee_make_room(par
, 8);
948 tdfx_outl(par
, SRCFORMAT
, fmt
);
949 tdfx_outl(par
, DSTFORMAT
, fmt
);
950 tdfx_outl(par
, COMMAND_2D
, blitcmd
);
951 tdfx_outl(par
, DSTSIZE
, area
->width
| (area
->height
<< 16));
952 tdfx_outl(par
, DSTXY
, dx
| (dy
<< 16));
953 tdfx_outl(par
, SRCBASE
, srcbase
);
954 tdfx_outl(par
, DSTBASE
, dstbase
);
955 tdfx_outl(par
, LAUNCH_2D
, sx
| (sy
<< 16));
958 static void tdfxfb_imageblit(struct fb_info
*info
, const struct fb_image
*image
)
960 struct tdfx_par
*par
= info
->par
;
961 int size
= image
->height
* ((image
->width
* image
->depth
+ 7) >> 3);
963 int i
, stride
= info
->fix
.line_length
;
964 u32 bpp
= info
->var
.bits_per_pixel
;
965 u32 dstfmt
= stride
| ((bpp
+ ((bpp
== 8) ? 0 : 8)) << 13);
966 u8
*chardata
= (u8
*) image
->data
;
972 if (image
->depth
!= 1) {
974 banshee_make_room(par
, 6 + ((size
+ 3) >> 2));
975 srcfmt
= stride
| ((bpp
+ ((bpp
== 8) ? 0 : 8)) << 13) |
978 cfb_imageblit(info
, image
);
982 banshee_make_room(par
, 9);
983 switch (info
->fix
.visual
) {
984 case FB_VISUAL_PSEUDOCOLOR
:
985 tdfx_outl(par
, COLORFORE
, image
->fg_color
);
986 tdfx_outl(par
, COLORBACK
, image
->bg_color
);
988 case FB_VISUAL_TRUECOLOR
:
990 tdfx_outl(par
, COLORFORE
,
991 par
->palette
[image
->fg_color
]);
992 tdfx_outl(par
, COLORBACK
,
993 par
->palette
[image
->bg_color
]);
996 srcfmt
= 0x400000 | BIT(20);
1000 /* asume always image->height < 4096 */
1001 if (dy
+ image
->height
> 4095) {
1002 dstbase
= stride
* dy
;
1005 /* asume always image->width < 4096 */
1006 if (dx
+ image
->width
> 4095) {
1007 dstbase
+= dx
* bpp
>> 3;
1011 tdfx_outl(par
, DSTBASE
, dstbase
);
1012 tdfx_outl(par
, SRCXY
, 0);
1013 tdfx_outl(par
, DSTXY
, dx
| (dy
<< 16));
1014 tdfx_outl(par
, COMMAND_2D
,
1015 COMMAND_2D_H2S_BITBLT
| (TDFX_ROP_COPY
<< 24));
1016 tdfx_outl(par
, SRCFORMAT
, srcfmt
);
1017 tdfx_outl(par
, DSTFORMAT
, dstfmt
);
1018 tdfx_outl(par
, DSTSIZE
, image
->width
| (image
->height
<< 16));
1020 /* A count of how many free FIFO entries we've requested.
1021 * When this goes negative, we need to request more. */
1024 /* Send four bytes at a time of data */
1025 for (i
= (size
>> 2); i
> 0; i
--) {
1026 if (--fifo_free
< 0) {
1028 banshee_make_room(par
, fifo_free
);
1030 tdfx_outl(par
, LAUNCH_2D
, *(u32
*)chardata
);
1034 /* Send the leftovers now */
1035 banshee_make_room(par
, 3);
1040 tdfx_outl(par
, LAUNCH_2D
, *chardata
);
1043 tdfx_outl(par
, LAUNCH_2D
, *(u16
*)chardata
);
1046 tdfx_outl(par
, LAUNCH_2D
,
1047 *(u16
*)chardata
| (chardata
[3] << 24));
1051 #endif /* CONFIG_FB_3DFX_ACCEL */
1053 static int tdfxfb_cursor(struct fb_info
*info
, struct fb_cursor
*cursor
)
1055 struct tdfx_par
*par
= info
->par
;
1059 return -EINVAL
; /* just to force soft_cursor() call */
1061 /* Too large of a cursor or wrong bpp :-( */
1062 if (cursor
->image
.width
> 64 ||
1063 cursor
->image
.height
> 64 ||
1064 cursor
->image
.depth
> 1)
1067 vidcfg
= tdfx_inl(par
, VIDPROCCFG
);
1069 tdfx_outl(par
, VIDPROCCFG
, vidcfg
| VIDCFG_HWCURSOR_ENABLE
);
1071 tdfx_outl(par
, VIDPROCCFG
, vidcfg
& ~VIDCFG_HWCURSOR_ENABLE
);
1074 * If the cursor is not be changed this means either we want the
1075 * current cursor state (if enable is set) or we want to query what
1076 * we can do with the cursor (if enable is not set)
1081 /* fix cursor color - XFree86 forgets to restore it properly */
1082 if (cursor
->set
& FB_CUR_SETCMAP
) {
1083 struct fb_cmap cmap
= info
->cmap
;
1084 u32 bg_idx
= cursor
->image
.bg_color
;
1085 u32 fg_idx
= cursor
->image
.fg_color
;
1086 unsigned long bg_color
, fg_color
;
1088 fg_color
= (((u32
)cmap
.red
[fg_idx
] & 0xff00) << 8) |
1089 (((u32
)cmap
.green
[fg_idx
] & 0xff00) << 0) |
1090 (((u32
)cmap
.blue
[fg_idx
] & 0xff00) >> 8);
1091 bg_color
= (((u32
)cmap
.red
[bg_idx
] & 0xff00) << 8) |
1092 (((u32
)cmap
.green
[bg_idx
] & 0xff00) << 0) |
1093 (((u32
)cmap
.blue
[bg_idx
] & 0xff00) >> 8);
1094 banshee_make_room(par
, 2);
1095 tdfx_outl(par
, HWCURC0
, bg_color
);
1096 tdfx_outl(par
, HWCURC1
, fg_color
);
1099 if (cursor
->set
& FB_CUR_SETPOS
) {
1100 int x
= cursor
->image
.dx
;
1101 int y
= cursor
->image
.dy
- info
->var
.yoffset
;
1105 banshee_make_room(par
, 1);
1106 tdfx_outl(par
, HWCURLOC
, (y
<< 16) + x
);
1108 if (cursor
->set
& (FB_CUR_SETIMAGE
| FB_CUR_SETSHAPE
)) {
1110 * Voodoo 3 and above cards use 2 monochrome cursor patterns.
1111 * The reason is so the card can fetch 8 words at a time
1112 * and are stored on chip for use for the next 8 scanlines.
1113 * This reduces the number of times for access to draw the
1114 * cursor for each screen refresh.
1115 * Each pattern is a bitmap of 64 bit wide and 64 bit high
1116 * (total of 8192 bits or 1024 bytes). The two patterns are
1117 * stored in such a way that pattern 0 always resides in the
1118 * lower half (least significant 64 bits) of a 128 bit word
1119 * and pattern 1 the upper half. If you examine the data of
1120 * the cursor image the graphics card uses then from the
1121 * begining you see line one of pattern 0, line one of
1122 * pattern 1, line two of pattern 0, line two of pattern 1,
1123 * etc etc. The linear stride for the cursor is always 16 bytes
1124 * (128 bits) which is the maximum cursor width times two for
1125 * the two monochrome patterns.
1127 u8 __iomem
*cursorbase
= info
->screen_base
+ info
->fix
.smem_len
;
1128 u8
*bitmap
= (u8
*)cursor
->image
.data
;
1129 u8
*mask
= (u8
*)cursor
->mask
;
1132 fb_memset(cursorbase
, 0, 1024);
1134 for (i
= 0; i
< cursor
->image
.height
; i
++) {
1136 int j
= (cursor
->image
.width
+ 7) >> 3;
1138 for (; j
> 0; j
--) {
1139 u8 data
= *mask
^ *bitmap
;
1140 if (cursor
->rop
== ROP_COPY
)
1141 data
= *mask
& *bitmap
;
1142 /* Pattern 0. Copy the cursor mask to it */
1143 fb_writeb(*mask
, cursorbase
+ h
);
1145 /* Pattern 1. Copy the cursor bitmap to it */
1146 fb_writeb(data
, cursorbase
+ h
+ 8);
1156 static struct fb_ops tdfxfb_ops
= {
1157 .owner
= THIS_MODULE
,
1158 .fb_check_var
= tdfxfb_check_var
,
1159 .fb_set_par
= tdfxfb_set_par
,
1160 .fb_setcolreg
= tdfxfb_setcolreg
,
1161 .fb_blank
= tdfxfb_blank
,
1162 .fb_pan_display
= tdfxfb_pan_display
,
1163 .fb_sync
= banshee_wait_idle
,
1164 .fb_cursor
= tdfxfb_cursor
,
1165 #ifdef CONFIG_FB_3DFX_ACCEL
1166 .fb_fillrect
= tdfxfb_fillrect
,
1167 .fb_copyarea
= tdfxfb_copyarea
,
1168 .fb_imageblit
= tdfxfb_imageblit
,
1170 .fb_fillrect
= cfb_fillrect
,
1171 .fb_copyarea
= cfb_copyarea
,
1172 .fb_imageblit
= cfb_imageblit
,
1176 #ifdef CONFIG_FB_3DFX_I2C
1177 /* The voo GPIO registers don't have individual masks for each bit
1178 so we always have to read before writing. */
1180 static void tdfxfb_i2c_setscl(void *data
, int val
)
1182 struct tdfxfb_i2c_chan
*chan
= data
;
1183 struct tdfx_par
*par
= chan
->par
;
1186 r
= tdfx_inl(par
, VIDSERPARPORT
);
1191 tdfx_outl(par
, VIDSERPARPORT
, r
);
1192 tdfx_inl(par
, VIDSERPARPORT
); /* flush posted write */
1195 static void tdfxfb_i2c_setsda(void *data
, int val
)
1197 struct tdfxfb_i2c_chan
*chan
= data
;
1198 struct tdfx_par
*par
= chan
->par
;
1201 r
= tdfx_inl(par
, VIDSERPARPORT
);
1206 tdfx_outl(par
, VIDSERPARPORT
, r
);
1207 tdfx_inl(par
, VIDSERPARPORT
); /* flush posted write */
1210 /* The GPIO pins are open drain, so the pins always remain outputs.
1211 We rely on the i2c-algo-bit routines to set the pins high before
1212 reading the input from other chips. */
1214 static int tdfxfb_i2c_getscl(void *data
)
1216 struct tdfxfb_i2c_chan
*chan
= data
;
1217 struct tdfx_par
*par
= chan
->par
;
1219 return (0 != (tdfx_inl(par
, VIDSERPARPORT
) & I2C_SCL_IN
));
1222 static int tdfxfb_i2c_getsda(void *data
)
1224 struct tdfxfb_i2c_chan
*chan
= data
;
1225 struct tdfx_par
*par
= chan
->par
;
1227 return (0 != (tdfx_inl(par
, VIDSERPARPORT
) & I2C_SDA_IN
));
1230 static void tdfxfb_ddc_setscl(void *data
, int val
)
1232 struct tdfxfb_i2c_chan
*chan
= data
;
1233 struct tdfx_par
*par
= chan
->par
;
1236 r
= tdfx_inl(par
, VIDSERPARPORT
);
1241 tdfx_outl(par
, VIDSERPARPORT
, r
);
1242 tdfx_inl(par
, VIDSERPARPORT
); /* flush posted write */
1245 static void tdfxfb_ddc_setsda(void *data
, int val
)
1247 struct tdfxfb_i2c_chan
*chan
= data
;
1248 struct tdfx_par
*par
= chan
->par
;
1251 r
= tdfx_inl(par
, VIDSERPARPORT
);
1256 tdfx_outl(par
, VIDSERPARPORT
, r
);
1257 tdfx_inl(par
, VIDSERPARPORT
); /* flush posted write */
1260 static int tdfxfb_ddc_getscl(void *data
)
1262 struct tdfxfb_i2c_chan
*chan
= data
;
1263 struct tdfx_par
*par
= chan
->par
;
1265 return (0 != (tdfx_inl(par
, VIDSERPARPORT
) & DDC_SCL_IN
));
1268 static int tdfxfb_ddc_getsda(void *data
)
1270 struct tdfxfb_i2c_chan
*chan
= data
;
1271 struct tdfx_par
*par
= chan
->par
;
1273 return (0 != (tdfx_inl(par
, VIDSERPARPORT
) & DDC_SDA_IN
));
1276 static int __devinit
tdfxfb_setup_ddc_bus(struct tdfxfb_i2c_chan
*chan
,
1277 const char *name
, struct device
*dev
)
1281 strlcpy(chan
->adapter
.name
, name
, sizeof(chan
->adapter
.name
));
1282 chan
->adapter
.owner
= THIS_MODULE
;
1283 chan
->adapter
.class = I2C_CLASS_DDC
;
1284 chan
->adapter
.algo_data
= &chan
->algo
;
1285 chan
->adapter
.dev
.parent
= dev
;
1286 chan
->algo
.setsda
= tdfxfb_ddc_setsda
;
1287 chan
->algo
.setscl
= tdfxfb_ddc_setscl
;
1288 chan
->algo
.getsda
= tdfxfb_ddc_getsda
;
1289 chan
->algo
.getscl
= tdfxfb_ddc_getscl
;
1290 chan
->algo
.udelay
= 10;
1291 chan
->algo
.timeout
= msecs_to_jiffies(500);
1292 chan
->algo
.data
= chan
;
1294 i2c_set_adapdata(&chan
->adapter
, chan
);
1296 rc
= i2c_bit_add_bus(&chan
->adapter
);
1298 DPRINTK("I2C bus %s registered.\n", name
);
1305 static int __devinit
tdfxfb_setup_i2c_bus(struct tdfxfb_i2c_chan
*chan
,
1306 const char *name
, struct device
*dev
)
1310 strlcpy(chan
->adapter
.name
, name
, sizeof(chan
->adapter
.name
));
1311 chan
->adapter
.owner
= THIS_MODULE
;
1312 chan
->adapter
.class = I2C_CLASS_TV_ANALOG
;
1313 chan
->adapter
.algo_data
= &chan
->algo
;
1314 chan
->adapter
.dev
.parent
= dev
;
1315 chan
->algo
.setsda
= tdfxfb_i2c_setsda
;
1316 chan
->algo
.setscl
= tdfxfb_i2c_setscl
;
1317 chan
->algo
.getsda
= tdfxfb_i2c_getsda
;
1318 chan
->algo
.getscl
= tdfxfb_i2c_getscl
;
1319 chan
->algo
.udelay
= 10;
1320 chan
->algo
.timeout
= msecs_to_jiffies(500);
1321 chan
->algo
.data
= chan
;
1323 i2c_set_adapdata(&chan
->adapter
, chan
);
1325 rc
= i2c_bit_add_bus(&chan
->adapter
);
1327 DPRINTK("I2C bus %s registered.\n", name
);
1334 static void __devinit
tdfxfb_create_i2c_busses(struct fb_info
*info
)
1336 struct tdfx_par
*par
= info
->par
;
1338 tdfx_outl(par
, VIDINFORMAT
, 0x8160);
1339 tdfx_outl(par
, VIDSERPARPORT
, 0xcffc0020);
1341 par
->chan
[0].par
= par
;
1342 par
->chan
[1].par
= par
;
1344 tdfxfb_setup_ddc_bus(&par
->chan
[0], "Voodoo3-DDC", info
->dev
);
1345 tdfxfb_setup_i2c_bus(&par
->chan
[1], "Voodoo3-I2C", info
->dev
);
1348 static void tdfxfb_delete_i2c_busses(struct tdfx_par
*par
)
1350 if (par
->chan
[0].par
)
1351 i2c_del_adapter(&par
->chan
[0].adapter
);
1352 par
->chan
[0].par
= NULL
;
1354 if (par
->chan
[1].par
)
1355 i2c_del_adapter(&par
->chan
[1].adapter
);
1356 par
->chan
[1].par
= NULL
;
1358 #endif /* CONFIG_FB_3DFX_I2C */
1361 * tdfxfb_probe - Device Initializiation
1363 * @pdev: PCI Device to initialize
1364 * @id: PCI Device ID
1366 * Initializes and allocates resources for PCI device @pdev.
1369 static int __devinit
tdfxfb_probe(struct pci_dev
*pdev
,
1370 const struct pci_device_id
*id
)
1372 struct tdfx_par
*default_par
;
1373 struct fb_info
*info
;
1376 err
= pci_enable_device(pdev
);
1378 printk(KERN_ERR
"tdfxfb: Can't enable pdev: %d\n", err
);
1382 info
= framebuffer_alloc(sizeof(struct tdfx_par
), &pdev
->dev
);
1387 default_par
= info
->par
;
1388 info
->fix
= tdfx_fix
;
1390 /* Configure the default fb_fix_screeninfo first */
1391 switch (pdev
->device
) {
1392 case PCI_DEVICE_ID_3DFX_BANSHEE
:
1393 strcpy(info
->fix
.id
, "3Dfx Banshee");
1394 default_par
->max_pixclock
= BANSHEE_MAX_PIXCLOCK
;
1396 case PCI_DEVICE_ID_3DFX_VOODOO3
:
1397 strcpy(info
->fix
.id
, "3Dfx Voodoo3");
1398 default_par
->max_pixclock
= VOODOO3_MAX_PIXCLOCK
;
1400 case PCI_DEVICE_ID_3DFX_VOODOO5
:
1401 strcpy(info
->fix
.id
, "3Dfx Voodoo5");
1402 default_par
->max_pixclock
= VOODOO5_MAX_PIXCLOCK
;
1406 info
->fix
.mmio_start
= pci_resource_start(pdev
, 0);
1407 info
->fix
.mmio_len
= pci_resource_len(pdev
, 0);
1408 if (!request_mem_region(info
->fix
.mmio_start
, info
->fix
.mmio_len
,
1410 printk(KERN_ERR
"tdfxfb: Can't reserve regbase\n");
1414 default_par
->regbase_virt
=
1415 ioremap_nocache(info
->fix
.mmio_start
, info
->fix
.mmio_len
);
1416 if (!default_par
->regbase_virt
) {
1417 printk(KERN_ERR
"fb: Can't remap %s register area.\n",
1419 goto out_err_regbase
;
1422 info
->fix
.smem_start
= pci_resource_start(pdev
, 1);
1423 info
->fix
.smem_len
= do_lfb_size(default_par
, pdev
->device
);
1424 if (!info
->fix
.smem_len
) {
1425 printk(KERN_ERR
"fb: Can't count %s memory.\n", info
->fix
.id
);
1426 goto out_err_regbase
;
1429 if (!request_mem_region(info
->fix
.smem_start
,
1430 pci_resource_len(pdev
, 1), "tdfx smem")) {
1431 printk(KERN_ERR
"tdfxfb: Can't reserve smem\n");
1432 goto out_err_regbase
;
1435 info
->screen_base
= ioremap_nocache(info
->fix
.smem_start
,
1436 info
->fix
.smem_len
);
1437 if (!info
->screen_base
) {
1438 printk(KERN_ERR
"fb: Can't remap %s framebuffer.\n",
1440 goto out_err_screenbase
;
1443 default_par
->iobase
= pci_resource_start(pdev
, 2);
1445 if (!request_region(pci_resource_start(pdev
, 2),
1446 pci_resource_len(pdev
, 2), "tdfx iobase")) {
1447 printk(KERN_ERR
"tdfxfb: Can't reserve iobase\n");
1448 goto out_err_screenbase
;
1451 printk(KERN_INFO
"fb: %s memory = %dK\n", info
->fix
.id
,
1452 info
->fix
.smem_len
>> 10);
1454 default_par
->mtrr_handle
= -1;
1456 default_par
->mtrr_handle
=
1457 mtrr_add(info
->fix
.smem_start
, info
->fix
.smem_len
,
1458 MTRR_TYPE_WRCOMB
, 1);
1460 info
->fix
.ypanstep
= nopan
? 0 : 1;
1461 info
->fix
.ywrapstep
= nowrap
? 0 : 1;
1463 info
->fbops
= &tdfxfb_ops
;
1464 info
->pseudo_palette
= default_par
->palette
;
1465 info
->flags
= FBINFO_DEFAULT
| FBINFO_HWACCEL_YPAN
;
1466 #ifdef CONFIG_FB_3DFX_ACCEL
1467 info
->flags
|= FBINFO_HWACCEL_FILLRECT
|
1468 FBINFO_HWACCEL_COPYAREA
|
1469 FBINFO_HWACCEL_IMAGEBLIT
|
1472 /* reserve 8192 bits for cursor */
1473 /* the 2.4 driver says PAGE_MASK boundary is not enough for Voodoo4 */
1475 info
->fix
.smem_len
= (info
->fix
.smem_len
- 1024) &
1477 #ifdef CONFIG_FB_3DFX_I2C
1478 tdfxfb_create_i2c_busses(info
);
1481 mode_option
= "640x480@60";
1483 err
= fb_find_mode(&info
->var
, info
, mode_option
, NULL
, 0, NULL
, 8);
1484 if (!err
|| err
== 4)
1485 info
->var
= tdfx_var
;
1487 /* maximize virtual vertical length */
1488 lpitch
= info
->var
.xres_virtual
* ((info
->var
.bits_per_pixel
+ 7) >> 3);
1489 info
->var
.yres_virtual
= info
->fix
.smem_len
/ lpitch
;
1490 if (info
->var
.yres_virtual
< info
->var
.yres
)
1491 goto out_err_iobase
;
1493 if (fb_alloc_cmap(&info
->cmap
, 256, 0) < 0) {
1494 printk(KERN_ERR
"tdfxfb: Can't allocate color map\n");
1495 goto out_err_iobase
;
1498 if (register_framebuffer(info
) < 0) {
1499 printk(KERN_ERR
"tdfxfb: can't register framebuffer\n");
1500 fb_dealloc_cmap(&info
->cmap
);
1501 goto out_err_iobase
;
1506 pci_set_drvdata(pdev
, info
);
1510 #ifdef CONFIG_FB_3DFX_I2C
1511 tdfxfb_delete_i2c_busses(default_par
);
1513 if (default_par
->mtrr_handle
>= 0)
1514 mtrr_del(default_par
->mtrr_handle
, info
->fix
.smem_start
,
1515 info
->fix
.smem_len
);
1516 release_mem_region(pci_resource_start(pdev
, 2),
1517 pci_resource_len(pdev
, 2));
1519 if (info
->screen_base
)
1520 iounmap(info
->screen_base
);
1521 release_mem_region(info
->fix
.smem_start
, pci_resource_len(pdev
, 1));
1524 * Cleanup after anything that was remapped/allocated.
1526 if (default_par
->regbase_virt
)
1527 iounmap(default_par
->regbase_virt
);
1528 release_mem_region(info
->fix
.mmio_start
, info
->fix
.mmio_len
);
1530 framebuffer_release(info
);
1535 static void __init
tdfxfb_setup(char *options
)
1539 if (!options
|| !*options
)
1542 while ((this_opt
= strsep(&options
, ",")) != NULL
) {
1545 if (!strcmp(this_opt
, "nopan")) {
1547 } else if (!strcmp(this_opt
, "nowrap")) {
1549 } else if (!strncmp(this_opt
, "hwcursor=", 9)) {
1550 hwcursor
= simple_strtoul(this_opt
+ 9, NULL
, 0);
1552 } else if (!strncmp(this_opt
, "nomtrr", 6)) {
1556 mode_option
= this_opt
;
1563 * tdfxfb_remove - Device removal
1565 * @pdev: PCI Device to cleanup
1567 * Releases all resources allocated during the course of the driver's
1568 * lifetime for the PCI device @pdev.
1571 static void __devexit
tdfxfb_remove(struct pci_dev
*pdev
)
1573 struct fb_info
*info
= pci_get_drvdata(pdev
);
1574 struct tdfx_par
*par
= info
->par
;
1576 unregister_framebuffer(info
);
1577 #ifdef CONFIG_FB_3DFX_I2C
1578 tdfxfb_delete_i2c_busses(par
);
1580 if (par
->mtrr_handle
>= 0)
1581 mtrr_del(par
->mtrr_handle
, info
->fix
.smem_start
,
1582 info
->fix
.smem_len
);
1583 iounmap(par
->regbase_virt
);
1584 iounmap(info
->screen_base
);
1586 /* Clean up after reserved regions */
1587 release_region(pci_resource_start(pdev
, 2),
1588 pci_resource_len(pdev
, 2));
1589 release_mem_region(pci_resource_start(pdev
, 1),
1590 pci_resource_len(pdev
, 1));
1591 release_mem_region(pci_resource_start(pdev
, 0),
1592 pci_resource_len(pdev
, 0));
1593 pci_set_drvdata(pdev
, NULL
);
1594 fb_dealloc_cmap(&info
->cmap
);
1595 framebuffer_release(info
);
1598 static int __init
tdfxfb_init(void)
1601 char *option
= NULL
;
1603 if (fb_get_options("tdfxfb", &option
))
1606 tdfxfb_setup(option
);
1608 return pci_register_driver(&tdfxfb_driver
);
1611 static void __exit
tdfxfb_exit(void)
1613 pci_unregister_driver(&tdfxfb_driver
);
1616 MODULE_AUTHOR("Hannu Mallat <hmallat@cc.hut.fi>");
1617 MODULE_DESCRIPTION("3Dfx framebuffer device driver");
1618 MODULE_LICENSE("GPL");
1620 module_param(hwcursor
, int, 0644);
1621 MODULE_PARM_DESC(hwcursor
, "Enable hardware cursor "
1622 "(1=enable, 0=disable, default=1)");
1623 module_param(mode_option
, charp
, 0);
1624 MODULE_PARM_DESC(mode_option
, "Initial video mode e.g. '648x480-8@60'");
1626 module_param(nomtrr
, bool, 0);
1627 MODULE_PARM_DESC(nomtrr
, "Disable MTRR support (default: enabled)");
1630 module_init(tdfxfb_init
);
1631 module_exit(tdfxfb_exit
);