Пример #1
0
void m68010_set_reg(int regnum, unsigned val)
{
	switch( regnum )
	{
		case M68K_VBR: m68k_set_reg(M68K_REG_VBR, val); break;
		case M68K_SFC: m68k_set_reg(M68K_REG_SFC, val); break;
		case M68K_DFC: m68k_set_reg(M68K_REG_DFC, val); break;
		default:       m68000_set_reg(regnum, val); break;
	}
}
Пример #2
0
void m68ec020_set_reg(int regnum, unsigned val)
{
	switch( regnum )
	{
		case M68K_MSP:  m68k_set_reg(M68K_REG_MSP, val); break;
		case M68K_CACR: m68k_set_reg(M68K_REG_CACR, val); break;
		case M68K_CAAR: m68k_set_reg(M68K_REG_CAAR, val); break;
		default:        m68010_set_reg(regnum, val); break;
	}
}
Пример #3
0
void SetRegisterValue(RegistersHandle _Register, int _iIndex, const char* _szValue)
{
    switch ((uint32)_Register)
    {
    case kRegister_Z80:
        {
            uint32 uiRegister = 0;
            sscanf(_szValue, gszRegisterFormatZ80[_iIndex], &uiRegister);
            gRegisterZ80[_iIndex]->d = uiRegister;
            break;
        }
    case kRegister_M68000:
        {
            uint32 uiRegister = 0;
            sscanf(_szValue, gszRegisterFormat68000[_iIndex], &uiRegister);
            m68k_set_reg(guiConv68000DebugToEmu[_iIndex], uiRegister);
            break;
        }
    case kRegister_S68000:
        {
            uint32 uiRegister = 0;
            sscanf(_szValue, gszRegisterFormat68000[_iIndex], &uiRegister);
            s68k_set_reg(guiConv68000DebugToEmu[_iIndex], uiRegister);
            break;
        }
    }
}
Пример #4
0
void m68020_set_reg(int regnum, unsigned val)
{
	switch( regnum )
	{
		case M68K_PC:  m68k_set_reg(M68K_REG_PC, val); break;
	}
	m68ec020_set_reg(regnum, val);
}
Пример #5
0
void M68K_SetPC(u32 val)
{
#ifdef CPU68K_USE_MUSASHI
    m68k_set_reg(M68K_REG_PC, val);
#endif

#ifdef CPU68K_USE_C68K
    C68k_Set_PC(&C68K, val);
#endif
}
Пример #6
0
inline void M68K_SetUSP(u32 val)
{
#ifdef CPU68K_USE_MUSASHI
    m68k_set_reg(M68K_REG_USP, val);
#endif

#ifdef CPU68K_USE_C68K
    C68k_Set_USP(&C68K, val);
#endif
}
Пример #7
0
inline void M68K_SetAReg(u32 num, u32 val)
{
#ifdef CPU68K_USE_MUSASHI
    m68k_set_reg(M68K_REG_A0 + num, val);
#endif

#ifdef CPU68K_USE_C68K
    C68k_Set_AReg(&C68K, num, val);
#endif
}
Пример #8
0
/* this function checks the cache to see if the current state is cached,
   if it is then it copies the cached data to the user region where code is
   executed from, if its not cached then it gets decrypted to the current
   cache position using the functions in fd1094.c */
