2 * linux/drivers/video/neofb.c -- NeoMagic Framebuffer Driver
4 * Copyright (c) 2001-2002 Denis Oliver Kropp <dok@directfb.org>
7 * Card specific code is based on XFree86's neomagic driver.
8 * Framebuffer framework code is based on code of cyber2000fb.
10 * This file is subject to the terms and conditions of the GNU General
11 * Public License. See the file COPYING in the main directory of this
12 * archive for more details.
16 * - Cosmetic changes (dok)
19 * - Toshiba Libretto support, allow modes larger than LCD size if
20 * LCD is disabled, keep BIOS settings if internal/external display
21 * haven't been enabled explicitly
22 * (Thomas J. Moore <dark@mama.indstate.edu>)
25 * - Porting over to new fbdev api. (jsimmons)
28 * - got rid of all floating point (dok)
31 * - added module license (dok)
34 * - hardware accelerated clear and move for 2200 and above (dok)
35 * - maximum allowed dotclock is handled now (dok)
38 * - correct panning after X usage (dok)
39 * - added module and kernel parameters (dok)
40 * - no stretching if external display is enabled (dok)
43 * - initial version (dok)
47 * - ioctl for internal/external switching
49 * - 32bit depth support, maybe impossible
50 * - disable pan-on-sync, need specs
53 * - white margin on bootup like with tdfxfb (colormap problem?)
57 #include <linux/module.h>
58 #include <linux/kernel.h>
59 #include <linux/errno.h>
60 #include <linux/string.h>
62 #include <linux/slab.h>
63 #include <linux/delay.h>
65 #include <linux/pci.h>
66 #include <linux/init.h>
68 #include <linux/toshiba.h>
73 #include <asm/pgtable.h>
74 #include <asm/system.h>
80 #include <video/vga.h>
81 #include <video/neomagic.h>
83 #define NEOFB_VERSION "0.4.2"
85 /* --------------------------------------------------------------------- */
91 static int nopciburst
;
92 static char *mode_option __devinitdata
= NULL
;
96 MODULE_AUTHOR("(c) 2001-2002 Denis Oliver Kropp <dok@convergence.de>");
97 MODULE_LICENSE("GPL");
98 MODULE_DESCRIPTION("FBDev driver for NeoMagic PCI Chips");
99 module_param(internal
, bool, 0);
100 MODULE_PARM_DESC(internal
, "Enable output on internal LCD Display.");
101 module_param(external
, bool, 0);
102 MODULE_PARM_DESC(external
, "Enable output on external CRT.");
103 module_param(libretto
, bool, 0);
104 MODULE_PARM_DESC(libretto
, "Force Libretto 100/110 800x480 LCD.");
105 module_param(nostretch
, bool, 0);
106 MODULE_PARM_DESC(nostretch
,
107 "Disable stretching of modes smaller than LCD.");
108 module_param(nopciburst
, bool, 0);
109 MODULE_PARM_DESC(nopciburst
, "Disable PCI burst mode.");
110 module_param(mode_option
, charp
, 0);
111 MODULE_PARM_DESC(mode_option
, "Preferred video mode ('640x480-8@60', etc)");
116 /* --------------------------------------------------------------------- */
118 static biosMode bios8
[] = {
127 static biosMode bios16
[] = {
136 static biosMode bios24
[] = {
142 #ifdef NO_32BIT_SUPPORT_YET
143 /* FIXME: guessed values, wrong */
144 static biosMode bios32
[] = {
151 static inline void write_le32(int regindex
, u32 val
, const struct neofb_par
*par
)
153 writel(val
, par
->neo2200
+ par
->cursorOff
+ regindex
);
156 static int neoFindMode(int xres
, int yres
, int depth
)
164 size
= ARRAY_SIZE(bios8
);
168 size
= ARRAY_SIZE(bios16
);
172 size
= ARRAY_SIZE(bios24
);
175 #ifdef NO_32BIT_SUPPORT_YET
177 size
= ARRAY_SIZE(bios32
);
185 for (i
= 0; i
< size
; i
++) {
186 if (xres
<= mode
[i
].x_res
) {
187 xres_s
= mode
[i
].x_res
;
188 for (; i
< size
; i
++) {
189 if (mode
[i
].x_res
!= xres_s
)
190 return mode
[i
- 1].mode
;
191 if (yres
<= mode
[i
].y_res
)
196 return mode
[size
- 1].mode
;
202 * Determine the closest clock frequency to the one requested.
208 static void neoCalcVCLK(const struct fb_info
*info
,
209 struct neofb_par
*par
, long freq
)
212 int n_best
= 0, d_best
= 0, f_best
= 0;
213 long f_best_diff
= 0x7ffff;
215 for (f
= 0; f
<= MAX_F
; f
++)
216 for (d
= 0; d
<= MAX_D
; d
++)
217 for (n
= 0; n
<= MAX_N
; n
++) {
221 f_out
= ((14318 * (n
+ 1)) / (d
+ 1)) >> f
;
222 f_diff
= abs(f_out
- freq
);
223 if (f_diff
<= f_best_diff
) {
224 f_best_diff
= f_diff
;
233 if (info
->fix
.accel
== FB_ACCEL_NEOMAGIC_NM2200
||
234 info
->fix
.accel
== FB_ACCEL_NEOMAGIC_NM2230
||
235 info
->fix
.accel
== FB_ACCEL_NEOMAGIC_NM2360
||
236 info
->fix
.accel
== FB_ACCEL_NEOMAGIC_NM2380
) {
237 /* NOT_DONE: We are trying the full range of the 2200 clock.
238 We should be able to try n up to 2047 */
239 par
->VCLK3NumeratorLow
= n_best
;
240 par
->VCLK3NumeratorHigh
= (f_best
<< 7);
242 par
->VCLK3NumeratorLow
= n_best
| (f_best
<< 7);
244 par
->VCLK3Denominator
= d_best
;
247 printk(KERN_DEBUG
"neoVCLK: f:%ld NumLow=%d NumHi=%d Den=%d Df=%ld\n",
249 par
->VCLK3NumeratorLow
,
250 par
->VCLK3NumeratorHigh
,
251 par
->VCLK3Denominator
, f_best_diff
);
257 * Handle the initialization, etc. of a screen.
258 * Return FALSE on failure.
261 static int vgaHWInit(const struct fb_var_screeninfo
*var
,
262 const struct fb_info
*info
,
263 struct neofb_par
*par
, struct xtimings
*timings
)
265 par
->MiscOutReg
= 0x23;
267 if (!(timings
->sync
& FB_SYNC_HOR_HIGH_ACT
))
268 par
->MiscOutReg
|= 0x40;
270 if (!(timings
->sync
& FB_SYNC_VERT_HIGH_ACT
))
271 par
->MiscOutReg
|= 0x80;
276 par
->Sequencer
[0] = 0x00;
277 par
->Sequencer
[1] = 0x01;
278 par
->Sequencer
[2] = 0x0F;
279 par
->Sequencer
[3] = 0x00; /* Font select */
280 par
->Sequencer
[4] = 0x0E; /* Misc */
285 par
->CRTC
[0] = (timings
->HTotal
>> 3) - 5;
286 par
->CRTC
[1] = (timings
->HDisplay
>> 3) - 1;
287 par
->CRTC
[2] = (timings
->HDisplay
>> 3) - 1;
288 par
->CRTC
[3] = (((timings
->HTotal
>> 3) - 1) & 0x1F) | 0x80;
289 par
->CRTC
[4] = (timings
->HSyncStart
>> 3);
290 par
->CRTC
[5] = ((((timings
->HTotal
>> 3) - 1) & 0x20) << 2)
291 | (((timings
->HSyncEnd
>> 3)) & 0x1F);
292 par
->CRTC
[6] = (timings
->VTotal
- 2) & 0xFF;
293 par
->CRTC
[7] = (((timings
->VTotal
- 2) & 0x100) >> 8)
294 | (((timings
->VDisplay
- 1) & 0x100) >> 7)
295 | ((timings
->VSyncStart
& 0x100) >> 6)
296 | (((timings
->VDisplay
- 1) & 0x100) >> 5)
297 | 0x10 | (((timings
->VTotal
- 2) & 0x200) >> 4)
298 | (((timings
->VDisplay
- 1) & 0x200) >> 3)
299 | ((timings
->VSyncStart
& 0x200) >> 2);
301 par
->CRTC
[9] = (((timings
->VDisplay
- 1) & 0x200) >> 4) | 0x40;
303 if (timings
->dblscan
)
304 par
->CRTC
[9] |= 0x80;
306 par
->CRTC
[10] = 0x00;
307 par
->CRTC
[11] = 0x00;
308 par
->CRTC
[12] = 0x00;
309 par
->CRTC
[13] = 0x00;
310 par
->CRTC
[14] = 0x00;
311 par
->CRTC
[15] = 0x00;
312 par
->CRTC
[16] = timings
->VSyncStart
& 0xFF;
313 par
->CRTC
[17] = (timings
->VSyncEnd
& 0x0F) | 0x20;
314 par
->CRTC
[18] = (timings
->VDisplay
- 1) & 0xFF;
315 par
->CRTC
[19] = var
->xres_virtual
>> 4;
316 par
->CRTC
[20] = 0x00;
317 par
->CRTC
[21] = (timings
->VDisplay
- 1) & 0xFF;
318 par
->CRTC
[22] = (timings
->VTotal
- 1) & 0xFF;
319 par
->CRTC
[23] = 0xC3;
320 par
->CRTC
[24] = 0xFF;
323 * are these unnecessary?
324 * vgaHWHBlankKGA(mode, regp, 0, KGA_FIX_OVERSCAN | KGA_ENABLE_ON_ZERO);
325 * vgaHWVBlankKGA(mode, regp, 0, KGA_FIX_OVERSCAN | KGA_ENABLE_ON_ZERO);
329 * Graphics Display Controller
331 par
->Graphics
[0] = 0x00;
332 par
->Graphics
[1] = 0x00;
333 par
->Graphics
[2] = 0x00;
334 par
->Graphics
[3] = 0x00;
335 par
->Graphics
[4] = 0x00;
336 par
->Graphics
[5] = 0x40;
337 par
->Graphics
[6] = 0x05; /* only map 64k VGA memory !!!! */
338 par
->Graphics
[7] = 0x0F;
339 par
->Graphics
[8] = 0xFF;
342 par
->Attribute
[0] = 0x00; /* standard colormap translation */
343 par
->Attribute
[1] = 0x01;
344 par
->Attribute
[2] = 0x02;
345 par
->Attribute
[3] = 0x03;
346 par
->Attribute
[4] = 0x04;
347 par
->Attribute
[5] = 0x05;
348 par
->Attribute
[6] = 0x06;
349 par
->Attribute
[7] = 0x07;
350 par
->Attribute
[8] = 0x08;
351 par
->Attribute
[9] = 0x09;
352 par
->Attribute
[10] = 0x0A;
353 par
->Attribute
[11] = 0x0B;
354 par
->Attribute
[12] = 0x0C;
355 par
->Attribute
[13] = 0x0D;
356 par
->Attribute
[14] = 0x0E;
357 par
->Attribute
[15] = 0x0F;
358 par
->Attribute
[16] = 0x41;
359 par
->Attribute
[17] = 0xFF;
360 par
->Attribute
[18] = 0x0F;
361 par
->Attribute
[19] = 0x00;
362 par
->Attribute
[20] = 0x00;
366 static void vgaHWLock(struct vgastate
*state
)
368 /* Protect CRTC[0-7] */
369 vga_wcrt(state
->vgabase
, 0x11, vga_rcrt(state
->vgabase
, 0x11) | 0x80);
372 static void vgaHWUnlock(void)
374 /* Unprotect CRTC[0-7] */
375 vga_wcrt(NULL
, 0x11, vga_rcrt(NULL
, 0x11) & ~0x80);
378 static void neoLock(struct vgastate
*state
)
380 vga_wgfx(state
->vgabase
, 0x09, 0x00);
384 static void neoUnlock(void)
387 vga_wgfx(NULL
, 0x09, 0x26);
391 * VGA Palette management
393 static int paletteEnabled
= 0;
395 static inline void VGAenablePalette(void)
397 vga_r(NULL
, VGA_IS1_RC
);
398 vga_w(NULL
, VGA_ATT_W
, 0x00);
402 static inline void VGAdisablePalette(void)
404 vga_r(NULL
, VGA_IS1_RC
);
405 vga_w(NULL
, VGA_ATT_W
, 0x20);
409 static inline void VGAwATTR(u8 index
, u8 value
)
416 vga_r(NULL
, VGA_IS1_RC
);
417 vga_wattr(NULL
, index
, value
);
420 static void vgaHWProtect(int on
)
426 * Turn off screen and disable sequencer.
428 tmp
= vga_rseq(NULL
, 0x01);
429 vga_wseq(NULL
, 0x00, 0x01); /* Synchronous Reset */
430 vga_wseq(NULL
, 0x01, tmp
| 0x20); /* disable the display */
435 * Reenable sequencer, then turn on screen.
437 tmp
= vga_rseq(NULL
, 0x01);
438 vga_wseq(NULL
, 0x01, tmp
& ~0x20); /* reenable display */
439 vga_wseq(NULL
, 0x00, 0x03); /* clear synchronousreset */
445 static void vgaHWRestore(const struct fb_info
*info
,
446 const struct neofb_par
*par
)
450 vga_w(NULL
, VGA_MIS_W
, par
->MiscOutReg
);
452 for (i
= 1; i
< 5; i
++)
453 vga_wseq(NULL
, i
, par
->Sequencer
[i
]);
455 /* Ensure CRTC registers 0-7 are unlocked by clearing bit 7 or CRTC[17] */
456 vga_wcrt(NULL
, 17, par
->CRTC
[17] & ~0x80);
458 for (i
= 0; i
< 25; i
++)
459 vga_wcrt(NULL
, i
, par
->CRTC
[i
]);
461 for (i
= 0; i
< 9; i
++)
462 vga_wgfx(NULL
, i
, par
->Graphics
[i
]);
466 for (i
= 0; i
< 21; i
++)
467 VGAwATTR(i
, par
->Attribute
[i
]);
473 /* -------------------- Hardware specific routines ------------------------- */
476 * Hardware Acceleration for Neo2200+
478 static inline int neo2200_sync(struct fb_info
*info
)
480 struct neofb_par
*par
= info
->par
;
482 while (readl(&par
->neo2200
->bltStat
) & 1);
486 static inline void neo2200_wait_fifo(struct fb_info
*info
,
487 int requested_fifo_space
)
489 // ndev->neo.waitfifo_calls++;
490 // ndev->neo.waitfifo_sum += requested_fifo_space;
492 /* FIXME: does not work
493 if (neo_fifo_space < requested_fifo_space)
495 neo_fifo_waitcycles++;
499 neo_fifo_space = (neo2200->bltStat >> 8);
500 if (neo_fifo_space >= requested_fifo_space)
506 neo_fifo_cache_hits++;
509 neo_fifo_space -= requested_fifo_space;
515 static inline void neo2200_accel_init(struct fb_info
*info
,
516 struct fb_var_screeninfo
*var
)
518 struct neofb_par
*par
= info
->par
;
519 Neo2200 __iomem
*neo2200
= par
->neo2200
;
524 switch (var
->bits_per_pixel
) {
526 bltMod
= NEO_MODE1_DEPTH8
;
527 pitch
= var
->xres_virtual
;
531 bltMod
= NEO_MODE1_DEPTH16
;
532 pitch
= var
->xres_virtual
* 2;
535 bltMod
= NEO_MODE1_DEPTH24
;
536 pitch
= var
->xres_virtual
* 3;
540 "neofb: neo2200_accel_init: unexpected bits per pixel!\n");
544 writel(bltMod
<< 16, &neo2200
->bltStat
);
545 writel((pitch
<< 16) | pitch
, &neo2200
->pitch
);
548 /* --------------------------------------------------------------------- */
551 neofb_open(struct fb_info
*info
, int user
)
553 struct neofb_par
*par
= info
->par
;
555 mutex_lock(&par
->open_lock
);
556 if (!par
->ref_count
) {
557 memset(&par
->state
, 0, sizeof(struct vgastate
));
558 par
->state
.flags
= VGA_SAVE_MODE
| VGA_SAVE_FONTS
;
559 save_vga(&par
->state
);
562 mutex_unlock(&par
->open_lock
);
568 neofb_release(struct fb_info
*info
, int user
)
570 struct neofb_par
*par
= info
->par
;
572 mutex_lock(&par
->open_lock
);
573 if (!par
->ref_count
) {
574 mutex_unlock(&par
->open_lock
);
577 if (par
->ref_count
== 1) {
578 restore_vga(&par
->state
);
581 mutex_unlock(&par
->open_lock
);
587 neofb_check_var(struct fb_var_screeninfo
*var
, struct fb_info
*info
)
589 struct neofb_par
*par
= info
->par
;
590 unsigned int pixclock
= var
->pixclock
;
591 struct xtimings timings
;
595 DBG("neofb_check_var");
598 pixclock
= 10000; /* 10ns = 100MHz */
599 timings
.pixclock
= 1000000000 / pixclock
;
600 if (timings
.pixclock
< 1)
601 timings
.pixclock
= 1;
603 if (timings
.pixclock
> par
->maxClock
)
606 timings
.dblscan
= var
->vmode
& FB_VMODE_DOUBLE
;
607 timings
.interlaced
= var
->vmode
& FB_VMODE_INTERLACED
;
608 timings
.HDisplay
= var
->xres
;
609 timings
.HSyncStart
= timings
.HDisplay
+ var
->right_margin
;
610 timings
.HSyncEnd
= timings
.HSyncStart
+ var
->hsync_len
;
611 timings
.HTotal
= timings
.HSyncEnd
+ var
->left_margin
;
612 timings
.VDisplay
= var
->yres
;
613 timings
.VSyncStart
= timings
.VDisplay
+ var
->lower_margin
;
614 timings
.VSyncEnd
= timings
.VSyncStart
+ var
->vsync_len
;
615 timings
.VTotal
= timings
.VSyncEnd
+ var
->upper_margin
;
616 timings
.sync
= var
->sync
;
618 /* Is the mode larger than the LCD panel? */
619 if (par
->internal_display
&&
620 ((var
->xres
> par
->NeoPanelWidth
) ||
621 (var
->yres
> par
->NeoPanelHeight
))) {
623 "Mode (%dx%d) larger than the LCD panel (%dx%d)\n",
624 var
->xres
, var
->yres
, par
->NeoPanelWidth
,
625 par
->NeoPanelHeight
);
629 /* Is the mode one of the acceptable sizes? */
630 if (!par
->internal_display
)
635 if (var
->yres
== 1024)
639 if (var
->yres
== 768)
643 if (var
->yres
== (par
->libretto
? 480 : 600))
647 if (var
->yres
== 480)
655 "Mode (%dx%d) won't display properly on LCD\n",
656 var
->xres
, var
->yres
);
660 var
->red
.msb_right
= 0;
661 var
->green
.msb_right
= 0;
662 var
->blue
.msb_right
= 0;
663 var
->transp
.msb_right
= 0;
665 switch (var
->bits_per_pixel
) {
666 case 8: /* PSEUDOCOLOUR, 256 */
667 var
->transp
.offset
= 0;
668 var
->transp
.length
= 0;
671 var
->green
.offset
= 0;
672 var
->green
.length
= 8;
673 var
->blue
.offset
= 0;
674 var
->blue
.length
= 8;
677 case 16: /* DIRECTCOLOUR, 64k */
678 var
->transp
.offset
= 0;
679 var
->transp
.length
= 0;
680 var
->red
.offset
= 11;
682 var
->green
.offset
= 5;
683 var
->green
.length
= 6;
684 var
->blue
.offset
= 0;
685 var
->blue
.length
= 5;
688 case 24: /* TRUECOLOUR, 16m */
689 var
->transp
.offset
= 0;
690 var
->transp
.length
= 0;
691 var
->red
.offset
= 16;
693 var
->green
.offset
= 8;
694 var
->green
.length
= 8;
695 var
->blue
.offset
= 0;
696 var
->blue
.length
= 8;
699 #ifdef NO_32BIT_SUPPORT_YET
700 case 32: /* TRUECOLOUR, 16m */
701 var
->transp
.offset
= 24;
702 var
->transp
.length
= 8;
703 var
->red
.offset
= 16;
705 var
->green
.offset
= 8;
706 var
->green
.length
= 8;
707 var
->blue
.offset
= 0;
708 var
->blue
.length
= 8;
712 printk(KERN_WARNING
"neofb: no support for %dbpp\n",
713 var
->bits_per_pixel
);
717 vramlen
= info
->fix
.smem_len
;
718 if (vramlen
> 4 * 1024 * 1024)
719 vramlen
= 4 * 1024 * 1024;
721 if (var
->yres_virtual
< var
->yres
)
722 var
->yres_virtual
= var
->yres
;
723 if (var
->xres_virtual
< var
->xres
)
724 var
->xres_virtual
= var
->xres
;
726 memlen
= var
->xres_virtual
* var
->bits_per_pixel
* var
->yres_virtual
>> 3;
728 if (memlen
> vramlen
) {
729 var
->yres_virtual
= vramlen
* 8 / (var
->xres_virtual
*
730 var
->bits_per_pixel
);
731 memlen
= var
->xres_virtual
* var
->bits_per_pixel
*
732 var
->yres_virtual
/ 8;
735 /* we must round yres/xres down, we already rounded y/xres_virtual up
736 if it was possible. We should return -EINVAL, but I disagree */
737 if (var
->yres_virtual
< var
->yres
)
738 var
->yres
= var
->yres_virtual
;
739 if (var
->xres_virtual
< var
->xres
)
740 var
->xres
= var
->xres_virtual
;
741 if (var
->xoffset
+ var
->xres
> var
->xres_virtual
)
742 var
->xoffset
= var
->xres_virtual
- var
->xres
;
743 if (var
->yoffset
+ var
->yres
> var
->yres_virtual
)
744 var
->yoffset
= var
->yres_virtual
- var
->yres
;
750 if (var
->bits_per_pixel
>= 24 || !par
->neo2200
)
751 var
->accel_flags
&= ~FB_ACCELF_TEXT
;
755 static int neofb_set_par(struct fb_info
*info
)
757 struct neofb_par
*par
= info
->par
;
758 struct xtimings timings
;
762 int hoffset
, voffset
;
764 DBG("neofb_set_par");
768 vgaHWProtect(1); /* Blank the screen */
770 timings
.dblscan
= info
->var
.vmode
& FB_VMODE_DOUBLE
;
771 timings
.interlaced
= info
->var
.vmode
& FB_VMODE_INTERLACED
;
772 timings
.HDisplay
= info
->var
.xres
;
773 timings
.HSyncStart
= timings
.HDisplay
+ info
->var
.right_margin
;
774 timings
.HSyncEnd
= timings
.HSyncStart
+ info
->var
.hsync_len
;
775 timings
.HTotal
= timings
.HSyncEnd
+ info
->var
.left_margin
;
776 timings
.VDisplay
= info
->var
.yres
;
777 timings
.VSyncStart
= timings
.VDisplay
+ info
->var
.lower_margin
;
778 timings
.VSyncEnd
= timings
.VSyncStart
+ info
->var
.vsync_len
;
779 timings
.VTotal
= timings
.VSyncEnd
+ info
->var
.upper_margin
;
780 timings
.sync
= info
->var
.sync
;
781 timings
.pixclock
= PICOS2KHZ(info
->var
.pixclock
);
783 if (timings
.pixclock
< 1)
784 timings
.pixclock
= 1;
787 * This will allocate the datastructure and initialize all of the
788 * generic VGA registers.
791 if (vgaHWInit(&info
->var
, info
, par
, &timings
))
795 * The default value assigned by vgaHW.c is 0x41, but this does
796 * not work for NeoMagic.
798 par
->Attribute
[16] = 0x01;
800 switch (info
->var
.bits_per_pixel
) {
802 par
->CRTC
[0x13] = info
->var
.xres_virtual
>> 3;
803 par
->ExtCRTOffset
= info
->var
.xres_virtual
>> 11;
804 par
->ExtColorModeSelect
= 0x11;
807 par
->CRTC
[0x13] = info
->var
.xres_virtual
>> 2;
808 par
->ExtCRTOffset
= info
->var
.xres_virtual
>> 10;
809 par
->ExtColorModeSelect
= 0x13;
812 par
->CRTC
[0x13] = (info
->var
.xres_virtual
* 3) >> 3;
813 par
->ExtCRTOffset
= (info
->var
.xres_virtual
* 3) >> 11;
814 par
->ExtColorModeSelect
= 0x14;
816 #ifdef NO_32BIT_SUPPORT_YET
817 case 32: /* FIXME: guessed values */
818 par
->CRTC
[0x13] = info
->var
.xres_virtual
>> 1;
819 par
->ExtCRTOffset
= info
->var
.xres_virtual
>> 9;
820 par
->ExtColorModeSelect
= 0x15;
827 par
->ExtCRTDispAddr
= 0x10;
829 /* Vertical Extension */
830 par
->VerticalExt
= (((timings
.VTotal
- 2) & 0x400) >> 10)
831 | (((timings
.VDisplay
- 1) & 0x400) >> 9)
832 | (((timings
.VSyncStart
) & 0x400) >> 8)
833 | (((timings
.VSyncStart
) & 0x400) >> 7);
835 /* Fast write bursts on unless disabled. */
837 par
->SysIfaceCntl1
= 0x30;
839 par
->SysIfaceCntl1
= 0x00;
841 par
->SysIfaceCntl2
= 0xc0; /* VESA Bios sets this to 0x80! */
843 /* Initialize: by default, we want display config register to be read */
844 par
->PanelDispCntlRegRead
= 1;
846 /* Enable any user specified display devices. */
847 par
->PanelDispCntlReg1
= 0x00;
848 if (par
->internal_display
)
849 par
->PanelDispCntlReg1
|= 0x02;
850 if (par
->external_display
)
851 par
->PanelDispCntlReg1
|= 0x01;
853 /* If the user did not specify any display devices, then... */
854 if (par
->PanelDispCntlReg1
== 0x00) {
855 /* Default to internal (i.e., LCD) only. */
856 par
->PanelDispCntlReg1
= vga_rgfx(NULL
, 0x20) & 0x03;
859 /* If we are using a fixed mode, then tell the chip we are. */
860 switch (info
->var
.xres
) {
862 par
->PanelDispCntlReg1
|= 0x60;
865 par
->PanelDispCntlReg1
|= 0x40;
868 par
->PanelDispCntlReg1
|= 0x20;
875 /* Setup shadow register locking. */
876 switch (par
->PanelDispCntlReg1
& 0x03) {
877 case 0x01: /* External CRT only mode: */
878 par
->GeneralLockReg
= 0x00;
879 /* We need to program the VCLK for external display only mode. */
880 par
->ProgramVCLK
= 1;
882 case 0x02: /* Internal LCD only mode: */
883 case 0x03: /* Simultaneous internal/external (LCD/CRT) mode: */
884 par
->GeneralLockReg
= 0x01;
885 /* Don't program the VCLK when using the LCD. */
886 par
->ProgramVCLK
= 0;
891 * If the screen is to be stretched, turn on stretching for the
894 * OPTION_LCD_STRETCH means stretching should be turned off!
896 par
->PanelDispCntlReg2
= 0x00;
897 par
->PanelDispCntlReg3
= 0x00;
899 if (par
->lcd_stretch
&& (par
->PanelDispCntlReg1
== 0x02) && /* LCD only */
900 (info
->var
.xres
!= par
->NeoPanelWidth
)) {
901 switch (info
->var
.xres
) {
902 case 320: /* Needs testing. KEM -- 24 May 98 */
903 case 400: /* Needs testing. KEM -- 24 May 98 */
908 par
->PanelDispCntlReg2
|= 0xC6;
912 /* No stretching in these modes. */
918 * If the screen is to be centerd, turn on the centering for the
921 par
->PanelVertCenterReg1
= 0x00;
922 par
->PanelVertCenterReg2
= 0x00;
923 par
->PanelVertCenterReg3
= 0x00;
924 par
->PanelVertCenterReg4
= 0x00;
925 par
->PanelVertCenterReg5
= 0x00;
926 par
->PanelHorizCenterReg1
= 0x00;
927 par
->PanelHorizCenterReg2
= 0x00;
928 par
->PanelHorizCenterReg3
= 0x00;
929 par
->PanelHorizCenterReg4
= 0x00;
930 par
->PanelHorizCenterReg5
= 0x00;
933 if (par
->PanelDispCntlReg1
& 0x02) {
934 if (info
->var
.xres
== par
->NeoPanelWidth
) {
936 * No centering required when the requested display width
937 * equals the panel width.
940 par
->PanelDispCntlReg2
|= 0x01;
941 par
->PanelDispCntlReg3
|= 0x10;
943 /* Calculate the horizontal and vertical offsets. */
946 ((par
->NeoPanelWidth
-
947 info
->var
.xres
) >> 4) - 1;
949 ((par
->NeoPanelHeight
-
950 info
->var
.yres
) >> 1) - 2;
952 /* Stretched modes cannot be centered. */
957 switch (info
->var
.xres
) {
958 case 320: /* Needs testing. KEM -- 24 May 98 */
959 par
->PanelHorizCenterReg3
= hoffset
;
960 par
->PanelVertCenterReg2
= voffset
;
962 case 400: /* Needs testing. KEM -- 24 May 98 */
963 par
->PanelHorizCenterReg4
= hoffset
;
964 par
->PanelVertCenterReg1
= voffset
;
967 par
->PanelHorizCenterReg1
= hoffset
;
968 par
->PanelVertCenterReg3
= voffset
;
971 par
->PanelHorizCenterReg2
= hoffset
;
972 par
->PanelVertCenterReg4
= voffset
;
975 par
->PanelHorizCenterReg5
= hoffset
;
976 par
->PanelVertCenterReg5
= voffset
;
980 /* No centering in these modes. */
987 neoFindMode(info
->var
.xres
, info
->var
.yres
,
988 info
->var
.bits_per_pixel
);
991 * Calculate the VCLK that most closely matches the requested dot
994 neoCalcVCLK(info
, par
, timings
.pixclock
);
996 /* Since we program the clocks ourselves, always use VCLK3. */
997 par
->MiscOutReg
|= 0x0C;
999 /* alread unlocked above */
1000 /* BOGUS vga_wgfx(NULL, 0x09, 0x26); */
1002 /* don't know what this is, but it's 0 from bootup anyway */
1003 vga_wgfx(NULL
, 0x15, 0x00);
1005 /* was set to 0x01 by my bios in text and vesa modes */
1006 vga_wgfx(NULL
, 0x0A, par
->GeneralLockReg
);
1009 * The color mode needs to be set before calling vgaHWRestore
1010 * to ensure the DAC is initialized properly.
1012 * NOTE: Make sure we don't change bits make sure we don't change
1013 * any reserved bits.
1015 temp
= vga_rgfx(NULL
, 0x90);
1016 switch (info
->fix
.accel
) {
1017 case FB_ACCEL_NEOMAGIC_NM2070
:
1018 temp
&= 0xF0; /* Save bits 7:4 */
1019 temp
|= (par
->ExtColorModeSelect
& ~0xF0);
1021 case FB_ACCEL_NEOMAGIC_NM2090
:
1022 case FB_ACCEL_NEOMAGIC_NM2093
:
1023 case FB_ACCEL_NEOMAGIC_NM2097
:
1024 case FB_ACCEL_NEOMAGIC_NM2160
:
1025 case FB_ACCEL_NEOMAGIC_NM2200
:
1026 case FB_ACCEL_NEOMAGIC_NM2230
:
1027 case FB_ACCEL_NEOMAGIC_NM2360
:
1028 case FB_ACCEL_NEOMAGIC_NM2380
:
1029 temp
&= 0x70; /* Save bits 6:4 */
1030 temp
|= (par
->ExtColorModeSelect
& ~0x70);
1034 vga_wgfx(NULL
, 0x90, temp
);
1037 * In some rare cases a lockup might occur if we don't delay
1038 * here. (Reported by Miles Lane)
1043 * Disable horizontal and vertical graphics and text expansions so
1044 * that vgaHWRestore works properly.
1046 temp
= vga_rgfx(NULL
, 0x25);
1048 vga_wgfx(NULL
, 0x25, temp
);
1051 * Sleep for 200ms to make sure that the two operations above have
1052 * had time to take effect.
1057 * This function handles restoring the generic VGA registers. */
1058 vgaHWRestore(info
, par
);
1060 /* linear colormap for non palettized modes */
1061 switch (info
->var
.bits_per_pixel
) {
1063 /* PseudoColor, 256 */
1064 info
->fix
.visual
= FB_VISUAL_PSEUDOCOLOR
;
1067 /* TrueColor, 64k */
1068 info
->fix
.visual
= FB_VISUAL_TRUECOLOR
;
1070 for (i
= 0; i
< 64; i
++) {
1073 outb(i
<< 1, 0x3c9);
1075 outb(i
<< 1, 0x3c9);
1079 #ifdef NO_32BIT_SUPPORT_YET
1082 /* TrueColor, 16m */
1083 info
->fix
.visual
= FB_VISUAL_TRUECOLOR
;
1085 for (i
= 0; i
< 256; i
++) {
1095 vga_wgfx(NULL
, 0x0E, par
->ExtCRTDispAddr
);
1096 vga_wgfx(NULL
, 0x0F, par
->ExtCRTOffset
);
1097 temp
= vga_rgfx(NULL
, 0x10);
1098 temp
&= 0x0F; /* Save bits 3:0 */
1099 temp
|= (par
->SysIfaceCntl1
& ~0x0F); /* VESA Bios sets bit 1! */
1100 vga_wgfx(NULL
, 0x10, temp
);
1102 vga_wgfx(NULL
, 0x11, par
->SysIfaceCntl2
);
1103 vga_wgfx(NULL
, 0x15, 0 /*par->SingleAddrPage */ );
1104 vga_wgfx(NULL
, 0x16, 0 /*par->DualAddrPage */ );
1106 temp
= vga_rgfx(NULL
, 0x20);
1107 switch (info
->fix
.accel
) {
1108 case FB_ACCEL_NEOMAGIC_NM2070
:
1109 temp
&= 0xFC; /* Save bits 7:2 */
1110 temp
|= (par
->PanelDispCntlReg1
& ~0xFC);
1112 case FB_ACCEL_NEOMAGIC_NM2090
:
1113 case FB_ACCEL_NEOMAGIC_NM2093
:
1114 case FB_ACCEL_NEOMAGIC_NM2097
:
1115 case FB_ACCEL_NEOMAGIC_NM2160
:
1116 temp
&= 0xDC; /* Save bits 7:6,4:2 */
1117 temp
|= (par
->PanelDispCntlReg1
& ~0xDC);
1119 case FB_ACCEL_NEOMAGIC_NM2200
:
1120 case FB_ACCEL_NEOMAGIC_NM2230
:
1121 case FB_ACCEL_NEOMAGIC_NM2360
:
1122 case FB_ACCEL_NEOMAGIC_NM2380
:
1123 temp
&= 0x98; /* Save bits 7,4:3 */
1124 temp
|= (par
->PanelDispCntlReg1
& ~0x98);
1127 vga_wgfx(NULL
, 0x20, temp
);
1129 temp
= vga_rgfx(NULL
, 0x25);
1130 temp
&= 0x38; /* Save bits 5:3 */
1131 temp
|= (par
->PanelDispCntlReg2
& ~0x38);
1132 vga_wgfx(NULL
, 0x25, temp
);
1134 if (info
->fix
.accel
!= FB_ACCEL_NEOMAGIC_NM2070
) {
1135 temp
= vga_rgfx(NULL
, 0x30);
1136 temp
&= 0xEF; /* Save bits 7:5 and bits 3:0 */
1137 temp
|= (par
->PanelDispCntlReg3
& ~0xEF);
1138 vga_wgfx(NULL
, 0x30, temp
);
1141 vga_wgfx(NULL
, 0x28, par
->PanelVertCenterReg1
);
1142 vga_wgfx(NULL
, 0x29, par
->PanelVertCenterReg2
);
1143 vga_wgfx(NULL
, 0x2a, par
->PanelVertCenterReg3
);
1145 if (info
->fix
.accel
!= FB_ACCEL_NEOMAGIC_NM2070
) {
1146 vga_wgfx(NULL
, 0x32, par
->PanelVertCenterReg4
);
1147 vga_wgfx(NULL
, 0x33, par
->PanelHorizCenterReg1
);
1148 vga_wgfx(NULL
, 0x34, par
->PanelHorizCenterReg2
);
1149 vga_wgfx(NULL
, 0x35, par
->PanelHorizCenterReg3
);
1152 if (info
->fix
.accel
== FB_ACCEL_NEOMAGIC_NM2160
)
1153 vga_wgfx(NULL
, 0x36, par
->PanelHorizCenterReg4
);
1155 if (info
->fix
.accel
== FB_ACCEL_NEOMAGIC_NM2200
||
1156 info
->fix
.accel
== FB_ACCEL_NEOMAGIC_NM2230
||
1157 info
->fix
.accel
== FB_ACCEL_NEOMAGIC_NM2360
||
1158 info
->fix
.accel
== FB_ACCEL_NEOMAGIC_NM2380
) {
1159 vga_wgfx(NULL
, 0x36, par
->PanelHorizCenterReg4
);
1160 vga_wgfx(NULL
, 0x37, par
->PanelVertCenterReg5
);
1161 vga_wgfx(NULL
, 0x38, par
->PanelHorizCenterReg5
);
1166 /* Program VCLK3 if needed. */
1167 if (par
->ProgramVCLK
&& ((vga_rgfx(NULL
, 0x9B) != par
->VCLK3NumeratorLow
)
1168 || (vga_rgfx(NULL
, 0x9F) != par
->VCLK3Denominator
)
1169 || (clock_hi
&& ((vga_rgfx(NULL
, 0x8F) & ~0x0f)
1170 != (par
->VCLK3NumeratorHigh
&
1172 vga_wgfx(NULL
, 0x9B, par
->VCLK3NumeratorLow
);
1174 temp
= vga_rgfx(NULL
, 0x8F);
1175 temp
&= 0x0F; /* Save bits 3:0 */
1176 temp
|= (par
->VCLK3NumeratorHigh
& ~0x0F);
1177 vga_wgfx(NULL
, 0x8F, temp
);
1179 vga_wgfx(NULL
, 0x9F, par
->VCLK3Denominator
);
1183 vga_wcrt(NULL
, 0x23, par
->biosMode
);
1185 vga_wgfx(NULL
, 0x93, 0xc0); /* Gives 5x faster framebuffer writes !!! */
1187 /* Program vertical extension register */
1188 if (info
->fix
.accel
== FB_ACCEL_NEOMAGIC_NM2200
||
1189 info
->fix
.accel
== FB_ACCEL_NEOMAGIC_NM2230
||
1190 info
->fix
.accel
== FB_ACCEL_NEOMAGIC_NM2360
||
1191 info
->fix
.accel
== FB_ACCEL_NEOMAGIC_NM2380
) {
1192 vga_wcrt(NULL
, 0x70, par
->VerticalExt
);
1195 vgaHWProtect(0); /* Turn on screen */
1197 /* Calling this also locks offset registers required in update_start */
1198 neoLock(&par
->state
);
1200 info
->fix
.line_length
=
1201 info
->var
.xres_virtual
* (info
->var
.bits_per_pixel
>> 3);
1203 switch (info
->fix
.accel
) {
1204 case FB_ACCEL_NEOMAGIC_NM2200
:
1205 case FB_ACCEL_NEOMAGIC_NM2230
:
1206 case FB_ACCEL_NEOMAGIC_NM2360
:
1207 case FB_ACCEL_NEOMAGIC_NM2380
:
1208 neo2200_accel_init(info
, &info
->var
);
1216 static void neofb_update_start(struct fb_info
*info
,
1217 struct fb_var_screeninfo
*var
)
1219 struct neofb_par
*par
= info
->par
;
1220 struct vgastate
*state
= &par
->state
;
1221 int oldExtCRTDispAddr
;
1224 DBG("neofb_update_start");
1226 Base
= (var
->yoffset
* var
->xres_virtual
+ var
->xoffset
) >> 2;
1227 Base
*= (var
->bits_per_pixel
+ 7) / 8;
1232 * These are the generic starting address registers.
1234 vga_wcrt(state
->vgabase
, 0x0C, (Base
& 0x00FF00) >> 8);
1235 vga_wcrt(state
->vgabase
, 0x0D, (Base
& 0x00FF));
1238 * Make sure we don't clobber some other bits that might already
1239 * have been set. NOTE: NM2200 has a writable bit 3, but it shouldn't
1242 oldExtCRTDispAddr
= vga_rgfx(NULL
, 0x0E);
1243 vga_wgfx(state
->vgabase
, 0x0E, (((Base
>> 16) & 0x0f) | (oldExtCRTDispAddr
& 0xf0)));
1249 * Pan or Wrap the Display
1251 static int neofb_pan_display(struct fb_var_screeninfo
*var
,
1252 struct fb_info
*info
)
1256 y_bottom
= var
->yoffset
;
1258 if (!(var
->vmode
& FB_VMODE_YWRAP
))
1259 y_bottom
+= var
->yres
;
1261 if (var
->xoffset
> (var
->xres_virtual
- var
->xres
))
1263 if (y_bottom
> info
->var
.yres_virtual
)
1266 neofb_update_start(info
, var
);
1268 info
->var
.xoffset
= var
->xoffset
;
1269 info
->var
.yoffset
= var
->yoffset
;
1271 if (var
->vmode
& FB_VMODE_YWRAP
)
1272 info
->var
.vmode
|= FB_VMODE_YWRAP
;
1274 info
->var
.vmode
&= ~FB_VMODE_YWRAP
;
1278 static int neofb_setcolreg(u_int regno
, u_int red
, u_int green
, u_int blue
,
1279 u_int transp
, struct fb_info
*fb
)
1281 if (regno
>= fb
->cmap
.len
|| regno
> 255)
1284 if (fb
->var
.bits_per_pixel
<= 8) {
1287 outb(red
>> 10, 0x3c9);
1288 outb(green
>> 10, 0x3c9);
1289 outb(blue
>> 10, 0x3c9);
1290 } else if (regno
< 16) {
1291 switch (fb
->var
.bits_per_pixel
) {
1293 ((u32
*) fb
->pseudo_palette
)[regno
] =
1294 ((red
& 0xf800)) | ((green
& 0xfc00) >> 5) |
1295 ((blue
& 0xf800) >> 11);
1298 ((u32
*) fb
->pseudo_palette
)[regno
] =
1299 ((red
& 0xff00) << 8) | ((green
& 0xff00)) |
1300 ((blue
& 0xff00) >> 8);
1302 #ifdef NO_32BIT_SUPPORT_YET
1304 ((u32
*) fb
->pseudo_palette
)[regno
] =
1305 ((transp
& 0xff00) << 16) | ((red
& 0xff00) << 8) |
1306 ((green
& 0xff00)) | ((blue
& 0xff00) >> 8);
1318 * (Un)Blank the display.
1320 static int neofb_blank(int blank_mode
, struct fb_info
*info
)
1323 * Blank the screen if blank_mode != 0, else unblank.
1324 * Return 0 if blanking succeeded, != 0 if un-/blanking failed due to
1325 * e.g. a video mode which doesn't support it. Implements VESA suspend
1326 * and powerdown modes for monitors, and backlight control on LCDs.
1327 * blank_mode == 0: unblanked (backlight on)
1328 * blank_mode == 1: blank (backlight on)
1329 * blank_mode == 2: suspend vsync (backlight off)
1330 * blank_mode == 3: suspend hsync (backlight off)
1331 * blank_mode == 4: powerdown (backlight off)
1333 * wms...Enable VESA DPMS compatible powerdown mode
1334 * run "setterm -powersave powerdown" to take advantage
1336 struct neofb_par
*par
= info
->par
;
1337 int seqflags
, lcdflags
, dpmsflags
, reg
, tmpdisp
;
1340 * Read back the register bits related to display configuration. They might
1341 * have been changed underneath the driver via Fn key stroke.
1344 tmpdisp
= vga_rgfx(NULL
, 0x20) & 0x03;
1345 neoLock(&par
->state
);
1347 /* In case we blank the screen, we want to store the possibly new
1348 * configuration in the driver. During un-blank, we re-apply this setting,
1349 * since the LCD bit will be cleared in order to switch off the backlight.
1351 if (par
->PanelDispCntlRegRead
) {
1352 par
->PanelDispCntlReg1
= tmpdisp
;
1354 par
->PanelDispCntlRegRead
= !blank_mode
;
1356 switch (blank_mode
) {
1357 case FB_BLANK_POWERDOWN
: /* powerdown - both sync lines down */
1358 seqflags
= VGA_SR01_SCREEN_OFF
; /* Disable sequencer */
1359 lcdflags
= 0; /* LCD off */
1360 dpmsflags
= NEO_GR01_SUPPRESS_HSYNC
|
1361 NEO_GR01_SUPPRESS_VSYNC
;
1362 #ifdef CONFIG_TOSHIBA
1363 /* Do we still need this ? */
1364 /* attempt to turn off backlight on toshiba; also turns off external */
1368 regs
.eax
= 0xff00; /* HCI_SET */
1369 regs
.ebx
= 0x0002; /* HCI_BACKLIGHT */
1370 regs
.ecx
= 0x0000; /* HCI_DISABLE */
1375 case FB_BLANK_HSYNC_SUSPEND
: /* hsync off */
1376 seqflags
= VGA_SR01_SCREEN_OFF
; /* Disable sequencer */
1377 lcdflags
= 0; /* LCD off */
1378 dpmsflags
= NEO_GR01_SUPPRESS_HSYNC
;
1380 case FB_BLANK_VSYNC_SUSPEND
: /* vsync off */
1381 seqflags
= VGA_SR01_SCREEN_OFF
; /* Disable sequencer */
1382 lcdflags
= 0; /* LCD off */
1383 dpmsflags
= NEO_GR01_SUPPRESS_VSYNC
;
1385 case FB_BLANK_NORMAL
: /* just blank screen (backlight stays on) */
1386 seqflags
= VGA_SR01_SCREEN_OFF
; /* Disable sequencer */
1388 * During a blank operation with the LID shut, we might store "LCD off"
1389 * by mistake. Due to timing issues, the BIOS may switch the lights
1390 * back on, and we turn it back off once we "unblank".
1392 * So here is an attempt to implement ">=" - if we are in the process
1393 * of unblanking, and the LCD bit is unset in the driver but set in the
1394 * register, we must keep it.
1396 lcdflags
= ((par
->PanelDispCntlReg1
| tmpdisp
) & 0x02); /* LCD normal */
1397 dpmsflags
= 0x00; /* no hsync/vsync suppression */
1399 case FB_BLANK_UNBLANK
: /* unblank */
1400 seqflags
= 0; /* Enable sequencer */
1401 lcdflags
= ((par
->PanelDispCntlReg1
| tmpdisp
) & 0x02); /* LCD normal */
1402 dpmsflags
= 0x00; /* no hsync/vsync suppression */
1403 #ifdef CONFIG_TOSHIBA
1404 /* Do we still need this ? */
1405 /* attempt to re-enable backlight/external on toshiba */
1409 regs
.eax
= 0xff00; /* HCI_SET */
1410 regs
.ebx
= 0x0002; /* HCI_BACKLIGHT */
1411 regs
.ecx
= 0x0001; /* HCI_ENABLE */
1416 default: /* Anything else we don't understand; return 1 to tell
1417 * fb_blank we didn't aactually do anything */
1422 reg
= (vga_rseq(NULL
, 0x01) & ~0x20) | seqflags
;
1423 vga_wseq(NULL
, 0x01, reg
);
1424 reg
= (vga_rgfx(NULL
, 0x20) & ~0x02) | lcdflags
;
1425 vga_wgfx(NULL
, 0x20, reg
);
1426 reg
= (vga_rgfx(NULL
, 0x01) & ~0xF0) | 0x80 | dpmsflags
;
1427 vga_wgfx(NULL
, 0x01, reg
);
1428 neoLock(&par
->state
);
1433 neo2200_fillrect(struct fb_info
*info
, const struct fb_fillrect
*rect
)
1435 struct neofb_par
*par
= info
->par
;
1438 dst
= rect
->dx
+ rect
->dy
* info
->var
.xres_virtual
;
1439 rop
= rect
->rop
? 0x060000 : 0x0c0000;
1441 neo2200_wait_fifo(info
, 4);
1443 /* set blt control */
1444 writel(NEO_BC3_FIFO_EN
|
1445 NEO_BC0_SRC_IS_FG
| NEO_BC3_SKIP_MAPPING
|
1446 // NEO_BC3_DST_XY_ADDR |
1447 // NEO_BC3_SRC_XY_ADDR |
1448 rop
, &par
->neo2200
->bltCntl
);
1450 switch (info
->var
.bits_per_pixel
) {
1452 writel(rect
->color
, &par
->neo2200
->fgColor
);
1456 writel(((u32
*) (info
->pseudo_palette
))[rect
->color
],
1457 &par
->neo2200
->fgColor
);
1461 writel(dst
* ((info
->var
.bits_per_pixel
+ 7) >> 3),
1462 &par
->neo2200
->dstStart
);
1463 writel((rect
->height
<< 16) | (rect
->width
& 0xffff),
1464 &par
->neo2200
->xyExt
);
1468 neo2200_copyarea(struct fb_info
*info
, const struct fb_copyarea
*area
)
1470 u32 sx
= area
->sx
, sy
= area
->sy
, dx
= area
->dx
, dy
= area
->dy
;
1471 struct neofb_par
*par
= info
->par
;
1472 u_long src
, dst
, bltCntl
;
1474 bltCntl
= NEO_BC3_FIFO_EN
| NEO_BC3_SKIP_MAPPING
| 0x0C0000;
1476 if ((dy
> sy
) || ((dy
== sy
) && (dx
> sx
))) {
1477 /* Start with the lower right corner */
1478 sy
+= (area
->height
- 1);
1479 dy
+= (area
->height
- 1);
1480 sx
+= (area
->width
- 1);
1481 dx
+= (area
->width
- 1);
1483 bltCntl
|= NEO_BC0_X_DEC
| NEO_BC0_DST_Y_DEC
| NEO_BC0_SRC_Y_DEC
;
1486 src
= sx
* (info
->var
.bits_per_pixel
>> 3) + sy
*info
->fix
.line_length
;
1487 dst
= dx
* (info
->var
.bits_per_pixel
>> 3) + dy
*info
->fix
.line_length
;
1489 neo2200_wait_fifo(info
, 4);
1491 /* set blt control */
1492 writel(bltCntl
, &par
->neo2200
->bltCntl
);
1494 writel(src
, &par
->neo2200
->srcStart
);
1495 writel(dst
, &par
->neo2200
->dstStart
);
1496 writel((area
->height
<< 16) | (area
->width
& 0xffff),
1497 &par
->neo2200
->xyExt
);
1501 neo2200_imageblit(struct fb_info
*info
, const struct fb_image
*image
)
1503 struct neofb_par
*par
= info
->par
;
1504 int s_pitch
= (image
->width
* image
->depth
+ 7) >> 3;
1505 int scan_align
= info
->pixmap
.scan_align
- 1;
1506 int buf_align
= info
->pixmap
.buf_align
- 1;
1507 int bltCntl_flags
, d_pitch
, data_len
;
1509 // The data is padded for the hardware
1510 d_pitch
= (s_pitch
+ scan_align
) & ~scan_align
;
1511 data_len
= ((d_pitch
* image
->height
) + buf_align
) & ~buf_align
;
1515 if (image
->depth
== 1) {
1516 if (info
->var
.bits_per_pixel
== 24 && image
->width
< 16) {
1517 /* FIXME. There is a bug with accelerated color-expanded
1518 * transfers in 24 bit mode if the image being transferred
1519 * is less than 16 bits wide. This is due to insufficient
1520 * padding when writing the image. We need to adjust
1521 * struct fb_pixmap. Not yet done. */
1522 return cfb_imageblit(info
, image
);
1524 bltCntl_flags
= NEO_BC0_SRC_MONO
;
1525 } else if (image
->depth
== info
->var
.bits_per_pixel
) {
1528 /* We don't currently support hardware acceleration if image
1529 * depth is different from display */
1530 return cfb_imageblit(info
, image
);
1533 switch (info
->var
.bits_per_pixel
) {
1535 writel(image
->fg_color
, &par
->neo2200
->fgColor
);
1536 writel(image
->bg_color
, &par
->neo2200
->bgColor
);
1540 writel(((u32
*) (info
->pseudo_palette
))[image
->fg_color
],
1541 &par
->neo2200
->fgColor
);
1542 writel(((u32
*) (info
->pseudo_palette
))[image
->bg_color
],
1543 &par
->neo2200
->bgColor
);
1547 writel(NEO_BC0_SYS_TO_VID
|
1548 NEO_BC3_SKIP_MAPPING
| bltCntl_flags
|
1549 // NEO_BC3_DST_XY_ADDR |
1550 0x0c0000, &par
->neo2200
->bltCntl
);
1552 writel(0, &par
->neo2200
->srcStart
);
1553 // par->neo2200->dstStart = (image->dy << 16) | (image->dx & 0xffff);
1554 writel(((image
->dx
& 0xffff) * (info
->var
.bits_per_pixel
>> 3) +
1555 image
->dy
* info
->fix
.line_length
), &par
->neo2200
->dstStart
);
1556 writel((image
->height
<< 16) | (image
->width
& 0xffff),
1557 &par
->neo2200
->xyExt
);
1559 memcpy_toio(par
->mmio_vbase
+ 0x100000, image
->data
, data_len
);
1563 neofb_fillrect(struct fb_info
*info
, const struct fb_fillrect
*rect
)
1565 switch (info
->fix
.accel
) {
1566 case FB_ACCEL_NEOMAGIC_NM2200
:
1567 case FB_ACCEL_NEOMAGIC_NM2230
:
1568 case FB_ACCEL_NEOMAGIC_NM2360
:
1569 case FB_ACCEL_NEOMAGIC_NM2380
:
1570 neo2200_fillrect(info
, rect
);
1573 cfb_fillrect(info
, rect
);
1579 neofb_copyarea(struct fb_info
*info
, const struct fb_copyarea
*area
)
1581 switch (info
->fix
.accel
) {
1582 case FB_ACCEL_NEOMAGIC_NM2200
:
1583 case FB_ACCEL_NEOMAGIC_NM2230
:
1584 case FB_ACCEL_NEOMAGIC_NM2360
:
1585 case FB_ACCEL_NEOMAGIC_NM2380
:
1586 neo2200_copyarea(info
, area
);
1589 cfb_copyarea(info
, area
);
1595 neofb_imageblit(struct fb_info
*info
, const struct fb_image
*image
)
1597 switch (info
->fix
.accel
) {
1598 case FB_ACCEL_NEOMAGIC_NM2200
:
1599 case FB_ACCEL_NEOMAGIC_NM2230
:
1600 case FB_ACCEL_NEOMAGIC_NM2360
:
1601 case FB_ACCEL_NEOMAGIC_NM2380
:
1602 neo2200_imageblit(info
, image
);
1605 cfb_imageblit(info
, image
);
1611 neofb_sync(struct fb_info
*info
)
1613 switch (info
->fix
.accel
) {
1614 case FB_ACCEL_NEOMAGIC_NM2200
:
1615 case FB_ACCEL_NEOMAGIC_NM2230
:
1616 case FB_ACCEL_NEOMAGIC_NM2360
:
1617 case FB_ACCEL_NEOMAGIC_NM2380
:
1628 neofb_draw_cursor(struct fb_info *info, u8 *dst, u8 *src, unsigned int width)
1630 //memset_io(info->sprite.addr, 0xff, 1);
1634 neofb_cursor(struct fb_info *info, struct fb_cursor *cursor)
1636 struct neofb_par *par = (struct neofb_par *) info->par;
1639 write_le32(NEOREG_CURSCNTL, ~NEO_CURS_ENABLE, par);
1641 if (cursor->set & FB_CUR_SETPOS) {
1642 u32 x = cursor->image.dx;
1643 u32 y = cursor->image.dy;
1645 info->cursor.image.dx = x;
1646 info->cursor.image.dy = y;
1647 write_le32(NEOREG_CURSX, x, par);
1648 write_le32(NEOREG_CURSY, y, par);
1651 if (cursor->set & FB_CUR_SETSIZE) {
1652 info->cursor.image.height = cursor->image.height;
1653 info->cursor.image.width = cursor->image.width;
1656 if (cursor->set & FB_CUR_SETHOT)
1657 info->cursor.hot = cursor->hot;
1659 if (cursor->set & FB_CUR_SETCMAP) {
1660 if (cursor->image.depth == 1) {
1661 u32 fg = cursor->image.fg_color;
1662 u32 bg = cursor->image.bg_color;
1664 info->cursor.image.fg_color = fg;
1665 info->cursor.image.bg_color = bg;
1667 fg = ((fg & 0xff0000) >> 16) | ((fg & 0xff) << 16) | (fg & 0xff00);
1668 bg = ((bg & 0xff0000) >> 16) | ((bg & 0xff) << 16) | (bg & 0xff00);
1669 write_le32(NEOREG_CURSFGCOLOR, fg, par);
1670 write_le32(NEOREG_CURSBGCOLOR, bg, par);
1674 if (cursor->set & FB_CUR_SETSHAPE)
1675 fb_load_cursor_image(info);
1677 if (info->cursor.enable)
1678 write_le32(NEOREG_CURSCNTL, NEO_CURS_ENABLE, par);
1683 static struct fb_ops neofb_ops
= {
1684 .owner
= THIS_MODULE
,
1685 .fb_open
= neofb_open
,
1686 .fb_release
= neofb_release
,
1687 .fb_check_var
= neofb_check_var
,
1688 .fb_set_par
= neofb_set_par
,
1689 .fb_setcolreg
= neofb_setcolreg
,
1690 .fb_pan_display
= neofb_pan_display
,
1691 .fb_blank
= neofb_blank
,
1692 .fb_sync
= neofb_sync
,
1693 .fb_fillrect
= neofb_fillrect
,
1694 .fb_copyarea
= neofb_copyarea
,
1695 .fb_imageblit
= neofb_imageblit
,
1698 /* --------------------------------------------------------------------- */
1700 static struct fb_videomode __devinitdata mode800x480
= {
1710 .sync
= FB_SYNC_HOR_HIGH_ACT
| FB_SYNC_VERT_HIGH_ACT
,
1711 .vmode
= FB_VMODE_NONINTERLACED
1714 static int __devinit
neo_map_mmio(struct fb_info
*info
,
1715 struct pci_dev
*dev
)
1717 struct neofb_par
*par
= info
->par
;
1719 DBG("neo_map_mmio");
1721 switch (info
->fix
.accel
) {
1722 case FB_ACCEL_NEOMAGIC_NM2070
:
1723 info
->fix
.mmio_start
= pci_resource_start(dev
, 0)+
1726 case FB_ACCEL_NEOMAGIC_NM2090
:
1727 case FB_ACCEL_NEOMAGIC_NM2093
:
1728 info
->fix
.mmio_start
= pci_resource_start(dev
, 0)+
1731 case FB_ACCEL_NEOMAGIC_NM2160
:
1732 case FB_ACCEL_NEOMAGIC_NM2097
:
1733 case FB_ACCEL_NEOMAGIC_NM2200
:
1734 case FB_ACCEL_NEOMAGIC_NM2230
:
1735 case FB_ACCEL_NEOMAGIC_NM2360
:
1736 case FB_ACCEL_NEOMAGIC_NM2380
:
1737 info
->fix
.mmio_start
= pci_resource_start(dev
, 1);
1740 info
->fix
.mmio_start
= pci_resource_start(dev
, 0);
1742 info
->fix
.mmio_len
= MMIO_SIZE
;
1744 if (!request_mem_region
1745 (info
->fix
.mmio_start
, MMIO_SIZE
, "memory mapped I/O")) {
1746 printk("neofb: memory mapped IO in use\n");
1750 par
->mmio_vbase
= ioremap(info
->fix
.mmio_start
, MMIO_SIZE
);
1751 if (!par
->mmio_vbase
) {
1752 printk("neofb: unable to map memory mapped IO\n");
1753 release_mem_region(info
->fix
.mmio_start
,
1754 info
->fix
.mmio_len
);
1757 printk(KERN_INFO
"neofb: mapped io at %p\n",
1762 static void neo_unmap_mmio(struct fb_info
*info
)
1764 struct neofb_par
*par
= info
->par
;
1766 DBG("neo_unmap_mmio");
1768 iounmap(par
->mmio_vbase
);
1769 par
->mmio_vbase
= NULL
;
1771 release_mem_region(info
->fix
.mmio_start
,
1772 info
->fix
.mmio_len
);
1775 static int __devinit
neo_map_video(struct fb_info
*info
,
1776 struct pci_dev
*dev
, int video_len
)
1778 //unsigned long addr;
1780 DBG("neo_map_video");
1782 info
->fix
.smem_start
= pci_resource_start(dev
, 0);
1783 info
->fix
.smem_len
= video_len
;
1785 if (!request_mem_region(info
->fix
.smem_start
, info
->fix
.smem_len
,
1787 printk("neofb: frame buffer in use\n");
1792 ioremap(info
->fix
.smem_start
, info
->fix
.smem_len
);
1793 if (!info
->screen_base
) {
1794 printk("neofb: unable to map screen memory\n");
1795 release_mem_region(info
->fix
.smem_start
,
1796 info
->fix
.smem_len
);
1799 printk(KERN_INFO
"neofb: mapped framebuffer at %p\n",
1803 ((struct neofb_par
*)(info
->par
))->mtrr
=
1804 mtrr_add(info
->fix
.smem_start
, pci_resource_len(dev
, 0),
1805 MTRR_TYPE_WRCOMB
, 1);
1808 /* Clear framebuffer, it's all white in memory after boot */
1809 memset_io(info
->screen_base
, 0, info
->fix
.smem_len
);
1811 /* Allocate Cursor drawing pad.
1812 info->fix.smem_len -= PAGE_SIZE;
1813 addr = info->fix.smem_start + info->fix.smem_len;
1814 write_le32(NEOREG_CURSMEMPOS, ((0x000f & (addr >> 10)) << 8) |
1815 ((0x0ff0 & (addr >> 10)) >> 4), par);
1816 addr = (unsigned long) info->screen_base + info->fix.smem_len;
1817 info->sprite.addr = (u8 *) addr; */
1821 static void neo_unmap_video(struct fb_info
*info
)
1823 DBG("neo_unmap_video");
1827 struct neofb_par
*par
= info
->par
;
1829 mtrr_del(par
->mtrr
, info
->fix
.smem_start
,
1830 info
->fix
.smem_len
);
1833 iounmap(info
->screen_base
);
1834 info
->screen_base
= NULL
;
1836 release_mem_region(info
->fix
.smem_start
,
1837 info
->fix
.smem_len
);
1840 static int __devinit
neo_scan_monitor(struct fb_info
*info
)
1842 struct neofb_par
*par
= info
->par
;
1843 unsigned char type
, display
;
1846 // Eventually we will have i2c support.
1847 info
->monspecs
.modedb
= kmalloc(sizeof(struct fb_videomode
), GFP_KERNEL
);
1848 if (!info
->monspecs
.modedb
)
1850 info
->monspecs
.modedb_len
= 1;
1852 /* Determine the panel type */
1853 vga_wgfx(NULL
, 0x09, 0x26);
1854 type
= vga_rgfx(NULL
, 0x21);
1855 display
= vga_rgfx(NULL
, 0x20);
1856 if (!par
->internal_display
&& !par
->external_display
) {
1857 par
->internal_display
= display
& 2 || !(display
& 3) ? 1 : 0;
1858 par
->external_display
= display
& 1;
1859 printk (KERN_INFO
"Autodetected %s display\n",
1860 par
->internal_display
&& par
->external_display
? "simultaneous" :
1861 par
->internal_display
? "internal" : "external");
1864 /* Determine panel width -- used in NeoValidMode. */
1865 w
= vga_rgfx(NULL
, 0x20);
1866 vga_wgfx(NULL
, 0x09, 0x00);
1867 switch ((w
& 0x18) >> 3) {
1870 par
->NeoPanelWidth
= 640;
1871 par
->NeoPanelHeight
= 480;
1872 memcpy(info
->monspecs
.modedb
, &vesa_modes
[3], sizeof(struct fb_videomode
));
1875 par
->NeoPanelWidth
= 800;
1876 if (par
->libretto
) {
1877 par
->NeoPanelHeight
= 480;
1878 memcpy(info
->monspecs
.modedb
, &mode800x480
, sizeof(struct fb_videomode
));
1881 par
->NeoPanelHeight
= 600;
1882 memcpy(info
->monspecs
.modedb
, &vesa_modes
[8], sizeof(struct fb_videomode
));
1887 par
->NeoPanelWidth
= 1024;
1888 par
->NeoPanelHeight
= 768;
1889 memcpy(info
->monspecs
.modedb
, &vesa_modes
[13], sizeof(struct fb_videomode
));
1892 /* 1280x1024@60 panel support needs to be added */
1894 par
->NeoPanelWidth
= 1280;
1895 par
->NeoPanelHeight
= 1024;
1896 memcpy(info
->monspecs
.modedb
, &vesa_modes
[20], sizeof(struct fb_videomode
));
1900 "neofb: Only 640x480, 800x600/480 and 1024x768 panels are currently supported\n");
1905 par
->NeoPanelWidth
= 640;
1906 par
->NeoPanelHeight
= 480;
1907 memcpy(info
->monspecs
.modedb
, &vesa_modes
[3], sizeof(struct fb_videomode
));
1911 printk(KERN_INFO
"Panel is a %dx%d %s %s display\n",
1913 par
->NeoPanelHeight
,
1914 (type
& 0x02) ? "color" : "monochrome",
1915 (type
& 0x10) ? "TFT" : "dual scan");
1919 static int __devinit
neo_init_hw(struct fb_info
*info
)
1921 struct neofb_par
*par
= info
->par
;
1923 int maxClock
= 65000;
1924 int CursorMem
= 1024;
1925 int CursorOff
= 0x100;
1926 int linearSize
= 1024;
1927 int maxWidth
= 1024;
1928 int maxHeight
= 1024;
1935 printk(KERN_DEBUG
"--- Neo extended register dump ---\n");
1936 for (int w
= 0; w
< 0x85; w
++)
1937 printk(KERN_DEBUG
"CR %p: %p\n", (void *) w
,
1938 (void *) vga_rcrt(NULL
, w
));
1939 for (int w
= 0; w
< 0xC7; w
++)
1940 printk(KERN_DEBUG
"GR %p: %p\n", (void *) w
,
1941 (void *) vga_rgfx(NULL
, w
));
1943 switch (info
->fix
.accel
) {
1944 case FB_ACCEL_NEOMAGIC_NM2070
:
1953 case FB_ACCEL_NEOMAGIC_NM2090
:
1954 case FB_ACCEL_NEOMAGIC_NM2093
:
1963 case FB_ACCEL_NEOMAGIC_NM2097
:
1972 case FB_ACCEL_NEOMAGIC_NM2160
:
1981 case FB_ACCEL_NEOMAGIC_NM2200
:
1988 maxHeight
= 1024; /* ???? */
1990 par
->neo2200
= (Neo2200 __iomem
*) par
->mmio_vbase
;
1992 case FB_ACCEL_NEOMAGIC_NM2230
:
1999 maxHeight
= 1024; /* ???? */
2001 par
->neo2200
= (Neo2200 __iomem
*) par
->mmio_vbase
;
2003 case FB_ACCEL_NEOMAGIC_NM2360
:
2010 maxHeight
= 1024; /* ???? */
2012 par
->neo2200
= (Neo2200 __iomem
*) par
->mmio_vbase
;
2014 case FB_ACCEL_NEOMAGIC_NM2380
:
2021 maxHeight
= 1024; /* ???? */
2023 par
->neo2200
= (Neo2200 __iomem
*) par
->mmio_vbase
;
2027 info->sprite.size = CursorMem;
2028 info->sprite.scan_align = 1;
2029 info->sprite.buf_align = 1;
2030 info->sprite.flags = FB_PIXMAP_IO;
2031 info->sprite.outbuf = neofb_draw_cursor;
2033 par
->maxClock
= maxClock
;
2034 par
->cursorOff
= CursorOff
;
2035 return ((videoRam
* 1024));
2039 static struct fb_info
*__devinit
neo_alloc_fb_info(struct pci_dev
*dev
, const struct
2042 struct fb_info
*info
;
2043 struct neofb_par
*par
;
2045 info
= framebuffer_alloc(sizeof(struct neofb_par
), &dev
->dev
);
2052 info
->fix
.accel
= id
->driver_data
;
2054 mutex_init(&par
->open_lock
);
2055 par
->pci_burst
= !nopciburst
;
2056 par
->lcd_stretch
= !nostretch
;
2057 par
->libretto
= libretto
;
2059 par
->internal_display
= internal
;
2060 par
->external_display
= external
;
2061 info
->flags
= FBINFO_DEFAULT
| FBINFO_HWACCEL_YPAN
;
2063 switch (info
->fix
.accel
) {
2064 case FB_ACCEL_NEOMAGIC_NM2070
:
2065 snprintf(info
->fix
.id
, sizeof(info
->fix
.id
),
2068 case FB_ACCEL_NEOMAGIC_NM2090
:
2069 snprintf(info
->fix
.id
, sizeof(info
->fix
.id
),
2072 case FB_ACCEL_NEOMAGIC_NM2093
:
2073 snprintf(info
->fix
.id
, sizeof(info
->fix
.id
),
2074 "MagicGraph 128ZV");
2076 case FB_ACCEL_NEOMAGIC_NM2097
:
2077 snprintf(info
->fix
.id
, sizeof(info
->fix
.id
),
2078 "MagicGraph 128ZV+");
2080 case FB_ACCEL_NEOMAGIC_NM2160
:
2081 snprintf(info
->fix
.id
, sizeof(info
->fix
.id
),
2082 "MagicGraph 128XD");
2084 case FB_ACCEL_NEOMAGIC_NM2200
:
2085 snprintf(info
->fix
.id
, sizeof(info
->fix
.id
),
2086 "MagicGraph 256AV");
2087 info
->flags
|= FBINFO_HWACCEL_IMAGEBLIT
|
2088 FBINFO_HWACCEL_COPYAREA
|
2089 FBINFO_HWACCEL_FILLRECT
;
2091 case FB_ACCEL_NEOMAGIC_NM2230
:
2092 snprintf(info
->fix
.id
, sizeof(info
->fix
.id
),
2093 "MagicGraph 256AV+");
2094 info
->flags
|= FBINFO_HWACCEL_IMAGEBLIT
|
2095 FBINFO_HWACCEL_COPYAREA
|
2096 FBINFO_HWACCEL_FILLRECT
;
2098 case FB_ACCEL_NEOMAGIC_NM2360
:
2099 snprintf(info
->fix
.id
, sizeof(info
->fix
.id
),
2100 "MagicGraph 256ZX");
2101 info
->flags
|= FBINFO_HWACCEL_IMAGEBLIT
|
2102 FBINFO_HWACCEL_COPYAREA
|
2103 FBINFO_HWACCEL_FILLRECT
;
2105 case FB_ACCEL_NEOMAGIC_NM2380
:
2106 snprintf(info
->fix
.id
, sizeof(info
->fix
.id
),
2107 "MagicGraph 256XL+");
2108 info
->flags
|= FBINFO_HWACCEL_IMAGEBLIT
|
2109 FBINFO_HWACCEL_COPYAREA
|
2110 FBINFO_HWACCEL_FILLRECT
;
2114 info
->fix
.type
= FB_TYPE_PACKED_PIXELS
;
2115 info
->fix
.type_aux
= 0;
2116 info
->fix
.xpanstep
= 0;
2117 info
->fix
.ypanstep
= 4;
2118 info
->fix
.ywrapstep
= 0;
2119 info
->fix
.accel
= id
->driver_data
;
2121 info
->fbops
= &neofb_ops
;
2122 info
->pseudo_palette
= par
->palette
;
2126 static void neo_free_fb_info(struct fb_info
*info
)
2130 * Free the colourmap
2132 fb_dealloc_cmap(&info
->cmap
);
2133 framebuffer_release(info
);
2137 /* --------------------------------------------------------------------- */
2139 static int __devinit
neofb_probe(struct pci_dev
*dev
,
2140 const struct pci_device_id
*id
)
2142 struct fb_info
*info
;
2143 u_int h_sync
, v_sync
;
2148 err
= pci_enable_device(dev
);
2153 info
= neo_alloc_fb_info(dev
, id
);
2157 err
= neo_map_mmio(info
, dev
);
2161 err
= neo_scan_monitor(info
);
2163 goto err_scan_monitor
;
2165 video_len
= neo_init_hw(info
);
2166 if (video_len
< 0) {
2171 err
= neo_map_video(info
, dev
, video_len
);
2175 if (!fb_find_mode(&info
->var
, info
, mode_option
, NULL
, 0,
2176 info
->monspecs
.modedb
, 16)) {
2177 printk(KERN_ERR
"neofb: Unable to find usable video mode.\n");
2182 * Calculate the hsync and vsync frequencies. Note that
2183 * we split the 1e12 constant up so that we can preserve
2184 * the precision and fit the results into 32-bit registers.
2185 * (1953125000 * 512 = 1e12)
2187 h_sync
= 1953125000 / info
->var
.pixclock
;
2189 h_sync
* 512 / (info
->var
.xres
+ info
->var
.left_margin
+
2190 info
->var
.right_margin
+ info
->var
.hsync_len
);
2192 h_sync
/ (info
->var
.yres
+ info
->var
.upper_margin
+
2193 info
->var
.lower_margin
+ info
->var
.vsync_len
);
2195 printk(KERN_INFO
"neofb v" NEOFB_VERSION
2196 ": %dkB VRAM, using %dx%d, %d.%03dkHz, %dHz\n",
2197 info
->fix
.smem_len
>> 10, info
->var
.xres
,
2198 info
->var
.yres
, h_sync
/ 1000, h_sync
% 1000, v_sync
);
2200 if (fb_alloc_cmap(&info
->cmap
, 256, 0) < 0)
2203 err
= register_framebuffer(info
);
2207 printk(KERN_INFO
"fb%d: %s frame buffer device\n",
2208 info
->node
, info
->fix
.id
);
2213 pci_set_drvdata(dev
, info
);
2217 fb_dealloc_cmap(&info
->cmap
);
2219 neo_unmap_video(info
);
2221 fb_destroy_modedb(info
->monspecs
.modedb
);
2223 neo_unmap_mmio(info
);
2225 neo_free_fb_info(info
);
2229 static void __devexit
neofb_remove(struct pci_dev
*dev
)
2231 struct fb_info
*info
= pci_get_drvdata(dev
);
2233 DBG("neofb_remove");
2237 * If unregister_framebuffer fails, then
2238 * we will be leaving hooks that could cause
2239 * oopsen laying around.
2241 if (unregister_framebuffer(info
))
2243 "neofb: danger danger! Oopsen imminent!\n");
2245 neo_unmap_video(info
);
2246 fb_destroy_modedb(info
->monspecs
.modedb
);
2247 neo_unmap_mmio(info
);
2248 neo_free_fb_info(info
);
2251 * Ensure that the driver data is no longer
2254 pci_set_drvdata(dev
, NULL
);
2258 static struct pci_device_id neofb_devices
[] = {
2259 {PCI_VENDOR_ID_NEOMAGIC
, PCI_CHIP_NM2070
,
2260 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, FB_ACCEL_NEOMAGIC_NM2070
},
2262 {PCI_VENDOR_ID_NEOMAGIC
, PCI_CHIP_NM2090
,
2263 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, FB_ACCEL_NEOMAGIC_NM2090
},
2265 {PCI_VENDOR_ID_NEOMAGIC
, PCI_CHIP_NM2093
,
2266 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, FB_ACCEL_NEOMAGIC_NM2093
},
2268 {PCI_VENDOR_ID_NEOMAGIC
, PCI_CHIP_NM2097
,
2269 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, FB_ACCEL_NEOMAGIC_NM2097
},
2271 {PCI_VENDOR_ID_NEOMAGIC
, PCI_CHIP_NM2160
,
2272 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, FB_ACCEL_NEOMAGIC_NM2160
},
2274 {PCI_VENDOR_ID_NEOMAGIC
, PCI_CHIP_NM2200
,
2275 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, FB_ACCEL_NEOMAGIC_NM2200
},
2277 {PCI_VENDOR_ID_NEOMAGIC
, PCI_CHIP_NM2230
,
2278 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, FB_ACCEL_NEOMAGIC_NM2230
},
2280 {PCI_VENDOR_ID_NEOMAGIC
, PCI_CHIP_NM2360
,
2281 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, FB_ACCEL_NEOMAGIC_NM2360
},
2283 {PCI_VENDOR_ID_NEOMAGIC
, PCI_CHIP_NM2380
,
2284 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, FB_ACCEL_NEOMAGIC_NM2380
},
2286 {0, 0, 0, 0, 0, 0, 0}
2289 MODULE_DEVICE_TABLE(pci
, neofb_devices
);
2291 static struct pci_driver neofb_driver
= {
2293 .id_table
= neofb_devices
,
2294 .probe
= neofb_probe
,
2295 .remove
= __devexit_p(neofb_remove
)
2298 /* ************************* init in-kernel code ************************** */
2301 static int __init
neofb_setup(char *options
)
2307 if (!options
|| !*options
)
2310 while ((this_opt
= strsep(&options
, ",")) != NULL
) {
2314 if (!strncmp(this_opt
, "internal", 8))
2316 else if (!strncmp(this_opt
, "external", 8))
2318 else if (!strncmp(this_opt
, "nostretch", 9))
2320 else if (!strncmp(this_opt
, "nopciburst", 10))
2322 else if (!strncmp(this_opt
, "libretto", 8))
2325 mode_option
= this_opt
;
2331 static int __init
neofb_init(void)
2334 char *option
= NULL
;
2336 if (fb_get_options("neofb", &option
))
2338 neofb_setup(option
);
2340 return pci_register_driver(&neofb_driver
);
2343 module_init(neofb_init
);
2346 static void __exit
neofb_exit(void)
2348 pci_unregister_driver(&neofb_driver
);
2351 module_exit(neofb_exit
);