diff options
Diffstat (limited to 'hw/kdrive')
34 files changed, 3961 insertions, 681 deletions
diff --git a/hw/kdrive/fbdev/fbdev.c b/hw/kdrive/fbdev/fbdev.c index ccd5505ff..c4026f629 100644 --- a/hw/kdrive/fbdev/fbdev.c +++ b/hw/kdrive/fbdev/fbdev.c @@ -88,40 +88,40 @@ fbdevScreenInit (KdScreenInfo *screen) screen->width = priv->var.xres; screen->height = priv->var.yres; - screen->depth = priv->var.bits_per_pixel; - screen->bitsPerPixel = priv->var.bits_per_pixel; - screen->byteStride = priv->fix.line_length; - screen->pixelStride = (priv->fix.line_length * 8 / + screen->fb[0].depth = priv->var.bits_per_pixel; + screen->fb[0].bitsPerPixel = priv->var.bits_per_pixel; + screen->fb[0].byteStride = priv->fix.line_length; + screen->fb[0].pixelStride = (priv->fix.line_length * 8 / priv->var.bits_per_pixel); switch (priv->fix.visual) { case FB_VISUAL_PSEUDOCOLOR: - screen->visuals = ((1 << StaticGray) | + screen->fb[0].visuals = ((1 << StaticGray) | (1 << GrayScale) | (1 << StaticColor) | (1 << PseudoColor) | (1 << TrueColor) | (1 << DirectColor)); - screen->blueMask = 0x00; - screen->greenMask = 0x00; - screen->redMask = 0x00; + screen->fb[0].blueMask = 0x00; + screen->fb[0].greenMask = 0x00; + screen->fb[0].redMask = 0x00; break; case FB_VISUAL_TRUECOLOR: - screen->visuals = (1 << TrueColor); - screen->redMask = FbStipMask (priv->var.red.offset, priv->var.red.length); - screen->greenMask = FbStipMask (priv->var.green.offset, priv->var.green.length); - screen->blueMask = FbStipMask (priv->var.blue.offset, priv->var.blue.length); - allbits = screen->redMask | screen->greenMask | screen->blueMask; + screen->fb[0].visuals = (1 << TrueColor); + screen->fb[0].redMask = FbStipMask (priv->var.red.offset, priv->var.red.length); + screen->fb[0].greenMask = FbStipMask (priv->var.green.offset, priv->var.green.length); + screen->fb[0].blueMask = FbStipMask (priv->var.blue.offset, priv->var.blue.length); + allbits = screen->fb[0].redMask | screen->fb[0].greenMask | screen->fb[0].blueMask; depth = 32; while (depth && !(allbits & (1 << (depth - 1)))) depth--; - screen->depth = depth; + screen->fb[0].depth = depth; break; default: return FALSE; break; } screen->rate = 72; - screen->frameBuffer = (CARD8 *) (priv->fb); + screen->fb[0].frameBuffer = (CARD8 *) (priv->fb); return TRUE; } @@ -191,7 +191,7 @@ fbdevCardFini (KdCardInfo *card) } void -fbdevGetColors (ScreenPtr pScreen, int n, xColorItem *pdefs) +fbdevGetColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs) { KdScreenPriv(pScreen); FbdevPriv *priv = pScreenPriv->card->driver; @@ -232,7 +232,7 @@ fbdevGetColors (ScreenPtr pScreen, int n, xColorItem *pdefs) } void -fbdevPutColors (ScreenPtr pScreen, int n, xColorItem *pdefs) +fbdevPutColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs) { KdScreenPriv(pScreen); FbdevPriv *priv = pScreenPriv->card->driver; diff --git a/hw/kdrive/fbdev/fbdev.h b/hw/kdrive/fbdev/fbdev.h index 5504a9804..a5a9e44e9 100644 --- a/hw/kdrive/fbdev/fbdev.h +++ b/hw/kdrive/fbdev/fbdev.h @@ -75,10 +75,10 @@ void fbdevCardFini (KdCardInfo *card); void -fbdevGetColors (ScreenPtr pScreen, int n, xColorItem *pdefs); +fbdevGetColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs); void -fbdevPutColors (ScreenPtr pScreen, int n, xColorItem *pdefs); +fbdevPutColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs); #endif /* _FBDEV_H_ */ diff --git a/hw/kdrive/igs/Imakefile b/hw/kdrive/igs/Imakefile new file mode 100644 index 000000000..05d1e1c76 --- /dev/null +++ b/hw/kdrive/igs/Imakefile @@ -0,0 +1,14 @@ +XCOMM $XFree86$ +#include <Server.tmpl> + +SRCS = igs.c igsdraw.c igsstub.c + +OBJS = igs.o igsdraw.o igsstub.o + +INCLUDES = -I.. -I. -I$(XBUILDINCDIR) -I$(FONTINCSRC) \ + -I../../../fb -I../../../mi -I../../../include -I../../../os \ + -I$(EXTINCSRC) -I$(XINCLUDESRC) + +NormalLibraryObjectRule() +NormalLibraryTarget(igs,$(OBJS)) +DependTarget() diff --git a/hw/kdrive/igs/igs.c b/hw/kdrive/igs/igs.c new file mode 100644 index 000000000..62b31af48 --- /dev/null +++ b/hw/kdrive/igs/igs.c @@ -0,0 +1,201 @@ +/* + * $XFree86$ + * + * Copyright © 1999 SuSE, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of SuSE not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. SuSE makes no representations about the + * suitability of this software for any purpose. It is provided "as is" + * without express or implied warranty. + * + * SuSE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL SuSE + * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Author: Keith Packard, SuSE, Inc. + */ + +#include "igs.h" + +Bool +igsCardInit (KdCardInfo *card) +{ + int k; + char *pixels; + IgsCardInfo *igsc; + + igsc = (IgsCardInfo *) xalloc (sizeof (IgsCardInfo)); + if (!igsc) + return FALSE; + + memset (igsc, '\0', sizeof (IgsCardInfo)); + + igsc->frameBuffer = (CARD8 *) KdMapDevice (card->attr.address[0], + 4096 * 1024); + + igsc->cop = (Cop5xxx *) KdMapDevice (card->attr.address[0] + + IGS_COP_OFFSET, + sizeof (Cop5xxx)); + + igsc->copData = (VOL32 *) KdMapDevice (card->attr.address[0] + + IGS_COP_DATA, + IGS_COP_DATA_LEN); + + card->driver = igsc; + + return TRUE; +} + +Bool +igsScreenInit (KdScreenInfo *screen) +{ + IgsCardInfo *igsc = screen->card->driver; + int fb = 0; + + if (screen->fb[fb].depth >= 24) + { + screen->fb[fb].depth = 24; + if (screen->fb[fb].bitsPerPixel != 24) + screen->fb[fb].bitsPerPixel = 32; + } + else if (screen->fb[fb].depth >= 16) + { + screen->fb[fb].depth = 16; + screen->fb[fb].bitsPerPixel = 16; + } + else if (screen->fb[fb].depth >= 15) + { + screen->fb[fb].depth = 15; + screen->fb[fb].bitsPerPixel = 16; + } + else + { + screen->fb[fb].depth = 8; + screen->fb[fb].bitsPerPixel = 8; + } + switch (screen->fb[fb].depth) { + case 8: + screen->fb[fb].visuals = ((1 << StaticGray) | + (1 << GrayScale) | + (1 << StaticColor) | + (1 << PseudoColor) | + (1 << TrueColor) | + (1 << DirectColor)); + screen->fb[fb].blueMask = 0x00; + screen->fb[fb].greenMask = 0x00; + screen->fb[fb].redMask = 0x00; + break; + case 15: + screen->fb[fb].visuals = (1 << TrueColor); + screen->fb[fb].blueMask = 0x001f; + screen->fb[fb].greenMask = 0x03e0; + screen->fb[fb].redMask = 0x7c00; + break; + case 16: + screen->fb[fb].visuals = (1 << TrueColor); + screen->fb[fb].blueMask = 0x001f; + screen->fb[fb].greenMask = 0x07e0; + screen->fb[fb].redMask = 0xf800; + break; + case 24: + screen->fb[fb].visuals = (1 << TrueColor); + screen->fb[fb].blueMask = 0x0000ff; + screen->fb[fb].greenMask = 0x00ff00; + screen->fb[fb].redMask = 0xff0000; + break; + } + screen->fb[fb].pixelStride = screen->width; + screen->fb[fb].byteStride = screen->width * (screen->fb[fb].bitsPerPixel >> 3); + screen->fb[fb].frameBuffer = igsc->frameBuffer; + if (!igsc->cop) + screen->dumb = TRUE; + return TRUE; +} + +Bool +igsInitScreen(ScreenPtr pScreen) +{ + return TRUE; +} + +void +igsPreserve (KdCardInfo *card) +{ +} + +void +igsEnable (ScreenPtr pScreen) +{ +} + +Bool +igsDPMS (ScreenPtr pScreen, int mode) +{ + return TRUE; +} + +void +igsDisable (ScreenPtr pScreen) +{ +} + +void +igsRestore (KdCardInfo *card) +{ +} + +void +igsScreenFini (KdScreenInfo *screen) +{ +} + +void +igsCardFini (KdCardInfo *card) +{ + IgsCardInfo *igsc = card->driver; + + if (igsc->copData) + KdUnmapDevice ((void *) igsc->copData, IGS_COP_DATA_LEN); + if (igsc->cop) + KdUnmapDevice (igsc->cop, sizeof (Cop5xxx)); + if (igsc->frameBuffer) + KdUnmapDevice (igsc->frameBuffer, 4096 * 1024); + xfree (igsc); + card->driver = 0; +} + +KdCardFuncs igsFuncs = { + igsCardInit, /* cardinit */ + igsScreenInit, /* scrinit */ + igsInitScreen, + igsPreserve, /* preserve */ + igsEnable, /* enable */ + igsDPMS, /* dpms */ + igsDisable, /* disable */ + igsRestore, /* restore */ + igsScreenFini, /* scrfini */ + igsCardFini, /* cardfini */ + + 0, /* initCursor */ + 0, /* enableCursor */ + 0, /* disableCursor */ + 0, /* finiCursor */ + 0, /* recolorCursor */ + + igsDrawInit, /* initAccel */ + igsDrawEnable, /* enableAccel */ + igsDrawSync, /* drawSync */ + igsDrawDisable, /* disableAccel */ + igsDrawFini, /* finiAccel */ + + 0, /* getColors */ + 0, /* putColors */ +}; diff --git a/hw/kdrive/igs/igs.h b/hw/kdrive/igs/igs.h new file mode 100644 index 000000000..9316ef249 --- /dev/null +++ b/hw/kdrive/igs/igs.h @@ -0,0 +1,244 @@ +/* + * $XFree86$ + * + * Copyright © 1999 SuSE, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of SuSE not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. SuSE makes no representations about the + * suitability of this software for any purpose. It is provided "as is" + * without express or implied warranty. + * + * SuSE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL SuSE + * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Author: Keith Packard, SuSE, Inc. + */ + +#ifndef _IGS_H_ +#define _IGS_H_ + +#include "kdrive.h" + +extern KdCardFuncs igsFuncs; + +/* + * FB 0x00000000 + * VGA 0x00800000 + * Blt window 0x008a0000 + * Coprocessor 0x008bf000 + */ + +#define IGS_COP_DATA 0x008a0000 +#define IGS_COP_DATA_LEN 0x00010000 +#define IGS_COP_OFFSET 0x008bf000 + +typedef volatile CARD8 VOL8; +typedef volatile CARD16 VOL16; +typedef volatile CARD32 VOL32; + +typedef struct _Cop5xxx { + VOL8 pad000[0x11]; /* 0x000 */ + + VOL8 control; /* 0x011 */ +#define IGS_CONTROL_HBLTW_RDYZ 0x01 +#define IGS_CONTROL_MALLWBEPTZ 0x02 +#define IGS_CONTROL_CMDFF 0x04 +#define IGS_CONTROL_SOP 0x08 +#define IGS_CONTROL_OPS 0x10 +#define IGS_CONTROL_TER 0x20 +#define IGS_CONTROL_HBACKZ 0x40 +#define IGS_CONTROL_BUSY 0x80 + + VOL8 pad012[0x06]; /* 0x012 */ + + VOL32 src1_stride; /* 0x018 */ + + VOL32 format; /* 0x01c */ + +#define IGS_FORMAT_8BPP 0 +#define IGS_FORMAT_16BPP 1 +#define IGS_FORMAT_24BPP 2 +#define IGS_FORMAT_32BPP 3 + + VOL32 bres_error; /* 0x020 */ + VOL32 bres_k1; /* 0x024 */ + VOL32 bres_k2; /* 0x028 */ + VOL8 pad02c[0x1c]; /* 0x02c */ + + VOL32 mix; /* 0x048 */ +#define IGS_MIX_FG 0x00ff +#define IGS_MIX_BG 0xff00 +#define IGS_MAKE_MIX(fg,bg) ((fg) | ((bg) << 8)) + +#define IGS_MIX_ZERO 0x0 +#define IGS_MIX_SRC_AND_DST 0x1 +#define IGS_MIX_SRC_AND_NOT_DST 0x2 +#define IGS_MIX_SRC 0x3 +#define IGS_MIX_NOT_SRC_AND_DST 0x4 +#define IGS_MIX_DST 0x5 +#define IGS_MIX_SRC_XOR_DST 0x6 +#define IGS_MIX_SRC_OR_DST 0x7 +#define IGS_MIX_NOT_SRC_AND_NOT_DST 0x8 +#define IGS_MIX_SRC_XOR_NOT_DST 0x9 +#define IGS_MIX_NOT_DST 0xa +#define IGS_MIX_SRC_OR_NOT_DST 0xb +#define IGS_MIX_NOT_SRC 0xc +#define IGS_MIX_NOT_SRC_OR_DST 0xd +#define IGS_MIX_NOT_SRC_OR_NOT_DST 0xe +#define IGS_MIX_ONE 0xf + + VOL32 colorComp; /* 0x04c */ + VOL32 planemask; /* 0x050 */ + + VOL8 pad054[0x4]; /* 0x054 */ + + VOL32 fg; /* 0x058 */ + VOL32 bg; /* 0x05c */ + VOL32 dim; /* 0x060 */ +#define IGS_MAKE_DIM(w,h) ((w) | ((h) << 16)) + VOL8 pad5[0x0c]; /* 0x064 */ + + VOL32 src1_base_address; /* 0x070 */ + VOL8 pad074[0x04]; /* 0x074 */ + + VOL16 dst_x_rotate; /* 0x078 */ + VOL16 pat_y_rotate; /* 0x07a */ + VOL32 operation; /* 0x07c */ + +/* OCT[2:0] */ +#define IGS_DRAW_X_MAJOR 0x00000000 +#define IGS_DRAW_Y_MAJOR 0x00000001 +#define IGS_DRAW_T_B 0x00000000 +#define IGS_DRAW_B_T 0x00000002 +#define IGS_DRAW_L_R 0x00000000 +#define IGS_DRAW_R_L 0x00000004 + +/* Draw_Mode[1:0] */ +#define IGS_DRAW_ALL 0x00000000 +#define IGS_DRAW_NOT_FIRST 0x00000010 +#define IGS_DRAW_NOT_LAST 0x00000020 +#define IGS_DRAW_NOT_FIRST_LAST 0x00000030 + +/* TRPS[1:0] */ +#define IGS_TRANS_SRC1 0x00000000 +#define IGS_TRANS_SRC2 0x00000100 +#define IGS_TRANS_DST 0x00000200 +/* TRPS2 Transparent Invert */ +#define IGS_TRANS_INVERT 0x00000400 +/* TRPS3, Transparent Enable */ +#define IGS_TRANS_ENABLE 0x00000800 + +/* PPS[3:0], Pattern Pixel Select */ +#define IGS_PIXEL_TEXT_OPAQUE 0x00001000 +#define IGS_PIXEL_STIP_OPAQUE 0x00002000 +#define IGS_PIXEL_LINE_OPAQUE 0x00003000 +#define IGS_PIXEL_TEXT_TRANS 0x00005000 +#define IGS_PIXEL_STIP_TRANS 0x00006000 +#define IGS_PIXEL_LINE_TRANS 0x00007000 +#define IGS_PIXEL_FG 0x00008000 +#define IGS_PIXEL_TILE 0x00009000 + +/* HostBltEnable[1:0] */ +#define IGS_HBLT_DISABLE 0x00000000 +#define IGS_HBLT_READ 0x00010000 +#define IGS_HBLT_WRITE_1 0x00020000 +#define IGS_HBLT_WRITE_2 0x00030000 + +/* Src2MapSelect[2:0], Src2 map select mode */ +#define IGS_SRC2_NORMAL 0x00000000 +#define IGS_SRC2_MONO_OPAQUE 0x00100000 +#define IGS_SRC2_FG 0x00200000 +#define IGS_SRC2_MONO_TRANS 0x00500000 + +/* StepFunction[3:0], Step function select */ +#define IGS_STEP_DRAW_AND_STEP 0x04000000 +#define IGS_STEP_LINE_DRAW 0x05000000 +#define IGS_STEP_PXBLT 0x08000000 +#define IGS_STEP_INVERT_PXBLT 0x09000000 +#define IGS_STEP_TERNARY_PXBLT 0x0b000000 + +/* FGS */ +#define IGS_FGS_FG 0x00000000 +#define IGS_FGS_SRC 0x20000000 + +/* BGS */ +#define IGS_BGS_BG 0x00000000 +#define IGS_BGS_SRC 0x80000000 + VOL8 pad080[0x91]; /* 0x080 */ + + VOL8 debug_control_1; /* 0x111 */ + VOL8 debug_control_2; /* 0x112 */ + VOL8 pad113[0x05]; /* 0x113 */ + + VOL32 src2_stride; /* 0x118 */ + VOL8 pad11c[0x14]; /* 0x11c */ + + VOL32 extension; /* 0x130 */ + +#define IGS_BURST_ENABLE 0x01 +#define IGS_STYLE_LINE 0x02 +#define IGS_ADDITIONAL_WAIT 0x04 +#define IGS_BLOCK_COP_REG 0x08 +#define IGS_TURBO_MONO 0x10 +#define IGS_SELECT_SAMPLE 0x40 +#define IGS_MDSBL_RD_B_WR 0x80 +#define IGS_WRMRSTZ 0x100 +#define IGS_TEST_MTST 0x200 + + VOL8 style_line_roll_over; /* 0x134 */ + VOL8 style_line_inc; /* 0x135 */ + VOL8 style_line_pattern; /* 0x136 */ + VOL8 style_line_accumulator; /* 0x137 */ + VOL8 style_line_pattern_index; /* 0x138 */ + VOL8 pad139[0x3]; /* 0x139 */ + + VOL16 mono_burst_total; /* 0x13c */ + VOL8 pad13e[0x12]; /* 0x13e */ + + VOL8 pat_x_rotate; /* 0x150 */ + VOL8 pad151[0x1f]; /* 0x151 */ + + VOL32 src1_start; /* 0x170 */ + VOL32 src2_start; /* 0x174 */ + VOL32 dst_start; /* 0x178 */ + VOL8 pad17c[0x9c]; /* 0x17c */ + + VOL16 dst_stride; /* 0x218 */ +} Cop5xxx; + +typedef struct _igsCardInfo { + Cop5xxx *cop; + VOL32 *copData; + Bool need_sync; + CARD8 *frameBuffer; +} IgsCardInfo; + +#define getIgsCardInfo(kd) ((IgsCardInfo *) ((kd)->card->driver)) +#define igsCardInfo(kd) IgsCardInfo *igsc = getIgsCardInfo(kd) + +Bool +igsDrawInit (ScreenPtr pScreen); + +void +igsDrawEnable (ScreenPtr pScreen); + +void +igsDrawDisable (ScreenPtr pScreen); + +void +igsDrawSync (ScreenPtr pScreen); + +void +igsDrawFini (ScreenPtr pScreen); + + +#endif /* _IGS_H_ */ diff --git a/hw/kdrive/igs/igsdraw.c b/hw/kdrive/igs/igsdraw.c new file mode 100644 index 000000000..43ca7cf6e --- /dev/null +++ b/hw/kdrive/igs/igsdraw.c @@ -0,0 +1,1114 @@ +/* + * $XFree86$ + * + * Copyright © 2000 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "igs.h" +#include "igsdraw.h" + +#include "Xmd.h" +#include "gcstruct.h" +#include "scrnintstr.h" +#include "pixmapstr.h" +#include "regionstr.h" +#include "mistruct.h" +#include "fontstruct.h" +#include "dixfontstr.h" +#include "fb.h" +#include "migc.h" +#include "miline.h" + +CARD8 igsPatRop[16] = { + /* GXclear */ 0x00, /* 0 */ + /* GXand */ 0xa0, /* src AND dst */ + /* GXandReverse */ 0x50, /* src AND NOT dst */ + /* GXcopy */ 0xf0, /* src */ + /* GXandInverted*/ 0x0a, /* NOT src AND dst */ + /* GXnoop */ 0xaa, /* dst */ + /* GXxor */ 0x5a, /* src XOR dst */ + /* GXor */ 0xfa, /* src OR dst */ + /* GXnor */ 0x05, /* NOT src AND NOT dst */ + /* GXequiv */ 0xa5, /* NOT src XOR dst */ + /* GXinvert */ 0x55, /* NOT dst */ + /* GXorReverse */ 0xf5, /* src OR NOT dst */ + /* GXcopyInverted*/ 0x0f, /* NOT src */ + /* GXorInverted */ 0xaf, /* NOT src OR dst */ + /* GXnand */ 0x5f, /* NOT src OR NOT dst */ + /* GXset */ 0xff, /* 1 */ +}; + +/* + * Handle pixel transfers + */ + +#define BURST +#ifdef BURST +#define PixTransDeclare VOL32 *pix_trans_base = igsc->copData,\ + *pix_trans = pix_trans_base +#define PixTransStart(n) if (pix_trans + (n) > pix_trans_base + 16384) pix_trans = pix_trans_base +#define PixTransStore(t) *pix_trans++ = (t) +#else +#define PixTransDeclare VOL32 *pix_trans = igsc->copData +#define PixTransStart(n) +#define PixTransStore(t) *pix_trans = (t) +#endif + +void +igsFillBoxSolid (DrawablePtr pDrawable, int nBox, BoxPtr pBox, + unsigned long pixel, int alu, unsigned long planemask) +{ + SetupIgs(pDrawable->pScreen); + CARD32 cmd; + + _igsSetSolidRect(cop,alu,planemask,pixel,cmd); + while (nBox--) + { + _igsRect(cop,pBox->x1,pBox->y1,pBox->x2-pBox->x1,pBox->y2-pBox->y1,cmd); + pBox++; + } + KdMarkSync (pDrawable->pScreen); +} + +void +igsCopyNtoN (DrawablePtr pSrcDrawable, + DrawablePtr pDstDrawable, + GCPtr pGC, + BoxPtr pbox, + int nbox, + int dx, + int dy, + Bool reverse, + Bool upsidedown, + Pixel bitplane, + void *closure) +{ + SetupIgs(pDstDrawable->pScreen); + int srcX, srcY, dstX, dstY; + int w, h; + CARD32 flags; + CARD32 cmd; + CARD8 alu; + + if (pGC) + { + alu = pGC->alu; + if (sourceInvarient (pGC->alu)) + { + igsFillBoxSolid (pDstDrawable, nbox, pbox, 0, pGC->alu, pGC->planemask); + return; + } + } + else + alu = GXcopy; + + _igsSetBlt(cop,alu,pGC->planemask,reverse,upsidedown,cmd); + while (nbox--) + { + w = pbox->x2 - pbox->x1; + h = pbox->y2 - pbox->y1; + if (reverse) + dstX = pbox->x2 - 1; + else + dstX = pbox->x1; + srcX = dstX + dx; + + if (upsidedown) + dstY = pbox->y2 - 1; + else + dstY = pbox->y1; + + srcY = dstY + dy; + + _igsBlt (cop, srcX, srcY, dstX, dstY, w, h, cmd); + pbox++; + } + KdMarkSync (pDstDrawable->pScreen); +} + +RegionPtr +igsCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable, GCPtr pGC, + int srcx, int srcy, int width, int height, int dstx, int dsty) +{ + KdScreenPriv(pDstDrawable->pScreen); + FbBits depthMask; + + depthMask = FbFullMask (pDstDrawable->depth); + if ((pGC->planemask & depthMask) == depthMask && + pSrcDrawable->type == DRAWABLE_WINDOW && + pDstDrawable->type == DRAWABLE_WINDOW) + { + return fbDoCopy (pSrcDrawable, pDstDrawable, pGC, + srcx, srcy, width, height, + dstx, dsty, igsCopyNtoN, 0, 0); + } + return KdCheckCopyArea (pSrcDrawable, pDstDrawable, pGC, + srcx, srcy, width, height, dstx, dsty); +} + +BOOL +igsFillOk (GCPtr pGC) +{ + FbBits depthMask; + + depthMask = FbFullMask(pGC->depth); + if ((pGC->planemask & depthMask) != depthMask) + return FALSE; + switch (pGC->fillStyle) { + case FillSolid: + return TRUE; +#if 0 + case FillTiled: + return (igsPatternDimOk (pGC->tile.pixmap->drawable.width) && + igsPatternDimOk (pGC->tile.pixmap->drawable.height)); + case FillStippled: + case FillOpaqueStippled: + return (igsPatternDimOk (pGC->stipple->drawable.width) && + igsPatternDimOk (pGC->stipple->drawable.height)); +#endif + } + return FALSE; +} + +void +igsFillSpans (DrawablePtr pDrawable, GCPtr pGC, int n, + DDXPointPtr ppt, int *pwidth, int fSorted) +{ + SetupIgs(pDrawable->pScreen); + DDXPointPtr pptFree; + FbGCPrivPtr fbPriv = fbGetGCPrivate(pGC); + int *pwidthFree;/* copies of the pointers to free */ + CARD32 cmd; + int nTmp; + INT16 x, y; + int width; + + if (!igsFillOk (pGC)) + { + KdCheckFillSpans (pDrawable, pGC, n, ppt, pwidth, fSorted); + return; + } + nTmp = n * miFindMaxBand(fbGetCompositeClip(pGC)); + pwidthFree = (int *)ALLOCATE_LOCAL(nTmp * sizeof(int)); + pptFree = (DDXPointRec *)ALLOCATE_LOCAL(nTmp * sizeof(DDXPointRec)); + if(!pptFree || !pwidthFree) + { + if (pptFree) DEALLOCATE_LOCAL(pptFree); + if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree); + return; + } + n = miClipSpans(fbGetCompositeClip(pGC), + ppt, pwidth, n, + pptFree, pwidthFree, fSorted); + pwidth = pwidthFree; + ppt = pptFree; + switch (pGC->fillStyle) { + case FillSolid: + _igsSetSolidRect(cop,pGC->alu,pGC->planemask,pGC->fgPixel,cmd); + break; +#if 0 + case FillTiled: + cmd = igsTilePrepare (pGC->tile.pixmap, + pGC->patOrg.x + pDrawable->x, + pGC->patOrg.y + pDrawable->y, + pGC->alu); + break; + default: + cmd = igsStipplePrepare (pDrawable, pGC); + break; +#endif + } + while (n--) + { + x = ppt->x; + y = ppt->y; + ppt++; + width = *pwidth++; + if (width) + { + _igsRect(cop,x,y,width,1,cmd); + } + } + DEALLOCATE_LOCAL(pptFree); + DEALLOCATE_LOCAL(pwidthFree); + KdMarkSync (pDrawable->pScreen); +} + +#define NUM_STACK_RECTS 1024 + +void +igsPolyFillRect (DrawablePtr pDrawable, GCPtr pGC, + int nrectFill, xRectangle *prectInit) +{ + SetupIgs(pDrawable->pScreen); + xRectangle *prect; + RegionPtr prgnClip; + register BoxPtr pbox; + register BoxPtr pboxClipped; + BoxPtr pboxClippedBase; + BoxPtr pextent; + BoxRec stackRects[NUM_STACK_RECTS]; + FbGCPrivPtr fbPriv = fbGetGCPrivate (pGC); + int numRects; + int n; + int xorg, yorg; + int x, y; + + if (!igsFillOk (pGC)) + { + KdCheckPolyFillRect (pDrawable, pGC, nrectFill, prectInit); + return; + } + prgnClip = fbGetCompositeClip (pGC); + xorg = pDrawable->x; + yorg = pDrawable->y; + + if (xorg || yorg) + { + prect = prectInit; + n = nrectFill; + while(n--) + { + prect->x += xorg; + prect->y += yorg; + prect++; + } + } + + prect = prectInit; + + numRects = REGION_NUM_RECTS(prgnClip) * nrectFill; + if (numRects > NUM_STACK_RECTS) + { + pboxClippedBase = (BoxPtr)xalloc(numRects * sizeof(BoxRec)); + if (!pboxClippedBase) + return; + } + else + pboxClippedBase = stackRects; + + pboxClipped = pboxClippedBase; + + if (REGION_NUM_RECTS(prgnClip) == 1) + { + int x1, y1, x2, y2, bx2, by2; + + pextent = REGION_RECTS(prgnClip); + x1 = pextent->x1; + y1 = pextent->y1; + x2 = pextent->x2; + y2 = pextent->y2; + while (nrectFill--) + { + if ((pboxClipped->x1 = prect->x) < x1) + pboxClipped->x1 = x1; + + if ((pboxClipped->y1 = prect->y) < y1) + pboxClipped->y1 = y1; + + bx2 = (int) prect->x + (int) prect->width; + if (bx2 > x2) + bx2 = x2; + pboxClipped->x2 = bx2; + + by2 = (int) prect->y + (int) prect->height; + if (by2 > y2) + by2 = y2; + pboxClipped->y2 = by2; + + prect++; + if ((pboxClipped->x1 < pboxClipped->x2) && + (pboxClipped->y1 < pboxClipped->y2)) + { + pboxClipped++; + } + } + } + else + { + int x1, y1, x2, y2, bx2, by2; + + pextent = REGION_EXTENTS(pGC->pScreen, prgnClip); + x1 = pextent->x1; + y1 = pextent->y1; + x2 = pextent->x2; + y2 = pextent->y2; + while (nrectFill--) + { + BoxRec box; + + if ((box.x1 = prect->x) < x1) + box.x1 = x1; + + if ((box.y1 = prect->y) < y1) + box.y1 = y1; + + bx2 = (int) prect->x + (int) prect->width; + if (bx2 > x2) + bx2 = x2; + box.x2 = bx2; + + by2 = (int) prect->y + (int) prect->height; + if (by2 > y2) + by2 = y2; + box.y2 = by2; + + prect++; + + if ((box.x1 >= box.x2) || (box.y1 >= box.y2)) + continue; + + n = REGION_NUM_RECTS (prgnClip); + pbox = REGION_RECTS(prgnClip); + + /* clip the rectangle to each box in the clip region + this is logically equivalent to calling Intersect() + */ + while(n--) + { + pboxClipped->x1 = max(box.x1, pbox->x1); + pboxClipped->y1 = max(box.y1, pbox->y1); + pboxClipped->x2 = min(box.x2, pbox->x2); + pboxClipped->y2 = min(box.y2, pbox->y2); + pbox++; + + /* see if clipping left anything */ + if(pboxClipped->x1 < pboxClipped->x2 && + pboxClipped->y1 < pboxClipped->y2) + { + pboxClipped++; + } + } + } + } + if (pboxClipped != pboxClippedBase) + { + switch (pGC->fillStyle) { + case FillSolid: + igsFillBoxSolid(pDrawable, + pboxClipped-pboxClippedBase, pboxClippedBase, + pGC->fgPixel, pGC->alu, pGC->planemask); + break; +#if 0 + case FillTiled: + igsFillBoxTiled(pDrawable, + pboxClipped-pboxClippedBase, pboxClippedBase, + pGC->tile.pixmap, + pGC->patOrg.x + pDrawable->x, + pGC->patOrg.y + pDrawable->y, + pGC->alu); + break; + case FillStippled: + case FillOpaqueStippled: + igsFillBoxStipple (pDrawable, pGC, + pboxClipped-pboxClippedBase, pboxClippedBase); + break; +#endif + } + } + if (pboxClippedBase != stackRects) + xfree(pboxClippedBase); +} + +int +igsTextInRegion (GCPtr pGC, + int x, + int y, + unsigned int nglyph, + CharInfoPtr *ppci) +{ + int w; + FontPtr pfont = pGC->font; + BoxRec bbox; + + if (FONTCONSTMETRICS(pfont)) + w = FONTMAXBOUNDS(pfont,characterWidth) * nglyph; + else + { + w = 0; + while (nglyph--) + w += (*ppci++)->metrics.characterWidth; + } + if (w < 0) + { + bbox.x1 = x + w; + bbox.x2 = x; + } + else + { + bbox.x1 = x; + bbox.x2 = x + w; + } + w = FONTMINBOUNDS(pfont,leftSideBearing); + if (w < 0) + bbox.x1 += w; + w = FONTMAXBOUNDS(pfont, rightSideBearing) - FONTMINBOUNDS(pfont, characterWidth); + if (w > 0) + bbox.x2 += w; + bbox.y1 = y - FONTMAXBOUNDS(pfont,ascent); + bbox.y2 = y + FONTMAXBOUNDS(pfont,descent); + + return RECT_IN_REGION(pGC->pScreen, fbGetCompositeClip(pGC), &bbox); +} + +void +igsGlyphBltClipped (DrawablePtr pDrawable, + GCPtr pGC, + int x, + int y, + unsigned int nglyph, + CharInfoPtr *ppciInit, + Bool image) +{ + SetupIgs(pDrawable->pScreen); + CARD32 cmd; + int h; + int w; + int xBack, yBack; + int hBack, wBack; + int lw; + FontPtr pfont = pGC->font; + CharInfoPtr pci; + unsigned long *bits; + BoxPtr extents; + BoxRec bbox; + CARD32 b; + CharInfoPtr *ppci; + FbGCPrivPtr fbPriv = fbGetGCPrivate(pGC); + RegionPtr pClip = fbGetCompositeClip(pGC); + BoxPtr pBox; + int nbox; + int x1, y1, x2, y2; + unsigned char alu; + Bool set; + PixTransDeclare; + + if (image) + { + xBack = x; + yBack = y - FONTASCENT(pGC->font); + wBack = 0; + hBack = FONTASCENT(pGC->font) + FONTDESCENT(pGC->font); + if (hBack) + { + h = nglyph; + ppci = ppciInit; + while (h--) + wBack += (*ppci++)->metrics.characterWidth; + } + if (wBack < 0) + { + xBack = xBack + wBack; + wBack = -wBack; + } + if (hBack < 0) + { + yBack = yBack + hBack; + hBack = -hBack; + } + alu = GXcopy; + if (wBack) + { + _igsSetSolidRect (cop, GXcopy, pGC->planemask, pGC->bgPixel, cmd); + for (nbox = REGION_NUM_RECTS (pClip), + pBox = REGION_RECTS (pClip); + nbox--; + pBox++) + { + x1 = xBack; + x2 = xBack + wBack; + y1 = yBack; + y2 = yBack + hBack; + if (x1 < pBox->x1) x1 = pBox->x1; + if (x2 > pBox->x2) x2 = pBox->x2; + if (y1 < pBox->y1) y1 = pBox->y1; + if (y2 > pBox->y2) y2 = pBox->y2; + if (x1 < x2 && y1 < y2) + { + _igsRect (cop, x1, y1, x2 - x1, y2 - y1, cmd); + } + } + KdMarkSync (pDrawable->pScreen); + } + } + else + { + wBack = 0; + alu = pGC->alu; + } + + ppci = ppciInit; + set = FALSE; + while (nglyph--) + { + pci = *ppci++; + h = pci->metrics.ascent + pci->metrics.descent; + w = pci->metrics.rightSideBearing - pci->metrics.leftSideBearing; + x1 = x + pci->metrics.leftSideBearing; + y1 = y - pci->metrics.ascent; + bbox.x1 = x1; + bbox.y1 = y1; + bbox.x2 = x1 + w; + bbox.y2 = y1 + h; + switch (RECT_IN_REGION(pGC->pScreen, pClip, &bbox)) + { + case rgnIN: + lw = h * ((w + 31) >> 5); + if (lw) + { + if (!set) + { + _igsSetTransparentPlaneBlt (cop, alu, pGC->planemask, pGC->fgPixel, cmd); + set = TRUE; + } + _igsPlaneBlt(cop, + x + pci->metrics.leftSideBearing, + y - pci->metrics.ascent, + w, h, cmd); + bits = (unsigned long *) pci->bits; + PixTransStart (lw); + while (lw--) + { + b = *bits++; + IgsAdjustBits32 (b); + PixTransStore(b); + } + KdMarkSync (pDrawable->pScreen); + } + break; + case rgnPART: + set = FALSE; + KdCheckSync (pDrawable->pScreen); + fbPutXYImage (pDrawable, + pClip, + fbPriv->fg, + fbPriv->bg, + fbPriv->pm, + alu, + FALSE, + x1, y1, + w, h, + (FbStip *) pci->bits, + (w + 31) >> 5, + 0); + break; + case rgnOUT: + break; + } + x += pci->metrics.characterWidth; + } +} + +void +igsGlyphBlt (DrawablePtr pDrawable, + GCPtr pGC, + int x, + int y, + unsigned int nglyph, + CharInfoPtr *ppciInit, + Bool image) +{ + SetupIgs(pDrawable->pScreen); + CARD32 cmd; + int h; + int w; + int xBack, yBack; + int hBack, wBack; + int lw; + FontPtr pfont = pGC->font; + CharInfoPtr pci; + unsigned long *bits; + BoxPtr extents; + BoxRec bbox; + CARD32 b; + CharInfoPtr *ppci; + unsigned char alu; + PixTransDeclare; + + /* + * Paint background for image text + */ + if (image) + { + xBack = x; + yBack = y - FONTASCENT(pGC->font); + wBack = 0; + hBack = FONTASCENT(pGC->font) + FONTDESCENT(pGC->font); + if (hBack) + { + h = nglyph; + ppci = ppciInit; + while (h--) + wBack += (*ppci++)->metrics.characterWidth; + } + if (wBack < 0) + { + xBack = xBack + wBack; + wBack = -wBack; + } + if (hBack < 0) + { + yBack = yBack + hBack; + hBack = -hBack; + } + alu = GXcopy; + if (wBack) + { + _igsSetSolidRect (cop, GXcopy, pGC->planemask, pGC->bgPixel, cmd); + _igsRect (cop, xBack, yBack, wBack, hBack, cmd); + } + } + else + { + wBack = 0; + alu = pGC->alu; + } + + _igsSetTransparentPlaneBlt (cop, alu, pGC->planemask, pGC->fgPixel, cmd); + ppci = ppciInit; + while (nglyph--) + { + pci = *ppci++; + h = pci->metrics.ascent + pci->metrics.descent; + w = pci->metrics.rightSideBearing - pci->metrics.leftSideBearing; + lw = h * ((w + 31) >> 5); + if (lw) + { + _igsPlaneBlt(cop, + x + pci->metrics.leftSideBearing, + y - pci->metrics.ascent, + w, h, cmd); + bits = (unsigned long *) pci->bits; + PixTransStart(lw); + while (lw--) + { + b = *bits++; + IgsAdjustBits32 (b); + PixTransStore(b); + } + } + x += pci->metrics.characterWidth; + } + KdMarkSync (pDrawable->pScreen); +} + +void +igsTEGlyphBlt (DrawablePtr pDrawable, + GCPtr pGC, + int xInit, + int yInit, + unsigned int nglyph, + CharInfoPtr *ppci, + Bool image) +{ + SetupIgs(pDrawable->pScreen); + CARD32 cmd; + int x, y; + int h, lw, lwTmp; + int w; + FontPtr pfont = pGC->font; + unsigned long *char1, *char2, *char3, *char4; + int widthGlyphs, widthGlyph; + BoxRec bbox; + CARD32 tmp; + PixTransDeclare; + + widthGlyph = FONTMAXBOUNDS(pfont,characterWidth); + if (!widthGlyph) + return; + + h = FONTASCENT(pfont) + FONTDESCENT(pfont); + if (!h) + return; + + x = xInit + FONTMAXBOUNDS(pfont,leftSideBearing); + y = yInit - FONTASCENT(pfont); + + if (image) + { + _igsSetOpaquePlaneBlt (cop, GXcopy, pGC->planemask, pGC->fgPixel, pGC->bgPixel, cmd); + } + else + { + _igsSetTransparentPlaneBlt (cop, pGC->alu, pGC->planemask, pGC->fgPixel, cmd); + } + +#if BITMAP_BIT_ORDER == LSBFirst +#define SHIFT << +#else +#define SHIFT >> +#endif + +#define LoopIt(count, w, loadup, fetch) \ + while (nglyph >= count) \ + { \ + nglyph -= count; \ + _igsPlaneBlt (cop, x, y, w, h, cmd); \ + x += w; \ + loadup \ + lwTmp = h; \ + PixTransStart(h); \ + while (lwTmp--) { \ + tmp = fetch; \ + IgsAdjustBits32(tmp); \ + PixTransStore(tmp); \ + } \ + } + + if (widthGlyph <= 8) + { + widthGlyphs = widthGlyph << 2; + LoopIt(4, widthGlyphs, + char1 = (unsigned long *) (*ppci++)->bits; + char2 = (unsigned long *) (*ppci++)->bits; + char3 = (unsigned long *) (*ppci++)->bits; + char4 = (unsigned long *) (*ppci++)->bits;, + (*char1++ | ((*char2++ | ((*char3++ | (*char4++ + SHIFT widthGlyph)) + SHIFT widthGlyph)) + SHIFT widthGlyph))) + } + else if (widthGlyph <= 10) + { + widthGlyphs = (widthGlyph << 1) + widthGlyph; + LoopIt(3, widthGlyphs, + char1 = (unsigned long *) (*ppci++)->bits; + char2 = (unsigned long *) (*ppci++)->bits; + char3 = (unsigned long *) (*ppci++)->bits;, + (*char1++ | ((*char2++ | (*char3++ SHIFT widthGlyph)) SHIFT widthGlyph))) + } + else if (widthGlyph <= 16) + { + widthGlyphs = widthGlyph << 1; + LoopIt(2, widthGlyphs, + char1 = (unsigned long *) (*ppci++)->bits; + char2 = (unsigned long *) (*ppci++)->bits;, + (*char1++ | (*char2++ SHIFT widthGlyph))) + } + lw = h * ((widthGlyph + 31) >> 5); + while (nglyph--) + { + _igsPlaneBlt (cop, x, y, widthGlyph, h, cmd); + x += widthGlyph; + char1 = (unsigned long *) (*ppci++)->bits; + lwTmp = lw; + PixTransStart(lw); + while (lwTmp--) + { + tmp = *char1++; + IgsAdjustBits32(tmp); + PixTransStore(tmp); + } + } + KdMarkSync (pDrawable->pScreen); +} + +/* + * Blt glyphs using image transfer window + */ + +void +igsPolyGlyphBlt (DrawablePtr pDrawable, + GCPtr pGC, + int x, + int y, + unsigned int nglyph, + CharInfoPtr *ppci, + pointer pglyphBase) +{ + x += pDrawable->x; + y += pDrawable->y; + + switch (igsTextInRegion (pGC, x, y, nglyph, ppci)) { + case rgnIN: + if (TERMINALFONT(pGC->font)) + igsTEGlyphBlt (pDrawable, pGC, x, y, nglyph, ppci, FALSE); + else + igsGlyphBlt (pDrawable, pGC, x, y, nglyph, ppci, FALSE); + break; + case rgnPART: + igsGlyphBltClipped (pDrawable, pGC, x, y, nglyph, ppci, FALSE); + break; + case rgnOUT: + break; + } +} + +void +igsImageGlyphBlt (DrawablePtr pDrawable, + GCPtr pGC, + int x, int y, + unsigned int nglyph, + CharInfoPtr *ppci, + pointer pglyphBase) +{ + x += pDrawable->x; + y += pDrawable->y; + + switch (igsTextInRegion (pGC, x, y, nglyph, ppci)) { + case rgnIN: + if (TERMINALFONT(pGC->font)) + igsTEGlyphBlt (pDrawable, pGC, x, y, nglyph, ppci, TRUE); + else + igsGlyphBlt (pDrawable, pGC, x, y, nglyph, ppci, TRUE); + break; + case rgnPART: + igsGlyphBltClipped (pDrawable, pGC, x, y, nglyph, ppci, TRUE); + break; + case rgnOUT: + break; + } +} + +static const GCOps igsOps = { + igsFillSpans, + KdCheckSetSpans, + KdCheckPutImage, + igsCopyArea, + KdCheckCopyPlane, + KdCheckPolyPoint, + KdCheckPolylines, + KdCheckPolySegment, + miPolyRectangle, + KdCheckPolyArc, + miFillPolygon, + igsPolyFillRect, + KdCheckPolyFillArc, + miPolyText8, + miPolyText16, + miImageText8, + miImageText16, + igsImageGlyphBlt, + igsPolyGlyphBlt, + KdCheckPushPixels, +#ifdef NEED_LINEHELPER + ,NULL +#endif +}; + +void +igsValidateGC (GCPtr pGC, Mask changes, DrawablePtr pDrawable) +{ + FbGCPrivPtr fbPriv = fbGetGCPrivate(pGC); + + fbValidateGC (pGC, changes, pDrawable); + + if (pDrawable->type == DRAWABLE_WINDOW) + pGC->ops = (GCOps *) &igsOps; + else + pGC->ops = (GCOps *) &fbGCOps; +} + +GCFuncs igsGCFuncs = { + igsValidateGC, + miChangeGC, + miCopyGC, + miDestroyGC, + miChangeClip, + miDestroyClip, + miCopyClip +}; + +int +igsCreateGC (GCPtr pGC) +{ + if (!fbCreateGC (pGC)) + return FALSE; + + if (pGC->depth != 1) + pGC->funcs = &igsGCFuncs; + + return TRUE; +} + +void +igsCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc) +{ + ScreenPtr pScreen = pWin->drawable.pScreen; + KdScreenPriv(pScreen); + RegionRec rgnDst; + int dx, dy; + WindowPtr pwinRoot; + + pwinRoot = WindowTable[pWin->drawable.pScreen->myNum]; + + dx = ptOldOrg.x - pWin->drawable.x; + dy = ptOldOrg.y - pWin->drawable.y; + REGION_TRANSLATE(pWin->drawable.pScreen, prgnSrc, -dx, -dy); + + REGION_INIT (pWin->drawable.pScreen, &rgnDst, NullBox, 0); + + REGION_INTERSECT(pWin->drawable.pScreen, &rgnDst, &pWin->borderClip, prgnSrc); + + fbCopyRegion ((DrawablePtr)pwinRoot, (DrawablePtr)pwinRoot, + 0, + &rgnDst, dx, dy, igsCopyNtoN, 0, 0); + + REGION_UNINIT(pWin->drawable.pScreen, &rgnDst); +} + +void +igsPaintWindow(WindowPtr pWin, RegionPtr pRegion, int what) +{ + KdScreenPriv(pWin->drawable.pScreen); + PixmapPtr pTile; + + if (!REGION_NUM_RECTS(pRegion)) + return; + switch (what) { + case PW_BACKGROUND: + switch (pWin->backgroundState) { + case None: + return; + case ParentRelative: + do { + pWin = pWin->parent; + } while (pWin->backgroundState == ParentRelative); + (*pWin->drawable.pScreen->PaintWindowBackground)(pWin, pRegion, + what); + return; +#if 0 + case BackgroundPixmap: + pTile = pWin->background.pixmap; + if (igsPatternDimOk (pTile->drawable.width) && + igsPatternDimOk (pTile->drawable.height)) + { + igsFillBoxTiled ((DrawablePtr)pWin, + (int)REGION_NUM_RECTS(pRegion), + REGION_RECTS(pRegion), + pTile, + pWin->drawable.x, pWin->drawable.y, GXcopy); + return; + } + break; +#endif + case BackgroundPixel: + igsFillBoxSolid((DrawablePtr)pWin, + (int)REGION_NUM_RECTS(pRegion), + REGION_RECTS(pRegion), + pWin->background.pixel, GXcopy, ~0); + return; + } + break; + case PW_BORDER: + if (pWin->borderIsPixel) + { + igsFillBoxSolid((DrawablePtr)pWin, + (int)REGION_NUM_RECTS(pRegion), + REGION_RECTS(pRegion), + pWin->border.pixel, GXcopy, ~0); + return; + } +#if 0 + else + { + pTile = pWin->border.pixmap; + if (igsPatternDimOk (pTile->drawable.width) && + igsPatternDimOk (pTile->drawable.height)) + { + igsFillBoxTiled ((DrawablePtr)pWin, + (int)REGION_NUM_RECTS(pRegion), + REGION_RECTS(pRegion), + pTile, + pWin->drawable.x, pWin->drawable.y, GXcopy); + return; + } + } +#endif + break; + } + KdCheckPaintWindow (pWin, pRegion, what); +} + +Bool +igsDrawInit (ScreenPtr pScreen) +{ + /* + * Replace various fb screen functions + */ + pScreen->CreateGC = igsCreateGC; + pScreen->CopyWindow = igsCopyWindow; + pScreen->PaintWindowBackground = igsPaintWindow; + pScreen->PaintWindowBorder = igsPaintWindow; + + KdScreenInitAsync (pScreen); + + return TRUE; +} + +void +igsDrawEnable (ScreenPtr pScreen) +{ + SetupIgs(pScreen); + CARD32 cmd; + CARD32 base; + CARD16 stride; + CARD32 format; + + stride = pScreenPriv->screen->fb[0].pixelStride; + _igsWaitIdleEmpty(cop); + _igsReset(cop); + switch (pScreenPriv->screen->fb[0].bitsPerPixel) { + case 8: + format = IGS_FORMAT_8BPP; + break; + case 16: + format = IGS_FORMAT_16BPP; + break; + case 24: + format = IGS_FORMAT_24BPP; + break; + case 32: + format = IGS_FORMAT_32BPP; + break; + } + cop->format = format; + cop->dst_stride = stride - 1; + cop->src1_stride = stride - 1; + cop->src2_stride = stride - 1; + cop->src1_start = 0; + cop->src2_start = 0; + cop->extension |= IGS_BLOCK_COP_REG | IGS_BURST_ENABLE; + + _igsSetSolidRect(cop, GXcopy, ~0, pScreen->blackPixel, cmd); + _igsRect (cop, 0, 0, + pScreenPriv->screen->width, pScreenPriv->screen->height, + cmd); + _igsWaitIdleEmpty (cop); +} + +void +igsDrawDisable (ScreenPtr pScreen) +{ +} + +void +igsDrawFini (ScreenPtr pScreen) +{ +} + +void +igsDrawSync (ScreenPtr pScreen) +{ + SetupIgs(pScreen); + + _igsWaitIdleEmpty(cop); +} diff --git a/hw/kdrive/igs/igsdraw.h b/hw/kdrive/igs/igsdraw.h new file mode 100644 index 000000000..5388d8e34 --- /dev/null +++ b/hw/kdrive/igs/igsdraw.h @@ -0,0 +1,188 @@ +/* + * $XFree86$ + * + * Copyright © 2000 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _IGSDRAW_H_ +#define _IGSDRAW_H_ + +extern CARD8 igsPatRop[]; + +#define SetupIgs(s) KdScreenPriv(s); \ + igsCardInfo(pScreenPriv); \ + Cop5xxx *cop = igsc->cop; \ + int cop_stride = pScreenPriv->screen->fb[0].pixelStride + +#define _igsWaitLoop(cop,mask,value) { \ + int __loop = 1000000; \ + while (((cop)->control & (mask)) != (value)) { \ + if (--__loop <= 0) { \ + FatalError("Warning: igsWaitLoop 0x%x 0x%x failed\n", mask, value); \ + } \ + } \ +} + +#define _igsWaitDone(cop) _igsWaitLoop(cop, \ + (IGS_CONTROL_BUSY| \ + IGS_CONTROL_MALLWBEPTZ), \ + 0) + +#define _igsWaitFull(cop) _igsWaitLoop(cop, \ + IGS_CONTROL_CMDFF, \ + 0) + +#define _igsWaitIdleEmpty(cop) _igsWaitDone(cop) +#define _igsWaitHostBltAck(cop) _igsWaitLoop(cop, \ + (IGS_CONTROL_HBACKZ| \ + IGS_CONTROL_CMDFF), \ + 0) + +#define _igsReset(cop) ((cop)->control = 0) + +#define IgsInvertBits32(v) { \ + v = ((v & 0x55555555) << 1) | ((v >> 1) & 0x55555555); \ + v = ((v & 0x33333333) << 2) | ((v >> 2) & 0x33333333); \ + v = ((v & 0x0f0f0f0f) << 4) | ((v >> 4) & 0x0f0f0f0f); \ +} + +#define IgsInvertBits16(v) { \ + v = ((v & 0x5555) << 1) | ((v >> 1) & 0x5555); \ + v = ((v & 0x3333) << 2) | ((v >> 2) & 0x3333); \ + v = ((v & 0x0f0f) << 4) | ((v >> 4) & 0x0f0f); \ +} + +#define IgsInvertBits8(v) { \ + v = ((v & 0x55) << 1) | ((v >> 1) & 0x55); \ + v = ((v & 0x33) << 2) | ((v >> 2) & 0x33); \ + v = ((v & 0x0f) << 4) | ((v >> 4) & 0x0f); \ +} + +#define IgsAdjustBits32(b) IgsInvertBits32(b) + +#define _igsSetSolidRect(cop,alu,pm,pix,cmd) {\ + _igsWaitFull(cop); \ + (cop)->mix = IGS_MAKE_MIX(alu,alu); \ + (cop)->fg = (pix); \ + (cop)->planemask = (pm); \ + (cmd) = (IGS_DRAW_T_B | \ + IGS_DRAW_L_R | \ + IGS_DRAW_ALL | \ + IGS_PIXEL_FG | \ + IGS_HBLT_DISABLE | \ + IGS_SRC2_NORMAL | \ + IGS_STEP_PXBLT | \ + IGS_FGS_FG | \ + IGS_BGS_BG); \ +} + +#define _igsRect(cop,x,y,w,h,cmd) { \ + _igsWaitFull(cop); \ + (cop)->dst_start = (x) + (y) * (cop_stride); \ + (cop)->dim = IGS_MAKE_DIM(w-1,h-1); \ + (cop)->operation = (cmd); \ +} + +#define _igsSetBlt(cop,alu,pm,backwards,upsidedown,cmd) { \ + _igsWaitFull(cop); \ + (cop)->mix = IGS_MAKE_MIX(alu,GXnoop); \ + (cop)->planemask = (pm); \ + (cop)->src1_stride = cop_stride - 1; \ + (cmd) = (IGS_DRAW_ALL | \ + IGS_PIXEL_FG | \ + IGS_HBLT_DISABLE | \ + IGS_SRC2_NORMAL | \ + IGS_STEP_PXBLT | \ + IGS_FGS_SRC | \ + IGS_BGS_BG); \ + if (backwards) (cmd) |= IGS_DRAW_R_L; \ + if (upsidedown) (cmd) |= IGS_DRAW_B_T; \ +} + +#if 0 +#define _igsPreparePlaneBlt(cop) { \ + _igsReset(cop); \ + (cop)->dst_stride = cop_stride - 1; \ + (cop)->src1_stride = cop_stride - 1; \ + (cop)->src2_stride = cop_stride - 1; \ + (cop)->format = IGS_FORMAT_16BPP; \ + (cop)->src1_start = 0; \ + (cop)->src2_start = 0; \ +} +#else +#define _igsPreparePlaneBlt(cop) +#endif + +#define _igsSetTransparentPlaneBlt(cop,alu,pm,fg_pix,cmd) { \ + _igsWaitIdleEmpty(cop); \ + _igsPreparePlaneBlt(cop); \ + (cop)->mix = IGS_MAKE_MIX(igsPatRop[alu],igsPatRop[GXnoop]); \ + (cop)->fg = (fg_pix); \ + (cop)->planemask = (pm); \ + (cmd) = (IGS_DRAW_T_B | \ + IGS_DRAW_L_R | \ + IGS_DRAW_ALL | \ + IGS_PIXEL_FG | \ + IGS_HBLT_WRITE_2 | \ + IGS_SRC2_MONO_TRANS | \ + IGS_STEP_TERNARY_PXBLT | \ + IGS_FGS_FG | \ + IGS_BGS_BG); \ +} + +#define _igsSetOpaquePlaneBlt(cop,alu,pm,fg_pix,bg_pix,cmd) { \ + _igsWaitIdleEmpty(cop); \ + _igsPreparePlaneBlt(cop); \ + (cop)->mix = IGS_MAKE_MIX(igsPatRop[alu],igsPatRop[alu]); \ + (cop)->planemask = (pm); \ + (cop)->fg = (fg_pix); \ + (cop)->bg = (bg_pix); \ + (cmd) = (IGS_DRAW_T_B | \ + IGS_DRAW_L_R | \ + IGS_DRAW_ALL | \ + IGS_PIXEL_FG | \ + IGS_HBLT_WRITE_2 | \ + IGS_SRC2_MONO_OPAQUE | \ + IGS_STEP_TERNARY_PXBLT | \ + IGS_FGS_FG | \ + IGS_BGS_BG); \ +} + +#define _igsPlaneBlt(cop,x,y,w,h,cmd) { \ +/* _igsWaitFull(cop); */ \ + (cop)->dst_start = (x) + (y) * (cop_stride); \ + (cop)->dim = IGS_MAKE_DIM((w)-1,(h)-1); \ + (cop)->operation = (cmd); \ +/* _igsWaitHostBltAck(cop); */ \ +} + +#define _igsBlt(cop,sx,sy,dx,dy,w,h,cmd) { \ + _igsWaitFull(cop); \ + (cop)->dst_start = (dx) + (dy) * cop_stride; \ + (cop)->src1_start = (sx) + (sy) * cop_stride; \ + (cop)->src1_stride = cop_stride - 1; \ + (cop)->dim = IGS_MAKE_DIM(w-1,h-1); \ + (cop)->operation = (cmd); \ +} + +#define sourceInvarient(alu) (((alu) & 3) == (((alu) >> 2) & 3)) + +#endif diff --git a/hw/kdrive/igs/igsstub.c b/hw/kdrive/igs/igsstub.c new file mode 100644 index 000000000..9d4c3d854 --- /dev/null +++ b/hw/kdrive/igs/igsstub.c @@ -0,0 +1,57 @@ +/* + * $XFree86$ + * + * Copyright © 2000 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "igs.h" + +void +InitCard (char *name) +{ + KdCardAttr attr; + CARD32 count; + + count = 0; + while (LinuxFindPci (0x10ea, 0x5000, count, &attr)) + { + KdCardInfoAdd (&igsFuncs, &attr, 0); + count++; + } +} + +void +InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv) +{ + KdInitOutput (pScreenInfo, argc, argv); +} + +void +InitInput (int argc, char **argv) +{ + KdInitInput (&Ps2MouseFuncs, &LinuxKeyboardFuncs); +} + +int +ddxProcessArgument (int argc, char **argv, int i) +{ + return KdProcessArgument (argc, argv, i); +} diff --git a/hw/kdrive/savage/s3.c b/hw/kdrive/savage/s3.c index 044ce0e7e..df62a27ce 100644 --- a/hw/kdrive/savage/s3.c +++ b/hw/kdrive/savage/s3.c @@ -22,7 +22,7 @@ * * Author: Keith Packard, SuSE, Inc. */ -/* $XFree86: xc/programs/Xserver/hw/kdrive/savage/s3.c,v 1.2 1999/12/30 03:03:10 robin Exp $ */ +/* $XFree86: xc/programs/Xserver/hw/kdrive/savage/s3.c,v 1.3 2000/02/23 20:30:01 dawes Exp $ */ #include "s3.h" @@ -30,6 +30,8 @@ #define PACKED_OFFSET (0x8100) #define IOMAP_OFFSET (0x8000) +#define S3_MIN_CLOCK 250000 + static void _s3SetBlank (S3Ptr s3, S3Vga *s3vga, Bool blank) { @@ -171,6 +173,15 @@ Bool s3ModeSupported (KdScreenInfo *screen, const KdMonitorTiming *t) { + if (screen->fb[1].depth) + { + /* + * Must have at least one true color stream + */ + if (screen->fb[0].depth <= 8 && + screen->fb[1].depth <= 8) + return FALSE; + } /* make sure the clock isn't too fast */ if (t->clock > S3_MAX_CLOCK * 2) return FALSE; @@ -188,35 +199,40 @@ s3ModeUsable (KdScreenInfo *screen) int screen_size; int pixel_width; int byte_width; + int fb; - if (screen->depth >= 24) - { - screen->depth = 24; - screen->bitsPerPixel = 32; - } - else if (screen->depth >= 16) - { - screen->depth = 16; - screen->bitsPerPixel = 16; - } - else if (screen->depth >= 15) - { - screen->depth = 15; - screen->bitsPerPixel = 16; - } - else + screen_size = 0; + for (fb = 0; fb < KD_MAX_FB && screen->fb[fb].depth; fb++) { - screen->depth = 8; - screen->bitsPerPixel = 8; + if (screen->fb[fb].depth >= 24) + { + screen->fb[fb].depth = 24; + if (screen->fb[fb].bitsPerPixel != 24) + screen->fb[fb].bitsPerPixel = 32; + } + else if (screen->fb[fb].depth >= 16) + { + screen->fb[fb].depth = 16; + screen->fb[fb].bitsPerPixel = 16; + } + else if (screen->fb[fb].depth >= 15) + { + screen->fb[fb].depth = 15; + screen->fb[fb].bitsPerPixel = 16; + } + else + { + screen->fb[fb].depth = 8; + screen->fb[fb].bitsPerPixel = 8; + } + + byte_width = screen->width * (screen->fb[fb].bitsPerPixel >> 3); + pixel_width = screen->width; + screen->fb[fb].pixelStride = pixel_width; + screen->fb[fb].byteStride = byte_width; + screen_size += byte_width * screen->height; } - byte_width = screen->width * (screen->bitsPerPixel >> 3); - pixel_width = screen->width; - screen->pixelStride = pixel_width; - screen->byteStride = byte_width; - - screen_size = byte_width * screen->height; - return screen_size <= s3c->memory; } @@ -233,6 +249,8 @@ s3ScreenInit (KdScreenInfo *screen) int i; const KdMonitorTiming *t; int screen_size; + int fb; + int ma; s3s = (S3ScreenInfo *) xalloc (sizeof (S3ScreenInfo)); if (!s3s) @@ -252,23 +270,25 @@ s3ScreenInit (KdScreenInfo *screen) screen->height = 600; screen->rate = 72; } - if (!screen->depth) - screen->depth = 8; + if (!screen->fb[0].depth) + screen->fb[0].depth = 8; t = KdFindMode (screen, s3ModeSupported); screen->rate = t->rate; screen->width = t->horizontal; screen->height = t->vertical; - s3GetClock (t->clock, &m, &n, &r, 511, 127, 4); + s3GetClock (t->clock, &m, &n, &r, 511, 127, 4, 250000); #ifdef DEBUG fprintf (stderr, "computed %d,%d,%d (%d)\n", m, n, r, S3_CLOCK(m,n,r)); #endif +#if 0 /* * Can only operate in pixel-doubled mode at 8 or 16 bits per pixel */ if (screen->depth > 16 && S3_CLOCK(m,n,r) > S3_MAX_CLOCK) screen->depth = 16; +#endif if (!KdTuneMode (screen, s3ModeUsable, s3ModeSupported)) { @@ -276,14 +296,31 @@ s3ScreenInit (KdScreenInfo *screen) return FALSE; } - screen_size = screen->byteStride * screen->height; + s3s->fbmap[2] = -1; + if (screen->fb[1].depth) + { + if (screen->fb[0].bitsPerPixel >= 16) + { + s3s->fbmap[0] = 1; + s3s->fbmap[1] = 0; + } + else + { + s3s->fbmap[0] = 0; + s3s->fbmap[1] = 1; + } + } + else + { + s3s->fbmap[0] = 0; + s3s->fbmap[1] = -1; + } - memory = s3c->memory - screen_size; + screen_size = 0; + for (fb = 0; fb < KD_MAX_FB && screen->fb[fb].depth; fb++) + screen_size += screen->fb[fb].byteStride * screen->height; - /* - * Stick frame buffer at start of memory - */ - screen->frameBuffer = s3c->frameBuffer; + memory = s3c->memory - screen_size; /* * Stick cursor at end of memory @@ -296,60 +333,61 @@ s3ScreenInit (KdScreenInfo *screen) else s3s->cursor_base = 0; - /* - * Use remaining memory for off-screen storage, but only use - * one piece (either right or bottom). - */ - if (memory >= screen->byteStride * S3_TILE_SIZE) - { - s3s->offscreen = s3c->frameBuffer + screen_size; - s3s->offscreen_x = 0; - s3s->offscreen_y = screen_size / screen->byteStride; - s3s->offscreen_width = screen->pixelStride; - s3s->offscreen_height = memory / screen->byteStride; - memory -= s3s->offscreen_height * screen->byteStride; - } - else if (screen->pixelStride - screen->width >= S3_TILE_SIZE) + screen_size = 0; + for (ma = 0; s3s->fbmap[ma] >= 0; ma++) { - s3s->offscreen = s3c->frameBuffer + screen->width; - s3s->offscreen_x = screen->width; - s3s->offscreen_y = 0; - s3s->offscreen_width = screen->pixelStride - screen->width; - s3s->offscreen_height = screen->height; - } - else - s3s->offscreen = 0; - - switch (screen->depth) { - case 8: - screen->visuals = ((1 << StaticGray) | - (1 << GrayScale) | - (1 << StaticColor) | - (1 << PseudoColor) | - (1 << TrueColor) | - (1 << DirectColor)); - screen->blueMask = 0x00; - screen->greenMask = 0x00; - screen->redMask = 0x00; - break; - case 15: - screen->visuals = (1 << TrueColor); - screen->blueMask = 0x001f; - screen->greenMask = 0x03e0; - screen->redMask = 0x7c00; - break; - case 16: - screen->visuals = (1 << TrueColor); - screen->blueMask = 0x001f; - screen->greenMask = 0x07e0; - screen->redMask = 0xf800; - break; - case 24: - screen->visuals = (1 << TrueColor); - screen->blueMask = 0x0000ff; - screen->greenMask = 0x00ff00; - screen->redMask = 0xff0000; - break; + fb = s3s->fbmap[ma]; + screen->fb[fb].frameBuffer = s3c->frameBuffer + screen_size; + screen_size += screen->fb[fb].byteStride * screen->height; + + /* + * Use remaining memory for off-screen storage, but only use + * one piece (either right or bottom). + */ + if (memory >= screen->fb[fb].byteStride * S3_TILE_SIZE) + { + s3s->fb[ma].offscreen = screen->fb[fb].frameBuffer; + s3s->fb[ma].offscreen_x = 0; + s3s->fb[ma].offscreen_y = screen->height; + s3s->fb[ma].offscreen_width = screen->fb[fb].pixelStride; + s3s->fb[ma].offscreen_height = S3_TILE_SIZE; + memory -= s3s->fb[ma].offscreen_height * screen->fb[fb].byteStride; + screen_size += s3s->fb[ma].offscreen_height * screen->fb[fb].byteStride; + } + else + s3s->fb[ma].offscreen = 0; + + switch (screen->fb[fb].depth) { + case 8: + screen->fb[fb].visuals = ((1 << StaticGray) | + (1 << GrayScale) | + (1 << StaticColor) | + (1 << PseudoColor) | + (1 << TrueColor) | + (1 << DirectColor)); + screen->fb[fb].blueMask = 0x00; + screen->fb[fb].greenMask = 0x00; + screen->fb[fb].redMask = 0x00; + break; + case 15: + screen->fb[fb].visuals = (1 << TrueColor); + screen->fb[fb].blueMask = 0x001f; + screen->fb[fb].greenMask = 0x03e0; + screen->fb[fb].redMask = 0x7c00; + break; + case 16: + screen->fb[fb].visuals = (1 << TrueColor); + screen->fb[fb].blueMask = 0x001f; + screen->fb[fb].greenMask = 0x07e0; + screen->fb[fb].redMask = 0xf800; + break; + case 24: + screen->fb[fb].visuals = (1 << TrueColor); + screen->fb[fb].blueMask = 0x0000ff; + screen->fb[fb].greenMask = 0x00ff00; + screen->fb[fb].redMask = 0xff0000; + break; + } } screen->driver = s3s; @@ -821,6 +859,7 @@ s3Preserve (KdCardInfo *card) S3Save *save = &s3c->save; CARD8 t1, t2; CARD8 *cursor_base; + CARD8 streams_mode; s3Save (s3vga); if (!s3c->bios_initialized) @@ -842,9 +881,30 @@ s3Preserve (KdCardInfo *card) save->write_mask = s3->write_mask; save->fg = s3->fg; save->bg = s3->bg; + /* + * Preserve streams processor state + */ + streams_mode = s3Get (s3vga, s3_streams_mode); + s3SetImm (s3vga, s3_streams_mode, 3); save->global_bitmap_1 = s3->global_bitmap_1; save->global_bitmap_2 = s3->global_bitmap_2; + save->adv_func_cntl = s3->adv_func_cntl; save->primary_bitmap_1 = s3->primary_bitmap_1; + save->primary_bitmap_2 = s3->primary_bitmap_2; + save->secondary_bitmap_1 = s3->secondary_bitmap_1; + save->secondary_bitmap_2 = s3->secondary_bitmap_2; + save->primary_stream_control = s3->primary_stream_control; + save->blend_control = s3->blend_control; + save->primary_stream_addr_0 = s3->primary_stream_addr_0; + save->primary_stream_addr_1 = s3->primary_stream_addr_1; + save->primary_stream_stride = s3->primary_stream_stride; + save->primary_stream_xy = s3->primary_stream_xy; + save->primary_stream_size = s3->primary_stream_size; + save->primary_stream_mem = s3->primary_stream_mem; + save->secondary_stream_xy = s3->secondary_stream_xy; + save->secondary_stream_size = s3->secondary_stream_size; + save->streams_fifo = s3->streams_fifo; + s3SetImm (s3vga, s3_streams_mode, streams_mode); _s3SetBlank (s3, s3vga, FALSE); } @@ -855,6 +915,49 @@ s3Preserve (KdCardInfo *card) int s3CpuTimeout, s3AccelTimeout; void +s3SetGlobalBitmap (ScreenPtr pScreen, int ma) +{ + KdScreenPriv(pScreen); + s3ScreenInfo (pScreenPriv); + + if (s3s->current_ma != ma) + { + s3CardInfo (pScreenPriv); + S3Vga *s3vga = &s3c->s3vga; + S3Ptr s3 = s3c->s3; + CARD32 gb1, gb2; + int depth; + int length; + KdCheckSync (pScreen); + switch (s3s->fb[ma].accel_bpp) { + case 8: + case 24: + length = 0; + break; + case 16: + length = 1; + break; + case 32: + length = 3; + break; + } + s3SetImm (s3vga, s3_pixel_length, length); + gb1 = s3s->fb[ma].bitmap_offset; + gb2 = ((1 << 0) | + (0 << 2) | + (1 << 3) | + ((s3s->fb[ma].accel_stride >> 4) << 4) | + (s3s->fb[ma].accel_bpp << 16) | + (0 << 24) | + (1 << 28)); + s3->global_bitmap_1 = gb1; + s3->global_bitmap_2 = gb2; + s3->global_bitmap_2 = gb2; + s3s->current_ma = ma; + } +} + +void s3Enable (ScreenPtr pScreen) { KdScreenPriv(pScreen); @@ -878,7 +981,7 @@ s3Enable (ScreenPtr pScreen) int h_screen_off; int h_start_fifo_fetch; - int primary_stream_l1; + int primary_stream_l1[KD_MAX_FB]; int v_total; int v_retrace_start; @@ -886,9 +989,14 @@ s3Enable (ScreenPtr pScreen) int v_display_end; int v_blank_start; int v_blank_end; - - int h_blank_start_adjust; - int h_blank_end_adjust; + int v_blank_start_adjust = 0; + int v_blank_end_adjust = 0; + + int h_blank_start_adjust = 0; + int h_blank_end_adjust = 0; + int h_sync_start_adjust = 0; + int h_sync_end_adjust = 0; + int h_start_fifo_fetch_adjust = 0; int h_sync_extend; int h_blank_extend; int i; @@ -899,6 +1007,13 @@ s3Enable (ScreenPtr pScreen) int cpu_timeout; int accel_timeout; int bytes_per_ms; + CARD32 control[2]; + int fb; + int ma; + + s3s->primary_depth = screen->fb[s3s->fbmap[0]].depth; + + s3s->use_streams = TRUE; t = KdFindMode (screen, s3ModeSupported); @@ -912,24 +1027,38 @@ s3Enable (ScreenPtr pScreen) vblank = t->vblank; vactive = t->vertical; + m = s3Get (s3vga, s3_dclk_m); n = s3Get (s3vga, s3_dclk_n); r = s3Get (s3vga, s3_dclk_r); -#ifdef DEBUG - fprintf (stderr, "old clock %d, %d, %d\n", m, n, r); +#define DEBUG_CLOCK +#ifdef DEBUG_CLOCK + fprintf (stderr, "old clock %d, %d, %d (%d)\n", m, n, r, S3_CLOCK(m,n,r)); #endif clock_double = FALSE; - s3GetClock (t->clock, &m, &n, &r, 511, 127, 4); - if (S3_CLOCK(m,n,r) > S3_MAX_CLOCK) + s3GetClock (t->clock, &m, &n, &r, 511, 127, 4, 250000); + if (S3_CLOCK(m,n,r) > S3_MAX_CLOCK && !s3s->use_streams) clock_double = TRUE; s3Set (s3vga, s3_clock_select, 3); s3Set (s3vga, s3_dclk_m, m); s3Set (s3vga, s3_dclk_n, n); s3Set (s3vga, s3_dclk_r, r); -#ifdef DEBUG +#ifdef DEBUG_CLOCK fprintf (stderr, "new clock %d, %d, %d (%d)\n", m, n, r, S3_CLOCK(m,n,r)); #endif + if (s3s->use_streams) + { + s3Set (s3vga, s3_streams_mode, 3); + s3Set (s3vga, s3_enable_l1_parameter, 1); + } + else + { + s3Set (s3vga, s3_streams_mode, 0); + s3Set (s3vga, s3_enable_l1_parameter, 0); + } + s3Set (s3vga, s3_flat_panel_output_control_1, 0); + s3Set (s3vga, s3_flat_panel_output_control_2, 0); s3Set (s3vga, s3_select_graphics_mode, 1); s3Set (s3vga, s3_enable_blinking, 0); s3Set (s3vga, s3_enable_vga_16bit, 0); @@ -949,10 +1078,12 @@ s3Enable (ScreenPtr pScreen) s3Set (s3vga, s3_enable_2d_3d, 1); s3Set (s3vga, s3_refresh_control, 1); s3Set (s3vga, s3_disable_pci_read_bursts, 0); + s3Set (s3vga, s3_pci_disconnect_enable, 1); + s3Set (s3vga, s3_primary_load_control, 0); + s3Set (s3vga, s3_secondary_load_control, 0); s3Set (s3vga, s3_pci_retry_enable, 1); s3Set (s3vga, s3_enable_256, 1); -/* s3Set (s3vga, s3_border_select, 1); /* eliminate white border */ - s3Set (s3vga, s3_border_select, 0); /* eliminate white border */ + s3Set (s3vga, s3_border_select, 1); /* eliminate white border */ s3SetImm (s3vga, s3_lock_palette, 0); /* unlock palette/border regs */ s3Set (s3vga, s3_disable_v_retrace_int, 1); if (t->hpol == KdSyncPositive) @@ -976,16 +1107,48 @@ s3Enable (ScreenPtr pScreen) s3Set (s3vga, s3_enable_clock_double, 0); s3Set (s3vga, s3_dclk_over_2, 0); - s3Set (s3vga, s3_fifo_fetch_timing, 1); - s3Set (s3vga, s3_fifo_drain_delay, 7); - - s3Set (s3vga, s3_delay_h_enable, 0); s3Set (s3vga, s3_sdclk_skew, 0); s3Set (s3vga, s3_dac_mask, 0xff); - s3Set (s3vga, s3_dac_power_saving_disable, 1); +#if 0 +#ifdef DEBUG_CLOCK + m = s3Get (s3vga, s3_mclk_m); + n = s3Get (s3vga, s3_mclk_n); + r = s3Get (s3vga, s3_mclk_r); + fprintf (stderr, "old mclk %d, %d, %d (%d)\n", m, n, r, S3_CLOCK(m,n,r)); +#endif + + s3GetClock (125282, &m, &n, &r, 127, 31, 3, 250000); + +#ifdef DEBUG_CLOCK + fprintf (stderr, "new mclk %d, %d, %d (%d)\n", m, n, r,S3_CLOCK(m,n,r)); +#endif + + s3Set (s3vga, s3_mclk_m, m); + s3Set (s3vga, s3_mclk_n, n); + s3Set (s3vga, s3_mclk_r, r); + +#ifdef DEBUG_CLOCK + m = s3Get (s3vga, s3_eclk_m); + n = s3Get (s3vga, s3_eclk_n); + r = s3Get (s3vga, s3_eclk_r); + fprintf (stderr, "old eclk %d, %d, %d (%d)\n", m, n, r, S3_CLOCK(m,n,r)); +#endif + +#define S3_ECLK 125282 + + s3GetClock (S3_ECLK, &m, &n, &r, 127, 31, 3, 250000); + +#ifdef DEBUG_CLOCK + fprintf (stderr, "new eclk %d, %d, %d (%d)\n", m, n, r,S3_CLOCK(m,n,r)); +#endif + + s3Set (s3vga, s3_eclk_m, m); + s3Set (s3vga, s3_eclk_n, n); + s3Set (s3vga, s3_eclk_r, r); +#endif s3s->manage_border = FALSE; /* @@ -998,61 +1161,85 @@ s3Enable (ScreenPtr pScreen) /* * Set pixel size, choose clock doubling mode */ - h_blank_start_adjust = 0; - h_blank_end_adjust = 0; - - switch (screen->bitsPerPixel) { - case 8: - h_screen_off = hactive; - s3Set (s3vga, s3_pixel_length, 0); - s3Set (s3vga, s3_color_mode, 0); - /* - * Set up for double-pixel mode, switch color modes, - * divide the dclk and delay h blank by 2 dclks - */ - if (clock_double) - { - s3Set (s3vga, s3_color_mode, 1); - s3Set (s3vga, s3_dclk_over_2, 1); - s3Set (s3vga, s3_enable_clock_double, 1); - s3Set (s3vga, s3_border_select, 0); -/* s3Set (s3vga, s3_border_color, pScreen->blackPixel); */ - h_blank_start_adjust = 4; - h_blank_end_adjust = -4; - s3s->manage_border = TRUE; - } - break; - case 16: - h_screen_off = hactive * 2; - s3Set (s3vga, s3_pixel_length, 1); - if (clock_double) - { - if (screen->depth == 15) - s3Set (s3vga, s3_color_mode, 3); + + bytes_per_ms = 0; + + for (ma = 0; s3s->fbmap[ma] >= 0; ma++) + { + fb = s3s->fbmap[ma]; + s3s->fb[ma].accel_bpp = screen->fb[fb].bitsPerPixel; + s3s->fb[ma].accel_stride = screen->fb[fb].pixelStride; + s3s->fb[ma].bitmap_offset = screen->fb[fb].frameBuffer - s3c->frameBuffer; + switch (s3s->fb[ma].accel_bpp) { + case 8: + h_screen_off = hactive; + s3Set (s3vga, s3_pixel_length, 0); + s3Set (s3vga, s3_color_mode, 0); + control[ma] = 0; + /* + * Set up for double-pixel mode, switch color modes, + * divide the dclk and delay h blank by 2 dclks + */ + if (clock_double) + { + s3Set (s3vga, s3_color_mode, 1); + s3Set (s3vga, s3_dclk_over_2, 1); + s3Set (s3vga, s3_enable_clock_double, 1); + s3Set (s3vga, s3_h_skew, 1); + h_blank_start_adjust = -3; + h_blank_end_adjust = -4; + s3Set (s3vga, s3_border_select, 0); +#if 0 + s3s->manage_border = TRUE; + /* s3Set (s3vga, s3_border_color, pScreen->blackPixel); */ +#endif + } + break; + case 16: + h_screen_off = hactive * 2; + s3Set (s3vga, s3_pixel_length, 1); + if (screen->fb[fb].depth == 15) + control[ma] = 3 << 24; else - s3Set (s3vga, s3_color_mode, 5); - s3Set (s3vga, s3_dclk_over_2, 1); - s3Set (s3vga, s3_enable_clock_double, 1); - s3Set (s3vga, s3_border_select, 0); - h_blank_start_adjust = 4; - h_blank_end_adjust = -4; - } - else - { - if (screen->depth == 15) - s3Set (s3vga, s3_color_mode, 2); + control[ma] = 5 << 24; + if (clock_double) + { + if (screen->fb[fb].depth == 15) + s3Set (s3vga, s3_color_mode, 3); + else + s3Set (s3vga, s3_color_mode, 5); + s3Set (s3vga, s3_dclk_over_2, 1); + s3Set (s3vga, s3_enable_clock_double, 1); + s3Set (s3vga, s3_border_select, 0); + h_blank_start_adjust = 4; + h_blank_end_adjust = -4; + } else - s3Set (s3vga, s3_color_mode, 4); - s3Set (s3vga, s3_dclk_over_2, 0); - s3Set (s3vga, s3_enable_clock_double, 0); - s3Set (s3vga, s3_delay_blank, 0); + { + if (screen->fb[fb].depth == 15) + s3Set (s3vga, s3_color_mode, 2); + else + s3Set (s3vga, s3_color_mode, 4); + s3Set (s3vga, s3_dclk_over_2, 0); + s3Set (s3vga, s3_enable_clock_double, 0); + s3Set (s3vga, s3_delay_blank, 0); + } + break; + case 24: + control[ma] = 6 << 24; + h_screen_off = hactive * 3; + s3s->fb[ma].accel_bpp = 8; + s3s->fb[ma].accel_stride = screen->fb[fb].pixelStride * 3; + break; + case 32: + control[ma] = 7 << 24; + h_screen_off = hactive * 4; + s3Set (s3vga, s3_pixel_length, 3); + s3Set (s3vga, s3_color_mode, 0xd); + break; } - break; - case 32: - h_screen_off = hactive * 4; - s3Set (s3vga, s3_pixel_length, 3); - s3Set (s3vga, s3_color_mode, 0xd); - break; + bytes_per_ms += t->clock * (screen->fb[fb].bitsPerPixel / 8); + primary_stream_l1[ma] = (screen->width * screen->fb[fb].bitsPerPixel / (8 * 8)) - 1; } /* @@ -1060,11 +1247,9 @@ s3Enable (ScreenPtr pScreen) */ s3Set (s3vga, s3_start_address, 0); - /* * Set various registers to avoid snow on the screen */ - bytes_per_ms = t->clock * (screen->bitsPerPixel / 8); fprintf (stderr, "bytes_per_ms %d\n", bytes_per_ms); fprintf (stderr, "primary 0x%x master 0x%x command 0x%x lpb 0x%x cpu 0x%x 2d 0x%x\n", @@ -1075,28 +1260,105 @@ s3Enable (ScreenPtr pScreen) s3Get (s3vga, s3_cpu_timeout), s3Get (s3vga, s3_2d_graphics_engine_timeout)); - /* cpu 2d - * 576000 - * 288000 0x1f 0x19 - + /* + * Test: + * accel x11perf -line500 + * cpu x11perf -circle500 + * + * cpu accel + * 1600x1200x32x85 (918000) 1 1 not enough + * 1600x1200x32x75 (810000) 3 2 + * 1600x1200x32x70 (756000) 4 3 + * 1600x1200x32x60 (648000) 6 5 + * + * 1280x1024x32x85 (630000) 6 4 + * 1280x1024x32x75 (540000) a 6 + * 1280x1024x32x60 (432000) 1f a + * + * 1152x900x32x85 (490000) a 6 + * 1152x900x32x75 (433000) 1f 8 + * 1152x900x32x70 (401000) 1f a + * 1152x900x32x66 (380000) 1f a + * + * 1024x768x32x85 (378000) 1f a + * 1024x768x32x75 (315000) 1f b + * 1024x768x32x70 (300000) 1f b + * 1024x768x32x60 (260000) 1f 12 + * + * 800x600x32x85 (225000) 1f 1a + * 800x600x32x72 (200000) 1f 1d + * 800x600x32x75 (198000) 1f 1d + * + * 1600x1200x16x85 (459000) 1f 8 + * 1600x1200x16x75 (405000) 1f a + * 1600x1200x16x70 (378000) 1f b + * 1600x1200x16x60 (324000) 1f f + * + * 1280x1024x16x85 (315000) 1f 12 + * 1280x1024x16x75 (270000) 1f 16 + * 1280x1024x16x60 (216000) 1f 1d + * + * 1600x1200x8x85 (229000) 1f 1f + * */ + if (s3CpuTimeout) { - cpu_timeout = s3CpuTimeout; - if (s3AccelTimeout) + if (s3CpuTimeout < 0) + cpu_timeout = 0; + else + cpu_timeout = s3CpuTimeout; + if (s3AccelTimeout < 0) + accel_timeout = 0; + else if (s3AccelTimeout) accel_timeout = s3AccelTimeout; else accel_timeout = s3CpuTimeout; } - else if (bytes_per_ms > 400000) + else if (bytes_per_ms >= 900000) { - cpu_timeout = 0x10; - accel_timeout = 0x7; + cpu_timeout = 0x01; + accel_timeout = 0x01; } - else if (bytes_per_ms > 250000) + else if (bytes_per_ms >= 800000) { - cpu_timeout = 0x10; - accel_timeout = 0x18; + cpu_timeout = 0x03; + accel_timeout = 0x02; + } + else if (bytes_per_ms >= 700000) + { + cpu_timeout = 0x04; + accel_timeout = 0x03; + } + else if (bytes_per_ms >= 600000) + { + cpu_timeout = 0x06; + accel_timeout = 0x04; + } + else if (bytes_per_ms >= 475000) + { + cpu_timeout = 0x0a; + accel_timeout = 0x06; + } + else if (bytes_per_ms >= 425000) + { + cpu_timeout = 0x1f; + accel_timeout = 0x8; + } + else if (bytes_per_ms >= 300000) + { + cpu_timeout = 0x1f; + accel_timeout = 0x0a; + } + else if (bytes_per_ms >= 250000) + { + cpu_timeout = 0x1f; + accel_timeout = 0x12; + } + else if (bytes_per_ms >= 200000) + { + cpu_timeout = 0x1f; + accel_timeout = 0x1a; } else { @@ -1104,6 +1366,8 @@ s3Enable (ScreenPtr pScreen) accel_timeout = 0x1f; } + fprintf (stderr, "cpu 0x%x accel 0x%x\n", cpu_timeout, accel_timeout); + s3Set (s3vga, s3_primary_stream_timeout, 0xc0); s3Set (s3vga, s3_master_control_unit_timeout, 0xf); s3Set (s3vga, s3_command_buffer_timeout, 0x1f); @@ -1111,14 +1375,17 @@ s3Enable (ScreenPtr pScreen) s3Set (s3vga, s3_2d_graphics_engine_timeout, accel_timeout); s3Set (s3vga, s3_cpu_timeout, cpu_timeout); + s3Set (s3vga, s3_fifo_fetch_timing, 1); + s3Set (s3vga, s3_fifo_drain_delay, 2); + /* * Compute horizontal register values from timings */ h_total = hactive + hblank - 5; h_display_end = hactive - 1; - h_sync_start = hactive + hfp; - h_sync_end = hactive + hblank - hbp; + h_sync_start = hactive + hfp + h_sync_start_adjust; + h_sync_end = hactive + hblank - hbp + h_sync_end_adjust; /* * pad the blank values narrow a bit and use the border_select to * eliminate the remaining border; don't know why, but it doesn't @@ -1141,6 +1408,7 @@ s3Enable (ScreenPtr pScreen) else h_start_fifo_fetch = h_total - 5; + h_start_fifo_fetch += h_start_fifo_fetch_adjust; if (h_blank_end - h_blank_start >= 0x40) h_blank_extend = 1; else @@ -1151,8 +1419,6 @@ s3Enable (ScreenPtr pScreen) else h_sync_extend = 0; - primary_stream_l1 = (screen->width * screen->bitsPerPixel / (8 * 8)) - 1; - #ifdef DEBUG fprintf (stderr, "h_total %d h_display_end %d\n", h_total, h_display_end); @@ -1173,18 +1439,18 @@ s3Enable (ScreenPtr pScreen) s3Set (s3vga, s3_h_sync_extend, h_sync_extend); s3Set (s3vga, s3_h_blank_extend, h_blank_extend); - s3Set (s3vga, s3_primary_stream_l1, primary_stream_l1); + s3Set (s3vga, s3_dac_power_saving_disable, 0); + s3Set (s3vga, s3_dac_power_up_time, hactive + hblank); + + s3Set (s3vga, s3_primary_stream_l1, primary_stream_l1[0]); + s3Set (s3vga, s3_streams_fifo_delay, 0); + v_total = vactive + vblank - 2; v_display_end = vactive - 1; -#if 0 - v_blank_start = vactive - 1; - v_blank_end = v_blank_start + vblank - 1; -#else - v_blank_start = vactive - 1; - v_blank_end = v_blank_start + vblank - 1; -#endif + v_blank_start = vactive - 1 + v_blank_start_adjust; + v_blank_end = v_blank_start + vblank - 1 + v_blank_end_adjust; v_retrace_start = vactive + vfp; v_retrace_end = vactive + vblank - vbp; @@ -1206,7 +1472,7 @@ s3Enable (ScreenPtr pScreen) */ if (!screen->softCursor) { - cursor_address = (s3s->cursor_base - screen->frameBuffer) / 1024; + cursor_address = (s3s->cursor_base - s3c->frameBuffer) / 1024; s3Set (s3vga, s3_cursor_address, cursor_address); s3Set (s3vga, s3_cursor_ms_x11, 0); @@ -1225,12 +1491,14 @@ s3Enable (ScreenPtr pScreen) * Set accelerator */ switch (screen->width) { - case 640: s3Set (s3vga, s3_ge_screen_width, 1); break; - case 800: s3Set (s3vga, s3_ge_screen_width, 2); break; - case 1024: s3Set (s3vga, s3_ge_screen_width, 0); break; - case 1152: s3Set (s3vga, s3_ge_screen_width, 4); break; - case 1280: s3Set (s3vga, s3_ge_screen_width, 3); break; - case 1600: s3Set (s3vga, s3_ge_screen_width, 6); break; +#if 0 + case 640: s3Set (s3vga, s3_ge_screen_width, 1); break; + case 800: s3Set (s3vga, s3_ge_screen_width, 2); break; + case 1024: s3Set (s3vga, s3_ge_screen_width, 0); break; + case 1152: s3Set (s3vga, s3_ge_screen_width, 4); break; + case 1280: s3Set (s3vga, s3_ge_screen_width, 3); break; + case 1600: s3Set (s3vga, s3_ge_screen_width, 6); break; +#endif default: s3Set (s3vga, s3_ge_screen_width, 7); /* use global bitmap descriptor */ } @@ -1246,17 +1514,70 @@ s3Enable (ScreenPtr pScreen) s3Set (s3vga, s3_vsync_control, 0); _s3SetBlank (s3, s3vga, TRUE); + if (s3s->use_streams) + s3Set (s3vga, s3_primary_stream_definition, 1); + else + s3Set (s3vga, s3_primary_stream_definition, 0); + VgaFlush(&s3vga->card); VgaSetImm (&s3vga->card, s3_clock_load_imm, 1); VgaSetImm(&s3vga->card, s3_clock_load_imm, 0); - s3->global_bitmap_1 = 0; - s3->global_bitmap_2 = MAKE_GBF (1, /* 64 bit bitmap descriptor size */ - 0, /* disable BCI */ - pScreenPriv->screen->pixelStride >> 4, - pScreenPriv->screen->bitsPerPixel, - 0); /* tile format */ + if (s3s->use_streams) + { + fb = s3s->fbmap[0]; + s3->primary_stream_control = control[0]; + s3->primary_stream_addr_0 = + s3->primary_stream_addr_1 = s3s->fb[0].bitmap_offset; + s3->primary_stream_stride = screen->fb[fb].byteStride; + s3->primary_stream_xy = (1 << 16) | 1; + s3->primary_stream_size = ((screen->fb[fb].pixelStride - 1) << 16) | screen->height; + s3->primary_stream_mem = (screen->fb[fb].byteStride * screen->height) / 8 - 1; + if (s3s->fbmap[1] >= 0) + { + fb = s3s->fbmap[1]; + s3->blend_control = 5 << 24; + if (s3s->fb[0].accel_bpp == 8) + s3->chroma_key_control = 0x330000ff; + else + s3->chroma_key_control = 0x13010101; + s3->secondary_stream_control = control[1] | screen->width; + s3->secondary_stream_h_scale = (1 << 15); + s3->color_adjustment = 0; + s3->secondary_stream_vscale = (1 << 15); + s3->secondary_stream_vinit = 0; + s3->secondary_stream_mbuf = 0; + s3->secondary_stream_addr_0 = + s3->secondary_stream_addr_1 = s3s->fb[1].bitmap_offset; + s3->secondary_stream_stride = screen->fb[fb].byteStride; + s3->secondary_stream_scount = screen->height; + s3->secondary_stream_xy = (1 << 16) | 1; + s3->secondary_stream_size = ((screen->fb[fb].pixelStride - 1) << 16) | screen->height; + s3->secondary_stream_mem = (1 << 22) | ((screen->fb[fb].byteStride * screen->height) / 8 - 1); + } + else + { + s3->blend_control = 1 << 24; + s3->secondary_stream_xy = 0x07ff07ff; + s3->secondary_stream_size = 0x00010001; + } + s3->streams_fifo = (0x20 << 11) | (0x20 << 5) | 0x2; + } + s3->mult_misc_read_sel = (((1 << 9) | + (1 << 11) | + (0xe << 12)) | + (((0xe << 0) | + (0xf << 12)) << 16)); + + s3->cmd_overflow_buf_ptr = (1 << 3); + s3->bci_power_management = (1 << 9); + s3->adv_func_cntl = (3 << 8) | (1 << 4) | (1 << 2) | 1; + s3->primary_bitmap_1 = 0; + s3->primary_bitmap_2 = 0; + s3->secondary_bitmap_1 = 0; + s3->secondary_bitmap_2 = 0; + s3s->current_ma = -1; _s3SetBlank (s3, s3vga, FALSE); -#if 1 +#if 0 { VGA16 r; static CARD32 streams[][2] = { @@ -1354,10 +1675,32 @@ s3Restore (KdCardInfo *card) S3Vga *s3vga = &s3c->s3vga; S3Save *save = &s3c->save; CARD8 *cursor_base; + CARD8 streams_mode; - /* graphics engine state */ + _s3SetBlank (s3, s3vga, TRUE); + /* streams processor state */ + streams_mode = s3Get (s3vga, s3_streams_mode); + s3SetImm (s3vga, s3_streams_mode, 3); s3->global_bitmap_1 = save->global_bitmap_1; s3->global_bitmap_2 = save->global_bitmap_2; + s3->adv_func_cntl = save->adv_func_cntl; + s3->primary_bitmap_1 = save->primary_bitmap_1; + s3->primary_bitmap_2 = save->primary_bitmap_2; + s3->secondary_bitmap_1 = save->secondary_bitmap_1; + s3->secondary_bitmap_2 = save->secondary_bitmap_2; + s3->primary_stream_control = save->primary_stream_control; + s3->blend_control = save->blend_control; + s3->primary_stream_addr_0 = save->primary_stream_addr_0; + s3->primary_stream_addr_0 = save->primary_stream_addr_0; + s3->primary_stream_stride = save->primary_stream_stride; + s3->primary_stream_xy = save->primary_stream_xy; + s3->primary_stream_size = save->primary_stream_size; + s3->primary_stream_mem = save->primary_stream_mem; + s3->secondary_stream_xy = save->secondary_stream_xy; + s3->secondary_stream_size = save->secondary_stream_size; + s3->streams_fifo = save->streams_fifo; + s3SetImm (s3vga, s3_streams_mode, streams_mode); + /* graphics engine state */ s3->alt_mix = save->alt_mix; s3->write_mask = save->write_mask; s3->fg = save->fg; @@ -1366,7 +1709,6 @@ s3Restore (KdCardInfo *card) s3->scissors_tl = 0x00000000; s3->scissors_br = 0x0fff0fff; - _s3SetBlank (s3, s3vga, TRUE); VgaRestore (&s3vga->card); s3Set (s3vga, s3_linear_window_size, 3); s3Set (s3vga, s3_enable_linear, 1); @@ -1417,6 +1759,100 @@ s3DPMS (ScreenPtr pScreen, int mode) } void +s3DumbPaintChromaKey (WindowPtr pWin, RegionPtr pRegion) +{ + ScreenPtr pScreen = pWin->drawable.pScreen; + KdScreenPriv(pScreen); + KdCardInfo *card = pScreenPriv->card; + KdScreenInfo *screen = pScreenPriv->screen; + s3CardInfo (pScreenPriv); + s3ScreenInfo (pScreenPriv); + + if (pWin->drawable.depth != s3s->primary_depth) + { + int nBox = REGION_NUM_RECTS(pRegion); + BoxPtr pBox = REGION_RECTS(pRegion); + PixmapPtr pPixmap; + FbOverlayScrPrivPtr pScrPriv = fbOverlayGetScrPriv(pScreen); + FbBits *dst; + FbStride dstStride; + int dstBpp; + + if (pScrPriv->pLayer[0]->drawable.depth == pWin->drawable.depth) + pPixmap = pScrPriv->pLayer[1]; + else + pPixmap = pScrPriv->pLayer[0]; + fbGetDrawable (&pPixmap->drawable, dst, dstStride, dstBpp); + while (nBox--) + { + fbSolid (dst + pBox->y1 * dstStride, + dstStride, + pBox->x1 * dstBpp, + dstBpp, + (pBox->x2 - pBox->x1) * dstBpp, + (pBox->y2 - pBox->y1), + 0x0, FB_ALLONES); + pBox++; + } + } +} + +void +s3DumbPaintWindow (WindowPtr pWin, RegionPtr pRegion, int what) +{ + s3DumbPaintChromaKey (pWin, pRegion); + fbPaintWindow (pWin, pRegion, what); +} + +void +s3DumbCopyWindow (WindowPtr pWin, + DDXPointRec ptOldOrg, + RegionPtr prgnSrc) +{ + ScreenPtr pScreen = pWin->drawable.pScreen; + RegionRec rgnDst; + int dx, dy; + PixmapPtr pPixmap; + FbOverlayScrPrivPtr pScrPriv = fbOverlayGetScrPriv(pScreen); + int fb; + + KdCheckSync (pScreen); + dx = ptOldOrg.x - pWin->drawable.x; + dy = ptOldOrg.y - pWin->drawable.y; + REGION_TRANSLATE(pWin->drawable.pScreen, prgnSrc, -dx, -dy); + + REGION_INIT (pWin->drawable.pScreen, &rgnDst, NullBox, 0); + + REGION_INTERSECT(pWin->drawable.pScreen, &rgnDst, &pWin->borderClip, prgnSrc); + + for (fb = 0; fb < pScrPriv->nlayers; fb++) + { + pPixmap = pScrPriv->pLayer[fb]; + fbCopyRegion (&pPixmap->drawable, &pPixmap->drawable, + 0, + &rgnDst, dx, dy, fbCopyWindowProc, 0, 0); + } + + REGION_UNINIT(pWin->drawable.pScreen, &rgnDst); + fbValidateDrawable (&pWin->drawable); +} + +Bool +s3InitScreen(ScreenPtr pScreen) +{ + KdScreenPriv(pScreen); + KdCardInfo *card = pScreenPriv->card; + KdScreenInfo *screen = pScreenPriv->screen; + s3CardInfo (pScreenPriv); + s3ScreenInfo (pScreenPriv); + + pScreen->PaintWindowBackground = s3DumbPaintWindow; + pScreen->PaintWindowBorder = s3DumbPaintWindow; + pScreen->CopyWindow = s3DumbCopyWindow; + return TRUE; +} + +void s3ScreenFini (KdScreenInfo *screen) { S3ScreenInfo *s3s = (S3ScreenInfo *) screen->driver; @@ -1439,7 +1875,7 @@ s3CardFini (KdCardInfo *card) KdCardFuncs s3Funcs = { s3CardInit, s3ScreenInit, - 0, + s3InitScreen, s3Preserve, s3Enable, s3DPMS, diff --git a/hw/kdrive/savage/s3.h b/hw/kdrive/savage/s3.h index 86cd1b0e9..a19b9c3d3 100644 --- a/hw/kdrive/savage/s3.h +++ b/hw/kdrive/savage/s3.h @@ -22,7 +22,7 @@ * * Author: Keith Packard, SuSE, Inc. */ -/* $XFree86: xc/programs/Xserver/hw/kdrive/savage/s3.h,v 1.2 1999/12/30 03:03:10 robin Exp $ */ +/* $XFree86: xc/programs/Xserver/hw/kdrive/savage/s3.h,v 1.3 2000/02/23 20:30:02 dawes Exp $ */ #ifndef _S3_H_ #define _S3_H_ @@ -98,110 +98,37 @@ typedef volatile struct _s3 { VOL32 blend_control; /* 81a0 */ VOL8 _pad3c[0x1c]; /* 81a4 */ VOL32 primary_stream_addr_0; /* 81c0 */ - VOL8 _pad3d[0x124]; /* 81c4 */ -#if 0 - VOL16 cur_y; /* 82e8 */ - VOL8 _pad4[0xc6]; /* 82ea */ -#else + VOL32 primary_stream_addr_1; /* 81c4 */ + VOL32 primary_stream_stride; /* 81c8 */ + VOL32 secondary_stream_mbuf; /* 81cc */ + VOL32 secondary_stream_addr_0;/* 81d0 */ + VOL32 secondary_stream_addr_1;/* 81d4 */ + VOL32 secondary_stream_stride;/* 81d8 */ + VOL8 _pad81dc[4]; /* 81dc */ + VOL32 secondary_stream_vscale;/* 81e0 */ + VOL32 secondary_stream_vinit; /* 81e4 */ + VOL32 secondary_stream_scount;/* 81e8 */ + VOL32 streams_fifo; /* 81ec */ + VOL32 primary_stream_xy; /* 81f0 */ + VOL32 primary_stream_size; /* 81f4 */ + VOL32 secondary_stream_xy; /* 81f8 */ + VOL32 secondary_stream_size; /* 81fc */ + VOL8 _pad8200[0xe8]; /* 8200 */ VOL32 cur_y; /* 82e8 */ - VOL8 _pad4[0xc4]; /* 82ec */ -#endif - -#if 0 - VOL8 crt_vga_3b0; /* 83b0 */ - VOL8 crt_vga_3b1; /* 83b1 */ - VOL8 crt_vga_3b2; /* 83b2 */ - VOL8 crt_vga_3b3; /* 83b3 */ - VOL8 crt_vga_3b4; /* 83b4 */ - VOL8 crt_vga_3b5; /* 83b5 */ - VOL8 crt_vga_3b6; /* 83b6 */ - VOL8 crt_vga_3b7; /* 83b7 */ - VOL8 crt_vga_3b8; /* 83b8 */ - VOL8 crt_vga_3b9; /* 83b9 */ - VOL8 crt_vga_3ba; /* 83ba */ - VOL8 crt_vga_3bb; /* 83bb */ - VOL8 crt_vga_3bc; /* 83bc */ - VOL8 crt_vga_3bd; /* 83bd */ - VOL8 crt_vga_3be; /* 83be */ - VOL8 crt_vga_3bf; /* 83bf */ - - VOL8 crt_vga_3c0; /* 83c0 */ - VOL8 crt_vga_3c1; /* 83c1 */ - VOL8 crt_vga_3c2; /* 83c2 */ - VOL8 crt_vga_3c3; /* 83c3 */ - VOL8 crt_vga_3c4; /* 83c4 */ - VOL8 crt_vga_3c5; /* 83c5 */ - VOL8 crt_vga_dac_ad_mk; /* 83c6 */ - VOL8 crt_vga_dac_rd_ad; /* 83c7 */ - VOL8 crt_vga_dac_wt_ad; /* 83c8 */ - VOL8 crt_vga_dac_data; /* 83c9 */ - VOL8 crt_vga_3ca; /* 83ca */ - VOL8 crt_vga_3cb; /* 83cb */ - VOL8 crt_vga_3cc; /* 83cc */ - VOL8 crt_vga_3cd; /* 83cd */ - VOL8 crt_vga_3ce; /* 83ce */ - VOL8 crt_vga_3cf; /* 83cf */ - - VOL8 crt_vga_3d0; /* 83d0 */ - VOL8 crt_vga_3d1; /* 83d1 */ - VOL8 crt_vga_3d2; /* 83d2 */ - VOL8 crt_vga_3d3; /* 83d3 */ - VOL8 crt_vga_3d4; /* 83d4 */ - VOL8 crt_vga_3d5; /* 83d5 */ - VOL8 crt_vga_3d6; /* 83d6 */ - VOL8 crt_vga_3d7; /* 83d7 */ - VOL8 crt_vga_3d8; /* 83d8 */ - VOL8 crt_vga_3d9; /* 83d9 */ - VOL8 crt_vga_status_1; /* 83da */ - VOL8 crt_vga_3db; /* 83db */ - VOL8 crt_vga_3dc; /* 83dc */ - VOL8 crt_vga_3dd; /* 83dd */ - VOL8 crt_vga_3de; /* 83de */ - VOL8 crt_vga_3df; /* 83df */ - - VOL8 _pad5[0x124]; /* 83e0 */ - VOL16 subsys_status; /* 8504 */ - VOL8 _pad6[0x6]; /* 8506 */ - VOL32 subsys_status; /* 8504 */ - VOL8 _pad6[0x4]; /* 8508 */ - VOL16 adv_control; /* 850c */ - VOL8 _pad7[0x1da]; /* 850e */ - VOL16 cur_x; /* 86e8 */ - VOL8 _pad8[0x3fe]; /* 86ea */ - VOL16 desty_axstp; /* 8ae8 */ - VOL8 _pad9[0x3fe]; /* 8aea */ - VOL16 destx_diastp; /* 8ee8 */ - VOL8 _pad10[0x3fe]; /* 8eea */ - VOL16 enh_err_term; /* 92e8 */ - VOL8 _pad11[0x3fe]; /* 92ea */ - VOL16 maj_axis_pcnt; /* 96e8 */ - VOL8 _pad12[0x3fe]; /* 96ea */ - VOL16 enh_cmd_gp_stat; /* 9ae8 */ - VOL8 _pad13[0x3fe]; /* 9aea */ - VOL16 enh_short_stroke; /* 9ee8 */ - VOL8 _pad14[0x3fe]; /* 9eea */ - VOL16 enh_bg; /* a2e8 */ - VOL8 _pad15[0x3fe]; /* a2ea */ - VOL16 enh_fg; /* a6e8 */ - VOL8 _pad16[0x3fe]; /* a6ea */ - VOL16 enh_wrt_mask; /* aae8 */ - VOL8 _pad17[0x3fe]; /* aaea */ - VOL16 enh_rd_mask; /* aee8 */ - VOL8 _pad18[0x3fe]; /* aeea */ - VOL16 enh_color_cmp; /* b2e8 */ - VOL8 _pad19[0x3fe]; /* b2ea */ - VOL16 enh_bg_mix; /* b6e8 */ - VOL8 _pad20[0x3fe]; /* b6ea */ - VOL16 enh_fg_mix; /* bae8 */ - VOL8 _pad21[0x3fe]; /* baea */ - VOL16 enh_rd_reg_dt; /* bee8 */ - VOL8 _pad22[0x23fe]; /* beea */ -#else - VOL8 _pad_reg[0x5f38]; /* 83b0 */ -#endif + VOL8 _pad4[0x14]; /* 82ec */ + VOL32 primary_stream_mem; /* 8300 */ + VOL32 secondary_stream_mem; /* 8304 */ + VOL8 _pad8308[0xD2]; /* 8308 */ + VOL8 input_status_1; /* 83da */ + VOL8 _pad83db[0x131]; /* 83db */ + VOL32 adv_func_cntl; /* 850c */ + VOL8 _pad8510[0x5dd8]; /* 8510 */ VOL32 pix_trans; /* e2e8 */ - - VOL8 _pad23[0x3a974]; /* e2ec */ + VOL8 _pade2ec[0x3a92c]; /* e2ec */ + VOL32 cmd_overflow_buf_ptr; /* 48c18 */ + VOL8 _pad48c1c[0x8]; /* 48c1c */ + VOL32 bci_power_management; /* 48c24 */ + VOL8 _pad48c28[0x38]; /* 48c28 */ VOL32 alt_status_0; /* 48c60 */ VOL32 alt_status_1; /* 48c64 */ } S3, *S3Ptr; @@ -368,6 +295,22 @@ typedef volatile struct _s3 { #define COLCMPOP_GT 0x0038 #define PLANEMODE 0x0004 +/* Multifunction Control Misc 8144 */ +#define MISC_DST_BA_0 (0x0 << 0) +#define MISC_DST_BA_1 (0x1 << 0) +#define MISC_DST_BA_2 (0x2 << 0) +#define MISC_DST_BA_3 (0x3 << 0) +#define MISC_SRC_BA_0 (0x0 << 2) +#define MISC_SRC_BA_1 (0x1 << 2) +#define MISC_SRC_BA_2 (0x2 << 2) +#define MISC_SRC_BA_3 (0x3 << 2) +#define MISC_RSF (1 << 4) +#define MISC_EXT_CLIP (1 << 5) +#define MISC_SRC_NE (1 << 7) +#define MISC_ENB_CMP (1 << 8) +#define MISC_32B (1 << 9) +#define MISC_DC (1 << 11) +#define MISC_INDEX_E (0xe << 12) #define S3_SAVAGE4_SLOTS 0x0001ffff #define S3_SAVAGE4_2DI 0x00800000 @@ -393,8 +336,7 @@ typedef volatile struct _s3 { } #define _s3WaitEmpty(s3) _s3WaitLoop(s3,S3_SAVAGE4_SLOTS, 0) -#define _s3WaitIdleEmpty(s3) _s3WaitLoop(s3,S3_SAVAGE4_SLOTS|S3_SAVAGE4_2DI, \ - S3_SAVAGE4_2DI) +#define _s3WaitIdleEmpty(s3) _s3WaitLoop(s3,S3_SAVAGE4_SLOTS|S3_SAVAGE4_2DI, S3_SAVAGE4_2DI) #define _s3WaitIdle(s3) _s3WaitLoop(s3,S3_SAVAGE4_2DI, S3_SAVAGE4_2DI) typedef struct _s3Cursor { @@ -457,8 +399,22 @@ typedef struct _s3Save { CARD32 bg; CARD32 global_bitmap_1; CARD32 global_bitmap_2; + CARD32 adv_func_cntl; CARD32 primary_bitmap_1; CARD32 primary_bitmap_2; + CARD32 secondary_bitmap_1; + CARD32 secondary_bitmap_2; + CARD32 primary_stream_control; + CARD32 blend_control; + CARD32 primary_stream_addr_0; + CARD32 primary_stream_addr_1; + CARD32 primary_stream_stride; + CARD32 primary_stream_xy; + CARD32 primary_stream_size; + CARD32 primary_stream_mem; + CARD32 secondary_stream_xy; + CARD32 secondary_stream_size; + CARD32 streams_fifo; CARD8 text_save[S3_TEXT_SAVE]; } S3Save; @@ -473,18 +429,29 @@ typedef struct _s3CardInfo { Bool bios_initialized; /* whether the bios has been run */ } S3CardInfo; -typedef struct _s3ScreenInfo { - CARD8 *cursor_base; /* pointer to cursor area */ +typedef struct _s3FbInfo { CARD8 *offscreen; /* pointer to offscreen area */ int offscreen_y; /* top y coordinate of offscreen area */ int offscreen_x; /* top x coordinate of offscreen area */ int offscreen_width; /* width of offscreen area */ int offscreen_height; /* height of offscreen area */ - S3Cursor cursor; S3Patterns patterns; + CARD32 bitmap_offset; + int accel_stride; + int accel_bpp; +} S3FBInfo; + +typedef struct _s3ScreenInfo { + CARD8 *cursor_base; /* pointer to cursor area */ + S3Cursor cursor; Bool manage_border; Bool managing_border; + Bool use_streams; + int primary_depth; + int current_ma; CARD32 border_pixel; + S3FBInfo fb[KD_MAX_FB]; + int fbmap[KD_MAX_FB+1]; /* map from fb to stream */ } S3ScreenInfo; #define getS3CardInfo(kd) ((S3CardInfo *) ((kd)->card->driver)) @@ -505,18 +472,21 @@ void s3CursorDisable (ScreenPtr pScreen); void s3CursorFini (ScreenPtr pScreen); void s3RecolorCursor (ScreenPtr pScreen, int ndef, xColorItem *pdefs); +void s3DumbPaintWindow (WindowPtr pWin, RegionPtr pRegion, int what); +void s3DumbCopyWindow (WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc); + Bool s3DrawInit (ScreenPtr pScreen); void s3DrawEnable (ScreenPtr pScreen); void s3DrawSync (ScreenPtr pScreen); void s3DrawDisable (ScreenPtr pScreen); void s3DrawFini (ScreenPtr pScreen); -void s3GetColors (ScreenPtr pScreen, int ndef, xColorItem *pdefs); -void s3PutColors (ScreenPtr pScreen, int ndef, xColorItem *pdefs); +void s3GetColors (ScreenPtr pScreen, int fb, int ndef, xColorItem *pdefs); +void s3PutColors (ScreenPtr pScreen, int fb, int ndef, xColorItem *pdefs); void S3InitCard (KdCardAttr *attr); -void s3GetClock (int target, int *Mp, int *Np, int *Rp, int maxM, int maxN, int maxR); +void s3GetClock (int target, int *Mp, int *Np, int *Rp, int maxM, int maxN, int maxR, int minVco); extern KdCardFuncs s3Funcs; @@ -539,6 +509,13 @@ extern KdCardFuncs s3Funcs; _loop_count = 0; \ while (s3GetImm(s3vga, s3_vertical_sync_active) == 0) S3_RETRACE_LOOP_CHECK; \ } +#define _s3WaitVRetraceFast(s3) { \ + int _loop_count; \ + _loop_count = 0; \ + while (s3->input_status_1 & 8) S3_RETRACE_LOOP_CHECK; \ + _loop_count = 0; \ + while ((s3->input_status_1 & 8) == 0) S3_RETRACE_LOOP_CHECK; \ +} /* * Wait for the begining of the retrace interval */ diff --git a/hw/kdrive/savage/s3clock.c b/hw/kdrive/savage/s3clock.c index 49b843624..d62762bee 100644 --- a/hw/kdrive/savage/s3clock.c +++ b/hw/kdrive/savage/s3clock.c @@ -22,7 +22,7 @@ * * Author: Keith Packard, SuSE, Inc. */ -/* $XFree86: xc/programs/Xserver/hw/kdrive/savage/s3clock.c,v 1.2 1999/12/30 03:03:11 robin Exp $ */ +/* $XFree86: xc/programs/Xserver/hw/kdrive/savage/s3clock.c,v 1.3 2000/02/23 20:30:02 dawes Exp $ */ #include "s3.h" @@ -41,11 +41,9 @@ */ /* all in kHz */ -#define MIN_VCO 135000.0 -#define MAX_VCO 270000.0 void -s3GetClock (int target, int *Mp, int *Np, int *Rp, int maxM, int maxN, int maxR) +s3GetClock (int target, int *Mp, int *Np, int *Rp, int maxM, int maxN, int maxR, int minVco) { int M, N, R, bestM, bestN; int f_vco, f_out; @@ -57,15 +55,15 @@ s3GetClock (int target, int *Mp, int *Np, int *Rp, int maxM, int maxN, int maxR) for (R = 0; R <= maxR; R++) { f_vco = target * (1 << R); - if (f_vco >= MIN_VCO) + if (f_vco >= minVco) break; } /* M = f_out / f_ref * ((N + 2) * (1 << R)); */ besterr = target; - for (N = 0; N <= maxN; N++) + for (N = 1; N <= maxN; N++) { - M = (target * (N + 2) * (1 << R) + (S3_CLOCK_REF/2)) / S3_CLOCK_REF - 2; + M = ((target * (N + 2) * (1 << R) + (S3_CLOCK_REF/2)) + S3_CLOCK_REF/2) / S3_CLOCK_REF - 2; if (0 <= M && M <= maxM) { f_out = S3_CLOCK(M,N,R); diff --git a/hw/kdrive/savage/s3cmap.c b/hw/kdrive/savage/s3cmap.c index b6540cbd1..a3ede490f 100644 --- a/hw/kdrive/savage/s3cmap.c +++ b/hw/kdrive/savage/s3cmap.c @@ -22,12 +22,12 @@ * * Author: Keith Packard, SuSE, Inc. */ -/* $XFree86: xc/programs/Xserver/hw/kdrive/savage/s3cmap.c,v 1.2 1999/12/30 03:03:11 robin Exp $ */ +/* $XFree86: xc/programs/Xserver/hw/kdrive/savage/s3cmap.c,v 1.3 2000/02/23 20:30:02 dawes Exp $ */ #include "s3.h" void -s3GetColors (ScreenPtr pScreen, int ndef, xColorItem *pdefs) +s3GetColors (ScreenPtr pScreen, int fb, int ndef, xColorItem *pdefs) { KdScreenPriv(pScreen); s3CardInfo(pScreenPriv); @@ -44,7 +44,7 @@ s3GetColors (ScreenPtr pScreen, int ndef, xColorItem *pdefs) } void -s3PutColors (ScreenPtr pScreen, int ndef, xColorItem *pdefs) +s3PutColors (ScreenPtr pScreen, int fb, int ndef, xColorItem *pdefs) { KdScreenPriv(pScreen); s3CardInfo(pScreenPriv); @@ -53,7 +53,12 @@ s3PutColors (ScreenPtr pScreen, int ndef, xColorItem *pdefs) Bool hit_border = FALSE; Bool check_border = FALSE; +#if 0 _s3WaitVRetrace (s3vga); +#else + S3Ptr s3 = s3c->s3; + _s3WaitVRetraceFast(s3); +#endif if (pScreenPriv->enabled && s3s->manage_border && !s3s->managing_border) check_border = TRUE; while (ndef--) @@ -77,10 +82,10 @@ s3PutColors (ScreenPtr pScreen, int ndef, xColorItem *pdefs) black.green = 0; black.blue = 0; s3s->managing_border = TRUE; - FakeAllocColor (pScreenPriv->pInstalledmap, + FakeAllocColor (pScreenPriv->pInstalledmap[fb], &black); s3s->border_pixel = black.pixel; - FakeFreeColor (pScreenPriv->pInstalledmap, s3s->border_pixel); + FakeFreeColor (pScreenPriv->pInstalledmap[fb], s3s->border_pixel); /* s3SetImm (&s3c->s3vga, s3_border_color, (VGA8) s3s->border_pixel); */ } } diff --git a/hw/kdrive/savage/s3curs.c b/hw/kdrive/savage/s3curs.c index fd61d5e32..1faa6d8c0 100644 --- a/hw/kdrive/savage/s3curs.c +++ b/hw/kdrive/savage/s3curs.c @@ -22,7 +22,7 @@ * * Author: Keith Packard, SuSE, Inc. */ -/* $XFree86: xc/programs/Xserver/hw/kdrive/savage/s3curs.c,v 1.2 1999/12/30 03:03:11 robin Exp $ */ +/* $XFree86: xc/programs/Xserver/hw/kdrive/savage/s3curs.c,v 1.3 2000/02/23 20:30:03 dawes Exp $ */ #include "s3.h" #include "s3draw.h" @@ -90,24 +90,42 @@ s3MoveCursor (ScreenPtr pScreen, int x, int y) _s3MoveCursor (pScreen, x, y); } +#define S3Trunc(c) (((c) >> 8) & 0xff) + +#define S3CursColor(r,g,b) ((S3Trunc(r) << 16) | \ + (S3Trunc(g) << 8) | \ + (S3Trunc(b))) + static void s3AllocCursorColors (ScreenPtr pScreen) { SetupCursor (pScreen); CursorPtr pCursor = pCurPriv->pCursor; - KdAllocateCursorPixels (pScreen, pCursor, - &pCurPriv->source, &pCurPriv->mask); - switch (pScreenPriv->screen->bitsPerPixel) { - case 4: - pCurPriv->source |= pCurPriv->source << 4; - pCurPriv->mask |= pCurPriv->mask << 4; - case 8: - pCurPriv->source |= pCurPriv->source << 8; - pCurPriv->mask |= pCurPriv->mask << 8; - case 16: - pCurPriv->source |= pCurPriv->source << 16; - pCurPriv->mask |= pCurPriv->mask << 16; + if (s3s->use_streams) + { + pCurPriv->source = S3CursColor(pCursor->foreRed, + pCursor->foreGreen, + pCursor->foreBlue); + pCurPriv->mask = S3CursColor(pCursor->backRed, + pCursor->backGreen, + pCursor->backBlue); + } + else + { + KdAllocateCursorPixels (pScreen, 0, pCursor, + &pCurPriv->source, &pCurPriv->mask); + switch (pScreenPriv->screen->fb[0].bitsPerPixel) { + case 4: + pCurPriv->source |= pCurPriv->source << 4; + pCurPriv->mask |= pCurPriv->mask << 4; + case 8: + pCurPriv->source |= pCurPriv->source << 8; + pCurPriv->mask |= pCurPriv->mask << 8; + case 16: + pCurPriv->source |= pCurPriv->source << 16; + pCurPriv->mask |= pCurPriv->mask << 16; + } } } @@ -221,6 +239,13 @@ s3LoadCursor (ScreenPtr pScreen, int x, int y) S3AdjustBits32(and); S3AdjustBits32(xor); +#define S3SwapNibbles(x) ((x) = (((x) & 0x0f0f0f0f) << 4 | \ + ((x) >> 4) & 0x0f0f0f0f)) + if (s3s->use_streams) + { + S3SwapNibbles(and); + S3SwapNibbles(xor); + } *ram++ = (and & 0xffff) | (xor << 16); *ram++ = (and >> 16) | (xor & 0xffff0000); } diff --git a/hw/kdrive/savage/s3draw.c b/hw/kdrive/savage/s3draw.c index d4d645184..c4c369c43 100644 --- a/hw/kdrive/savage/s3draw.c +++ b/hw/kdrive/savage/s3draw.c @@ -22,7 +22,7 @@ * * Author: Keith Packard, SuSE, Inc. */ -/* $XFree86: xc/programs/Xserver/hw/kdrive/savage/s3draw.c,v 1.2 1999/12/30 03:03:11 robin Exp $ */ +/* $XFree86: xc/programs/Xserver/hw/kdrive/savage/s3draw.c,v 1.3 2000/02/23 20:30:03 dawes Exp $ */ #include "s3.h" #include "s3draw.h" @@ -114,6 +114,7 @@ s3CopyNtoN (DrawablePtr pSrcDrawable, return; } + s3SetGlobalBitmap (pDstDrawable->pScreen, s3GCMap (pGC)); _s3SetBlt(s3,pGC->alu,pGC->planemask); DRAW_DEBUG ((DEBUG_RENDER, "s3CopyNtoN alu %d planemask 0x%x", pGC->alu, pGC->planemask)); @@ -265,6 +266,7 @@ s3Copy1toN (DrawablePtr pSrcDrawable, return; } + s3SetGlobalBitmap (pDstDrawable->pScreen, s3GCMap (pGC)); fbGetStipDrawable (pSrcDrawable, psrcBase, widthSrc, srcBpp); if (args->opaque) @@ -345,6 +347,7 @@ s3FillBoxSolid (DrawablePtr pDrawable, int nBox, BoxPtr pBox, SetupS3(pDrawable->pScreen); register int r; + s3SetGlobalBitmap (pDrawable->pScreen, s3DrawMap (pDrawable)); _s3SetSolidFill(s3,pixel,alu,planemask); while (nBox--) { @@ -355,13 +358,13 @@ s3FillBoxSolid (DrawablePtr pDrawable, int nBox, BoxPtr pBox, } void -_s3SetPattern (ScreenPtr pScreen, +_s3SetPattern (ScreenPtr pScreen, int ma, int alu, unsigned long planemask, s3PatternPtr pPattern) { SetupS3(pScreen); S3PatternCache *cache; - _s3LoadPattern (pScreen, pPattern); + _s3LoadPattern (pScreen, ma, pPattern); cache = pPattern->cache; switch (pPattern->fillStyle) { @@ -385,7 +388,8 @@ s3FillBoxPattern (DrawablePtr pDrawable, int nBox, BoxPtr pBox, S3PatternCache *cache; int patx, paty; - _s3SetPattern (pDrawable->pScreen, alu, planemask, pPattern); + s3SetGlobalBitmap (pDrawable->pScreen, s3DrawMap (pDrawable)); + _s3SetPattern (pDrawable->pScreen, s3DrawMap(pDrawable), alu, planemask, pPattern); cache = pPattern->cache; while (nBox--) { @@ -415,6 +419,7 @@ s3FillBoxLargeStipple (DrawablePtr pDrawable, GCPtr pGC, stipHeight = pStipple->height; fbGetStipDrawable (pStipple, stip, stipStride, stipBpp); + s3SetGlobalBitmap (pDrawable->pScreen, s3DrawMap (pDrawable)); if (pGC->fillStyle == FillOpaqueStippled) { _s3SetOpaquePlaneBlt(s3,pGC->alu,pGC->planemask, @@ -648,6 +653,7 @@ _s3FillSpanLargeStipple (DrawablePtr pDrawable, GCPtr pGC, int stipWidth, stipHeight; int dstX, dstY, width, height; + s3SetGlobalBitmap (pDrawable->pScreen, s3GCMap (pGC)); stipWidth = pStipple->width; stipHeight = pStipple->height; fbGetStipDrawable (pStipple, stip, stipStride, stipBpp); @@ -711,6 +717,7 @@ s3FillSpans (DrawablePtr pDrawable, GCPtr pGC, int n, S3PatternCache *cache; RegionPtr pClip = fbGetCompositeClip (pGC); + s3SetGlobalBitmap (pDrawable->pScreen, s3GCMap (pGC)); if (REGION_NUM_RECTS(pClip) == 1 && (pGC->fillStyle == FillSolid || s3Priv->pPattern)) { @@ -726,7 +733,7 @@ s3FillSpans (DrawablePtr pDrawable, GCPtr pGC, int n, } else { - _s3SetPattern (pDrawable->pScreen, pGC->alu, pGC->planemask, + _s3SetPattern (pDrawable->pScreen, s3GCMap(pGC), pGC->alu, pGC->planemask, s3Priv->pPattern); cache = s3Priv->pPattern->cache; } @@ -793,7 +800,7 @@ s3FillSpans (DrawablePtr pDrawable, GCPtr pGC, int n, } else if (s3Priv->pPattern) { - _s3SetPattern (pDrawable->pScreen, pGC->alu, pGC->planemask, + _s3SetPattern (pDrawable->pScreen, s3GCMap(pGC), pGC->alu, pGC->planemask, s3Priv->pPattern); cache = s3Priv->pPattern->cache; while (n--) @@ -843,6 +850,7 @@ s3FillSpans (DrawablePtr pDrawable, GCPtr pGC, int n, static void _s3FillEllipse (DrawablePtr pDraw, S3Ptr s3, xArc *arc) { + KdScreenPriv(pDraw->pScreen); int x, y, e; int yk, xk, ym, xm, dx, dy, xorg, yorg; int y_top, y_bot; @@ -850,6 +858,7 @@ _s3FillEllipse (DrawablePtr pDraw, S3Ptr s3, xArc *arc) register int xpos; int slw; + s3SetGlobalBitmap (pDraw->pScreen, s3DrawMap (pDraw)); miFillArcSetup(arc, &info); MIFILLARCSETUP(); y_top = pDraw->y + yorg - y; @@ -873,6 +882,7 @@ _s3FillEllipse (DrawablePtr pDraw, S3Ptr s3, xArc *arc) static void _s3FillArcSlice (DrawablePtr pDraw, GCPtr pGC, S3Ptr s3, xArc *arc) { + KdScreenPriv(pDraw->pScreen); int yk, xk, ym, xm, dx, dy, xorg, yorg, slw; register int x, y, e; miFillArcRec info; @@ -880,6 +890,7 @@ _s3FillArcSlice (DrawablePtr pDraw, GCPtr pGC, S3Ptr s3, xArc *arc) int xl, xr, xc; int y_top, y_bot; + s3SetGlobalBitmap (pDraw->pScreen, s3DrawMap (pDraw)); DRAW_DEBUG ((DEBUG_ARCS, "slice %dx%d+%d+%d %d->%d", arc->width, arc->height, arc->x, arc->y, arc->angle1, arc->angle2)); @@ -1013,6 +1024,7 @@ s3FillPoly1Rect (DrawablePtr pDrawable, GCPtr pGC, int shape, return; } + s3SetGlobalBitmap (pDrawable->pScreen, s3GCMap (pGC)); fbPriv = fbGetGCPrivate(pGC); sy = pDrawable->y; sx = pDrawable->x; @@ -1258,6 +1270,7 @@ s3PolyGlyphBltClipped (DrawablePtr pDrawable, Bool set; PixTransDeclare; + s3SetGlobalBitmap (pDrawable->pScreen, s3GCMap (pGC)); x += pDrawable->x; y += pDrawable->y; @@ -1408,6 +1421,7 @@ s3PolyGlyphBlt (DrawablePtr pDrawable, unsigned char alu; PixTransDeclare; + s3SetGlobalBitmap (pDrawable->pScreen, s3GCMap (pGC)); x += pDrawable->x; y += pDrawable->y; @@ -1549,6 +1563,7 @@ s3ImageTEGlyphBlt (DrawablePtr pDrawable, GCPtr pGC, CARD32 tmp; PixTransDeclare; + s3SetGlobalBitmap (pDrawable->pScreen, s3GCMap (pGC)); widthGlyph = FONTMAXBOUNDS(pfont,characterWidth); if (!widthGlyph) return; @@ -1701,6 +1716,7 @@ _s3Segment (DrawablePtr pDrawable, unsigned int oc1; /* outcode of point 1 */ unsigned int oc2; /* outcode of point 2 */ + s3SetGlobalBitmap (pDrawable->pScreen, s3GCMap (pGC)); nBox = REGION_NUM_RECTS (pClip); pBox = REGION_RECTS (pClip); CalcLineDeltas(x1, y1, x2, y2, adx, ady, signdx, signdy, @@ -1875,6 +1891,7 @@ s3PolySegment (DrawablePtr pDrawable, GCPtr pGC, Bool s3AllocPattern (ScreenPtr pScreen, + int ma, PixmapPtr pPixmap, int xorg, int yorg, int fillStyle, Pixel fg, Pixel bg, @@ -1884,7 +1901,7 @@ s3AllocPattern (ScreenPtr pScreen, s3ScreenInfo(pScreenPriv); s3PatternPtr pPattern; - if (s3s->patterns.cache && fillStyle != FillSolid && + if (s3s->fb[ma].patterns.cache && fillStyle != FillSolid && s3CheckPattern (pPixmap->drawable.width, pPixmap->drawable.height)) { if (!(pPattern = *ppPattern)) @@ -1935,6 +1952,7 @@ s3CheckGCFill (GCPtr pGC) break; } s3AllocPattern (pGC->pScreen, + s3GCMap(pGC), pPixmap, pGC->patOrg.x + pGC->lastWinOrg.x, pGC->patOrg.y + pGC->lastWinOrg.y, @@ -2005,27 +2023,33 @@ s3FetchPatternPixel (s3PatternPtr pPattern, int x, int y) * Place pattern image on screen; done with S3 locked */ void -_s3PutPattern (ScreenPtr pScreen, s3PatternPtr pPattern) +_s3PutPattern (ScreenPtr pScreen, int ma, s3PatternPtr pPattern) { SetupS3(pScreen); + s3ScreenInfo(pScreenPriv); int x, y; CARD8 *dstLine, *dst8; CARD16 *dst16; CARD32 *dst32; S3PatternCache *cache = pPattern->cache; +#ifdef S3_TRIO + int fb = 0; +#else + int fb = s3s->fbmap[ma]; +#endif DRAW_DEBUG ((DEBUG_PATTERN, "_s3PutPattern 0x%x id %d to %d %d", pPattern, pPattern->id, cache->x, cache->y)); - dstLine = (pScreenPriv->screen->frameBuffer + - cache->y * pScreenPriv->screen->byteStride + - cache->x * pScreenPriv->bytesPerPixel); + dstLine = (pScreenPriv->screen->fb[fb].frameBuffer + + cache->y * pScreenPriv->screen->fb[fb].byteStride + + cache->x * pScreenPriv->bytesPerPixel[fb]); CheckSyncS3 (pScreen); for (y = 0; y < S3_TILE_SIZE; y++) { - switch (pScreenPriv->screen->bitsPerPixel) { + switch (pScreenPriv->screen->fb[fb].bitsPerPixel) { case 8: dst8 = dstLine; for (x = 0; x < S3_TILE_SIZE; x++) @@ -2051,7 +2075,7 @@ _s3PutPattern (ScreenPtr pScreen, s3PatternPtr pPattern) *dst32++ = s3FetchPatternPixel (pPattern, x, y); break; } - dstLine += pScreenPriv->screen->byteStride; + dstLine += pScreenPriv->screen->fb[fb].byteStride; } } @@ -2059,7 +2083,7 @@ _s3PutPattern (ScreenPtr pScreen, s3PatternPtr pPattern) * Load a stipple to off-screen memory; done with S3 locked */ void -_s3LoadPattern (ScreenPtr pScreen, s3PatternPtr pPattern) +_s3LoadPattern (ScreenPtr pScreen, int ma, s3PatternPtr pPattern) { SetupS3(pScreen); s3ScreenInfo(pScreenPriv); @@ -2078,13 +2102,13 @@ _s3LoadPattern (ScreenPtr pScreen, s3PatternPtr pPattern) /* * Lame replacement strategy; assume we'll have plenty of room. */ - cache = &s3s->patterns.cache[s3s->patterns.last_used]; - if (++s3s->patterns.last_used == s3s->patterns.ncache) - s3s->patterns.last_used = 0; - cache->id = ++s3s->patterns.last_id; + cache = &s3s->fb[ma].patterns.cache[s3s->fb[ma].patterns.last_used]; + if (++s3s->fb[ma].patterns.last_used == s3s->fb[ma].patterns.ncache) + s3s->fb[ma].patterns.last_used = 0; + cache->id = ++s3s->fb[ma].patterns.last_id; pPattern->id = cache->id; pPattern->cache = cache; - _s3PutPattern (pScreen, pPattern); + _s3PutPattern (pScreen, ma, pPattern); } void @@ -2110,6 +2134,8 @@ GCFuncs s3GCFuncs = { int s3CreateGC (GCPtr pGC) { + KdScreenPriv(pGC->pScreen); + s3ScreenInfo(pScreenPriv); s3PrivGCPtr s3Priv; if (!fbCreateGC (pGC)) @@ -2121,17 +2147,30 @@ s3CreateGC (GCPtr pGC) s3Priv = s3GetGCPrivate(pGC); s3Priv->type = DRAWABLE_PIXMAP; s3Priv->pPattern = 0; - +#ifndef S3_TRIO + if (pGC->depth == s3s->primary_depth) + s3Priv->ma = 0; + else + s3Priv->ma = 1; +#endif return TRUE; } Bool s3CreateWindow (WindowPtr pWin) { + KdScreenPriv(pWin->drawable.pScreen); + s3ScreenInfo(pScreenPriv); + if (!KdCreateWindow (pWin)) return FALSE; pWin->devPrivates[s3WindowPrivateIndex].ptr = 0; - return TRUE; +#ifndef S3_TRIO + if (pWin->drawable.depth != s3s->primary_depth) + return fbOverlayCreateWindow (pWin); + else +#endif + return fbCreateWindow (pWin); } Bool @@ -2146,6 +2185,7 @@ s3DestroyWindow (WindowPtr pWin) Bool s3ChangeWindowAttributes (WindowPtr pWin, Mask mask) { + KdScreenPriv(pWin->drawable.pScreen); Bool ret; s3PatternPtr pPattern; PixmapPtr pPixmap; @@ -2165,7 +2205,9 @@ s3ChangeWindowAttributes (WindowPtr pWin, Mask mask) fillStyle = FillSolid; } pPattern = s3GetWindowPrivate(pWin); - s3AllocPattern (pWin->drawable.pScreen, pPixmap, + s3AllocPattern (pWin->drawable.pScreen, + s3DrawMap (&pWin->drawable), + pPixmap, pWin->drawable.x, pWin->drawable.y, fillStyle, 0, 0, &pPattern); DRAW_DEBUG ((DEBUG_PAINT_WINDOW, "Background pattern 0x%x pixmap 0x%x style %d", @@ -2175,6 +2217,30 @@ s3ChangeWindowAttributes (WindowPtr pWin, Mask mask) return ret; } +#ifndef S3_TRIO +void +s3PaintChromaKey (WindowPtr pWin, RegionPtr pRegion) +{ + SetupS3 (pWin->drawable.pScreen); + s3ScreenInfo (pScreenPriv); + + if (pWin->drawable.depth != s3s->primary_depth) + { + int nBox = REGION_NUM_RECTS(pRegion); + BoxPtr pBox = REGION_RECTS(pRegion); + + s3SetGlobalBitmap (pWin->drawable.pScreen, 0); + _s3SetSolidFill(s3,0xffffffff,GXcopy,0xffffffff); + while (nBox--) + { + _s3SolidRect(s3,pBox->x1,pBox->y1,pBox->x2-pBox->x1,pBox->y2-pBox->y1); + pBox++; + } + MarkSyncS3 (pWin->drawable.pScreen); + } +} +#endif + void s3PaintWindow(WindowPtr pWin, RegionPtr pRegion, int what) { @@ -2188,6 +2254,9 @@ s3PaintWindow(WindowPtr pWin, RegionPtr pRegion, int what) REGION_NUM_RECTS(pRegion))); if (!REGION_NUM_RECTS(pRegion)) return; +#ifndef S3_TRIO + s3PaintChromaKey (pWin, pRegion); +#endif switch (what) { case PW_BACKGROUND: switch (pWin->backgroundState) { @@ -2234,11 +2303,24 @@ s3PaintWindow(WindowPtr pWin, RegionPtr pRegion, int what) } void +s3RestoreAreas(PixmapPtr pPixmap, + RegionPtr prgnRestore, + int xorg, + int yorg, + WindowPtr pWin) +{ +#ifndef S3_TRIO + s3PaintChromaKey (pWin, prgnRestore); +#endif + KdCheckRestoreAreas (pPixmap, prgnRestore, xorg, yorg, pWin); +} + +void s3CopyWindowProc (DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable, GCPtr pGC, - BoxPtr pbox, - int nbox, + BoxPtr pboxOrig, + int nboxOrig, int dx, int dy, Bool reverse, @@ -2247,23 +2329,248 @@ s3CopyWindowProc (DrawablePtr pSrcDrawable, void *closure) { SetupS3(pDstDrawable->pScreen); + s3ScreenInfo(pScreenPriv); + int srcX, srcY, dstX, dstY; + int x1, x2; + int w, h; + int flags; + int ma; + BoxPtr pbox; + int nbox; + + if (pSrcDrawable->bitsPerPixel == 24) + dx *= 3; +#ifdef S3_TRIO + ma = 0; +#else + for (ma = 0; s3s->fbmap[ma] >= 0; ma++) +#endif + { + nbox = nboxOrig; + pbox = pboxOrig; + s3SetGlobalBitmap (pDstDrawable->pScreen, ma); + _s3SetBlt(s3,GXcopy,~0); + while (nbox--) + { + x1 = pbox->x1; + x2 = pbox->x2; + if (pSrcDrawable->bitsPerPixel == 24) + { + x1 *= 3; + x2 *= 3; + } + + w = x2 - x1; + h = pbox->y2 - pbox->y1; + flags = 0; + if (reverse) + { + dstX = x2 - 1; + } + else + { + dstX = x1; + flags |= INC_X; + } + srcX = dstX + dx; + + if (upsidedown) + { + dstY = pbox->y2 - 1; + } + else + { + dstY = pbox->y1; + flags |= INC_Y; + } + srcY = dstY + dy; + + _s3Blt (s3, srcX, srcY, dstX, dstY, w, h, flags); + pbox++; + } + MarkSyncS3 (pDstDrawable->pScreen); + } +} + +void +s3CopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc) +{ + ScreenPtr pScreen = pWin->drawable.pScreen; + KdScreenPriv(pScreen); + RegionRec rgnDst; + int dx, dy; + WindowPtr pwinRoot; + + pwinRoot = WindowTable[pWin->drawable.pScreen->myNum]; + + dx = ptOldOrg.x - pWin->drawable.x; + dy = ptOldOrg.y - pWin->drawable.y; + REGION_TRANSLATE(pWin->drawable.pScreen, prgnSrc, -dx, -dy); + + REGION_INIT (pWin->drawable.pScreen, &rgnDst, NullBox, 0); + + REGION_INTERSECT(pWin->drawable.pScreen, &rgnDst, &pWin->borderClip, prgnSrc); + + fbCopyRegion ((DrawablePtr)pwinRoot, (DrawablePtr)pwinRoot, + 0, + &rgnDst, dx, dy, s3CopyWindowProc, 0, 0); + + REGION_UNINIT(pWin->drawable.pScreen, &rgnDst); +} + +void +s3_24FillBoxSolid (DrawablePtr pDrawable, int nBox, BoxPtr pBox, + unsigned long pixel, int alu, unsigned long planemask) +{ + SetupS3(pDrawable->pScreen); + register int r; + int x1, x2; + + s3SetGlobalBitmap (pDrawable->pScreen, s3DrawMap (pDrawable)); + _s3SetSolidFill(s3,pixel,alu,planemask); + + while (nBox--) { + x1 = pBox->x1 * 3; + x2 = pBox->x2 * 3; + _s3SolidRect(s3,x1,pBox->y1,x2-x1,pBox->y2-pBox->y1); + pBox++; + } + MarkSyncS3 (pDrawable->pScreen); +} + +#define ok24(p) (((p) & 0xffffff) == ((((p) & 0xff) << 16) | (((p) >> 8) & 0xffff))) + +void +s3_24FillSpans (DrawablePtr pDrawable, GCPtr pGC, int n, + DDXPointPtr ppt, int *pwidth, int fSorted) +{ + SetupS3(pDrawable->pScreen); + int x, y, x1, y1, x2, y2; + int width; + /* next three parameters are post-clip */ + int nTmp; + int *pwidthFree;/* copies of the pointers to free */ + DDXPointPtr pptFree; + FbGCPrivPtr fbPriv = fbGetGCPrivate(pGC); + BoxPtr extents; + RegionPtr pClip = fbGetCompositeClip (pGC); + + if (pGC->fillStyle != FillSolid || !ok24 (pGC->fgPixel) || !ok24(pGC->planemask)) + { + KdCheckFillSpans (pDrawable, pGC, n, ppt, pwidth, fSorted); + return; + } + + s3SetGlobalBitmap (pDrawable->pScreen, s3GCMap (pGC)); + if (REGION_NUM_RECTS(pClip) == 1) + { + extents = REGION_RECTS(pClip); + x1 = extents->x1; + x2 = extents->x2; + y1 = extents->y1; + y2 = extents->y2; + _s3SetSolidFill(s3,pGC->fgPixel,pGC->alu,pGC->planemask); + while (n--) + { + y = ppt->y; + if (y1 <= y && y < y2) + { + x = ppt->x; + width = *pwidth; + if (x < x1) + { + width -= (x1 - x); + x = x1; + } + if (x2 < x + width) + width = x2 - x; + if (width > 0) + { + _s3SolidRect(s3,x*3,y,width*3,1); + } + } + ppt++; + pwidth++; + } + } + else + { + nTmp = n * miFindMaxBand(pClip); + pwidthFree = (int *)ALLOCATE_LOCAL(nTmp * sizeof(int)); + pptFree = (DDXPointRec *)ALLOCATE_LOCAL(nTmp * sizeof(DDXPointRec)); + if(!pptFree || !pwidthFree) + { + if (pptFree) DEALLOCATE_LOCAL(pptFree); + if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree); + return; + } + n = miClipSpans(fbGetCompositeClip(pGC), + ppt, pwidth, n, + pptFree, pwidthFree, fSorted); + pwidth = pwidthFree; + ppt = pptFree; + _s3SetSolidFill(s3,pGC->fgPixel,pGC->alu,pGC->planemask); + while (n--) + { + x = ppt->x; + y = ppt->y; + ppt++; + width = *pwidth++; + if (width) + { + _s3SolidRect(s3,x*3,y,width*3,1); + } + } + DEALLOCATE_LOCAL(pptFree); + DEALLOCATE_LOCAL(pwidthFree); + } + MarkSyncS3 (pDrawable->pScreen); +} + +void +s3_24CopyNtoN (DrawablePtr pSrcDrawable, + DrawablePtr pDstDrawable, + GCPtr pGC, + BoxPtr pbox, + int nbox, + int dx, + int dy, + Bool reverse, + Bool upsidedown, + Pixel bitplane, + void *closure) +{ + SetupS3(pDstDrawable->pScreen); int srcX, srcY, dstX, dstY; int w, h; int flags; + int x1, x2; + + if (sourceInvarient (pGC->alu)) + { + s3_24FillBoxSolid (pDstDrawable, nbox, pbox, 0, pGC->alu, pGC->planemask); + return; + } - _s3SetBlt(s3,GXcopy,~0); + s3SetGlobalBitmap (pDstDrawable->pScreen, s3GCMap (pGC)); + _s3SetBlt(s3,pGC->alu,pGC->planemask); + DRAW_DEBUG ((DEBUG_RENDER, "s3CopyNtoN alu %d planemask 0x%x", + pGC->alu, pGC->planemask)); + dx *= 3; while (nbox--) { - w = pbox->x2 - pbox->x1; + x1 = pbox->x1 * 3; + x2 = pbox->x2 * 3; + w = x2 - x1; h = pbox->y2 - pbox->y1; flags = 0; if (reverse) { - dstX = pbox->x2 - 1; + dstX = x2 - 1; } else { - dstX = pbox->x1; + dstX = x1; flags |= INC_X; } srcX = dstX + dx; @@ -2282,33 +2589,456 @@ s3CopyWindowProc (DrawablePtr pSrcDrawable, _s3Blt (s3, srcX, srcY, dstX, dstY, w, h, flags); pbox++; } - MarkSyncS3 (pDstDrawable->pScreen); + MarkSyncS3 (pSrcDrawable->pScreen); } -void -s3CopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc) +RegionPtr +s3_24CopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable, GCPtr pGC, + int srcx, int srcy, int width, int height, int dstx, int dsty) { - ScreenPtr pScreen = pWin->drawable.pScreen; - KdScreenPriv(pScreen); - RegionRec rgnDst; - int dx, dy; - WindowPtr pwinRoot; + SetupS3(pDstDrawable->pScreen); + + if (pSrcDrawable->type == DRAWABLE_WINDOW && + pDstDrawable->type == DRAWABLE_WINDOW && + ok24(pGC->planemask)) + { + return fbDoCopy (pSrcDrawable, pDstDrawable, pGC, + srcx, srcy, width, height, + dstx, dsty, s3_24CopyNtoN, 0, 0); + } + return KdCheckCopyArea (pSrcDrawable, pDstDrawable, pGC, + srcx, srcy, width, height, dstx, dsty); +} - pwinRoot = WindowTable[pWin->drawable.pScreen->myNum]; - dx = ptOldOrg.x - pWin->drawable.x; - dy = ptOldOrg.y - pWin->drawable.y; - REGION_TRANSLATE(pWin->drawable.pScreen, prgnSrc, -dx, -dy); +#define NUM_STACK_RECTS 1024 - REGION_INIT (pWin->drawable.pScreen, &rgnDst, NullBox, 0); +void +s3_24PolyFillRect (DrawablePtr pDrawable, GCPtr pGC, + int nrectFill, xRectangle *prectInit) +{ + s3GCPrivate(pGC); + xRectangle *prect; + RegionPtr prgnClip; + register BoxPtr pbox; + register BoxPtr pboxClipped; + BoxPtr pboxClippedBase; + BoxPtr pextent; + BoxRec stackRects[NUM_STACK_RECTS]; + FbGCPrivPtr fbPriv = fbGetGCPrivate (pGC); + int numRects; + int n; + int xorg, yorg; + int x, y; + + if (pGC->fillStyle != FillSolid || !ok24 (pGC->fgPixel) || !ok24(pGC->planemask)) + { + KdCheckPolyFillRect (pDrawable, pGC, nrectFill, prectInit); + return; + } - REGION_INTERSECT(pWin->drawable.pScreen, &rgnDst, &pWin->borderClip, prgnSrc); + prgnClip = fbGetCompositeClip(pGC); + xorg = pDrawable->x; + yorg = pDrawable->y; + + if (xorg || yorg) + { + prect = prectInit; + n = nrectFill; + while(n--) + { + prect->x += xorg; + prect->y += yorg; + prect++; + } + } + + prect = prectInit; - fbCopyRegion ((DrawablePtr)pwinRoot, (DrawablePtr)pwinRoot, - 0, - &rgnDst, dx, dy, s3CopyWindowProc, 0, 0); + numRects = REGION_NUM_RECTS(prgnClip) * nrectFill; + if (numRects > NUM_STACK_RECTS) + { + pboxClippedBase = (BoxPtr)ALLOCATE_LOCAL(numRects * sizeof(BoxRec)); + if (!pboxClippedBase) + return; + } + else + pboxClippedBase = stackRects; + + pboxClipped = pboxClippedBase; + + if (REGION_NUM_RECTS(prgnClip) == 1) + { + int x1, y1, x2, y2, bx2, by2; + + pextent = REGION_RECTS(prgnClip); + x1 = pextent->x1; + y1 = pextent->y1; + x2 = pextent->x2; + y2 = pextent->y2; + while (nrectFill--) + { + if ((pboxClipped->x1 = prect->x) < x1) + pboxClipped->x1 = x1; - REGION_UNINIT(pWin->drawable.pScreen, &rgnDst); + if ((pboxClipped->y1 = prect->y) < y1) + pboxClipped->y1 = y1; + + bx2 = (int) prect->x + (int) prect->width; + if (bx2 > x2) + bx2 = x2; + pboxClipped->x2 = bx2; + + by2 = (int) prect->y + (int) prect->height; + if (by2 > y2) + by2 = y2; + pboxClipped->y2 = by2; + + prect++; + if ((pboxClipped->x1 < pboxClipped->x2) && + (pboxClipped->y1 < pboxClipped->y2)) + { + pboxClipped++; + } + } + } + else + { + int x1, y1, x2, y2, bx2, by2; + + pextent = REGION_EXTENTS(pGC->pScreen, prgnClip); + x1 = pextent->x1; + y1 = pextent->y1; + x2 = pextent->x2; + y2 = pextent->y2; + while (nrectFill--) + { + BoxRec box; + + if ((box.x1 = prect->x) < x1) + box.x1 = x1; + + if ((box.y1 = prect->y) < y1) + box.y1 = y1; + + bx2 = (int) prect->x + (int) prect->width; + if (bx2 > x2) + bx2 = x2; + box.x2 = bx2; + + by2 = (int) prect->y + (int) prect->height; + if (by2 > y2) + by2 = y2; + box.y2 = by2; + + prect++; + + if ((box.x1 >= box.x2) || (box.y1 >= box.y2)) + continue; + + n = REGION_NUM_RECTS (prgnClip); + pbox = REGION_RECTS(prgnClip); + + /* clip the rectangle to each box in the clip region + this is logically equivalent to calling Intersect() + */ + while(n--) + { + pboxClipped->x1 = max(box.x1, pbox->x1); + pboxClipped->y1 = max(box.y1, pbox->y1); + pboxClipped->x2 = min(box.x2, pbox->x2); + pboxClipped->y2 = min(box.y2, pbox->y2); + pbox++; + + /* see if clipping left anything */ + if(pboxClipped->x1 < pboxClipped->x2 && + pboxClipped->y1 < pboxClipped->y2) + { + pboxClipped++; + } + } + } + } + if (pboxClipped != pboxClippedBase) + { + s3_24FillBoxSolid(pDrawable, + pboxClipped-pboxClippedBase, pboxClippedBase, + pGC->fgPixel, pGC->alu, pGC->planemask); + } + if (pboxClippedBase != stackRects) + DEALLOCATE_LOCAL(pboxClippedBase); +} + +void +s3_24SolidBoxClipped (DrawablePtr pDrawable, + RegionPtr pClip, + int x1, + int y1, + int x2, + int y2, + FbBits fg) +{ + SetupS3 (pDrawable->pScreen); + BoxPtr pbox; + int nbox; + int partX1, partX2, partY1, partY2; + + s3SetGlobalBitmap (pDrawable->pScreen, s3DrawMap (pDrawable)); + _s3SetSolidFill(s3,fg,GXcopy,~0); + + for (nbox = REGION_NUM_RECTS(pClip), pbox = REGION_RECTS(pClip); + nbox--; + pbox++) + { + partX1 = pbox->x1; + if (partX1 < x1) + partX1 = x1; + + partX2 = pbox->x2; + if (partX2 > x2) + partX2 = x2; + + if (partX2 <= partX1) + continue; + + partY1 = pbox->y1; + if (partY1 < y1) + partY1 = y1; + + partY2 = pbox->y2; + if (partY2 > y2) + partY2 = y2; + + if (partY2 <= partY1) + continue; + + partX1 *= 3; + partX2 *= 3; + _s3SolidRect(s3,partX1, partY1, partX2-partX1, partY2-partY1); + } + MarkSyncS3(pDrawable->pScreen); +} + +void +s3_24ImageGlyphBlt (DrawablePtr pDrawable, + GCPtr pGC, + int x, + int y, + unsigned int nglyph, + CharInfoPtr *ppciInit, + pointer pglyphBase) +{ + FbGCPrivPtr pPriv = fbGetGCPrivate(pGC); + CharInfoPtr *ppci; + CharInfoPtr pci; + unsigned char *pglyph; /* pointer bits in glyph */ + int gWidth, gHeight; /* width and height of glyph */ + FbStride gStride; /* stride of glyph */ + Bool opaque; + int n; + int gx, gy; + FbBits *dst; + FbStride dstStride; + int dstBpp; + FbBits depthMask; + int xBack, widthBack; + int yBack, heightBack; + + depthMask = FbFullMask(pDrawable->depth); + if (!ok24 (pGC->fgPixel) || + !ok24(pGC->bgPixel) || + !ok24(pGC->planemask)) + { + KdCheckImageGlyphBlt(pDrawable, pGC, x, y, nglyph, ppciInit, pglyphBase); + return; + } + fbGetDrawable (pDrawable, dst, dstStride, dstBpp); + + x += pDrawable->x; + y += pDrawable->y; + + ppci = ppciInit; + n = nglyph; + widthBack = 0; + while (n--) + widthBack += (*ppci++)->metrics.characterWidth; + + xBack = x; + if (widthBack < 0) + { + xBack += widthBack; + widthBack = -widthBack; + } + yBack = y - FONTASCENT(pGC->font); + heightBack = FONTASCENT(pGC->font) + FONTDESCENT(pGC->font); + s3_24SolidBoxClipped (pDrawable, + fbGetCompositeClip(pGC), + xBack, + yBack, + xBack + widthBack, + yBack + heightBack, + pPriv->bg); + + KdCheckSync (pDrawable->pScreen); + + ppci = ppciInit; + while (nglyph--) + { + pci = *ppci++; + pglyph = FONTGLYPHBITS(pglyphBase, pci); + gWidth = GLYPHWIDTHPIXELS(pci); + gHeight = GLYPHHEIGHTPIXELS(pci); + if (gWidth && gHeight) + { + gx = x + pci->metrics.leftSideBearing; + gy = y - pci->metrics.ascent; + if (gWidth <= sizeof (FbStip) * 8 && + fbGlyphIn (fbGetCompositeClip(pGC), gx, gy, gWidth, gHeight)) + { + fbGlyph24 (dst + gy * dstStride, + dstStride, + dstBpp, + (FbStip *) pglyph, + pPriv->fg, + gx, + gHeight); + } + else + { + gStride = GLYPHWIDTHBYTESPADDED(pci) / sizeof (FbStip); + fbPutXYImage (pDrawable, + fbGetCompositeClip(pGC), + pPriv->fg, + pPriv->bg, + pPriv->pm, + GXcopy, + FALSE, + + gx, + gy, + gWidth, gHeight, + + (FbStip *) pglyph, + gStride, + 0); + } + } + x += pci->metrics.characterWidth; + } +} + +static const GCOps s3_24GCOps = { + s3_24FillSpans, + KdCheckSetSpans, + KdCheckPutImage, + KdCheckCopyArea, + KdCheckCopyPlane, + KdCheckPolyPoint, + KdCheckPolylines, + KdCheckPolySegment, + KdCheckPolyRectangle, + KdCheckPolyArc, + KdCheckFillPolygon, + s3_24PolyFillRect, + KdCheckPolyFillArc, + miPolyText8, + miPolyText16, + miImageText8, + miImageText16, + s3_24ImageGlyphBlt, + KdCheckPolyGlyphBlt, + KdCheckPushPixels, +#ifdef NEED_LINEHELPER + ,NULL +#endif +}; + +void +s3_24ValidateGC (GCPtr pGC, Mask changes, DrawablePtr pDrawable) +{ + if (pDrawable->type != DRAWABLE_WINDOW) + pGC->ops = (GCOps *) &kdAsyncPixmapGCOps; + else + pGC->ops = (GCOps *) &s3_24GCOps; + fbValidateGC (pGC, changes, pDrawable); +} + +GCFuncs s3_24GCFuncs = { + s3_24ValidateGC, + miChangeGC, + miCopyGC, + miDestroyGC, + miChangeClip, + miDestroyClip, + miCopyClip +}; + +Bool +s3_24CreateGC (GCPtr pGC) +{ + if (!fbCreateGC (pGC)) + return FALSE; + + if (pGC->depth != 1) + pGC->funcs = &s3_24GCFuncs; + + return TRUE; +} + +Bool +s3_24CreateWindow(WindowPtr pWin) +{ + return fbCreateWindow (pWin); +} + +void +s3_24PaintWindow(WindowPtr pWin, RegionPtr pRegion, int what) +{ + SetupS3(pWin->drawable.pScreen); + s3PatternPtr pPattern; + + DRAW_DEBUG ((DEBUG_PAINT_WINDOW, "s3PaintWindow 0x%x extents %d %d %d %d n %d", + pWin->drawable.id, + pRegion->extents.x1, pRegion->extents.y1, + pRegion->extents.x2, pRegion->extents.y2, + REGION_NUM_RECTS(pRegion))); + if (!REGION_NUM_RECTS(pRegion)) + return; + switch (what) { + case PW_BACKGROUND: + switch (pWin->backgroundState) { + case None: + return; + case ParentRelative: + do { + pWin = pWin->parent; + } while (pWin->backgroundState == ParentRelative); + (*pWin->drawable.pScreen->PaintWindowBackground)(pWin, pRegion, + what); + return; + case BackgroundPixel: + if (ok24(pWin->background.pixel)) + { + s3_24FillBoxSolid((DrawablePtr)pWin, + (int)REGION_NUM_RECTS(pRegion), + REGION_RECTS(pRegion), + pWin->background.pixel, GXcopy, ~0); + return; + } + } + break; + case PW_BORDER: + if (pWin->borderIsPixel && ok24(pWin->border.pixel)) + { + s3_24FillBoxSolid((DrawablePtr)pWin, + (int)REGION_NUM_RECTS(pRegion), + REGION_RECTS(pRegion), + pWin->border.pixel, GXcopy, ~0); + return; + } + break; + } + KdCheckPaintWindow (pWin, pRegion, what); } Bool @@ -2319,25 +3049,20 @@ s3DrawInit (ScreenPtr pScreen) int ncache_w, ncache_h, ncache; int px, py; S3PatternCache *cache; + Bool dumb = FALSE; + int ma; - switch (pScreenPriv->screen->bitsPerPixel) { + switch (pScreenPriv->screen->fb[0].bitsPerPixel) { case 8: case 16: case 32: break; + case 24: + dumb = TRUE; + break; default: return FALSE; } - if (serverGeneration != s3Generation) - { - s3GCPrivateIndex = AllocateGCPrivateIndex (); - s3WindowPrivateIndex = AllocateWindowPrivateIndex (); - s3Generation = serverGeneration; - } - if (!AllocateWindowPrivate(pScreen, s3WindowPrivateIndex, 0)) - return FALSE; - if (!AllocateGCPrivate(pScreen, s3GCPrivateIndex, sizeof (s3PrivGCRec))) - return FALSE; /* * Hook up asynchronous drawing */ @@ -2345,38 +3070,75 @@ s3DrawInit (ScreenPtr pScreen) /* * Replace various fb screen functions */ - pScreen->CreateGC = s3CreateGC; - pScreen->CreateWindow = s3CreateWindow; - pScreen->ChangeWindowAttributes = s3ChangeWindowAttributes; - pScreen->DestroyWindow = s3DestroyWindow; - pScreen->PaintWindowBackground = s3PaintWindow; - pScreen->PaintWindowBorder = s3PaintWindow; - pScreen->CopyWindow = s3CopyWindow; - - /* - * Initialize patterns - */ - ncache_w = s3s->offscreen_width / S3_TILE_SIZE; - ncache_h = s3s->offscreen_height / S3_TILE_SIZE; - ncache = ncache_w * ncache_h; - DRAW_DEBUG ((DEBUG_S3INIT, "ncache_w %d ncache_h %d ncache %d", - ncache_w, ncache_h, ncache)); - s3s->patterns.cache = (S3PatternCache *) xalloc (ncache * sizeof (S3PatternCache)); - if (s3s->patterns.cache) - { - DRAW_DEBUG ((DEBUG_S3INIT, "Have pattern cache")); - s3s->patterns.ncache = ncache; - s3s->patterns.last_used = 0; - s3s->patterns.last_id = 0; - cache = s3s->patterns.cache; - for (py = 0; py < ncache_h; py++) - for (px = 0; px < ncache_w; px++) + if (dumb) + { + pScreen->CreateGC = s3_24CreateGC; + pScreen->CreateWindow = s3_24CreateWindow; + pScreen->PaintWindowBackground = s3_24PaintWindow; + pScreen->PaintWindowBorder = s3_24PaintWindow; + pScreen->CopyWindow = s3CopyWindow; + } + else + { + if (serverGeneration != s3Generation) + { + s3GCPrivateIndex = AllocateGCPrivateIndex (); + s3WindowPrivateIndex = AllocateWindowPrivateIndex (); + s3Generation = serverGeneration; + } + if (!AllocateWindowPrivate(pScreen, s3WindowPrivateIndex, 0)) + return FALSE; + if (!AllocateGCPrivate(pScreen, s3GCPrivateIndex, sizeof (s3PrivGCRec))) + return FALSE; + pScreen->CreateGC = s3CreateGC; + pScreen->CreateWindow = s3CreateWindow; + pScreen->ChangeWindowAttributes = s3ChangeWindowAttributes; + pScreen->DestroyWindow = s3DestroyWindow; + pScreen->PaintWindowBackground = s3PaintWindow; + pScreen->PaintWindowBorder = s3PaintWindow; + pScreen->CopyWindow = s3CopyWindow; + pScreen->BackingStoreFuncs.RestoreAreas = s3RestoreAreas; +#if 0 + pScreen->PaintWindowBackground = s3DumbPaintWindow; + pScreen->PaintWindowBorder = s3DumbPaintWindow; + pScreen->CopyWindow = s3DumbCopyWindow; +#endif + + /* + * Initialize patterns + */ +#ifdef S3_TRIO + ma = 0; +#else + for (ma = 0; s3s->fbmap[ma] >= 0; ma++) +#endif + { + ncache_w = s3s->fb[ma].offscreen_width / S3_TILE_SIZE; + ncache_h = s3s->fb[ma].offscreen_height / S3_TILE_SIZE; + ncache = ncache_w * ncache_h; + if (ncache > 64) + ncache = 64; + DRAW_DEBUG ((DEBUG_S3INIT, "ncache_w %d ncache_h %d ncache %d", + ncache_w, ncache_h, ncache)); + s3s->fb[ma].patterns.cache = (S3PatternCache *) xalloc (ncache * sizeof (S3PatternCache)); + if (s3s->fb[ma].patterns.cache) { - cache->id = 0; - cache->x = s3s->offscreen_x + px * S3_TILE_SIZE; - cache->y = s3s->offscreen_y + py * S3_TILE_SIZE; - cache++; + DRAW_DEBUG ((DEBUG_S3INIT, "Have pattern cache")); + s3s->fb[ma].patterns.ncache = ncache; + s3s->fb[ma].patterns.last_used = 0; + s3s->fb[ma].patterns.last_id = 0; + cache = s3s->fb[ma].patterns.cache; + for (py = 0; py < ncache_h && ncache; py++) + for (px = 0; px < ncache_w && ncache; px++) + { + cache->id = 0; + cache->x = s3s->fb[ma].offscreen_x + px * S3_TILE_SIZE; + cache->y = s3s->fb[ma].offscreen_y + py * S3_TILE_SIZE; + cache++; + ncache--; + } } + } } return TRUE; } @@ -2387,18 +3149,37 @@ s3DrawEnable (ScreenPtr pScreen) SetupS3(pScreen); s3ScreenInfo(pScreenPriv); int c; + int ma; - /* - * Flush pattern cache - */ - for (c = 0; c < s3s->patterns.ncache; c++) - s3s->patterns.cache[c].id = 0; - + s3SetGlobalBitmap (pScreen, 0); _s3WaitIdleEmpty (s3); - _s3SetScissorsTl(s3, 0, 0); - _s3SetScissorsBr(s3, pScreenPriv->screen->width - 1, pScreenPriv->screen->height - 1); - _s3SetSolidFill(s3, pScreen->blackPixel, GXcopy, ~0); - _s3SolidRect (s3, 0, 0, pScreenPriv->screen->width, pScreenPriv->screen->height); + if (pScreenPriv->screen->fb[0].bitsPerPixel == 24) + { + _s3SetScissorsTl(s3, 0, 0); + _s3SetScissorsBr(s3, pScreenPriv->screen->width*3 - 1, pScreenPriv->screen->height - 1); + _s3SetSolidFill(s3, pScreen->whitePixel, GXcopy, ~0); + _s3SolidRect (s3, 0, 0, pScreenPriv->screen->width*3, pScreenPriv->screen->height); + } + else + { + /* + * Flush pattern cache + */ +#ifdef S3_TRIO + ma = 0; +#else + for (ma = 0; s3s->fbmap[ma] >= 0; ma++) +#endif + { + for (c = 0; c < s3s->fb[ma].patterns.ncache; c++) + s3s->fb[ma].patterns.cache[c].id = 0; + } + + _s3SetScissorsTl(s3, 0, 0); + _s3SetScissorsBr(s3, pScreenPriv->screen->width - 1, pScreenPriv->screen->height - 1); + _s3SetSolidFill(s3, pScreen->blackPixel, GXcopy, ~0); + _s3SolidRect (s3, 0, 0, pScreenPriv->screen->width, pScreenPriv->screen->height); + } MarkSyncS3 (pScreen); } @@ -2414,12 +3195,20 @@ s3DrawFini (ScreenPtr pScreen) { SetupS3(pScreen); s3ScreenInfo(pScreenPriv); + int ma; - if (s3s->patterns.cache) +#ifdef S3_TRIO + ma = 0; +#else + for (ma = 0; s3s->fbmap[ma] >= 0; ma++) +#endif { - xfree (s3s->patterns.cache); - s3s->patterns.cache = 0; - s3s->patterns.ncache = 0; + if (s3s->fb[ma].patterns.cache) + { + xfree (s3s->fb[ma].patterns.cache); + s3s->fb[ma].patterns.cache = 0; + s3s->fb[ma].patterns.ncache = 0; + } } } diff --git a/hw/kdrive/savage/s3draw.h b/hw/kdrive/savage/s3draw.h index f5b66e094..81bbad413 100644 --- a/hw/kdrive/savage/s3draw.h +++ b/hw/kdrive/savage/s3draw.h @@ -22,7 +22,7 @@ * * Author: Keith Packard, SuSE, Inc. */ -/* $XFree86: xc/programs/Xserver/hw/kdrive/savage/s3draw.h,v 1.2 1999/12/30 03:03:12 robin Exp $ */ +/* $XFree86: xc/programs/Xserver/hw/kdrive/savage/s3draw.h,v 1.3 2000/02/23 20:30:04 dawes Exp $ */ #ifndef _S3DRAW_H_ #define _S3DRAW_H_ @@ -41,6 +41,7 @@ typedef struct _s3Pattern { typedef struct _s3PrivGC { int type; /* type of drawable validated against */ + int ma; /* stream descriptor */ s3PatternPtr pPattern; /* pattern */ } s3PrivGCRec, *s3PrivGCPtr; @@ -55,8 +56,7 @@ typedef struct _s3PrivGC { #define s3SetWindowPrivate(w,p) (\ (w)->devPrivates[s3WindowPrivateIndex].ptr = (pointer) p) - -void _s3LoadPattern (ScreenPtr pScreen, s3PatternPtr pPattern); +void _s3LoadPattern (ScreenPtr pScreen, int fb, s3PatternPtr pPattern); #define SetupS3(s) KdScreenPriv(s); \ s3CardInfo(pScreenPriv); \ @@ -82,6 +82,18 @@ void _s3LoadPattern (ScreenPtr pScreen, s3PatternPtr pPattern); #define WIDEN(x) ((unsigned long) (x)) #define MERGE(a,b) ((WIDEN(a) << 16) | WIDEN(b)) +#define s3BitmapDescriptor(_stream) ((_stream) + 1) + +#ifdef S3_TRIO +#define s3DrawMap(pDraw) 0 +#define s3SetGlobalBitmap(s,d) +#else +#define s3DrawMap(pDraw) ((pDraw)->depth == \ + getS3ScreenInfo(pScreenPriv)->primary_depth ? 0 : 1) +#endif + +#define s3GCMap(pGC) (s3GetGCPrivate(pGC)->ma) + /* * Ok, so the S3 is broken -- it expects bitmaps to come MSB bit order, * but it's willing to take them in LSB byte order. These macros diff --git a/hw/kdrive/savage/s3reg.c b/hw/kdrive/savage/s3reg.c index 0fac18b12..b2cb7a377 100644 --- a/hw/kdrive/savage/s3reg.c +++ b/hw/kdrive/savage/s3reg.c @@ -22,7 +22,7 @@ * * Author: Keith Packard, SuSE, Inc. */ -/* $XFree86: xc/programs/Xserver/hw/kdrive/savage/s3reg.c,v 1.2 1999/12/30 03:03:12 robin Exp $ */ +/* $XFree86: xc/programs/Xserver/hw/kdrive/savage/s3reg.c,v 1.3 2000/02/23 20:30:04 dawes Exp $ */ #include "s3reg.h" @@ -403,6 +403,11 @@ VgaReg s3_line_compare[] = { VGA_REG_END }; +VgaReg s3_delay_primary_load[] = { + CR21, 1, 1, + VGA_REG_END +}; + VgaReg s3_device_id[] = { CR2E, 0, 8, CR2D, 0, 8, @@ -654,16 +659,36 @@ VgaReg s3_pci_disconnect_enable[] = { VGA_REG_END }; +VgaReg s3_primary_load_control[] = { + CR66, 4, 1, + VGA_REG_END +}; + +VgaReg s3_secondary_load_control[] = { + CR66, 5, 1, + VGA_REG_END +}; + VgaReg s3_pci_retry_enable[] = { CR66, 7, 1, VGA_REG_END }; +VgaReg s3_streams_mode[] = { + CR67, 2, 2, + VGA_REG_END +}; + VgaReg s3_color_mode[] = { CR67, 4, 4, VGA_REG_END }; +VgaReg s3_primary_stream_definition[] = { + CR69, 7, 1, + VGA_REG_END +}; + VgaReg s3_primary_stream_timeout[] = { CR71, 0, 8, VGA_REG_END @@ -714,6 +739,26 @@ VgaReg s3_dac_power_saving_disable[] = { VGA_REG_END }; +VgaReg s3_flat_panel_output_control_1[] = { + CR90, 3, 1, + VGA_REG_END +}; + +VgaReg s3_streams_fifo_delay[] = { + CR90, 4, 2, + VGA_REG_END +}; + +VgaReg s3_flat_panel_output_control_2[] = { + CR90, 6, 1, + VGA_REG_END +}; + +VgaReg s3_enable_l1_parameter[] = { + CR90, 7, 1, + VGA_REG_END +}; + VgaReg s3_primary_stream_l1[] = { CR91, 0, 8, CR90, 0, 3, @@ -975,6 +1020,21 @@ VgaReg s3_dclk_control[] = { VGA_REG_END }; +VgaReg s3_eclk_n[] = { + SR32, 0, 5, + VGA_REG_END +}; + +VgaReg s3_eclk_r[] = { + SR32, 5, 2, + VGA_REG_END +}; + +VgaReg s3_eclk_m[] = { + SR32, 0, 5, + VGA_REG_END +}; + VgaReg s3_vga_dclk_n[] = { SR36, 0, 6, SR39, 4, 1, diff --git a/hw/kdrive/savage/s3reg.h b/hw/kdrive/savage/s3reg.h index 88a4c3c07..aec76e8b3 100644 --- a/hw/kdrive/savage/s3reg.h +++ b/hw/kdrive/savage/s3reg.h @@ -22,7 +22,7 @@ * * Author: Keith Packard, SuSE, Inc. */ -/* $XFree86: xc/programs/Xserver/hw/kdrive/savage/s3reg.h,v 1.2 1999/12/30 03:03:12 robin Exp $ */ +/* $XFree86: xc/programs/Xserver/hw/kdrive/savage/s3reg.h,v 1.3 2000/02/23 20:30:05 dawes Exp $ */ #ifndef _S3REG_H_ #define _S3REG_H_ @@ -74,6 +74,7 @@ extern VgaReg s3_word_mode[]; extern VgaReg s3_byte_mode[]; extern VgaReg s3_hardware_reset[]; extern VgaReg s3_line_compare[]; +extern VgaReg s3_delay_primary_load[]; extern VgaReg s3_device_id[]; extern VgaReg s3_revision[]; extern VgaReg s3_enable_vga_16bit[]; @@ -123,8 +124,12 @@ extern VgaReg s3_delay_blank[]; extern VgaReg s3_delay_h_enable[]; extern VgaReg s3_enable_2d_3d[]; extern VgaReg s3_pci_disconnect_enable[]; +extern VgaReg s3_primary_load_control[]; +extern VgaReg s3_secondary_load_control[]; extern VgaReg s3_pci_retry_enable[]; +extern VgaReg s3_streams_mode[]; extern VgaReg s3_color_mode[]; +extern VgaReg s3_primary_stream_definition[]; extern VgaReg s3_primary_stream_timeout[]; extern VgaReg s3_master_control_unit_timeout[]; extern VgaReg s3_command_buffer_timeout[]; @@ -135,6 +140,10 @@ extern VgaReg s3_fifo_drain_delay[]; extern VgaReg s3_fifo_fetch_timing[]; extern VgaReg s3_dac_power_up_time[]; extern VgaReg s3_dac_power_saving_disable[]; +extern VgaReg s3_flat_panel_output_control_1[]; +extern VgaReg s3_streams_fifo_delay[]; +extern VgaReg s3_flat_panel_output_control_2[]; +extern VgaReg s3_enable_l1_parameter[]; extern VgaReg s3_primary_stream_l1[]; extern VgaReg s3_dot_clock_8[]; @@ -165,6 +174,9 @@ extern VgaReg s3_dclk_double_15_16_invert[]; extern VgaReg s3_enable_gamma_correction[]; extern VgaReg s3_enable_8_bit_luts[]; extern VgaReg s3_dclk_control[]; +extern VgaReg s3_eclk_n[]; +extern VgaReg s3_eclk_r[]; +extern VgaReg s3_eclk_m[]; extern VgaReg s3_vga_dclk_n[]; extern VgaReg s3_vga_dclk_r[]; extern VgaReg s3_vga_dclk_m1[]; diff --git a/hw/kdrive/sis530/sis.c b/hw/kdrive/sis530/sis.c index b889cc738..d0aa0a0bd 100644 --- a/hw/kdrive/sis530/sis.c +++ b/hw/kdrive/sis530/sis.c @@ -253,30 +253,30 @@ sisScreenInit (KdScreenInfo *screen) screen->height = 600; screen->rate = 72; } - if (!screen->depth) - screen->depth = 8; + if (!screen->fb[0].depth) + screen->fb[0].depth = 8; for (;;) { - if (screen->depth >= 24) + if (screen->fb[0].depth >= 24) { - screen->depth = 24; - screen->bitsPerPixel = 24; + screen->fb[0].depth = 24; + screen->fb[0].bitsPerPixel = 24; } - else if (screen->depth >= 16) + else if (screen->fb[0].depth >= 16) { - screen->depth = 16; - screen->bitsPerPixel = 16; + screen->fb[0].depth = 16; + screen->fb[0].bitsPerPixel = 16; } - else if (screen->depth >= 15) + else if (screen->fb[0].depth >= 15) { - screen->depth = 15; - screen->bitsPerPixel = 16; + screen->fb[0].depth = 15; + screen->fb[0].bitsPerPixel = 16; } else { - screen->depth = 8; - screen->bitsPerPixel = 8; + screen->fb[0].depth = 8; + screen->fb[0].bitsPerPixel = 8; } /* Normalize width to supported values */ @@ -294,10 +294,10 @@ sisScreenInit (KdScreenInfo *screen) else screen->width = 640; - byte_width = screen->width * (screen->bitsPerPixel >> 3); + byte_width = screen->width * (screen->fb[0].bitsPerPixel >> 3); pixel_width = screen->width; - screen->pixelStride = pixel_width; - screen->byteStride = byte_width; + screen->fb[0].pixelStride = pixel_width; + screen->fb[0].byteStride = byte_width; screen_size = byte_width * screen->height; @@ -307,10 +307,10 @@ sisScreenInit (KdScreenInfo *screen) /* * Fix requested depth and geometry until it works */ - if (screen->depth > 16) - screen->depth = 16; - else if (screen->depth > 8) - screen->depth = 8; + if (screen->fb[0].depth > 16) + screen->fb[0].depth = 16; + else if (screen->fb[0].depth > 8) + screen->fb[0].depth = 8; else if (screen->width > 1152) { screen->width = 1152; @@ -346,30 +346,30 @@ sisScreenInit (KdScreenInfo *screen) /* * Take requested geometry and adjust to fit possible geometries */ - switch (screen->depth) { + switch (screen->fb[0].depth) { case 4: - screen->bitsPerPixel = 4; + screen->fb[0].bitsPerPixel = 4; break; case 8: - screen->bitsPerPixel = 8; + screen->fb[0].bitsPerPixel = 8; break; case 15: case 16: - screen->bitsPerPixel = 16; + screen->fb[0].bitsPerPixel = 16; break; case 24: case 32: - screen->bitsPerPixel = 24; + screen->fb[0].bitsPerPixel = 24; screen->dumb = TRUE; break; } - screen->byteStride = screen->width * (screen->bitsPerPixel >> 3); - screen->pixelStride = screen->width; + screen->fb[0].byteStride = screen->width * (screen->fb[0].bitsPerPixel >> 3); + screen->fb[0].pixelStride = screen->width; memory = sisc->memory - screen_size; - screen->frameBuffer = sisc->frameBuffer; + screen->fb[0].frameBuffer = sisc->frameBuffer; /* * Cursor lives in the last 16k of memory @@ -389,7 +389,7 @@ sisScreenInit (KdScreenInfo *screen) if (memory > 8192) { - siss->expand = screen->frameBuffer + screen_size; + siss->expand = screen->fb[0].frameBuffer + screen_size; siss->expand_off = siss->expand - sisc->frameBuffer; siss->expand_len = memory; memory = 0; @@ -400,35 +400,35 @@ sisScreenInit (KdScreenInfo *screen) siss->expand_len = 0; } - switch (screen->depth) { + switch (screen->fb[0].depth) { case 8: - screen->visuals = ((1 << StaticGray) | + screen->fb[0].visuals = ((1 << StaticGray) | (1 << GrayScale) | (1 << StaticColor) | (1 << PseudoColor) | (1 << TrueColor) | (1 << DirectColor)); - screen->blueMask = 0x00; - screen->greenMask = 0x00; - screen->redMask = 0x00; + screen->fb[0].blueMask = 0x00; + screen->fb[0].greenMask = 0x00; + screen->fb[0].redMask = 0x00; break; case 15: - screen->visuals = (1 << TrueColor); - screen->blueMask = 0x001f; - screen->greenMask = 0x03e0; - screen->redMask = 0x7c00; + screen->fb[0].visuals = (1 << TrueColor); + screen->fb[0].blueMask = 0x001f; + screen->fb[0].greenMask = 0x03e0; + screen->fb[0].redMask = 0x7c00; break; case 16: - screen->visuals = (1 << TrueColor); - screen->blueMask = 0x001f; - screen->greenMask = 0x07e0; - screen->redMask = 0xf800; + screen->fb[0].visuals = (1 << TrueColor); + screen->fb[0].blueMask = 0x001f; + screen->fb[0].greenMask = 0x07e0; + screen->fb[0].redMask = 0xf800; break; case 24: - screen->visuals = (1 << TrueColor); - screen->blueMask = 0x0000ff; - screen->greenMask = 0x00ff00; - screen->redMask = 0xff0000; + screen->fb[0].visuals = (1 << TrueColor); + screen->fb[0].blueMask = 0x0000ff; + screen->fb[0].greenMask = 0x00ff00; + screen->fb[0].redMask = 0xff0000; break; } @@ -752,7 +752,7 @@ sisEnable (ScreenPtr pScreen) pixel = (hactive + hblank) * (vactive + vblank) * t->rate; - switch (screen->bitsPerPixel) { + switch (screen->fb[0].bitsPerPixel) { case 8: hactive /= 8; hblank /= 8; @@ -775,7 +775,7 @@ sisEnable (ScreenPtr pScreen) crtc.color_mode_256 = 0; - if (screen->depth == 15) + if (screen->fb[0].depth == 15) crtc.graphics_mode_32k = 1; else crtc.graphics_mode_64k = 1; @@ -826,7 +826,7 @@ sisEnable (ScreenPtr pScreen) crtc.high_speed_dac_0 = crtc.high_speed_dac_1 = pixel > 135000000; - sisEngThresh (&crtc, pixel, screen->bitsPerPixel); + sisEngThresh (&crtc, pixel, screen->fb[0].bitsPerPixel); /* * Compute horizontal register values from timings diff --git a/hw/kdrive/sis530/sis.h b/hw/kdrive/sis530/sis.h index 9ffc9d197..f4d7e750c 100644 --- a/hw/kdrive/sis530/sis.h +++ b/hw/kdrive/sis530/sis.h @@ -1102,8 +1102,8 @@ void sisDrawSync (ScreenPtr pScreen); void sisDrawDisable (ScreenPtr pScreen); void sisDrawFini (ScreenPtr pScreen); -void sisGetColors (ScreenPtr pScreen, int ndef, xColorItem *pdefs); -void sisPutColors (ScreenPtr pScreen, int ndef, xColorItem *pdefs); +void sisGetColors (ScreenPtr pScreen, int fb, int ndef, xColorItem *pdefs); +void sisPutColors (ScreenPtr pScreen, int fb, int ndef, xColorItem *pdefs); void SISInitCard (KdCardAttr *attr); diff --git a/hw/kdrive/sis530/siscmap.c b/hw/kdrive/sis530/siscmap.c index a8b504135..28b218273 100644 --- a/hw/kdrive/sis530/siscmap.c +++ b/hw/kdrive/sis530/siscmap.c @@ -26,7 +26,7 @@ #include "sis.h" void -sisGetColors (ScreenPtr pScreen, int ndef, xColorItem *pdefs) +sisGetColors (ScreenPtr pScreen, int fb, int ndef, xColorItem *pdefs) { KdScreenPriv(pScreen); sisCardInfo(pScreenPriv); @@ -44,7 +44,7 @@ sisGetColors (ScreenPtr pScreen, int ndef, xColorItem *pdefs) } void -sisPutColors (ScreenPtr pScreen, int ndef, xColorItem *pdefs) +sisPutColors (ScreenPtr pScreen, int fb, int ndef, xColorItem *pdefs) { KdScreenPriv(pScreen); sisCardInfo(pScreenPriv); diff --git a/hw/kdrive/sis530/sisdraw.c b/hw/kdrive/sis530/sisdraw.c index a21f43d52..2461d3c4b 100644 --- a/hw/kdrive/sis530/sisdraw.c +++ b/hw/kdrive/sis530/sisdraw.c @@ -1636,8 +1636,8 @@ sisDrawEnable (ScreenPtr pScreen) CARD32 base; CARD16 stride; - base = pScreenPriv->screen->frameBuffer - sisc->frameBuffer; - stride = pScreenPriv->screen->byteStride; + base = pScreenPriv->screen->fb[0].frameBuffer - sisc->frameBuffer; + stride = pScreenPriv->screen->fb[0].byteStride; sis->u.general.dst_base = base; sis->u.general.dst_pitch = stride; sis->u.general.dst_height = pScreenPriv->screen->height; diff --git a/hw/kdrive/src/kcmap.c b/hw/kdrive/src/kcmap.c index 669aca42f..76d2f1f53 100644 --- a/hw/kdrive/src/kcmap.c +++ b/hw/kdrive/src/kcmap.c @@ -21,7 +21,7 @@ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. */ -/* $XFree86: xc/programs/Xserver/hw/kdrive/kcmap.c,v 1.1 1999/11/19 13:53:48 hohndel Exp $ */ +/* $XFree86: xc/programs/Xserver/hw/kdrive/kcmap.c,v 1.2 2000/02/23 20:29:52 dawes Exp $ */ #include "kdrive.h" @@ -30,10 +30,10 @@ */ void -KdSetColormap (ScreenPtr pScreen) +KdSetColormap (ScreenPtr pScreen, int fb) { KdScreenPriv(pScreen); - ColormapPtr pCmap = pScreenPriv->pInstalledmap; + ColormapPtr pCmap = pScreenPriv->pInstalledmap[fb]; Pixel pixels[KD_MAX_PSEUDO_SIZE]; xrgb colors[KD_MAX_PSEUDO_SIZE]; xColorItem defs[KD_MAX_PSEUDO_SIZE]; @@ -41,7 +41,7 @@ KdSetColormap (ScreenPtr pScreen) if (!pScreenPriv->card->cfuncs->putColors) return; - if (pScreenPriv->screen->depth > KD_MAX_PSEUDO_DEPTH) + if (pScreenPriv->screen->fb[fb].depth > KD_MAX_PSEUDO_DEPTH) return; if (!pScreenPriv->enabled) @@ -55,12 +55,12 @@ KdSetColormap (ScreenPtr pScreen) * true/direct as well as pseudo/static visuals */ - for (i = 0; i < (1 << pScreenPriv->screen->depth); i++) + for (i = 0; i < (1 << pScreenPriv->screen->fb[i].depth); i++) pixels[i] = i; - QueryColors (pCmap, (1 << pScreenPriv->screen->depth), pixels, colors); + QueryColors (pCmap, (1 << pScreenPriv->screen->fb[i].depth), pixels, colors); - for (i = 0; i < (1 << pScreenPriv->screen->depth); i++) + for (i = 0; i < (1 << pScreenPriv->screen->fb[i].depth); i++) { defs[i].pixel = i; defs[i].red = colors[i].red; @@ -69,9 +69,9 @@ KdSetColormap (ScreenPtr pScreen) defs[i].flags = DoRed|DoGreen|DoBlue; } - (*pScreenPriv->card->cfuncs->putColors) (pCmap->pScreen, - (1 << pScreenPriv->screen->depth), - defs); + (*pScreenPriv->card->cfuncs->putColors) (pCmap->pScreen, fb, + (1 << pScreenPriv->screen->fb[i].depth), + defs); /* recolor hardware cursor */ if (pScreenPriv->card->cfuncs->recolorCursor) @@ -87,33 +87,78 @@ KdEnableColormap (ScreenPtr pScreen) { KdScreenPriv(pScreen); int i; + int fb; + Bool done = FALSE; if (!pScreenPriv->card->cfuncs->putColors) return; - if (pScreenPriv->screen->depth <= KD_MAX_PSEUDO_DEPTH) + for (fb = 0; fb < KD_MAX_FB && pScreenPriv->screen->fb[fb].depth; fb++) { - for (i = 0; i < (1 << pScreenPriv->screen->depth); i++) - pScreenPriv->systemPalette[i].pixel = i; - (*pScreenPriv->card->cfuncs->getColors) (pScreen, - (1 << pScreenPriv->screen->depth), - pScreenPriv->systemPalette); + if (pScreenPriv->screen->fb[fb].depth <= KD_MAX_PSEUDO_DEPTH && !done) + { + for (i = 0; i < (1 << pScreenPriv->screen->fb[fb].depth); i++) + pScreenPriv->systemPalette[i].pixel = i; + (*pScreenPriv->card->cfuncs->getColors) (pScreen, fb, + (1 << pScreenPriv->screen->fb[fb].depth), + pScreenPriv->systemPalette); + done = TRUE; + } + KdSetColormap (pScreen, fb); } - KdSetColormap (pScreen); } void KdDisableColormap (ScreenPtr pScreen) { KdScreenPriv(pScreen); + int fb; if (!pScreenPriv->card->cfuncs->putColors) return; - if (pScreenPriv->screen->depth > KD_MAX_PSEUDO_DEPTH) - return; - - (*pScreenPriv->card->cfuncs->putColors) (pScreen, - (1 << pScreenPriv->screen->depth), - pScreenPriv->systemPalette); + for (fb = 0; fb < KD_MAX_FB && pScreenPriv->screen->fb[fb].depth; fb++) + { + if (pScreenPriv->screen->fb[fb].depth <= KD_MAX_PSEUDO_DEPTH) + { + (*pScreenPriv->card->cfuncs->putColors) (pScreen, fb, + (1 << pScreenPriv->screen->fb[fb].depth), + pScreenPriv->systemPalette); + break; + } + } +} + +int +KdColormapFb (ColormapPtr pCmap) +{ + ScreenPtr pScreen = pCmap->pScreen; + KdScreenPriv (pScreen); + KdScreenInfo *screen = pScreenPriv->screen; + int d; + DepthPtr depth; + int v, vi; + VisualPtr visual; + VisualID vid = pCmap->pVisual->vid; + int fb; + + if (screen->fb[1].depth) + { + for (d = 0; d < pScreen->numDepths; d++) + { + depth = &pScreen->allowedDepths[d]; + for (v = 0; v < depth->numVids; v++) + { + if (depth->vids[v] == vid) + { + for (fb = 0; fb < KD_MAX_FB && screen->fb[fb].depth; fb++) + { + if (depth->depth == screen->fb[fb].depth) + return fb; + } + } + } + } + } + return 0; } /* @@ -129,19 +174,20 @@ void KdInstallColormap (ColormapPtr pCmap) { KdScreenPriv(pCmap->pScreen); + int fb = KdColormapFb (pCmap); - if (pCmap == pScreenPriv->pInstalledmap) + if (pCmap == pScreenPriv->pInstalledmap[fb]) return; /* Tell X clients that the installed colormap is going away. */ - if (pScreenPriv->pInstalledmap) - WalkTree(pScreenPriv->pInstalledmap->pScreen, TellLostMap, - (pointer) &(pScreenPriv->pInstalledmap->mid)); + if (pScreenPriv->pInstalledmap[fb]) + WalkTree(pScreenPriv->pInstalledmap[fb]->pScreen, TellLostMap, + (pointer) &(pScreenPriv->pInstalledmap[fb]->mid)); /* Take note of the new installed colorscreen-> */ - pScreenPriv->pInstalledmap = pCmap; + pScreenPriv->pInstalledmap[fb] = pCmap; - KdSetColormap (pCmap->pScreen); + KdSetColormap (pCmap->pScreen, fb); /* Tell X clients of the new colorscreen-> */ WalkTree(pCmap->pScreen, TellGainedMap, (pointer) &(pCmap->mid)); @@ -157,8 +203,9 @@ void KdUninstallColormap (ColormapPtr pCmap) { KdScreenPriv(pCmap->pScreen); + int fb = KdColormapFb (pCmap); - if (pCmap == pScreenPriv->pInstalledmap) + if (pCmap == pScreenPriv->pInstalledmap[0]) { Colormap defMapID = pCmap->pScreen->defColormap; @@ -176,13 +223,18 @@ int KdListInstalledColormaps (ScreenPtr pScreen, Colormap *pCmaps) { KdScreenPriv(pScreen); + int fb; + int n = 0; - if (pScreenPriv->pInstalledmap) + for (fb = 0; fb < KD_MAX_FB && pScreenPriv->screen->fb[fb].depth; fb++) { - *pCmaps = pScreenPriv->pInstalledmap->mid; - return 1; + if (pScreenPriv->pInstalledmap[fb]) + { + *pCmaps++ = pScreenPriv->pInstalledmap[fb]->mid; + n++; + } } - return 0; + return n; } /* @@ -198,14 +250,15 @@ KdStoreColors (ColormapPtr pCmap, int ndef, xColorItem *pdefs) KdScreenPriv(pCmap->pScreen); VisualPtr pVisual; xColorItem expanddefs[KD_MAX_PSEUDO_SIZE]; + int fb = KdColormapFb (pCmap); - if (pCmap != pScreenPriv->pInstalledmap) + if (pCmap != pScreenPriv->pInstalledmap[fb]) return; if (!pScreenPriv->card->cfuncs->putColors) return; - if (pScreenPriv->screen->depth > KD_MAX_PSEUDO_DEPTH) + if (pScreenPriv->screen->fb[fb].depth > KD_MAX_PSEUDO_DEPTH) return; if (!pScreenPriv->enabled) @@ -223,7 +276,7 @@ KdStoreColors (ColormapPtr pCmap, int ndef, xColorItem *pdefs) pdefs = expanddefs; } - (*pScreenPriv->card->cfuncs->putColors) (pCmap->pScreen, ndef, pdefs); + (*pScreenPriv->card->cfuncs->putColors) (pCmap->pScreen, fb, ndef, pdefs); /* recolor hardware cursor */ if (pScreenPriv->card->cfuncs->recolorCursor) diff --git a/hw/kdrive/src/kcurscol.c b/hw/kdrive/src/kcurscol.c index 3327e9044..1e6e09b10 100644 --- a/hw/kdrive/src/kcurscol.c +++ b/hw/kdrive/src/kcurscol.c @@ -45,6 +45,7 @@ KdComputeCmapShift (unsigned long mask) void KdAllocateCursorPixels (ScreenPtr pScreen, + int fb, CursorPtr pCursor, Pixel *source, Pixel *mask) @@ -53,18 +54,18 @@ KdAllocateCursorPixels (ScreenPtr pScreen, int r, g, b; KdScreenPriv(pScreen); - if (pScreenPriv->screen->redMask) + if (pScreenPriv->screen->fb[fb].redMask) { - r = KdComputeCmapShift (pScreenPriv->screen->redMask); - g = KdComputeCmapShift (pScreenPriv->screen->greenMask); - b = KdComputeCmapShift (pScreenPriv->screen->blueMask); - *source = ((Shift(pCursor->foreRed,r) & pScreenPriv->screen->redMask) | - (Shift(pCursor->foreGreen,g) & pScreenPriv->screen->greenMask) | - (Shift(pCursor->foreBlue,b) & pScreenPriv->screen->blueMask)); - *mask = ((Shift(pCursor->backRed,r) & pScreenPriv->screen->redMask) | - (Shift(pCursor->backGreen,g) & pScreenPriv->screen->greenMask) | - (Shift(pCursor->backBlue,b) & pScreenPriv->screen->blueMask)); + r = KdComputeCmapShift (pScreenPriv->screen->fb[fb].redMask); + g = KdComputeCmapShift (pScreenPriv->screen->fb[fb].greenMask); + b = KdComputeCmapShift (pScreenPriv->screen->fb[fb].blueMask); + *source = ((Shift(pCursor->foreRed,r) & pScreenPriv->screen->fb[fb].redMask) | + (Shift(pCursor->foreGreen,g) & pScreenPriv->screen->fb[fb].greenMask) | + (Shift(pCursor->foreBlue,b) & pScreenPriv->screen->fb[fb].blueMask)); + *mask = ((Shift(pCursor->backRed,r) & pScreenPriv->screen->fb[fb].redMask) | + (Shift(pCursor->backGreen,g) & pScreenPriv->screen->fb[fb].greenMask) | + (Shift(pCursor->backBlue,b) & pScreenPriv->screen->fb[fb].blueMask)); } else { @@ -79,13 +80,13 @@ KdAllocateCursorPixels (ScreenPtr pScreen, sourceColor.red = pCursor->foreRed; sourceColor.green = pCursor->foreGreen; sourceColor.blue = pCursor->foreBlue; - FakeAllocColor(pScreenPriv->pInstalledmap, &sourceColor); + FakeAllocColor(pScreenPriv->pInstalledmap[fb], &sourceColor); maskColor.red = pCursor->backRed; maskColor.green = pCursor->backGreen; maskColor.blue = pCursor->backBlue; - FakeAllocColor(pScreenPriv->pInstalledmap, &maskColor); - FakeFreeColor(pScreenPriv->pInstalledmap, sourceColor.pixel); - FakeFreeColor(pScreenPriv->pInstalledmap, maskColor.pixel); + FakeAllocColor(pScreenPriv->pInstalledmap[fb], &maskColor); + FakeFreeColor(pScreenPriv->pInstalledmap[fb], sourceColor.pixel); + FakeFreeColor(pScreenPriv->pInstalledmap[fb], maskColor.pixel); *source = sourceColor.pixel; *mask = maskColor.pixel; } diff --git a/hw/kdrive/src/kdrive.c b/hw/kdrive/src/kdrive.c index 308179950..d636260e5 100644 --- a/hw/kdrive/src/kdrive.c +++ b/hw/kdrive/src/kdrive.c @@ -21,7 +21,7 @@ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. */ -/* $XFree86: xc/programs/Xserver/hw/kdrive/kdrive.c,v 1.2 1999/12/30 03:03:05 robin Exp $ */ +/* $XFree86: xc/programs/Xserver/hw/kdrive/kdrive.c,v 1.3 2000/02/23 20:29:53 dawes Exp $ */ #include "kdrive.h" #ifdef PSEUDO8 @@ -301,10 +301,14 @@ void KdParseScreen (KdScreenInfo *screen, char *arg) { + char *bpp; + int fb; + screen->width = 0; screen->height = 0; - screen->depth = 0; screen->rate = 0; + for (fb = 0; fb < KD_MAX_FB; fb++) + screen->fb[fb].depth = 0; if (!arg) return; @@ -320,7 +324,27 @@ KdParseScreen (KdScreenInfo *screen, return; arg++; - screen->depth = atoi(arg); + fb = 0; + while (fb < KD_MAX_FB) + { + screen->fb[fb].depth = atoi(arg); + + bpp = strchr (arg, '/'); + if (bpp) + { + bpp++; + screen->fb[fb].bitsPerPixel = atoi(bpp); + arg = bpp; + } + else + screen->fb[fb].bitsPerPixel = 0; + bpp = strchr (arg, ','); + if (!bpp) + break; + arg = bpp+1; + fb++; + } + arg = strchr (arg, 'x'); if (!arg) return; @@ -551,7 +575,7 @@ KdCreateWindow (WindowPtr pWin) } } #endif - return TRUE; + return fbCreateWindow (pWin); } /* Pass through AddScreen, which doesn't take any closure */ @@ -563,6 +587,7 @@ KdScreenInit(int index, ScreenPtr pScreen, int argc, char **argv) KdScreenInfo *screen = kdCurrentScreen; KdCardInfo *card = screen->card; KdPrivScreenPtr pScreenPriv; + int fb; KdAllocatePrivates (pScreen); @@ -571,7 +596,8 @@ KdScreenInit(int index, ScreenPtr pScreen, int argc, char **argv) screen->pScreen = pScreen; pScreenPriv->screen = screen; pScreenPriv->card = card; - pScreenPriv->bytesPerPixel = screen->bitsPerPixel >> 3; + for (fb = 0; fb < KD_MAX_FB && screen->fb[fb].depth; fb++) + pScreenPriv->bytesPerPixel[fb] = screen->fb[fb].bitsPerPixel >> 3; pScreenPriv->dpmsState = KD_DPMS_NORMAL; /* @@ -580,11 +606,11 @@ KdScreenInit(int index, ScreenPtr pScreen, int argc, char **argv) * backing store */ if (!fbSetupScreen (pScreen, - screen->frameBuffer, + screen->fb[0].frameBuffer, screen->width, screen->height, screen->dpix, screen->dpiy, - screen->pixelStride, - screen->bitsPerPixel)) + screen->fb[0].pixelStride, + screen->fb[0].bitsPerPixel)) { return FALSE; } @@ -608,14 +634,34 @@ KdScreenInit(int index, ScreenPtr pScreen, int argc, char **argv) pScreenPriv->BackingStoreFuncs.GetSpansPixmap = 0; #endif - if (!fbFinishScreenInit (pScreen, - screen->frameBuffer, - screen->width, screen->height, - screen->dpix, screen->dpiy, - screen->pixelStride, - screen->bitsPerPixel)) + if (screen->fb[1].depth) + { + if (!fbOverlayFinishScreenInit (pScreen, + screen->fb[0].frameBuffer, + screen->fb[1].frameBuffer, + screen->width, screen->height, + screen->dpix, screen->dpiy, + screen->fb[0].pixelStride, + screen->fb[1].pixelStride, + screen->fb[0].bitsPerPixel, + screen->fb[1].bitsPerPixel, + screen->fb[0].depth, + screen->fb[1].depth)) + { + return FALSE; + } + } + else { - return FALSE; + if (!fbFinishScreenInit (pScreen, + screen->fb[0].frameBuffer, + screen->width, screen->height, + screen->dpix, screen->dpiy, + screen->fb[0].pixelStride, + screen->fb[0].bitsPerPixel)) + { + return FALSE; + } } /* @@ -720,6 +766,8 @@ KdSetPixmapFormats (ScreenInfo *pScreenInfo) KdCardInfo *card; KdScreenInfo *screen; int i; + int bpp; + int fb; PixmapFormatRec *format; for (i = 1; i <= 32; i++) @@ -735,10 +783,16 @@ KdSetPixmapFormats (ScreenInfo *pScreenInfo) { for (screen = card->screenList; screen; screen = screen->next) { - if (!depthToBpp[screen->depth]) - depthToBpp[screen->depth] = screen->bitsPerPixel; - else if (depthToBpp[screen->depth] != screen->bitsPerPixel) - return FALSE; + for (fb = 0; fb < KD_MAX_FB && screen->fb[fb].depth; fb++) + { + bpp = screen->fb[fb].bitsPerPixel; + if (bpp == 24) + bpp = 32; + if (!depthToBpp[screen->fb[fb].depth]) + depthToBpp[screen->fb[fb].depth] = bpp; + else if (depthToBpp[screen->fb[fb].depth] != bpp) + return FALSE; + } } } @@ -784,18 +838,20 @@ KdAddScreen (ScreenInfo *pScreenInfo, { unsigned long visuals; Pixel rm, gm, bm; + int fb; - if (pScreenInfo->formats[i].depth == screen->depth) + visuals = 0; + rm = gm = bm = 0; + for (fb = 0; fb < KD_MAX_FB && screen->fb[fb].depth; fb++) { - visuals = screen->visuals; - rm = screen->redMask; - gm = screen->greenMask; - bm = screen->blueMask; - } - else - { - visuals = 0; - rm = gm = bm = 0; + if (pScreenInfo->formats[i].depth == screen->fb[fb].depth) + { + visuals = screen->fb[fb].visuals; + rm = screen->fb[fb].redMask; + gm = screen->fb[fb].greenMask; + bm = screen->fb[fb].blueMask; + break; + } } fbSetVisualTypesAndMasks (pScreenInfo->formats[i].depth, visuals, @@ -808,6 +864,17 @@ KdAddScreen (ScreenInfo *pScreenInfo, AddScreen (KdScreenInit, argc, argv); } +int +KdDepthToFb (ScreenPtr pScreen, int depth) +{ + KdScreenPriv(pScreen); + int fb; + + for (fb = 0; fb <= KD_MAX_FB && pScreenPriv->screen->fb[fb].frameBuffer; fb++) + if (pScreenPriv->screen->fb[fb].depth == depth) + return fb; +} + void KdInitOutput (ScreenInfo *pScreenInfo, int argc, diff --git a/hw/kdrive/src/kdrive.h b/hw/kdrive/src/kdrive.h index 9458512b4..4b6c06ed4 100644 --- a/hw/kdrive/src/kdrive.h +++ b/hw/kdrive/src/kdrive.h @@ -21,7 +21,7 @@ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. */ -/* $XFree86: xc/programs/Xserver/hw/kdrive/kdrive.h,v 1.3 2000/01/21 01:12:01 dawes Exp $ */ +/* $XFree86: xc/programs/Xserver/hw/kdrive/kdrive.h,v 1.4 2000/02/23 20:29:53 dawes Exp $ */ #include <stdio.h> #include "X.h" @@ -40,6 +40,7 @@ #include "mi.h" #include "dix.h" #include "fb.h" +#include "fboverlay.h" extern WindowPtr *WindowTable; @@ -49,10 +50,18 @@ extern WindowPtr *WindowTable; #define KD_DPMS_POWERDOWN 3 #define KD_DPMS_MAX KD_DPMS_POWERDOWN +#ifndef KD_MAX_FB +#define KD_MAX_FB 2 +#endif + +#ifndef KD_MAX_CARD_ADDRESS +#define KD_MAX_CARD_ADDRESS 8 +#endif + /* * Configuration information per video card */ -#define KD_MAX_CARD_ADDRESS 8 + typedef struct _KdCardAttr { CARD32 io; CARD32 address[KD_MAX_CARD_ADDRESS]; @@ -75,25 +84,30 @@ extern KdCardInfo *kdCardInfo; /* * Configuration information per X screen */ +typedef struct _KdFrameBuffer { + CARD8 *frameBuffer; + int depth; + int bitsPerPixel; + int pixelStride; + int byteStride; + unsigned long visuals; + Pixel redMask, greenMask, blueMask; + void *closure; +} KdFrameBuffer; + typedef struct _KdScreenInfo { struct _KdScreenInfo *next; KdCardInfo *card; ScreenPtr pScreen; void *driver; - CARD8 *frameBuffer; int width; int height; - int depth; int rate; - int bitsPerPixel; - int pixelStride; - int byteStride; int dpix, dpiy; - unsigned long visuals; - Pixel redMask, greenMask, blueMask; Bool dumb; Bool softCursor; int mynum; + KdFrameBuffer fb[KD_MAX_FB]; } KdScreenInfo; typedef struct _KdCardFuncs { @@ -120,8 +134,8 @@ typedef struct _KdCardFuncs { void (*disableAccel) (ScreenPtr); void (*finiAccel) (ScreenPtr); - void (*getColors) (ScreenPtr, int, xColorItem *); - void (*putColors) (ScreenPtr, int, xColorItem *); + void (*getColors) (ScreenPtr, int, int, xColorItem *); + void (*putColors) (ScreenPtr, int, int, xColorItem *); } KdCardFuncs; #define KD_MAX_PSEUDO_DEPTH 8 @@ -133,11 +147,11 @@ typedef struct { Bool enabled; Bool closed; - int bytesPerPixel; + int bytesPerPixel[KD_MAX_FB]; int dpmsState; - ColormapPtr pInstalledmap; /* current colormap */ + ColormapPtr pInstalledmap[KD_MAX_FB]; /* current colormap */ xColorItem systemPalette[KD_MAX_PSEUDO_SIZE];/* saved windows colors */ CloseScreenProcPtr CloseScreen; @@ -341,7 +355,7 @@ extern GCOps kdNoopOps; /* kcmap.c */ void -KdSetColormap (ScreenPtr pScreen); +KdSetColormap (ScreenPtr pScreen, int fb); void KdEnableColormap (ScreenPtr pScreen); @@ -364,6 +378,7 @@ KdStoreColors (ColormapPtr pCmap, int ndef, xColorItem *pdefs); /* kcurscol.c */ void KdAllocateCursorPixels (ScreenPtr pScreen, + int fb, CursorPtr pCursor, Pixel *source, Pixel *mask); diff --git a/hw/kdrive/src/kinput.c b/hw/kdrive/src/kinput.c index 2b3b13e3e..5f1886519 100644 --- a/hw/kdrive/src/kinput.c +++ b/hw/kdrive/src/kinput.c @@ -21,7 +21,7 @@ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. */ -/* $XFree86: xc/programs/Xserver/hw/kdrive/kinput.c,v 1.2 1999/12/30 03:03:06 robin Exp $ */ +/* $XFree86: xc/programs/Xserver/hw/kdrive/kinput.c,v 1.3 2000/02/23 20:29:54 dawes Exp $ */ #include "kdrive.h" #include "inputstr.h" @@ -137,6 +137,9 @@ KdAddFd (int fd) memset (&act, '\0', sizeof act); act.sa_handler = KdSigio; sigemptyset (&act.sa_mask); + sigaddset (&act.sa_mask, SIGIO); + sigaddset (&act.sa_mask, SIGALRM); + sigaddset (&act.sa_mask, SIGVTALRM); sigaction (SIGIO, &act, 0); sigemptyset (&set); sigprocmask (SIG_SETMASK, &set, 0); diff --git a/hw/kdrive/src/kmode.c b/hw/kdrive/src/kmode.c index 73ef282f2..4c2116223 100644 --- a/hw/kdrive/src/kmode.c +++ b/hw/kdrive/src/kmode.c @@ -295,10 +295,12 @@ KdTuneMode (KdScreenInfo *screen, /* * Fix requested depth and geometry until it works */ - if (screen->depth > 16) - screen->depth = 16; - else if (screen->depth > 8) - screen->depth = 8; + if (screen->fb[1].depth) + screen->fb[1].depth = 0; + else if (screen->fb[0].depth > 16) + screen->fb[0].depth = 16; + else if (screen->fb[0].depth > 8) + screen->fb[0].depth = 8; else { t = kdFindPrevSize (KdFindMode (screen, supported)); diff --git a/hw/kdrive/trident/trident.c b/hw/kdrive/trident/trident.c index 08e5ce46d..1a8509dbe 100644 --- a/hw/kdrive/trident/trident.c +++ b/hw/kdrive/trident/trident.c @@ -74,7 +74,7 @@ tridentScreenInit (KdScreenInfo *screen) } if (!tridentc->cop) screen->dumb = TRUE; - screen_size = screen->byteStride * screen->height; + screen_size = screen->fb[0].byteStride * screen->height; memory = (2048 + 512) * 1024; if (memory >= screen_size + 2048) { diff --git a/hw/kdrive/trident/tridentcurs.c b/hw/kdrive/trident/tridentcurs.c index b10319d31..19b45c68b 100644 --- a/hw/kdrive/trident/tridentcurs.c +++ b/hw/kdrive/trident/tridentcurs.c @@ -88,9 +88,9 @@ tridentAllocCursorColors (ScreenPtr pScreen) SetupCursor (pScreen); CursorPtr pCursor = pCurPriv->pCursor; - KdAllocateCursorPixels (pScreen, pCursor, + KdAllocateCursorPixels (pScreen, 0, pCursor, &pCurPriv->source, &pCurPriv->mask); - switch (pScreenPriv->screen->bitsPerPixel) { + switch (pScreenPriv->screen->fb[0].bitsPerPixel) { case 4: pCurPriv->source |= pCurPriv->source << 4; pCurPriv->mask |= pCurPriv->mask << 4; diff --git a/hw/kdrive/trident/tridentdraw.c b/hw/kdrive/trident/tridentdraw.c index 4cdfb09e4..4ac0a627d 100644 --- a/hw/kdrive/trident/tridentdraw.c +++ b/hw/kdrive/trident/tridentdraw.c @@ -812,8 +812,8 @@ tridentDrawEnable (ScreenPtr pScreen) CARD32 alpha; int tries; - stride = pScreenPriv->screen->pixelStride; - switch (pScreenPriv->screen->bitsPerPixel) { + stride = pScreenPriv->screen->fb[0].pixelStride; + switch (pScreenPriv->screen->fb[0].bitsPerPixel) { case 8: format = COP_DEPTH_8; break; diff --git a/hw/kdrive/trio/s3.c b/hw/kdrive/trio/s3.c index 489f5ce0f..07e6852b9 100644 --- a/hw/kdrive/trio/s3.c +++ b/hw/kdrive/trio/s3.c @@ -445,31 +445,31 @@ s3ModeUsable (KdScreenInfo *screen) int pixel_width; int byte_width; - if (screen->depth >= 24) + if (screen->fb[0].depth >= 24) { - screen->depth = 24; - screen->bitsPerPixel = 32; + screen->fb[0].depth = 24; + screen->fb[0].bitsPerPixel = 32; } - else if (screen->depth >= 16) + else if (screen->fb[0].depth >= 16) { - screen->depth = 16; - screen->bitsPerPixel = 16; + screen->fb[0].depth = 16; + screen->fb[0].bitsPerPixel = 16; } - else if (screen->depth >= 15) + else if (screen->fb[0].depth >= 15) { - screen->depth = 15; - screen->bitsPerPixel = 16; + screen->fb[0].depth = 15; + screen->fb[0].bitsPerPixel = 16; } else { - screen->depth = 8; - screen->bitsPerPixel = 8; + screen->fb[0].depth = 8; + screen->fb[0].bitsPerPixel = 8; } - byte_width = screen->width * (screen->bitsPerPixel >> 3); + byte_width = screen->width * (screen->fb[0].bitsPerPixel >> 3); pixel_width = screen->width; - screen->pixelStride = pixel_width; - screen->byteStride = byte_width; + screen->fb[0].pixelStride = pixel_width; + screen->fb[0].byteStride = byte_width; screen_size = byte_width * screen->height; @@ -505,8 +505,8 @@ s3ScreenInit (KdScreenInfo *screen) screen->height = 600; screen->rate = 72; } - if (!screen->depth) - screen->depth = 8; + if (!screen->fb[0].depth) + screen->fb[0].depth = 8; DRAW_DEBUG ((DEBUG_S3INIT, "Requested parameters %dx%dx%d", screen->width, screen->height, screen->rate)); @@ -524,8 +524,8 @@ s3ScreenInit (KdScreenInfo *screen) /* * Can only operate in pixel-doubled mode at 8 bits per pixel */ - if (screen->depth > 8 && S3_CLOCK(m,n,r) > S3_MAX_CLOCK) - screen->depth = 8; + if (screen->fb[0].depth > 8 && S3_CLOCK(m,n,r) > S3_MAX_CLOCK) + screen->fb[0].depth = 8; if (!KdTuneMode (screen, s3ModeUsable, s3ModeSupported)) { @@ -538,7 +538,7 @@ s3ScreenInit (KdScreenInfo *screen) /* * Stick frame buffer at start of memory */ - screen->frameBuffer = s3c->frameBuffer; + screen->fb[0].frameBuffer = s3c->frameBuffer; /* * Stick cursor at end of memory @@ -557,25 +557,25 @@ s3ScreenInit (KdScreenInfo *screen) */ if (memory >= byte_width * S3_TILE_SIZE) { - s3s->offscreen = s3c->frameBuffer + screen_size; - s3s->offscreen_x = 0; - s3s->offscreen_y = screen_size / byte_width; - s3s->offscreen_width = pixel_width; - s3s->offscreen_height = memory / byte_width; - memory -= s3s->offscreen_height * byte_width; + s3s->fb[0].offscreen = s3c->frameBuffer + screen_size; + s3s->fb[0].offscreen_x = 0; + s3s->fb[0].offscreen_y = screen_size / byte_width; + s3s->fb[0].offscreen_width = pixel_width; + s3s->fb[0].offscreen_height = memory / byte_width; + memory -= s3s->fb[0].offscreen_height * byte_width; } else if (pixel_width - screen->width >= S3_TILE_SIZE) { - s3s->offscreen = s3c->frameBuffer + screen->width; - s3s->offscreen_x = screen->width; - s3s->offscreen_y = 0; - s3s->offscreen_width = pixel_width - screen->width; - s3s->offscreen_height = screen->height; + s3s->fb[0].offscreen = s3c->frameBuffer + screen->width; + s3s->fb[0].offscreen_x = screen->width; + s3s->fb[0].offscreen_y = 0; + s3s->fb[0].offscreen_width = pixel_width - screen->width; + s3s->fb[0].offscreen_height = screen->height; } else - s3s->offscreen = 0; + s3s->fb[0].offscreen = 0; - DRAW_DEBUG ((DEBUG_S3INIT, "depth %d bits %d", screen->depth, screen->bitsPerPixel)); + DRAW_DEBUG ((DEBUG_S3INIT, "depth %d bits %d", screen->fb[0].depth, screen->fb[0].bitsPerPixel)); DRAW_DEBUG ((DEBUG_S3INIT, "Screen size %dx%d memory %d", screen->width, screen->height, s3c->memory)); @@ -585,35 +585,35 @@ s3ScreenInit (KdScreenInfo *screen) s3s->offscreen_width, s3s->offscreen_height, s3s->offscreen_x, s3s->offscreen_y)); - switch (screen->depth) { + switch (screen->fb[0].depth) { case 8: - screen->visuals = ((1 << StaticGray) | + screen->fb[0].visuals = ((1 << StaticGray) | (1 << GrayScale) | (1 << StaticColor) | (1 << PseudoColor) | (1 << TrueColor) | (1 << DirectColor)); - screen->blueMask = 0x00; - screen->greenMask = 0x00; - screen->redMask = 0x00; + screen->fb[0].blueMask = 0x00; + screen->fb[0].greenMask = 0x00; + screen->fb[0].redMask = 0x00; break; case 15: - screen->visuals = (1 << TrueColor); - screen->blueMask = 0x001f; - screen->greenMask = 0x03e0; - screen->redMask = 0x7c00; + screen->fb[0].visuals = (1 << TrueColor); + screen->fb[0].blueMask = 0x001f; + screen->fb[0].greenMask = 0x03e0; + screen->fb[0].redMask = 0x7c00; break; case 16: - screen->visuals = (1 << TrueColor); - screen->blueMask = 0x001f; - screen->greenMask = 0x07e0; - screen->redMask = 0xf800; + screen->fb[0].visuals = (1 << TrueColor); + screen->fb[0].blueMask = 0x001f; + screen->fb[0].greenMask = 0x07e0; + screen->fb[0].redMask = 0xf800; break; case 24: - screen->visuals = (1 << TrueColor); - screen->blueMask = 0x0000ff; - screen->greenMask = 0x00ff00; - screen->redMask = 0xff0000; + screen->fb[0].visuals = (1 << TrueColor); + screen->fb[0].blueMask = 0x0000ff; + screen->fb[0].greenMask = 0x00ff00; + screen->fb[0].redMask = 0xff0000; break; } @@ -712,7 +712,7 @@ s3Enable (ScreenPtr pScreen) /* * Compute character lengths for horizontal timing values */ - switch (screen->bitsPerPixel) { + switch (screen->fb[0].bitsPerPixel) { case 8: hactive = screen->width / 8; hblank /= 8; @@ -830,7 +830,7 @@ s3Enable (ScreenPtr pScreen) */ if (!screen->softCursor) { - cursor_address = (s3s->cursor_base - screen->frameBuffer) / 1024; + cursor_address = (s3s->cursor_base - screen->fb[0].frameBuffer) / 1024; crtc->cursor_address_0_7 = cursor_address; crtc->cursor_address_8_15 = cursor_address >> 8; @@ -855,8 +855,8 @@ s3Enable (ScreenPtr pScreen) /* * Set depth values */ - crtc->bits_per_pixel = screen->bitsPerPixel; - crtc->depth = screen->depth; + crtc->bits_per_pixel = screen->fb[0].bitsPerPixel; + crtc->depth = screen->fb[0].depth; crtc->l_parm_0_7 = screen->width / 4; /* Undocumented. */ diff --git a/hw/kdrive/trio/s3.h b/hw/kdrive/trio/s3.h index 41a94d2eb..c5492ab62 100644 --- a/hw/kdrive/trio/s3.h +++ b/hw/kdrive/trio/s3.h @@ -1097,15 +1097,22 @@ typedef struct _s3CardInfo { Bool need_sync; } S3CardInfo; -typedef struct _s3ScreenInfo { - CARD8 *cursor_base; /* pointer to cursor area */ +typedef struct _s3FbInfo { CARD8 *offscreen; /* pointer to offscreen area */ int offscreen_y; /* top y coordinate of offscreen area */ int offscreen_x; /* top x coordinate of offscreen area */ int offscreen_width; /* width of offscreen area */ int offscreen_height; /* height of offscreen area */ - S3Cursor cursor; S3Patterns patterns; + CARD32 bitmap_offset; + int accel_stride; + int accel_bpp; +} S3FBInfo; + +typedef struct _s3ScreenInfo { + CARD8 *cursor_base; /* pointer to cursor area */ + S3Cursor cursor; + S3FBInfo fb[1]; } S3ScreenInfo; #define LockS3(s3c) @@ -1135,8 +1142,8 @@ void s3DrawSync (ScreenPtr pScreen); void s3DrawDisable (ScreenPtr pScreen); void s3DrawFini (ScreenPtr pScreen); -void s3GetColors (ScreenPtr pScreen, int ndef, xColorItem *pdefs); -void s3PutColors (ScreenPtr pScreen, int ndef, xColorItem *pdefs); +void s3GetColors (ScreenPtr pScreen, int fb, int ndef, xColorItem *pdefs); +void s3PutColors (ScreenPtr pScreen, int fb, int ndef, xColorItem *pdefs); void S3InitCard (KdCardAttr *attr); diff --git a/hw/kdrive/trio/s3cmap.c b/hw/kdrive/trio/s3cmap.c index fd213869e..01035e8d7 100644 --- a/hw/kdrive/trio/s3cmap.c +++ b/hw/kdrive/trio/s3cmap.c @@ -26,7 +26,7 @@ #include "s3.h" void -s3GetColors (ScreenPtr pScreen, int ndef, xColorItem *pdefs) +s3GetColors (ScreenPtr pScreen, int fb, int ndef, xColorItem *pdefs) { KdScreenPriv(pScreen); s3CardInfo(pScreenPriv); @@ -47,7 +47,7 @@ s3GetColors (ScreenPtr pScreen, int ndef, xColorItem *pdefs) } void -s3PutColors (ScreenPtr pScreen, int ndef, xColorItem *pdefs) +s3PutColors (ScreenPtr pScreen, int fb, int ndef, xColorItem *pdefs) { KdScreenPriv(pScreen); s3CardInfo(pScreenPriv); diff --git a/hw/kdrive/trio/s3curs.c b/hw/kdrive/trio/s3curs.c index 2c17b341a..f67b77b4a 100644 --- a/hw/kdrive/trio/s3curs.c +++ b/hw/kdrive/trio/s3curs.c @@ -95,9 +95,9 @@ s3AllocCursorColors (ScreenPtr pScreen) CursorPtr pCursor = pCurPriv->pCursor; xColorItem sourceColor, maskColor; - KdAllocateCursorPixels (pScreen, pCursor, + KdAllocateCursorPixels (pScreen, 0, pCursor, &pCurPriv->source, &pCurPriv->mask); - switch (pScreenPriv->screen->bitsPerPixel) { + switch (pScreenPriv->screen->fb[0].bitsPerPixel) { case 4: pCurPriv->source |= pCurPriv->source << 4; pCurPriv->mask |= pCurPriv->mask << 4; |