static void fd1094_setstate_and_decrypt(INT32 state)
{
    INT32 i;
    UINT32 addr;

    // force a flush of the prefetch cache
    m68k_set_reg(M68K_REG_PREF_ADDR, 0x1000);

    /* set the FD1094 state ready to decrypt.. */
    state = fd1094_set_state(fd1094_key,state);

    /* first check the cache, if its cached we don't need to decrypt it, just copy */
    for (i=0; i<S16_NUMCACHE; i++)
    {
        if (fd1094_cached_states[i] == state)
        {
            /* copy cached state */
            fd1094_userregion=fd1094_cacheregion[i];
            SekOpen(nFD1094CPU);
            SekMapMemory((UINT8*)fd1094_userregion, 0x000000, 0x0fffff, SM_FETCH);
            if (System18Banking) SekMapMemory((UINT8*)fd1094_userregion + 0x200000, 0x200000, 0x27ffff, SM_FETCH);
            SekClose();

            return;
        }
    }

    /* mark it as cached (because it will be once we decrypt it) */
    fd1094_cached_states[fd1094_current_cacheposition]=state;

    for (addr=0; addr<fd1094_cpuregionsize/2; addr++)
    {
        UINT16 dat;
        dat = fd1094_decode(addr,fd1094_cpuregion[addr],fd1094_key,0);
        fd1094_cacheregion[fd1094_current_cacheposition][addr]=dat;
    }

    /* copy newly decrypted data to user region */
    fd1094_userregion=fd1094_cacheregion[fd1094_current_cacheposition];
    SekOpen(nFD1094CPU);
    SekMapMemory((UINT8*)fd1094_userregion, 0x000000, 0x0fffff, SM_FETCH);
    if (System18Banking) SekMapMemory((UINT8*)fd1094_userregion + 0x200000, 0x200000, 0x27ffff, SM_FETCH);
    SekClose();

    fd1094_current_cacheposition++;

    if (fd1094_current_cacheposition>=S16_NUMCACHE)
    {
#if 1 && defined FBA_DEBUG
        bprintf(PRINT_NORMAL, _T("out of cache, performance may suffer, increase S16_NUMCACHE!\n"));
#endif
        fd1094_current_cacheposition=0;
    }
}
Пример #9
0
PICO_INTERNAL void SekUnpackCpu(const unsigned char *cpu, int is_sub)
{
#if defined(EMU_C68K)
  struct Cyclone *context = is_sub ? &PicoCpuCS68k : &PicoCpuCM68k;
  CycloneSetSr(context, *(unsigned int *)(cpu+0x44));
  context->osp=*(unsigned int *)(cpu+0x48);
  memcpy(context->d,cpu,0x40);
  context->membase = 0;
  context->pc = *(unsigned int *)(cpu+0x40);
  CycloneUnpack(context, NULL); // rebase PC
  context->irq = cpu[0x4c];
  context->state_flags = 0;
  if (cpu[0x4d])
    context->state_flags |= 1;
#elif defined(EMU_M68K)
  void *oldcontext = m68ki_cpu_p;
  m68k_set_context(is_sub ? &PicoCpuMS68k : &PicoCpuMM68k);
  m68k_set_reg(M68K_REG_SR, *(unsigned int *)(cpu+0x44));
  memcpy(m68ki_cpu_p->dar,cpu,0x40);
  m68ki_cpu_p->pc=*(unsigned int *)(cpu+0x40);
  m68ki_cpu_p->sp[m68ki_cpu_p->s_flag^SFLAG_SET]=*(unsigned int *)(cpu+0x48);
  CPU_INT_LEVEL = cpu[0x4c] << 8;
  CPU_STOPPED = cpu[0x4d];
  m68k_set_context(oldcontext);
#elif defined(EMU_F68K)
  M68K_CONTEXT *context = is_sub ? &PicoCpuFS68k : &PicoCpuFM68k;
  memcpy(context->dreg,cpu,0x40);
  context->pc =*(unsigned int *)(cpu+0x40);
  context->sr =*(unsigned int *)(cpu+0x44);
  context->asp=*(unsigned int *)(cpu+0x48);
  context->interrupts[0] = cpu[0x4c];
  context->execinfo &= ~FM68K_HALTED;
  if (cpu[0x4d]&1) context->execinfo |= FM68K_HALTED;
#endif
  if (is_sub)
    SekCycleCntS68k = *(unsigned int *)(cpu+0x50);
  else
    SekCycleCnt = *(unsigned int *)(cpu+0x50);
}
Пример #10
0
int state_load(unsigned char *buffer)
{
  /* buffer size */
  int bufferptr = 0;

  /* uncompress savestate */
  unsigned long inbytes, outbytes;
  memcpy(&inbytes, buffer, 4);
  outbytes = STATE_SIZE;
  uncompress ((Bytef *)state, &outbytes, (Bytef *)(buffer + 4), inbytes);

  /* version check */
  char version[16];
  load_param(version,16);
  if (strncmp(version,STATE_VERSION,16))
  {
    return 0;
  }

  /* reset system */
  system_reset();
  m68k_memory_map[0].base = default_rom;

  // GENESIS
  load_param(work_ram, sizeof(work_ram));
  load_param(zram, sizeof(zram));
  load_param(&zbusreq, sizeof(zbusreq));
  load_param(&zreset, sizeof(zreset));
  load_param(&zbank, sizeof(zbank));
  zbusack = 1 ^(zbusreq & zreset);

  // IO
  load_param(io_reg, sizeof(io_reg));

  // VDP
  uint8 temp_reg[0x20];
  load_param(sat, sizeof(sat));
  load_param(vram, sizeof(vram));
  load_param(cram, sizeof(cram));
  load_param(vsram, sizeof(vsram));
  load_param(temp_reg, sizeof(temp_reg));
  load_param(&addr, sizeof(addr));
  load_param(&addr_latch, sizeof(addr_latch));
  load_param(&code, sizeof(code));
  load_param(&pending, sizeof(pending));
  load_param(&status, sizeof(status));
  load_param(&dmafill, sizeof(dmafill));
  load_param(&hint_pending, sizeof(hint_pending));
  load_param(&vint_pending, sizeof(vint_pending));
  load_param(&irq_status, sizeof(irq_status));
  vdp_restore(temp_reg);

  // FM 
  YM2612Restore(&state[bufferptr]);
  bufferptr+= YM2612GetContextSize();

  // PSG
  load_param(SN76489_GetContextPtr(),SN76489_GetContextSize());

  // 68000 
  uint16 tmp16;
  uint32 tmp32;
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D0, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D1, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D2, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D3, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D4, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D5, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D6, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D7, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A0, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A1, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A2, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A3, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A4, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A5, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A6, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A7, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_PC, tmp32);  
  load_param(&tmp16, 2); m68k_set_reg(M68K_REG_SR, tmp16);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_USP,tmp32);

  // Z80 
  load_param(&Z80, sizeof(Z80_Regs));

  return 1;
}
Пример #11
0
void m68000_set_reg(int regnum, unsigned val)
{
	switch( regnum )
	{
		case M68K_PC:  m68k_set_reg(M68K_REG_PC, val); break;
		case M68K_SP:  m68k_set_reg(M68K_REG_SP, val); break;
		case M68K_ISP: m68k_set_reg(M68K_REG_ISP, val); break;
		case M68K_USP: m68k_set_reg(M68K_REG_USP, val); break;
		case M68K_SR:  m68k_set_reg(M68K_REG_SR, val); break;
		case M68K_D0:  m68k_set_reg(M68K_REG_D0, val); break;
		case M68K_D1:  m68k_set_reg(M68K_REG_D1, val); break;
		case M68K_D2:  m68k_set_reg(M68K_REG_D2, val); break;
		case M68K_D3:  m68k_set_reg(M68K_REG_D3, val); break;
		case M68K_D4:  m68k_set_reg(M68K_REG_D4, val); break;
		case M68K_D5:  m68k_set_reg(M68K_REG_D5, val); break;
		case M68K_D6:  m68k_set_reg(M68K_REG_D6, val); break;
		case M68K_D7:  m68k_set_reg(M68K_REG_D7, val); break;
		case M68K_A0:  m68k_set_reg(M68K_REG_A0, val); break;
		case M68K_A1:  m68k_set_reg(M68K_REG_A1, val); break;
		case M68K_A2:  m68k_set_reg(M68K_REG_A2, val); break;
		case M68K_A3:  m68k_set_reg(M68K_REG_A3, val); break;
		case M68K_A4:  m68k_set_reg(M68K_REG_A4, val); break;
		case M68K_A5:  m68k_set_reg(M68K_REG_A5, val); break;
		case M68K_A6:  m68k_set_reg(M68K_REG_A6, val); break;
		case M68K_A7:  m68k_set_reg(M68K_REG_A7, val); break;
/* TODO: set contents of [SP + wordsize * (REG_SP_CONTENTS-regnum)] */
		default:
			if( regnum < REG_SP_CONTENTS )
			{
				unsigned offset = m68k_get_reg(NULL, M68K_REG_SP) + 4 * (REG_SP_CONTENTS - regnum);
				if( offset < 0xfffffd )
					m68k_write_memory_16( offset, val );
			}
	}
}
Пример #12
0
void m68000_set_sp(unsigned val)
{
	m68k_set_reg(M68K_REG_SP, val);
}
Пример #13
0
void m68000_set_pc(unsigned val)
{
	m68k_set_reg(M68K_REG_PC, val&0x00ffffff);
}
Пример #14
0
int main(int argc, char **argv)
{
    int binary_file;
    void *binary_data;
    struct stat sb;
    struct tos_environment te;
    int argb = 1;
    
    verbose = 0;
    
    /* Program usage */
    if (argc < 2)
    {
        printf("Usage: tosemu [-v] <binary> [<args>]\n\n\t<binary> name of binary to execute\n");
        return -1;
    }
    
    /* Check if we want to be verbose */
    if (argc >= 3 && strcmp("-v", argv[1]) == 0)
    {
        verbose = -1;
        argb++;
    }

    /* Open the provided file */
    binary_file = open(argv[argb], O_RDONLY);
    if (binary_file == -1)
    {
        printf("Error: failed to open '%s'\n", argv[argc-1]);
        return -1;
    }
    
    /* Determine the file size */
    fstat(binary_file, &sb);
    
    /* Mmap the file into memory */
    binary_data = mmap(NULL, sb.st_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, binary_file, 0);
    if (!binary_data)
    {
        printf("Error: failed to mmap '%s'\n", argv[argc-1]);
        close(binary_file);
        return -1;
    }
    
    /* Check that the binary starts with the magix 0x601a sequence */
    if( ((char*)binary_data)[0] != 0x60 || ((char*)binary_data)[1] != 0x1a)
    {
        printf("Error: invalid magic in '%s'\n", argv[argc-1]);
        close(binary_file);
        return -1;
    }
    
    argb++;
    argv += argb;
    argc -= argb;

    /* Setup a TOS environment for the binary */
    if (init_tos_environment(&te, binary_data, sb.st_size, argc, argv))
    {
        printf("Error: failed to initialize TOS environment\n");
        close(binary_file);
        return -1;
    }
    
    /* Close the binary file */
    close(binary_file);

    /* Start execution */

    /* TODO init cpu */
    m68k_init();
    m68k_set_cpu_type(M68K_CPU_TYPE_68000);
    m68k_pulse_reset();

    /* TODO is this really correct, or should it be the MSP? If so, why does that not work? */
    m68k_set_reg(M68K_REG_ISP, 0x600); /* supervisor stack pointer */
    m68k_set_reg(M68K_REG_USP, te.size-4); /* user stack pointer */
    m68k_write_memory_32(te.size, 0x800); /* big endian 0x800 */
    m68k_set_reg(M68K_REG_PC, 0x900); /* Set PC to the binary entry point */
    disable_supervisor_mode();
    
    /* TODO exec */
    while (keepongoing) {
        m68k_execute(1);
    }
  
    /* Clean up */
    free_tos_environment(&te);
    
    return 0; 
}
Пример #15
0
int state_load(unsigned char *buffer)
{
  /* buffer size */
  int bufferptr = 0;

  /* first allocate state buffer */
  unsigned char *state = (unsigned char *)malloc(STATE_SIZE);
  if (!state) return 0;

  /* uncompress savestate */
  unsigned long inbytes, outbytes;
  memcpy(&inbytes, buffer, 4);
  outbytes = STATE_SIZE;
  uncompress ((Bytef *)state, &outbytes, (Bytef *)(buffer + 4), inbytes);

  /* signature check (GENPLUS-GX x.x.x) */
  char version[17];
  load_param(version,16);
  version[16] = 0;
  if (strncmp(version,STATE_VERSION,11))
  {
    free(state);
    return -1;
  }

  /* version check (1.5.0 and above) */
  if ((version[11] < 0x31) || ((version[11] == 0x31) && (version[13] < 0x35)))
  {
    free(state);
    return -1;
  }

  /* reset system */
  system_reset();

  // GENESIS
  if ((system_hw & SYSTEM_PBC) == SYSTEM_MD)
  {
    load_param(work_ram, sizeof(work_ram));
    load_param(zram, sizeof(zram));
    load_param(&zstate, sizeof(zstate));
    load_param(&zbank, sizeof(zbank));
    if (zstate == 3)
    {
      m68k_memory_map[0xa0].read8   = z80_read_byte;
      m68k_memory_map[0xa0].read16  = z80_read_word;
      m68k_memory_map[0xa0].write8  = z80_write_byte;
      m68k_memory_map[0xa0].write16 = z80_write_word;
    }
    else
    {
      m68k_memory_map[0xa0].read8   = m68k_read_bus_8;
      m68k_memory_map[0xa0].read16  = m68k_read_bus_16;
      m68k_memory_map[0xa0].write8  = m68k_unused_8_w;
      m68k_memory_map[0xa0].write16 = m68k_unused_16_w;
    }
  }
  else
  {
    load_param(work_ram, 0x2000);
  }

  /* extended state */
  load_param(&mcycles_68k, sizeof(mcycles_68k));
  load_param(&mcycles_z80, sizeof(mcycles_z80));

  // IO
  if ((system_hw & SYSTEM_PBC) == SYSTEM_MD)
  {
    load_param(io_reg, sizeof(io_reg));
    io_reg[0] = region_code | 0x20 | (config.tmss & 1);
  }
  else
  {
    load_param(&io_reg[0x0F], 1);
  }

  // VDP
  bufferptr += vdp_context_load(&state[bufferptr], version);

  // SOUND 
  bufferptr += sound_context_load(&state[bufferptr], version);

  // 68000 
  if ((system_hw & SYSTEM_PBC) == SYSTEM_MD)
  {
    uint16 tmp16;
    uint32 tmp32;
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D0, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D1, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D2, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D3, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D4, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D5, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D6, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D7, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A0, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A1, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A2, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A3, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A4, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A5, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A6, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A7, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_PC, tmp32);  
    load_param(&tmp16, 2); m68k_set_reg(M68K_REG_SR, tmp16);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_USP,tmp32);
  }

  // Z80 
  load_param(&Z80, sizeof(Z80_Regs));
  Z80.irq_callback = z80_irq_callback;

  // Cartridge HW
  if ((system_hw & SYSTEM_PBC) == SYSTEM_MD)
  {  
    bufferptr += md_cart_context_load(&state[bufferptr]);
  }
  else
  {
    bufferptr += sms_cart_context_load(&state[bufferptr]);
  }

  free(state);
  return 1;
}
Пример #16
0
int state_load_old(unsigned char *state)
{
	int i, bufferptr = 0x10;

	/* reset system */
	system_reset();

	// GENESIS
	if (system_hw == SYSTEM_PBC || system_hw == SYSTEM_GAMEGEAR) {
		load_param(work_ram, 0x2000);
	} else {
		load_param(work_ram, sizeof(work_ram));
		load_param(zram, sizeof(zram));
		load_param(&zstate, sizeof(zstate));
		load_param(&zbank, sizeof(zbank));
		if (zstate == 3) {
			m68k_memory_map[0xa0].read8 = z80_read_byte;
			m68k_memory_map[0xa0].read16 = z80_read_word;
			m68k_memory_map[0xa0].write8 = z80_write_byte;
			m68k_memory_map[0xa0].write16 = z80_write_word;
		} else {
			m68k_memory_map[0xa0].read8 = m68k_read_bus_8;
			m68k_memory_map[0xa0].read16 = m68k_read_bus_16;
			m68k_memory_map[0xa0].write8 = m68k_unused_8_w;
			m68k_memory_map[0xa0].write16 = m68k_unused_16_w;
		}
	}

	// IO
	if (system_hw == SYSTEM_PBC || system_hw == SYSTEM_GAMEGEAR) {
		load_param(&io_reg[0xf], 1);
		bufferptr+=0x10-1;
	} else {
		load_param(io_reg, sizeof(io_reg));
		io_reg[0] = region_code | 0x20 | (config.tmss & 1);
	}

	  /* VDP */
	  bufferptr += vdp_context_load_old(&state[bufferptr]);

	  /* SOUND */
	  bufferptr += sound_context_load(&state[bufferptr]);

	  /* 68000 */
	  if (system_hw != SYSTEM_PBC && system_hw != SYSTEM_GAMEGEAR)
	  {
	    uint16 tmp16;
	    uint32 tmp32;
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D0, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D1, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D2, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D3, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D4, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D5, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D6, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D7, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A0, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A1, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A2, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A3, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A4, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A5, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A6, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A7, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_PC, tmp32);
	    load_param(&tmp16, 2); m68k_set_reg(M68K_REG_SR, tmp16);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_USP,tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_ISP,tmp32);

	  	load_param(&mcycles_68k, sizeof(mcycles_68k));
	  	load_param(&tmp32, 4);
	  	m68k_irq_state = tmp32 >> 8;
	    bufferptr += 4; // skip m68k.stopped
	  }
