nkeynes@10: /**
nkeynes@586:  * $Id$
nkeynes@10:  * sh4mem.c is responsible for the SH4's access to memory (including memory
nkeynes@10:  * mapped I/O), using the page maps created in mem.c
nkeynes@10:  *
nkeynes@10:  * Copyright (c) 2005 Nathan Keynes.
nkeynes@10:  *
nkeynes@10:  * This program is free software; you can redistribute it and/or modify
nkeynes@10:  * it under the terms of the GNU General Public License as published by
nkeynes@10:  * the Free Software Foundation; either version 2 of the License, or
nkeynes@10:  * (at your option) any later version.
nkeynes@10:  *
nkeynes@10:  * This program is distributed in the hope that it will be useful,
nkeynes@10:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
nkeynes@10:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
nkeynes@10:  * GNU General Public License for more details.
nkeynes@10:  */
nkeynes@10: 
nkeynes@35: #define MODULE sh4_module
nkeynes@35: 
nkeynes@10: #include <string.h>
nkeynes@10: #include <zlib.h>
nkeynes@10: #include "dream.h"
nkeynes@10: #include "mem.h"
nkeynes@10: #include "mmio.h"
nkeynes@10: #include "dreamcast.h"
nkeynes@422: #include "sh4/sh4core.h"
nkeynes@422: #include "sh4/sh4mmio.h"
nkeynes@422: #include "sh4/xltcache.h"
nkeynes@100: #include "pvr2/pvr2.h"
nkeynes@422: #include "asic.h"
nkeynes@10: 
nkeynes@10: #define OC_BASE 0x1C000000
nkeynes@10: #define OC_TOP  0x20000000
nkeynes@10: 
nkeynes@90: #define TRANSLATE_VIDEO_64BIT_ADDRESS(a)  ( (((a)&0x00FFFFF8)>>1)|(((a)&0x00000004)<<20)|((a)&0x03)|0x05000000 )
nkeynes@10: 
nkeynes@10: #ifdef ENABLE_WATCH
nkeynes@10: #define CHECK_READ_WATCH( addr, size ) \
nkeynes@10:     if( mem_is_watched(addr,size,WATCH_READ) != NULL ) { \
nkeynes@10:         WARN( "Watch triggered at %08X by %d byte read", addr, size ); \
nkeynes@740:         sh4_core_exit(CORE_EXIT_HALT); \
nkeynes@10:     }
nkeynes@10: #define CHECK_WRITE_WATCH( addr, size, val )                  \
nkeynes@10:     if( mem_is_watched(addr,size,WATCH_WRITE) != NULL ) { \
nkeynes@10:         WARN( "Watch triggered at %08X by %d byte write <= %0*X", addr, size, size*2, val ); \
nkeynes@740:         sh4_core_exit(CORE_EXIT_HALT); \
nkeynes@10:     }
nkeynes@10: #else
nkeynes@10: #define CHECK_READ_WATCH( addr, size )
nkeynes@234: #define CHECK_WRITE_WATCH( addr, size, val )
nkeynes@10: #endif
nkeynes@10: 
nkeynes@406: #ifdef ENABLE_TRACE_IO
nkeynes@172: #define TRACE_IO( str, p, r, ... ) if(io_rgn[(uint32_t)p]->trace_flag && !MMIO_NOTRACE_BYNUM((uint32_t)p,r)) \
nkeynes@172:     TRACE( str " [%s.%s: %s]", __VA_ARGS__,			       \
nkeynes@736:             MMIO_NAME_BYNUM((uint32_t)p), MMIO_REGID_BYNUM((uint32_t)p, r), \
nkeynes@736:             MMIO_REGDESC_BYNUM((uint32_t)p, r) )
nkeynes@172: #define TRACE_P4IO( str, io, r, ... ) if(io->trace_flag && !MMIO_NOTRACE_IOBYNUM(io,r)) \
nkeynes@736:     TRACE( str " [%s.%s: %s]", __VA_ARGS__, \
nkeynes@736:             io->id, MMIO_REGID_IOBYNUM(io, r), \
nkeynes@736:             MMIO_REGDESC_IOBYNUM(io, r) )
nkeynes@406: #else
nkeynes@406: #define TRACE_IO( str, p, r, ... )
nkeynes@406: #define TRACE_P4IO( str, io, r, ... )
nkeynes@406: #endif
nkeynes@10: 
nkeynes@10: extern struct mem_region mem_rgn[];
nkeynes@10: extern struct mmio_region *P4_io[];
nkeynes@10: 
nkeynes@905: int32_t FASTCALL sh4_read_p4( sh4addr_t addr )
nkeynes@10: {
nkeynes@10:     struct mmio_region *io = P4_io[(addr&0x1FFFFFFF)>>19];
nkeynes@10:     if( !io ) {
nkeynes@736:         switch( addr & 0x1F000000 ) {
nkeynes@736:         case 0x00000000: case 0x01000000: case 0x02000000: case 0x03000000: 
nkeynes@736:             /* Store queue - readable? */
nkeynes@736:             return 0;
nkeynes@736:             break;
nkeynes@736:         case 0x10000000: return mmu_icache_addr_read( addr );
nkeynes@736:         case 0x11000000: return mmu_icache_data_read( addr );
nkeynes@736:         case 0x12000000: return mmu_itlb_addr_read( addr );
nkeynes@736:         case 0x13000000: return mmu_itlb_data_read( addr );
nkeynes@736:         case 0x14000000: return mmu_ocache_addr_read( addr );
nkeynes@736:         case 0x15000000: return mmu_ocache_data_read( addr );
nkeynes@736:         case 0x16000000: return mmu_utlb_addr_read( addr );
nkeynes@736:         case 0x17000000: return mmu_utlb_data_read( addr );
nkeynes@736:         default:
nkeynes@550:             WARN( "Attempted read from unknown or invalid P4 region: %08X", addr );
nkeynes@736:             return 0;
nkeynes@282:         }
nkeynes@10:     } else {
nkeynes@736:         int32_t val = io->io_read( addr&0xFFF );
nkeynes@736:         TRACE_P4IO( "Long read %08X <= %08X", io, (addr&0xFFF), val, addr );
nkeynes@156:         return val;
nkeynes@10:     }    
nkeynes@10: }
nkeynes@10: 
nkeynes@905: void FASTCALL sh4_write_p4( sh4addr_t addr, int32_t val )
nkeynes@10: {
nkeynes@10:     struct mmio_region *io = P4_io[(addr&0x1FFFFFFF)>>19];
nkeynes@10:     if( !io ) {
nkeynes@736:         switch( addr & 0x1F000000 ) {
nkeynes@736:         case 0x00000000: case 0x01000000: case 0x02000000: case 0x03000000: 
nkeynes@10:             /* Store queue */
nkeynes@10:             SH4_WRITE_STORE_QUEUE( addr, val );
nkeynes@736:             break;
nkeynes@736:         case 0x10000000: mmu_icache_addr_write( addr, val ); break;
nkeynes@736:         case 0x11000000: mmu_icache_data_write( addr, val ); break;
nkeynes@736:         case 0x12000000: mmu_itlb_addr_write( addr, val ); break;
nkeynes@736:         case 0x13000000: mmu_itlb_data_write( addr, val ); break;
nkeynes@736:         case 0x14000000: mmu_ocache_addr_write( addr, val ); break;
nkeynes@736:         case 0x15000000: mmu_ocache_data_write( addr, val ); break;
nkeynes@736:         case 0x16000000: mmu_utlb_addr_write( addr, val ); break;
nkeynes@736:         case 0x17000000: mmu_utlb_data_write( addr, val ); break;
nkeynes@736:         default:
nkeynes@828:             if( (addr & 0xFFFF0000 ) == 0xFF940000 ||
nkeynes@828:                 (addr & 0xFFFF0000 ) == 0xFF900000 ) {
nkeynes@828:                 // SDRAM configuration, ignore for now
nkeynes@828:             } else {
nkeynes@828:                 WARN( "Attempted write to unknown P4 region: %08X", addr );
nkeynes@828:             }
nkeynes@10:         }
nkeynes@10:     } else {
nkeynes@736:         TRACE_P4IO( "Long write %08X => %08X", io, (addr&0xFFF), val, addr );
nkeynes@10:         io->io_write( addr&0xFFF, val );
nkeynes@10:     }
nkeynes@10: }
nkeynes@10: 
nkeynes@527: int32_t sh4_read_phys_word( sh4addr_t addr )
nkeynes@10: {
nkeynes@502:     sh4ptr_t page;
nkeynes@83:     if( addr >= 0xE0000000 ) /* P4 Area, handled specially */
nkeynes@10:         return SIGNEXT16(sh4_read_p4( addr ));
nkeynes@736: 
nkeynes@10:     if( (addr&0x1F800000) == 0x04000000 ) {
nkeynes@10:         addr = TRANSLATE_VIDEO_64BIT_ADDRESS(addr);
nkeynes@10:     }
nkeynes@10: 
nkeynes@10:     page = page_map[ (addr & 0x1FFFFFFF) >> 12 ];
nkeynes@504:     if( ((uintptr_t)page) < MAX_IO_REGIONS ) { /* IO Region */
nkeynes@10:         if( page == NULL ) {
nkeynes@448:             WARN( "Attempted word read to missing page: %08X",
nkeynes@736:                     addr );
nkeynes@10:             return 0;
nkeynes@10:         }
nkeynes@504:         return SIGNEXT16(io_rgn[(uintptr_t)page]->io_read(addr&0xFFF));
nkeynes@10:     } else {
nkeynes@10:         return SIGNEXT16(*(int16_t *)(page+(addr&0xFFF)));
nkeynes@10:     }
nkeynes@10: }
nkeynes@10: 
nkeynes@527: /**
nkeynes@527:  * Convenience function to read a quad-word (implemented as two long reads).
nkeynes@527:  */
nkeynes@905: int64_t FASTCALL sh4_read_quad( sh4addr_t addr )
nkeynes@527: {
nkeynes@527:     return ((int64_t)((uint32_t)sh4_read_long(addr))) |
nkeynes@736:     (((int64_t)((uint32_t)sh4_read_long(addr+4))) << 32);
nkeynes@527: }
nkeynes@527: 
nkeynes@905: int32_t FASTCALL sh4_read_long( sh4addr_t addr )
nkeynes@10: {
nkeynes@502:     sh4ptr_t page;
nkeynes@736: 
nkeynes@10:     CHECK_READ_WATCH(addr,4);
nkeynes@10: 
nkeynes@418:     if( addr >= 0xE0000000 ) { /* P4 Area, handled specially */
nkeynes@586:         return ZEROEXT32(sh4_read_p4( addr ));
nkeynes@418:     } else if( (addr&0x1C000000) == 0x0C000000 ) {
nkeynes@736:         return ZEROEXT32(*(int32_t *)(sh4_main_ram + (addr&0x00FFFFFF)));
nkeynes@418:     } else if( (addr&0x1F800000) == 0x04000000 ) {
nkeynes@10:         addr = TRANSLATE_VIDEO_64BIT_ADDRESS(addr);
nkeynes@736:         pvr2_render_buffer_invalidate(addr, FALSE);
nkeynes@217:     } else if( (addr&0x1F800000) == 0x05000000 ) {
nkeynes@736:         pvr2_render_buffer_invalidate(addr, FALSE);
nkeynes@10:     }
nkeynes@10: 
nkeynes@10:     page = page_map[ (addr & 0x1FFFFFFF) >> 12 ];
nkeynes@504:     if( ((uintptr_t)page) < MAX_IO_REGIONS ) { /* IO Region */
nkeynes@10:         int32_t val;
nkeynes@10:         if( page == NULL ) {
nkeynes@448:             WARN( "Attempted long read to missing page: %08X", addr );
nkeynes@10:             return 0;
nkeynes@10:         }
nkeynes@504:         val = io_rgn[(uintptr_t)page]->io_read(addr&0xFFF);
nkeynes@10:         TRACE_IO( "Long read %08X <= %08X", page, (addr&0xFFF), val, addr );
nkeynes@586:         return ZEROEXT32(val);
nkeynes@10:     } else {
nkeynes@586:         return ZEROEXT32(*(int32_t *)(page+(addr&0xFFF)));
nkeynes@10:     }
nkeynes@10: }
nkeynes@10: 
nkeynes@905: int32_t FASTCALL sh4_read_word( sh4addr_t addr )
nkeynes@10: {
nkeynes@502:     sh4ptr_t page;
nkeynes@10: 
nkeynes@10:     CHECK_READ_WATCH(addr,2);
nkeynes@10: 
nkeynes@418:     if( addr >= 0xE0000000 ) { /* P4 Area, handled specially */
nkeynes@586:         return ZEROEXT32(SIGNEXT16(sh4_read_p4( addr )));
nkeynes@418:     } else if( (addr&0x1C000000) == 0x0C000000 ) {
nkeynes@736:         return ZEROEXT32(SIGNEXT16(*(int16_t *)(sh4_main_ram + (addr&0x00FFFFFF))));
nkeynes@418:     } else if( (addr&0x1F800000) == 0x04000000 ) {
nkeynes@10:         addr = TRANSLATE_VIDEO_64BIT_ADDRESS(addr);
nkeynes@736:         pvr2_render_buffer_invalidate(addr, FALSE);
nkeynes@217:     } else if( (addr&0x1F800000) == 0x05000000 ) {
nkeynes@736:         pvr2_render_buffer_invalidate(addr, FALSE);
nkeynes@10:     }
nkeynes@736: 
nkeynes@10:     page = page_map[ (addr & 0x1FFFFFFF) >> 12 ];
nkeynes@504:     if( ((uintptr_t)page) < MAX_IO_REGIONS ) { /* IO Region */
nkeynes@10:         int32_t val;
nkeynes@10:         if( page == NULL ) {
nkeynes@736:             WARN( "Attempted word read to missing page: %08X", addr );
nkeynes@10:             return 0;
nkeynes@10:         }
nkeynes@504:         val = SIGNEXT16(io_rgn[(uintptr_t)page]->io_read(addr&0xFFF));
nkeynes@10:         TRACE_IO( "Word read %04X <= %08X", page, (addr&0xFFF), val&0xFFFF, addr );
nkeynes@586:         return ZEROEXT32(val);
nkeynes@10:     } else {
nkeynes@586:         return ZEROEXT32(SIGNEXT16(*(int16_t *)(page+(addr&0xFFF))));
nkeynes@10:     }
nkeynes@10: }
nkeynes@10: 
nkeynes@905: int32_t FASTCALL sh4_read_byte( sh4addr_t addr )
nkeynes@10: {
nkeynes@502:     sh4ptr_t page;
nkeynes@10: 
nkeynes@10:     CHECK_READ_WATCH(addr,1);
nkeynes@10: 
nkeynes@418:     if( addr >= 0xE0000000 ) { /* P4 Area, handled specially */
nkeynes@586:         return ZEROEXT32(SIGNEXT8(sh4_read_p4( addr )));
nkeynes@418:     } else if( (addr&0x1C000000) == 0x0C000000 ) {
nkeynes@736:         return ZEROEXT32(SIGNEXT8(*(int8_t *)(sh4_main_ram + (addr&0x00FFFFFF))));
nkeynes@418:     } else if( (addr&0x1F800000) == 0x04000000 ) {
nkeynes@10:         addr = TRANSLATE_VIDEO_64BIT_ADDRESS(addr);
nkeynes@736:         pvr2_render_buffer_invalidate(addr, FALSE);
nkeynes@217:     } else if( (addr&0x1F800000) == 0x05000000 ) {
nkeynes@736:         pvr2_render_buffer_invalidate(addr, FALSE);
nkeynes@10:     }
nkeynes@217: 
nkeynes@736: 
nkeynes@10:     page = page_map[ (addr & 0x1FFFFFFF) >> 12 ];
nkeynes@504:     if( ((uintptr_t)page) < MAX_IO_REGIONS ) { /* IO Region */
nkeynes@10:         int32_t val;
nkeynes@10:         if( page == NULL ) {
nkeynes@448:             WARN( "Attempted byte read to missing page: %08X", addr );
nkeynes@10:             return 0;
nkeynes@10:         }
nkeynes@504:         val = SIGNEXT8(io_rgn[(uintptr_t)page]->io_read(addr&0xFFF));
nkeynes@10:         TRACE_IO( "Byte read %02X <= %08X", page, (addr&0xFFF), val&0xFF, addr );
nkeynes@586:         return ZEROEXT32(val);
nkeynes@10:     } else {
nkeynes@586:         return ZEROEXT32(SIGNEXT8(*(int8_t *)(page+(addr&0xFFF))));
nkeynes@10:     }
nkeynes@10: }
nkeynes@10: 
nkeynes@527: /**
nkeynes@527:  * Convenience function to write a quad-word (implemented as two long writes).
nkeynes@527:  */
nkeynes@905: void FASTCALL sh4_write_quad( sh4addr_t addr, uint64_t val )
nkeynes@527: {
nkeynes@527:     sh4_write_long( addr, (uint32_t)val );
nkeynes@527:     sh4_write_long( addr+4, (uint32_t)(val>>32) );
nkeynes@527: }
nkeynes@527: 
nkeynes@905: void FASTCALL sh4_write_long( sh4addr_t addr, uint32_t val )
nkeynes@10: {
nkeynes@502:     sh4ptr_t page;
nkeynes@400: 
nkeynes@10:     CHECK_WRITE_WATCH(addr,4,val);
nkeynes@10: 
nkeynes@83:     if( addr >= 0xE0000000 ) {
nkeynes@910:     	if( addr < 0xE4000000 ) { // Shortcut for the extremely common case
nkeynes@910:             SH4_WRITE_STORE_QUEUE( addr, val );
nkeynes@910:     	} else {
nkeynes@910:             sh4_write_p4( addr, val );
nkeynes@910:     	}
nkeynes@10:         return;
nkeynes@418:     } else if( (addr&0x1C000000) == 0x0C000000 ) {
nkeynes@736:         *(uint32_t *)(sh4_main_ram + (addr&0x00FFFFFF)) = val;
nkeynes@736:         xlat_invalidate_long(addr);
nkeynes@736:         return;
nkeynes@418:     } else if( (addr&0x1F800000) == 0x04000000 || 
nkeynes@736:             (addr&0x1F800000) == 0x11000000 ) {
nkeynes@736:         texcache_invalidate_page(addr& 0x7FFFFF);
nkeynes@10:         addr = TRANSLATE_VIDEO_64BIT_ADDRESS(addr);
nkeynes@736:         pvr2_render_buffer_invalidate(addr, TRUE);
nkeynes@165:     } else if( (addr&0x1F800000) == 0x05000000 ) {
nkeynes@736:         pvr2_render_buffer_invalidate(addr, TRUE);
nkeynes@10:     }
nkeynes@10: 
nkeynes@10:     if( (addr&0x1FFFFFFF) < 0x200000 ) {
nkeynes@448:         WARN( "Attempted write to read-only memory: %08X => %08X", val, addr);
nkeynes@10:         sh4_stop();
nkeynes@10:         return;
nkeynes@10:     }
nkeynes@137:     if( (addr&0x1F800000) == 0x00800000 )
nkeynes@736:         asic_g2_write_word();
nkeynes@137: 
nkeynes@10:     page = page_map[ (addr & 0x1FFFFFFF) >> 12 ];
nkeynes@504:     if( ((uintptr_t)page) < MAX_IO_REGIONS ) { /* IO Region */
nkeynes@10:         if( page == NULL ) {
nkeynes@736:             if( (addr & 0x1F000000) >= 0x04000000 &&
nkeynes@736:                     (addr & 0x1F000000) < 0x07000000 )
nkeynes@736:                 return;
nkeynes@448:             WARN( "Long write to missing page: %08X => %08X", val, addr );
nkeynes@10:             return;
nkeynes@10:         }
nkeynes@10:         TRACE_IO( "Long write %08X => %08X", page, (addr&0xFFF), val, addr );
nkeynes@504:         io_rgn[(uintptr_t)page]->io_write(addr&0xFFF, val);
nkeynes@10:     } else {
nkeynes@10:         *(uint32_t *)(page+(addr&0xFFF)) = val;
nkeynes@10:     }
nkeynes@10: }
nkeynes@10: 
nkeynes@905: void FASTCALL sh4_write_word( sh4addr_t addr, uint32_t val )
nkeynes@10: {
nkeynes@502:     sh4ptr_t page;
nkeynes@10: 
nkeynes@10:     CHECK_WRITE_WATCH(addr,2,val);
nkeynes@10: 
nkeynes@83:     if( addr >= 0xE0000000 ) {
nkeynes@10:         sh4_write_p4( addr, (int16_t)val );
nkeynes@10:         return;
nkeynes@418:     } else if( (addr&0x1C000000) == 0x0C000000 ) {
nkeynes@736:         *(uint16_t *)(sh4_main_ram + (addr&0x00FFFFFF)) = val;
nkeynes@736:         xlat_invalidate_word(addr);
nkeynes@736:         return;
nkeynes@418:     } else if( (addr&0x1F800000) == 0x04000000 ||
nkeynes@736:             (addr&0x1F800000) == 0x11000000 ) {
nkeynes@736:         texcache_invalidate_page(addr& 0x7FFFFF);
nkeynes@10:         addr = TRANSLATE_VIDEO_64BIT_ADDRESS(addr);
nkeynes@736:         pvr2_render_buffer_invalidate(addr, TRUE);
nkeynes@165:     } else if( (addr&0x1F800000) == 0x05000000 ) {
nkeynes@736:         pvr2_render_buffer_invalidate(addr, TRUE);
nkeynes@10:     }
nkeynes@406: 
nkeynes@400:     if( (addr&0x1FFFFFFF) < 0x200000 ) {
nkeynes@448:         WARN( "Attempted write to read-only memory: %08X => %08X", val, addr);
nkeynes@400:         sh4_stop();
nkeynes@400:         return;
nkeynes@400:     }
nkeynes@10:     page = page_map[ (addr & 0x1FFFFFFF) >> 12 ];
nkeynes@504:     if( ((uintptr_t)page) < MAX_IO_REGIONS ) { /* IO Region */
nkeynes@10:         if( page == NULL ) {
nkeynes@448:             WARN( "Attempted word write to missing page: %08X", addr );
nkeynes@10:             return;
nkeynes@10:         }
nkeynes@10:         TRACE_IO( "Word write %04X => %08X", page, (addr&0xFFF), val&0xFFFF, addr );
nkeynes@504:         io_rgn[(uintptr_t)page]->io_write(addr&0xFFF, val);
nkeynes@10:     } else {
nkeynes@10:         *(uint16_t *)(page+(addr&0xFFF)) = val;
nkeynes@10:     }
nkeynes@10: }
nkeynes@10: 
nkeynes@905: void FASTCALL sh4_write_byte( sh4addr_t addr, uint32_t val )
nkeynes@10: {
nkeynes@502:     sh4ptr_t page;
nkeynes@586: 
nkeynes@10:     CHECK_WRITE_WATCH(addr,1,val);
nkeynes@10: 
nkeynes@83:     if( addr >= 0xE0000000 ) {
nkeynes@10:         sh4_write_p4( addr, (int8_t)val );
nkeynes@10:         return;
nkeynes@418:     } else if( (addr&0x1C000000) == 0x0C000000 ) {
nkeynes@736:         *(uint8_t *)(sh4_main_ram + (addr&0x00FFFFFF)) = val;
nkeynes@736:         xlat_invalidate_word(addr);
nkeynes@736:         return;
nkeynes@418:     } else if( (addr&0x1F800000) == 0x04000000 ||
nkeynes@736:             (addr&0x1F800000) == 0x11000000 ) {
nkeynes@736:         texcache_invalidate_page(addr& 0x7FFFFF);
nkeynes@10:         addr = TRANSLATE_VIDEO_64BIT_ADDRESS(addr);
nkeynes@736:         pvr2_render_buffer_invalidate(addr, TRUE);
nkeynes@165:     } else if( (addr&0x1F800000) == 0x05000000 ) {
nkeynes@736:         pvr2_render_buffer_invalidate(addr, TRUE);
nkeynes@10:     }
nkeynes@736: 
nkeynes@400:     if( (addr&0x1FFFFFFF) < 0x200000 ) {
nkeynes@448:         WARN( "Attempted write to read-only memory: %08X => %08X", val, addr);
nkeynes@400:         sh4_stop();
nkeynes@400:         return;
nkeynes@400:     }
nkeynes@10:     page = page_map[ (addr & 0x1FFFFFFF) >> 12 ];
nkeynes@504:     if( ((uintptr_t)page) < MAX_IO_REGIONS ) { /* IO Region */
nkeynes@10:         if( page == NULL ) {
nkeynes@448:             WARN( "Attempted byte write to missing page: %08X", addr );
nkeynes@10:             return;
nkeynes@10:         }
nkeynes@10:         TRACE_IO( "Byte write %02X => %08X", page, (addr&0xFFF), val&0xFF, addr );
nkeynes@504:         io_rgn[(uintptr_t)page]->io_write( (addr&0xFFF), val);
nkeynes@10:     } else {
nkeynes@10:         *(uint8_t *)(page+(addr&0xFFF)) = val;
nkeynes@10:     }
nkeynes@10: }
nkeynes@10: 
nkeynes@10: 
nkeynes@10: 
nkeynes@10: /* FIXME: Handle all the many special cases when the range doesn't fall cleanly
nkeynes@400:  * into the same memory block
nkeynes@10:  */
nkeynes@912: void mem_copy_from_sh4( sh4ptr_t dest, sh4addr_t srcaddr, size_t count ) {
nkeynes@103:     if( srcaddr >= 0x04000000 && srcaddr < 0x05000000 ) {
nkeynes@736:         pvr2_vram64_read( dest, srcaddr, count );
nkeynes@103:     } else {
nkeynes@736:         sh4ptr_t src = mem_get_region(srcaddr);
nkeynes@736:         if( src == NULL ) {
nkeynes@736:             WARN( "Attempted block read from unknown address %08X", srcaddr );
nkeynes@736:         } else {
nkeynes@736:             memcpy( dest, src, count );
nkeynes@736:         }
nkeynes@103:     }
nkeynes@10: }
nkeynes@10: 
nkeynes@912: void mem_copy_to_sh4( sh4addr_t destaddr, sh4ptr_t src, size_t count ) {
nkeynes@325:     if( destaddr >= 0x10000000 && destaddr < 0x14000000 ) {
nkeynes@736:         pvr2_dma_write( destaddr, src, count );
nkeynes@736:         return;
nkeynes@325:     } else if( (destaddr & 0x1F800000) == 0x05000000 ) {
nkeynes@736:         pvr2_render_buffer_invalidate( destaddr, TRUE );
nkeynes@325:     } else if( (destaddr & 0x1F800000) == 0x04000000 ) {
nkeynes@736:         pvr2_vram64_write( destaddr, src, count );
nkeynes@736:         return;
nkeynes@325:     }
nkeynes@502:     sh4ptr_t dest = mem_get_region(destaddr);
nkeynes@325:     if( dest == NULL )
nkeynes@736:         WARN( "Attempted block write to unknown address %08X", destaddr );
nkeynes@325:     else {
nkeynes@736:         xlat_invalidate_block( destaddr, count );
nkeynes@736:         memcpy( dest, src, count );
nkeynes@90:     }
nkeynes@10: }
nkeynes@369: 
nkeynes@586: sh4ptr_t sh4_get_region_by_vma( sh4addr_t vma )
nkeynes@369: {
nkeynes@598:     sh4addr_t addr = mmu_vma_to_phys_read(vma);
nkeynes@598:     if( addr == MMU_VMA_ERROR ) {
nkeynes@736:         return NULL;
nkeynes@586:     }
nkeynes@586: 
nkeynes@586:     sh4ptr_t page = page_map[ (addr & 0x1FFFFFFF) >> 12 ];
nkeynes@586:     if( ((uintptr_t)page) < MAX_IO_REGIONS ) { /* IO Region */
nkeynes@586:         return NULL;
nkeynes@586:     } else {
nkeynes@586:         return page+(addr&0xFFF);
nkeynes@586:     }
nkeynes@369: }
nkeynes@586: