Example #1
0
void sms_mapper8k_w(INT32 address, UINT8 data) // WIP
{
    /* Calculate ROM page index */
    UINT32 poffset = (data % (cart.pages * 2)) << 13;

    /* Save frame control register data */
    cart.fcr[address] = data;

    /* 4 x 8k banks */
    switch (address & 3)
    {
    case 0: /* cartridge ROM bank (8k) at $8000-$9FFF */
        ZetMapMemory(cart.rom + poffset, 0x8000, 0x9fff, MAP_ROM);
        break;

    case 1: /* cartridge ROM bank (8k) at $A000-$BFFF */
        ZetMapMemory(cart.rom + poffset, 0xa000, 0xbfff, MAP_ROM);
        break;

    case 2: /* cartridge ROM bank (8k) at $4000-$5FFF */
        ZetMapMemory(cart.rom + poffset, 0x4000, 0x5fff, MAP_ROM);
        break;

    case 3: /* cartridge ROM bank (8k) at $6000-$7FFF */
        ZetMapMemory(cart.rom + poffset, 0x6000, 0x7fff, MAP_ROM);
        break;
    }
}
Example #2
0
static void bankswitch(INT32 data)
{
	*z80_bank = data;

	INT32 nBank = (data & 0x80) ? 0x14000 : 0x10000;

	ZetMapMemory(DrvZ80ROM + nBank, 0x8000, 0xbfff, MAP_ROM);
}
Example #3
0
void sms_mapper_w(INT32 address, UINT8 data)
{
    /* Calculate ROM page index */
    UINT32 poffset = (data % cart.pages) << 14;

    /* Save frame control register data */
    cart.fcr[address] = data;

    switch(address)
    {
    case 0: // page 2
        if(data & 8)
        {
            uint32 offset = (data & 4) ? 0x4000 : 0x0000;
            sms.save = 1;
            ZetMapMemory((UINT8 *)&cart.sram + offset, 0x8000, 0xbfff, MAP_RAM);
        }
        else
        {
            poffset = ((cart.fcr[3] % cart.pages) << 14);
            ZetMapMemory(cart.rom + poffset, 0x8000, 0xbfff, MAP_ROM);
            if (cart.mapper == MAPPER_SEGA)
                ZetMapMemory((UINT8 *)&dummy_write, 0x8000, 0xbfff, MAP_WRITE);
        }
        break;

    case 1: // page 0
        ZetMapMemory(cart.rom + poffset, 0x0000, 0x3fff, MAP_ROM);
        break;

    case 2: // page 1
        ZetMapMemory(cart.rom + poffset, 0x4000, 0x7fff, MAP_ROM);
        break;

    case 3: // page 2
        if(!(cart.fcr[0] & 0x08))
        {
            ZetMapMemory(cart.rom + poffset, 0x8000, 0xbfff, MAP_ROM);
        }
        break;
    }
}
Example #4
0
static INT32 DrvInit()
{
	BurnSetRefreshRate(60.00);

	AllMem = NULL;
	MemIndex();
	INT32 nLen = MemEnd - (UINT8 *)0;
	if ((AllMem = (UINT8 *)BurnMalloc(nLen)) == NULL) return 1;
	memset(AllMem, 0, nLen);
	MemIndex();

	{
		if (BurnLoadRom(DrvZ80ROM  + 0x00000,  0, 1)) return 1;
		if (BurnLoadRom(DrvZ80ROM  + 0x10000,  1, 1)) return 1;

		if (BurnLoadRom(t5182ROM   + 0x00000,  2, 1)) return 1;
		if (BurnLoadRom(t5182ROM   + 0x08000,  3, 1)) return 1;

		if (BurnLoadRom(DrvGfxROM0 + 0x00000,  4, 1)) return 1;
		if (BurnLoadRom(DrvGfxROM0 + 0x02000,  5, 1)) return 1;

		if (BurnLoadRom(DrvGfxROM1 + 0x10000,  6, 1)) return 1;
		if (BurnLoadRom(DrvGfxROM1 + 0x00000,  7, 1)) return 1;
		if (BurnLoadRom(DrvGfxROM1 + 0x30000,  8, 1)) return 1;
		if (BurnLoadRom(DrvGfxROM1 + 0x20000,  9, 1)) return 1;

		if (BurnLoadRom(DrvGfxROM2 + 0x00000, 10, 1)) return 1;
		if (BurnLoadRom(DrvGfxROM2 + 0x10000, 11, 1)) return 1;
		if (BurnLoadRom(DrvGfxROM2 + 0x20000, 12, 1)) return 1;
		if (BurnLoadRom(DrvGfxROM2 + 0x30000, 13, 1)) return 1;

		if (BurnLoadRom(DrvGfxROM3 + 0x00000, 14, 1)) return 1;
		if (BurnLoadRom(DrvGfxROM3 + 0x08000, 15, 1)) return 1;

		if (BurnLoadRom(DrvGfxROM4 + 0x00000, 16, 1)) return 1;
		if (BurnLoadRom(DrvGfxROM4 + 0x04000, 17, 1)) return 1;

		if (BurnLoadRom(DrvColPROM + 0x00000, 18, 1)) return 1;
		if (BurnLoadRom(DrvColPROM + 0x00100, 19, 1)) return 1;
		if (BurnLoadRom(DrvColPROM + 0x00200, 20, 1)) return 1;
		if (BurnLoadRom(DrvColPROM + 0x00300, 21, 1)) return 1;

		decrypt_prg();
		decrypt_gfx();
		decrypt_snd();

		DrvGfxDecode();
		DrvPaletteInit();
	}

	ZetInit(0);
	ZetOpen(0);
	ZetMapMemory(DrvZ80ROM,		0x0000, 0x7fff, MAP_ROM);
	ZetMapMemory(DrvZ80ROMDec,	0x0000, 0x7fff, MAP_FETCHOP);
	ZetMapMemory(DrvPalRAM,		0xd000, 0xd3ff, MAP_ROM);
	ZetMapMemory(DrvScrollRAM,	0xd400, 0xd4ff, MAP_RAM);
	ZetMapMemory(DrvVidRAM,		0xd800, 0xdfff, MAP_RAM);
	ZetMapMemory(DrvZ80RAM,		0xe000, 0xefff, MAP_RAM);
	ZetMapMemory(DrvSprRAM,		0xf000, 0xffff, MAP_RAM);
	ZetSetWriteHandler(darkmist_main_write);
	ZetSetReadHandler(darkmist_main_read);
	ZetClose();

	t5182Init(1, 14318180/4);

	GenericTilesInit();

	DrvDoReset();

	return 0;
}
Example #5
0
void sms_reset(void)
{
    ZetOpen(0);

    /* Clear SMS context */
    memset(&dummy_write, 0, sizeof(dummy_write));
    memset(&sms.wram,    0, sizeof(sms.wram));
    memset(cart.sram,   0, sizeof(cart.sram));

    sms.paused      = 0x00;
    sms.save        = 0x00;
    sms.fm_detect   = 0x00;
    sms.memctrl     = 0xAB;
    sms.ioctrl      = 0xFF;

    ZetMapMemory(cart.rom + 0x0000, 0x0000, 0x03ff, MAP_ROM);
    ZetMapMemory(cart.rom + 0x0400, 0x0400, 0x3fff, MAP_ROM);
    ZetMapMemory(cart.rom + 0x4000, 0x4000, 0x7fff, MAP_ROM);
    ZetMapMemory(cart.rom + 0x8000, 0x8000, 0xbfff, MAP_ROM);

    if(cart.mapper == MAPPER_CODIES) {
        ZetMapMemory((UINT8 *)&sms.wram + 0x0000, 0xc000, 0xdfff, MAP_RAM);
        ZetMapMemory((UINT8 *)&sms.wram + 0x0000, 0xe000, 0xffff, MAP_RAM);
    } else if(cart.mapper == MAPPER_SEGA) {
        ZetMapMemory((UINT8 *)&sms.wram + 0x0000, 0xc000, 0xdfff, MAP_RAM);
        ZetMapMemory((UINT8 *)&dummy_write, 0x0000, 0xbfff, MAP_WRITE);
        ZetMapMemory((UINT8 *)&sms.wram + 0x0000, 0xe000, 0xffff, MAP_READ);
    } else
    {   // MSX Mapper
        ZetMapMemory((UINT8 *)&sms.wram + 0x0000, 0xc000, 0xdfff, MAP_RAM);
        ZetMapMemory((UINT8 *)&sms.wram + 0x0000, 0xe000, 0xffff, MAP_RAM);
    }
    ZetReset();
    ZetClose();

    cart.fcr[0] = 0x00;
    cart.fcr[1] = 0x00;
    cart.fcr[2] = 0x01;
    cart.fcr[3] = 0x00;

    switch (cart.mapper)
    {
    case MAPPER_MSX_NEMESIS: { // WIP!! / won't boot
//			bprintf(0, _T("(nemesis)\n"));
        cart.fcr[2] = 0x00;
        UINT32 poffset = (0x0f) << 13;
        ZetOpen(0);
        ZetMapMemory(cart.rom + poffset, 0x0000, 0x1fff, MAP_READ);
        ZetClose();
    }

    }
}