SVGA: double buffering

16 files changed, 556 insertions, 322 deletions

diff --git a/3d_accel.h b/3d_accel.h
index 979d747..46e6689 100644
--- a/3d_accel.h
+++ b/3d_accel.h
@@ -38,7 +38,7 @@ THE SOFTWARE.
 #define ESCAPE_DRV_NT         0x1103 /* (4355) */

 

 /* function codes */

-#define OP_FBHDA_SETUP        0x110B /* VXD, DRV, ExtEscape */

+#define OP_FBHDA_SETUP        0x110B /* VXD, DRV, ExtEscape, VxDCall */

 #define OP_FBHDA_ACCESS_BEGIN 0x110C /* VXD, DRV, ESCAPE_DRV_NT */

 #define OP_FBHDA_ACCESS_END   0x110D /* VXD, DRV, ESCAPE_DRV_NT */

 #define OP_FBHDA_SWAP         0x110E /* VXD, DRV, ESCAPE_DRV_NT */

@@ -46,7 +46,12 @@ THE SOFTWARE.
 #define OP_FBHDA_PALETTE_SET  0x1110 /* VXD, DRV, ESCAPE_DRV_NT */

 #define OP_FBHDA_PALETTE_GET  0x1111 /* VXD, DRV, ESCAPE_DRV_NT */

 #define OP_FBHDA_ACCESS_RECT  0x1112 /* VXD, DRV, ESCAPE_DRV_NT */

-#define OB_FBHDA_OVERLAY      0x1113 /* VXD, ESCAPE_DRV_NT */

+#define OP_FBHDA_OVERLAY_SETUP  0x1113 /* VXD, VxDCall, ESCAPE_DRV_NT */

+#define OP_FBHDA_OVERLAY_LOCK   0x1114 /* VXD, VxDCall, ESCAPE_DRV_NT */

+#define OP_FBHDA_OVERLAY_UNLOCK 0x1115 /* VXD, VxDCall, ESCAPE_DRV_NT */

+

+#define OP_FBHDA_GAMMA_SET    0x1116 /* VXD, DRV, ESCAPE_DRV_NT */

+#define OP_FBHDA_GAMMA_GET    0x1117 /* VXD, DRV, ESCAPE_DRV_NT */

 

 #define OP_SVGA_VALID         0x2000  /* VXD, DRV, ESCAPE_DRV_NT */

 #define OP_SVGA_SETMODE       0x2001  /* DRV */

@@ -82,6 +87,14 @@ THE SOFTWARE.
 #define OP_MOUSE_SHOW         0x1F03 /* DRV */

 #define OP_MOUSE_HIDE         0x1F04 /* DRV */

 

+/* VXDCall */

+#define FBHDA_DEVICE_ID       0x4333

+#define FBHDA_SERVICE_TABLE_OFFSET 0x110A

+#define FBHDA__GET_VERSION 0

+#define FBHDA__SETUP (OP_FBHDA_SETUP-FBHDA_SERVICE_TABLE_OFFSET)

+#define FBHDA__OVERLAY_SETUP (OP_FBHDA_OVERLAY_SETUP-FBHDA_SERVICE_TABLE_OFFSET)

+#define FBHDA__OVERLAY_LOCK (OP_FBHDA_OVERLAY_LOCK-FBHDA_SERVICE_TABLE_OFFSET)

+#define FBHDA__OVERLAY_UNLOCK (OP_FBHDA_OVERLAY_UNLOCK-FBHDA_SERVICE_TABLE_OFFSET)

 

 #pragma pack(push)

 #pragma pack(1)

@@ -127,10 +140,10 @@ typedef struct FBHDA
 	         DWORD overlay;

 	         FBHDA_overlay_t overlays[FBHA_OVERLAYS_MAX];

 	         DWORD overlays_size;

-	         DWORD gamma; // fixed decimal point, 65536 = 1.0

-	         DWORD res1;

-	         DWORD res2;

-	         DWORD res3;

+	         DWORD gamma; /* fixed decimal point, 65536 = 1.0 */

+	         DWORD system_surface;

+	         DWORD palette_update; /* INC by one everytime when the palette is updated */

+	         DWORD gamma_update; /* INC by one everytime when the pallete is updated */

 	         DWORD res4;

 	         DWORD res5;

 } FBHDA_t;

@@ -144,7 +157,8 @@ typedef struct FBHDA
 #define FB_ACCEL_VMSVGA10      64

 #define FB_MOUSE_NO_BLIT      128

 #define FB_FORCE_SOFTWARE     256

-#define FB_ACCEL_VMSVGA10_ST  512

+#define FB_ACCEL_VMSVGA10_ST  512 /* not used */

+#define FB_BUG_VMWARE_UPDATE 1024

 

 /* for internal use in RING-0 by VXD only */

 BOOL FBHDA_init_hw(); 

@@ -160,7 +174,8 @@ void FBHDA_free();
 	FBHDA_t *FBHDA_setup();

 #endif

 

-#define FBHDA_IGNORE_CURSOR 1

+#define FBHDA_ACCESS_RAW_BUFFERING 1

+#define FBHDA_ACCESS_MOUSE_MOVE 2

 

 void FBHDA_access_begin(DWORD flags);

 void FBHDA_access_end(DWORD flags);

@@ -169,7 +184,15 @@ BOOL FBHDA_swap(DWORD offset);
 void FBHDA_clean();

 void  FBHDA_palette_set(unsigned char index, DWORD rgb);

 DWORD FBHDA_palette_get(unsigned char index);

-DWORD FBHDA_overlay(DWORD overlay, DWORD width, DWORD height, DWORD bpp);

+

+/* return pitch or 0 when failed */

+DWORD FBHDA_overlay_setup(DWORD overlay, DWORD width, DWORD height, DWORD bpp);

+void  FBHDA_overlay_lock(DWORD left, DWORD top, DWORD right, DWORD bottom);

+void  FBHDA_overlay_unlock(DWORD flags);

+

+/* format simitar to WINAPI Set/GetDeviceGammaRamp */

+BOOL FBHDA_gamma_get(VOID FBPTR ramp, DWORD buffer_size);

+BOOL FBHDA_gamma_set(VOID FBPTR ramp, DWORD buffer_size);

 

 /* mouse */

 #ifdef FBHDA_SIXTEEN

@@ -282,7 +305,7 @@ BOOL SVGA_valid();
 #define SVGA_CB_RENDER             0x02000000UL /* this is 'render' cmd, WAIT for 'present', 'update' */

 #define SVGA_CB_UPDATE             0x01000000UL /* this is 'update' cmd, updates screen on HOST, WAIT for 'update', 'present' */

 

-// SVGA_CB_FLAG_DX_CONTEXT

+/* SVGA_CB_FLAG_DX_CONTEXT */

 

 BOOL SVGA_setmode(DWORD w, DWORD h, DWORD bpp);

 BOOL SVGA_validmode(DWORD w, DWORD h, DWORD bpp);

diff --git a/dddrv.c b/dddrv.c
index e7244f9..09c1719 100644
--- a/dddrv.c
+++ b/dddrv.c
@@ -272,7 +272,7 @@ static void buildDDHALInfo(VMDAHAL_t __far *hal, int modeidx)
 	/*

 	 * current primary surface attributes

 	 */

-	hal->ddHALInfo.vmiData.fpPrimary       = hda->vram_pm32;

+	hal->ddHALInfo.vmiData.fpPrimary       = hda->vram_pm32 + hda->system_surface;

 	hal->ddHALInfo.vmiData.dwDisplayWidth  = hda->width;

 	hal->ddHALInfo.vmiData.dwDisplayHeight = hda->height;

 	hal->ddHALInfo.vmiData.lDisplayPitch   = hda->pitch;

@@ -299,12 +299,7 @@ static void buildDDHALInfo(VMDAHAL_t __far *hal, int modeidx)
 

 	vidMem[0].dwFlags = VIDMEM_ISLINEAR;

 	vidMem[0].ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;

