static int udbg_40x_real_getc(void)
{
if (udbg_comport) {
while ((real_readb(&udbg_comport->lsr) & LSR_DR) == 0)
; /* wait for char */
return real_readb(&udbg_comport->rbr);
}
return -1;
}
void INT10_ScrollWindow(Bit8u rul,Bit8u cul,Bit8u rlr,Bit8u clr,Bit8s nlines,Bit8u attr,Bit8u page) {
/* Do some range checking */
if (CurMode->type!=M_TEXT) page=0xff;
BIOS_NCOLS;BIOS_NROWS;
if(rul>rlr) return;
if(cul>clr) return;
if(rlr>=nrows) rlr=(Bit8u)nrows-1;
if(clr>=ncols) clr=(Bit8u)ncols-1;
clr++;
/* Get the correct page: current start address for current page (0xFF),
otherwise calculate from page number and page size */
PhysPt base=CurMode->pstart;
if (page==0xff) base+=real_readw(BIOSMEM_SEG,BIOSMEM_CURRENT_START);
else base+=(unsigned int)page*real_readw(BIOSMEM_SEG,BIOSMEM_PAGE_SIZE);
if (GCC_UNLIKELY(machine==MCH_PCJR)) {
if (real_readb(BIOSMEM_SEG, BIOSMEM_CURRENT_MODE) >= 9) {
// PCJr cannot handle these modes at 0xb800
// See INT10_PutPixel M_TANDY16
Bitu cpupage =
(real_readb(BIOSMEM_SEG, BIOSMEM_CRTCPU_PAGE) >> 3) & 0x7;
base = cpupage << 14;
if (page!=0xff)
base += (unsigned int)page*real_readw(BIOSMEM_SEG,BIOSMEM_PAGE_SIZE);
}
}
static void udbg_40x_real_flush(void)
{
if (udbg_comport) {
while ((real_readb(&udbg_comport->lsr) & LSR_THRE) == 0)
/* wait for idle */;
}
}
void DOS_FreeProcessMemory(Bit16u pspseg) {
Bit16u mcb_segment=dos.firstMCB;
DOS_MCB mcb(mcb_segment);
for (;;) {
if (mcb.GetPSPSeg()==pspseg) {
mcb.SetPSPSeg(MCB_FREE);
}
if (mcb.GetType()==0x5a) {
/* check if currently last block reaches up to the PCJr graphics memory */
if ((machine==MCH_PCJR) && (mcb_segment+mcb.GetSize()==0x17fe) &&
(real_readb(0x17ff,0)==0x4d) && (real_readw(0x17ff,1)==8)) {
/* re-enable the memory past segment 0x2000 */
mcb.SetType(0x4d);
} else break;
}
if (GCC_UNLIKELY(mcb.GetType()!=0x4d)) E_Exit("Corrupt MCB chain");
mcb_segment+=mcb.GetSize()+1;
mcb.SetPt(mcb_segment);
}
Bit16u umb_start=dos_infoblock.GetStartOfUMBChain();
if (umb_start==UMB_START_SEG) {
DOS_MCB umb_mcb(umb_start);
for (;;) {
if (umb_mcb.GetPSPSeg()==pspseg) {
umb_mcb.SetPSPSeg(MCB_FREE);
}
if (umb_mcb.GetType()!=0x4d) break;
umb_start+=umb_mcb.GetSize()+1;
umb_mcb.SetPt(umb_start);
}
} else if (umb_start!=0xffff) LOG(LOG_DOSMISC,LOG_ERROR)("Corrupt UMB chain: %x",umb_start);
DOS_CompressMemory();
}
static void udbg_real_scc_putc(char c)
{
while ((real_readb(sccc) & SCC_TXRDY) == 0)
;
real_writeb(c, sccd);
if (c == '\n')
udbg_real_scc_putc('\r');
}
void RestoreCursorBackgroundText() {
if (mouse.hidden || mouse.inhibit_draw) return;
if (mouse.background) {
WriteChar(mouse.backposx,mouse.backposy,real_readb(BIOSMEM_SEG,BIOSMEM_CURRENT_PAGE),mouse.backData[0],mouse.backData[1],true);
mouse.background = false;
}
}
/* check if Tandy DAC is still playing */
static bool Tandy_TransferInProgress(void) {
if (real_readw(0x40,0xd0)) return true; /* not yet done */
if (real_readb(0x40,0xd4)==0xff) return false; /* still in init-state */
Bit8u tandy_dma = 1;
if (tandy_sb.port) tandy_dma = tandy_sb.dma;
else if (tandy_dac.port) tandy_dma = tandy_dac.dma;
IO_Write(0x0c,0x00);
Bit16u datalen=(Bit8u)(IO_ReadB(tandy_dma*2+1)&0xff);
datalen|=(IO_ReadB(tandy_dma*2+1)<<8);
if (datalen==0xffff) return false; /* no DMA transfer */
else if ((datalen<0x10) && (real_readb(0x40,0xd4)==0x0f) && (real_readw(0x40,0xd2)==0x1c)) {
/* stop already requested */
return false;
}
return true;
}
void udbg_maple_real_putc(char c)
{
if (udbg_comport) {
while ((real_readb(&udbg_comport->lsr) & LSR_THRE) == 0)
/* wait for idle */;
real_writeb(c, &udbg_comport->thr); eieio();
if (c == '\n')
udbg_maple_real_putc('\r');
}
}
static void TANDY16_CopyRow(Bit8u cleft,Bit8u cright,Bit8u rold,Bit8u rnew,PhysPt base) {
Bit8u cheight = real_readb(BIOSMEM_SEG,BIOSMEM_CHAR_HEIGHT);
Bit8u banks=CurMode->twidth/10;
PhysPt dest=base+((CurMode->twidth*rnew)*(cheight/banks)+cleft)*4;
PhysPt src=base+((CurMode->twidth*rold)*(cheight/banks)+cleft)*4;
Bitu copy=(Bitu)(cright-cleft)*4u;Bitu nextline=(Bitu)CurMode->twidth*4u;
for (Bitu i=0;i<static_cast<Bitu>(cheight/banks);i++) {
for (Bitu b=0;b<banks;b++) MEM_BlockCopy(dest+b*8*1024,src+b*8*1024,copy);
dest+=nextline;src+=nextline;
}
}
static void VGA_FillRow(Bit8u cleft,Bit8u cright,Bit8u row,PhysPt base,Bit8u attr) {
/* Write some bytes */
Bit8u cheight = real_readb(BIOSMEM_SEG,BIOSMEM_CHAR_HEIGHT);
PhysPt dest=base+8*((CurMode->twidth*row)*cheight+cleft);
Bitu nextline=8*CurMode->twidth;
Bitu copy = cheight;Bitu rowsize=8u*(Bitu)(cright-cleft);
for (;copy>0;copy--) {
for (Bitu x=0;x<rowsize;x++) mem_writeb(dest+x,attr);
dest+=nextline;
}
}
static Bitu INT10_Handler(void) {
// NTS: We do have to check the "current video mode" from the BIOS data area every call.
// Some OSes like Windows 95 rely on overwriting the "current video mode" byte in
// the BIOS data area to play tricks with the BIOS. If we don't call this, tricks
// like the Windows 95 boot logo or INT 10h virtualization in Windows 3.1/9x/ME
// within the DOS "box" will not work properly.
INT10_SetCurMode();
switch (reg_ah) {
case 0x00: /* Set VideoMode */
INT10_SetVideoMode(reg_al);
break;
case 0x01: /* Set TextMode Cursor Shape */
INT10_SetCursorShape(reg_ch,reg_cl);
break;
case 0x02: /* Set Cursor Pos */
INT10_SetCursorPos(reg_dh,reg_dl,reg_bh);
break;
case 0x03: /* get Cursor Pos and Cursor Shape*/
// reg_ah=0;
reg_dl=CURSOR_POS_COL(reg_bh);
reg_dh=CURSOR_POS_ROW(reg_bh);
reg_cx=real_readw(BIOSMEM_SEG,BIOSMEM_CURSOR_TYPE);
break;
case 0x04: /* read light pen pos YEAH RIGHT */
/* Light pen is not supported */
reg_ax=0;
break;
case 0x05: /* Set Active Page */
if ((reg_al & 0x80) && IS_TANDY_ARCH) {
Bit8u crtcpu=real_readb(BIOSMEM_SEG, BIOSMEM_CRTCPU_PAGE);
switch (reg_al) {
case 0x80:
reg_bh=crtcpu & 7;
reg_bl=(crtcpu >> 3) & 0x7;
break;
case 0x81:
crtcpu=(crtcpu & 0xc7) | ((reg_bl & 7) << 3);
break;
case 0x82:
crtcpu=(crtcpu & 0xf8) | (reg_bh & 7);
break;
case 0x83:
crtcpu=(crtcpu & 0xc0) | (reg_bh & 7) | ((reg_bl & 7) << 3);
break;
}
if (machine==MCH_PCJR) {
/* always return graphics mapping, even for invalid values of AL */
reg_bh=crtcpu & 7;
reg_bl=(crtcpu >> 3) & 0x7;
}
IO_WriteB(0x3df,crtcpu);
real_writeb(BIOSMEM_SEG, BIOSMEM_CRTCPU_PAGE,crtcpu);
}
static void MCGA2_CopyRow(Bit8u cleft,Bit8u cright,Bit8u rold,Bit8u rnew,PhysPt base) {
Bit8u cheight = real_readb(BIOSMEM_SEG,BIOSMEM_CHAR_HEIGHT);
PhysPt dest=base+((CurMode->twidth*rnew)*cheight+cleft);
PhysPt src=base+((CurMode->twidth*rold)*cheight+cleft);
Bitu copy=(Bitu)(cright-cleft);
Bitu nextline=CurMode->twidth;
for (Bitu i=0;i<cheight;i++) {
MEM_BlockCopy(dest,src,copy);
dest+=nextline;src+=nextline;
}
}
static void CGA4_CopyRow(Bit8u cleft,Bit8u cright,Bit8u rold,Bit8u rnew,PhysPt base) {
Bit8u cheight = real_readb(BIOSMEM_SEG,BIOSMEM_CHAR_HEIGHT);
PhysPt dest=base+((CurMode->twidth*rnew)*(cheight/2)+cleft)*2;
PhysPt src=base+((CurMode->twidth*rold)*(cheight/2)+cleft)*2;
Bitu copy=(Bitu)(cright-cleft)*2u;Bitu nextline=(Bitu)CurMode->twidth*2u;
for (Bitu i=0;i<cheight/2U;i++) {
MEM_BlockCopy(dest,src,copy);
MEM_BlockCopy(dest+8*1024,src+8*1024,copy);
dest+=nextline;src+=nextline;
}
}
static void CGA4_FillRow(Bit8u cleft,Bit8u cright,Bit8u row,PhysPt base,Bit8u attr) {
Bit8u cheight = real_readb(BIOSMEM_SEG,BIOSMEM_CHAR_HEIGHT);
PhysPt dest=base+((CurMode->twidth*row)*(cheight/2)+cleft)*2;
Bitu copy=(Bitu)(cright-cleft)*2u;Bitu nextline=CurMode->twidth*2;
attr=(attr & 0x3) | ((attr & 0x3) << 2) | ((attr & 0x3) << 4) | ((attr & 0x3) << 6);
for (Bitu i=0;i<cheight/2U;i++) {
for (Bitu x=0;x<copy;x++) {
mem_writeb(dest+x,attr);
mem_writeb(dest+8*1024+x,attr);
}
dest+=nextline;
}
}
static void TANDY16_FillRow(Bit8u cleft,Bit8u cright,Bit8u row,PhysPt base,Bit8u attr) {
Bit8u cheight = real_readb(BIOSMEM_SEG,BIOSMEM_CHAR_HEIGHT);
Bit8u banks=CurMode->twidth/10;
PhysPt dest=base+((CurMode->twidth*row)*(cheight/banks)+cleft)*4;
Bitu copy=(Bitu)(cright-cleft)*4u;Bitu nextline=CurMode->twidth*4;
attr=(attr & 0xf) | (attr & 0xf) << 4;
for (Bitu i=0;i<static_cast<Bitu>(cheight/banks);i++) {
for (Bitu x=0;x<copy;x++) {
for (Bitu b=0;b<banks;b++) mem_writeb(dest+b*8*1024+x,attr);
}
dest+=nextline;
}
}
static void VGA_CopyRow(Bit8u cleft,Bit8u cright,Bit8u rold,Bit8u rnew,PhysPt base) {
PhysPt src,dest;Bitu copy;
Bit8u cheight = real_readb(BIOSMEM_SEG,BIOSMEM_CHAR_HEIGHT);
dest=base+8u*((CurMode->twidth*rnew)*cheight+cleft);
src=base+8u*((CurMode->twidth*rold)*cheight+cleft);
Bitu nextline=8u*(Bitu)CurMode->twidth;
Bitu rowsize=8u*(Bitu)(cright-cleft);
copy=cheight;
for (;copy>0;copy--) {
for (Bitu x=0;x<rowsize;x++) mem_writeb(dest+x,mem_readb(src+x));
dest+=nextline;src+=nextline;
}
}
static void EGA16_FillRow(Bit8u cleft,Bit8u cright,Bit8u row,PhysPt base,Bit8u attr) {
/* Set Bitmask / Color / Full Set Reset */
IO_Write(0x3ce,0x8);IO_Write(0x3cf,0xff);
IO_Write(0x3ce,0x0);IO_Write(0x3cf,attr);
IO_Write(0x3ce,0x1);IO_Write(0x3cf,0xf);
/* Enable all Write planes */
IO_Write(0x3c4,2);IO_Write(0x3c5,0xf);
/* Write some bytes */
Bit8u cheight = real_readb(BIOSMEM_SEG,BIOSMEM_CHAR_HEIGHT);
PhysPt dest=base+(CurMode->twidth*row)*cheight+cleft;
Bitu nextline=CurMode->twidth;
Bitu copy = cheight;Bitu rowsize=(Bitu)(cright-cleft);
for (;copy>0;copy--) {
for (Bitu x=0;x<rowsize;x++) mem_writeb(dest+x,0xff);
dest+=nextline;
}
IO_Write(0x3cf,0);
}
static void EGA16_CopyRow(Bit8u cleft,Bit8u cright,Bit8u rold,Bit8u rnew,PhysPt base) {
PhysPt src,dest;Bitu copy;
Bit8u cheight = real_readb(BIOSMEM_SEG,BIOSMEM_CHAR_HEIGHT);
dest=base+(CurMode->twidth*rnew)*cheight+cleft;
src=base+(CurMode->twidth*rold)*cheight+cleft;
Bitu nextline=(Bitu)CurMode->twidth;
/* Setup registers correctly */
IO_Write(0x3ce,5);IO_Write(0x3cf,1); /* Memory transfer mode */
IO_Write(0x3c4,2);IO_Write(0x3c5,0xf); /* Enable all Write planes */
/* Do some copying */
Bitu rowsize=(Bitu)(cright-cleft);
copy=cheight;
for (;copy>0;copy--) {
for (Bitu x=0;x<rowsize;x++) mem_writeb(dest+x,mem_readb(src+x));
dest+=nextline;src+=nextline;
}
/* Restore registers */
IO_Write(0x3ce,5);IO_Write(0x3cf,0); /* Normal transfer mode */
}
void DrawCursorText() {
// Restore Background
RestoreCursorBackgroundText();
// Save Background
mouse.backposx = POS_X>>3;
mouse.backposy = POS_Y>>3;
//use current page (CV program)
Bit8u page = real_readb(BIOSMEM_SEG,BIOSMEM_CURRENT_PAGE);
Bit16u result;
ReadCharAttr(mouse.backposx,mouse.backposy,page,&result);
mouse.backData[0] = (Bit8u)(result & 0xFF);
mouse.backData[1] = (Bit8u)(result>>8);
mouse.background = true;
// Write Cursor
result = (result & mouse.textAndMask) ^ mouse.textXorMask;
WriteChar(mouse.backposx,mouse.backposy,page,(Bit8u)(result&0xFF),(Bit8u)(result>>8),true);
}
static u8 udbg_uart_in_40x(unsigned int reg)
{
return real_readb((void __iomem *)CONFIG_PPC_EARLY_DEBUG_40x_PHYSADDR
+ reg);
}
bool DOS_Execute(char * name,PhysPt block_pt,Bit8u flags) {
EXE_Header head;Bitu i;
Bit16u fhandle;Bit16u len;Bit32u pos;
Bit16u pspseg,envseg,loadseg,memsize,readsize;
PhysPt loadaddress;RealPt relocpt;
Bitu headersize,imagesize;
DOS_ParamBlock block(block_pt);
block.LoadData();
if (flags!=LOADNGO && flags!=OVERLAY && flags!=LOAD) {
E_Exit("DOS:Not supported execute mode %d for file %s",flags,name);
}
/* Check for EXE or COM File */
bool iscom=false;
if (!DOS_OpenFile(name,OPEN_READ,&fhandle)) return false;
len=sizeof(EXE_Header);
if (!DOS_ReadFile(fhandle,(Bit8u *)&head,&len)) {
DOS_CloseFile(fhandle);
return false;
}
if (len<sizeof(EXE_Header)) {
if (len==0) {
/* Prevent executing zero byte files */
DOS_SetError(DOSERR_ACCESS_DENIED);
DOS_CloseFile(fhandle);
return false;
}
/* Otherwise must be a .com file */
iscom=true;
} else {
/* Convert the header to correct endian, i hope this works */
HostPt endian=(HostPt)&head;
for (i=0;i<sizeof(EXE_Header)/2;i++) {
*((Bit16u *)endian)=host_readw(endian);
endian+=2;
}
if ((head.signature!=MAGIC1) && (head.signature!=MAGIC2)) iscom=true;
else {
if(head.pages & ~0x07ff) /* 1 MB dos maximum address limit. Fixes TC3 IDE (kippesoep) */
LOG(LOG_EXEC,LOG_NORMAL)("Weird header: head.pages > 1 MB");
head.pages&=0x07ff;
headersize = head.headersize*16;
imagesize = head.pages*512-headersize;
if (imagesize+headersize<512) imagesize = 512-headersize;
}
}
Bit8u * loadbuf=(Bit8u *)new Bit8u[0x10000];
if (flags!=OVERLAY) {
/* Create an environment block */
envseg=block.exec.envseg;
if (!MakeEnv(name,&envseg)) {
DOS_CloseFile(fhandle);
return false;
}
/* Get Memory */
Bit16u minsize,maxsize;Bit16u maxfree=0xffff;DOS_AllocateMemory(&pspseg,&maxfree);
if (iscom) {
minsize=0x1000;maxsize=0xffff;
if (machine==MCH_PCJR) {
/* try to load file into memory below 96k */
pos=0;DOS_SeekFile(fhandle,&pos,DOS_SEEK_SET);
Bit16u dataread=0x1800;
DOS_ReadFile(fhandle,loadbuf,&dataread);
if (dataread<0x1800) maxsize=dataread;
if (minsize>maxsize) minsize=maxsize;
}
} else { /* Exe size calculated from header */
minsize=long2para(imagesize+(head.minmemory<<4)+256);
if (head.maxmemory!=0) maxsize=long2para(imagesize+(head.maxmemory<<4)+256);
else maxsize=0xffff;
}
if (maxfree<minsize) {
DOS_SetError(DOSERR_INSUFFICIENT_MEMORY);
DOS_FreeMemory(envseg);
return false;
}
if (maxfree<maxsize) memsize=maxfree;
else memsize=maxsize;
if (!DOS_AllocateMemory(&pspseg,&memsize)) E_Exit("DOS:Exec error in memory");
if (iscom && (machine==MCH_PCJR) && (pspseg<0x2000)) {
maxsize=0xffff;
/* resize to full extent of memory block */
DOS_ResizeMemory(pspseg,&maxsize);
/* now try to lock out memory above segment 0x2000 */
if ((real_readb(0x2000,0)==0x5a) && (real_readw(0x2000,1)==0) && (real_readw(0x2000,3)==0x7ffe)) {
/* MCB after PCJr graphics memory region is still free */
if (pspseg+maxsize==0x17ff) {
DOS_MCB cmcb((Bit16u)(pspseg-1));
cmcb.SetType(0x5a); // last block
}
}
}
loadseg=pspseg+16;
if (!iscom) {
/* Check if requested to load program into upper part of allocated memory */
if ((head.minmemory == 0) && (head.maxmemory == 0))
loadseg = ((pspseg+memsize)*0x10-imagesize)/0x10;
}
} else loadseg=block.overlay.loadseg;
/* Load the executable */
loadaddress=PhysMake(loadseg,0);
if (iscom) { /* COM Load 64k - 256 bytes max */
pos=0;DOS_SeekFile(fhandle,&pos,DOS_SEEK_SET);
readsize=0xffff-256;
DOS_ReadFile(fhandle,loadbuf,&readsize);
MEM_BlockWrite(loadaddress,loadbuf,readsize);
} else { /* EXE Load in 32kb blocks and then relocate */
pos=headersize;DOS_SeekFile(fhandle,&pos,DOS_SEEK_SET);
while (imagesize>0x7FFF) {
readsize=0x8000;DOS_ReadFile(fhandle,loadbuf,&readsize);
MEM_BlockWrite(loadaddress,loadbuf,readsize);
// if (readsize!=0x8000) LOG(LOG_EXEC,LOG_NORMAL)("Illegal header");
loadaddress+=0x8000;imagesize-=0x8000;
}
if (imagesize>0) {
readsize=(Bit16u)imagesize;DOS_ReadFile(fhandle,loadbuf,&readsize);
MEM_BlockWrite(loadaddress,loadbuf,readsize);
// if (readsize!=imagesize) LOG(LOG_EXEC,LOG_NORMAL)("Illegal header");
}
/* Relocate the exe image */
Bit16u relocate;
if (flags==OVERLAY) relocate=block.overlay.relocation;
else relocate=loadseg;
pos=head.reloctable;DOS_SeekFile(fhandle,&pos,0);
for (i=0;i<head.relocations;i++) {
readsize=4;DOS_ReadFile(fhandle,(Bit8u *)&relocpt,&readsize);
relocpt=host_readd((HostPt)&relocpt); //Endianize
PhysPt address=PhysMake(RealSeg(relocpt)+loadseg,RealOff(relocpt));
mem_writew(address,mem_readw(address)+relocate);
}
}
delete[] loadbuf;
DOS_CloseFile(fhandle);
/* Setup a psp */
if (flags!=OVERLAY) {
// Create psp after closing exe, to avoid dead file handle of exe in copied psp
SetupPSP(pspseg,memsize,envseg);
SetupCMDLine(pspseg,block);
};
CALLBACK_SCF(false); /* Carry flag cleared for caller if successfull */
if (flags==OVERLAY) return true; /* Everything done for overlays */
RealPt csip,sssp;
if (iscom) {
csip=RealMake(pspseg,0x100);
sssp=RealMake(pspseg,0xfffe);
mem_writew(PhysMake(pspseg,0xfffe),0);
} else {
csip=RealMake(loadseg+head.initCS,head.initIP);
sssp=RealMake(loadseg+head.initSS,head.initSP);
}
if (flags==LOAD) {
DOS_PSP callpsp(dos.psp());
/* Save the SS:SP on the PSP of calling program */
callpsp.SetStack(RealMakeSeg(ss,reg_sp));
/* Switch the psp's */
dos.psp(pspseg);
DOS_PSP newpsp(dos.psp());
dos.dta(RealMake(newpsp.GetSegment(),0x80));
block.exec.initsssp = sssp;
block.exec.initcsip = csip;
block.SaveData();
return true;
}
if (flags==LOADNGO) {
/* Get Caller's program CS:IP of the stack and set termination address to that */
RealSetVec(0x22,RealMake(mem_readw(SegPhys(ss)+reg_sp+2),mem_readw(SegPhys(ss)+reg_sp)));
SaveRegisters();
DOS_PSP callpsp(dos.psp());
/* Save the SS:SP on the PSP of calling program */
callpsp.SetStack(RealMakeSeg(ss,reg_sp));
/* Switch the psp's and set new DTA */
dos.psp(pspseg);
DOS_PSP newpsp(dos.psp());
dos.dta(RealMake(newpsp.GetSegment(),0x80));
/* save vectors */
newpsp.SaveVectors();
/* copy fcbs */
newpsp.SetFCB1(block.exec.fcb1);
newpsp.SetFCB2(block.exec.fcb2);
/* Set the stack for new program */
SegSet16(ss,RealSeg(sssp));reg_sp=RealOff(sssp);
/* Add some flags and CS:IP on the stack for the IRET */
reg_sp-=6;
mem_writew(SegPhys(ss)+reg_sp+0,RealOff(csip));
mem_writew(SegPhys(ss)+reg_sp+2,RealSeg(csip));
/* DOS starts programs with a RETF, so our IRET
should not modify critical flags (IOPL in v86 mode);
interrupt flag is set explicitly, test flags cleared */
mem_writew(SegPhys(ss)+reg_sp+4,(reg_flags&(~FMASK_TEST))|FLAG_IF);
/* Setup the rest of the registers */
reg_ax=reg_bx=0;reg_cx=0xff;
reg_dx=pspseg;
reg_si=RealOff(csip);
reg_di=RealOff(sssp);
reg_bp=0x91c; /* DOS internal stack begin relict */
SegSet16(ds,pspseg);SegSet16(es,pspseg);
#if C_DEBUG
/* Started from debug.com, then set breakpoint at start */
DEBUG_CheckExecuteBreakpoint(RealSeg(csip),RealOff(csip));
#endif
/* Add the filename to PSP and environment MCB's */
char stripname[8];Bitu index=0;
while (char chr=*name++) {
switch (chr) {
case ':':case '\\':case '/':index=0;break;
default:if (index<8) stripname[index++]=toupper(chr);
}
}
index=0;
while (index<8) {
if (stripname[index]=='.') break;
if (!stripname[index]) break;
index++;
}
memset(&stripname[index],0,8-index);
DOS_MCB pspmcb(dos.psp()-1);
pspmcb.SetFileName(stripname);
DOS_UpdatePSPName();
return true;
}
return false;
}
void DrawCursor() {
if (mouse.hidden || mouse.inhibit_draw) return;
// In Textmode ?
if (CurMode->type==M_TEXT) {
DrawCursorText();
return;
}
// Check video page. Seems to be ignored for text mode.
// hence the text mode handled above this
if (real_readb(BIOSMEM_SEG,BIOSMEM_CURRENT_PAGE)!=mouse.page) return;
// Check if cursor in update region
/* if ((POS_X >= mouse.updateRegion_x[0]) && (POS_X <= mouse.updateRegion_x[1]) &&
(POS_Y >= mouse.updateRegion_y[0]) && (POS_Y <= mouse.updateRegion_y[1])) {
if (CurMode->type==M_TEXT16)
RestoreCursorBackgroundText();
else
RestoreCursorBackground();
mouse.shown--;
return;
}
*/ /*Not sure yet what to do update region should be set to ??? */
// Get Clipping ranges
mouse.clipx = (Bit16s)((Bits)CurMode->swidth-1); /* Get from bios ? */
mouse.clipy = (Bit16s)((Bits)CurMode->sheight-1);
/* might be vidmode == 0x13?2:1 */
Bit16s xratio = 640;
if (CurMode->swidth>0) xratio/=CurMode->swidth;
if (xratio==0) xratio = 1;
RestoreCursorBackground();
SaveVgaRegisters();
// Save Background
Bit16s x,y;
Bit16u addx1,addx2,addy;
Bit16u dataPos = 0;
Bit16s x1 = POS_X / xratio - mouse.hotx;
Bit16s y1 = POS_Y - mouse.hoty;
Bit16s x2 = x1 + CURSORX - 1;
Bit16s y2 = y1 + CURSORY - 1;
ClipCursorArea(x1,x2,y1,y2, addx1, addx2, addy);
dataPos = addy * CURSORX;
for (y=y1; y<=y2; y++) {
dataPos += addx1;
for (x=x1; x<=x2; x++) {
INT10_GetPixel(x,y,mouse.page,&mouse.backData[dataPos++]);
};
dataPos += addx2;
};
mouse.background= true;
mouse.backposx = POS_X / xratio - mouse.hotx;
mouse.backposy = POS_Y - mouse.hoty;
// Draw Mousecursor
dataPos = addy * CURSORX;
for (y=y1; y<=y2; y++) {
Bit16u scMask = mouse.screenMask[addy+y-y1];
Bit16u cuMask = mouse.cursorMask[addy+y-y1];
if (addx1>0) { scMask<<=addx1; cuMask<<=addx1; dataPos += addx1; };
for (x=x1; x<=x2; x++) {
Bit8u pixel = 0;
// ScreenMask
if (scMask & HIGHESTBIT) pixel = mouse.backData[dataPos];
scMask<<=1;
// CursorMask
if (cuMask & HIGHESTBIT) pixel = pixel ^ 0x0F;
cuMask<<=1;
// Set Pixel
INT10_PutPixel(x,y,mouse.page,pixel);
dataPos++;
};
dataPos += addx2;
};
RestoreVgaRegisters();
}
static Bitu INT10_Handler(void) {
#if 0
switch (reg_ah) {
case 0x02:
case 0x03:
case 0x09:
case 0xc:
case 0xd:
case 0x0e:
case 0x10:
case 0x4f:
break;
default:
LOG(LOG_INT10,LOG_NORMAL)("Function AX:%04X , BX %04X DX %04X",reg_ax,reg_bx,reg_dx);
break;
}
#endif
switch (reg_ah) {
case 0x00: /* Set VideoMode */
INT10_SetVideoMode(reg_al);
break;
case 0x01: /* Set TextMode Cursor Shape */
INT10_SetCursorShape(reg_ch,reg_cl);
break;
case 0x02: /* Set Cursor Pos */
INT10_SetCursorPos(reg_dh,reg_dl,reg_bh);
break;
case 0x03: /* get Cursor Pos and Cursor Shape*/
// reg_ah=0;
reg_dl=CURSOR_POS_COL(reg_bh);
reg_dh=CURSOR_POS_ROW(reg_bh);
reg_cx=real_readw(BIOSMEM_SEG,BIOSMEM_CURSOR_TYPE);
break;
case 0x04: /* read light pen pos YEAH RIGHT */
/* Light pen is not supported */
reg_ax=0;
break;
case 0x05: /* Set Active Page */
if ((reg_al & 0x80) && IS_TANDY_ARCH) {
Bit8u crtcpu=real_readb(BIOSMEM_SEG, BIOSMEM_CRTCPU_PAGE);
switch (reg_al) {
case 0x80:
reg_bh=crtcpu & 7;
reg_bl=(crtcpu >> 3) & 0x7;
break;
case 0x81:
crtcpu=(crtcpu & 0xc7) | ((reg_bl & 7) << 3);
break;
case 0x82:
crtcpu=(crtcpu & 0xf8) | (reg_bh & 7);
break;
case 0x83:
crtcpu=(crtcpu & 0xc0) | (reg_bh & 7) | ((reg_bl & 7) << 3);
break;
}
if (machine==MCH_PCJR) {
/* always return graphics mapping, even for invalid values of AL */
reg_bh=crtcpu & 7;
reg_bl=(crtcpu >> 3) & 0x7;
}
IO_WriteB(0x3df,crtcpu);
real_writeb(BIOSMEM_SEG, BIOSMEM_CRTCPU_PAGE,crtcpu);
}
//Does way to much. Many things should be moved to mouse reset one day
void Mouse_NewVideoMode(void) {
mouse.inhibit_draw=false;
/* Get the correct resolution from the current video mode */
Bit8u mode=mem_readb(BIOS_VIDEO_MODE);
if(mode == mouse.mode) {LOG(LOG_MOUSE,LOG_NORMAL)("New video is the same as the old"); /*return;*/}
switch (mode) {
case 0x00:
case 0x01:
case 0x02:
case 0x03: {
Bitu rows=real_readb(BIOSMEM_SEG,BIOSMEM_NB_ROWS);
if ((rows==0) || (rows>250)) rows=25-1;
mouse.max_y=8*(rows+1)-1;
break;
}
case 0x04:
case 0x05:
case 0x06:
case 0x07:
case 0x08:
case 0x09:
case 0x0a:
case 0x0d:
case 0x0e:
case 0x13:
mouse.max_y=199;
break;
case 0x0f:
case 0x10:
mouse.max_y=349;
break;
case 0x11:
case 0x12:
mouse.max_y=479;
break;
default:
LOG(LOG_MOUSE,LOG_ERROR)("Unhandled videomode %X on reset",mode);
mouse.inhibit_draw=true;
return;
}
mouse.mode = mode;
mouse.hidden = 1;
mouse.max_x = 639;
mouse.min_x = 0;
mouse.min_y = 0;
mouse.granMask = (mode == 0x0d || mode == 0x13) ? 0xfffe : 0xffff;
mouse.events = 0;
mouse.timer_in_progress = false;
PIC_RemoveEvents(MOUSE_Limit_Events);
mouse.hotx = 0;
mouse.hoty = 0;
mouse.background = false;
mouse.screenMask = defaultScreenMask;
mouse.cursorMask = defaultCursorMask;
mouse.textAndMask= defaultTextAndMask;
mouse.textXorMask= defaultTextXorMask;
mouse.language = 0;
mouse.page = 0;
mouse.doubleSpeedThreshold = 64;
mouse.updateRegion_x[0] = 1;
mouse.updateRegion_y[0] = 1;
mouse.updateRegion_x[1] = 1;
mouse.updateRegion_y[1] = 1;
mouse.cursorType = 0;
mouse.enabled=true;
mouse.oldhidden=1;
oldmouseX = static_cast<Bit16s>(mouse.x);
oldmouseY = static_cast<Bit16s>(mouse.y);
}
//Initializer - is startet if executed file is SCHICKM.EXE/BLADEM.EXE or GEN.EXE
//Returns true if the desired programm is started
bool init_schick(char *name, unsigned short reloc, unsigned short _cs, unsigned short ip)
{
char borsig[] = "Borland C++ - Copyright 1991 Borland Intl.";
char fname[81];
int ver;
schick_get_fname(fname, name);
if (strcmp(fname, "schickm.exe")
&& strcmp(fname, "bladem.exe")
&& strcmp(fname, "gen.exe")) return false;
/* Check CS:IP in the EXE-Header are 0:0
* and the first executed instruction is mov dx,i16 */
if (_cs != 0 || ip != 0 || real_readb(reloc+_cs, ip) != 0xba)
return false;
/* Show CS:IP on the virtual machine and the pointer to 0:0 */
D1_TRAC("\n\nCS:IP 0x%x:0x%x\tMemBase: %p\n", reloc, ip, MemBase);
/* Read and show the Datasegment */
datseg_bak = datseg;
datseg = real_readw(reloc, ip+1);
p_datseg_bak = p_datseg;
p_datseg = MemBase + PhysMake(datseg, 0);
D1_TRAC("Dseg: 0x%X\n", datseg);
/* Check if the start of the Datasegment is Borland C++ */
if (host_readd(p_datseg) != 0 ||
strcmp((char*)MemBase+PhysMake(datseg, 4), borsig)) {
D1_ERR("Kein Borland C++ Kompilat!\n");
return false;
}
/* check for the game program */
if (!strcmp(fname, "schickm.exe") || !strcmp(fname, "bladem.exe")) {
reloc_game = reloc;
ver = schick_get_version((char*)p_datseg);
if (ver == 0) {
D1_ERR("Unbekannte Version von DSA1\n");
return false;
}
D1_INFO("\nDSA1 Schicksalsklinge gefunden V%d.%02d_%s\n",
ver / 100, ver % 100, schick_is_en() ? "en": "de");
/* enable profiler only on this version */
if (ver == 302 && !schick_is_en()) {
D1_INFO("Starte Profiler\n");
/* enable status comperator */
schick_status_init();
schick_timer_enable();
schick++;
}
}
/* check for the character generation program */
if (!strcmp(fname, "gen.exe")) {
reloc_gen = reloc;
ver = schick_gen_get_version((char*)p_datseg);
if (ver == 0) {
D1_ERR("Unbekannte Version von DSA1 Generierung\n");
return false;
}
D1_INFO("DSA1 Generierung gefunden V%d.%02d_%s\n",
ver / 100, ver % 100, schick_gen_is_en() ? "en": "de");
/* This happens only gen is started from the game.
We have to save some values. */
if (!fromgame && schick && !gen) {
if (schick_get_version((char*)p_datseg_bak) == 302 && !schick_is_en()) {
schick_status_disable();
schick_timer_disable();
}
schick--;
fromgame++;
D1_INFO("Gen gestartet\nreloc (0x%x)\n",
(unsigned int)reloc_gen);
}
/* enable profiler only on this version */
if (ver == 105 && !schick_is_en()) {
D1_INFO("Starte Profiler\n");
gen++;
}
}
return true;
}
bool INT10_VideoState_Restore(Bitu state,RealPt buffer) {
Bitu ct;
if ((state&7)==0) return false;
Bit16u base_seg=RealSeg(buffer);
Bit16u base_dest;
if (state&1) {
base_dest=real_readw(base_seg,RealOff(buffer));
Bit16u crt_reg=real_readw(base_seg,base_dest+0x40);
// reprogram for full access to plane latches
IO_WriteW(0x3c4,0x0704);
IO_WriteW(0x3ce,0x0406);
IO_WriteW(0x3ce,0x0005);
IO_WriteW(0x3c4,0x0002);
mem_writeb(0xaffff,real_readb(base_seg,base_dest+0x42));
IO_WriteW(0x3c4,0x0102);
mem_writeb(0xaffff,real_readb(base_seg,base_dest+0x43));
IO_WriteW(0x3c4,0x0202);
mem_writeb(0xaffff,real_readb(base_seg,base_dest+0x44));
IO_WriteW(0x3c4,0x0402);
mem_writeb(0xaffff,real_readb(base_seg,base_dest+0x45));
IO_WriteW(0x3c4,0x0f02);
mem_readb(0xaffff);
IO_WriteW(0x3c4,0x0100);
// sequencer
for (ct=1; ct<5; ct++) {
IO_WriteW(0x3c4,ct+(real_readb(base_seg,base_dest+0x04+ct)<<8));
}
IO_WriteB(0x3c2,real_readb(base_seg,base_dest+0x09));
IO_WriteW(0x3c4,0x0300);
IO_WriteW(crt_reg,0x0011);
// crt controller
for (ct=0; ct<0x19; ct++) {
IO_WriteW(crt_reg,ct+(real_readb(base_seg,base_dest+0x0a+ct)<<8));
}
IO_ReadB(crt_reg+6);
// attr registers
for (ct=0; ct<4; ct++) {
IO_WriteB(0x3c0,0x10+ct);
IO_WriteB(0x3c0,real_readb(base_seg,base_dest+0x33+ct));
}
// graphics registers
for (ct=0; ct<9; ct++) {
IO_WriteW(0x3ce,ct+(real_readb(base_seg,base_dest+0x37+ct)<<8));
}
IO_WriteB(crt_reg+6,real_readb(base_seg,base_dest+0x04));
IO_ReadB(crt_reg+6);
// attr registers
for (ct=0; ct<0x10; ct++) {
IO_WriteB(0x3c0,ct);
IO_WriteB(0x3c0,real_readb(base_seg,base_dest+0x23+ct));
}
IO_WriteB(0x3c4,real_readb(base_seg,base_dest+0x00));
IO_WriteB(0x3d4,real_readb(base_seg,base_dest+0x01));
IO_WriteB(0x3ce,real_readb(base_seg,base_dest+0x02));
IO_ReadB(crt_reg+6);
IO_WriteB(0x3c0,real_readb(base_seg,base_dest+0x03));
}
if (state&2) {
base_dest=real_readw(base_seg,RealOff(buffer)+2);
mem_writeb(0x410,(mem_readb(0x410)&0xcf) | real_readb(base_seg,base_dest+0x00));
for (ct=0; ct<0x1e; ct++) {
mem_writeb(0x449+ct,real_readb(base_seg,base_dest+0x01+ct));
}
for (ct=0; ct<0x07; ct++) {
mem_writeb(0x484+ct,real_readb(base_seg,base_dest+0x1f+ct));
}
mem_writed(0x48a,real_readd(base_seg,base_dest+0x26));
mem_writed(0x14,real_readd(base_seg,base_dest+0x2a)); // int 5
mem_writed(0x74,real_readd(base_seg,base_dest+0x2e)); // int 1d
mem_writed(0x7c,real_readd(base_seg,base_dest+0x32)); // int 1f
mem_writed(0x10c,real_readd(base_seg,base_dest+0x36)); // int 43
}
if (state&4) {
base_dest=real_readw(base_seg,RealOff(buffer)+4);
Bit16u crt_reg=real_readw(BIOSMEM_SEG,BIOSMEM_CRTC_ADDRESS);
IO_WriteB(0x3c6,real_readb(base_seg,base_dest+0x002));
for (ct=0; ct<0x100; ct++) {
IO_WriteB(0x3c8,ct);
IO_WriteB(0x3c9,real_readb(base_seg,base_dest+0x003+ct*3+0));
IO_WriteB(0x3c9,real_readb(base_seg,base_dest+0x003+ct*3+1));
IO_WriteB(0x3c9,real_readb(base_seg,base_dest+0x003+ct*3+2));
}
IO_ReadB(crt_reg+6);
IO_WriteB(0x3c0,0x14);
IO_WriteB(0x3c0,real_readb(base_seg,base_dest+0x303));
Bitu dac_state=real_readb(base_seg,base_dest+0x000);
if (dac_state==0) {
IO_WriteB(0x3c8,real_readb(base_seg,base_dest+0x001));
} else {
IO_WriteB(0x3c7,real_readb(base_seg,base_dest+0x001));
}
}
if ((svgaCard==SVGA_S3Trio) && (state&8)) {
base_dest=real_readw(base_seg,RealOff(buffer)+6);
Bit16u crt_reg=real_readw(BIOSMEM_SEG,BIOSMEM_CRTC_ADDRESS);
Bitu seq_idx=IO_ReadB(0x3c4);
IO_WriteB(0x3c4,0x08);
// Bitu seq_8=IO_ReadB(0x3c5);
IO_ReadB(0x3c5);
// real_writeb(base_seg,base_dest+0x00,IO_ReadB(0x3c5));
IO_WriteB(0x3c5,0x06); // unlock s3-specific registers
// sequencer
for (ct=0; ct<0x13; ct++) {
IO_WriteW(0x3c4,(0x09+ct)+(real_readb(base_seg,base_dest+0x00+ct)<<8));
}
IO_WriteB(0x3c4,seq_idx);
// Bitu crtc_idx=IO_ReadB(0x3d4);
// unlock s3-specific registers
IO_WriteW(crt_reg,0x4838);
IO_WriteW(crt_reg,0xa539);
// crt controller
Bitu ct_dest=0x13;
for (ct=0; ct<0x40; ct++) {
if ((ct==0x4a-0x30) || (ct==0x4b-0x30)) {
IO_WriteB(crt_reg,0x45);
IO_ReadB(crt_reg+1);
IO_WriteB(crt_reg,0x30+ct);
IO_WriteB(crt_reg,real_readb(base_seg,base_dest+(ct_dest++)));
} else {
IO_WriteW(crt_reg,(0x30+ct)+(real_readb(base_seg,base_dest+(ct_dest++))<<8));
}
}
// mmio
/* IO_WriteB(crt_reg,0x40);
Bitu sysval1=IO_ReadB(crt_reg+1);
IO_WriteB(crt_reg+1,sysval|1);
IO_WriteB(crt_reg,0x53);
Bitu sysva2=IO_ReadB(crt_reg+1);
IO_WriteB(crt_reg+1,sysval2|0x10);
real_writew(0xa000,0x8128,0xffff);
IO_WriteB(crt_reg,0x40);
IO_WriteB(crt_reg,sysval1);
IO_WriteB(crt_reg,0x53);
IO_WriteB(crt_reg,sysval2);
IO_WriteB(crt_reg,crtc_idx); */
}
return true;
}
static u8 udbg_uart_in_maple(unsigned int reg)
{
return real_readb(UDBG_UART_MAPLE_ADDR + reg);
}
void INT10_GenerateVideoParameterTable(void) {
if (!IS_VGA_ARCH) E_Exit("Be sure that all graphics registers are readable!");
Bitu i;
for (i=0; i<4; i++) {
LOG_MSG("// video parameter table for mode %x (cga emulation)",i);
LOG_MSG(" 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,");
LOG_MSG(" 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,");
LOG_MSG(" 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,");
LOG_MSG(" 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,");
}
for (i=4; i<0x0f; i++) {
Bitu ct;
LOG_MSG("// video parameter table for mode %x",i);
if ((i>=8) && (i<0x0d)) {
LOG_MSG(" 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,");
LOG_MSG(" 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,");
LOG_MSG(" 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,");
LOG_MSG(" 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,");
} else {
INT10_SetVideoMode(i);
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, // bios data",real_readb(0x40,0x4a),real_readb(0x40,0x84),real_readb(0x40,0x85),real_readb(0x40,0x4c),real_readb(0x40,0x4d));
Bitu seq_regs[4];
for (ct=0; ct<4; ct++) {
IO_WriteB(0x3c4,ct+1);
seq_regs[ct]=IO_ReadB(0x3c5);
}
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, // sequencer registers",seq_regs[0],seq_regs[1],seq_regs[2],seq_regs[3]);
LOG_MSG(" 0x%02x, // misc output registers",IO_ReadB(0x3cc));
Bitu crtc_regs[0x19];
Bit16u crt_addr=real_readw(BIOSMEM_SEG,BIOSMEM_CRTC_ADDRESS);
for (ct=0; ct<0x19; ct++) {
IO_WriteB(crt_addr,ct);
crtc_regs[ct]=IO_ReadB(crt_addr+1);
}
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, // crtc registers 0-7",
crtc_regs[0x00],crtc_regs[0x01],crtc_regs[0x02],crtc_regs[0x03],
crtc_regs[0x04],crtc_regs[0x05],crtc_regs[0x06],crtc_regs[0x07]);
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, // crtc registers 8-15",
crtc_regs[0x08],crtc_regs[0x09],crtc_regs[0x0a],crtc_regs[0x0b],
crtc_regs[0x0c],crtc_regs[0x0d],crtc_regs[0x0e],crtc_regs[0x0f]);
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, // crtc registers 16-24",
crtc_regs[0x10],crtc_regs[0x11],crtc_regs[0x12],crtc_regs[0x13],
crtc_regs[0x14],crtc_regs[0x15],crtc_regs[0x16],crtc_regs[0x17],crtc_regs[0x18]);
Bitu attr_regs[0x14];
for (ct=0; ct<0x14; ct++) {
IO_ReadB(crt_addr+6);
IO_WriteB(0x3c0,ct);
attr_regs[ct]=IO_ReadB(0x3c1);
}
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, // attr registers 0-7",
attr_regs[0x00],attr_regs[0x01],attr_regs[0x02],attr_regs[0x03],
attr_regs[0x04],attr_regs[0x05],attr_regs[0x06],attr_regs[0x07]);
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, // attr registers 8-15",
attr_regs[0x08],attr_regs[0x09],attr_regs[0x0a],attr_regs[0x0b],
attr_regs[0x0c],attr_regs[0x0d],attr_regs[0x0e],attr_regs[0x0f]);
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, // attr registers 16-19",
attr_regs[0x10],attr_regs[0x11],attr_regs[0x12],attr_regs[0x13]);
Bitu gfx_regs[9];
for (ct=0; ct<0x09; ct++) {
IO_WriteB(0x3ce,ct);
gfx_regs[ct]=IO_ReadB(0x3cf);
}
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, // graphics registers 0-8",
gfx_regs[0x00],gfx_regs[0x01],gfx_regs[0x02],gfx_regs[0x03],
gfx_regs[0x04],gfx_regs[0x05],gfx_regs[0x06],gfx_regs[0x07],gfx_regs[0x08]);
}
}
for (i=0x0f; i<0x11; i++) {
LOG_MSG("// video parameter table for mode %x (64k graphics memory)",i);
LOG_MSG(" 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,");
LOG_MSG(" 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,");
LOG_MSG(" 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,");
LOG_MSG(" 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,");
}
for (i=0x0f; i<0x11; i++) {
Bitu ct;
INT10_SetVideoMode(i);
LOG_MSG("// video parameter table for mode %x (>64k graphics memory)",i);
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, // bios data",real_readb(0x40,0x4a),real_readb(0x40,0x84),real_readb(0x40,0x85),real_readb(0x40,0x4c),real_readb(0x40,0x4d));
Bitu seq_regs[4];
for (ct=0; ct<4; ct++) {
IO_WriteB(0x3c4,ct+1);
seq_regs[ct]=IO_ReadB(0x3c5);
}
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, // sequencer registers",seq_regs[0],seq_regs[1],seq_regs[2],seq_regs[3]);
LOG_MSG(" 0x%02x, // misc output registers",IO_ReadB(0x3cc));
Bitu crtc_regs[0x19];
Bit16u crt_addr=real_readw(BIOSMEM_SEG,BIOSMEM_CRTC_ADDRESS);
for (ct=0; ct<0x19; ct++) {
IO_WriteB(crt_addr,ct);
crtc_regs[ct]=IO_ReadB(crt_addr+1);
}
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, // crtc registers 0-7",
crtc_regs[0x00],crtc_regs[0x01],crtc_regs[0x02],crtc_regs[0x03],
crtc_regs[0x04],crtc_regs[0x05],crtc_regs[0x06],crtc_regs[0x07]);
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, // crtc registers 8-15",
crtc_regs[0x08],crtc_regs[0x09],crtc_regs[0x0a],crtc_regs[0x0b],
crtc_regs[0x0c],crtc_regs[0x0d],crtc_regs[0x0e],crtc_regs[0x0f]);
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, // crtc registers 16-24",
crtc_regs[0x10],crtc_regs[0x11],crtc_regs[0x12],crtc_regs[0x13],
crtc_regs[0x14],crtc_regs[0x15],crtc_regs[0x16],crtc_regs[0x17],crtc_regs[0x18]);
Bitu attr_regs[0x14];
for (ct=0; ct<0x14; ct++) {
IO_ReadB(crt_addr+6);
IO_WriteB(0x3c0,ct);
attr_regs[ct]=IO_ReadB(0x3c1);
}
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, // attr registers 0-7",
attr_regs[0x00],attr_regs[0x01],attr_regs[0x02],attr_regs[0x03],
attr_regs[0x04],attr_regs[0x05],attr_regs[0x06],attr_regs[0x07]);
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, // attr registers 8-15",
attr_regs[0x08],attr_regs[0x09],attr_regs[0x0a],attr_regs[0x0b],
attr_regs[0x0c],attr_regs[0x0d],attr_regs[0x0e],attr_regs[0x0f]);
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, // attr registers 16-19",
attr_regs[0x10],attr_regs[0x11],attr_regs[0x12],attr_regs[0x13]);
Bitu gfx_regs[9];
for (ct=0; ct<0x09; ct++) {
IO_WriteB(0x3ce,ct);
gfx_regs[ct]=IO_ReadB(0x3cf);
}
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, // graphics registers 0-8",
gfx_regs[0x00],gfx_regs[0x01],gfx_regs[0x02],gfx_regs[0x03],
gfx_regs[0x04],gfx_regs[0x05],gfx_regs[0x06],gfx_regs[0x07],gfx_regs[0x08]);
}
for (i=0; i<4; i++) {
if (IS_VGA_ARCH) {
LOG_MSG("// video parameter table for mode %x (350 lines)",i);
LOG_MSG(" 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,");
LOG_MSG(" 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,");
LOG_MSG(" 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,");
LOG_MSG(" 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,");
} else {
Bitu ct;
INT10_SetVideoMode(i);
LOG_MSG("// video parameter table for mode %x (350 lines)",i);
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, // bios data",real_readb(0x40,0x4a),real_readb(0x40,0x84),real_readb(0x40,0x85),real_readb(0x40,0x4c),real_readb(0x40,0x4d));
Bitu seq_regs[4];
for (ct=0; ct<4; ct++) {
IO_WriteB(0x3c4,ct+1);
seq_regs[ct]=IO_ReadB(0x3c5);
}
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, // sequencer registers",seq_regs[0],seq_regs[1],seq_regs[2],seq_regs[3]);
LOG_MSG(" 0x%02x, // misc output registers",IO_ReadB(0x3cc));
Bitu crtc_regs[0x19];
Bit16u crt_addr=real_readw(BIOSMEM_SEG,BIOSMEM_CRTC_ADDRESS);
for (ct=0; ct<0x19; ct++) {
IO_WriteB(crt_addr,ct);
crtc_regs[ct]=IO_ReadB(crt_addr+1);
}
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, // crtc registers 0-7",
crtc_regs[0x00],crtc_regs[0x01],crtc_regs[0x02],crtc_regs[0x03],
crtc_regs[0x04],crtc_regs[0x05],crtc_regs[0x06],crtc_regs[0x07]);
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, // crtc registers 8-15",
crtc_regs[0x08],crtc_regs[0x09],crtc_regs[0x0a],crtc_regs[0x0b],
crtc_regs[0x0c],crtc_regs[0x0d],crtc_regs[0x0e],crtc_regs[0x0f]);
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, // crtc registers 16-24",
crtc_regs[0x10],crtc_regs[0x11],crtc_regs[0x12],crtc_regs[0x13],
crtc_regs[0x14],crtc_regs[0x15],crtc_regs[0x16],crtc_regs[0x17],crtc_regs[0x18]);
Bitu attr_regs[0x14];
for (ct=0; ct<0x14; ct++) {
IO_ReadB(crt_addr+6);
IO_WriteB(0x3c0,ct);
attr_regs[ct]=IO_ReadB(0x3c1);
}
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, // attr registers 0-7",
attr_regs[0x00],attr_regs[0x01],attr_regs[0x02],attr_regs[0x03],
attr_regs[0x04],attr_regs[0x05],attr_regs[0x06],attr_regs[0x07]);
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, // attr registers 8-15",
attr_regs[0x08],attr_regs[0x09],attr_regs[0x0a],attr_regs[0x0b],
attr_regs[0x0c],attr_regs[0x0d],attr_regs[0x0e],attr_regs[0x0f]);
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, // attr registers 16-19",
attr_regs[0x10],attr_regs[0x11],attr_regs[0x12],attr_regs[0x13]);
Bitu gfx_regs[9];
for (ct=0; ct<0x09; ct++) {
IO_WriteB(0x3ce,ct);
gfx_regs[ct]=IO_ReadB(0x3cf);
}
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, // graphics registers 0-8",
gfx_regs[0x00],gfx_regs[0x01],gfx_regs[0x02],gfx_regs[0x03],
gfx_regs[0x04],gfx_regs[0x05],gfx_regs[0x06],gfx_regs[0x07],gfx_regs[0x08]);
}
}
if (IS_VGA_ARCH) {
for (i=0x0e; i<0x14; i++) {
Bitu ct=i;
if (i==0x0e) ct=1;
if (i==0x0f) ct=3;
if (i==0x010) ct=7;
INT10_SetVideoMode(ct);
LOG_MSG("// video parameter table for mode %x",i);
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, // bios data",real_readb(0x40,0x4a),real_readb(0x40,0x84),real_readb(0x40,0x85),real_readb(0x40,0x4c),real_readb(0x40,0x4d));
Bitu seq_regs[4];
for (ct=0; ct<4; ct++) {
IO_WriteB(0x3c4,ct+1);
seq_regs[ct]=IO_ReadB(0x3c5);
}
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, // sequencer registers",seq_regs[0],seq_regs[1],seq_regs[2],seq_regs[3]);
LOG_MSG(" 0x%02x, // misc output registers",IO_ReadB(0x3cc));
Bitu crtc_regs[0x19];
Bit16u crt_addr=real_readw(BIOSMEM_SEG,BIOSMEM_CRTC_ADDRESS);
for (ct=0; ct<0x19; ct++) {
IO_WriteB(crt_addr,ct);
crtc_regs[ct]=IO_ReadB(crt_addr+1);
}
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, // crtc registers 0-7",
crtc_regs[0x00],crtc_regs[0x01],crtc_regs[0x02],crtc_regs[0x03],
crtc_regs[0x04],crtc_regs[0x05],crtc_regs[0x06],crtc_regs[0x07]);
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, // crtc registers 8-15",
crtc_regs[0x08],crtc_regs[0x09],crtc_regs[0x0a],crtc_regs[0x0b],
crtc_regs[0x0c],crtc_regs[0x0d],crtc_regs[0x0e],crtc_regs[0x0f]);
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, // crtc registers 16-24",
crtc_regs[0x10],crtc_regs[0x11],crtc_regs[0x12],crtc_regs[0x13],
crtc_regs[0x14],crtc_regs[0x15],crtc_regs[0x16],crtc_regs[0x17],crtc_regs[0x18]);
Bitu attr_regs[0x14];
for (ct=0; ct<0x14; ct++) {
IO_ReadB(crt_addr+6);
IO_WriteB(0x3c0,ct);
attr_regs[ct]=IO_ReadB(0x3c1);
}
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, // attr registers 0-7",
attr_regs[0x00],attr_regs[0x01],attr_regs[0x02],attr_regs[0x03],
attr_regs[0x04],attr_regs[0x05],attr_regs[0x06],attr_regs[0x07]);
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, // attr registers 8-15",
attr_regs[0x08],attr_regs[0x09],attr_regs[0x0a],attr_regs[0x0b],
attr_regs[0x0c],attr_regs[0x0d],attr_regs[0x0e],attr_regs[0x0f]);
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, // attr registers 16-19",
attr_regs[0x10],attr_regs[0x11],attr_regs[0x12],attr_regs[0x13]);
Bitu gfx_regs[9];
for (ct=0; ct<0x09; ct++) {
IO_WriteB(0x3ce,ct);
gfx_regs[ct]=IO_ReadB(0x3cf);
}
LOG_MSG(" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, // graphics registers 0-8",
gfx_regs[0x00],gfx_regs[0x01],gfx_regs[0x02],gfx_regs[0x03],
gfx_regs[0x04],gfx_regs[0x05],gfx_regs[0x06],gfx_regs[0x07],gfx_regs[0x08]);
}
}
INT10_SetVideoMode(3);
E_Exit("done!");
}
