GLOBAL VOID
AAA()
{
if ( (GET_AL() & 0xf) > 9 || GET_AF() )
{
SET_AX(GET_AX() + 6);
SET_AH(GET_AH() + 1);
SET_CF(1);
SET_AF(1);
}
else
{
SET_CF(0);
SET_AF(0);
}
SET_AL(GET_AL() & 0xf);
/* Set undefined flag(s) */
#ifdef SET_UNDEFINED_FLAG
SET_OF(UNDEFINED_FLAG);
SET_SF(UNDEFINED_FLAG);
SET_ZF(UNDEFINED_FLAG);
SET_PF(UNDEFINED_FLAG);
#endif
}
/**********************************************************************
* DOSVM_Int25Handler
*
* Handler for int 25h (absolute disk read).
*/
void WINAPI DOSVM_Int25Handler( CONTEXT *context )
{
WCHAR drivespec[4] = {'A', ':', '\\', 0};
BYTE *dataptr = CTX_SEG_OFF_TO_LIN( context, context->SegDs, context->Ebx );
DWORD begin;
DWORD length;
drivespec[0] += AL_reg( context );
if (GetDriveTypeW( drivespec ) == DRIVE_NO_ROOT_DIR ||
GetDriveTypeW( drivespec ) == DRIVE_UNKNOWN)
{
SET_CFLAG( context );
SET_AX( context, 0x0201 ); /* unknown unit */
return;
}
if (CX_reg( context ) == 0xffff)
{
begin = *(DWORD *)dataptr;
length = *(WORD *)(dataptr + 4);
dataptr = (BYTE *)CTX_SEG_OFF_TO_LIN( context,
*(WORD *)(dataptr + 8),
*(DWORD *)(dataptr + 6) );
}
else
{
begin = DX_reg( context );
length = CX_reg( context );
}
DOSVM_RawRead( AL_reg( context ), begin, length, dataptr, TRUE );
RESET_CFLAG( context );
}
GLOBAL VOID
CMPXCHG16
IFN2(
IU32 *, pop1, /* pntr to dst/lsrc operand */
IU32, op2 /* rsrc operand */
)
{
/*
First do comparision and generate flags.
*/
CMP((IU32)GET_AX(), *pop1, 16);
/*
Then swap data as required.
*/
if ( GET_ZF() ) /* ie iff AX == op1 */
{
*pop1 = op2;
}
else
{
SET_AX(*pop1);
}
}
/**********************************************************************
* EMS_restore_context
*
* Restore physical page mappings from handle specific save area.
*/
static void EMS_restore_context( CONTEXT86 *context )
{
WORD handle = DX_reg(context);
int i;
for(i=0; i<4; i++) {
int hindex = EMS_record->mapping_save_area[handle][i].hindex;
int logical_page = EMS_record->mapping_save_area[handle][i].logical_page;
if(EMS_map( i, hindex, logical_page )) {
SET_AX( context, 0x8e ); /* status: restore of mapping context failed */
return;
}
}
SET_AX( context, 0 ); /* status: ok */
}
/**********************************************************************
* FreeRMCB (WINEDOS.@)
*/
void WINAPI DOSVM_FreeRMCB( CONTEXT86 *context )
{
FIXME("callback address: %04x:%04x\n",
CX_reg(context), DX_reg(context));
if (DPMI_FreeRMCB(MAKELONG(DX_reg(context), CX_reg(context)))) {
SET_AX( context, 0x8024 ); /* invalid callback address */
SET_CFLAG(context);
}
}
/**********************************************************************
* EMS_save_context
*
* Save physical page mappings into handle specific save area.
*/
static void EMS_save_context( CONTEXT86 *context )
{
WORD h = DX_reg(context);
int i;
for(i=0; i<4; i++) {
EMS_record->mapping_save_area[h][i].hindex = EMS_record->mapping[i].hindex;
EMS_record->mapping_save_area[h][i].logical_page = EMS_record->mapping[i].logical_page;
}
SET_AX( context, 0 ); /* status: ok */
}
/**********************************************************************
* INT33_ResetMouse
*
* Handler for:
* - subfunction 0x00 (reset mouse)
* - subfunction 0x21 (software reset)
*/
static void INT33_ResetMouse( CONTEXT *context )
{
memset( &mouse_info, 0, sizeof(mouse_info) );
/* Set the default mickey/pixel ratio */
mouse_info.HMPratio = 8;
mouse_info.VMPratio = 16;
/* Hide the mouse cursor */
mouse_info.hide_count = 1;
VGA_ShowMouse( FALSE );
if (context)
{
SET_AX( context, 0xFFFF ); /* driver installed */
SET_BX( context, 3 ); /* number of buttons */
}
}
/********************************************************************** * DOSVM_Int11Handler * * Handler for int 11h (get equipment list). * * * Borrowed from Ralph Brown's interrupt lists: * * bits 15-14: number of parallel devices * bit 13: [Conv] Internal modem * bit 12: reserved * bits 11- 9: number of serial devices * bit 8: reserved * bits 7- 6: number of diskette drives minus one * bits 5- 4: Initial video mode: * 00b = EGA,VGA,PGA * 01b = 40 x 25 color * 10b = 80 x 25 color * 11b = 80 x 25 mono * bit 3: reserved * bit 2: [PS] =1 if pointing device * [non-PS] reserved * bit 1: =1 if math co-processor * bit 0: =1 if diskette available for boot * * * Currently the only of these bits correctly set are: * * bits 15-14 } Added by William Owen Smith, * bits 11-9 } [email protected] * bits 7-6 * bit 2 (always set) ( bit 2 = 4 ) * bit 1 } Robert 'Admiral' Coeyman * All *nix systems either have a math processor or * emulate one. */ static void WINAPI DOSVM_Int11Handler( CONTEXT86 *context ) { int diskdrives = 0; int parallelports = 0; int serialports = 0; int x; if (GetDriveTypeA("A:\\") == DRIVE_REMOVABLE) diskdrives++; if (GetDriveTypeA("B:\\") == DRIVE_REMOVABLE) diskdrives++; if (diskdrives) diskdrives--; for (x=0; x < 9; x++) { HANDLE handle; char file[10]; /* serial port name */ sprintf( file, "\\\\.\\COM%d", x+1 ); handle = CreateFileA( file, 0, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0 ); if (handle != INVALID_HANDLE_VALUE) { CloseHandle( handle ); serialports++; } sprintf( file, "\\\\.\\LPT%d", x+1 ); handle = CreateFileA( file, 0, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0 ); if (handle != INVALID_HANDLE_VALUE) { CloseHandle( handle ); parallelports++; } } if (serialports > 7) /* 3 bits -- maximum value = 7 */ serialports = 7; if (parallelports > 3) /* 2 bits -- maximum value = 3 */ parallelports = 3; SET_AX( context, (diskdrives << 6) | (serialports << 9) | (parallelports << 14) | 0x06 ); }
/**********************************************************************
* AllocRMCB (WINEDOS.@)
*/
void WINAPI DOSVM_AllocRMCB( CONTEXT86 *context )
{
RMCB *NewRMCB = DPMI_AllocRMCB();
TRACE("Function to call: %04x:%04x\n", (WORD)context->SegDs, SI_reg(context) );
if (NewRMCB)
{
NewRMCB->proc_ofs = DOSVM_IsDos32() ? context->Esi : LOWORD(context->Esi);
NewRMCB->proc_sel = context->SegDs;
NewRMCB->regs_ofs = DOSVM_IsDos32() ? context->Edi : LOWORD(context->Edi);
NewRMCB->regs_sel = context->SegEs;
SET_CX( context, HIWORD(NewRMCB->address) );
SET_DX( context, LOWORD(NewRMCB->address) );
}
else
{
SET_AX( context, 0x8015 ); /* callback unavailable */
SET_CFLAG(context);
}
}
void WINAPI XMS_Handler( CONTEXT86 *context )
{
switch(AH_reg(context))
{
case 0x00: /* Get XMS version number */
TRACE("get XMS version number\n");
SET_AX( context, 0x0200 ); /* 2.0 */
SET_BX( context, 0x0000 ); /* internal revision */
SET_DX( context, 0x0001 ); /* HMA exists */
break;
case 0x08: /* Query Free Extended Memory */
{
MEMORYSTATUS status;
TRACE("query free extended memory\n");
GlobalMemoryStatus( &status );
SET_DX( context, status.dwAvailVirtual >> 10 );
SET_AX( context, status.dwAvailVirtual >> 10 );
TRACE("returning largest %dK, total %dK\n", AX_reg(context), DX_reg(context));
}
break;
case 0x09: /* Allocate Extended Memory Block */
TRACE("allocate extended memory block (%dK)\n",
DX_reg(context));
SET_DX( context, GlobalAlloc16(GMEM_MOVEABLE, (DWORD)DX_reg(context)<<10) );
SET_AX( context, DX_reg(context) ? 1 : 0 );
if (!DX_reg(context)) SET_BL( context, 0xA0 ); /* out of memory */
break;
case 0x0a: /* Free Extended Memory Block */
TRACE("free extended memory block %04x\n",DX_reg(context));
if(!DX_reg(context) || GlobalFree16(DX_reg(context))) {
SET_AX( context, 0 ); /* failure */
SET_BL( context, 0xa2 ); /* invalid handle */
} else
SET_AX( context, 1 ); /* success */
break;
case 0x0b: /* Move Extended Memory Block */
{
MOVESTRUCT*move=CTX_SEG_OFF_TO_LIN(context,
context->SegDs,context->Esi);
BYTE*src,*dst;
TRACE("move extended memory block\n");
src=XMS_Offset(&move->Source);
dst=XMS_Offset(&move->Dest);
memcpy(dst,src,move->Length);
if (move->Source.Handle) GlobalUnlock16(move->Source.Handle);
if (move->Dest.Handle) GlobalUnlock16(move->Dest.Handle);
break;
}
case 0x88: /* Query Any Free Extended Memory */
{
MEMORYSTATUS status;
SYSTEM_INFO info;
TRACE("query any free extended memory\n");
GlobalMemoryStatus( &status );
GetSystemInfo( &info );
context->Eax = status.dwAvailVirtual >> 10;
context->Edx = status.dwAvailVirtual >> 10;
context->Ecx = (DWORD)info.lpMaximumApplicationAddress;
SET_BL( context, 0 ); /* No errors. */
TRACE("returning largest %dK, total %dK, highest 0x%x\n",
context->Eax, context->Edx, context->Ecx);
}
break;
default:
INT_BARF( context, 0x31 );
SET_AX( context, 0x0000 ); /* failure */
SET_BL( context, 0x80 ); /* function not implemented */
break;
}
}
/**********************************************************************
* DOSVM_Int12Handler
*
* Handler for int 12h (get memory size).
*/
static void WINAPI DOSVM_Int12Handler( CONTEXT86 *context )
{
SET_AX( context, 640 );
}
/**********************************************************************
* DOSVM_Int31Handler (WINEDOS16.149)
*
* Handler for int 31h (DPMI).
*/
void WINAPI DOSVM_Int31Handler( CONTEXT86 *context )
{
RESET_CFLAG(context);
switch(AX_reg(context))
{
case 0x0000: /* Allocate LDT descriptors */
TRACE( "allocate LDT descriptors (%d)\n", CX_reg(context) );
{
WORD sel = AllocSelectorArray16( CX_reg(context) );
if(!sel)
{
TRACE( "failed\n" );
SET_AX( context, 0x8011 ); /* descriptor unavailable */
SET_CFLAG( context );
}
else
{
TRACE( "success, array starts at 0x%04x\n", sel );
SET_AX( context, sel );
}
}
break;
case 0x0001: /* Free LDT descriptor */
TRACE( "free LDT descriptor (0x%04x)\n", BX_reg(context) );
if (FreeSelector16( BX_reg(context) ))
{
SET_AX( context, 0x8022 ); /* invalid selector */
SET_CFLAG( context );
}
else
{
/* If a segment register contains the selector being freed, */
/* set it to zero. */
if (!((context->SegDs^BX_reg(context)) & ~3)) context->SegDs = 0;
if (!((context->SegEs^BX_reg(context)) & ~3)) context->SegEs = 0;
if (!((context->SegFs^BX_reg(context)) & ~3)) context->SegFs = 0;
if (!((context->SegGs^BX_reg(context)) & ~3)) context->SegGs = 0;
}
break;
case 0x0002: /* Real mode segment to descriptor */
TRACE( "real mode segment to descriptor (0x%04x)\n", BX_reg(context) );
{
WORD entryPoint = 0; /* KERNEL entry point for descriptor */
switch(BX_reg(context))
{
case 0x0000: entryPoint = 183; break; /* __0000H */
case 0x0040: entryPoint = 193; break; /* __0040H */
case 0xa000: entryPoint = 174; break; /* __A000H */
case 0xb000: entryPoint = 181; break; /* __B000H */
case 0xb800: entryPoint = 182; break; /* __B800H */
case 0xc000: entryPoint = 195; break; /* __C000H */
case 0xd000: entryPoint = 179; break; /* __D000H */
case 0xe000: entryPoint = 190; break; /* __E000H */
case 0xf000: entryPoint = 194; break; /* __F000H */
default:
FIXME("Real mode segment (%x) to descriptor: no longer supported\n",
BX_reg(context));
SET_CFLAG( context );
break;
}
if (entryPoint)
{
FARPROC16 proc = GetProcAddress16( GetModuleHandle16( "KERNEL" ),
(LPCSTR)(ULONG_PTR)entryPoint );
SET_AX( context, LOWORD(proc) );
}
}
break;
case 0x0003: /* Get next selector increment */
TRACE("get selector increment (__AHINCR)\n");
context->Eax = __AHINCR;
break;
case 0x0004: /* Lock selector (not supported) */
FIXME("lock selector not supported\n");
context->Eax = 0; /* FIXME: is this a correct return value? */
break;
case 0x0005: /* Unlock selector (not supported) */
FIXME("unlock selector not supported\n");
context->Eax = 0; /* FIXME: is this a correct return value? */
break;
case 0x0006: /* Get selector base address */
TRACE( "get selector base address (0x%04x)\n", BX_reg(context) );
{
LDT_ENTRY entry;
WORD sel = BX_reg(context);
wine_ldt_get_entry( sel, &entry );
if (wine_ldt_is_empty(&entry))
{
context->Eax = 0x8022; /* invalid selector */
SET_CFLAG(context);
}
else
{
void *base = wine_ldt_get_base(&entry);
SET_CX( context, HIWORD(base) );
SET_DX( context, LOWORD(base) );
}
}
break;
case 0x0007: /* Set selector base address */
{
DWORD base = MAKELONG( DX_reg(context), CX_reg(context) );
WORD sel = BX_reg(context);
TRACE( "set selector base address (0x%04x,0x%08lx)\n", sel, base );
/* check if Win16 app wants to access lower 64K of DOS memory */
if (base < 0x10000 && DOSVM_IsWin16())
DOSMEM_MapDosLayout();
SetSelectorBase( sel, base );
}
break;
case 0x0008: /* Set selector limit */
{
DWORD limit = MAKELONG( DX_reg(context), CX_reg(context) );
TRACE( "set selector limit (0x%04x,0x%08lx)\n",
BX_reg(context), limit );
SetSelectorLimit16( BX_reg(context), limit );
}
break;
case 0x0009: /* Set selector access rights */
TRACE( "set selector access rights(0x%04x,0x%04x)\n",
BX_reg(context), CX_reg(context) );
SelectorAccessRights16( BX_reg(context), 1, CX_reg(context) );
break;
case 0x000a: /* Allocate selector alias */
TRACE( "allocate selector alias (0x%04x)\n", BX_reg(context) );
SET_AX( context, AllocCStoDSAlias16( BX_reg(context) ) );
if (!AX_reg(context))
{
SET_AX( context, 0x8011 ); /* descriptor unavailable */
SET_CFLAG(context);
}
break;
case 0x000b: /* Get descriptor */
TRACE( "get descriptor (0x%04x)\n", BX_reg(context) );
{
LDT_ENTRY *entry = (LDT_ENTRY*)CTX_SEG_OFF_TO_LIN( context,
context->SegEs,
context->Edi );
wine_ldt_get_entry( BX_reg(context), entry );
}
break;
case 0x000c: /* Set descriptor */
TRACE( "set descriptor (0x%04x)\n", BX_reg(context) );
{
LDT_ENTRY *entry = (LDT_ENTRY*)CTX_SEG_OFF_TO_LIN( context,
context->SegEs,
context->Edi );
wine_ldt_set_entry( BX_reg(context), entry );
}
break;
case 0x000d: /* Allocate specific LDT descriptor */
FIXME( "allocate descriptor (0x%04x), stub!\n", BX_reg(context) );
SET_AX( context, 0x8011 ); /* descriptor unavailable */
SET_CFLAG( context );
break;
case 0x000e: /* Get Multiple Descriptors (1.0) */
FIXME( "get multiple descriptors - unimplemented\n" );
break;
case 0x000f: /* Set Multiple Descriptors (1.0) */
FIXME( "set multiple descriptors - unimplemented\n" );
break;
case 0x0100: /* Allocate DOS memory block */
TRACE( "allocate DOS memory block (0x%x paragraphs)\n", BX_reg(context) );
{
DWORD dw = GlobalDOSAlloc16( (DWORD)BX_reg(context) << 4 );
if (dw) {
SET_AX( context, HIWORD(dw) );
SET_DX( context, LOWORD(dw) );
} else {
SET_AX( context, 0x0008 ); /* insufficient memory */
SET_BX( context, DOSMEM_Available() >> 4 );
SET_CFLAG(context);
}
break;
}
case 0x0101: /* Free DOS memory block */
TRACE( "free DOS memory block (0x%04x)\n", DX_reg(context) );
{
WORD error = GlobalDOSFree16( DX_reg(context) );
if (error) {
SET_AX( context, 0x0009 ); /* memory block address invalid */
SET_CFLAG( context );
}
}
break;
case 0x0102: /* Resize DOS Memory Block */
FIXME( "resize DOS memory block (0x%04x, 0x%x paragraphs) - unimplemented\n",
DX_reg(context), BX_reg(context) );
break;
case 0x0200: /* get real mode interrupt vector */
TRACE( "get realmode interupt vector (0x%02x)\n",
BL_reg(context) );
{
FARPROC16 proc = DOSVM_GetRMHandler( BL_reg(context) );
SET_CX( context, SELECTOROF(proc) );
SET_DX( context, OFFSETOF(proc) );
}
break;
case 0x0201: /* set real mode interrupt vector */
TRACE( "set realmode interrupt vector (0x%02x, 0x%04x:0x%04x)\n",
BL_reg(context), CX_reg(context), DX_reg(context) );
DOSVM_SetRMHandler( BL_reg(context),
(FARPROC16)MAKESEGPTR(CX_reg(context), DX_reg(context)) );
break;
case 0x0202: /* Get Processor Exception Handler Vector */
FIXME( "Get Processor Exception Handler Vector (0x%02x)\n",
BL_reg(context) );
if (DOSVM_IsDos32())
{
SET_CX( context, 0 );
context->Edx = 0;
}
else
{
SET_CX( context, 0 );
SET_DX( context, 0 );
}
break;
case 0x0203: /* Set Processor Exception Handler Vector */
FIXME( "Set Processor Exception Handler Vector (0x%02x)\n",
BL_reg(context) );
break;
case 0x0204: /* Get protected mode interrupt vector */
TRACE("get protected mode interrupt handler (0x%02x)\n",
BL_reg(context));
if (DOSVM_IsDos32())
{
FARPROC48 handler = DOSVM_GetPMHandler48( BL_reg(context) );
SET_CX( context, handler.selector );
context->Edx = handler.offset;
}
else
{
FARPROC16 handler = DOSVM_GetPMHandler16( BL_reg(context) );
SET_CX( context, SELECTOROF(handler) );
SET_DX( context, OFFSETOF(handler) );
}
break;
case 0x0205: /* Set protected mode interrupt vector */
TRACE("set protected mode interrupt handler (0x%02x,0x%04x:0x%08lx)\n",
BL_reg(context), CX_reg(context), context->Edx);
if (DOSVM_IsDos32())
{
FARPROC48 handler;
handler.selector = CX_reg(context);
handler.offset = context->Edx;
DOSVM_SetPMHandler48( BL_reg(context), handler );
}
else
{
FARPROC16 handler;
handler = (FARPROC16)MAKESEGPTR( CX_reg(context), DX_reg(context));
DOSVM_SetPMHandler16( BL_reg(context), handler );
}
break;
case 0x0300: /* Simulate real mode interrupt */
TRACE( "Simulate real mode interrupt %02x.\n", BL_reg(context));
DOSVM_CallRMInt( context );
break;
case 0x0301: /* Call real mode procedure with far return */
TRACE( "Call real mode procedure with far return.\n" );
DOSVM_CallRMProc( context, FALSE );
break;
case 0x0302: /* Call real mode procedure with interrupt return */
TRACE( "Call real mode procedure with interrupt return.\n" );
DOSVM_CallRMProc( context, TRUE );
break;
case 0x0303: /* Allocate Real Mode Callback Address */
TRACE( "Allocate real mode callback address.\n" );
DOSVM_AllocRMCB( context );
break;
case 0x0304: /* Free Real Mode Callback Address */
TRACE( "Free real mode callback address.\n" );
DOSVM_FreeRMCB( context );
break;
case 0x0305: /* Get State Save/Restore Addresses */
TRACE("get state save/restore addresses\n");
/* we probably won't need this kind of state saving */
SET_AX( context, 0 );
/* real mode: just point to the lret */
SET_BX( context, DOSVM_dpmi_segments->wrap_seg );
SET_CX( context, 2 );
/* protected mode: don't have any handler yet... */
/* FIXME: Use DI in 16-bit DPMI and EDI in 32-bit DPMI */
FIXME("no protected-mode dummy state save/restore handler yet\n");
SET_SI( context, 0 );
context->Edi = 0;
break;
case 0x0306: /* Get Raw Mode Switch Addresses */
TRACE("get raw mode switch addresses\n");
/* real mode, point to standard DPMI return wrapper */
SET_BX( context, DOSVM_dpmi_segments->wrap_seg );
SET_CX( context, 0 );
/* protected mode, point to DPMI call wrapper */
/* FIXME: Use DI in 16-bit DPMI and EDI in 32-bit DPMI */
/* FIXME: Doesn't work in DPMI32... */
SET_SI( context, DOSVM_dpmi_segments->dpmi_sel );
context->Edi = 8; /* offset of the INT 0x31 call */
break;
case 0x0400: /* Get DPMI version */
TRACE("get DPMI version\n");
{
SYSTEM_INFO si;
GetSystemInfo(&si);
SET_AX( context, 0x005a ); /* DPMI version 0.90 */
SET_BX( context, 0x0005 ); /* Flags: 32-bit, virtual memory */
SET_CL( context, si.wProcessorLevel );
SET_DX( context, 0x0870 ); /* Master/slave interrupt controller base */
}
break;
case 0x0401: /* Get DPMI Capabilities (1.0) */
FIXME( "get dpmi capabilities - unimplemented\n");
break;
case 0x0500: /* Get free memory information */
TRACE("get free memory information\n");
{
MEMORYSTATUS status;
/* the layout is just the same as MEMMANINFO, but without
* the dwSize entry.
*/
struct
{
DWORD dwLargestFreeBlock;
DWORD dwMaxPagesAvailable;
DWORD dwMaxPagesLockable;
DWORD dwTotalLinearSpace;
DWORD dwTotalUnlockedPages;
DWORD dwFreePages;
DWORD dwTotalPages;
DWORD dwFreeLinearSpace;
DWORD dwSwapFilePages;
WORD wPageSize;
} *info = CTX_SEG_OFF_TO_LIN( context, context->SegEs, context->Edi );
GlobalMemoryStatus( &status );
info->wPageSize = getpagesize();
info->dwLargestFreeBlock = status.dwAvailVirtual;
info->dwMaxPagesAvailable = info->dwLargestFreeBlock / info->wPageSize;
info->dwMaxPagesLockable = info->dwMaxPagesAvailable;
info->dwTotalLinearSpace = status.dwTotalVirtual / info->wPageSize;
info->dwTotalUnlockedPages = info->dwTotalLinearSpace;
info->dwFreePages = info->dwMaxPagesAvailable;
info->dwTotalPages = info->dwTotalLinearSpace;
info->dwFreeLinearSpace = info->dwMaxPagesAvailable;
info->dwSwapFilePages = status.dwTotalPageFile / info->wPageSize;
break;
}
case 0x0501: /* Allocate memory block */
{
DWORD size = MAKELONG( CX_reg(context), BX_reg(context) );
BYTE *ptr;
TRACE( "allocate memory block (%ld bytes)\n", size );
ptr = (BYTE *)DPMI_xalloc( size );
if (!ptr)
{
SET_AX( context, 0x8012 ); /* linear memory not available */
SET_CFLAG(context);
}
else
{
SET_BX( context, HIWORD(ptr) );
SET_CX( context, LOWORD(ptr) );
SET_SI( context, HIWORD(ptr) );
SET_DI( context, LOWORD(ptr) );
}
break;
}
case 0x0502: /* Free memory block */
{
DWORD handle = MAKELONG( DI_reg(context), SI_reg(context) );
TRACE( "free memory block (0x%08lx)\n", handle );
DPMI_xfree( (void *)handle );
}
break;
case 0x0503: /* Resize memory block */
{
DWORD size = MAKELONG( CX_reg(context), BX_reg(context) );
DWORD handle = MAKELONG( DI_reg(context), SI_reg(context) );
BYTE *ptr;
TRACE( "resize memory block (0x%08lx, %ld bytes)\n", handle, size );
ptr = (BYTE *)DPMI_xrealloc( (void *)handle, size );
if (!ptr)
{
SET_AX( context, 0x8012 ); /* linear memory not available */
SET_CFLAG(context);
} else {
SET_BX( context, HIWORD(ptr) );
SET_CX( context, LOWORD(ptr) );
SET_SI( context, HIWORD(ptr) );
SET_DI( context, LOWORD(ptr) );
}
}
break;
case 0x0507: /* Set page attributes (1.0) */
FIXME( "set page attributes - unimplemented\n" );
break; /* Just ignore it */
case 0x0600: /* Lock linear region */
TRACE( "lock linear region - ignored (no paging)\n" );
break;
case 0x0601: /* Unlock linear region */
TRACE( "unlock linear region - ignored (no paging)\n" );
break;
case 0x0602: /* Mark real mode region as pageable */
TRACE( "mark real mode region as pageable - ignored (no paging)\n" );
break;
case 0x0603: /* Relock real mode region */
TRACE( "relock real mode region - ignored (no paging)\n" );
break;
case 0x0604: /* Get page size */
TRACE("get pagesize\n");
SET_BX( context, HIWORD(getpagesize()) );
SET_CX( context, LOWORD(getpagesize()) );
break;
case 0x0700: /* Mark pages as paging candidates */
TRACE( "mark pages as paging candidates - ignored (no paging)\n" );
break;
case 0x0701: /* Discard pages */
TRACE( "discard pages - ignored (no paging)\n" );
break;
case 0x0702: /* Mark page as demand-paging candidate */
TRACE( "mark page as demand-paging candidate - ignored (no paging)\n" );
break;
case 0x0703: /* Discard page contents */
TRACE( "discard page contents - ignored (no paging)\n" );
break;
case 0x0800: /* Physical address mapping */
FIXME( "physical address mapping (0x%08lx) - unimplemented\n",
MAKELONG(CX_reg(context),BX_reg(context)) );
break;
case 0x0900: /* Get and Disable Virtual Interrupt State */
TRACE( "Get and Disable Virtual Interrupt State: %ld\n",
NtCurrentTeb()->dpmi_vif );
SET_AL( context, NtCurrentTeb()->dpmi_vif ? 1 : 0 );
NtCurrentTeb()->dpmi_vif = 0;
break;
case 0x0901: /* Get and Enable Virtual Interrupt State */
TRACE( "Get and Enable Virtual Interrupt State: %ld\n",
NtCurrentTeb()->dpmi_vif );
SET_AL( context, NtCurrentTeb()->dpmi_vif ? 1 : 0 );
NtCurrentTeb()->dpmi_vif = 1;
break;
case 0x0902: /* Get Virtual Interrupt State */
TRACE( "Get Virtual Interrupt State: %ld\n",
NtCurrentTeb()->dpmi_vif );
SET_AL( context, NtCurrentTeb()->dpmi_vif ? 1 : 0 );
break;
case 0x0e00: /* Get Coprocessor Status (1.0) */
/*
* Return status in AX bits:
* B0 - MPv (MP bit in the virtual MSW/CR0)
* 0 = numeric coprocessor is disabled for this client
* 1 = numeric coprocessor is enabled for this client
* B1 - EMv (EM bit in the virtual MSW/CR0)
* 0 = client is not emulating coprocessor instructions
* 1 = client is emulating coprocessor instructions
* B2 - MPr (MP bit from the actual MSW/CR0)
* 0 = numeric coprocessor is not present
* 1 = numeric coprocessor is present
* B3 - EMr (EM bit from the actual MSW/CR0)
* 0 = host is not emulating coprocessor instructions
* 1 = host is emulating coprocessor instructions
* B4-B7 - coprocessor type
* 00H = no coprocessor
* 02H = 80287
* 03H = 80387
* 04H = 80486 with numeric coprocessor
* 05H-0FH = reserved for future numeric processors
*/
TRACE( "Get Coprocessor Status\n" );
SET_AX( context, 69 ); /* 486, coprocessor present and enabled */
break;
case 0x0e01: /* Set Coprocessor Emulation (1.0) */
/*
* See function 0x0e00.
* BX bit B0 is new value for MPv.
* BX bit B1 is new value for EMv.
*/
if (BX_reg(context) != 1)
FIXME( "Set Coprocessor Emulation to %d - unimplemented\n",
BX_reg(context) );
else
TRACE( "Set Coprocessor Emulation - ignored\n" );
break;
default:
INT_BARF( context, 0x31 );
SET_AX( context, 0x8001 ); /* unsupported function */
SET_CFLAG(context);
break;
}
}
/**********************************************************************
* DOSVM_Int33Handler
*
* Handler for int 33h (MS MOUSE).
*/
void WINAPI DOSVM_Int33Handler( CONTEXT *context )
{
switch (AX_reg(context))
{
case 0x0000:
TRACE("Reset mouse driver and request status\n");
INT33_ResetMouse( context );
break;
case 0x0001:
TRACE("Show mouse cursor, old hide count: %d\n",
mouse_info.hide_count);
if (mouse_info.hide_count >= 1)
mouse_info.hide_count--;
if (!mouse_info.hide_count)
VGA_ShowMouse( TRUE );
break;
case 0x0002:
TRACE("Hide mouse cursor, old hide count: %d\n",
mouse_info.hide_count);
if(!mouse_info.hide_count)
VGA_ShowMouse( FALSE );
mouse_info.hide_count++;
break;
case 0x0003:
TRACE("Return mouse position and button status: (%d,%d) and %d\n",
mouse_info.x, mouse_info.y, mouse_info.but);
SET_BX( context, mouse_info.but );
SET_CX( context, mouse_info.x );
SET_DX( context, mouse_info.y );
break;
case 0x0004:
FIXME("Position mouse cursor\n");
break;
case 0x0005:
TRACE("Return Mouse button press Information for %s mouse button\n",
BX_reg(context) ? "right" : "left");
if (BX_reg(context))
{
SET_BX( context, mouse_info.rbcount );
mouse_info.rbcount = 0;
SET_CX( context, mouse_info.rlastx );
SET_DX( context, mouse_info.rlasty );
}
else
{
SET_BX( context, mouse_info.lbcount );
mouse_info.lbcount = 0;
SET_CX( context, mouse_info.llastx );
SET_DX( context, mouse_info.llasty );
}
SET_AX( context, mouse_info.but );
break;
case 0x0007:
FIXME("Define horizontal mouse cursor range %d..%d\n",
CX_reg(context), DX_reg(context));
break;
case 0x0008:
FIXME("Define vertical mouse cursor range %d..%d\n",
CX_reg(context), DX_reg(context));
break;
case 0x0009:
FIXME("Define graphics mouse cursor\n");
break;
case 0x000A:
FIXME("Define text mouse cursor\n");
break;
case 0x000B:
TRACE("Read Mouse motion counters\n");
{
int dx = ((int)mouse_info.x - (int)mouse_info.oldx)
* (mouse_info.HMPratio / 8);
int dy = ((int)mouse_info.y - (int)mouse_info.oldy)
* (mouse_info.VMPratio / 8);
SET_CX( context, (WORD)dx );
SET_DX( context, (WORD)dy );
mouse_info.oldx = mouse_info.x;
mouse_info.oldy = mouse_info.y;
}
break;
case 0x000C:
TRACE("Define mouse interrupt subroutine\n");
mouse_info.callmask = CX_reg(context);
mouse_info.callback = (FARPROC16)MAKESEGPTR(context->SegEs,
DX_reg(context));
break;
case 0x000F:
TRACE("Set mickey/pixel ratio\n");
mouse_info.HMPratio = CX_reg(context);
mouse_info.VMPratio = DX_reg(context);
break;
case 0x0010:
FIXME("Define screen region for update\n");
break;
case 0x0021:
TRACE("Software reset\n");
INT33_ResetMouse( context );
break;
default:
INT_BARF(context,0x33);
}
}
