1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
|
/* gameplaySP
*
* Copyright (C) 2006 Exophase <exophase@gmail.com>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef MEMORY_H
#define MEMORY_H
#include "libretro.h"
typedef enum
{
DMA_START_IMMEDIATELY,
DMA_START_VBLANK,
DMA_START_HBLANK,
DMA_START_SPECIAL,
DMA_INACTIVE
} dma_start_type;
typedef enum
{
DMA_16BIT,
DMA_32BIT
} dma_length_type;
typedef enum
{
DMA_NO_REPEAT,
DMA_REPEAT
} dma_repeat_type;
typedef enum
{
DMA_INCREMENT,
DMA_DECREMENT,
DMA_FIXED,
DMA_RELOAD
} dma_increment_type;
typedef enum
{
DMA_NO_IRQ,
DMA_TRIGGER_IRQ
} dma_irq_type;
typedef enum
{
DMA_DIRECT_SOUND_A,
DMA_DIRECT_SOUND_B,
DMA_NO_DIRECT_SOUND
} dma_ds_type;
typedef struct
{
u32 dma_channel;
u32 source_address;
u32 dest_address;
u32 length;
dma_repeat_type repeat_type;
dma_ds_type direct_sound_channel;
dma_increment_type source_direction;
dma_increment_type dest_direction;
dma_length_type length_type;
dma_start_type start_type;
dma_irq_type irq;
} dma_transfer_type;
typedef enum
{
REG_DISPCNT = 0x000,
REG_DISPSTAT = 0x002,
REG_VCOUNT = 0x003,
REG_BG0CNT = 0x004,
REG_BG1CNT = 0x005,
REG_BG2CNT = 0x006,
REG_BG3CNT = 0x007,
REG_BG0HOFS = 0x08,
REG_BG0VOFS = 0x09,
REG_BG1HOFS = 0x0A,
REG_BG1VOFS = 0x0B,
REG_BG2HOFS = 0x0C,
REG_BG2VOFS = 0x0D,
REG_BG3HOFS = 0x0E,
REG_BG3VOFS = 0x0F,
REG_BG2PA = 0x10,
REG_BG2PB = 0x11,
REG_BG2PC = 0x12,
REG_BG2PD = 0x13,
REG_BG2X_L = 0x14,
REG_BG2X_H = 0x15,
REG_BG2Y_L = 0x16,
REG_BG2Y_H = 0x17,
REG_BG3PA = 0x18,
REG_BG3PB = 0x19,
REG_BG3PC = 0x1A,
REG_BG3PD = 0x1B,
REG_BG3X_L = 0x1C,
REG_BG3X_H = 0x1D,
REG_BG3Y_L = 0x1E,
REG_BG3Y_H = 0x1F,
REG_WIN0H = 0x20,
REG_WIN1H = 0x21,
REG_WIN0V = 0x22,
REG_WIN1V = 0x23,
REG_WININ = 0x24,
REG_WINOUT = 0x25,
REG_BLDCNT = 0x28,
REG_BLDALPHA = 0x29,
REG_BLDY = 0x2A,
REG_TM0D = 0x80,
REG_TM0CNT = 0x81,
REG_TM1D = 0x82,
REG_TM1CNT = 0x83,
REG_TM2D = 0x84,
REG_TM2CNT = 0x85,
REG_TM3D = 0x86,
REG_TM3CNT = 0x87,
REG_P1 = 0x098,
REG_P1CNT = 0x099,
REG_RCNT = 0x9A,
REG_IE = 0x100,
REG_IF = 0x101,
REG_IME = 0x104,
REG_HALTCNT = 0x180
} hardware_register;
typedef enum
{
FLASH_DEVICE_MACRONIX_64KB = 0x1C,
FLASH_DEVICE_AMTEL_64KB = 0x3D,
FLASH_DEVICE_SST_64K = 0xD4,
FLASH_DEVICE_PANASONIC_64KB = 0x1B,
FLASH_DEVICE_MACRONIX_128KB = 0x09
} flash_device_id_type;
typedef enum
{
FLASH_MANUFACTURER_MACRONIX = 0xC2,
FLASH_MANUFACTURER_AMTEL = 0x1F,
FLASH_MANUFACTURER_PANASONIC = 0x32,
FLASH_MANUFACTURER_SST = 0xBF
} flash_manufacturer_id_type;
u8 read_memory8(u32 address);
u32 read_memory16(u32 address);
u16 read_memory16_signed(u32 address);
u32 read_memory32(u32 address);
cpu_alert_type write_memory8(u32 address, u8 value);
cpu_alert_type write_memory16(u32 address, u16 value);
cpu_alert_type write_memory32(u32 address, u32 value);
extern u8 *memory_regions[16];
extern u32 memory_limits[16];
/* EDIT: Shouldn't this be extern ?! */
extern u32 waitstate_cycles_sequential[16][3];
extern u32 gamepak_size;
extern char gamepak_title[13];
extern char gamepak_code[5];
extern char gamepak_maker[3];
extern char gamepak_filename[512];
cpu_alert_type dma_transfer(dma_transfer_type *dma);
u8 *memory_region(u32 address, u32 *memory_limit);
u32 load_gamepak(const struct retro_game_info* info, const char *name);
u32 load_backup(char *name);
s32 load_bios(char *name);
void update_backup(void);
void init_memory(void);
void init_gamepak_buffer(void);
void memory_term(void);
void bios_region_read_allow(void);
void bios_region_read_protect(void);
u8 *load_gamepak_page(u32 physical_index);
extern u8 *gamepak_rom;
extern u32 gamepak_ram_buffer_size;
extern u32 oam_update;
extern u32 gbc_sound_update;
extern u32 gbc_sound_wave_update;
extern dma_transfer_type dma[4];
extern u16 palette_ram[512];
extern u16 oam_ram[512];
extern u16 palette_ram_converted[512];
extern u16 io_registers[1024 * 16];
extern u8 ewram[1024 * 256 * 2];
extern u8 iwram[1024 * 32 * 2];
extern u8 vram[1024 * 96 * 2];
extern u8 bios_rom[1024 * 32];
extern u32 bios_read_protect;
extern u8 *memory_map_read[8 * 1024];
extern u32 *reg;
extern u8 *memory_map_write[8 * 1024];
extern flash_device_id_type flash_device_id;
extern const u8 *state_mem_read_ptr;
extern u8 *state_mem_write_ptr;
static inline void state_mem_write(const void* src, size_t size)
{
memcpy(state_mem_write_ptr, src, size);
state_mem_write_ptr += size;
}
/* this is an upper limit, ToDo : calculate the exact state size */
#define GBA_STATE_MEM_SIZE (512*1024)
#define state_mem_write_array(array) state_mem_write(array, sizeof(array))
#define state_mem_write_variable(variable) state_mem_write(&variable, sizeof(variable))
static inline void state_mem_read(void* dst, size_t size)
{
memcpy(dst, state_mem_read_ptr, size);
state_mem_read_ptr += size;
}
#define state_mem_read_array(array) state_mem_read(array, sizeof(array))
#define state_mem_read_variable(variable) state_mem_read(&variable, sizeof(variable))
void memory_write_savestate(void);
void memory_read_savestate(void);
void gba_load_state(const void *src);
void gba_save_state(void *dst);
#endif
|
