void MS_bop_D(void)
{
#ifdef MONITOR
extern VOID MonitorEndIretHook(VOID);
half_word iret_index;
// get iret index
iret_index = *Sim32GetVDMPointer(SEGOFF(getCS(),getIP()),
1,
(UCHAR)(getPE() ? TRUE : FALSE)
);
// Tell ica that an iret bop has been called
ica_iret_hook_called((int) iret_index);
//
// Clean up stack, and resume normal code path
//
MonitorEndIretHook();
#else
illegal_bop();
#endif
}
int install_undi_irq_handler ( irq_t irq, segoff_t entrypointsp ) {
segoff_t undi_irq_handler_segoff = SEGOFF(undi_irq_handler);
if ( undi_irq_installed_on != IRQ_NONE ) {
DBG ( "Can install undi IRQ handler only once\n" );
return 0;
}
if ( SEGMENT(undi_irq_handler) > 0xffff ) {
DBG ( "Trivial IRQ handler not in base memory\n" );
return 0;
}
DBG ( "Installing undi IRQ handler on IRQ %d\n", irq );
*pxenv_undi_entrypointsp = entrypointsp;
*pxenv_undi_irq = irq;
if ( ! install_irq_handler ( irq, &undi_irq_handler_segoff,
undi_irq_chain,
undi_irq_chain_to ) )
return 0;
undi_irq_installed_on = irq;
DBG ( "Disabling undi IRQ %d\n", irq );
disable_irq ( irq );
*undi_irq_trigger_count = 0;
undi_irq_previous_trigger_count = 0;
DBG ( "UNDI IRQ handler installed successfully\n" );
return 1;
}
void MS_bop_8 (void)
{
ULONG iFunc;
UCHAR uchMode = getMSW() & MSW_PE ? TRUE : FALSE;
// Get the Function Number
iFunc = (ULONG)(*Sim32GetVDMPointer(SEGOFF(getCS(),getIP()),
1,
uchMode
));
switch (iFunc) {
case 0: /* RegisterModule */
ISV_RegisterModule (uchMode);
break;
case 1: /* DeRegisterModule */
ISV_DeRegisterModule ();
break;
case 2: /* DispatchCall */
ISV_DispatchCall ();
break;
default:
setCF(1);
}
setIP((USHORT)(getIP() + 1));
return;
}
// XMS BOP
void MS_bop_2(void) {
XMSDispatch((ULONG)(*Sim32GetVDMPointer(SEGOFF(getCS(),getIP()),
1,
FALSE
)));
setIP((USHORT)(getIP() + 1));
}
static void
vbe_104f00(struct bregs *regs)
{
u16 seg = regs->es;
struct vbe_info *info = (void*)(regs->di+0);
if (GET_FARVAR(seg, info->signature) == VBE2_SIGNATURE) {
dprintf(4, "Get VBE Controller: VBE2 Signature found\n");
} else if (GET_FARVAR(seg, info->signature) == VESA_SIGNATURE) {
dprintf(4, "Get VBE Controller: VESA Signature found\n");
} else {
dprintf(4, "Get VBE Controller: Invalid Signature\n");
}
memset_far(seg, info, 0, sizeof(*info));
SET_FARVAR(seg, info->signature, VESA_SIGNATURE);
SET_FARVAR(seg, info->version, 0x0300);
SET_FARVAR(seg, info->oem_string,
SEGOFF(get_global_seg(), (u32)VBE_OEM_STRING));
SET_FARVAR(seg, info->capabilities, GET_GLOBAL(VBE_capabilities));
/* We generate our mode list in the reserved field of the info block */
u16 *destmode = (void*)info->reserved;
SET_FARVAR(seg, info->video_mode, SEGOFF(seg, (u32)destmode));
/* Total memory (in 64k blocks) */
SET_FARVAR(seg, info->total_memory
, GET_GLOBAL(VBE_total_memory) / (64*1024));
SET_FARVAR(seg, info->oem_vendor_string,
SEGOFF(get_global_seg(), (u32)VBE_VENDOR_STRING));
SET_FARVAR(seg, info->oem_product_string,
SEGOFF(get_global_seg(), (u32)VBE_PRODUCT_STRING));
SET_FARVAR(seg, info->oem_revision_string,
SEGOFF(get_global_seg(), (u32)VBE_REVISION_STRING));
/* Fill list of modes */
u16 *last = (void*)&info->reserved[sizeof(info->reserved)];
vgahw_list_modes(seg, destmode, last - 1);
regs->ax = 0x004f;
}
static void
ivt_init(void)
{
dprintf(3, "init ivt\n");
// Setup reset-vector entry point (controls legacy reboots).
HaveRunPost = 1;
rtc_write(CMOS_RESET_CODE, 0);
// Initialize all vectors to the default handler.
int i;
for (i=0; i<256; i++)
SET_IVT(i, FUNC16(entry_iret_official));
// Initialize all hw vectors to a default hw handler.
for (i=BIOS_HWIRQ0_VECTOR; i<BIOS_HWIRQ0_VECTOR+8; i++)
SET_IVT(i, FUNC16(entry_hwpic1));
for (i=BIOS_HWIRQ8_VECTOR; i<BIOS_HWIRQ8_VECTOR+8; i++)
SET_IVT(i, FUNC16(entry_hwpic2));
// Initialize software handlers.
SET_IVT(0x02, FUNC16(entry_02));
SET_IVT(0x10, FUNC16(entry_10));
SET_IVT(0x11, FUNC16(entry_11));
SET_IVT(0x12, FUNC16(entry_12));
SET_IVT(0x13, FUNC16(entry_13_official));
SET_IVT(0x14, FUNC16(entry_14));
SET_IVT(0x15, FUNC16(entry_15_official));
SET_IVT(0x16, FUNC16(entry_16));
SET_IVT(0x17, FUNC16(entry_17));
SET_IVT(0x18, FUNC16(entry_18));
SET_IVT(0x19, FUNC16(entry_19_official));
SET_IVT(0x1a, FUNC16(entry_1a_official));
SET_IVT(0x40, FUNC16(entry_40));
// INT 60h-66h reserved for user interrupt
for (i=0x60; i<=0x66; i++)
SET_IVT(i, SEGOFF(0, 0));
// set vector 0x79 to zero
// this is used by 'gardian angel' protection system
SET_IVT(0x79, SEGOFF(0, 0));
}
static void
init_ivt(void)
{
dprintf(3, "init ivt\n");
// Initialize all vectors to the default handler.
int i;
for (i=0; i<256; i++)
SET_IVT(i, FUNC16(entry_iret_official));
// Initialize all hw vectors to a default hw handler.
for (i=0x08; i<=0x0f; i++)
SET_IVT(i, FUNC16(entry_hwpic1));
for (i=0x70; i<=0x77; i++)
SET_IVT(i, FUNC16(entry_hwpic2));
// Initialize software handlers.
SET_IVT(0x02, FUNC16(entry_02));
SET_IVT(0x10, FUNC16(entry_10));
SET_IVT(0x11, FUNC16(entry_11));
SET_IVT(0x12, FUNC16(entry_12));
SET_IVT(0x13, FUNC16(entry_13_official));
SET_IVT(0x14, FUNC16(entry_14));
SET_IVT(0x15, FUNC16(entry_15));
SET_IVT(0x16, FUNC16(entry_16));
SET_IVT(0x17, FUNC16(entry_17));
SET_IVT(0x18, FUNC16(entry_18));
SET_IVT(0x19, FUNC16(entry_19_official));
SET_IVT(0x1a, FUNC16(entry_1a));
SET_IVT(0x40, FUNC16(entry_40));
// INT 60h-66h reserved for user interrupt
for (i=0x60; i<=0x66; i++)
SET_IVT(i, SEGOFF(0, 0));
// set vector 0x79 to zero
// this is used by 'gardian angel' protection system
SET_IVT(0x79, SEGOFF(0, 0));
SET_IVT(0x1E, SEGOFF(SEG_BIOS, (u32)&diskette_param_table2 - BUILD_BIOS_ADDR));
}
// DOS EMULATION BOP
void MS_bop_0(void) {
ULONG DemCmd;
DemCmd = (ULONG)(*Sim32GetVDMPointer(SEGOFF(getCS(),getIP()),
1,
FALSE
));
DemDispatch( DemCmd );
setIP((USHORT)(getIP() + 1));
// we need to prevent the idle system from going off on intensive file
// reads. However, we don't want to disable it for continuous 'Get Time'
// calls (command 0x15). Nor for Get Date (0x15).
if (DemCmd != 0x15 && DemCmd != 0x14)
IDLE_disk();
}
int remove_undi_irq_handler ( irq_t irq ) {
segoff_t undi_irq_handler_segoff = SEGOFF(undi_irq_handler);
if ( undi_irq_installed_on == IRQ_NONE ) return 1;
if ( irq != undi_irq_installed_on ) {
DBG ( "Cannot uninstall undi IRQ handler from IRQ %d; "
"is installed on IRQ %d\n", irq,
undi_irq_installed_on );
return 0;
}
if ( ! remove_irq_handler ( irq, &undi_irq_handler_segoff,
undi_irq_chain,
undi_irq_chain_to ) )
return 0;
if ( undi_irq_triggered ( undi_irq_installed_on ) ) {
DBG ( "Sending EOI for unwanted undi IRQ\n" );
send_specific_eoi ( undi_irq_installed_on );
}
undi_irq_installed_on = IRQ_NONE;
return 1;
}
static void
vbe_104f01(struct bregs *regs)
{
u16 seg = regs->es;
struct vbe_mode_info *info = (void*)(regs->di+0);
u16 mode = regs->cx;
dprintf(1, "VBE mode info request: %x\n", mode);
struct vgamode_s *vmode_g = vgahw_find_mode(mode & ~MF_VBEFLAGS);
if (! vmode_g) {
dprintf(1, "VBE mode %x not found\n", mode);
regs->ax = 0x014f;
return;
}
memset_far(seg, info, 0, sizeof(*info));
// Basic information about video controller.
u32 win_granularity = GET_GLOBAL(VBE_win_granularity);
SET_FARVAR(seg, info->winA_attributes,
(win_granularity ? VBE_WINDOW_ATTRIBUTE_RELOCATABLE : 0) |
VBE_WINDOW_ATTRIBUTE_READABLE |
VBE_WINDOW_ATTRIBUTE_WRITEABLE);
SET_FARVAR(seg, info->winB_attributes, 0);
SET_FARVAR(seg, info->win_granularity, win_granularity);
SET_FARVAR(seg, info->win_size, 64); /* Bank size 64K */
SET_FARVAR(seg, info->winA_seg, GET_GLOBAL(vmode_g->sstart));
SET_FARVAR(seg, info->winB_seg, 0x0);
extern void entry_104f05(void);
SET_FARVAR(seg, info->win_func_ptr
, SEGOFF(get_global_seg(), (u32)entry_104f05));
// Basic information about mode.
int width = GET_GLOBAL(vmode_g->width);
int height = GET_GLOBAL(vmode_g->height);
int linesize = DIV_ROUND_UP(width * vga_bpp(vmode_g), 8);
SET_FARVAR(seg, info->bytes_per_scanline, linesize);
SET_FARVAR(seg, info->xres, width);
SET_FARVAR(seg, info->yres, height);
SET_FARVAR(seg, info->xcharsize, GET_GLOBAL(vmode_g->cwidth));
SET_FARVAR(seg, info->ycharsize, GET_GLOBAL(vmode_g->cheight));
int depth = GET_GLOBAL(vmode_g->depth);
SET_FARVAR(seg, info->bits_per_pixel, depth);
u8 memmodel = GET_GLOBAL(vmode_g->memmodel);
SET_FARVAR(seg, info->mem_model, memmodel);
SET_FARVAR(seg, info->reserved0, 1);
// Mode specific info.
u16 mode_attr = VBE_MODE_ATTRIBUTE_SUPPORTED |
VBE_MODE_ATTRIBUTE_EXTENDED_INFORMATION_AVAILABLE |
VBE_MODE_ATTRIBUTE_COLOR_MODE |
VBE_MODE_ATTRIBUTE_GRAPHICS_MODE |
VBE_MODE_ATTRIBUTE_NOT_VGA_COMPATIBLE;
u32 framebuffer = 0;
int planes = 1, banks = 1;
u32 pages = GET_GLOBAL(VBE_total_memory) / ALIGN(height * linesize, 64*1024);
switch (memmodel) {
case MM_TEXT:
mode_attr &= ~VBE_MODE_ATTRIBUTE_GRAPHICS_MODE;
mode_attr |= VBE_MODE_ATTRIBUTE_TTY_BIOS_SUPPORT;
if (GET_GLOBAL(vmode_g->sstart) == SEG_MTEXT)
mode_attr &= ~VBE_MODE_ATTRIBUTE_COLOR_MODE;
pages = 1;
break;
case MM_CGA:
pages = 1;
banks = 2;
SET_FARVAR(seg, info->bank_size, 8);
break;
case MM_PLANAR:
planes = 4;
pages /= 4;
break;
default:
framebuffer = GET_GLOBAL(VBE_framebuffer);
if (framebuffer)
mode_attr |= VBE_MODE_ATTRIBUTE_LINEAR_FRAME_BUFFER_MODE;
break;
}
SET_FARVAR(seg, info->mode_attributes, mode_attr);
SET_FARVAR(seg, info->planes, planes);
SET_FARVAR(seg, info->pages, pages - 1);
SET_FARVAR(seg, info->banks, banks);
// Pixel color breakdown
u8 r_size, r_pos, g_size, g_pos, b_size, b_pos, a_size, a_pos;
switch (depth) {
case 15: r_size = 5; r_pos = 10; g_size = 5; g_pos = 5;
b_size = 5; b_pos = 0; a_size = 1; a_pos = 15; break;
case 16: r_size = 5; r_pos = 11; g_size = 6; g_pos = 5;
b_size = 5; b_pos = 0; a_size = 0; a_pos = 0; break;
case 24: r_size = 8; r_pos = 16; g_size = 8; g_pos = 8;
b_size = 8; b_pos = 0; a_size = 0; a_pos = 0; break;
case 32: r_size = 8; r_pos = 16; g_size = 8; g_pos = 8;
b_size = 8; b_pos = 0; a_size = 8; a_pos = 24;
SET_FARVAR(seg, info->directcolor_info,
VBE_DIRECTCOLOR_RESERVED_BITS_AVAILABLE);
break;
default: r_size = 0; r_pos = 0; g_size = 0; g_pos = 0;
b_size = 0; b_pos = 0; a_size = 0; a_pos = 0; break;
}
SET_FARVAR(seg, info->red_size, r_size);
SET_FARVAR(seg, info->red_pos, r_pos);
SET_FARVAR(seg, info->green_size, g_size);
SET_FARVAR(seg, info->green_pos, g_pos);
SET_FARVAR(seg, info->blue_size, b_size);
SET_FARVAR(seg, info->blue_pos, b_pos);
SET_FARVAR(seg, info->alpha_size, a_size);
SET_FARVAR(seg, info->alpha_pos, a_pos);
// Linear framebuffer info.
if (framebuffer) {
SET_FARVAR(seg, info->phys_base, framebuffer);
SET_FARVAR(seg, info->reserved1, 0);
SET_FARVAR(seg, info->reserved2, 0);
SET_FARVAR(seg, info->linear_bytes_per_scanline, linesize);
SET_FARVAR(seg, info->linear_pages, 0);
SET_FARVAR(seg, info->linear_red_size, r_size);
SET_FARVAR(seg, info->linear_red_pos, r_pos);
SET_FARVAR(seg, info->linear_green_size, g_size);
SET_FARVAR(seg, info->linear_green_pos, g_pos);
SET_FARVAR(seg, info->linear_blue_size, b_size);
SET_FARVAR(seg, info->linear_blue_pos, b_pos);
SET_FARVAR(seg, info->linear_alpha_size, a_size);
SET_FARVAR(seg, info->linear_alpha_pos, a_pos);
}
regs->ax = 0x004f;
}
// IBM/MS get drive parameters
static void
disk_1348(struct bregs *regs, struct drive_s *drive_gf)
{
int ret = fill_edd(SEGOFF(regs->ds, regs->si), drive_gf);
disk_ret(regs, ret);
}
// IBM/MS get drive parameters
static void noinline
disk_1348(struct bregs *regs, struct drive_s *drive_gf)
{
u16 seg = regs->ds;
struct int13dpt_s *param_far = (struct int13dpt_s*)(regs->si+0);
u16 size = GET_FARVAR(seg, param_far->size);
u16 t13 = size == 74;
// Buffer is too small
if (size < 26) {
disk_ret(regs, DISK_RET_EPARAM);
return;
}
// EDD 1.x
u8 type = GET_GLOBALFLAT(drive_gf->type);
u16 npc = GET_GLOBALFLAT(drive_gf->pchs.cylinder);
u16 nph = GET_GLOBALFLAT(drive_gf->pchs.head);
u16 nps = GET_GLOBALFLAT(drive_gf->pchs.sector);
u64 lba = GET_GLOBALFLAT(drive_gf->sectors);
u16 blksize = GET_GLOBALFLAT(drive_gf->blksize);
dprintf(DEBUG_HDL_13, "disk_1348 size=%d t=%d chs=%d,%d,%d lba=%d bs=%d\n"
, size, type, npc, nph, nps, (u32)lba, blksize);
SET_FARVAR(seg, param_far->size, 26);
if (type == DTYPE_ATA_ATAPI) {
// 0x74 = removable, media change, lockable, max values
SET_FARVAR(seg, param_far->infos, 0x74);
SET_FARVAR(seg, param_far->cylinders, 0xffffffff);
SET_FARVAR(seg, param_far->heads, 0xffffffff);
SET_FARVAR(seg, param_far->spt, 0xffffffff);
SET_FARVAR(seg, param_far->sector_count, (u64)-1);
} else {
if (lba > (u64)nps*nph*0x3fff) {
SET_FARVAR(seg, param_far->infos, 0x00); // geometry is invalid
SET_FARVAR(seg, param_far->cylinders, 0x3fff);
} else {
SET_FARVAR(seg, param_far->infos, 0x02); // geometry is valid
SET_FARVAR(seg, param_far->cylinders, (u32)npc);
}
SET_FARVAR(seg, param_far->heads, (u32)nph);
SET_FARVAR(seg, param_far->spt, (u32)nps);
SET_FARVAR(seg, param_far->sector_count, lba);
}
SET_FARVAR(seg, param_far->blksize, blksize);
if (size < 30 ||
(type != DTYPE_ATA && type != DTYPE_ATA_ATAPI &&
type != DTYPE_VIRTIO_BLK && type != DTYPE_VIRTIO_SCSI)) {
disk_ret(regs, DISK_RET_SUCCESS);
return;
}
// EDD 2.x
int bdf;
u16 iobase1 = 0;
u64 device_path = 0;
u8 channel = 0;
SET_FARVAR(seg, param_far->size, 30);
if (type == DTYPE_ATA || type == DTYPE_ATA_ATAPI) {
SET_FARVAR(seg, param_far->dpte, SEGOFF(SEG_LOW, (u32)&DefaultDPTE));
// Fill in dpte
struct atadrive_s *adrive_gf = container_of(
drive_gf, struct atadrive_s, drive);
struct ata_channel_s *chan_gf = GET_GLOBALFLAT(adrive_gf->chan_gf);
u8 slave = GET_GLOBALFLAT(adrive_gf->slave);
u16 iobase2 = GET_GLOBALFLAT(chan_gf->iobase2);
u8 irq = GET_GLOBALFLAT(chan_gf->irq);
iobase1 = GET_GLOBALFLAT(chan_gf->iobase1);
bdf = GET_GLOBALFLAT(chan_gf->pci_bdf);
device_path = slave;
channel = GET_GLOBALFLAT(chan_gf->chanid);
u16 options = 0;
if (type == DTYPE_ATA) {
u8 translation = GET_GLOBALFLAT(drive_gf->translation);
if (translation != TRANSLATION_NONE) {
options |= 1<<3; // CHS translation
if (translation == TRANSLATION_LBA)
options |= 1<<9;
if (translation == TRANSLATION_RECHS)
options |= 3<<9;
}
} else {
// ATAPI
options |= 1<<5; // removable device
options |= 1<<6; // atapi device
}
options |= 1<<4; // lba translation
if (CONFIG_ATA_PIO32)
options |= 1<<7;
SET_LOW(DefaultDPTE.iobase1, iobase1);
SET_LOW(DefaultDPTE.iobase2, iobase2 + ATA_CB_DC);
SET_LOW(DefaultDPTE.prefix, ((slave ? ATA_CB_DH_DEV1 : ATA_CB_DH_DEV0)
| ATA_CB_DH_LBA));
SET_LOW(DefaultDPTE.unused, 0xcb);
SET_LOW(DefaultDPTE.irq, irq);
SET_LOW(DefaultDPTE.blkcount, 1);
SET_LOW(DefaultDPTE.dma, 0);
SET_LOW(DefaultDPTE.pio, 0);
SET_LOW(DefaultDPTE.options, options);
SET_LOW(DefaultDPTE.reserved, 0);
SET_LOW(DefaultDPTE.revision, 0x11);
u8 sum = checksum_far(SEG_LOW, &DefaultDPTE, 15);
SET_LOW(DefaultDPTE.checksum, -sum);
} else {
void ISV_RegisterModule (BOOL fMode)
{
char *pchDll,*pchInit,*pchDispatch;
HANDLE hDll;
FARPROC DispatchEntry;
FARPROC InitEntry;
ULONG i;
UCHAR uchMode;
// Check if we have free space in bop table.
for (i=0; i<MAX_ISV_BOP; i++) {
if (isvbop_table[i].hDll == 0)
break;
}
if (i == MAX_ISV_BOP) {
setCF (1);
setAX(4);
return;
}
uchMode = fMode ? TRUE : FALSE;
pchDll = (PCHAR) Sim32GetVDMPointer (SEGOFF(getDS(),getSI()),
1,
uchMode
);
if (pchDll == NULL) {
setCF (1);
setAX(1);
return;
}
pchInit = (PCHAR) Sim32GetVDMPointer(SEGOFF(getES(),getDI()),
1,
uchMode
);
pchDispatch = (PCHAR) Sim32GetVDMPointer(SEGOFF(getDS(),getBX()),
1,
uchMode
);
if (pchDispatch == NULL) {
setCF (1);
setAX(2);
return;
}
if ((hDll = SafeLoadLibrary(pchDll)) == NULL){
setCF (1);
setAX(1);
return;
}
// Get the init entry point and dispatch entry point
if (pchInit){
if ((ULONG)pchInit < 64*1024){
if (strlen (pchInit) >= MAX_PROC_NAME) {
FreeLibrary(hDll);
setCF (1);
setAX(4);
return;
}
strcpy (procbuffer,pchInit);
pchInit = procbuffer;
}
if ((InitEntry = (MYFARPROC)GetProcAddress(hDll, pchInit)) == NULL){
FreeLibrary(hDll);
setCF(1);
setAX(3);
return;
}
}
if ((ULONG)pchDispatch < 64*1024){
if (strlen (pchDispatch) >= MAX_PROC_NAME) {
FreeLibrary(hDll);
setCF (1);
setAX(4);
return;
}
strcpy (procbuffer,pchDispatch);
pchDispatch = procbuffer;
}
if ((DispatchEntry = (MYFARPROC)GetProcAddress(hDll, pchDispatch)) == NULL){
FreeLibrary(hDll);
setCF(1);
setAX(2);
return;
}
// Call the init routine
if (pchInit) {
(*InitEntry)();
}
// Fill up the bop table
isvbop_table[i].hDll = hDll;
isvbop_table[i].fpDispatch = DispatchEntry;
i++;
setAX((USHORT)i);
return;
}
VOID
MS_bop_7(
VOID
)
/*++
Routine Description:
Calls Vdm Redir Dispatcher. If the VDMREDIR DLL is not loaded, tries to
load it before calling Dispatcher. If the DLL could not be loaded (or
couldn't be loaded in the past) return an ERROR_INVALID_FUNCTION
Arguments:
None.
Return Value:
None.
--*/
{
static int VdmRedirLoadState = 0; // tristate:
// 0 = not loaded, first attempt
// 1 = loaded
// 2 = tried loading already, failed
//
// new: VdmRedir support is now a DLL. Try to load it. If it can't be loaded
// for whatever reason, return an error to the DOS program. Since it is
// trying to call a Redir function, we will return ERROR_INVALID_FUNCTION
//
switch (VdmRedirLoadState) {
case 0:
//
// the DLL is not yet loaded. If we can't load it and get the entry
// points for any reason, return ERROR_INVALID_FUNCTION. From now on,
// net support (including DLC, NetBIOS, named pipes and mailslots) will
// not be available to DOS programs in this session (running as part of
// this NTVDM process), but the rest of DOS functionality will be OK
//
if (LoadVdmRedir()) {
VdmRedirLoadState = 1;
} else {
VdmRedirLoadState = 2;
goto returnError;
}
//
// fall through to dispatcher in case 1
//
case 1:
//
// VdmRedir is loaded: do it
//
VrDispatch((ULONG)(*Sim32GetVDMPointer(SEGOFF(getCS(),getIP()),
1,
(UCHAR)(getMSW() & MSW_PE ? TRUE : FALSE)
)));
break;
case 2:
//
// we tried to load VdmRedir once, but the wheels fell off, so we don't
// try it any more - just return an error, OK?
//
returnError:
setCF(1);
setAX(ERROR_INVALID_FUNCTION);
break;
#if DBG
default:
printf("MS_bop_7: BAD: VdmRedirLoadState=%d???\n", VdmRedirLoadState);
#endif
}
//
// irrespective of whether the DLL is/was loaded or not, we must bump the
// VDM ip past the BOP
//
setIP((USHORT)(getIP() + 1));
}
