| 1 | // |
| 2 | // MEMORY.H: Header file |
| 3 | // |
| 4 | // All Jaguar related memory and I/O locations are contained in this file |
| 5 | // |
| 6 | // JPM = Jean-Paul Mari <djipi.mari@gmail.com> |
| 7 | // |
| 8 | // Who When What |
| 9 | // --- ---------- ------------------------------------------------------------- |
| 10 | // JPM 06/16/2016 Added a Big to Little endian |
| 11 | // |
| 12 | |
| 13 | #ifndef __MEMORY_H__ |
| 14 | #define __MEMORY_H__ |
| 15 | |
| 16 | #include <stdint.h> |
| 17 | |
| 18 | extern uint8_t jagMemSpace[]; |
| 19 | |
| 20 | extern uint8_t * jaguarMainRAM; |
| 21 | extern uint8_t * jaguarMainROM; |
| 22 | extern uint8_t * gpuRAM; |
| 23 | extern uint8_t * dspRAM; |
| 24 | |
| 25 | #if 1 |
| 26 | extern uint32_t & butch, & dscntrl; |
| 27 | extern uint16_t & ds_data; |
| 28 | extern uint32_t & i2cntrl, & sbcntrl, & subdata, & subdatb, & sb_time, & fifo_data, & i2sdat2, & unknown; |
| 29 | #else |
| 30 | extern uint32_t butch, dscntrl, ds_data, i2cntrl, sbcntrl, subdata, subdatb, sb_time, fifo_data, i2sdat2, unknown; |
| 31 | #endif |
| 32 | |
| 33 | extern uint16_t & memcon1, & memcon2, & hc, & vc, & lph, & lpv; |
| 34 | extern uint64_t & obData; |
| 35 | extern uint32_t & olp; |
| 36 | extern uint16_t & obf, & vmode, & bord1, & bord2, & hp, & hbb, & hbe, & hs, |
| 37 | & hvs, & hdb1, & hdb2, & hde, & vp, & vbb, & vbe, & vs, & vdb, & vde, |
| 38 | & veb, & vee, & vi, & pit0, & pit1, & heq; |
| 39 | extern uint32_t & bg; |
| 40 | extern uint16_t & int1, & int2; |
| 41 | extern uint8_t * clut, * lbuf; |
| 42 | extern uint32_t & g_flags, & g_mtxc, & g_mtxa, & g_end, & g_pc, & g_ctrl, |
| 43 | & g_hidata, & g_divctrl; |
| 44 | extern uint32_t g_remain; |
| 45 | extern uint32_t & a1_base, & a1_flags, & a1_clip, & a1_pixel, & a1_step, |
| 46 | & a1_fstep, & a1_fpixel, & a1_inc, & a1_finc, & a2_base, & a2_flags, |
| 47 | & a2_mask, & a2_pixel, & a2_step, & b_cmd, & b_count; |
| 48 | extern uint64_t & b_srcd, & b_dstd, & b_dstz, & b_srcz1, & b_srcz2, & b_patd; |
| 49 | extern uint32_t & b_iinc, & b_zinc, & b_stop, & b_i3, & b_i2, & b_i1, & b_i0, & b_z3, |
| 50 | & b_z2, & b_z1, & b_z0; |
| 51 | extern uint16_t & jpit1, & jpit2, & jpit3, & jpit4, & clk1, & clk2, & clk3, & j_int, |
| 52 | & asidata, & asictrl; |
| 53 | extern uint16_t asistat; |
| 54 | extern uint16_t & asiclk, & joystick, & joybuts; |
| 55 | extern uint32_t & d_flags, & d_mtxc, & d_mtxa, & d_end, & d_pc, & d_ctrl, |
| 56 | & d_mod, & d_divctrl; |
| 57 | extern uint32_t d_remain; |
| 58 | extern uint32_t & d_machi; |
| 59 | extern uint16_t & ltxd, lrxd, & rtxd, rrxd; |
| 60 | extern uint8_t & sclk, sstat; |
| 61 | extern uint32_t & smode; |
| 62 | /* |
| 63 | uint16_t & ltxd = *((uint16_t *)&jagMemSpace[0xF1A148]); |
| 64 | uint16_t lrxd; // Dual register with $F1A148 |
| 65 | uint16_t & rtxd = *((uint16_t *)&jagMemSpace[0xF1A14C]); |
| 66 | uint16_t rrxd; // Dual register with $F1A14C |
| 67 | uint8_t & sclk = *((uint8_t *) &jagMemSpace[0xF1A150]); |
| 68 | uint8_t sstat; // Dual register with $F1A150 |
| 69 | uint32_t & smode = *((uint32_t *)&jagMemSpace[0xF1A154]); |
| 70 | */ |
| 71 | |
| 72 | // Read/write tracing enumeration |
| 73 | |
| 74 | enum { UNKNOWN, JAGUAR, DSP, GPU, TOM, JERRY, M68K, BLITTER, OP, DEBUG }; |
| 75 | extern const char * whoName[10]; |
| 76 | |
| 77 | // BIOS identification enum |
| 78 | |
| 79 | //enum { BIOS_NORMAL=0x01, BIOS_CD=0x02, BIOS_STUB1=0x04, BIOS_STUB2=0x08, BIOS_DEV_CD=0x10 }; |
| 80 | //extern int biosAvailable; |
| 81 | |
| 82 | // Some handy macros to help converting native endian to big endian (jaguar native) |
| 83 | // & vice versa |
| 84 | |
| 85 | #define SET64(r, a, v) r[(a)] = ((v) & 0xFF00000000000000) >> 56, r[(a)+1] = ((v) & 0x00FF000000000000) >> 48, \ |
| 86 | r[(a)+2] = ((v) & 0x0000FF0000000000) >> 40, r[(a)+3] = ((v) & 0x000000FF00000000) >> 32, \ |
| 87 | r[(a)+4] = ((v) & 0xFF000000) >> 24, r[(a)+5] = ((v) & 0x00FF0000) >> 16, \ |
| 88 | r[(a)+6] = ((v) & 0x0000FF00) >> 8, r[(a)+7] = (v) & 0x000000FF |
| 89 | #define GET64(r, a) (((uint64_t)r[(a)] << 56) | ((uint64_t)r[(a)+1] << 48) | \ |
| 90 | ((uint64_t)r[(a)+2] << 40) | ((uint64_t)r[(a)+3] << 32) | \ |
| 91 | ((uint64_t)r[(a)+4] << 24) | ((uint64_t)r[(a)+5] << 16) | \ |
| 92 | ((uint64_t)r[(a)+6] << 8) | (uint64_t)r[(a)+7]) |
| 93 | #define SET32(r, a, v) r[(a)] = ((v) & 0xFF000000) >> 24, r[(a)+1] = ((v) & 0x00FF0000) >> 16, \ |
| 94 | r[(a)+2] = ((v) & 0x0000FF00) >> 8, r[(a)+3] = (v) & 0x000000FF |
| 95 | #define GET32(r, a) ((r[(a)] << 24) | (r[(a)+1] << 16) | (r[(a)+2] << 8) | r[(a)+3]) |
| 96 | #define SET16(r, a, v) r[(a)] = ((v) & 0xFF00) >> 8, r[(a)+1] = (v) & 0xFF |
| 97 | #define GET16(r, a) ((r[(a)] << 8) | r[(a)+1]) |
| 98 | |
| 99 | #define BigToLittleEndian16(a) (((a & 0xFF) << 8) | (a >> 8)) |
| 100 | #define BigToLittleEndian32(a) (((a & 0xFF) << 24) | ((a & 0xFF00) << 8) | ((a & 0xFF0000) >> 8) | ((a & 0xFF000000) >> 24)) |
| 101 | |
| 102 | //This doesn't seem to work on OSX. So have to figure something else out. :-( |
| 103 | //byteswap.h doesn't exist on OSX. |
| 104 | #if 0 |
| 105 | // This is GCC specific, but we can fix that if we need to... |
| 106 | // Big plus of this approach is that these compile down to single instructions on little |
| 107 | // endian machines while one big endian machines we don't have any overhead. :-) |
| 108 | |
| 109 | #include <byteswap.h> |
| 110 | #include <endian.h> |
| 111 | |
| 112 | #if __BYTE_ORDER == __LITTLE_ENDIAN |
| 113 | #define ESAFE16(x) bswap_16(x) |
| 114 | #define ESAFE32(x) bswap_32(x) |
| 115 | #define ESAFE64(x) bswap_64(x) |
| 116 | #else |
| 117 | #define ESAFE16(x) (x) |
| 118 | #define ESAFE32(x) (x) |
| 119 | #define ESAFE64(x) (x) |
| 120 | #endif |
| 121 | #endif |
| 122 | |
| 123 | #if 0 |
| 124 | Stuff ripped out of Hatari, that may be useful: |
| 125 | |
| 126 | /* Can the actual CPU access unaligned memory? */ |
| 127 | #ifndef CPU_CAN_ACCESS_UNALIGNED |
| 128 | # if defined(__i386__) || defined(powerpc) || defined(__mc68020__) |
| 129 | # define CPU_CAN_ACCESS_UNALIGNED 1 |
| 130 | # else |
| 131 | # define CPU_CAN_ACCESS_UNALIGNED 0 |
| 132 | # endif |
| 133 | #endif |
| 134 | |
| 135 | |
| 136 | /* If the CPU can access unaligned memory, use these accelerated functions: */ |
| 137 | #if CPU_CAN_ACCESS_UNALIGNED |
| 138 | |
| 139 | #include <SDL_endian.h> |
| 140 | |
| 141 | |
| 142 | static inline uae_u32 do_get_mem_long(void *a) |
| 143 | { |
| 144 | return SDL_SwapBE32(*(uae_u32 *)a); |
| 145 | } |
| 146 | |
| 147 | static inline uae_u16 do_get_mem_word(void *a) |
| 148 | { |
| 149 | return SDL_SwapBE16(*(uae_u16 *)a); |
| 150 | } |
| 151 | |
| 152 | |
| 153 | static inline void do_put_mem_long(void *a, uae_u32 v) |
| 154 | { |
| 155 | *(uae_u32 *)a = SDL_SwapBE32(v); |
| 156 | } |
| 157 | |
| 158 | static inline void do_put_mem_word(void *a, uae_u16 v) |
| 159 | { |
| 160 | *(uae_u16 *)a = SDL_SwapBE16(v); |
| 161 | } |
| 162 | |
| 163 | |
| 164 | #else /* Cpu can not access unaligned memory: */ |
| 165 | |
| 166 | |
| 167 | static inline uae_u32 do_get_mem_long(void *a) |
| 168 | { |
| 169 | uae_u8 *b = (uae_u8 *)a; |
| 170 | |
| 171 | return (b[0] << 24) | (b[1] << 16) | (b[2] << 8) | b[3]; |
| 172 | } |
| 173 | |
| 174 | static inline uae_u16 do_get_mem_word(void *a) |
| 175 | { |
| 176 | uae_u8 *b = (uae_u8 *)a; |
| 177 | |
| 178 | return (b[0] << 8) | b[1]; |
| 179 | } |
| 180 | |
| 181 | |
| 182 | static inline void do_put_mem_long(void *a, uae_u32 v) |
| 183 | { |
| 184 | uae_u8 *b = (uae_u8 *)a; |
| 185 | |
| 186 | b[0] = v >> 24; |
| 187 | b[1] = v >> 16; |
| 188 | b[2] = v >> 8; |
| 189 | b[3] = v; |
| 190 | } |
| 191 | |
| 192 | static inline void do_put_mem_word(void *a, uae_u16 v) |
| 193 | { |
| 194 | uae_u8 *b = (uae_u8 *)a; |
| 195 | |
| 196 | b[0] = v >> 8; |
| 197 | b[1] = v; |
| 198 | } |
| 199 | |
| 200 | |
| 201 | #endif /* CPU_CAN_ACCESS_UNALIGNED */ |
| 202 | |
| 203 | |
| 204 | /* These are same for all architectures: */ |
| 205 | |
| 206 | static inline uae_u8 do_get_mem_byte(uae_u8 *a) |
| 207 | { |
| 208 | return *a; |
| 209 | } |
| 210 | |
| 211 | static inline void do_put_mem_byte(uae_u8 *a, uae_u8 v) |
| 212 | { |
| 213 | *a = v; |
| 214 | } |
| 215 | #endif |
| 216 | |
| 217 | #endif // __MEMORY_H__ |