Пример #17
0
bool loadstate(const char *fn)
{
    uint32_t val;
    FILE *f = fopen(fn, "rb");
    if (!f) return false;

    fseek(f, 0x80, SEEK_SET);
    CPU_M68K.init();
    for (int i=0;i<16;i++)
    {
        fread(&val, 1, 4, f);
        m68k_set_reg((m68k_register_t)i, val);
    }

    fseek(f, 0xC8, SEEK_SET);
    fread(&val, 1, 4, f);
    m68k_set_reg(M68K_REG_PC, val);

    fseek(f, 0xD0, SEEK_SET);
    val = 0; fread(&val, 1, 2, f);
    //m68k_set_reg(M68K_REG_SR, val);
    m68ki_set_sr_noint_nosp(val);

    val = 0; fread(&val, 1, 4, f);
    m68k_set_reg(M68K_REG_USP, val);
    val = 0; fread(&val, 1, 4, f);
    m68k_set_reg(M68K_REG_ISP, val);

    assert(ftell(f) == 0xDA);
    fseek(f, 0xFA, SEEK_SET);

    VDP.reset();
    fread(VDP.regs, 1, 24, f);
    fread(VDP.CRAM, 1, 128, f);
    fread(VDP.VSRAM, 1, 80, f);
    assert(ftell(f) == 0x1E2);

    fseek(f, 0x1E4, SEEK_SET);

    uint8_t opnregs[512];
    fread(opnregs, 1, 512, f);
    YM2612LoadRegs(opnregs);

    assert(ftell(f) == 0x3E4);
    fseek(f, 0x404, SEEK_SET);

    CPU_Z80.reset();
    fread(&CPU_Z80._cpu.AF.W, 1, 4, f);
    fread(&CPU_Z80._cpu.BC.W, 1, 4, f);
    fread(&CPU_Z80._cpu.DE.W, 1, 4, f);
    fread(&CPU_Z80._cpu.HL.W, 1, 4, f);
    fread(&CPU_Z80._cpu.IX.W, 1, 4, f);
    fread(&CPU_Z80._cpu.IY.W, 1, 4, f);
    fread(&CPU_Z80._cpu.PC.W, 1, 4, f);
    fread(&CPU_Z80._cpu.SP.W, 1, 4, f);
    fread(&CPU_Z80._cpu.AF1.W, 1, 4, f);
    fread(&CPU_Z80._cpu.BC1.W, 1, 4, f);
    fread(&CPU_Z80._cpu.DE1.W, 1, 4, f);
    fread(&CPU_Z80._cpu.HL1.W, 1, 4, f);
    fread(&CPU_Z80._cpu.I, 1, 1, f);
    fseek(f, 1, SEEK_CUR);
    fread(&CPU_Z80._cpu.IFF, 1, 1, f);
    fseek(f, 1, SEEK_CUR);

    fread(&CPU_Z80._reset_line, 1, 1, f);
    fread(&CPU_Z80._busreq_line, 1, 1, f);
    fseek(f, 2, SEEK_CUR);
    fread(&Z80_BANK, 1, 4, f);
    CPU_Z80._reset_once = true;

    assert(ftell(f) == 0x440);
    fseek(f, 0x474, SEEK_SET);

    fread(ZRAM, 1, sizeof(ZRAM), f);
    fseek(f, 4, SEEK_CUR);
    fread(RAM, 1, sizeof(RAM), f);
    fread(VDP.VRAM, 1, sizeof(VDP.VRAM), f);
    assert(ftell(f) == 0x22478);
    fclose(f);

    return true;
}
Пример #18
0
void m68020_set_pc(unsigned val)
{
	m68k_set_reg(M68K_REG_PC, val);
}