summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorKeith Packard <keithp@keithp.com>2001-06-03 18:48:19 +0000
committerKeith Packard <keithp@keithp.com>2001-06-03 18:48:19 +0000
commit88ae32841d766c7d0df79ee25e1db62996d4ecb3 (patch)
treedc884d84c52ac66c90d9eebe0651bb5962dece73
parent14ed0c3d6d674df4edcbcd8840a7cea4b41a0673 (diff)
Add mach64 driver to Tiny-X
-rw-r--r--hw/kdrive/mach64/Imakefile15
-rw-r--r--hw/kdrive/mach64/mach64.c331
-rw-r--r--hw/kdrive/mach64/mach64.h522
-rw-r--r--hw/kdrive/mach64/mach64curs.c389
-rw-r--r--hw/kdrive/mach64/mach64draw.c410
-rw-r--r--hw/kdrive/mach64/mach64draw.h72
-rw-r--r--hw/kdrive/mach64/mach64stub.c58
-rw-r--r--hw/kdrive/src/kaa.c73
-rw-r--r--hw/kdrive/trident/trident.c6
-rw-r--r--hw/kdrive/trident/tridentdraw.c8
10 files changed, 1839 insertions, 45 deletions
diff --git a/hw/kdrive/mach64/Imakefile b/hw/kdrive/mach64/Imakefile
new file mode 100644
index 000000000..067db5110
--- /dev/null
+++ b/hw/kdrive/mach64/Imakefile
@@ -0,0 +1,15 @@
+XCOMM $XFree86: xc/programs/Xserver/hw/kdrive/mach64/Imakefile,v 1.6 2000/10/20 00:19:51 keithp Exp $
+KDRIVE=..
+#include "../Kdrive.tmpl"
+
+SRCS = mach64.c mach64draw.c mach64stub.c
+
+OBJS = mach64.o mach64draw.o mach64stub.o
+
+DEFINES = -DVESA /* -DUSE_PCI*/
+
+INCLUDES = -I. $(KDINCS) -I$(KDRIVE)/vesa
+
+NormalLibraryObjectRule()
+NormalLibraryTarget(mach64,$(OBJS))
+DependTarget()
diff --git a/hw/kdrive/mach64/mach64.c b/hw/kdrive/mach64/mach64.c
new file mode 100644
index 000000000..7abbf7bf5
--- /dev/null
+++ b/hw/kdrive/mach64/mach64.c
@@ -0,0 +1,331 @@
+/*
+ * Copyright © 2001 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.
+ */
+/* $XFree86: xc/programs/Xserver/hw/kdrive/mach64/mach64.c,v 1.16 2001/03/21 16:43:16 dawes Exp $ */
+
+#include "mach64.h"
+#include <sys/io.h>
+
+Bool
+mach64CardInit (KdCardInfo *card)
+{
+ Mach64CardInfo *mach64c;
+
+ mach64c = (Mach64CardInfo *) xalloc (sizeof (Mach64CardInfo));
+ if (!mach64c)
+ return FALSE;
+
+ mach64c->reg_base = (CARD8 *) KdMapDevice (MACH64_REG_BASE(card),
+ MACH64_REG_SIZE(card));
+
+ if (mach64c->reg_base)
+ {
+ KdSetMappedMode (MACH64_REG_BASE(card),
+ MACH64_REG_SIZE(card),
+ KD_MAPPED_MODE_REGISTERS);
+ }
+ mach64c->reg = (Reg *) (mach64c->reg_base + MACH64_REG_OFF(card));
+ mach64c->media_reg = (MediaReg *) (mach64c->reg_base + MACH64_MEDIA_REG_OFF(card));
+
+ if (!vesaInitialize (card, &mach64c->vesa))
+ {
+ xfree (mach64c);
+ return FALSE;
+ }
+
+ card->driver = mach64c;
+
+ return TRUE;
+}
+
+Bool
+mach64ScreenInit (KdScreenInfo *screen)
+{
+ Mach64CardInfo *mach64c = screen->card->driver;
+ Mach64ScreenInfo *mach64s;
+ int screen_size, memory;
+
+ mach64s = (Mach64ScreenInfo *) xalloc (sizeof (Mach64ScreenInfo));
+ if (!mach64s)
+ return FALSE;
+ memset (mach64s, '\0', sizeof (Mach64ScreenInfo));
+ if (!vesaScreenInitialize (screen, &mach64s->vesa))
+ {
+ xfree (mach64s);
+ return FALSE;
+ }
+ if (!mach64c->reg)
+ screen->dumb = TRUE;
+ if (mach64s->vesa.mapping != VESA_LINEAR)
+ screen->dumb = TRUE;
+ mach64s->screen = mach64s->vesa.fb;
+ memory = mach64s->vesa.fb_size;
+ screen_size = screen->fb[0].byteStride * screen->height;
+ if (mach64s->screen && memory >= screen_size + 2048)
+ {
+ memory -= 2048;
+ mach64s->cursor_base = mach64s->screen + memory - 2048;
+ }
+ else
+ mach64s->cursor_base = 0;
+ screen->softCursor = TRUE; /* XXX for now */
+ memory -= screen_size;
+ if (memory > screen->fb[0].byteStride)
+ {
+ mach64s->off_screen = mach64s->screen + screen_size;
+ mach64s->off_screen_size = memory;
+ }
+ else
+ {
+ mach64s->off_screen = 0;
+ mach64s->off_screen_size = 0;
+ }
+ screen->driver = mach64s;
+ return TRUE;
+}
+
+Bool
+mach64InitScreen (ScreenPtr pScreen)
+{
+ return vesaInitScreen (pScreen);
+}
+
+CARD32
+mach64ReadLCD (Reg *reg, int id)
+{
+ CARD32 LCD_INDEX;
+
+ LCD_INDEX = reg->LCD_INDEX & ~(0x3f);
+ reg->LCD_INDEX = (LCD_INDEX | id);
+ return reg->LCD_DATA;
+}
+
+void
+mach64WriteLCD (Reg *reg, int id, CARD32 data)
+{
+ CARD32 LCD_INDEX;
+
+ LCD_INDEX = reg->LCD_INDEX & ~(0x3f);
+ reg->LCD_INDEX = (LCD_INDEX | id);
+ reg->LCD_DATA = data;
+}
+
+void
+mach64Preserve (KdCardInfo *card)
+{
+ Mach64CardInfo *mach64c = card->driver;
+ Reg *reg = mach64c->reg;
+
+ vesaPreserve(card);
+ if (reg)
+ mach64c->save.POWER_MANAGEMENT = mach64ReadLCD (reg, 0x8);
+}
+
+void
+mach64SetMMIO (Mach64CardInfo *mach64c)
+{
+ if (mach64c->reg->GUI_STAT == 0xffffffff)
+ FatalError ("Mach64 REG not visible\n");
+}
+
+void
+mach64ResetMMIO (Mach64CardInfo *mach64c)
+{
+}
+
+Bool
+mach64Enable (ScreenPtr pScreen)
+{
+ KdScreenPriv(pScreen);
+ Mach64CardInfo *mach64c = pScreenPriv->card->driver;
+
+ if (!vesaEnable (pScreen))
+ return FALSE;
+
+ mach64SetMMIO (mach64c);
+ mach64DPMS (pScreen, KD_DPMS_NORMAL);
+ return TRUE;
+}
+
+void
+mach64Disable (ScreenPtr pScreen)
+{
+ vesaDisable (pScreen);
+}
+
+const CARD8 mach64DPMSModes[4] = {
+ 0x80, /* KD_DPMS_NORMAL */
+ 0x8c, /* KD_DPMS_STANDBY */
+ 0x8c, /* KD_DPMS_STANDBY */
+ 0x8c, /* KD_DPMS_STANDBY */
+/* 0xb0, /* KD_DPMS_SUSPEND */
+/* 0xbc, /* KD_DPMS_POWERDOWN */
+};
+
+Bool
+mach64DPMS (ScreenPtr pScreen, int mode)
+{
+ KdScreenPriv(pScreen);
+ Mach64CardInfo *mach64c = pScreenPriv->card->driver;
+ int hsync_off, vsync_off, blank;
+ CARD32 CRTC_GEN_CNTL;
+ CARD32 POWER_MANAGEMENT;
+ Reg *reg = mach64c->reg;
+
+ if (!reg)
+ return FALSE;
+
+ CRTC_GEN_CNTL = reg->CRTC_GEN_CNTL;
+ POWER_MANAGEMENT = mach64ReadLCD (reg, 8);
+
+ /*
+ * Select register mode
+ */
+ POWER_MANAGEMENT = (POWER_MANAGEMENT & ~(3 << 1)) | (1 << 1);
+ /*
+ * Switch back to ON mode
+ */
+ POWER_MANAGEMENT &= ~(1 << 28);
+ POWER_MANAGEMENT &= ~(1 << 29);
+
+ switch (mode) {
+ case KD_DPMS_NORMAL:
+ hsync_off = 0;
+ vsync_off = 0;
+ blank = 0;
+ break;
+ case KD_DPMS_STANDBY:
+ hsync_off = 1;
+ vsync_off = 0;
+ /*
+ * Standby
+ */
+ POWER_MANAGEMENT |= (1 << 28);
+ blank = 1;
+ break;
+ case KD_DPMS_SUSPEND:
+ hsync_off = 0;
+ vsync_off = 1;
+ blank = 1;
+ /*
+ * Suspend
+ */
+ POWER_MANAGEMENT |= (1 << 28);
+ break;
+ case KD_DPMS_POWERDOWN:
+ hsync_off = 1;
+ vsync_off = 1;
+ /*
+ * Suspend
+ */
+ POWER_MANAGEMENT |= (1 << 28);
+ blank = 1;
+ }
+
+
+ if (hsync_off)
+ CRTC_GEN_CNTL |= (1 << 2);
+ else
+ CRTC_GEN_CNTL &= ~(1 << 2);
+ if (vsync_off)
+ CRTC_GEN_CNTL |= (1 << 3);
+ else
+ CRTC_GEN_CNTL &= ~(1 << 3);
+ if (blank)
+ CRTC_GEN_CNTL |= (1 << 6);
+ else
+ CRTC_GEN_CNTL &= ~(1 << 6);
+ mach64WriteLCD (reg, 8, POWER_MANAGEMENT);
+
+ reg->CRTC_GEN_CNTL = CRTC_GEN_CNTL;
+ return TRUE;
+}
+
+void
+mach64Restore (KdCardInfo *card)
+{
+ Mach64CardInfo *mach64c = card->driver;
+ Reg *reg = mach64c->reg;
+
+ if (reg)
+ mach64WriteLCD (reg, 8, mach64c->save.POWER_MANAGEMENT);
+ mach64ResetMMIO (mach64c);
+ vesaRestore (card);
+}
+
+void
+mach64ScreenFini (KdScreenInfo *screen)
+{
+ Mach64ScreenInfo *mach64s = (Mach64ScreenInfo *) screen->driver;
+
+ vesaScreenFini (screen);
+ xfree (mach64s);
+ screen->driver = 0;
+}
+
+void
+mach64CardFini (KdCardInfo *card)
+{
+ Mach64CardInfo *mach64c = card->driver;
+
+ if (mach64c->reg_base)
+ {
+ KdUnmapDevice ((void *) mach64c->reg_base, MACH64_REG_SIZE(card));
+ KdResetMappedMode (MACH64_REG_BASE(card),
+ MACH64_REG_SIZE(card),
+ KD_MAPPED_MODE_REGISTERS);
+ }
+ vesaCardFini (card);
+}
+
+#define mach64CursorInit 0 /* initCursor */
+#define mach64CursorEnable 0 /* enableCursor */
+#define mach64CursorDisable 0 /* disableCursor */
+#define mach64CursorFini 0 /* finiCursor */
+#define mach64RecolorCursor 0 /* recolorCursor */
+
+KdCardFuncs mach64Funcs = {
+ mach64CardInit, /* cardinit */
+ mach64ScreenInit, /* scrinit */
+ mach64InitScreen, /* initScreen */
+ mach64Preserve, /* preserve */
+ mach64Enable, /* enable */
+ mach64DPMS, /* dpms */
+ mach64Disable, /* disable */
+ mach64Restore, /* restore */
+ mach64ScreenFini, /* scrfini */
+ mach64CardFini, /* cardfini */
+
+ mach64CursorInit, /* initCursor */
+ mach64CursorEnable, /* enableCursor */
+ mach64CursorDisable, /* disableCursor */
+ mach64CursorFini, /* finiCursor */
+ mach64RecolorCursor, /* recolorCursor */
+
+ mach64DrawInit, /* initAccel */
+ mach64DrawEnable, /* enableAccel */
+ mach64DrawSync, /* syncAccel */
+ mach64DrawDisable, /* disableAccel */
+ mach64DrawFini, /* finiAccel */
+
+ vesaGetColors, /* getColors */
+ vesaPutColors, /* putColors */
+};
diff --git a/hw/kdrive/mach64/mach64.h b/hw/kdrive/mach64/mach64.h
new file mode 100644
index 000000000..2f0c376e3
--- /dev/null
+++ b/hw/kdrive/mach64/mach64.h
@@ -0,0 +1,522 @@
+/*
+ * Id: mach64.h,v 1.2 1999/11/02 08:17:24 keithp Exp $
+ *
+ * Copyright © 2001 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.
+ */
+/* $XFree86: xc/programs/Xserver/hw/kdrive/mach64/mach64.h,v 1.9 2000/11/29 08:42:25 keithp Exp $ */
+
+#ifndef _MACH64_H_
+#define _MACH64_H_
+#include <vesa.h>
+
+/*
+ * offset from ioport beginning
+ */
+
+#define MACH64_REG_BASE(c) ((c)->attr.address[1])
+#define MACH64_REG_SIZE(c) (4096)
+
+#define MACH64_REG_OFF(c) (1024)
+#define MACH64_MEDIA_REG_OFF(c) (0)
+
+typedef volatile CARD8 VOL8;
+typedef volatile CARD16 VOL16;
+typedef volatile CARD32 VOL32;
+
+typedef struct _Reg {
+ VOL32 CRTC_H_TOTAL_DISP; /* 0x00 */
+ VOL32 CRTC_H_SYNC_STRT_WID; /* 0x01 */
+ VOL32 CRTC_V_TOTAL_DISP; /* 0x02 */
+ VOL32 CRTC_V_SYNC_STRT_WID; /* 0x03 */
+ VOL32 CRTC_VLINE_CRNT_VLINE; /* 0x04 */
+ VOL32 CRTC_OFF_PITCH; /* 0x05 */
+ VOL32 CRTC_INT_CNTL; /* 0x06 */
+ VOL32 CRTC_GEN_CNTL; /* 0x07 */
+ VOL32 DSP_CONFIG; /* 0x08 */
+ VOL32 DSP_ON_OFF; /* 0x09 */
+ VOL32 TIMER_CONFIG; /* 0x0a */
+ VOL32 MEM_BUF_CNTL; /* 0x0b */
+ VOL32 unused0; /* 0x0c */
+ VOL32 MEM_ADDR_CONFIG; /* 0x0d */
+ VOL32 CRT_TRAP; /* 0x0e */
+ VOL32 I2C_CNTL_0; /* 0x0f */
+ VOL32 OVR_CLR; /* 0x10 */
+ VOL32 OVR_WID_LEFT_RIGHT; /* 0x11 */
+ VOL32 OVR_WID_TOP_BOTTOM; /* 0x12 */
+ VOL32 VGA_DSP_CONFIG; /* 0x13 */
+ VOL32 VGA_DSP_ON_OFF; /* 0x14 */
+ VOL32 DSP2_CONFIG; /* 0x15 */
+ VOL32 DSP2_ON_OFF; /* 0x16 */
+ VOL32 CRTC2_OFF_PITCH; /* 0x17 */
+ VOL32 CUR_CLR0; /* 0x18 */
+ VOL32 CUR_CLR1; /* 0x19 */
+ VOL32 CUR_OFFSET; /* 0x1a */
+ VOL32 CUR_HORZ_VERT_POSN; /* 0x1b */
+ VOL32 CUR_HORZ_VERT_OFF; /* 0x1c */
+ VOL32 TV_OUT_INDEX; /* 0x1d */
+ VOL32 GP_IO; /* 0x1e */
+ VOL32 HW_DEBUG; /* 0x1f */
+ VOL32 SCRATCH_REG0; /* 0x20 */
+ VOL32 SCRATCH_REG1;
+ VOL32 SCRATCH_REG2;
+ VOL32 SCRATCH_REG3;
+ VOL32 CLOCK_CNTL;
+ VOL32 CONFIG_STAT1;
+ VOL32 CONFIG_STAT2;
+ VOL32 TV_OUT_DATA;
+ VOL32 BUS_CNTL; /* 0x28 */
+ VOL32 LCD_INDEX; /* 0x29 */
+ VOL32 LCD_DATA; /* 0x2a */
+ VOL32 EXT_MEM_CNTL;
+ VOL32 MEM_CNTL;
+ VOL32 MEM_VGA_WP_SEL;
+ VOL32 MEM_VGA_RP_SEL;
+ VOL32 I2C_CNTL_1;
+ VOL32 DAC_REGS; /* 0x30 */
+ VOL32 DAC_CNTL; /* 0x31 */
+ VOL32 unused_32;
+ VOL32 unused_33;
+ VOL32 GEN_TEST_CNTL; /* 0x34 */
+ VOL32 CUSTOM_MACRO_CNTL;
+ VOL32 unused36;
+ VOL32 CONFIG_CNTL;
+ VOL32 CONFIG_CHIP_ID;
+ VOL32 CONFIG_STAT0;
+ VOL32 CRC_SIG;
+ VOL32 unused_3b;
+ VOL32 unused_3c;
+ VOL32 unused_3d;
+ VOL32 unused_3e;
+ VOL32 unused_3f;
+ VOL32 DST_OFF_PITCH; /* 0x40 */
+ VOL32 DST_X;
+ VOL32 DST_Y;
+ VOL32 DST_Y_X;
+ VOL32 DST_WIDTH;
+ VOL32 DST_HEIGHT;
+ VOL32 DST_HEIGHT_WIDTH;
+ VOL32 DST_X_WIDTH;
+ VOL32 DST_BRES_LNTH;
+ VOL32 DST_BRES_ERR;
+ VOL32 DST_BRES_INC;
+ VOL32 DST_BRES_DEC;
+ VOL32 DST_CNTL;
+ VOL32 DST_Y_X_ALIAS;
+ VOL32 TRAIL_BRES_ERR;
+ VOL32 TRAIL_BRES_INC;
+ VOL32 TRAIL_BRES_DEC;
+ VOL32 LEAD_BRES_LNTH;
+ VOL32 Z_OFF_PITCH;
+ VOL32 Z_CNTL;
+ VOL32 ALPHA_TST_CNTL;
+ VOL32 unused55;
+ VOL32 SECONDARY_STW_EXP;
+ VOL32 SECONDARY_S_X_INC;
+ VOL32 SECONDARY_S_Y_INC;
+ VOL32 SECONDARY_S_START;
+ VOL32 SECONDARY_W_X_INC;
+ VOL32 SECONDARY_W_Y_INC;
+ VOL32 SECONDARY_W_START;
+ VOL32 SECONDARY_T_X_INC;
+ VOL32 SECONDARY_T_Y_INC;
+ VOL32 SECONDARY_T_START;
+ VOL32 SRC_OFF_PITCH;
+ VOL32 SRC_X;
+ VOL32 SRC_Y;
+ VOL32 SRC_Y_X;
+ VOL32 SRC_WIDTH1;
+ VOL32 SRC_HEIGHT1;
+ VOL32 SRC_HEIGHT1_WIDTH1;
+ VOL32 SRC_X_START;
+ VOL32 SRC_Y_START;
+ VOL32 SRC_Y_X_START;
+ VOL32 SRC_WIDTH2;
+ VOL32 SRC_HEIGHT2;
+ VOL32 SRC_HEIGHT2_WIDTH2;
+ VOL32 SRC_CNTL;
+ VOL32 unused6e;
+ VOL32 unused6f;
+ union {
+ struct {
+ VOL32 SCALE_OFF; /* 0x70 */
+ VOL32 unused71;
+ VOL32 unused72;
+ VOL32 unused73;
+ VOL32 unused74;
+ VOL32 unused75;
+ VOL32 unused76;
+ VOL32 SCALE_WIDTH;
+ VOL32 SCALE_HEIGHT;
+ VOL32 unused79;
+ VOL32 unused7a;
+ VOL32 SCALE_PITCH;
+ VOL32 SCALE_X_INC;
+ VOL32 SCALE_Y_INC;
+ VOL32 SCALE_VACC;
+ VOL32 SCALE_3D_CNTL; /* 0x7f */
+ } scaler;
+ struct {
+ VOL32 TEX_0_OFF; /* 0x70 */
+ VOL32 TEX_1_OFF;
+ VOL32 TEX_2_OFF;
+ VOL32 TEX_3_OFF;
+ VOL32 TEX_4_OFF;
+ VOL32 TEX_5_OFF;
+ VOL32 TEX_6_OFF;
+ VOL32 TEX_7_OFF;
+ VOL32 TEX_8_OFF;
+ VOL32 TEX_9_OFF;
+ VOL32 TEX_10_OFF;
+ VOL32 S_Y_INC;
+ VOL32 RED_X_INC;
+ VOL32 GREEN_X_INC; /* 0x7d */
+ VOL32 unused7e;
+ VOL32 unused7f;
+ } texture;
+ } u;
+ VOL32 HOST_DATA[16]; /* 0x80 */
+ VOL32 HOST_CNTL; /* 0x90 */
+ VOL32 BM_HOSTDATA; /* 0x91 */
+ VOL32 BM_ADDR; /* 0x92 */
+ VOL32 BM_GUI_TABLE_CMD; /* 0x93 */
+ VOL32 unused94; /* 0x94 */
+ VOL32 unused95; /* 0x95 */
+ VOL32 unused96; /* 0x96 */
+ VOL32 FOG_TABLE_INDEX; /* 0x97 */
+ VOL32 FOG_TABLE_DATA[8]; /* 0x98 */
+ VOL32 PAT_REG0; /* 0xa0 */
+ VOL32 PAT_REG1;
+ VOL32 PAT_CNTL;
+ VOL32 unused_0a3;
+ VOL32 unused_0a4;
+ VOL32 unused_0a5;
+ VOL32 unused_0a6;
+ VOL32 unused_0a7;
+ VOL32 SC_LEFT;
+ VOL32 SC_RIGHT;
+ VOL32 SC_LEFT_RIGHT;
+ VOL32 SC_TOP;
+ VOL32 SC_BOTTOM;
+ VOL32 SC_TOP_BOTTOM;
+ VOL32 USR1_DST_OFF_PITCH;
+ VOL32 USR2_DST_OFF_PITCH;
+ VOL32 DP_BKGD_CLR; /* 0xb0 */
+ VOL32 DP_FRGD_CLR;
+ VOL32 DP_WRITE_MSK;
+ VOL32 unused_0b3;
+ VOL32 DP_PIX_WIDTH;
+ VOL32 DP_MIX;
+ VOL32 DP_SRC;
+ VOL32 DP_FRGD_CLR_MIX;
+ VOL32 DP_FRGD_BKGD_CLR;
+ VOL32 unused_0b9;
+ VOL32 DST_X_Y;
+ VOL32 DST_WIDTH_HEIGHT;
+ VOL32 USR_DST_PITCH;
+ VOL32 unused_0bd;
+ VOL32 DP_SET_GUI_ENGINE2;
+ VOL32 DP_SET_GUI_ENGINE;
+ VOL32 CLR_CMP_CLR; /* 0xc0 */
+ VOL32 CLR_CMP_MSK;
+ VOL32 CLR_CMP_CNTL;
+ VOL32 unused_0c3;
+ VOL32 FIFO_STAT;
+ VOL32 unused_0c5;
+ VOL32 unused_0c6;
+ VOL32 unused_0c7;
+ VOL32 unused_0c8;
+ VOL32 unused_0c9;
+ VOL32 unused_0ca;
+ VOL32 unused_0cb;
+ VOL32 GUI_TRAJ_CNTL;
+ VOL32 unused_0cd;
+ VOL32 GUI_STAT;
+ VOL32 unused_0cf;
+ VOL32 TEX_PALETTE_INDEX;
+ VOL32 STW_EXP;
+ VOL32 LOG_MAX_INC;
+ VOL32 S_X_INC;
+ VOL32 S_Y_INC_2_SCALE_PITCH;
+ VOL32 S_START;
+ VOL32 W_X_INC;
+ VOL32 W_Y_INC;
+ VOL32 W_START;
+ VOL32 T_X_INC;
+ VOL32 T_Y_INC_SECONDARY_SCALE_PITCH;
+ VOL32 T_START;
+ VOL32 TEX_SIZE_PITCH;
+ VOL32 TEX_CNTL;
+ VOL32 SECONDARY_TEX_OFFSET_SECONDARY_SCALE_OFF;
+ VOL32 TEX_PALETTE;
+ VOL32 SCALE_PITCH_BOTH; /* 0xe0 */
+ VOL32 SECONDARY_SCALE_OFF_ACC;
+ VOL32 SCALE_OFF_ACC;
+ VOL32 SCALE_DST_Y_X;
+ VOL32 unused_0e4;
+ VOL32 unused_0e5;
+ VOL32 COMPOSITE_SHADOW_ID;
+ VOL32 SECONDARY_SCALE_X_INC_SPECULAR_RED_X_INC;
+ VOL32 SPECULAR_RED_Y_INC;
+ VOL32 SPECULAR_RED_START_SECONDARY_SCALE_HACC;;
+ VOL32 SPECULAR_GREEN_X_INC;
+ VOL32 SPECULAR_GREEN_Y_INC;
+ VOL32 SPECULAR_GREEN_START;
+ VOL32 SPECULAR_BLUE_X_INC;
+ VOL32 SPECULAR_BLUE_Y_INC;
+ VOL32 SPECULAR_BLUE_START;
+ VOL32 RED_X_INC_SCALE_X_INC;
+ VOL32 RED_Y_INC;
+ VOL32 RED_START_SCALE_HACC;
+ VOL32 GREEN_X_INC_SCALE_Y_INC;
+ VOL32 GREEN_Y_INC_SECONDARY_SCALE_Y_INC;
+ VOL32 GREEN_START_SECONDARY_SCALE_VACC;
+ VOL32 BLUE_X_INC;
+ VOL32 BLUE_Y_INC;
+ VOL32 BLUE_START;
+ VOL32 Z_X_INC;
+ VOL32 Z_Y_INC;
+ VOL32 Z_START;
+ VOL32 ALPHA_X_INC;
+ VOL32 FOG_X_INC;
+ VOL32 ALPHA_Y_INC;
+ VOL32 FOG_Y_INC;
+ VOL32 ALPHA_START;
+ VOL32 FOG_START;
+ VOL32 unused_0ff;
+} Reg; /* 0x100 */
+
+#define DST_X_DIR (1 << 0)
+#define DST_Y_DIR (1 << 1)
+#define DST_Y_MAJOR (1 << 2)
+#define DST_X_TILE (1 << 3)
+#define DST_Y_TILE (1 << 4)
+#define DST_LAST_PEL (1 << 5)
+#define DST_POLYGON_EN (1 << 6)
+#define DST_24_ROT_EN (1 << 7)
+#define DST_24_ROT(n) ((n) << 8)
+#define DST_BRES_ZERO (1 << 11)
+#define DST_POLYGON_RTEDGE_DIS (1 << 12)
+#define TRAIL_X_DIR (1 << 13)
+#define TRAP_FILL_DIR (1 << 14)
+#define TRAIL_BRES_SIGN (1 << 15)
+#define SRC_PATT_EN (1 << 16)
+#define SRC_PATT_ROT_EN (1 << 17)
+#define SRC_LINEAR_EN (1 << 18)
+#define SRC_BYTE_ALIGN (1 << 19)
+#define SRC_LINE_X_DIR (1 << 20)
+#define SRC_8x8x8_BRUSH (1 << 21)
+#define FAST_FILL_EN (1 << 22)
+#define SRC_TRACK_DST (1 << 23)
+#define PAT_MONO_EN (1 << 24)
+#define PAT_CLR_4x2_EN (1 << 25)
+#define PAT_CLR_8x1_EN (1 << 26)
+#define HOST_BYTE_ALIGN (1 << 28)
+#define HOST_BIG_ENDIAN_EN (1 << 29)
+
+typedef struct _MediaReg {
+ VOL32 OVERLAY_Y_X_START; /* 0x100 */
+ VOL32 OVERLAY_Y_X_END;
+ VOL32 OVERLAY_VIDEO_KEY_CLR;
+ VOL32 OVERLAY_VIDEO_KEY_MSK;
+ VOL32 OVERLAY_GRAPHICS_KEY_CLR;
+ VOL32 OVERLAY_GRAPHICS_KEY_MSK;
+ VOL32 OVERLAY_KEY_CNTL;
+ VOL32 unused_107;
+ VOL32 OVERLAY_SCALE_INC;
+ VOL32 OVERLAY_SCALE_CNTL;
+ VOL32 SCALER_HEIGHT_WIDTH;
+ VOL32 SCALER_TEST;
+ VOL32 unused_10c;
+ VOL32 SCALER_BUF0_OFFSET;
+ VOL32 SCALER_BUF1_OFFSET;
+ VOL32 SCALER_BUF_PITCH;
+ VOL32 CAPTURE_START_END; /* 0x110 */
+ VOL32 CAPTURE_X_WIDTH;
+ VOL32 VIDEO_FORMAT;
+ VOL32 VBI_START_END;
+ VOL32 CAPTURE_CONFIG;
+ VOL32 TRIG_CNTL;
+ VOL32 OVERLAY_EXCLUSIVE_HORZ;
+ VOL32 OVERLAY_EXCLUSIVE_VERT;
+ VOL32 VBI_WIDTH;
+ VOL32 CAPTURE_DEBUG;
+ VOL32 VIDEO_SYNC_TEST;
+ VOL32 unused_11b;
+ VOL32 SNAPSHOT_VH_COUNTS;
+ VOL32 SNAPSHOT_F_COUNT;
+ VOL32 N_VIF_COUNT;
+ VOL32 SNAPSHOT_VIF_COUNT;
+ VOL32 CAPTURE_BUF0_OFFSET; /* 0x120 */
+ VOL32 CAPTURE_BUF1_OFFSET;
+ VOL32 ONESHOT_BUF_OFFSET;
+ VOL32 unused_123;
+ VOL32 unused_124;
+ VOL32 unused_125;
+ VOL32 unused_126;
+ VOL32 unused_127;
+ VOL32 unused_128;
+ VOL32 unused_129;
+ VOL32 unused_12a;
+ VOL32 unused_12b;
+ VOL32 SNAPSHOT2_VH_COUNTS;
+ VOL32 SNAPSHOT2_F_COUNT;
+ VOL32 N_VIF2_COUNT;
+ VOL32 SNAPSHOT2_VIF_COUNT;
+ VOL32 MPP_CONFIG; /* 0x130 */
+ VOL32 MPP_STROBE_SEQ;
+ VOL32 MPP_ADDR;
+ VOL32 MPP_DATA;
+ VOL32 unused_134;
+ VOL32 unused_135;
+ VOL32 unused_136;
+ VOL32 unused_137;
+ VOL32 unused_138;
+ VOL32 unused_139;
+ VOL32 unused_13a;
+ VOL32 unused_13b;
+ VOL32 unused_13c;
+ VOL32 unused_13d;
+ VOL32 unused_13e;
+ VOL32 unused_13f;
+ VOL32 TVO_CNTL; /* 0x140 */
+ VOL32 unused_141[15];
+ VOL32 unused_150; /* 0x150 */
+ VOL32 CRT_HORZ_VERT_LOAD;
+ VOL32 AGP_BASE_AGP_CNTL;
+ VOL32 SCALER_COLOUR_CNTL;
+ VOL32 SCALER_H_COEFF0;
+ VOL32 SCALER_H_COEFF1;
+ VOL32 SCALER_H_COEFF2;
+ VOL32 SCALER_H_COEFF3;
+ VOL32 SCALER_H_COEFF4;
+ VOL32 unused_15a;
+ VOL32 unused_15b;
+ VOL32 GUI_CMDFIFO_DEBUG;
+ VOL32 GUI_CMDFIFO_DATA;
+ VOL32 GUI_CNTL;
+ VOL32 unused_15f;
+ VOL32 BM_FRAME_BUF_OFFSET; /* 0x160 */
+ VOL32 BM_SYSTEM_MEM_ADDR;
+ VOL32 BM_COMMAND;
+ VOL32 BM_STATUS;
+ VOL32 unused_164[10];
+ VOL32 BM_GUI_TABLE;
+ VOL32 BM_SYSTEM_TABLE;
+ VOL32 unused_170[5]; /* 0x170 */
+ VOL32 SCALER_BUF0_OFFSET_U;
+ VOL32 SCALER_BUF0_OFFSET_V;
+ VOL32 SCALER_BUF1_OFFSET_U;
+ VOL32 SCALER_BUF1_OFFSET_V;
+ VOL32 unused_179[7];
+ VOL32 unused_180[16]; /* 0x180 */
+ VOL32 setup_engine[0x40]; /* 0x190 */
+ VOL32 dvd_subpicture[0x30]; /* 0x1d0 */
+} MediaReg;
+
+#define TRI_XY(x,y) ((y) << 16 | (x))
+
+typedef struct _mach64Save {
+ CARD32 POWER_MANAGEMENT;
+} Mach64Save;
+
+typedef struct _mach64CardInfo {
+ VesaCardPrivRec vesa;
+ CARD8 *reg_base;
+ Reg *reg;
+ MediaReg *media_reg;
+ Mach64Save save;
+} Mach64CardInfo;
+
+#define getMach64CardInfo(kd) ((Mach64CardInfo *) ((kd)->card->driver))
+#define mach64CardInfo(kd) Mach64CardInfo *mach64c = getMach64CardInfo(kd)
+
+typedef struct _mach64Cursor {
+ int width, height;
+ int xhot, yhot;
+ Bool has_cursor;
+ CursorPtr pCursor;
+ Pixel source, mask;
+} Mach64Cursor;
+
+#define MACH64_CURSOR_WIDTH 64
+#define MACH64_CURSOR_HEIGHT 64
+
+typedef struct _mach64ScreenInfo {
+ VesaScreenPrivRec vesa;
+ CARD8 *cursor_base;
+ CARD8 *screen;
+ CARD8 *off_screen;
+ int off_screen_size;
+ CARD32 DP_PIX_WIDTH;
+ CARD32 DP_SET_GUI_ENGINE;
+ CARD32 USR1_DST_OFF_PITCH;
+ Bool bpp24;
+ Mach64Cursor cursor;
+} Mach64ScreenInfo;
+
+#define getMach64ScreenInfo(kd) ((Mach64ScreenInfo *) ((kd)->screen->driver))
+#define mach64ScreenInfo(kd) Mach64ScreenInfo *mach64s = getMach64ScreenInfo(kd)
+
+CARD32
+mach64ReadLCD (Reg *reg, int id);
+
+void
+mach64WriteLCD (Reg *reg, int id, CARD32 data);
+
+Bool
+mach64DrawInit (ScreenPtr pScreen);
+
+void
+mach64DrawEnable (ScreenPtr pScreen);
+
+void
+mach64DrawSync (ScreenPtr pScreen);
+
+void
+mach64DrawDisable (ScreenPtr pScreen);
+
+void
+mach64DrawFini (ScreenPtr pScreen);
+
+CARD8
+mach64ReadIndex (Mach64CardInfo *mach64c, CARD16 port, CARD8 index);
+
+void
+mach64WriteIndex (Mach64CardInfo *mach64c, CARD16 port, CARD8 index, CARD8 value);
+
+Bool
+mach64CursorInit (ScreenPtr pScreen);
+
+void
+mach64CursorEnable (ScreenPtr pScreen);
+
+void
+mach64CursorDisable (ScreenPtr pScreen);
+
+void
+mach64CursorFini (ScreenPtr pScreen);
+
+void
+mach64RecolorCursor (ScreenPtr pScreen, int ndef, xColorItem *pdef);
+
+extern KdCardFuncs mach64Funcs;
+
+#endif /* _MACH64_H_ */
diff --git a/hw/kdrive/mach64/mach64curs.c b/hw/kdrive/mach64/mach64curs.c
new file mode 100644
index 000000000..d34b38bf6
--- /dev/null
+++ b/hw/kdrive/mach64/mach64curs.c
@@ -0,0 +1,389 @@
+/*
+ * Id: tridentcurs.c,v 1.1 1999/11/02 03:54:47 keithp Exp $
+ *
+ * Copyright © 1999 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.
+ */
+/* $XFree86: xc/programs/Xserver/hw/kdrive/trident/tridentcurs.c,v 1.6 2000/09/03 05:11:20 keithp Exp $ */
+
+#include "trident.h"
+#include "cursorstr.h"
+
+#define SetupCursor(s) KdScreenPriv(s); \
+ tridentCardInfo(pScreenPriv); \
+ tridentScreenInfo(pScreenPriv); \
+ TridentCursor *pCurPriv = &tridents->cursor
+
+static void
+_tridentMoveCursor (ScreenPtr pScreen, int x, int y)
+{
+ SetupCursor(pScreen);
+ CARD8 xlow, xhigh, ylow, yhigh;
+ CARD8 xoff, yoff;
+
+ x -= pCurPriv->xhot;
+ xoff = 0;
+ if (x < 0)
+ {
+ xoff = -x;
+ x = 0;
+ }
+ y -= pCurPriv->yhot;
+ yoff = 0;
+ if (y < 0)
+ {
+ yoff = -y;
+ y = 0;
+ }
+ xlow = (CARD8) x;
+ xhigh = (CARD8) (x >> 8);
+ ylow = (CARD8) y;
+ yhigh = (CARD8) (y >> 8);
+
+
+ /* This is the recommended order to move the cursor */
+
+ tridentWriteIndex (tridentc, 0x3d4, 0x41, xhigh);
+ tridentWriteIndex (tridentc, 0x3d4, 0x40, xlow);
+ tridentWriteIndex (tridentc, 0x3d4, 0x42, ylow);
+ tridentWriteIndex (tridentc, 0x3d4, 0x46, xoff);
+ tridentWriteIndex (tridentc, 0x3d4, 0x47, yoff);
+ tridentWriteIndex (tridentc, 0x3d4, 0x43, yhigh);
+}
+
+static void
+tridentMoveCursor (ScreenPtr pScreen, int x, int y)
+{
+ SetupCursor (pScreen);
+
+ if (!pCurPriv->has_cursor)
+ return;
+
+ if (!pScreenPriv->enabled)
+ return;
+
+ _tridentMoveCursor (pScreen, x, y);
+}
+
+static void
+tridentAllocCursorColors (ScreenPtr pScreen)
+{
+ SetupCursor (pScreen);
+ CursorPtr pCursor = pCurPriv->pCursor;
+
+ 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;
+ }
+}
+
+static void
+tridentSetCursorColors (ScreenPtr pScreen)
+{
+ SetupCursor (pScreen);
+ CursorPtr pCursor = pCurPriv->pCursor;
+ CARD32 fg, bg;
+
+ fg = pCurPriv->source;
+ bg = pCurPriv->mask;
+ tridentWriteIndex (tridentc, 0x3d4, 0x48, fg);
+ tridentWriteIndex (tridentc, 0x3d4, 0x49, fg >> 8);
+ tridentWriteIndex (tridentc, 0x3d4, 0x4a, fg >> 16);
+
+ tridentWriteIndex (tridentc, 0x3d4, 0x4c, bg);
+ tridentWriteIndex (tridentc, 0x3d4, 0x4d, bg >> 8);
+ tridentWriteIndex (tridentc, 0x3d4, 0x4e, bg >> 16);
+}
+
+void
+tridentRecolorCursor (ScreenPtr pScreen, int ndef, xColorItem *pdef)
+{
+ SetupCursor (pScreen);
+ CursorPtr pCursor = pCurPriv->pCursor;
+ xColorItem sourceColor, maskColor;
+
+ if (!pCurPriv->has_cursor || !pCursor)
+ return;
+
+ if (!pScreenPriv->enabled)
+ return;
+
+ if (pdef)
+ {
+ while (ndef)
+ {
+ if (pdef->pixel == pCurPriv->source ||
+ pdef->pixel == pCurPriv->mask)
+ break;
+ ndef--;
+ }
+ if (!ndef)
+ return;
+ }
+ tridentAllocCursorColors (pScreen);
+ tridentSetCursorColors (pScreen);
+}
+
+#define InvertBits32(v) { \
+ v = ((v & 0x55555555) << 1) | ((v >> 1) & 0x55555555); \
+ v = ((v & 0x33333333) << 2) | ((v >> 2) & 0x33333333); \
+ v = ((v & 0x0f0f0f0f) << 4) | ((v >> 4) & 0x0f0f0f0f); \
+}
+
+static void
+tridentLoadCursor (ScreenPtr pScreen, int x, int y)
+{
+ SetupCursor(pScreen);
+ CursorPtr pCursor = pCurPriv->pCursor;
+ CursorBitsPtr bits = pCursor->bits;
+ int w, h;
+ CARD32 *ram, *msk, *mskLine, *src, *srcLine;
+ int i, j;
+ int cursor_address;
+ int lwsrc;
+ unsigned char ramdac_control_;
+ CARD32 offset;
+
+ /*
+ * Allocate new colors
+ */
+ tridentAllocCursorColors (pScreen);
+
+ pCurPriv->pCursor = pCursor;
+ pCurPriv->xhot = pCursor->bits->xhot;
+ pCurPriv->yhot = pCursor->bits->yhot;
+
+ /*
+ * Stick new image into cursor memory
+ */
+ ram = (CARD32 *) tridents->cursor_base;
+ mskLine = (CARD32 *) bits->mask;
+ srcLine = (CARD32 *) bits->source;
+
+ h = bits->height;
+ if (h > TRIDENT_CURSOR_HEIGHT)
+ h = TRIDENT_CURSOR_HEIGHT;
+
+ lwsrc = BitmapBytePad(bits->width) / 4; /* words per line */
+
+ for (i = 0; i < TRIDENT_CURSOR_HEIGHT; i++) {
+ msk = mskLine;
+ src = srcLine;
+ mskLine += lwsrc;
+ srcLine += lwsrc;
+ for (j = 0; j < TRIDENT_CURSOR_WIDTH / 32; j++) {
+
+ CARD32 m, s;
+
+#if 1
+ if (i < h && j < lwsrc)
+ {
+ m = *msk++;
+ s = *src++;
+ InvertBits32(m);
+ InvertBits32(s);
+ }
+ else
+ {
+ m = 0;
+ s = 0;
+ }
+#endif
+ *ram++ = m;
+ *ram++ = s;
+ }
+ }
+
+ /* Set address for cursor bits */
+ offset = tridents->cursor_base - (CARD8 *) tridents->screen;
+ offset >>= 10;
+ tridentWriteIndex (tridentc, 0x3d4, 0x44, (CARD8) (offset & 0xff));
+ tridentWriteIndex (tridentc, 0x3d4, 0x45, (CARD8) (offset >> 8));
+
+ /* Set new color */
+ tridentSetCursorColors (pScreen);
+
+ /* Enable the cursor */
+ tridentWriteIndex (tridentc, 0x3d4, 0x50, 0xc1);
+
+ /* Move to new position */
+ tridentMoveCursor (pScreen, x, y);
+}
+
+static void
+tridentUnloadCursor (ScreenPtr pScreen)
+{
+ SetupCursor (pScreen);
+
+ /* Disable cursor */
+ tridentWriteIndex (tridentc, 0x3d4, 0x50, 0);
+}
+
+static Bool
+tridentRealizeCursor (ScreenPtr pScreen, CursorPtr pCursor)
+{
+ SetupCursor(pScreen);
+
+ if (!pScreenPriv->enabled)
+ return TRUE;
+
+ /* miRecolorCursor does this */
+ if (pCurPriv->pCursor == pCursor)
+ {
+ if (pCursor)
+ {
+ int x, y;
+
+ miPointerPosition (&x, &y);
+ tridentLoadCursor (pScreen, x, y);
+ }
+ }
+ return TRUE;
+}
+
+static Bool
+tridentUnrealizeCursor (ScreenPtr pScreen, CursorPtr pCursor)
+{
+ return TRUE;
+}
+
+static void
+tridentSetCursor (ScreenPtr pScreen, CursorPtr pCursor, int x, int y)
+{
+ SetupCursor(pScreen);
+
+ pCurPriv->pCursor = pCursor;
+
+ if (!pScreenPriv->enabled)
+ return;
+
+ if (pCursor)
+ tridentLoadCursor (pScreen, x, y);
+ else
+ tridentUnloadCursor (pScreen);
+}
+
+miPointerSpriteFuncRec tridentPointerSpriteFuncs = {
+ tridentRealizeCursor,
+ tridentUnrealizeCursor,
+ tridentSetCursor,
+ tridentMoveCursor,
+};
+
+static void
+tridentQueryBestSize (int class,
+ unsigned short *pwidth, unsigned short *pheight,
+ ScreenPtr pScreen)
+{
+ SetupCursor (pScreen);
+
+ switch (class)
+ {
+ case CursorShape:
+ if (*pwidth > pCurPriv->width)
+ *pwidth = pCurPriv->width;
+ if (*pheight > pCurPriv->height)
+ *pheight = pCurPriv->height;
+ if (*pwidth > pScreen->width)
+ *pwidth = pScreen->width;
+ if (*pheight > pScreen->height)
+ *pheight = pScreen->height;
+ break;
+ default:
+ fbQueryBestSize (class, pwidth, pheight, pScreen);
+ break;
+ }
+}
+
+Bool
+tridentCursorInit (ScreenPtr pScreen)
+{
+ SetupCursor (pScreen);
+
+ if (!tridents->cursor_base)
+ {
+ pCurPriv->has_cursor = FALSE;
+ return FALSE;
+ }
+
+ pCurPriv->width = TRIDENT_CURSOR_WIDTH;
+ pCurPriv->height= TRIDENT_CURSOR_HEIGHT;
+ pScreen->QueryBestSize = tridentQueryBestSize;
+ miPointerInitialize (pScreen,
+ &tridentPointerSpriteFuncs,
+ &kdPointerScreenFuncs,
+ FALSE);
+ pCurPriv->has_cursor = TRUE;
+ pCurPriv->pCursor = NULL;
+ return TRUE;
+}
+
+void
+tridentCursorEnable (ScreenPtr pScreen)
+{
+ SetupCursor (pScreen);
+
+ if (pCurPriv->has_cursor)
+ {
+ if (pCurPriv->pCursor)
+ {
+ int x, y;
+
+ miPointerPosition (&x, &y);
+ tridentLoadCursor (pScreen, x, y);
+ }
+ else
+ tridentUnloadCursor (pScreen);
+ }
+}
+
+void
+tridentCursorDisable (ScreenPtr pScreen)
+{
+ SetupCursor (pScreen);
+
+ if (!pScreenPriv->enabled)
+ return;
+
+ if (pCurPriv->has_cursor)
+ {
+ if (pCurPriv->pCursor)
+ {
+ tridentUnloadCursor (pScreen);
+ }
+ }
+}
+
+void
+tridentCursorFini (ScreenPtr pScreen)
+{
+ SetupCursor (pScreen);
+
+ pCurPriv->pCursor = NULL;
+}
diff --git a/hw/kdrive/mach64/mach64draw.c b/hw/kdrive/mach64/mach64draw.c
new file mode 100644
index 000000000..e248dabdd
--- /dev/null
+++ b/hw/kdrive/mach64/mach64draw.c
@@ -0,0 +1,410 @@
+/*
+ * Id: mach64draw.c,v 1.1 1999/11/02 03:54:47 keithp Exp $
+ *
+ * Copyright © 1999 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.
+ */
+/* $XFree86: xc/programs/Xserver/hw/kdrive/mach64/mach64draw.c,v 1.9 2001/05/30 15:36:25 keithp Exp $ */
+
+#include "mach64.h"
+#include "mach64draw.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"
+#include "picturestr.h"
+
+CARD8 mach64Rop[16] = {
+ /* GXclear */ 0x01, /* 0 */
+ /* GXand */ 0x0c, /* src AND dst */
+ /* GXandReverse */ 0x0d, /* src AND NOT dst */
+ /* GXcopy */ 0x07, /* src */
+ /* GXandInverted*/ 0x0e, /* NOT src AND dst */
+ /* GXnoop */ 0x03, /* dst */
+ /* GXxor */ 0x05, /* src XOR dst */
+ /* GXor */ 0x0b, /* src OR dst */
+ /* GXnor */ 0x0f, /* NOT src AND NOT dst */
+ /* GXequiv */ 0x06, /* NOT src XOR dst */
+ /* GXinvert */ 0x00, /* NOT dst */
+ /* GXorReverse */ 0x0a, /* src OR NOT dst */
+ /* GXcopyInverted*/ 0x04, /* NOT src */
+ /* GXorInverted */ 0x09, /* NOT src OR dst */
+ /* GXnand */ 0x08, /* NOT src OR NOT dst */
+ /* GXset */ 0x02, /* 1 */
+};
+
+#define MACH64_DRAW_COMBO_SOLID 0x1
+#define MACH64_DRAW_COMBO_COPY 0x8
+
+static Reg *reg;
+static CARD32 cmd;
+static CARD32 avail;
+static CARD32 triple;
+static CARD32 combo;
+
+#define IDX(reg,n) (&(reg)->n - &(reg)->CRTC_H_TOTAL_DISP)
+
+static void
+WAIT_AVAIL(Reg *reg, int n)
+{
+ if (avail < n)
+ {
+ while ((avail = ((reg->GUI_STAT) >> 16) & 0x3ff) < n)
+ ;
+ }
+ avail -= n;
+}
+
+static void
+WAIT_IDLE (Reg *reg)
+{
+ while (reg->GUI_STAT & 1)
+ ;
+}
+
+#define MACH64_XY(x,y) (((x) & 0x7fff) | (((y) & 0x7fff) << 16))
+#define MACH64_YX(x,y) (((y) & 0x7fff) | (((x) & 0x7fff) << 16))
+
+static void
+mach64Setup (ScreenPtr pScreen, CARD32 combo, int wait)
+{
+ KdScreenPriv(pScreen);
+ mach64ScreenInfo(pScreenPriv);
+ mach64CardInfo(pScreenPriv);
+ reg = mach64c->reg;
+ triple = mach64s->bpp24;
+
+ avail = 0;
+ WAIT_AVAIL(reg, wait + 3);
+ reg->DP_PIX_WIDTH = mach64s->DP_PIX_WIDTH;
+ reg->USR1_DST_OFF_PITCH = mach64s->USR1_DST_OFF_PITCH;
+ reg->DP_SET_GUI_ENGINE = mach64s->DP_SET_GUI_ENGINE | (combo << 20);
+}
+
+Bool
+mach64PrepareSolid (DrawablePtr pDrawable,
+ int alu,
+ Pixel pm,
+ Pixel fg)
+{
+ mach64Setup (pDrawable->pScreen, 1, 3);
+ reg->DP_MIX = (mach64Rop[alu] << 16) | 0;
+ reg->DP_WRITE_MSK = pm;
+ reg->DP_FRGD_CLR = fg;
+ return TRUE;
+}
+
+void
+mach64Solid (int x1, int y1, int x2, int y2)
+{
+ if (triple)
+ {
+ CARD32 traj;
+
+ x1 *= 3;
+ x2 *= 3;
+
+ traj = (DST_X_DIR |
+ DST_Y_DIR |
+ DST_24_ROT_EN |
+ DST_24_ROT((x1 / 4) % 6));
+ WAIT_AVAIL (reg, 1);
+ reg->GUI_TRAJ_CNTL = traj;
+ }
+ WAIT_AVAIL(reg,2);
+ reg->DST_X_Y = MACH64_XY(x1,y1);
+ reg->DST_WIDTH_HEIGHT = MACH64_XY(x2-x1,y2-y1);
+}
+
+void
+mach64DoneSolid (void)
+{
+}
+
+static int copyDx;
+static int copyDy;
+
+Bool
+mach64PrepareCopy (DrawablePtr pSrcDrawable,
+ DrawablePtr pDstDrawable,
+ int dx,
+ int dy,
+ int alu,
+ Pixel pm)
+{
+ CARD32 combo = 8;
+
+ if ((copyDx = dx) > 0)
+ combo |= 1;
+ if ((copyDy = dy) > 0)
+ combo |= 2;
+ mach64Setup (pDstDrawable->pScreen, combo, 2);
+ reg->DP_MIX = (mach64Rop[alu] << 16) | 0;
+ reg->DP_WRITE_MSK = pm;
+ return TRUE;
+}
+
+void
+mach64Copy (int srcX,
+ int srcY,
+ int dstX,
+ int dstY,
+ int w,
+ int h)
+{
+ if (triple)
+ {
+ CARD32 traj;
+
+ srcX *= 3;
+ dstX *= 3;
+ w *= 3;
+
+ traj = DST_24_ROT_EN | DST_24_ROT((dstX / 4) % 6);
+
+ if (copyDx > 0)
+ traj |= 1;
+ if (copyDy > 0)
+ traj |= 2;
+
+ WAIT_AVAIL (reg, 1);
+ reg->GUI_TRAJ_CNTL = traj;
+ }
+ if (copyDx <= 0)
+ {
+ srcX += w - 1;
+ dstX += w - 1;
+ }
+ if (copyDy <= 0)
+ {
+ srcY += h - 1;
+ dstY += h - 1;
+ }
+ WAIT_AVAIL (reg, 4);
+ reg->SRC_Y_X = MACH64_YX(srcX, srcY);
+ reg->SRC_WIDTH1 = w;
+ reg->DST_Y_X = MACH64_YX(dstX, dstY);
+ reg->DST_HEIGHT_WIDTH = MACH64_YX(w,h);
+}
+
+void
+mach64DoneCopy (void)
+{
+}
+
+KaaScreenPrivRec mach64Kaa = {
+ mach64PrepareSolid,
+ mach64Solid,
+ mach64DoneSolid,
+
+ mach64PrepareCopy,
+ mach64Copy,
+ mach64DoneCopy,
+};
+
+#define PIX_FORMAT_MONO 0
+#define PIX_FORMAT_PSEUDO_8 2
+#define PIX_FORMAT_TRUE_1555 3
+#define PIX_FORMAT_TRUE_565 4
+#define PIX_FORMAT_TRUE_8888 6
+#define PIX_FORMAT_TRUE_332 7
+#define PIX_FORMAT_GRAY_8 8
+#define PIX_FORMAT_YUV_422 0xb
+#define PIX_FORMAT_YUV_444 0xe
+#define PIX_FORMAT_TRUE_4444 0xf
+
+mach64DrawInit (ScreenPtr pScreen)
+{
+ KdScreenPriv(pScreen);
+ mach64ScreenInfo(pScreenPriv);
+ CARD32 DP_PIX_WIDTH;
+ CARD32 DP_SET_GUI_ENGINE;
+ CARD32 SET_DP_DST_PIX_WIDTH;
+ CARD32 DST1_PITCH;
+
+ mach64s->bpp24 = FALSE;
+ switch (pScreenPriv->screen->fb[0].depth) {
+ case 1:
+ DP_PIX_WIDTH = ((PIX_FORMAT_MONO << 0) | /* DP_DST_PIX_WIDTH */
+ (PIX_FORMAT_TRUE_8888 << 4) | /* COMPOSITE_PIX_WIDTH */
+ (PIX_FORMAT_MONO << 8) | /* DP_SRC_PIX_WIDTH */
+ (0 << 13) | /* DP_HOST_TRIPLE_EN */
+ (0 << 14) | /* DP_PALETTE_TYPE */
+ (PIX_FORMAT_MONO << 16) | /* DP_HOST_PIX_WIDTH */
+ (0 << 20) | /* DP_C14_RGB_INDEX */
+ (0 << 24) | /* DP_BYTE_PIX_ORDER */
+ (0 << 25) | /* DP_CONVERSION_TEMP */
+ (0 << 26) | /* DP_C14_RGB_LOW_NIBBLE */
+ (0 << 27) | /* DP_C14_RGB_HIGH_NIBBLE */
+ (PIX_FORMAT_TRUE_8888 << 28) | /* DP_SCALE_PIX_WIDTH */
+ 0);
+ SET_DP_DST_PIX_WIDTH = PIX_FORMAT_MONO;
+ break;
+ case 4:
+ return FALSE;
+ break;
+ case 8:
+ DP_PIX_WIDTH = ((PIX_FORMAT_PSEUDO_8 << 0) | /* DP_DST_PIX_WIDTH */
+ (PIX_FORMAT_TRUE_8888 << 4) | /* COMPOSITE_PIX_WIDTH */
+ (PIX_FORMAT_PSEUDO_8 << 8) | /* DP_SRC_PIX_WIDTH */
+ (0 << 13) | /* DP_HOST_TRIPLE_EN */
+ (0 << 14) | /* DP_PALETTE_TYPE */
+ (PIX_FORMAT_PSEUDO_8 << 16) | /* DP_HOST_PIX_WIDTH */
+ (0 << 20) | /* DP_C14_RGB_INDEX */
+ (0 << 24) | /* DP_BYTE_PIX_ORDER */
+ (0 << 25) | /* DP_CONVERSION_TEMP */
+ (0 << 26) | /* DP_C14_RGB_LOW_NIBBLE */
+ (0 << 27) | /* DP_C14_RGB_HIGH_NIBBLE */
+ (PIX_FORMAT_TRUE_8888 << 28) | /* DP_SCALE_PIX_WIDTH */
+ 0);
+ SET_DP_DST_PIX_WIDTH = PIX_FORMAT_PSEUDO_8;
+ break;
+ case 15:
+ DP_PIX_WIDTH = ((PIX_FORMAT_TRUE_1555 << 0) | /* DP_DST_PIX_WIDTH */
+ (PIX_FORMAT_TRUE_8888 << 4) | /* COMPOSITE_PIX_WIDTH */
+ (PIX_FORMAT_TRUE_1555 << 8) | /* DP_SRC_PIX_WIDTH */
+ (0 << 13) | /* DP_HOST_TRIPLE_EN */
+ (0 << 14) | /* DP_PALETTE_TYPE */
+ (PIX_FORMAT_TRUE_1555 << 16) | /* DP_HOST_PIX_WIDTH */
+ (0 << 20) | /* DP_C14_RGB_INDEX */
+ (0 << 24) | /* DP_BYTE_PIX_ORDER */
+ (0 << 25) | /* DP_CONVERSION_TEMP */
+ (0 << 26) | /* DP_C14_RGB_LOW_NIBBLE */
+ (0 << 27) | /* DP_C14_RGB_HIGH_NIBBLE */
+ (PIX_FORMAT_TRUE_8888 << 28) | /* DP_SCALE_PIX_WIDTH */
+ 0);
+ SET_DP_DST_PIX_WIDTH = PIX_FORMAT_TRUE_1555;
+ break;
+ case 16:
+ DP_PIX_WIDTH = ((PIX_FORMAT_TRUE_565 << 0) | /* DP_DST_PIX_WIDTH */
+ (PIX_FORMAT_TRUE_8888 << 4) | /* COMPOSITE_PIX_WIDTH */
+ (PIX_FORMAT_TRUE_565 << 8) | /* DP_SRC_PIX_WIDTH */
+ (0 << 13) | /* DP_HOST_TRIPLE_EN */
+ (0 << 14) | /* DP_PALETTE_TYPE */
+ (PIX_FORMAT_TRUE_565 << 16) | /* DP_HOST_PIX_WIDTH */
+ (0 << 20) | /* DP_C14_RGB_INDEX */
+ (0 << 24) | /* DP_BYTE_PIX_ORDER */
+ (0 << 25) | /* DP_CONVERSION_TEMP */
+ (0 << 26) | /* DP_C14_RGB_LOW_NIBBLE */
+ (0 << 27) | /* DP_C14_RGB_HIGH_NIBBLE */
+ (PIX_FORMAT_TRUE_8888 << 28) | /* DP_SCALE_PIX_WIDTH */
+ 0);
+ SET_DP_DST_PIX_WIDTH = PIX_FORMAT_TRUE_565;
+ break;
+ case 24:
+ if (pScreenPriv->screen->fb[0].bitsPerPixel == 24)
+ {
+ mach64s->bpp24 = TRUE;
+ DP_PIX_WIDTH = ((PIX_FORMAT_PSEUDO_8 << 0) | /* DP_DST_PIX_WIDTH */
+ (PIX_FORMAT_PSEUDO_8 << 4) | /* COMPOSITE_PIX_WIDTH */
+ (PIX_FORMAT_PSEUDO_8 << 8) | /* DP_SRC_PIX_WIDTH */
+ (0 << 13) | /* DP_HOST_TRIPLE_EN */
+ (0 << 14) | /* DP_PALETTE_TYPE */
+ (PIX_FORMAT_PSEUDO_8 << 16) | /* DP_HOST_PIX_WIDTH */
+ (0 << 20) | /* DP_C14_RGB_INDEX */
+ (0 << 24) | /* DP_BYTE_PIX_ORDER */
+ (0 << 25) | /* DP_CONVERSION_TEMP */
+ (0 << 26) | /* DP_C14_RGB_LOW_NIBBLE */
+ (0 << 27) | /* DP_C14_RGB_HIGH_NIBBLE */
+ (PIX_FORMAT_TRUE_8888 << 28) | /* DP_SCALE_PIX_WIDTH */
+ 0);
+ SET_DP_DST_PIX_WIDTH = PIX_FORMAT_PSEUDO_8;
+ }
+ else
+ {
+ DP_PIX_WIDTH = ((PIX_FORMAT_TRUE_8888 << 0) | /* DP_DST_PIX_WIDTH */
+ (PIX_FORMAT_TRUE_8888 << 4) | /* COMPOSITE_PIX_WIDTH */
+ (PIX_FORMAT_TRUE_8888 << 8) | /* DP_SRC_PIX_WIDTH */
+ (0 << 13) | /* DP_HOST_TRIPLE_EN */
+ (0 << 14) | /* DP_PALETTE_TYPE */
+ (PIX_FORMAT_TRUE_8888 << 16) | /* DP_HOST_PIX_WIDTH */
+ (0 << 20) | /* DP_C14_RGB_INDEX */
+ (0 << 24) | /* DP_BYTE_PIX_ORDER */
+ (0 << 25) | /* DP_CONVERSION_TEMP */
+ (0 << 26) | /* DP_C14_RGB_LOW_NIBBLE */
+ (0 << 27) | /* DP_C14_RGB_HIGH_NIBBLE */
+ (PIX_FORMAT_TRUE_8888 << 28) | /* DP_SCALE_PIX_WIDTH */
+ 0);
+ SET_DP_DST_PIX_WIDTH = PIX_FORMAT_TRUE_8888;
+ }
+ break;
+ }
+
+ if (!kaaDrawInit (pScreen, &mach64Kaa))
+ return FALSE;
+
+ mach64s->DP_PIX_WIDTH = DP_PIX_WIDTH;
+ DST1_PITCH = (pScreenPriv->screen->fb[0].pixelStride) >> 3;
+ if (mach64s->bpp24)
+ DST1_PITCH *= 3;
+ mach64s->USR1_DST_OFF_PITCH = ((0 << 0) | /* USR1_DST_OFFSET */
+ (DST1_PITCH << 22) | /* USR1_DST_PITCH */
+ 0);
+ mach64s->DP_SET_GUI_ENGINE = ((SET_DP_DST_PIX_WIDTH << 3) |
+ (1 << 6) | /* SET_DP_SRC_PIX_WIDTH */
+ (0 << 7) | /* SET_DST_OFFSET */
+ (0 << 10) | /* SET_DST_PITCH */
+ (0 << 14) | /* SET_DST_PITCH_BY_2 */
+ (1 << 15) | /* SET_SRC_OFFPITCH_COPY */
+ (0 << 16) | /* SET_SRC_HGTWID1_2 */
+ (0 << 20) | /* SET_DRAWING_COMBO */
+ (1 << 24) | /* SET_BUS_MASTER_OP */
+ (0 << 26) | /* SET_BUS_MASTER_EN */
+ (0 << 27) | /* SET_BUS_MASTER_SYNC */
+ (0 << 28) | /* DP_HOST_TRIPLE_EN */
+ (0 << 29) | /* FAST_FILL_EN */
+ (0 << 30) | /* BLOCK_WRITE_EN */
+ 0);
+ return TRUE;
+}
+
+void
+mach64DrawEnable (ScreenPtr pScreen)
+{
+ KdMarkSync (pScreen);
+}
+
+void
+mach64DrawDisable (ScreenPtr pScreen)
+{
+}
+
+void
+mach64DrawFini (ScreenPtr pScreen)
+{
+}
+
+void
+mach64DrawSync (ScreenPtr pScreen)
+{
+ KdScreenPriv(pScreen);
+ mach64CardInfo(pScreenPriv);
+ reg = mach64c->reg;
+
+ WAIT_IDLE (reg);
+}
diff --git a/hw/kdrive/mach64/mach64draw.h b/hw/kdrive/mach64/mach64draw.h
new file mode 100644
index 000000000..185d6b86c
--- /dev/null
+++ b/hw/kdrive/mach64/mach64draw.h
@@ -0,0 +1,72 @@
+/*
+ * Id: tridentdraw.h,v 1.1 1999/11/02 03:54:47 keithp Exp $
+ *
+ * Copyright © 1999 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.
+ */
+/* $XFree86: xc/programs/Xserver/hw/kdrive/trident/tridentdraw.h,v 1.4 2000/10/11 06:04:40 keithp Exp $ */
+
+#ifndef _TRIDENTDRAW_H_
+#define _TRIDENTDRAW_H_
+
+#define SetupTrident(s) KdScreenPriv(s); \
+ tridentCardInfo(pScreenPriv); \
+ Cop *cop = tridentc->cop
+
+#define TridentAlpha (COP_MULTI_ALPHA|COP_ALPHA_WRITE_ENABLE)
+
+#define _tridentInit(cop,tridentc) { \
+ if ((cop)->status == 0xffffffff) tridentSetMMIO(tridentc); \
+ (cop)->multi = (tridentc)->cop_depth; \
+ (cop)->multi = (tridentc)->cop_stride; \
+ (cop)->multi = TridentAlpha; \
+} \
+
+#define _tridentSetSolidRect(cop,pix,alu,cmd) {\
+ cop->multi = COP_MULTI_PATTERN; \
+ cop->multi = COP_MULTI_ROP | tridentRop[alu]; \
+ cop->fg = (pix); \
+ cmd = COP_OP_BLT | COP_SCL_OPAQUE | COP_OP_ROP | COP_OP_FG; \
+}
+
+#define _tridentRect(cop,x1,y1,x2,y2,cmd) { \
+ (cop)->dst_start_xy = TRI_XY (x1,y1); \
+ (cop)->dst_end_xy = TRI_XY(x2,y2); \
+ _tridentWaitDone(cop); \
+ (cop)->command = (cmd); \
+}
+
+#define COP_STATUS_BUSY (COP_STATUS_BE_BUSY | \
+ COP_STATUS_DPE_BUSY | \
+ COP_STATUS_MI_BUSY)
+
+#define _tridentWaitDone(cop) { \
+ int __q__ = 500000; \
+ while (__q__-- && (cop)->status & COP_STATUS_BUSY) \
+ ; \
+ if (!__q__) \
+ (cop)->status = 0; \
+}
+
+#define _tridentWaitIdleEmpty(cop) _tridentWaitDone(cop)
+
+#define sourceInvarient(alu) (((alu) & 3) == (((alu) >> 2) & 3))
+
+#endif
diff --git a/hw/kdrive/mach64/mach64stub.c b/hw/kdrive/mach64/mach64stub.c
new file mode 100644
index 000000000..fac8d46ac
--- /dev/null
+++ b/hw/kdrive/mach64/mach64stub.c
@@ -0,0 +1,58 @@
+/*
+ * Id: mach64stub.c,v 1.1 1999/11/02 08:19:15 keithp Exp $
+ *
+ * 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.
+ */
+/* $XFree86: xc/programs/Xserver/hw/kdrive/mach64/mach64stub.c,v 1.5 2000/11/29 08:42:25 keithp Exp $ */
+
+#include "mach64.h"
+
+void
+InitCard (char *name)
+{
+ KdCardAttr attr;
+
+ if (LinuxFindPci (0x1002, 0x4c4d, 0, &attr))
+ KdCardInfoAdd (&mach64Funcs, &attr, 0);
+}
+
+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)
+{
+ int ret;
+
+ if (!(ret = vesaProcessArgument (argc, argv, i)))
+ ret = KdProcessArgument(argc, argv, i);
+ return ret;
+}
diff --git a/hw/kdrive/src/kaa.c b/hw/kdrive/src/kaa.c
index da9d89284..28164abf3 100644
--- a/hw/kdrive/src/kaa.c
+++ b/hw/kdrive/src/kaa.c
@@ -1,5 +1,5 @@
/*
- * $XFree86: xc/programs/Xserver/hw/kdrive/kaa.c,v 1.1 2001/05/29 04:54:10 keithp Exp $
+ * $XFree86: xc/programs/Xserver/hw/kdrive/kaa.c,v 1.2 2001/05/30 15:36:25 keithp Exp $
*
* Copyright © 2001 Keith Packard, member of The XFree86 Project, Inc.
*
@@ -130,8 +130,8 @@ kaaCopyNtoN (DrawablePtr pSrcDrawable,
if (pSrcDrawable->type == DRAWABLE_WINDOW &&
(*pKaaScr->PrepareCopy) (pSrcDrawable,
pDstDrawable,
- upsidedown,
- reverse,
+ dx,
+ dy,
pGC ? pGC->alu : GXcopy,
pGC ? pGC->planemask : FB_ALLONES))
{
@@ -275,46 +275,45 @@ kaaSolidBoxClipped (DrawablePtr pDrawable,
int partX1, partX2, partY1, partY2;
CARD32 cmd;
- if ((*pKaaScr->PrepareSolid) (pDrawable, GXcopy, pm, fg))
- {
- 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;
-
- (*pKaaScr->Solid) (partX1, partY1, partX2, partY2);
- }
- (*pKaaScr->DoneSolid) ();
- KdMarkSync(pDrawable->pScreen);
- }
- else
+ if (!(*pKaaScr->PrepareSolid) (pDrawable, GXcopy, pm, fg))
{
+ KdCheckSync (pDrawable->pScreen);
fg = fbReplicatePixel (fg, pDrawable->bitsPerPixel);
fbSolidBoxClipped (pDrawable, pClip, x1, y1, x2, y2,
fbAnd (GXcopy, fg, pm),
fbXor (GXcopy, fg, pm));
+ return;
+ }
+ 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;
+
+ (*pKaaScr->Solid) (partX1, partY1, partX2, partY2);
}
+ (*pKaaScr->DoneSolid) ();
+ KdMarkSync(pDrawable->pScreen);
}
void
diff --git a/hw/kdrive/trident/trident.c b/hw/kdrive/trident/trident.c
index 88f797b7f..065548bdd 100644
--- a/hw/kdrive/trident/trident.c
+++ b/hw/kdrive/trident/trident.c
@@ -19,12 +19,10 @@
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
-/* $XFree86: xc/programs/Xserver/hw/kdrive/trident/trident.c,v 1.15 2000/11/29 08:42:25 keithp Exp $ */
+/* $XFree86: xc/programs/Xserver/hw/kdrive/trident/trident.c,v 1.16 2001/03/21 16:43:16 dawes Exp $ */
#include "trident.h"
-#define extern
-#include <asm/io.h>
-#undef extern
+#include <sys/io.h>
#undef TRI_DEBUG
diff --git a/hw/kdrive/trident/tridentdraw.c b/hw/kdrive/trident/tridentdraw.c
index 486bad693..78835ea93 100644
--- a/hw/kdrive/trident/tridentdraw.c
+++ b/hw/kdrive/trident/tridentdraw.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/trident/tridentdraw.c,v 1.8 2001/05/29 04:54:12 keithp Exp $ */
+/* $XFree86: xc/programs/Xserver/hw/kdrive/trident/tridentdraw.c,v 1.9 2001/05/30 15:36:25 keithp Exp $ */
#include "trident.h"
#include "tridentdraw.h"
@@ -112,8 +112,8 @@ tridentDoneSolid (void)
Bool
tridentPrepareCopy (DrawablePtr pSrcDrawable,
DrawablePtr pDstDrawable,
- Bool upsidedown,
- Bool reverse,
+ int dx,
+ int dy,
int alu,
Pixel pm)
{
@@ -128,7 +128,7 @@ tridentPrepareCopy (DrawablePtr pSrcDrawable,
cop->multi = COP_MULTI_PATTERN;
cop->multi = COP_MULTI_ROP | tridentRop[alu];
cmd = COP_OP_BLT | COP_SCL_OPAQUE | COP_OP_ROP | COP_OP_FB;
- if (upsidedown || reverse)
+ if (dx < 0 || dy < 0)
cmd |= COP_X_REVERSE;
return TRUE;
}