-	vidMem[0].fpStart = hda->vram_pm32 + hda->stride;

-	if((hda->flags & FB_ACCEL_VMSVGA3D) != 0 && (hda->flags & FB_ACCEL_VMSVGA10) == 0)

-	{

-		vidMem[0].fpStart += hda->stride; // extra backbuffer for vGPU9 present

-	}

-	

+	vidMem[0].fpStart = hda->vram_pm32 + hda->system_surface + hda->stride;	

 	vidMem[0].fpEnd   = hda->vram_pm32 + hda->vram_size - hda->overlays_size - 1;

 	

 	hal->ddHALInfo.vmiData.dwNumHeaps = 1;

diff --git a/enable.c b/enable.c
index e4d4ae4..eff94c8 100644
--- a/enable.c
+++ b/enable.c
@@ -267,7 +267,7 @@ UINT WINAPI __loadds Enable( LPVOID lpDevice, UINT style, LPSTR lpDeviceType,
         lpEng->deBitsPixel    = wBpp;

         lpEng->deReserved1    = 0;

         lpEng->delpPDevice    = 0;

-        lpEng->deBitsOffset   = 0;

+        lpEng->deBitsOffset   = hda->surface;

         lpEng->deBitsSelector = ((DWORD)hda->vram_pm16) >> 16;

         lpEng->deBitmapInfo   = lpInfo;

         lpEng->deVersion      = 0x400;

diff --git a/makefile b/makefile
index b036288..5b8ca9f 100644
--- a/makefile
+++ b/makefile
@@ -7,12 +7,12 @@ OBJS = &
 OBJS += &

   dbgprint32.obj svga.obj pci.obj vxd_fbhda.obj vxd_lib.obj vxd_main.obj &

   vxd_main_qemu.obj vxd_main_svga.obj vxd_svga.obj vxd_vdd.obj vxd_vdd_qemu.obj &

-  vxd_vdd_svga.obj vxd_vbe.obj vxd_vbe_qemu.obj vxd_mouse.obj vxd_svga_st.obj &

+  vxd_vdd_svga.obj vxd_vbe.obj vxd_vbe_qemu.obj vxd_mouse.obj &

   vxd_mouse_svga.obj vxd_svga_mouse.obj vxd_svga_mem.obj vxd_svga_cb.obj

 

 INCS = -I$(%WATCOM)\h\win -Iddk -Ivmware

 

-VER_BUILD = 75

+VER_BUILD = 78

 

 FLAGS = -DDRV_VER_BUILD=$(VER_BUILD)

 

@@ -36,7 +36,7 @@ FIXLINK_CC  = wcl386 -q fixlink\fixlink.c -fe=$(FIXLINK_EXE)
 #FLAGS += -DHWBLT

 

 # Set DBGPRINT to add debug printf logging.

-DBGPRINT = 1

+#DBGPRINT = 1

 

 !ifdef DBGPRINT

 FLAGS += -DDBGPRINT

@@ -163,9 +163,6 @@ vxd_mouse_svga.obj : vxd_mouse_svga.c .autodepend
 vxd_svga.obj : vxd_svga.c .autodepend

 	$(CC32) $(CFLAGS32) $(INCS) $(FLAGS) $<

 

-vxd_svga_st.obj : vxd_svga_st.c .autodepend

-	$(CC32) $(CFLAGS32) $(INCS) $(FLAGS) $<

-

 vxd_svga_mouse.obj : vxd_svga_mouse.c .autodepend

 	$(CC32) $(CFLAGS32) $(INCS) $(FLAGS) $<

 

@@ -437,7 +434,6 @@ file pci.obj
 file vxd_fbhda.obj

 file vxd_lib.obj

 file vxd_svga.obj

-file vxd_svga_st.obj

 file vxd_svga_mouse.obj

 file vxd_svga_mem.obj

 file vxd_svga_cb.obj

diff --git a/vxd.h b/vxd.h
index 627c02a..8e0122d 100644
--- a/vxd.h
+++ b/vxd.h
@@ -5,18 +5,20 @@
  * https://fd.lod.bz/rbil/interrup/windows/2f1684.html#sect-4579

  * This looks like free

  */

+/*

 #define VXD_DEVICE_SVGA_ID 0x4331

 #define VXD_DEVICE_QEMU_ID 0x4332

-#define VXD_DEVICE_VBE_ID  0x4333

+#define VXD_DEVICE_VBE_ID  0x4333*/

+#define VXD_DEVICE_VMDISP9X_ID  0x4333

 

 #if defined(SVGA)

-#define VXD_DEVICE_ID VXD_DEVICE_SVGA_ID

+#define VXD_DEVICE_ID VXD_DEVICE_VMDISP9X_ID

 #define VXD_DEVICE_NAME "VMWSVXD"

 #elif defined(QEMU)

-#define VXD_DEVICE_ID VXD_DEVICE_QEMU_ID

+#define VXD_DEVICE_ID VXD_DEVICE_VMDISP9X_ID

 #define VXD_DEVICE_NAME "QEMUVXD"

 #else

-#define VXD_DEVICE_ID VXD_DEVICE_VBE_ID

+#define VXD_DEVICE_ID VXD_DEVICE_VMDISP9X_ID

 #define VXD_DEVICE_NAME "BOXVVXD"

 #endif

 

diff --git a/vxd_color.h b/vxd_color.h
new file mode 100644
index 0000000..7b9ecf0
--- /dev/null
+++ b/vxd_color.h
@@ -0,0 +1,71 @@
+#ifndef __VXD_COLOR_H__INCLUDED__

+#define __VXD_COLOR_H__INCLUDED__

+

+DWORD palette_emulation[256] = {0};

+

+static inline void blit16(

+	void *src, DWORD src_pitch,

+	void *dst, DWORD dst_pitch,

+	DWORD blit_x, DWORD blit_y, DWORD blit_w, DWORD blit_h)

+{

+	const DWORD bottom = blit_y+blit_h;

+	DWORD x, y;

+	for(y = blit_y; y < bottom; y++)

+	{

+		WORD *src_ptr = ((WORD*)(((BYTE*)src) + src_pitch*y))+blit_x;

+		DWORD *dst_ptr = ((DWORD*)(((BYTE*)dst) + dst_pitch*y))+blit_x;		

+		

+		for(x = 0; x < blit_w; x++)

+		{

+			DWORD px = *src_ptr;

+			*dst_ptr = ((px & 0xF800) << 8) | ((px & 0x07E0) << 5) | ((px & 0x001F) << 3);

+			src_ptr++;

+			dst_ptr++;

+		}

+	}

+}

+

+static inline void blit8(

+	void *src, DWORD src_pitch,

+	void *dst, DWORD dst_pitch,

+	DWORD blit_x, DWORD blit_y, DWORD blit_w, DWORD blit_h)

+{

+	const DWORD bottom = blit_y+blit_h;

+	DWORD x, y;

+	for(y = blit_y; y < bottom; y++)

+	{

+		BYTE *src_ptr = (((BYTE*)src) + src_pitch*y)+blit_x;

+		DWORD *dst_ptr = ((DWORD*)(((BYTE*)dst) + dst_pitch*y))+blit_x;		

+		

+		for(x = 0; x < blit_w; x++)

+		{

+			*dst_ptr = palette_emulation[*src_ptr];

+			src_ptr++;

+			dst_ptr++;

+		}

+	}

+}

+

+static inline void readback16(

+	void *src, DWORD src_pitch,

+	void *dst, DWORD dst_pitch,

+	DWORD blit_x, DWORD blit_y, DWORD blit_w, DWORD blit_h)

+{

+	const DWORD bottom = blit_y+blit_h;

+	DWORD x, y;

+	for(y = blit_y; y < bottom; y++)

+	{

+		DWORD *src_ptr = ((DWORD*)(((BYTE*)src) + src_pitch*y))+blit_x;

+		WORD  *dst_ptr =  ((WORD*)(((BYTE*)dst) + dst_pitch*y))+blit_x;		

+		

+		for(x = 0; x < blit_w; x++)

+		{

+			DWORD px = *src_ptr;

+			*dst_ptr = ((px & 0xF80000) >> 8) | ((px & 0xFC00) >> 5) | ((px & 0x00F8) >> 3);

+			src_ptr++;

+			dst_ptr++;

+		}

+	}

+}

+

+#endif /* __VXD_COLOR_H__INCLUDED__ */

diff --git a/vxd_lib.c b/vxd_lib.c
index b8e43a8..509a288 100644
--- a/vxd_lib.c
+++ b/vxd_lib.c
@@ -376,6 +376,7 @@ void __cdecl _Allocate_LDT_Selector(ULONG vm, ULONG DescHigh, ULONG DescLow, ULO
 	}

 }

 

