Return to ioMem.h CVS log

Up to [HATARI the Atari ST Emulator] / hatari / src / includes

Annotation of hatari/src/includes/ioMem.h, revision 1.1.1.6

1.1       root        1: /*
                      2:   Hatari - ioMem.h
                      3: 
1.1.1.6 ! root        4:   This file is distributed under the GNU General Public License, version 2
        !             5:   or at your option any later version. Read the file gpl.txt for details.
1.1       root        6: */
                      7: 
                      8: #ifndef HATARI_IOMEM_H
                      9: #define HATARI_IOMEM_H
                     10: 
1.1.1.3   root       11: #include "config.h"
                     12: 
                     13: #if ENABLE_SMALL_MEM
                     14: # include "sysdeps.h"
                     15: # include "maccess.h"
                     16: # include "main.h"
                     17: extern uae_u8 *IOmemory;
                     18: # define IoMem (IOmemory-0xff0000)
1.1       root       19: #else
1.1.1.3   root       20: # include "stMemory.h"
                     21: # define IoMem STRam
                     22: #endif  /* ENABLE_SMALL_MEM */
1.1       root       23: 
                     24: 
                     25: extern Uint32 IoAccessBaseAddress;
1.1.1.3   root       26: extern Uint32 IoAccessCurrentAddress;
1.1       root       27: extern int nIoMemAccessSize;
                     28: 
                     29: 
1.1.1.4   root       30: /**
                     31:  * Read 32-bit word from IO memory space without interception.
                     32:  * NOTE - value will be converted to PC endian.
                     33:  */
1.1       root       34: static inline Uint32 IoMem_ReadLong(Uint32 Address)
                     35: {
                     36:        Address &= 0x0ffffff;
                     37:        return do_get_mem_long(&IoMem[Address]);
                     38: }
                     39: 
1.1.1.4   root       40: 
                     41: /**
                     42:  * Read 16-bit word from IO memory space without interception.
                     43:  * NOTE - value will be converted to PC endian.
                     44:  */
1.1       root       45: static inline Uint16 IoMem_ReadWord(Uint32 Address)
                     46: {
                     47:        Address &= 0x0ffffff;
                     48:        return do_get_mem_word(&IoMem[Address]);
                     49: }
                     50: 
1.1.1.4   root       51: 
                     52: /**
                     53:  * Read 8-bit byte from IO memory space without interception.
                     54:  */
1.1       root       55: static inline Uint8 IoMem_ReadByte(Uint32 Address)
                     56: {
                     57:        Address &= 0x0ffffff;
                     58:        return IoMem[Address];
                     59: }
                     60: 
                     61: 
1.1.1.4   root       62: /**
                     63:  * Write 32-bit word into IO memory space without interception.
                     64:  * NOTE - value will be convert to 68000 endian
                     65:  */
1.1       root       66: static inline void IoMem_WriteLong(Uint32 Address, Uint32 Var)
                     67: {
                     68:        Address &= 0x0ffffff;
                     69:        do_put_mem_long(&IoMem[Address], Var);
                     70: }
                     71: 
1.1.1.4   root       72: 
                     73: /**
                     74:  * Write 16-bit word into IO memory space without interception.
                     75:  * NOTE - value will be convert to 68000 endian.
                     76:  */
1.1       root       77: static inline void IoMem_WriteWord(Uint32 Address, Uint16 Var)
                     78: {
                     79:        Address &= 0xffffff;
                     80:        do_put_mem_word(&IoMem[Address], Var);
                     81: }
                     82: 
1.1.1.4   root       83: 
                     84: /**
                     85:  * Write 8-bit byte into IO memory space without interception.
                     86:  */
1.1       root       87: static inline void IoMem_WriteByte(Uint32 Address, Uint8 Var)
                     88: {
                     89:        Address &= 0x0ffffff;
                     90:        IoMem[Address] = Var;
                     91: }
                     92: 
                     93: 
                     94: extern void IoMem_Init(void);
                     95: extern void IoMem_UnInit(void);
1.1.1.5   root       96: extern void IoMem_Init_FalconInSTeBuscompatibilityMode(Uint8 value);
                     97: 
1.1       root       98: 
                     99: extern uae_u32 IoMem_bget(uaecptr addr);
                    100: extern uae_u32 IoMem_wget(uaecptr addr);
                    101: extern uae_u32 IoMem_lget(uaecptr addr);
                    102: 
                    103: extern void IoMem_bput(uaecptr addr, uae_u32 val);
                    104: extern void IoMem_wput(uaecptr addr, uae_u32 val);
                    105: extern void IoMem_lput(uaecptr addr, uae_u32 val);
                    106: 
                    107: extern void IoMem_BusErrorEvenReadAccess(void);
                    108: extern void IoMem_BusErrorOddReadAccess(void);
                    109: extern void IoMem_BusErrorEvenWriteAccess(void);
                    110: extern void IoMem_BusErrorOddWriteAccess(void);
                    111: extern void IoMem_VoidRead(void);
1.1.1.5   root      112: extern void IoMem_VoidRead_00(void);
1.1       root      113: extern void IoMem_VoidWrite(void);
                    114: extern void IoMem_WriteWithoutInterception(void);
                    115: extern void IoMem_ReadWithoutInterception(void);
                    116: 
1.1.1.5   root      117: extern void IoMem_MemorySnapShot_Capture(bool bSave);
                    118: 
1.1       root      119: #endif

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.