uae_u32 REGPARAM2 kickmem_lget (uaecptr addr)
{
uae_u16 *m;
addr -= kickmem_start /*& kickmem_mask*/;
#ifdef SAFE_MEMORY_ACCESS
addr &= kickmem_mask;
#endif
m = (uae_u16 *)(kickmemory + addr);
return (do_get_mem_word(m) << 16) |
(do_get_mem_word(m + 1));
}
static uae_u32 REGPARAM2 a3000hmem_wget (uaecptr addr)
{
uae_u16 *m;
addr &= a3000hmem_mask;
m = (uae_u16 *)(a3000hmemory + addr);
return do_get_mem_word (m);
}
short MemReadWord (p68K pos)
{
#ifdef M68K_DEBUG
BOUNDS_CHECK (pos,2);
#endif /* M68K_DEBUG */
return do_get_mem_word ((u16 *)(m68kram+pos));
}
static uae_u32 mem_rom_wget(uaecptr addr)
{
// if ((addr<0x2000) && (SCR_ROM_overlay)) {do_get_mem_word(NEXTRam + 0x03FFE000 +addr);}
addr &= NEXT_EPROM_MASK;
return do_get_mem_word(ROMmemory + addr);
}
static uae_u32 REGPARAM2 extendedkickmem_wget (uaecptr addr)
{
uae_u16 *m;
addr -= extendedkickmem_start & extendedkickmem_mask;
addr &= extendedkickmem_mask;
m = (uae_u16 *)(extendedkickmemory + addr);
return do_get_mem_word (m);
}
uae_u32 REGPARAM2 bogomem_wget (uaecptr addr)
{
uae_u16 *m;
addr -= bogomem_start & bogomem_mask;
addr &= bogomem_mask;
m = (uae_u16 *)(bogomemory + addr);
return do_get_mem_word (m);
}
uae_u32 REGPARAM2 chipmem_agnus_wget (uaecptr addr)
{
uae_u16 *m;
addr &= chipmem_full_mask;
m = (uae_u16 *)(chipmemory + addr);
return do_get_mem_word (m);
}
uae_u32 REGPARAM2 kickmem_wget (uaecptr addr)
{
uae_u16 *m;
addr -= kickmem_start & kickmem_mask;
addr &= kickmem_mask;
m = (uae_u16 *)(kickmemory + addr);
return swab_w(do_get_mem_word (m));
}
uae_u32 REGPARAM2 z3fastmem_wget (uaecptr addr)
{
uae_u8 *m;
addr -= z3fastmem_start & z3fastmem_mask;
addr &= z3fastmem_mask;
m = z3fastmem + addr;
return do_get_mem_word ((uae_u16 *)m);
}
uae_u32 REGPARAM2 filesys_wget (uaecptr addr)
{
uae_u8 *m;
addr -= filesys_start & 65535;
addr &= 65535;
m = filesysory + addr;
return do_get_mem_word ((uae_u16 *)m);
}
uae_u32 REGPARAM2 fastmem_wget (uaecptr addr)
{
uae_u8 *m;
addr -= fastmem_start & fastmem_mask;
addr &= fastmem_mask;
m = fastmemory + addr;
return do_get_mem_word ((uae_u16 *)m);
}
uae_u32 REGPARAM2 chipmem_wget (uaecptr addr)
{
uae_u16 *m;
addr -= chipmem_start & chipmem_mask;
addr &= chipmem_mask;
m = (uae_u16 *)(chipmemory + addr);
return swab_w(do_get_mem_word (m));
}
uae_u32 REGPARAM2 a3000mem_wget (uaecptr addr)
{
#ifdef DEBUG_MEMORY
dbgf("a3000mem_wget 0x%X\n",addr);
#endif
uae_u16 *m;
addr -= a3000mem_start & a3000mem_mask;
addr &= a3000mem_mask;
m = (uae_u16 *)(a3000memory + addr);
return SWAP_W(do_get_mem_word (m));
}
uae_u32 REGPARAM2 bogomem_wget (uaecptr addr)
{
uae_u16 *m;
addr -= bogomem_start /*& bogomem_mask*/;
#ifdef SAFE_MEMORY_ACCESS
addr &= bogomem_mask;
#endif
m = (uae_u16 *)(bogomemory + addr);
return do_get_mem_word (m);
}
uae_u32 REGPARAM2 extendedkickmem_wget (uaecptr addr)
{
#ifdef DEBUG_MEMORY
dbgf("extendedkickmem_wget 0x%X\n",addr);
#endif
uae_u16 *m;
addr -= extendedkickmem_start & extendedkickmem_mask;
addr &= extendedkickmem_mask;
m = (uae_u16 *)(extendedkickmemory + addr);
return swab_w(do_get_mem_word (m));
}
uae_u32 REGPARAM2 chipmem_wget (uaecptr addr)
{
uae_u16 *m;
// addr -= chipmem_start /*& chipmem_mask*/;
#ifdef SAFE_MEMORY_ACCESS
addr &= chipmem_mask;
#endif
m = (uae_u16 *)(chipmemory + addr);
return do_get_mem_word (m);
}
static uae_u32 REGPARAM2 chipmem_wget2 (uaecptr addr)
{
uae_u16 *m;
addr -= chipmem_start & chipmem_mask;
addr &= chipmem_mask;
m = (uae_u16 *)(chipmemory + addr);
if (ISILLEGAL (addr))
enforcer_display_hit ("WORD READ from", GET_PC, addr);
return do_get_mem_word (m);
}
static uae_u32 REGPARAM2 blizzardf0_wget(uaecptr addr)
{
#ifdef JIT
special_mem |= S_READ;
#endif
uae_u16 *m, v;
regs.memory_waitstate_cycles += F0_WAITSTATES * 3;
addr &= blizzardf0_bank.mask;
m = (uae_u16 *)(blizzardf0_bank.baseaddr + addr);
v = do_get_mem_word(m);
return v;
}
static uae_u32 REGPARAM2 chipmem_wget2(uaecptr addr)
{
uae_u16 *m;
addr -= chipmem_start_addr & chipmem_bank.mask;
addr &= chipmem_bank.mask;
m = (uae_u16 *)(chipmem_bank.baseaddr + addr);
if (ISILLEGAL_WORD (addr))
{
enforcer_display_hit (_T("WORD READ from"), m68k_getpc (), addr);
if (enforcermode & 1)
set_special (SPCFLAG_TRAP);
}
return do_get_mem_word (m);
}
static uae_u32 REGPARAM2 chipmem_wget2(uaecptr addr)
{
uae_u16 *m;
addr -= chipmem_start & chipmem_mask;
addr &= chipmem_mask;
m = (uae_u16 *)(chipmemory + addr);
if (ISILLEGAL_WORD (addr))
{
enforcer_display_hit (_T("WORD READ from"),(uae_u32)(regs.pc_p - NMEM_OFFSET),addr);
if (enforcermode & 1)
set_special (SPCFLAG_TRAP);
}
return do_get_mem_word (m);
}
/**
* Read long/word/byte from memory.
* NOTE - value will be converted to 68000 endian
*/
Uint32 STMemory_Read ( Uint32 addr , int size )
{
addrbank *pBank;
Uint8 *p;
//printf ( "mem direct read %x %d\n" , addr , size );
pBank = &get_mem_bank ( addr );
if ( pBank->baseaddr == NULL )
return 0; /* No real memory, return 0 */
addr -= pBank->start & pBank->mask;
addr &= pBank->mask;
p = pBank->baseaddr + addr;
if ( size == 4 )
return do_get_mem_long ( p );
else if ( size == 2 )
return (Uint32)do_get_mem_word ( p );
else
return (Uint32)*p;
}
static uae_u32 mem_ram_bank3_wget(uaecptr addr)
{
addr &= NEXT_ram_bank3_mask;
return do_get_mem_word(NEXTRam + addr);
}
/**
* Uncompress .MSA data into a new buffer.
*/
Uint8 *MSA_UnCompress(Uint8 *pMSAFile, long *pImageSize)
{
MSAHEADERSTRUCT *pMSAHeader;
Uint8 *pMSAImageBuffer, *pImageBuffer;
Uint8 Byte,Data;
int i,Track,Side,DataLength,NumBytesUnCompressed,RunLength;
Uint8 *pBuffer = NULL;
*pImageSize = 0;
/* Is an '.msa' file?? Check header */
pMSAHeader = (MSAHEADERSTRUCT *)pMSAFile;
if (pMSAHeader->ID == SDL_SwapBE16(0x0E0F))
{
/* First swap 'header' words around to PC format - easier later on */
pMSAHeader->SectorsPerTrack = SDL_SwapBE16(pMSAHeader->SectorsPerTrack);
pMSAHeader->Sides = SDL_SwapBE16(pMSAHeader->Sides);
pMSAHeader->StartingTrack = SDL_SwapBE16(pMSAHeader->StartingTrack);
pMSAHeader->EndingTrack = SDL_SwapBE16(pMSAHeader->EndingTrack);
/* Create buffer */
pBuffer = malloc((pMSAHeader->EndingTrack - pMSAHeader->StartingTrack + 1)
* pMSAHeader->SectorsPerTrack * (pMSAHeader->Sides + 1)
* NUMBYTESPERSECTOR);
if (!pBuffer)
{
perror("MSA_UnCompress");
return NULL;
}
/* Set pointers */
pImageBuffer = (Uint8 *)pBuffer;
pMSAImageBuffer = (Uint8 *)((unsigned long)pMSAFile + sizeof(MSAHEADERSTRUCT));
/* Uncompress to memory as '.ST' disk image - NOTE: assumes 512 bytes
* per sector (use NUMBYTESPERSECTOR define)!!! */
for (Track = pMSAHeader->StartingTrack; Track <= pMSAHeader->EndingTrack; Track++)
{
for (Side = 0; Side < (pMSAHeader->Sides+1); Side++)
{
int nBytesPerTrack = NUMBYTESPERSECTOR*pMSAHeader->SectorsPerTrack;
/* Uncompress MSA Track, first check if is not compressed */
DataLength = do_get_mem_word(pMSAImageBuffer);
pMSAImageBuffer += sizeof(short int);
if (DataLength == nBytesPerTrack)
{
/* No compression on track, simply copy and continue */
memcpy(pImageBuffer, pMSAImageBuffer, nBytesPerTrack);
pImageBuffer += nBytesPerTrack;
pMSAImageBuffer += DataLength;
}
else
{
/* Uncompress track */
NumBytesUnCompressed = 0;
while (NumBytesUnCompressed < nBytesPerTrack)
{
Byte = *pMSAImageBuffer++;
if (Byte != 0xE5) /* Compressed header?? */
{
*pImageBuffer++ = Byte; /* No, just copy byte */
NumBytesUnCompressed++;
}
else
{
Data = *pMSAImageBuffer++; /* Byte to copy */
RunLength = do_get_mem_word(pMSAImageBuffer); /* For length */
/* Limit length to size of track, incorrect images may overflow */
if (RunLength+NumBytesUnCompressed > nBytesPerTrack)
{
fprintf(stderr, "MSA_UnCompress: Illegal run length -> corrupted disk image?\n");
RunLength = nBytesPerTrack - NumBytesUnCompressed;
}
pMSAImageBuffer += sizeof(short int);
for (i = 0; i < RunLength; i++)
*pImageBuffer++ = Data; /* Copy byte */
NumBytesUnCompressed += RunLength;
}
}
}
}
}
/* Set size of loaded image */
*pImageSize = (unsigned long)pImageBuffer-(unsigned long)pBuffer;
}
/* Return pointer to buffer, NULL if failed */
return(pBuffer);
}
static uae_u32 mem_video_wget(uaecptr addr)
{
addr &= NEXT_VRAM_MASK;
return do_get_mem_word(NEXTVideo + addr);
}
