mirror of
https://github.com/kanjitalk755/macemu.git
synced 2024-06-01 22:41:29 +00:00
643 lines
16 KiB
C++
643 lines
16 KiB
C++
/*
|
|
* UAE - The Un*x Amiga Emulator
|
|
*
|
|
* Memory management
|
|
*
|
|
* (c) 1995 Bernd Schmidt
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "sysdeps.h"
|
|
|
|
#include "cpu_emulation.h"
|
|
#include "main.h"
|
|
#include "video.h"
|
|
|
|
#include "m68k.h"
|
|
#include "memory.h"
|
|
#include "readcpu.h"
|
|
#include "newcpu.h"
|
|
|
|
#if !REAL_ADDRESSING && !DIRECT_ADDRESSING
|
|
|
|
static bool illegal_mem = false;
|
|
|
|
#ifdef SAVE_MEMORY_BANKS
|
|
addrbank *mem_banks[65536];
|
|
#else
|
|
addrbank mem_banks[65536];
|
|
#endif
|
|
|
|
#ifdef WORDS_BIGENDIAN
|
|
# define swap_words(X) (X)
|
|
#else
|
|
# define swap_words(X) (((X) >> 16) | ((X) << 16))
|
|
#endif
|
|
|
|
#ifdef NO_INLINE_MEMORY_ACCESS
|
|
uae_u32 longget (uaecptr addr)
|
|
{
|
|
return call_mem_get_func (get_mem_bank (addr).lget, addr);
|
|
}
|
|
uae_u32 wordget (uaecptr addr)
|
|
{
|
|
return call_mem_get_func (get_mem_bank (addr).wget, addr);
|
|
}
|
|
uae_u32 byteget (uaecptr addr)
|
|
{
|
|
return call_mem_get_func (get_mem_bank (addr).bget, addr);
|
|
}
|
|
void longput (uaecptr addr, uae_u32 l)
|
|
{
|
|
call_mem_put_func (get_mem_bank (addr).lput, addr, l);
|
|
}
|
|
void wordput (uaecptr addr, uae_u32 w)
|
|
{
|
|
call_mem_put_func (get_mem_bank (addr).wput, addr, w);
|
|
}
|
|
void byteput (uaecptr addr, uae_u32 b)
|
|
{
|
|
call_mem_put_func (get_mem_bank (addr).bput, addr, b);
|
|
}
|
|
#endif
|
|
|
|
/* A dummy bank that only contains zeros */
|
|
|
|
static uae_u32 REGPARAM2 dummy_lget (uaecptr) REGPARAM;
|
|
static uae_u32 REGPARAM2 dummy_wget (uaecptr) REGPARAM;
|
|
static uae_u32 REGPARAM2 dummy_bget (uaecptr) REGPARAM;
|
|
static void REGPARAM2 dummy_lput (uaecptr, uae_u32) REGPARAM;
|
|
static void REGPARAM2 dummy_wput (uaecptr, uae_u32) REGPARAM;
|
|
static void REGPARAM2 dummy_bput (uaecptr, uae_u32) REGPARAM;
|
|
|
|
uae_u32 REGPARAM2 dummy_lget (uaecptr addr)
|
|
{
|
|
if (illegal_mem)
|
|
write_log ("Illegal lget at %08x\n", addr);
|
|
|
|
return 0;
|
|
}
|
|
|
|
uae_u32 REGPARAM2 dummy_wget (uaecptr addr)
|
|
{
|
|
if (illegal_mem)
|
|
write_log ("Illegal wget at %08x\n", addr);
|
|
|
|
return 0;
|
|
}
|
|
|
|
uae_u32 REGPARAM2 dummy_bget (uaecptr addr)
|
|
{
|
|
if (illegal_mem)
|
|
write_log ("Illegal bget at %08x\n", addr);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void REGPARAM2 dummy_lput (uaecptr addr, uae_u32 l)
|
|
{
|
|
if (illegal_mem)
|
|
write_log ("Illegal lput at %08x\n", addr);
|
|
}
|
|
void REGPARAM2 dummy_wput (uaecptr addr, uae_u32 w)
|
|
{
|
|
if (illegal_mem)
|
|
write_log ("Illegal wput at %08x\n", addr);
|
|
}
|
|
void REGPARAM2 dummy_bput (uaecptr addr, uae_u32 b)
|
|
{
|
|
if (illegal_mem)
|
|
write_log ("Illegal bput at %08x\n", addr);
|
|
}
|
|
|
|
/* Mac RAM (32 bit addressing) */
|
|
|
|
static uae_u32 REGPARAM2 ram_lget(uaecptr) REGPARAM;
|
|
static uae_u32 REGPARAM2 ram_wget(uaecptr) REGPARAM;
|
|
static uae_u32 REGPARAM2 ram_bget(uaecptr) REGPARAM;
|
|
static void REGPARAM2 ram_lput(uaecptr, uae_u32) REGPARAM;
|
|
static void REGPARAM2 ram_wput(uaecptr, uae_u32) REGPARAM;
|
|
static void REGPARAM2 ram_bput(uaecptr, uae_u32) REGPARAM;
|
|
static uae_u8 *REGPARAM2 ram_xlate(uaecptr addr) REGPARAM;
|
|
|
|
static uintptr RAMBaseDiff; // RAMBaseHost - RAMBaseMac
|
|
|
|
uae_u32 REGPARAM2 ram_lget(uaecptr addr)
|
|
{
|
|
uae_u32 *m;
|
|
m = (uae_u32 *)(RAMBaseDiff + addr);
|
|
return do_get_mem_long(m);
|
|
}
|
|
|
|
uae_u32 REGPARAM2 ram_wget(uaecptr addr)
|
|
{
|
|
uae_u16 *m;
|
|
m = (uae_u16 *)(RAMBaseDiff + addr);
|
|
return do_get_mem_word(m);
|
|
}
|
|
|
|
uae_u32 REGPARAM2 ram_bget(uaecptr addr)
|
|
{
|
|
return (uae_u32)*(uae_u8 *)(RAMBaseDiff + addr);
|
|
}
|
|
|
|
void REGPARAM2 ram_lput(uaecptr addr, uae_u32 l)
|
|
{
|
|
uae_u32 *m;
|
|
m = (uae_u32 *)(RAMBaseDiff + addr);
|
|
do_put_mem_long(m, l);
|
|
}
|
|
|
|
void REGPARAM2 ram_wput(uaecptr addr, uae_u32 w)
|
|
{
|
|
uae_u16 *m;
|
|
m = (uae_u16 *)(RAMBaseDiff + addr);
|
|
do_put_mem_word(m, w);
|
|
}
|
|
|
|
void REGPARAM2 ram_bput(uaecptr addr, uae_u32 b)
|
|
{
|
|
*(uae_u8 *)(RAMBaseDiff + addr) = b;
|
|
}
|
|
|
|
uae_u8 *REGPARAM2 ram_xlate(uaecptr addr)
|
|
{
|
|
return (uae_u8 *)(RAMBaseDiff + addr);
|
|
}
|
|
|
|
/* Mac RAM (24 bit addressing) */
|
|
|
|
static uae_u32 REGPARAM2 ram24_lget(uaecptr) REGPARAM;
|
|
static uae_u32 REGPARAM2 ram24_wget(uaecptr) REGPARAM;
|
|
static uae_u32 REGPARAM2 ram24_bget(uaecptr) REGPARAM;
|
|
static void REGPARAM2 ram24_lput(uaecptr, uae_u32) REGPARAM;
|
|
static void REGPARAM2 ram24_wput(uaecptr, uae_u32) REGPARAM;
|
|
static void REGPARAM2 ram24_bput(uaecptr, uae_u32) REGPARAM;
|
|
static uae_u8 *REGPARAM2 ram24_xlate(uaecptr addr) REGPARAM;
|
|
|
|
uae_u32 REGPARAM2 ram24_lget(uaecptr addr)
|
|
{
|
|
uae_u32 *m;
|
|
m = (uae_u32 *)(RAMBaseDiff + (addr & 0xffffff));
|
|
return do_get_mem_long(m);
|
|
}
|
|
|
|
uae_u32 REGPARAM2 ram24_wget(uaecptr addr)
|
|
{
|
|
uae_u16 *m;
|
|
m = (uae_u16 *)(RAMBaseDiff + (addr & 0xffffff));
|
|
return do_get_mem_word(m);
|
|
}
|
|
|
|
uae_u32 REGPARAM2 ram24_bget(uaecptr addr)
|
|
{
|
|
return (uae_u32)*(uae_u8 *)(RAMBaseDiff + (addr & 0xffffff));
|
|
}
|
|
|
|
void REGPARAM2 ram24_lput(uaecptr addr, uae_u32 l)
|
|
{
|
|
uae_u32 *m;
|
|
m = (uae_u32 *)(RAMBaseDiff + (addr & 0xffffff));
|
|
do_put_mem_long(m, l);
|
|
}
|
|
|
|
void REGPARAM2 ram24_wput(uaecptr addr, uae_u32 w)
|
|
{
|
|
uae_u16 *m;
|
|
m = (uae_u16 *)(RAMBaseDiff + (addr & 0xffffff));
|
|
do_put_mem_word(m, w);
|
|
}
|
|
|
|
void REGPARAM2 ram24_bput(uaecptr addr, uae_u32 b)
|
|
{
|
|
*(uae_u8 *)(RAMBaseDiff + (addr & 0xffffff)) = b;
|
|
}
|
|
|
|
uae_u8 *REGPARAM2 ram24_xlate(uaecptr addr)
|
|
{
|
|
return (uae_u8 *)(RAMBaseDiff + (addr & 0xffffff));
|
|
}
|
|
|
|
/* Mac ROM (32 bit addressing) */
|
|
|
|
static uae_u32 REGPARAM2 rom_lget(uaecptr) REGPARAM;
|
|
static uae_u32 REGPARAM2 rom_wget(uaecptr) REGPARAM;
|
|
static uae_u32 REGPARAM2 rom_bget(uaecptr) REGPARAM;
|
|
static void REGPARAM2 rom_lput(uaecptr, uae_u32) REGPARAM;
|
|
static void REGPARAM2 rom_wput(uaecptr, uae_u32) REGPARAM;
|
|
static void REGPARAM2 rom_bput(uaecptr, uae_u32) REGPARAM;
|
|
static uae_u8 *REGPARAM2 rom_xlate(uaecptr addr) REGPARAM;
|
|
|
|
static uintptr ROMBaseDiff; // ROMBaseHost - ROMBaseMac
|
|
|
|
uae_u32 REGPARAM2 rom_lget(uaecptr addr)
|
|
{
|
|
uae_u32 *m;
|
|
m = (uae_u32 *)(ROMBaseDiff + addr);
|
|
return do_get_mem_long(m);
|
|
}
|
|
|
|
uae_u32 REGPARAM2 rom_wget(uaecptr addr)
|
|
{
|
|
uae_u16 *m;
|
|
m = (uae_u16 *)(ROMBaseDiff + addr);
|
|
return do_get_mem_word(m);
|
|
}
|
|
|
|
uae_u32 REGPARAM2 rom_bget(uaecptr addr)
|
|
{
|
|
return (uae_u32)*(uae_u8 *)(ROMBaseDiff + addr);
|
|
}
|
|
|
|
void REGPARAM2 rom_lput(uaecptr addr, uae_u32 b)
|
|
{
|
|
if (illegal_mem)
|
|
write_log ("Illegal ROM lput at %08x\n", addr);
|
|
}
|
|
|
|
void REGPARAM2 rom_wput(uaecptr addr, uae_u32 b)
|
|
{
|
|
if (illegal_mem)
|
|
write_log ("Illegal ROM wput at %08x\n", addr);
|
|
}
|
|
|
|
void REGPARAM2 rom_bput(uaecptr addr, uae_u32 b)
|
|
{
|
|
if (illegal_mem)
|
|
write_log ("Illegal ROM bput at %08x\n", addr);
|
|
}
|
|
|
|
uae_u8 *REGPARAM2 rom_xlate(uaecptr addr)
|
|
{
|
|
return (uae_u8 *)(ROMBaseDiff + addr);
|
|
}
|
|
|
|
/* Mac ROM (24 bit addressing) */
|
|
|
|
static uae_u32 REGPARAM2 rom24_lget(uaecptr) REGPARAM;
|
|
static uae_u32 REGPARAM2 rom24_wget(uaecptr) REGPARAM;
|
|
static uae_u32 REGPARAM2 rom24_bget(uaecptr) REGPARAM;
|
|
static uae_u8 *REGPARAM2 rom24_xlate(uaecptr addr) REGPARAM;
|
|
|
|
uae_u32 REGPARAM2 rom24_lget(uaecptr addr)
|
|
{
|
|
uae_u32 *m;
|
|
m = (uae_u32 *)(ROMBaseDiff + (addr & 0xffffff));
|
|
return do_get_mem_long(m);
|
|
}
|
|
|
|
uae_u32 REGPARAM2 rom24_wget(uaecptr addr)
|
|
{
|
|
uae_u16 *m;
|
|
m = (uae_u16 *)(ROMBaseDiff + (addr & 0xffffff));
|
|
return do_get_mem_word(m);
|
|
}
|
|
|
|
uae_u32 REGPARAM2 rom24_bget(uaecptr addr)
|
|
{
|
|
return (uae_u32)*(uae_u8 *)(ROMBaseDiff + (addr & 0xffffff));
|
|
}
|
|
|
|
uae_u8 *REGPARAM2 rom24_xlate(uaecptr addr)
|
|
{
|
|
return (uae_u8 *)(ROMBaseDiff + (addr & 0xffffff));
|
|
}
|
|
|
|
/* Frame buffer */
|
|
|
|
static uae_u32 REGPARAM2 frame_direct_lget(uaecptr) REGPARAM;
|
|
static uae_u32 REGPARAM2 frame_direct_wget(uaecptr) REGPARAM;
|
|
static uae_u32 REGPARAM2 frame_direct_bget(uaecptr) REGPARAM;
|
|
static void REGPARAM2 frame_direct_lput(uaecptr, uae_u32) REGPARAM;
|
|
static void REGPARAM2 frame_direct_wput(uaecptr, uae_u32) REGPARAM;
|
|
static void REGPARAM2 frame_direct_bput(uaecptr, uae_u32) REGPARAM;
|
|
|
|
static uae_u32 REGPARAM2 frame_host_555_lget(uaecptr) REGPARAM;
|
|
static uae_u32 REGPARAM2 frame_host_555_wget(uaecptr) REGPARAM;
|
|
static void REGPARAM2 frame_host_555_lput(uaecptr, uae_u32) REGPARAM;
|
|
static void REGPARAM2 frame_host_555_wput(uaecptr, uae_u32) REGPARAM;
|
|
|
|
static uae_u32 REGPARAM2 frame_host_565_lget(uaecptr) REGPARAM;
|
|
static uae_u32 REGPARAM2 frame_host_565_wget(uaecptr) REGPARAM;
|
|
static void REGPARAM2 frame_host_565_lput(uaecptr, uae_u32) REGPARAM;
|
|
static void REGPARAM2 frame_host_565_wput(uaecptr, uae_u32) REGPARAM;
|
|
|
|
static uae_u32 REGPARAM2 frame_host_888_lget(uaecptr) REGPARAM;
|
|
static void REGPARAM2 frame_host_888_lput(uaecptr, uae_u32) REGPARAM;
|
|
|
|
static uae_u8 *REGPARAM2 frame_xlate(uaecptr addr) REGPARAM;
|
|
|
|
static uintptr FrameBaseDiff; // MacFrameBaseHost - MacFrameBaseMac
|
|
|
|
uae_u32 REGPARAM2 frame_direct_lget(uaecptr addr)
|
|
{
|
|
uae_u32 *m;
|
|
m = (uae_u32 *)(FrameBaseDiff + addr);
|
|
return do_get_mem_long(m);
|
|
}
|
|
|
|
uae_u32 REGPARAM2 frame_direct_wget(uaecptr addr)
|
|
{
|
|
uae_u16 *m;
|
|
m = (uae_u16 *)(FrameBaseDiff + addr);
|
|
return do_get_mem_word(m);
|
|
}
|
|
|
|
uae_u32 REGPARAM2 frame_direct_bget(uaecptr addr)
|
|
{
|
|
return (uae_u32)*(uae_u8 *)(FrameBaseDiff + addr);
|
|
}
|
|
|
|
void REGPARAM2 frame_direct_lput(uaecptr addr, uae_u32 l)
|
|
{
|
|
uae_u32 *m;
|
|
m = (uae_u32 *)(FrameBaseDiff + addr);
|
|
do_put_mem_long(m, l);
|
|
}
|
|
|
|
void REGPARAM2 frame_direct_wput(uaecptr addr, uae_u32 w)
|
|
{
|
|
uae_u16 *m;
|
|
m = (uae_u16 *)(FrameBaseDiff + addr);
|
|
do_put_mem_word(m, w);
|
|
}
|
|
|
|
void REGPARAM2 frame_direct_bput(uaecptr addr, uae_u32 b)
|
|
{
|
|
*(uae_u8 *)(FrameBaseDiff + addr) = b;
|
|
}
|
|
|
|
uae_u32 REGPARAM2 frame_host_555_lget(uaecptr addr)
|
|
{
|
|
uae_u32 *m, l;
|
|
m = (uae_u32 *)(FrameBaseDiff + addr);
|
|
l = *m;
|
|
return swap_words(l);
|
|
}
|
|
|
|
uae_u32 REGPARAM2 frame_host_555_wget(uaecptr addr)
|
|
{
|
|
uae_u16 *m;
|
|
m = (uae_u16 *)(FrameBaseDiff + addr);
|
|
return *m;
|
|
}
|
|
|
|
void REGPARAM2 frame_host_555_lput(uaecptr addr, uae_u32 l)
|
|
{
|
|
uae_u32 *m;
|
|
m = (uae_u32 *)(FrameBaseDiff + addr);
|
|
*m = swap_words(l);
|
|
}
|
|
|
|
void REGPARAM2 frame_host_555_wput(uaecptr addr, uae_u32 w)
|
|
{
|
|
uae_u16 *m;
|
|
m = (uae_u16 *)(FrameBaseDiff + addr);
|
|
*m = w;
|
|
}
|
|
|
|
uae_u32 REGPARAM2 frame_host_565_lget(uaecptr addr)
|
|
{
|
|
uae_u32 *m, l;
|
|
m = (uae_u32 *)(FrameBaseDiff + addr);
|
|
l = *m;
|
|
l = (l & 0x001f001f) | ((l >> 1) & 0x7fe07fe0);
|
|
return swap_words(l);
|
|
}
|
|
|
|
uae_u32 REGPARAM2 frame_host_565_wget(uaecptr addr)
|
|
{
|
|
uae_u16 *m, w;
|
|
m = (uae_u16 *)(FrameBaseDiff + addr);
|
|
w = *m;
|
|
return (w & 0x1f) | ((w >> 1) & 0x7fe0);
|
|
}
|
|
|
|
void REGPARAM2 frame_host_565_lput(uaecptr addr, uae_u32 l)
|
|
{
|
|
uae_u32 *m;
|
|
m = (uae_u32 *)(FrameBaseDiff + addr);
|
|
l = (l & 0x001f001f) | ((l << 1) & 0xffc0ffc0);
|
|
*m = swap_words(l);
|
|
}
|
|
|
|
void REGPARAM2 frame_host_565_wput(uaecptr addr, uae_u32 w)
|
|
{
|
|
uae_u16 *m;
|
|
m = (uae_u16 *)(FrameBaseDiff + addr);
|
|
*m = (w & 0x1f) | ((w << 1) & 0xffc0);
|
|
}
|
|
|
|
uae_u32 REGPARAM2 frame_host_888_lget(uaecptr addr)
|
|
{
|
|
uae_u32 *m, l;
|
|
m = (uae_u32 *)(FrameBaseDiff + addr);
|
|
return *m;
|
|
}
|
|
|
|
void REGPARAM2 frame_host_888_lput(uaecptr addr, uae_u32 l)
|
|
{
|
|
uae_u32 *m;
|
|
m = (uae_u32 *)(MacFrameBaseHost + addr - MacFrameBaseMac);
|
|
*m = l;
|
|
}
|
|
|
|
uae_u8 *REGPARAM2 frame_xlate(uaecptr addr)
|
|
{
|
|
return (uae_u8 *)(FrameBaseDiff + addr);
|
|
}
|
|
|
|
/* Mac framebuffer RAM (24 bit addressing)
|
|
*
|
|
* This works by duplicating appropriate writes to the 32-bit
|
|
* address-space framebuffer.
|
|
*/
|
|
|
|
static void REGPARAM2 fram24_lput(uaecptr, uae_u32) REGPARAM;
|
|
static void REGPARAM2 fram24_wput(uaecptr, uae_u32) REGPARAM;
|
|
static void REGPARAM2 fram24_bput(uaecptr, uae_u32) REGPARAM;
|
|
|
|
void REGPARAM2 fram24_lput(uaecptr addr, uae_u32 l)
|
|
{
|
|
uaecptr page_off = addr & 0xffff;
|
|
if (0xa700 <= page_off && page_off < 0xfc80) {
|
|
uae_u32 *fm;
|
|
fm = (uae_u32 *)(MacFrameBaseHost + page_off - 0xa700);
|
|
do_put_mem_long(fm, l);
|
|
}
|
|
|
|
uae_u32 *m;
|
|
m = (uae_u32 *)(RAMBaseDiff + (addr & 0xffffff));
|
|
do_put_mem_long(m, l);
|
|
}
|
|
|
|
void REGPARAM2 fram24_wput(uaecptr addr, uae_u32 w)
|
|
{
|
|
uaecptr page_off = addr & 0xffff;
|
|
if (0xa700 <= page_off && page_off < 0xfc80) {
|
|
uae_u16 *fm;
|
|
fm = (uae_u16 *)(MacFrameBaseHost + page_off - 0xa700);
|
|
do_put_mem_word(fm, w);
|
|
}
|
|
|
|
uae_u16 *m;
|
|
m = (uae_u16 *)(RAMBaseDiff + (addr & 0xffffff));
|
|
do_put_mem_word(m, w);
|
|
}
|
|
|
|
void REGPARAM2 fram24_bput(uaecptr addr, uae_u32 b)
|
|
{
|
|
uaecptr page_off = addr & 0xffff;
|
|
if (0xa700 <= page_off && page_off < 0xfc80) {
|
|
*(uae_u8 *)(MacFrameBaseHost + page_off - 0xa700) = b;
|
|
}
|
|
|
|
*(uae_u8 *)(RAMBaseDiff + (addr & 0xffffff)) = b;
|
|
}
|
|
|
|
/* Default memory access functions */
|
|
|
|
uae_u8 *REGPARAM2 default_xlate (uaecptr a)
|
|
{
|
|
write_log("Your Mac program just did something terribly stupid\n");
|
|
return NULL;
|
|
}
|
|
|
|
/* Address banks */
|
|
|
|
addrbank dummy_bank = {
|
|
dummy_lget, dummy_wget, dummy_bget,
|
|
dummy_lput, dummy_wput, dummy_bput,
|
|
default_xlate
|
|
};
|
|
|
|
addrbank ram_bank = {
|
|
ram_lget, ram_wget, ram_bget,
|
|
ram_lput, ram_wput, ram_bput,
|
|
ram_xlate
|
|
};
|
|
|
|
addrbank ram24_bank = {
|
|
ram24_lget, ram24_wget, ram24_bget,
|
|
ram24_lput, ram24_wput, ram24_bput,
|
|
ram24_xlate
|
|
};
|
|
|
|
addrbank rom_bank = {
|
|
rom_lget, rom_wget, rom_bget,
|
|
rom_lput, rom_wput, rom_bput,
|
|
rom_xlate
|
|
};
|
|
|
|
addrbank rom24_bank = {
|
|
rom24_lget, rom24_wget, rom24_bget,
|
|
rom_lput, rom_wput, rom_bput,
|
|
rom24_xlate
|
|
};
|
|
|
|
addrbank frame_direct_bank = {
|
|
frame_direct_lget, frame_direct_wget, frame_direct_bget,
|
|
frame_direct_lput, frame_direct_wput, frame_direct_bput,
|
|
frame_xlate
|
|
};
|
|
|
|
addrbank frame_host_555_bank = {
|
|
frame_host_555_lget, frame_host_555_wget, frame_direct_bget,
|
|
frame_host_555_lput, frame_host_555_wput, frame_direct_bput,
|
|
frame_xlate
|
|
};
|
|
|
|
addrbank frame_host_565_bank = {
|
|
frame_host_565_lget, frame_host_565_wget, frame_direct_bget,
|
|
frame_host_565_lput, frame_host_565_wput, frame_direct_bput,
|
|
frame_xlate
|
|
};
|
|
|
|
addrbank frame_host_888_bank = {
|
|
frame_host_888_lget, frame_direct_wget, frame_direct_bget,
|
|
frame_host_888_lput, frame_direct_wput, frame_direct_bput,
|
|
frame_xlate
|
|
};
|
|
|
|
addrbank fram24_bank = {
|
|
ram24_lget, ram24_wget, ram24_bget,
|
|
fram24_lput, fram24_wput, fram24_bput,
|
|
ram24_xlate
|
|
};
|
|
|
|
void memory_init(void)
|
|
{
|
|
for(long i=0; i<65536; i++)
|
|
put_mem_bank(i<<16, &dummy_bank);
|
|
|
|
// Limit RAM size to not overlap ROM
|
|
uint32 ram_size = RAMSize > ROMBaseMac ? ROMBaseMac : RAMSize;
|
|
|
|
RAMBaseDiff = (uintptr)RAMBaseHost - (uintptr)RAMBaseMac;
|
|
ROMBaseDiff = (uintptr)ROMBaseHost - (uintptr)ROMBaseMac;
|
|
FrameBaseDiff = (uintptr)MacFrameBaseHost - (uintptr)MacFrameBaseMac;
|
|
|
|
// Map RAM, ROM and display
|
|
if (TwentyFourBitAddressing) {
|
|
map_banks(&ram24_bank, RAMBaseMac >> 16, ram_size >> 16);
|
|
map_banks(&rom24_bank, ROMBaseMac >> 16, ROMSize >> 16);
|
|
|
|
// Map frame buffer at end of RAM.
|
|
map_banks(&fram24_bank, ((RAMBaseMac + ram_size) >> 16) - 1, 1);
|
|
} else {
|
|
map_banks(&ram_bank, RAMBaseMac >> 16, ram_size >> 16);
|
|
map_banks(&rom_bank, ROMBaseMac >> 16, ROMSize >> 16);
|
|
|
|
// Map frame buffer
|
|
switch (MacFrameLayout) {
|
|
case FLAYOUT_DIRECT:
|
|
map_banks(&frame_direct_bank, MacFrameBaseMac >> 16, (MacFrameSize >> 16) + 1);
|
|
break;
|
|
case FLAYOUT_HOST_555:
|
|
map_banks(&frame_host_555_bank, MacFrameBaseMac >> 16, (MacFrameSize >> 16) + 1);
|
|
break;
|
|
case FLAYOUT_HOST_565:
|
|
map_banks(&frame_host_565_bank, MacFrameBaseMac >> 16, (MacFrameSize >> 16) + 1);
|
|
break;
|
|
case FLAYOUT_HOST_888:
|
|
map_banks(&frame_host_888_bank, MacFrameBaseMac >> 16, (MacFrameSize >> 16) + 1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void map_banks(addrbank *bank, int start, int size)
|
|
{
|
|
int bnr;
|
|
unsigned long int hioffs = 0, endhioffs = 0x100;
|
|
|
|
if (start >= 0x100) {
|
|
for (bnr = start; bnr < start + size; bnr++)
|
|
put_mem_bank (bnr << 16, bank);
|
|
return;
|
|
}
|
|
if (TwentyFourBitAddressing) endhioffs = 0x10000;
|
|
for (hioffs = 0; hioffs < endhioffs; hioffs += 0x100)
|
|
for (bnr = start; bnr < start+size; bnr++)
|
|
put_mem_bank((bnr + hioffs) << 16, bank);
|
|
}
|
|
|
|
#endif /* !REAL_ADDRESSING && !DIRECT_ADDRESSING */
|
|
|