+

 static void __declspec(naked) __cdecl _Allocate_GDT_Selector_(ULONG DescHigh, ULONG DescLow, ULONG flags)

 {

 	VMMJmp(_Allocate_GDT_Selector);

@@ -404,6 +405,11 @@ void __cdecl _Allocate_GDT_Selector(ULONG DescHigh, ULONG DescLow, ULONG flags,
 	}

 }

 

+ULONG __declspec(naked) __cdecl _SetDescriptor(ULONG selector, ULONG vm, DWORD DescDWORD1, DWORD DescDWORD2, ULONG flags)

+{

+	VMMJmp(_SetDescriptor);

+}

+

 static ULONG __declspec(naked) __cdecl _PageAllocate_call(ULONG nPages, ULONG pType, ULONG VM, ULONG AlignMask, ULONG minPhys, ULONG maxPhys, ULONG *PhysAddr, ULONG flags)

 {

 	VMMJmp(_PageAllocate);

diff --git a/vxd_lib.h b/vxd_lib.h
index 9f29f20..363dada 100644
--- a/vxd_lib.h
+++ b/vxd_lib.h
@@ -60,6 +60,7 @@ void Release_Time_Slice();
 void __cdecl _BuildDescriptorDWORDs(ULONG DESCBase, ULONG DESCLimit, ULONG DESCType, ULONG DESCSize, ULONG flags, DWORD *outDescHigh, DWORD *outDescLow);

 void __cdecl _Allocate_LDT_Selector(ULONG vm, ULONG DescHigh, ULONG DescLow, ULONG Count, ULONG flags, DWORD *outFirstSelector, DWORD *outSelectorTable);

 void __cdecl _Allocate_GDT_Selector(ULONG DescHigh, ULONG DescLow, ULONG flags, DWORD *outFirstSelector, DWORD *outSelectorTable);

+ULONG __cdecl _SetDescriptor(ULONG selector, ULONG vm, DWORD DescDWORD1, DWORD DescDWORD2, ULONG flags);

 

 void Enable_Global_Trapping(DWORD port);

 void Disable_Global_Trapping(DWORD port);

diff --git a/vxd_main.c b/vxd_main.c
index 966adb5..c73dc2a 100644
--- a/vxd_main.c
+++ b/vxd_main.c
@@ -533,7 +533,7 @@ DWORD __stdcall Device_IO_Control_proc(DWORD vmhandle, struct DIOCParams *params
 	

 	Begin_Critical_Section(0);

 	

-	dbg_printf(dbg_deviceiocontrol, params->dwIoControlCode);

+	//dbg_printf("I%x\n", params->dwIoControlCode);

 	

 	switch(params->dwIoControlCode)

 	{

@@ -576,8 +576,8 @@ DWORD __stdcall Device_IO_Control_proc(DWORD vmhandle, struct DIOCParams *params
 			rc = 0;

 			break;

 #ifdef SVGA

-		case OB_FBHDA_OVERLAY:

-			//outBuf[0] = FBHDA_overlay(inBuf[0], inBuf[1], inBuf[2], inBuf[3]);

+		case OP_FBHDA_OVERLAY_SETUP:

+			//outBuf[0] = FBHDA_overlay_setup(inBuf[0], inBuf[1], inBuf[2], inBuf[3]);

 			rc = 0;

 			break;

 		case OP_SVGA_VALID:

@@ -678,11 +678,11 @@ DWORD __stdcall Device_IO_Control_proc(DWORD vmhandle, struct DIOCParams *params
 #endif /*DBGPRINT */

 #endif /* SVGA */

 		default:

-			dbg_printf(dbg_dic_unknown, params->dwIoControlCode);

+			dbg_printf("DeviceIOControl: Unknown: %d\n", params->dwIoControlCode);

 			break;

 	}

 	

-	dbg_printf(dbg_deviceiocontrol_leave);

+	//dbg_printf("IL\n");

 	End_Critical_Section();

 

 	return rc;

diff --git a/vxd_mouse.c b/vxd_mouse.c
index 83d8151..710f5d2 100644
--- a/vxd_mouse.c
+++ b/vxd_mouse.c
@@ -215,10 +215,10 @@ void mouse_move(int x, int y)
 	

 	if(mouse_valid && mouse_visible && !mouse_empty)

 	{

-		FBHDA_access_begin(0);

+		FBHDA_access_begin(FBHDA_ACCESS_MOUSE_MOVE);

 		mouse_x = x;

 		mouse_y = y;

-		FBHDA_access_end(0);

+		FBHDA_access_end(FBHDA_ACCESS_MOUSE_MOVE);

 	}

 	else

 	{

@@ -294,7 +294,7 @@ BOOL mouse_blit()
 	return FALSE;

 }

 

-/* called by FBHA_access_begin */

+/* called by FBHDA_access_begin */

 void mouse_erase()

 {

 	if(mouse_valid && mouse_visible && !mouse_empty)

@@ -302,3 +302,57 @@ void mouse_erase()
 		draw_restore();

 	}

 }

+

+BOOL mouse_get_rect(DWORD *ptr_left, DWORD *ptr_top,

+	DWORD *ptr_right, DWORD *ptr_bottom)

+{

+	int mx;

+	int my;

+	int mw;

+	int mh;

+	

+	if(mouse_valid && !mouse_empty)

+	{

+		mw = mouse_w;

+		mx = mouse_x - mouse_pointx;

+		

+		if(mx < 0)

+		{

+			mw += mx;

+			mx = 0;

+		}

+		

+		if(mx + mw > hda->width)

+		{

+			mw = hda->width - mx;

+		}

+		

+		mh = mouse_h;

+		my = mouse_y - mouse_pointy;

+		

+		if(my < 0)

+		{

+			mh += my;

+			my = 0;

+		}

+		

+		if(my + mh > hda->height)

+		{

+			mh = hda->height - my;

+		}

+		

+		if(mw > 0 && mh > 0)

+		{

+			*ptr_left    = mx;

+			*ptr_top     = my;

+			*ptr_right   = mx + mw;

+			*ptr_bottom  = my + mh;

+			

+			return TRUE;

+		}

+		

+		return TRUE;

+	}

+	

+	return FALSE;

+}

diff --git a/vxd_strings.h b/vxd_strings.h
index a41cdd1..0073ed4 100644
--- a/vxd_strings.h
+++ b/vxd_strings.h
@@ -30,7 +30,6 @@ DSTR(dbg_Device_Init_proc, "Device_Init_proc\n");
 DSTR(dbg_Device_Init_proc_succ, "Device_Init_proc success\n");

 DSTR(dbg_dic_ring, "DeviceIOControl: Ring\n");

 DSTR(dbg_dic_sync, "DeviceIOControl: Sync\n");

-DSTR(dbg_dic_unknown, "DeviceIOControl: Unknown: %d\n");

 DSTR(dbg_dic_system, "DeviceIOControl: System code: %d\n");

 DSTR(dbg_get_ppa, "%lx -> %lx\n");

 DSTR(dbg_get_ppa_beg, "Virtual: %lx\n");

@@ -67,9 +66,6 @@ DSTR(dbg_cmd_on, "SVGA_CMB_submit: ptr=%X, first cmd=%X, flags=%X, size=%d\n");
 DSTR(dbg_cmd_off, "SVGA_CMB_submit: end - cmd: %X\n");

 DSTR(dbg_cmd_error, "CB error: %d, first cmd %X (error at %d)\n");

 

-DSTR(dbg_deviceiocontrol, "I%x\n");

-DSTR(dbg_deviceiocontrol_leave, "IL\n");

-

 DSTR(dbg_gmr, "GMR: %ld at %X\n");

 DSTR(dbg_gmr_succ, "GMR ALLOC: %ld (size: %ld)\n");

 

@@ -120,8 +116,6 @@ DSTR(dbg_map_pm16, "map_pm16: vm = %ld, linear = %lX, size = %ld\n");
 

 DSTR(dbg_map_pm16_sel, "map_pm16: selector %lX\n");

 

-DSTR(dbg_register, "register: ebx = %ld, ecx = %ld, VM = %lX\n");

-

 DSTR(dbg_map_pm16_qw, "map_pm16: high=%lX, low=%lX\n");

 

 DSTR(dbg_lock_cb, "Lock CB buffer: %ld (line: %ld)\n");

@@ -159,8 +153,6 @@ DSTR(dbg_cb_suc, "submit SVGA_CB_SYNC success\n");
 DSTR(dbg_region_1, "SVGA_region_create #1: %ld, max: %ld\n");

 DSTR(dbg_region_2, "SVGA_region_create #2: %ld\n");

 

-DSTR(dbg_cb_error, "Error (%ld): offset %ld, error command: %ld\n");

-

 DSTR(dbg_cs_underflow, "WARNING: closing inactive CS!\n");

 DSTR(dbg_cs_active, "WARNING: CS is still active!\n");

 

diff --git a/vxd_svga.c b/vxd_svga.c
index 4493893..4fad1bb 100644
--- a/vxd_svga.c
+++ b/vxd_svga.c
@@ -45,6 +45,8 @@ THE SOFTWARE.
 

 #include "svga_ver.h"

 

+#include "vxd_color.h"

+

 /*

  * consts

  */

@@ -74,14 +76,18 @@ static DWORD prefer_fifo = 1;
 

 static BOOL SVGA_is_valid = FALSE;

 

+BOOL surface_dirty = FALSE;

+

 static DWORD fence_next_id = 1;

 void *cmdbuf = NULL;

 void *ctlbuf = NULL;

 

 DWORD async_mobs = 1;

 

-/* guest frame buffer is dirty */

-BOOL ST_FB_invalid = FALSE;

+/* vxd_mouse.vxd */

+BOOL mouse_get_rect(DWORD *ptr_left, DWORD *ptr_top,

+	DWORD *ptr_right, DWORD *ptr_bottom);

+

 

 //DWORD present_fence = 0;

 /*

@@ -97,8 +103,6 @@ static char SVGA_conf_rgb565bug[]  = "RGB565bug";
 static char SVGA_conf_cb[]         = "CommandBuffers";

 static char SVGA_conf_pref_fifo[]  = "PreferFIFO";

 static char SVGA_conf_hw_version[] = "HWVersion";

-static char SVGA_conf_st_size[]    = "STSize";

-static char SVGA_conf_st_flags[]   = "STOptions";

 static char SVGA_vxd_name[]        = "vmwsmini.vxd";

 

 static char SVGA_conf_disable_multisample[] = "NoMultisample";

@@ -331,7 +335,6 @@ BOOL SVGA_vxdcmd(DWORD cmd)
 	switch(cmd)

 	{

 		case SVGA_CMD_INVALIDATE_FB:

-			ST_FB_invalid = TRUE;

 			return TRUE;

 	}

 	

@@ -339,26 +342,11 @@ BOOL SVGA_vxdcmd(DWORD cmd)
 }

 

 static DWORD fb_pm16 = 0;

-static DWORD st_pm16 = 0;

-static DWORD st_address = 0;

+//static DWORD st_pm16 = 0;

+//static DWORD st_address = 0;

 static DWORD st_surface_mb = 0;

 static DWORD disable_multisample = 0;

 

-BOOL st_useable(DWORD bpp)

-{

-	if(st_used)

-	{

-		if(bpp == 32) return TRUE;

-			

-		if(bpp == 16 && (st_flags & ST_16BPP))

-		{

-			return TRUE;

-		}

-	}

-	

-	return FALSE;

-}

-

 static void SVGA_write_driver_id()

 {

 	if(gSVGA.deviceVersionId >= SVGA_ID_2)

@@ -411,9 +399,6 @@ BOOL SVGA_init_hw()
  	RegReadConf(HKEY_LOCAL_MACHINE, SVGA_conf_path, SVGA_conf_hw_version, &conf_hw_version);

  	RegReadConf(HKEY_LOCAL_MACHINE, SVGA_conf_path, SVGA_conf_pref_fifo,  &prefer_fifo);

  	

- 	RegReadConf(HKEY_LOCAL_MACHINE, SVGA_conf_path, SVGA_conf_st_size,    &st_surface_mb);

- 	RegReadConf(HKEY_LOCAL_MACHINE, SVGA_conf_path, SVGA_conf_st_flags,   &st_flags);

- 	

  	RegReadConf(HKEY_LOCAL_MACHINE, SVGA_conf_path, SVGA_conf_disable_multisample, &disable_multisample);

  	RegReadConf(HKEY_LOCAL_MACHINE, SVGA_conf_path, SVGA_conf_async_mobs, &async_mobs);

  	

@@ -553,14 +538,6 @@ BOOL SVGA_init_hw()
 			if(cb_support) /* SVGA_CB_start may fail */

 			{

 				SVGA_OTable_load();

-				

-				if(st_surface_mb >= 8)

-				{

-					if(st_memory_allocate(st_surface_mb*1024*1024, &st_address))

-					{

-						st_used = TRUE;

-					}

-				}

 			}

 		}

 		

@@ -568,20 +545,9 @@ BOOL SVGA_init_hw()
 		fb_pm16 = map_pm16(1, gSVGA.fbLinear, gSVGA.vramSize);

 		

 		/* fill address in FBHDA */

-		if(st_used)

-		{

-			st_pm16 = map_pm16(1, st_address, st_surface_mb*1024*1024);

-			

-			hda->vram_pm32 = (void*)st_address;

-			hda->vram_size = st_surface_mb*1024*1024;

-			hda->vram_pm16 = st_pm16;

-		}

-		else

-		{

-			hda->vram_pm32 = (void*)gSVGA.fbLinear;

-			hda->vram_size = gSVGA.vramSize;

-			hda->vram_pm16 = fb_pm16;

-		}

+		hda->vram_pm32 = (void*)gSVGA.fbLinear;

+		hda->vram_size = gSVGA.vramSize;

+		hda->vram_pm16 = fb_pm16;

 		

  		memcpy(hda->vxdname, SVGA_vxd_name, sizeof(SVGA_vxd_name));

 		

@@ -673,17 +639,25 @@ BOOL SVGA3D_Init(void)
 DWORD SVGA_pitch(DWORD width, DWORD bpp)

 {

 	DWORD bp = (bpp + 7) / 8;

-	return (bp * width + 3) & 0xFFFFFFFC;

+	return (bp * width + 3) & 0xFFFFFFFCUL;

 }

 

+static DWORD SVGA_DT_stride(DWORD w, DWORD h)

+{

+	DWORD stride = SVGA_pitch(w, 32) * h;

+	

+	return (stride + 65535) & 0xFFFF0000UL;

+}

+

+/**

+ *

+ * @return: screen offset to VRAM

+ **/

 static void SVGA_defineScreen(DWORD w, DWORD h, DWORD bpp, DWORD offset)

 {

   SVGAFifoCmdDefineScreen *screen;

-  SVGAFifoCmdDefineGMRFB  *fbgmr;

   DWORD cmdoff = 0;

   

-  DWORD pitch = SVGA_pitch(w, bpp);

-  

   wait_for_cmdbuf();

   

   screen = SVGA_cmd_ptr(cmdbuf, &cmdoff, SVGA_CMD_DEFINE_SCREEN, sizeof(SVGAFifoCmdDefineScreen));

@@ -698,43 +672,47 @@ static void SVGA_defineScreen(DWORD w, DWORD h, DWORD bpp, DWORD offset)
 	screen->screen.root.y = 0;

 	screen->screen.cloneCount = 0;

 

-	if(bpp < 32)

-	{

-		screen->screen.backingStore.pitch = pitch;

-	}

+	screen->screen.backingStore.pitch = SVGA_pitch(w, bpp);

+	screen->screen.backingStore.ptr.offset = 0; /* vmware, always 0 for primary surface  */

+	screen->screen.backingStore.ptr.gmrId = SVGA_GMR_FRAMEBUFFER; /* must be framebuffer */

 	

-	screen->screen.backingStore.ptr.offset = offset;

-	screen->screen.backingStore.ptr.gmrId = SVGA_GMR_FRAMEBUFFER;

+	submit_cmdbuf(cmdoff, SVGA_CB_SYNC|SVGA_CB_FORCE_FIFO, 0);

+}

 

-  /* set GMR to same location as screen */

-  if(bpp >= 15/* || bpp < 32*/)

-  {

-  	fbgmr = SVGA_cmd_ptr(cmdbuf, &cmdoff, SVGA_CMD_DEFINE_GMRFB, sizeof(SVGAFifoCmdDefineGMRFB));

-	  

-	  if(fbgmr)

-	  {

-	  	fbgmr->ptr.gmrId = SVGA_GMR_FRAMEBUFFER;

-	  	fbgmr->ptr.offset = offset;

-	  	fbgmr->bytesPerLine = pitch;

-	  	fbgmr->format.colorDepth = bpp;

-	  	if(bpp >= 24)

-	  	{

-	  		fbgmr->format.bitsPerPixel = 32;

-	  		fbgmr->format.colorDepth   = 24;

-	  		fbgmr->format.reserved     = 0;

-	  	}

-	  	else

-	  	{

-	  		fbgmr->format.bitsPerPixel = 16;

-	  		fbgmr->format.colorDepth   = 16;

-	  		fbgmr->format.reserved     = 0;

-	  	}

-	  }

+static void SVGA_FillGMRFB(SVGAFifoCmdDefineGMRFB *fbgmr)

+{

+	fbgmr->ptr.gmrId = SVGA_GMR_FRAMEBUFFER;

+	fbgmr->ptr.offset = hda->surface;

+	fbgmr->bytesPerLine = hda->pitch;

+	fbgmr->format.colorDepth = hda->bpp;

+	if(hda->bpp >= 24)

+	{

+		fbgmr->format.bitsPerPixel = 32;

+		fbgmr->format.colorDepth   = 24;

+		fbgmr->format.reserved     = 0;

+	}

+	else

+	{

+		fbgmr->format.bitsPerPixel = 16;

+		fbgmr->format.colorDepth   = 16;

+		fbgmr->format.reserved     = 0;

 	}

-	

-	submit_cmdbuf(cmdoff, SVGA_CB_SYNC|SVGA_CB_FORCE_FIFO, 0);

 }

 

+static void SVGA_DefineGMRFB()

+{

+	SVGAFifoCmdDefineGMRFB *gmrfb;

+	DWORD cmd_offset = 0;

+

+	wait_for_cmdbuf();

+	  	

+	gmrfb = SVGA_cmd_ptr(cmdbuf, &cmd_offset, SVGA_CMD_DEFINE_GMRFB, sizeof(SVGAFifoCmdDefineGMRFB));

+	SVGA_FillGMRFB(gmrfb);

+	submit_cmdbuf(cmd_offset, 0, 0);

+	

+	dbg_printf("SVGA_DefineGMRFB: %ld\n", hda->surface);

+	

+}

 

 /**

  * Test if display mode is supported

@@ -747,9 +725,6 @@ BOOL SVGA_validmode(DWORD w, DWORD h, DWORD bpp)
 		case 16:

 		case 32:

 			break;

-		case 24:

-			if(!st_useable(24)) return FALSE;

-			break;

 		default:

 			return FALSE;

 	}

@@ -826,7 +801,7 @@ BOOL SVGA_setmode(DWORD w, DWORD h, DWORD bpp)
 	SVGA_CB_stop();

   

    /* setup by legacy registry */

-  if(st_useable(bpp))

+  if(SVGA_hasAccelScreen())

   {

 		SVGA_SetModeLegacy(w, h, 32);

 	}

@@ -834,6 +809,7 @@ BOOL SVGA_setmode(DWORD w, DWORD h, DWORD bpp)
 	{

 		SVGA_SetModeLegacy(w, h, bpp);

 	}

+	

 	/* VMware, vGPU10: OK, when screen has change, whoale GPU is reset including FIFO */

 	SVGA_Enable();

 	

@@ -842,15 +818,14 @@ BOOL SVGA_setmode(DWORD w, DWORD h, DWORD bpp)
 	/* setting screen by fifo, this method is required in VB 6.1 */

 	if(SVGA_hasAccelScreen())

 	{

-		if(!st_useable(bpp))

-		{

-			SVGA_defineScreen(w, h, bpp, 0);

+		SVGA_defineScreen(w, h, bpp, 0);

 			

-			/* reenable fifo */

-			SVGA_Enable();

-		}

+		/* reenable fifo */

+		SVGA_Enable();

 		

 		SVGA_Flush();

+		

+		/* TODO, not do this on vGPU10 */

 	}

 	SVGA_Sync();

 	

@@ -864,56 +839,43 @@ BOOL SVGA_setmode(DWORD w, DWORD h, DWORD bpp)
 	

 	hda->flags &= ~((DWORD)FB_SUPPORT_FLIPING);

 	

-	if(st_useable(bpp))

-	{

-		SVGA_CB_stop();

-		st_defineScreen(w, h, bpp);

-		hda->flags |= FB_ACCEL_VMSVGA10_ST;

-		

-		SVGA_CB_start();

-	}

-	else

+	hda->flags &= ~((DWORD)FB_ACCEL_VMSVGA10_ST);

+

+	hda->vram_pm32 = (void*)gSVGA.fbLinear;

+	hda->vram_size = gSVGA.vramSize;

+	hda->vram_pm16 = fb_pm16;

+

+	hda->width   = w;//SVGA_ReadReg(SVGA_REG_WIDTH);

+	hda->height  = h;//SVGA_ReadReg(SVGA_REG_HEIGHT);

+	

+	if(SVGA_hasAccelScreen())

 	{

-		hda->flags &= ~((DWORD)FB_ACCEL_VMSVGA10_ST);

-		

-		if(bpp >= 15)

+		if(bpp >= 8)

 		{

-			hda->flags |= FB_SUPPORT_FLIPING;

+			DWORD offset = SVGA_DT_stride(hda->width, hda->height);

+			

+			hda->bpp     = bpp;

+			hda->pitch   = SVGA_pitch(hda->width, bpp);

+			hda->system_surface = offset;

+			hda->surface = offset;

+		}

+		else

+		{

+			hda->bpp     = SVGA_ReadReg(SVGA_REG_BITS_PER_PIXEL);

+			hda->pitch   = SVGA_ReadReg(SVGA_REG_BYTES_PER_LINE);

+			hda->surface = 0;

+			hda->system_surface = 0;

 		}

-	}

-	

-	if(st_useable(bpp))

-	{

-		hda->vram_pm32 = (void*)st_address;

-		hda->vram_size = st_surface_mb*1024*1024;

-		hda->vram_pm16 = st_pm16;

-	}

-	else

-	{

-		hda->vram_pm32 = (void*)gSVGA.fbLinear;

-		hda->vram_size = gSVGA.vramSize;

-		hda->vram_pm16 = fb_pm16;

-	}

-

-	hda->width   = SVGA_ReadReg(SVGA_REG_WIDTH);

-	hda->height  = SVGA_ReadReg(SVGA_REG_HEIGHT);

-	if(st_useable(bpp))

-	{

-		/*

-		 when screen target is used, screen bpp and pitch may be different from 

-		 backscreen surface.

-		 */

-		hda->bpp     = bpp;

-		hda->pitch   = SVGA_pitch(hda->width, bpp);

 	}

 	else

 	{

 		hda->bpp     = SVGA_ReadReg(SVGA_REG_BITS_PER_PIXEL);

 		hda->pitch   = SVGA_ReadReg(SVGA_REG_BYTES_PER_LINE);

+		hda->surface = 0;

+		hda->system_surface = 0;

 	}

 	hda->stride  = hda->height * hda->pitch;

-	hda->surface = 0;

-

+	

 	if(has3D && SVGA_GetDevCap(SVGA3D_DEVCAP_3D) > 0)

 	{

 		hda->flags |= FB_ACCEL_VMSVGA3D;

@@ -923,6 +885,12 @@ BOOL SVGA_setmode(DWORD w, DWORD h, DWORD bpp)
 		hda->flags &= ~((DWORD)FB_ACCEL_VMSVGA3D);

 	}

 	

+	if(hda->system_surface > 0)

+	{

+		hda->flags |= FB_SUPPORT_FLIPING;

+		SVGA_DefineGMRFB();

+	}

+	

 	mouse_invalidate();

 	FBHDA_access_end(0);

 

@@ -1079,47 +1047,19 @@ BOOL SVGA_valid()
 

 BOOL FBHDA_swap(DWORD offset)

 {

-  if(hda->bpp == 32)

-  {

-  	FBHDA_access_begin(0);

-  	SVGA_defineScreen(hda->width, hda->height, hda->bpp, offset);

-	  hda->surface = offset;

-	  FBHDA_access_end(0);

-	  

-	  return TRUE;

-	}

-	else

+	BOOL rc = FALSE;

+	if(offset >= hda->system_surface) /* DON'T touch surface 0 */

 	{

-		DWORD ps = (hda->bpp + 7) / 8;

-		DWORD offset_y = offset/hda->pitch;

-		DWORD offset_x = (offset % hda->pitch)/ps;

-		

-		if(offset_y > 0 || offset_x > 0)

-		{

-			offset_y = 1;

-			offset_x = 0;

+	 	FBHDA_access_begin(0);

+	 	if(hda->bpp > 8)

+	 	{

+	 		SVGA_DefineGMRFB();

+	  	hda->surface = offset;

 		}

-		

-		SVGA_WriteReg(SVGA_REG_NUM_GUEST_DISPLAYS, 1);

-		SVGA_WriteReg(SVGA_REG_DISPLAY_ID, 0);

-		SVGA_WriteReg(SVGA_REG_DISPLAY_IS_PRIMARY, 1);

-		SVGA_WriteReg(SVGA_REG_DISPLAY_POSITION_X, offset_x);

-		SVGA_WriteReg(SVGA_REG_DISPLAY_POSITION_Y, offset_y);

-		SVGA_WriteReg(SVGA_REG_DISPLAY_WIDTH,      hda->width);

-		SVGA_WriteReg(SVGA_REG_DISPLAY_HEIGHT,     hda->height);

-		SVGA_WriteReg(SVGA_REG_DISPLAY_ID,         SVGA_ID_INVALID);

-		

-		hda->surface = offset;

-	  

-	  return TRUE;

+	  FBHDA_access_end(0);

 	}

-	

-	return FALSE;

-}

 

-void FBHDA_access_begin(DWORD flags)

-{

-	FBHDA_access_rect(0, 0, hda->width, hda->height);

+	return rc;

 }

 

 static DWORD rect_left;

@@ -1127,125 +1067,249 @@ static DWORD rect_top;
 static DWORD rect_right;

 static DWORD rect_bottom;

 

-void FBHDA_access_rect(DWORD left, DWORD top, DWORD right, DWORD bottom)

+static inline void update_rect(DWORD left, DWORD top, DWORD right, DWORD bottom)

 {

-	Wait_Semaphore(hda_sem, 0);

-	

-	if(fb_lock_cnt++ == 0)

+	if(left < rect_left)

+		rect_left = left;

+

+	if(top < rect_top)

+		rect_top = top;

+

+	if(right > rect_right)

 	{

-		BOOL readback = FALSE;

-		SVGA_CMB_wait_update();

-		

-		if(ST_FB_invalid)

+		rect_right = right;

+		if(rect_right > hda->width)

 		{

-			readback = TRUE;		

-			ST_FB_invalid = FALSE;

+			rect_right = hda->width;

 		}

-		

-		if(readback)

+	}

+

+	if(bottom > rect_bottom)

+	{

+		rect_bottom = bottom;

+		if(rect_bottom > hda->height)

 		{

-			if(st_useable(hda->bpp))

+			rect_bottom = hda->height;

+		}

+	}

+}

+

+static inline void check_dirty()

+{

+	if(surface_dirty)

+	{

+		switch(hda->bpp)

+		{

+			case 32:

 			{

-				DWORD cmd_offset = 0;

-				SVGA3dCmdReadbackGBSurface *gbreadback;

-				

+			 	SVGAFifoCmdBlitScreenToGMRFB *gmrblit;

+			 	DWORD cmd_offset = 0;

+		

 				wait_for_cmdbuf();

-				

-				gbreadback = SVGA_cmd3d_ptr(cmdbuf, &cmd_offset, SVGA_3D_CMD_READBACK_GB_SURFACE, sizeof(SVGA3dCmdReadbackGBSurface));

-				gbreadback->sid = ST_SURFACE_ID;

-				submit_cmdbuf(cmd_offset, SVGA_CB_SYNC, 0);

+						

+				gmrblit = SVGA_cmd_ptr(cmdbuf, &cmd_offset, SVGA_CMD_BLIT_SCREEN_TO_GMRFB, sizeof(SVGAFifoCmdBlitScreenToGMRFB));

+	

+				gmrblit->destOrigin.x    = 0;

+				gmrblit->destOrigin.y    = 0;

+				gmrblit->srcRect.left    = 0;

+				gmrblit->srcRect.top     = 0;

+				gmrblit->srcRect.right   = hda->width;

+				gmrblit->srcRect.bottom  = hda->height;

+				gmrblit->srcScreenId = 0;

+				  	

+				submit_cmdbuf(cmd_offset, SVGA_CB_UPDATE, 0);

+				break;

 			}

-		}

+			case 16:

+			{

+				readback16(

+					hda->vram_pm32, SVGA_pitch(hda->width, 32),

+					((BYTE*)hda->vram_pm32)+hda->surface, hda->pitch,

+					0, 0, hda->width, hda->height

+				);

+				break;

+			}

+		} // switch

 		

-		mouse_erase();

+		surface_dirty = FALSE;

+	}

+}

+

+void FBHDA_access_rect(DWORD left, DWORD top, DWORD right, DWORD bottom)

+{

+	Wait_Semaphore(hda_sem, 0);

+	

+/*	dbg_printf("FBHDA_access_rect(%ld, %ld, %ld, %ld)\n",

+		left, top, right, bottom

+	);*/

+	

+	if(left > hda->width)

+		return;

+	

+	if(top > hda->height)

+		return;

+	

+	if(right > hda->width)

+		right = hda->width;

+	

+	if(bottom > hda->height)

+		bottom = hda->height;

+

+	if(fb_lock_cnt++ == 0)

+	{

+		SVGA_CMB_wait_update();

+		check_dirty();

 		

 		rect_left   = left;

 		rect_top    = top;

 		rect_right  = right;

 		rect_bottom = bottom;

+

+		mouse_erase();

+

+		if(mouse_get_rect(&left, &top, &right, &bottom))

+		{

+			update_rect(left, top, right, bottom);

+		}

 	}

 	else

 	{

-		if(left < rect_left)

-			rect_left = left;

+		update_rect(left, top, right, bottom);

+	}

+

+	Signal_Semaphore(hda_sem);

+}

+

+void FBHDA_access_begin(DWORD flags)

+{

+	if(flags & (FBHDA_ACCESS_RAW_BUFFERING | FBHDA_ACCESS_MOUSE_MOVE))

+	{

+		Wait_Semaphore(hda_sem, 0);

+		check_dirty();

 		

-		if(top < rect_top)

-			rect_top = top;

+//		dbg_printf("FBHDA_access_begin(%ld)\n", flags);

 		

-		if(right > rect_right)

-			rect_right = right;

+		if(fb_lock_cnt++ == 0)

+		{

+			SVGA_CMB_wait_update();

+			mouse_erase();

+			

+			if(!mouse_get_rect(&rect_left, &rect_top, &rect_right, &rect_bottom))

+			{

+				rect_left   = 0;

+				rect_top    = 0;

+				rect_right  = 0;

+				rect_bottom = 0;

+			}

+		}

+		else

+		{

+			DWORD l, t, r, b;

+			

+			if(mouse_get_rect(&l, &t, &r, &b))

+			{

+				update_rect(l, t, r, b);

+			}

+		}

 		

-		if(bottom > rect_bottom)

-			rect_bottom = bottom;

+		Signal_Semaphore(hda_sem);

+	}

+	else

+	{

+		FBHDA_access_rect(0, 0, hda->width, hda->height);

 	}

-	

-	Signal_Semaphore(hda_sem);

 }

 

 void FBHDA_access_end(DWORD flags)

 {

 	Wait_Semaphore(hda_sem, 0);

+	

+	if(flags & FBHDA_ACCESS_MOUSE_MOVE)

+	{

+		DWORD l, t, r, b;

+		

+		if(mouse_get_rect(&l, &t, &r, &b))

+		{

+			update_rect(l, t, r, b);

+		}

+	}

 

 	fb_lock_cnt--;

 	if(fb_lock_cnt < 0) fb_lock_cnt = 0;

 	

 	if(fb_lock_cnt == 0)

 	{

-		mouse_blit();		

-		if(st_useable(hda->bpp))

+		BOOL need_refresh = ((hda->bpp == 32) && (hda->system_surface == 0));

+		

+/*		dbg_printf("FBHDA_access_end(%ld %ld %ld %ld)\n", 

+			rect_left, rect_top, rect_right, rect_bottom);*/

+		mouse_blit();

+		if(hda->surface > 0)

 		{

-			SVGA3dCmdUpdateGBSurface *gbupdate;

-			SVGA3dCmdUpdateGBScreenTarget *stupdate;

-			SVGA3dCmdUpdateGBImage   *gbupdate_rect;

-			DWORD cmd_offset = 0;

-			DWORD w = rect_right - rect_left;

-			DWORD h = rect_bottom - rect_top;

-

-		 	wait_for_cmdbuf();

-

-			if(w == hda->width && h == hda->height)

+			switch(hda->bpp)

 			{

-				/* full screen update */

-				gbupdate = SVGA_cmd3d_ptr(cmdbuf, &cmd_offset, SVGA_3D_CMD_UPDATE_GB_SURFACE, sizeof(SVGA3dCmdUpdateGBSurface));

-				gbupdate->sid = ST_SURFACE_ID;

-			}

-			else

-			{

-				/* partial box */

-				gbupdate_rect = SVGA_cmd3d_ptr(cmdbuf, &cmd_offset, SVGA_3D_CMD_UPDATE_GB_IMAGE, sizeof(SVGA3dCmdUpdateGBImage));

-				gbupdate_rect->image.sid = ST_SURFACE_ID;

-				gbupdate_rect->image.face = 0;

-				gbupdate_rect->image.mipmap = 0;

-				gbupdate_rect->box.x = rect_left;

-				gbupdate_rect->box.y = rect_top;

-				gbupdate_rect->box.z = 0;

-				gbupdate_rect->box.w = w;

-				gbupdate_rect->box.h = h;

-				gbupdate_rect->box.d = 1;

-			}

-

-			stupdate = SVGA_cmd3d_ptr(cmdbuf, &cmd_offset, SVGA_3D_CMD_UPDATE_GB_SCREENTARGET, sizeof(SVGA3dCmdUpdateGBScreenTarget));

-			stupdate->stid = 0;

-	  	stupdate->rect.x = rect_left;

-	  	stupdate->rect.y = rect_top;

-	  	stupdate->rect.w = w;

-	  	stupdate->rect.h = h;

-

-			submit_cmdbuf(cmd_offset, SVGA_CB_UPDATE, 0);

+				case 32:

+				{

+					DWORD w, h;

+			  	SVGAFifoCmdBlitGMRFBToScreen *gmrblit;

+			  	DWORD cmd_offset = 0;

+		

+					w = rect_right - rect_left;

+					h = rect_bottom - rect_top;

+					

+					if(w > 0 && h > 0)

+					{

+						wait_for_cmdbuf();

+						

+				  	gmrblit = SVGA_cmd_ptr(cmdbuf, &cmd_offset, SVGA_CMD_BLIT_GMRFB_TO_SCREEN, sizeof(SVGAFifoCmdBlitGMRFBToScreen));

+	

+				  	gmrblit->srcOrigin.x      = rect_left;

+				  	gmrblit->srcOrigin.y      = rect_top;

+				  	gmrblit->destRect.left    = rect_left;

+				  	gmrblit->destRect.top     = rect_top;

+				  	gmrblit->destRect.right   = rect_right;

+				  	gmrblit->destRect.bottom  = rect_bottom;

+	

+				  	gmrblit->destScreenId = 0;

+				  	

+						submit_cmdbuf(cmd_offset, SVGA_CB_UPDATE, 0);

+					}

+					break;

+				}

+				case 16:

+					blit16(

+						((BYTE*)hda->vram_pm32)+hda->surface, hda->pitch,

+						hda->vram_pm32,  SVGA_pitch(hda->width, 32),

+						rect_left, rect_top,

+						rect_right - rect_left, rect_bottom - rect_top

+					);

+					need_refresh = TRUE;

+					break;

+				case 8:

+					blit8(

+						((BYTE*)hda->vram_pm32)+hda->surface, hda->pitch,

+						hda->vram_pm32,  SVGA_pitch(hda->width, 32),

+						rect_left, rect_top,

+						rect_right - rect_left, rect_bottom - rect_top

+					);

+					need_refresh = TRUE;

+					break;

+			} // switch

 		}

-	  else if(hda->bpp == 32)

+

+	  if(need_refresh)

 	  {

-	  	SVGAFifoCmdUpdate  *cmd_update;

+	  	SVGAFifoCmdUpdate *cmd_update;

 	  	DWORD cmd_offset = 0;

 

 	  	wait_for_cmdbuf();

 

 	  	cmd_update = SVGA_cmd_ptr(cmdbuf, &cmd_offset, SVGA_CMD_UPDATE, sizeof(SVGAFifoCmdUpdate));

-	  	cmd_update->x = 0;

-	  	cmd_update->y = 0;

-	  	cmd_update->width  = hda->width;

-	  	cmd_update->height = hda->height;

-	  	

+	  	cmd_update->x = rect_left;

+	  	cmd_update->y = rect_top;

+	  	cmd_update->width  = rect_right - rect_left;

+	  	cmd_update->height = rect_bottom - rect_top;

+

 			submit_cmdbuf(cmd_offset, SVGA_CB_UPDATE, 0);

 	  }

 	} // fb_lock_cnt == 0

@@ -1253,20 +1317,35 @@ void FBHDA_access_end(DWORD flags)
 	Signal_Semaphore(hda_sem);

 }

 

-void  FBHDA_palette_set(unsigned char index, DWORD rgb)

+void FBHDA_palette_set(unsigned char index, DWORD rgb)

 {

-	UINT sIndex = SVGA_PALETTE_BASE + index*3;

-	

-  SVGA_WriteReg(sIndex+0, (rgb >> 16) & 0xFF);

-  SVGA_WriteReg(sIndex+1, (rgb >>  8) & 0xFF);

-  SVGA_WriteReg(sIndex+2,  rgb        & 0xFF);

+	if(hda->system_surface > 0)

+	{

+		palette_emulation[index] = rgb;

+	}

+	else

+	{

+		UINT sIndex = SVGA_PALETTE_BASE + index*3;

+		

+  	SVGA_WriteReg(sIndex+0, (rgb >> 16) & 0xFF);

+  	SVGA_WriteReg(sIndex+1, (rgb >>  8) & 0xFF);

+  	SVGA_WriteReg(sIndex+2,  rgb        & 0xFF);

+  }

+  hda->palette_update++;

 }

 

 DWORD FBHDA_palette_get(unsigned char index)

 {

-	UINT sIndex = SVGA_PALETTE_BASE + index*3;

+	if(hda->system_surface > 0)

+	{

+		return palette_emulation[index];

+	}

+	else

+	{

+		UINT sIndex = SVGA_PALETTE_BASE + index*3;

 	

-	return ((SVGA_ReadReg(sIndex+0) & 0xFF) << 16) |

-		((SVGA_ReadReg(sIndex+1) & 0xFF) << 8) |

-		 (SVGA_ReadReg(sIndex+2) & 0xFF);

+		return ((SVGA_ReadReg(sIndex+0) & 0xFF) << 16) |

+			((SVGA_ReadReg(sIndex+1) & 0xFF) << 8) |

+		 	(SVGA_ReadReg(sIndex+2) & 0xFF);

+	}

 }

diff --git a/vxd_svga.h b/vxd_svga.h
index 4d2a4c4..7b56564 100644
--- a/vxd_svga.h
+++ b/vxd_svga.h
@@ -30,19 +30,9 @@ void SVGA_fence_wait_dbg(DWORD fence_id, int line);
 #define SVGA_fence_wait(_fence) SVGA_fence_wait_dbg(_fence, __LINE__)

 #endif

 

-

-/* screen target */

-extern BOOL  st_used;

-extern DWORD st_flags;

-BOOL st_memory_allocate(DWORD size, DWORD *out);

-void st_defineScreen(DWORD w, DWORD h, DWORD bpp);

-void st_destroyScreen();

-

-SVGA_DB_surface_t *SVGA_GetSurfaceInfo(DWORD sid);

-BOOL st_useable(DWORD bpp);

-

 /* VDD */

 DWORD map_pm16(DWORD vm, DWORD linear, DWORD size);

+void update_pm16(DWORD vm, DWORD oldmap, DWORD linear, DWORD size);

 

 void SVGA_Sync();

 void SVGA_Flush_CB();

diff --git a/vxd_svga_cb.c b/vxd_svga_cb.c
index b6e80eb..b368ba7 100644
--- a/vxd_svga_cb.c
+++ b/vxd_svga_cb.c
@@ -80,8 +80,12 @@ extern BOOL gb_support;
 extern BOOL cb_support;

 extern BOOL cb_context0;

 

+extern BOOL surface_dirty;

+

 //extern DWORD present_fence;

-extern BOOL ST_FB_invalid;

+//extern BOOL ST_FB_invalid;

+

+extern FBHDA_t *hda;

 

 BOOL CB_queue_check(SVGACBHeader *tracked);

 inline BOOL CB_queue_check_inline(SVGACBHeader *tracked);

@@ -207,12 +211,17 @@ inline BOOL CB_queue_check_inline(SVGACBHeader *tracked)
 			

 			if(cb->status > SVGA_CB_STATUS_COMPLETED)

 			{

-				#ifdef DBGPRINT

+				DWORD *cmd_ptr = (DWORD*)(cb+1);

+				dbg_printf("Error (%ld): offset %ld, error command: %ld\n", cb->status, cb->errorOffset, cmd_ptr[cb->errorOffset/4]);

+				if(cmd_ptr[cb->errorOffset/4] == SVGA_CMD_UPDATE)

 				{

-					DWORD *cmd_ptr = (DWORD*)(cb+1);

-					dbg_printf(dbg_cb_error, cb->status, cb->errorOffset, cmd_ptr[cb->errorOffset/4]);

+					if(cmd_ptr[0] == SVGA_3D_CMD_SURFACE_DMA)

+					{

+						dbg_printf("VMware update bug detected!\n");

+						hda->flags |= FB_BUG_VMWARE_UPDATE;

+					}

 				}

-				#endif

+				

 				need_restart = TRUE;

 			}

 			

@@ -369,7 +378,7 @@ static DWORD flags_to_cbq(DWORD cb_flags)
 	

 	if((cb_flags & SVGA_CB_UPDATE) != 0)

 	{

-		r |= SVGA_CB_UPDATE;

+		r |= CBQ_UPDATE;

 	}

 	

 	return r;

@@ -486,7 +495,7 @@ void SVGA_CMB_submit(DWORD FBPTR cmb, DWORD cmb_size, SVGA_CMB_status_t FBPTR st
 	

 	if(flags & SVGA_CB_DIRTY_SURFACE)

 	{

-		ST_FB_invalid = TRUE;

+		surface_dirty = TRUE;

 	}

 

 	if(proc_by_cb)

diff --git a/vxd_svga_mouse.c b/vxd_svga_mouse.c
index f564847..7769c49 100644
--- a/vxd_svga_mouse.c
+++ b/vxd_svga_mouse.c
@@ -192,6 +192,7 @@ BOOL SVGA_mouse_load()
 

 BOOL SVGA_mouse_hw()

 {

+#if 0

 	if(st_used)

 	{

 		if(st_flags & ST_CURSOR)

@@ -202,6 +203,7 @@ BOOL SVGA_mouse_hw()
 			}

 		}

 	}

+#endif

 	

 	return FALSE;

 }

@@ -241,7 +243,9 @@ void SVGA_mouse_hide(BOOL invalidate)
 	gSVGA.fifoMem[SVGA_FIFO_CURSOR_ON] = 0;

 	

 	/* vbox bug, move cursor outside screen */

+#if 0

 	if((st_flags & ST_CURSOR_HIDEABLE) == 0)

+#endif

 	{

 		gSVGA.fifoMem[SVGA_FIFO_CURSOR_X] = hda->width;

 		gSVGA.fifoMem[SVGA_FIFO_CURSOR_Y] = hda->height;

diff --git a/vxd_vdd.c b/vxd_vdd.c
index 422b1c4..af7b200 100644
--- a/vxd_vdd.c
+++ b/vxd_vdd.c
@@ -92,6 +92,18 @@ DWORD map_pm16(DWORD vm, DWORD linear, DWORD size)
 	return selector << 16;

 }

 

+void update_pm16(DWORD vm, DWORD oldmap, DWORD linear, DWORD size)

+{

+	WORD selector = oldmap >> 16;

+	DWORD hi  = 0;

+	DWORD low = 0;

+	

+	dbg_printf("update_pm16: %ld\n", linear);

+	

+	_BuildDescriptorDWORDs(linear, RoundToPages(size), 0x92, 0x80, 0, &hi, &low);

+	_SetDescriptor(selector, vm, hi, low, 0);

+}

+

 /*

 You can implement all the VESA support entirely in your mini-VDD. Doing so will

 cause VESA applications to run more efficiently since all of the VESA support is

@@ -128,7 +140,7 @@ See also VDD_REGISTER_DISPLAY_DRIVER_INFO.
 **/

 VDDPROC(REGISTER_DISPLAY_DRIVER, register_display_driver)

 {

-	dbg_printf(dbg_register, state->Client_EBX, state->Client_ECX, ThisVM);

+	dbg_printf("register: ebx = %ld, ecx = %ld, VM = %lX\n", state->Client_EBX, state->Client_ECX, ThisVM);

 	

 	if(hda->vram_pm16 == 0)

 	{