/********************************************************************** * 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_Int67Handler (WINEDOS16.203) * * Handler for interrupt 67h EMS routines. */ void WINAPI DOSVM_Int67Handler( CONTEXT86 *context ) { switch AH_reg(context) { case 0x40: /* EMS - GET MANAGER STATUS */ SET_AH( context, 0 ); /* status: ok */ break; case 0x41: /* EMS - GET PAGE FRAME SEGMENT */ EMS_init(); SET_BX( context, EMS_record->frame_selector ); /* segment of page frame */ SET_AH( context, 0 ); /* status: ok */ break; case 0x42: /* EMS - GET NUMBER OF PAGES */ EMS_init(); /* unallocated 16k pages */ SET_BX( context, EMS_MAX_PAGES - EMS_record->used_pages ); /* total number of 16k pages */ SET_DX( context, EMS_MAX_PAGES ); /* status: ok */ SET_AH( context, 0 ); break; case 0x43: /* EMS - GET HANDLE AND ALLOCATE MEMORY */ EMS_init(); EMS_alloc(context); break; case 0x44: /* EMS - MAP MEMORY */ EMS_init(); SET_AH( context, EMS_map( AL_reg(context), DX_reg(context), BX_reg(context) ) ); break; case 0x45: /* EMS - RELEASE HANDLE AND MEMORY */ EMS_init(); EMS_free(context); break; case 0x46: /* EMS - GET EMM VERSION */ SET_AL( context, 0x40 ); /* version 4.0 */ SET_AH( context, 0 ); /* status: ok */ break; case 0x47: /* EMS - SAVE MAPPING CONTEXT */ EMS_init(); EMS_save_context(context); break; case 0x48: /* EMS - RESTORE MAPPING CONTEXT */ EMS_init(); EMS_restore_context(context); break; case 0x49: /* EMS - reserved - GET I/O PORT ADDRESSES */ case 0x4a: /* EMS - reserved - GET TRANSLATION ARRAY */ INT_BARF(context,0x67); break; case 0x4b: /* EMS - GET NUMBER OF EMM HANDLES */ SET_BX( context, EMS_MAX_HANDLES ); /* EMM handles */ SET_AH( context, 0 ); /* status: ok */ break; case 0x4c: /* EMS - GET PAGES OWNED BY HANDLE */ case 0x4d: /* EMS - GET PAGES FOR ALL HANDLES */ case 0x4e: /* EMS - GET OR SET PAGE MAP */ case 0x4f: /* EMS 4.0 - GET/SET PARTIAL PAGE MAP */ INT_BARF(context,0x67); break; case 0x50: /* EMS 4.0 - MAP/UNMAP MULTIPLE HANDLE PAGES */ EMS_init(); EMS_map_multiple(context); break; case 0x51: /* EMS 4.0 - REALLOCATE PAGES */ case 0x52: /* EMS 4.0 - GET/SET HANDLE ATTRIBUTES */ INT_BARF(context,0x67); break; case 0x53: /* EMS 4.0 - GET/SET HANDLE NAME */ EMS_init(); EMS_access_name(context); break; case 0x54: /* EMS 4.0 - GET HANDLE DIRECTORY */ case 0x55: /* EMS 4.0 - ALTER PAGE MAP AND JUMP */ case 0x56: /* EMS 4.0 - ALTER PAGE MAP AND CALL */ case 0x57: /* EMS 4.0 - MOVE/EXCHANGE MEMORY REGION */ case 0x58: /* EMS 4.0 - GET MAPPABLE PHYSICAL ADDRESS ARRAY */ INT_BARF(context,0x67); break; case 0x59: /* EMS 4.0 - GET EXPANDED MEMORY HARDWARE INFORMATION */ if(AL_reg(context) == 0x01) { EMS_init(); /* unallocated raw pages */ SET_BX( context, EMS_MAX_PAGES - EMS_record->used_pages ); /* total number raw pages */ SET_DX( context, EMS_MAX_PAGES ); /* status: ok */ SET_AH( context, 0 ); } else INT_BARF(context,0x67); break; case 0x5a: /* EMS 4.0 - ALLOCATE STANDARD/RAW PAGES */ case 0x5b: /* EMS 4.0 - ALTERNATE MAP REGISTER SET */ case 0x5c: /* EMS 4.0 - PREPARE EXPANDED MEMORY HARDWARE FOR WARM BOOT */ case 0x5d: /* EMS 4.0 - ENABLE/DISABLE OS FUNCTION SET FUNCTIONS */ INT_BARF(context,0x67); break; case 0xde: /* Virtual Control Program Interface (VCPI) */ if(AL_reg(context) == 0x00) { /* * VCPI INSTALLATION CHECK * (AH_reg() != 0) means VCPI is not present */ TRACE("- VCPI installation check\n"); return; } else INT_BARF(context,0x67); break; default: INT_BARF(context,0x67); } }
/********************************************************************** * INT10_HandleVESA * * Handler for VESA functions (int10 function 0x4f). */ static void INT10_HandleVESA( CONTEXT *context ) { BIOSDATA *data = DOSVM_BiosData(); switch(AL_reg(context)) { case 0x00: /* RETURN CONTROLLER INFORMATION */ TRACE( "VESA RETURN CONTROLLER INFORMATION\n" ); { BYTE *ptr = CTX_SEG_OFF_TO_LIN(context, context->SegEs, context->Edi); INT10_FillControllerInformation( ptr ); SET_AL( context, 0x4f ); SET_AH( context, 0x00 ); /* 0x00 = successful 0x01 = failed */ } break; case 0x01: /* RETURN MODE INFORMATION */ TRACE( "VESA RETURN MODE INFORMATION %04x\n", CX_reg(context) ); { struct _ModeInfoBlock *ptr = CTX_SEG_OFF_TO_LIN(context, context->SegEs, context->Edi); SET_AL( context, 0x4f ); if (INT10_FillModeInformation( ptr, CX_reg(context) )) SET_AH( context, 0x00 ); /* status: success */ else SET_AH( context, 0x01 ); /* status: failed */ } break; case 0x02: /* SET SuperVGA VIDEO MODE */ TRACE( "Set VESA video mode %04x\n", BX_reg(context) ); SET_AL( context, 0x4f ); /* function supported */ if (INT10_SetVideoMode( data, BX_reg(context) )) SET_AH( context, 0x00 ); /* success */ else SET_AH( context, 0x01 ); /* failed */ break; case 0x03: /* VESA SuperVGA BIOS - GET CURRENT VIDEO MODE */ SET_AL( context, 0x4f ); SET_AH( context, 0x00 ); SET_BX( context, INT10_GetHeap()->VesaCurrentMode ); break; case 0x04: /* VESA SuperVGA BIOS - SAVE/RESTORE SuperVGA VIDEO STATE */ ERR("VESA SAVE/RESTORE Video State - Not Implemented\n"); /* AL_reg(context) = 0x4f; = supported so not set since not implemented */ /* maybe we should do this instead ? */ /* AH_reg(context = 0x01; not implemented so just fail */ break; case 0x05: /* VESA SuperVGA BIOS - CPU VIDEO MEMORY CONTROL */ /* * This subfunction supports only Window A (BL_reg == 0) and * it assumes that window granularity is 64k. */ switch(BH_reg(context)) { case 0x00: /* select video memory window */ SET_AL( context, 0x4f ); /* function supported */ if(BL_reg(context) == 0) { VGA_SetWindowStart(DX_reg(context) * 64 * 1024); SET_AH( context, 0x00 ); /* status: successful */ } else SET_AH( context, 0x01 ); /* status: failed */ break; case 0x01: /* get video memory window */ SET_AL( context, 0x4f ); /* function supported */ if(BL_reg(context) == 0) { SET_DX( context, VGA_GetWindowStart() / 64 / 1024 ); SET_AH( context, 0x00 ); /* status: successful */ } else SET_AH( context, 0x01 ); /* status: failed */ break; default: INT_BARF( context, 0x10 ); } break; case 0x06: /* VESA GET/SET LOGICAL SCAN LINE LENGTH */ ERR("VESA GET/SET LOGICAL SCAN LINE LENGTH - Not Implemented\n"); /* AL_reg(context) = 0x4f; = supported so not set since not implemented */ /* maybe we should do this instead ? */ /* AH_reg(context = 0x001; not implemented so just fail */ break; case 0x07: /* GET/SET DISPLAY START */ ERR("VESA GET/SET DISPLAY START - Not Implemented\n"); /* AL_reg(context) = 0x4f; = supported so not set since not implemented */ /* maybe we should do this instead ? */ /* AH_reg(context = 0x001; not implemented so just fail */ break; case 0x08: /* GET/SET DAC PALETTE CONTROL */ ERR("VESA GET/SET DAC PALETTE CONTROL- Not Implemented\n"); /* AL_reg(context) = 0x4f; = supported so not set since not implemented */ /* maybe we should do this instead ? */ /* AH_reg(context = 0x001; not implemented so just fail */ break; case 0x09: /* SET PALETTE ENTRIES */ FIXME("VESA Set palette entries - not implemented\n"); break; case 0x0a: /* GET PROTECTED-MODE CODE */ FIXME("VESA Get protected-mode code - not implemented\n"); break; case 0x10: /* Display Power Management Extensions */ FIXME("VESA Display Power Management Extensions - not implemented\n"); break; case 0xef: /* get video mode for hercules-compatibles */ /* There's no reason to really support this */ /* is there?....................(A.C.) */ TRACE("Just report the video not hercules compatible\n"); SET_DX( context, 0xffff ); break; case 0xff: /* Turn VESA ON/OFF */ /* I don't know what to do */ break; default: FIXME("VESA Function (0x%x) - Not Supported\n", AH_reg(context)); break; } }
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_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; } }
/********************************************************************** * INT13_ReadFloppyParams * * Read floppy disk parameters. */ static void INT13_ReadFloppyParams( CONTEXT *context ) { #ifdef linux static const BYTE floppy_params[2][13] = { { 0xaf, 0x02, 0x25, 0x02, 0x12, 0x1b, 0xff, 0x6c, 0xf6, 0x0f, 0x08 }, { 0xaf, 0x02, 0x25, 0x02, 0x12, 0x1b, 0xff, 0x6c, 0xf6, 0x0f, 0x08 } }; static const DWORD drive_type_info[7]={ 0x0000, /* none */ 0x2709, /* 360 K */ 0x4f0f, /* 1.2 M */ 0x4f09, /* 720 K */ 0x4f12, /* 1.44 M */ 0x4f24, /* 2.88 M */ 0x4f24 /* 2.88 M */ }; unsigned int i; unsigned int nr_of_drives = 0; BYTE drive_nr = DL_reg( context ); int floppy_fd; int r; struct floppy_drive_params floppy_parm; WCHAR root[] = {'A',':','\\',0}, drive_root[] = {'\\','\\','.','\\','A',':',0}; HANDLE h; TRACE("in [ EDX=%08x ]\n", context->Edx ); SET_AL( context, 0 ); SET_BX( context, 0 ); SET_CX( context, 0 ); SET_DH( context, 0 ); for (i = 0; i < MAX_DOS_DRIVES; i++, root[0]++) if (GetDriveTypeW(root) == DRIVE_REMOVABLE) nr_of_drives++; SET_DL( context, nr_of_drives ); if (drive_nr > 1) { /* invalid drive ? */ INT13_SetStatus( context, 0x07 ); /* drive parameter activity failed */ return; } drive_root[4] = 'A' + drive_nr; h = CreateFileW(drive_root, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL); if (h == INVALID_HANDLE_VALUE || wine_server_handle_to_fd(h, FILE_READ_DATA, &floppy_fd, NULL)) { WARN("Can't determine floppy geometry !\n"); INT13_SetStatus( context, 0x07 ); /* drive parameter activity failed */ return; } r = ioctl(floppy_fd, FDGETDRVPRM, &floppy_parm); wine_server_release_fd( h, floppy_fd ); CloseHandle(h); if(r<0) { INT13_SetStatus( context, 0x07 ); /* drive parameter activity failed */ return; } SET_BL( context, floppy_parm.cmos ); /* * CH = low eight bits of max cyl * CL = max sec nr (bits 5-0), * hi two bits of max cyl (bits 7-6) * DH = max head nr */ if(BL_reg( context ) && BL_reg( context ) < 7) { SET_DH( context, 0x01 ); SET_CX( context, drive_type_info[BL_reg( context )] ); } context->Edi = (DWORD)floppy_params[drive_nr]; if(!context->Edi) { ERR("Get floppy params failed for drive %d\n", drive_nr); INT13_SetStatus( context, 0x07 ); /* drive parameter activity failed */ return; } TRACE("out [ EAX=%08x EBX=%08x ECX=%08x EDX=%08x EDI=%08x ]\n", context->Eax, context->Ebx, context->Ecx, context->Edx, context->Edi); INT13_SetStatus( context, 0x00 ); /* success */ /* FIXME: Word exits quietly if we return with no error. Why? */ FIXME("Returned ERROR!\n"); SET_CFLAG( context ); #else INT13_SetStatus( context, 0x01 ); /* invalid function */ #endif }
/********************************************************************** * 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); } }