/**
* NF_COMMAND - execute Hatari (cli / debugger) command
* Stack arguments are:
* - pointer to command string
*/
static bool nf_command(Uint32 stack, Uint32 subid, Uint32 *retval)
{
const char *buffer;
Uint32 ptr;
ptr = STMemory_ReadLong(stack);
if ( !STMemory_CheckAreaType ( ptr, 1, ABFLAG_RAM | ABFLAG_ROM ) ) {
M68000_BusError(ptr, BUS_ERROR_READ, BUS_ERROR_SIZE_BYTE, BUS_ERROR_ACCESS_DATA);
return false;
}
buffer = (const char *)STMemory_STAddrToPointer ( ptr );
LOG_TRACE(TRACE_NATFEATS, "NF_COMMAND(0x%x \"%s\")\n", ptr, buffer);
Control_ProcessBuffer(buffer);
return true;
}
static bool nf_stderr(Uint32 stack, Uint32 subid, Uint32 *retval)
{
const char *str;
Uint32 ptr;
ptr = STMemory_ReadLong(stack);
//Dprintf(("NF stderr(0x%x)\n", ptr));
if (!STMemory_ValidArea(ptr, 1)) {
M68000_BusError(ptr, BUS_ERROR_READ);
return false;
}
str = (const char *)STRAM_ADDR(ptr);
*retval = fprintf(stderr, "%s", str);
fflush(stderr);
return true;
}
Uint32 tmc_lget(uaecptr addr) {
Uint32 val = 0;
if (addr%4) {
Log_Printf(LOG_WARN, "[TMC] Unaligned access.");
abort();
}
if (addr==0x02210000) {
Log_Printf(LOG_WARN, "[TMC] Nitro register lget from $%08X",addr);
if (ConfigureParams.System.nCpuFreq==40) {
val = tmc.nitro;
} else {
Log_Printf(LOG_WARN, "[TMC] No nitro --> bus error!");
M68000_BusError(addr, 1);
}
return val;
}
if ((addr&0xFFFFF00)==TMC_ADB_ADDR_MASK) {
return adb_lget(addr);
}
Log_Printf(LOG_TMC_LEVEL, "[TMC] lget from %08X",addr);
addr &= TMC_REGS_MASK;
if (addr<36) {
val = tmc_read_reg[addr]()<<24;
val |= tmc_read_reg[addr+1]()<<16;
val |= tmc_read_reg[addr+2]()<<8;
val |= tmc_read_reg[addr+3]();
} else if (addr>=128 && addr<144) {
val = tmc_read_vid_reg[addr&0xF]()<<24;
val |= tmc_read_vid_reg[(addr+1)&0xF]()<<16;
val |= tmc_read_vid_reg[(addr+2)&0xF]()<<8;
val |= tmc_read_vid_reg[(addr+3)&0xF]();
}
return val;
}
/**
* NF_NAME - emulator name
* Stack arguments are:
* - pointer to buffer for emulator name, and
* - uint32_t for its size
* If subid is set, emulator name includes also version information
*/
static bool nf_name(Uint32 stack, Uint32 subid, Uint32 *retval)
{
Uint32 ptr, len;
const char *str;
char *buf;
ptr = STMemory_ReadLong(stack);
len = STMemory_ReadLong(stack + SIZE_LONG);
LOG_TRACE(TRACE_NATFEATS, "NF_NAME[%d](0x%x, %d)\n", subid, ptr, len);
if ( !STMemory_CheckAreaType ( ptr, len, ABFLAG_RAM | ABFLAG_ROM ) ) {
M68000_BusError(ptr, BUS_ERROR_WRITE, BUS_ERROR_SIZE_BYTE, BUS_ERROR_ACCESS_DATA);
return false;
}
if (subid) {
str = PROG_NAME;
} else {
str = "Hatari";
}
buf = (char *)STMemory_STAddrToPointer ( ptr );
*retval = snprintf(buf, len, "%s", str);
return true;
}
static bool nf_name(Uint32 stack, Uint32 subid, Uint32 *retval)
{
Uint32 ptr, len;
const char *str;
char *buf;
ptr = STMemory_ReadLong(stack);
len = STMemory_ReadLong(stack + SIZE_LONG);
Dprintf(("NF name[%d](0x%x, %d)\n", subid, ptr, len));
if (!STMemory_ValidArea(ptr, len)) {
M68000_BusError(ptr, BUS_ERROR_WRITE);
return false;
}
if (subid) {
str = PROG_NAME;
} else {
str = "Hatari";
}
buf = (char *)STRAM_ADDR(ptr);
*retval = snprintf(buf, len, "%s", str);
return true;
}
/**
* Handle long-word read access from IO memory.
*/
uae_u32 IoMem_lget(uaecptr addr)
{
Uint32 idx;
Uint32 val;
int n;
/* Check if access is made by a new instruction or by the same instruction doing multiple long accesses */
if ( IoAccessInstrPrevClock == CyclesGlobalClockCounter )
IoAccessInstrCount++; /* Same instruction, increase access count */
else
{
IoAccessInstrPrevClock = CyclesGlobalClockCounter;
if ( ( OpcodeFamily != i_MVMEL ) && ( OpcodeFamily != i_MVMLE ) )
IoAccessInstrCount = 0; /* Instruction is not a movem : no multiple accesses */
else
IoAccessInstrCount = 1; /* 1st access of a movem.l */
}
addr &= 0x00ffffff; /* Use a 24 bit address */
if (addr < 0xff8000 || !regs.s)
{
/* invalid memory addressing --> bus error */
M68000_BusError(addr, BUS_ERROR_READ, BUS_ERROR_SIZE_LONG, BUS_ERROR_ACCESS_DATA);
return -1;
}
if (addr > 0xfffffc)
{
fprintf(stderr, "Illegal IO memory access: IoMem_lget($%x)\n", addr);
return -1;
}
IoAccessBaseAddress = addr; /* Store for exception frame */
nIoMemAccessSize = SIZE_LONG;
nBusErrorAccesses = 0;
idx = addr - 0xff8000;
IoAccessCurrentAddress = addr;
pInterceptReadTable[idx](); /* Call 1st handler */
for (n = 1; n < nIoMemAccessSize; n++)
{
if (pInterceptReadTable[idx+n] != pInterceptReadTable[idx+n-1])
{
IoAccessCurrentAddress = addr + n;
pInterceptReadTable[idx+n](); /* Call n-th handler */
}
}
/* Check if we completely read from a bus-error region */
if (nBusErrorAccesses == 4)
{
M68000_BusError(addr, BUS_ERROR_READ, BUS_ERROR_SIZE_LONG, BUS_ERROR_ACCESS_DATA);
return -1;
}
val = IoMem_ReadLong(addr);
LOG_TRACE(TRACE_IOMEM_RD, "IO read.l $%06x = $%08x pc=%x\n", addr, val, M68000_GetPC());
return val;
}
static void mem_rom_bput(uaecptr addr, uae_u32 b)
{
illegal_trace(write_log ("Illegal ROMmem bput at %08lx\n", (long)addr));
M68000_BusError(addr, 0);
}
