LOCALPROC Sony_Install(void)
{
ui3p pto = Sony_DriverBase + (ui3p)ROM;
MyMoveBytes((anyp)sony_driver, (anyp)pto, sizeof(sony_driver));
pto += sizeof(sony_driver);
do_put_mem_word(pto, kcom_callcheck);
pto += 2;
do_put_mem_word(pto, kExtnSony);
pto += 2;
do_put_mem_long(pto, kExtn_Block_Base); /* pokeaddr */
pto += 4;
my_disk_icon_addr = (pto - (ui3p)ROM) + kROM_Base;
MyMoveBytes((anyp)my_disk_icon, (anyp)pto, sizeof(my_disk_icon));
pto += sizeof(my_disk_icon);
#if UseLargeScreenHack
{
ui3p patchp = pto;
#include "SCRNHACK.h"
}
#endif
}
void MemWriteWord (p68K pos, int val)
{
#ifdef M68K_DEBUG
BOUNDS_CHECK (pos,2);
#endif /* M68K_DEBUG */
do_put_mem_word ((u16 *)(m68kram+pos), (u16)val);
}
/**
* Write long/word/byte into memory.
* NOTE - value will be converted to 68000 endian
*/
void STMemory_Write ( Uint32 addr , Uint32 val , int size )
{
addrbank *pBank;
Uint8 *p;
//printf ( "mem direct write %x %x %d\n" , addr , val , size );
pBank = &get_mem_bank ( addr );
if ( pBank->baseaddr == NULL )
return; /* No real memory, do nothing */
addr -= pBank->start & pBank->mask;
addr &= pBank->mask;
p = pBank->baseaddr + addr;
/* We modify the memory, so we flush the instr/data caches if needed */
M68000_Flush_All_Caches ( addr , size );
if ( size == 4 )
do_put_mem_long ( p , val );
else if ( size == 2 )
do_put_mem_word ( p , (Uint16)val );
else
*p = (Uint8)val;
}
static void REGPARAM2 a3000hmem_wput (uaecptr addr, uae_u32 w)
{
uae_u16 *m;
addr &= a3000hmem_mask;
m = (uae_u16 *)(a3000hmemory + addr);
do_put_mem_word (m, w);
}
void REGPARAM2 bogomem_wput (uaecptr addr, uae_u32 w)
{
uae_u16 *m;
addr -= bogomem_start & bogomem_mask;
addr &= bogomem_mask;
m = (uae_u16 *)(bogomemory + addr);
do_put_mem_word (m, w);
}
static void REGPARAM2 blizzardmaprom_wput(uaecptr addr, uae_u32 w)
{
uae_u16 *m;
#ifdef JIT
special_mem |= S_WRITE;
#endif
if (is_blizzard2060() && !maprom_state)
return;
addr &= blizzardmaprom_bank.mask;
m = (uae_u16 *)(blizzardmaprom_bank.baseaddr + addr);
do_put_mem_word(m, w);
if (maprom_state && !(addr & 0x80000)) {
no_rom_protect();
m = (uae_u16 *)(kickmem_bank.baseaddr + addr);
do_put_mem_word(m, w);
}
}
void REGPARAM2 z3fastmem_wput (uaecptr addr, uae_u32 w)
{
uae_u8 *m;
addr -= z3fastmem_start & z3fastmem_mask;
addr &= z3fastmem_mask;
m = z3fastmem + addr;
do_put_mem_word ((uae_u16 *)m, w);
}
void REGPARAM2 fastmem_wput (uaecptr addr, uae_u32 w)
{
uae_u8 *m;
addr -= fastmem_start & fastmem_mask;
addr &= fastmem_mask;
m = fastmemory + addr;
do_put_mem_word ((uae_u16 *)m, w);
}
void REGPARAM2 chipmem_wput (uaecptr addr, uae_u32 w)
{
uae_u16 *m;
addr -= chipmem_start & chipmem_mask;
addr &= chipmem_mask;
m = (uae_u16 *)(chipmemory + addr);
do_put_mem_word (m, swab_w(w));
}
void REGPARAM2 chipmem_agnus_wput (uaecptr addr, uae_u32 w)
{
uae_u16 *m;
addr &= chipmem_full_mask;
if (addr >= allocated_chipmem)
return;
m = (uae_u16 *)(chipmemory + addr);
do_put_mem_word (m, w);
}
void REGPARAM2 bogomem_wput (uaecptr addr, uae_u32 w)
{
uae_u16 *m;
addr -= bogomem_start /*& bogomem_mask*/;
#ifdef SAFE_MEMORY_ACCESS
addr &= bogomem_mask;
#endif
m = (uae_u16 *)(bogomemory + addr);
do_put_mem_word (m, w);
}
void REGPARAM2 a3000mem_wput (uaecptr addr, uae_u32 w)
{
#ifdef DEBUG_MEMORY
dbgf("a3000mem_wput 0x%X = 0x%X\n",addr,w);
#endif
uae_u16 *m;
addr -= a3000mem_start & a3000mem_mask;
addr &= a3000mem_mask;
m = (uae_u16 *)(a3000memory + addr);
do_put_mem_word (m, SWAP_W(w));
}
static void REGPARAM2 chipmem_wput2 (uaecptr addr, uae_u32 w)
{
uae_u16 *m;
addr -= chipmem_start & chipmem_mask;
addr &= chipmem_mask;
m = (uae_u16 *)(chipmemory + addr);
if (ISILLEGAL (addr))
enforcer_display_hit ("WORD WRITE to", GET_PC, addr);
do_put_mem_word (m, w);
}
static void REGPARAM2 blizzardram_nojit_wput(uaecptr addr, uae_u32 w)
{
uae_u16 *m;
#ifdef JIT
special_mem |= S_WRITE;
#endif
addr &= blizzardram_nojit_bank.mask;
if (maprom_state && addr >= maprom_base)
return;
m = (uae_u16 *)(blizzardram_nojit_bank.baseaddr + addr);
do_put_mem_word(m, w);
}
void REGPARAM2 kickmem_lput (uaecptr addr, uae_u32 l)
{
uae_u16 *m;
if (a1000_kickstart_mode) {
if (addr >= 0xfc0000) {
addr -= kickmem_start /*& kickmem_mask*/;
#ifdef SAFE_MEMORY_ACCESS
addr &= kickmem_mask;
#endif
m = (uae_u16 *)(kickmemory + addr);
do_put_mem_word(m, l >> 16);
do_put_mem_word(m + 1, l);
return;
} else
void REGPARAM2 kickmem_wput (uaecptr addr, uae_u32 b)
{
uae_u16 *m;
if (a1000_kickstart_mode) {
if (addr >= 0xfc0000) {
addr -= kickmem_start & kickmem_mask;
addr &= kickmem_mask;
m = (uae_u16 *)(kickmemory + addr);
do_put_mem_word (m, swab_w(b));
return;
} else
a1000_handle_kickstart (0);
}
}
void REGPARAM2 kickmem_wput (uaecptr addr, uae_u32 b)
{
uae_u16 *m;
if (a1000_kickstart_mode) {
if (addr >= 0xfc0000) {
addr -= kickmem_start & kickmem_mask;
addr &= kickmem_mask;
m = (uae_u16 *)(kickmemory + addr);
do_put_mem_word (m, b);
return;
} else
a1000_handle_kickstart (0);
} else if (currprefs.illegal_mem)
printf ("Illegal kickmem wput at %08lx\n", addr);
}
static void REGPARAM2 chipmem_wput2 (uaecptr addr, uae_u32 w)
{
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 WRITE to"), m68k_getpc (), addr);
if (enforcermode & 1)
set_special (SPCFLAG_TRAP);
}
if (ISEXEC (addr) || ISEXEC (addr + 1))
return;
do_put_mem_word (m, w);
}
static void REGPARAM2 chipmem_wput2 (uaecptr addr, uae_u32 w)
{
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 WRITE to"),(uae_u32)(regs.pc_p - NMEM_OFFSET),addr);
if (enforcermode & 1)
set_special (SPCFLAG_TRAP);
}
if (ISEXEC (addr) || ISEXEC (addr + 1))
return;
do_put_mem_word (m, w);
}
static void mem_ram_bank3_wput(uaecptr addr, uae_u32 w)
{
addr &= NEXT_ram_bank3_mask;
do_put_mem_word(NEXTRam + addr, w);
}
static void mem_video_wput(uaecptr addr, uae_u32 w)
{
addr &= NEXT_VRAM_MASK;
do_put_mem_word(NEXTVideo + addr, w);
}
void dw (uae_u16 data)
{
do_put_mem_word ((uae_u16 *)(rtarea + rt_addr), data);
rt_addr += 2;
}
/**
* Save compressed .MSA file from memory buffer. Returns true is all OK
*/
bool MSA_WriteDisk(const char *pszFileName, Uint8 *pBuffer, int ImageSize)
{
#ifdef SAVE_TO_MSA_IMAGES
MSAHEADERSTRUCT *pMSAHeader;
unsigned short int *pMSADataLength;
Uint8 *pMSAImageBuffer, *pMSABuffer, *pImageBuffer;
Uint16 nSectorsPerTrack, nSides, nCompressedBytes, nBytesPerTrack;
bool nRet;
int nTracks,nBytesToGo,nBytesRun;
int Track,Side;
/* Allocate workspace for compressed image */
pMSAImageBuffer = (Uint8 *)malloc(MSA_WORKSPACE_SIZE);
if (!pMSAImageBuffer)
{
perror("MSA_WriteDisk");
return false;
}
/* Store header */
pMSAHeader = (MSAHEADERSTRUCT *)pMSAImageBuffer;
pMSAHeader->ID = SDL_SwapBE16(0x0E0F);
Floppy_FindDiskDetails(pBuffer,ImageSize, &nSectorsPerTrack, &nSides);
pMSAHeader->SectorsPerTrack = SDL_SwapBE16(nSectorsPerTrack);
pMSAHeader->Sides = SDL_SwapBE16(nSides-1);
pMSAHeader->StartingTrack = SDL_SwapBE16(0);
nTracks = ((ImageSize / NUMBYTESPERSECTOR) / nSectorsPerTrack) / nSides;
pMSAHeader->EndingTrack = SDL_SwapBE16(nTracks-1);
/* Compress image */
pMSABuffer = pMSAImageBuffer + sizeof(MSAHEADERSTRUCT);
for (Track = 0; Track < nTracks; Track++)
{
for (Side = 0; Side < nSides; Side++)
{
/* Get track data pointer */
nBytesPerTrack = NUMBYTESPERSECTOR*nSectorsPerTrack;
pImageBuffer = pBuffer + (nBytesPerTrack*Side) + ((nBytesPerTrack*nSides)*Track);
/* Skip data length (fill in later) */
pMSADataLength = (Uint16 *)pMSABuffer;
pMSABuffer += sizeof(Uint16);
/* Compress track */
nBytesToGo = nBytesPerTrack;
nCompressedBytes = 0;
while (nBytesToGo > 0)
{
nBytesRun = MSA_FindRunOfBytes(pImageBuffer,nBytesToGo);
if (nBytesRun == 0)
{
/* Just copy byte */
*pMSABuffer++ = *pImageBuffer++;
nCompressedBytes++;
nBytesRun = 1;
}
else
{
/* Store run! */
*pMSABuffer++ = 0xE5; /* Marker */
*pMSABuffer++ = *pImageBuffer; /* Byte, and follow with 16-bit length */
do_put_mem_word(pMSABuffer, nBytesRun);
pMSABuffer += sizeof(Uint16);
pImageBuffer += nBytesRun;
nCompressedBytes += 4;
}
nBytesToGo -= nBytesRun;
}
/* Is compressed track smaller than the original? */
if (nCompressedBytes < nBytesPerTrack)
{
/* Yes, store size */
do_put_mem_word(pMSADataLength, nCompressedBytes);
}
else
{
/* No, just store uncompressed track */
do_put_mem_word(pMSADataLength, nBytesPerTrack);
pMSABuffer = ((Uint8 *)pMSADataLength) + 2;
pImageBuffer = pBuffer + (nBytesPerTrack*Side) + ((nBytesPerTrack*nSides)*Track);
memcpy(pMSABuffer,pImageBuffer, nBytesPerTrack);
pMSABuffer += nBytesPerTrack;
}
}
}
/* And save to file! */
nRet = File_Save(pszFileName,pMSAImageBuffer, pMSABuffer-pMSAImageBuffer, false);
/* Free workspace */
free(pMSAImageBuffer);
return nRet;
#else /*SAVE_TO_MSA_IMAGES*/
/* Oops, cannot save */
return false;
#endif /*SAVE_TO_MSA_IMAGES*/
}
