← Back to branch summary

~ubuntu-branches/ubuntu/quantal/vice/quantal

« back to all changes in this revision

Viewing changes to src/c64/cart/c64cartmem.c

  • Committer: Bazaar Package Importer
  • Author(s): Laszlo Boszormenyi (GCS)
  • Date: 2010-02-11 18:30:16 UTC
  • mfrom: (1.1.8 upstream) (9.2.2 sid)
  • Revision ID: james.westby@ubuntu.com-20100211183016-f6n8usn3tzp0u6dp
Tags: 2.2.dfsg-1
* New upstream release, C64 DTV is included so update package description
  and add it to the menu.
* Drop patch fixing build failure with gcc-4.4 , applied upstream.
* Fix some lintian problems and clean up debian/rules .

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/c64/cart/c64cartmem.c
46
46
#include "delaep64.h"
47
47
#include "delaep7x8.h"
48
48
#include "dqbb.h"
 
49
#include "easyflash.h"
49
50
#include "epyxfastload.h"
50
51
#include "expert.h"
51
52
#include "final.h"
72
73
#include "vicii-phi1.h"
73
74
#include "zaxxon.h"
74
75
 
75
 
 
76
76
/* #define DEBUG */
77
77
 
78
78
/* Expansion port signals.  */
79
79
export_t export;
80
80
 
81
81
/* Expansion port ROML/ROMH images.  */
82
 
BYTE roml_banks[0x80000], romh_banks[0x20000];
 
82
BYTE roml_banks[0x80000], romh_banks[0x80000];
83
83
 
84
84
/* Expansion port RAM images.  */
85
85
BYTE export_ram0[C64CART_RAM_LIMIT];
100
100
  mode & 3 = 2 : ram
101
101
  mode & 3 = 3 : ultimax
102
102
*/
103
 
void cartridge_config_changed(BYTE mode_phi1, BYTE mode_phi2,
104
 
                              unsigned int wflag)
 
103
void cartridge_config_changed(BYTE mode_phi1, BYTE mode_phi2, unsigned int wflag)
105
104
{
106
 
    if (wflag == CMODE_WRITE)
 
105
    if (wflag == CMODE_WRITE) {
107
106
        machine_handle_pending_alarms(maincpu_rmw_flag + 1);
108
 
    else
 
107
    } else {
109
108
        machine_handle_pending_alarms(0);
 
109
    }
110
110
 
111
111
    export.game = mode_phi2 & 1;
112
112
    export.exrom = ((mode_phi2 >> 1) & 1) ^ 1;
114
114
    cartridge_romlbank_set((mode_phi2 >> 3) & 3);
115
115
    export_ram = (mode_phi2 >> 5) & 1;
116
116
    mem_pla_config_changed();
117
 
    if (mode_phi2 & 0x40)
 
117
    if (mode_phi2 & 0x40) {
118
118
        cartridge_release_freeze();
 
119
    }
119
120
    cart_ultimax_phi1 = (mode_phi1 & 1) & ((mode_phi1 >> 1) & 1);
120
 
    cart_ultimax_phi2 = export.game & (export.exrom ^ 1)
121
 
                        & ((~mode_phi1 >> 2) & 1);
 
121
    cart_ultimax_phi2 = export.game & (export.exrom ^ 1) & ((~mode_phi1 >> 2) & 1);
122
122
    machine_update_memory_ptrs();
123
123
}
124
124
 
128
128
    log_debug("Read IO1 %02x.", addr);
129
129
#endif
130
130
    switch (mem_cartridge_type) {
131
 
      case CARTRIDGE_STARDOS:
132
 
        return stardos_io1_read(addr);
133
 
      case CARTRIDGE_ACTION_REPLAY3:
134
 
        return actionreplay3_io1_read(addr);
135
 
      case CARTRIDGE_ACTION_REPLAY:
136
 
        return actionreplay_io1_read(addr);
137
 
      case CARTRIDGE_ATOMIC_POWER:
138
 
        return atomicpower_io1_read(addr);
139
 
      case CARTRIDGE_RETRO_REPLAY:
140
 
        return retroreplay_io1_read(addr);
141
 
      case CARTRIDGE_IDE64:
142
 
        return ide64_io1_read(addr);
143
 
      case CARTRIDGE_KCS_POWER:
144
 
        return kcs_io1_read(addr);
145
 
      case CARTRIDGE_FINAL_III:
146
 
        return final_v3_io1_read(addr);
147
 
      case CARTRIDGE_FINAL_I:
148
 
        return final_v1_io1_read(addr);
149
 
      case CARTRIDGE_MIKRO_ASSEMBLER:
150
 
        return mikroass_io1_read(addr);
151
 
      case CARTRIDGE_SIMONS_BASIC:
152
 
      case CARTRIDGE_GS:
153
 
        cartridge_config_changed(0, 0, CMODE_READ);
154
 
        return vicii_read_phi1();
155
 
      case CARTRIDGE_WARPSPEED:
156
 
        io_source=IO_SOURCE_WARPSPEED;
157
 
        return roml_banks[0x1e00 + (addr & 0xff)];
158
 
      case CARTRIDGE_DINAMIC:
159
 
        cartridge_romlbank_set(addr & 0x0f);
160
 
        break;
161
 
      case CARTRIDGE_SUPER_SNAPSHOT:
162
 
        return supersnapshot_v4_io1_read(addr);
163
 
      case CARTRIDGE_SUPER_SNAPSHOT_V5:
164
 
        return supersnapshot_v5_io1_read(addr);
165
 
      case CARTRIDGE_EXPERT:
166
 
        return expert_io1_read(addr);
167
 
      case CARTRIDGE_MAGIC_FORMEL:
168
 
        return magicformel_io1_read(addr);
169
 
      case CARTRIDGE_ROSS:
170
 
        return ross_io1_read(addr);
171
 
      case CARTRIDGE_STRUCTURED_BASIC:
172
 
        return stb_io1_read(addr);
173
 
      case CARTRIDGE_DELA_EP64:
174
 
        return delaep64_io1_read(addr);
 
131
        case CARTRIDGE_STARDOS:
 
132
            return stardos_io1_read(addr);
 
133
        case CARTRIDGE_ACTION_REPLAY3:
 
134
            return actionreplay3_io1_read(addr);
 
135
        case CARTRIDGE_ACTION_REPLAY:
 
136
            return actionreplay_io1_read(addr);
 
137
        case CARTRIDGE_ATOMIC_POWER:
 
138
            return atomicpower_io1_read(addr);
 
139
        case CARTRIDGE_RETRO_REPLAY:
 
140
            return retroreplay_io1_read(addr);
 
141
        case CARTRIDGE_IDE64:
 
142
            return ide64_io1_read(addr);
 
143
        case CARTRIDGE_KCS_POWER:
 
144
            return kcs_io1_read(addr);
 
145
        case CARTRIDGE_FINAL_III:
 
146
            return final_v3_io1_read(addr);
 
147
        case CARTRIDGE_FINAL_I:
 
148
            return final_v1_io1_read(addr);
 
149
        case CARTRIDGE_MIKRO_ASSEMBLER:
 
150
            return mikroass_io1_read(addr);
 
151
        case CARTRIDGE_SIMONS_BASIC:
 
152
        case CARTRIDGE_GS:
 
153
            cartridge_config_changed(0, 0, CMODE_READ);
 
154
            return vicii_read_phi1();
 
155
        case CARTRIDGE_WARPSPEED:
 
156
            io_source = IO_SOURCE_WARPSPEED;
 
157
            return roml_banks[0x1e00 + (addr & 0xff)];
 
158
        case CARTRIDGE_DINAMIC:
 
159
            cartridge_romlbank_set(addr & 0x0f);
 
160
            break;
 
161
        case CARTRIDGE_SUPER_SNAPSHOT:
 
162
            return supersnapshot_v4_io1_read(addr);
 
163
        case CARTRIDGE_SUPER_SNAPSHOT_V5:
 
164
            return supersnapshot_v5_io1_read(addr);
 
165
        case CARTRIDGE_EXPERT:
 
166
            return expert_io1_read(addr);
 
167
        case CARTRIDGE_MAGIC_FORMEL:
 
168
            return magicformel_io1_read(addr);
 
169
        case CARTRIDGE_ROSS:
 
170
            return ross_io1_read(addr);
 
171
        case CARTRIDGE_STRUCTURED_BASIC:
 
172
            return stb_io1_read(addr);
 
173
        case CARTRIDGE_DELA_EP64:
 
174
            return delaep64_io1_read(addr);
175
175
    }
176
176
    return vicii_read_phi1();
177
177
}
183
183
#endif
184
184
 
185
185
    switch (mem_cartridge_type) {
186
 
      case CARTRIDGE_ACTION_REPLAY4:
187
 
        actionreplay4_io1_store(addr, value);
188
 
        break;
189
 
      case CARTRIDGE_ACTION_REPLAY3:
190
 
        actionreplay3_io1_store(addr, value);
191
 
        break;
192
 
      case CARTRIDGE_ACTION_REPLAY:
193
 
        actionreplay_io1_store(addr, value);
194
 
        break;
195
 
      case CARTRIDGE_RETRO_REPLAY:
196
 
        retroreplay_io1_store(addr, value);
197
 
        break;
198
 
      case CARTRIDGE_IDE64:
199
 
        ide64_io1_store(addr, value);
200
 
        break;
201
 
      case CARTRIDGE_ATOMIC_POWER:
202
 
        atomicpower_io1_store(addr, value);
203
 
        break;
204
 
      case CARTRIDGE_KCS_POWER:
205
 
        kcs_io1_store(addr, value);
206
 
        break;
207
 
      case CARTRIDGE_FINAL_I:
208
 
        final_v1_io1_store(addr, value);
209
 
        break;
210
 
      case CARTRIDGE_FINAL_III:
211
 
        final_v3_io1_store(addr, value);
212
 
        break;
213
 
      case CARTRIDGE_COMAL80:
214
 
        comal80_io1_store(addr, value);
215
 
        break;
216
 
      case CARTRIDGE_SIMONS_BASIC:
217
 
        cartridge_config_changed(1, 1, CMODE_WRITE);
218
 
        break;
219
 
      case CARTRIDGE_WARPSPEED:
220
 
        cartridge_config_changed(1, 1, CMODE_WRITE);
221
 
        break;
222
 
      case CARTRIDGE_SUPER_SNAPSHOT:
223
 
        supersnapshot_v4_io1_store(addr, value);
224
 
        break;
225
 
      case CARTRIDGE_SUPER_SNAPSHOT_V5:
226
 
        supersnapshot_v5_io1_store(addr, value);
227
 
        break;
228
 
      case CARTRIDGE_OCEAN:
229
 
      case CARTRIDGE_FUNPLAY:
230
 
        switch (mem_cartridge_type) {
231
 
          case CARTRIDGE_OCEAN:
232
 
            cartridge_romhbank_set(value & 0x3f);
 
186
        case CARTRIDGE_ACTION_REPLAY4:
 
187
            actionreplay4_io1_store(addr, value);
 
188
            break;
 
189
        case CARTRIDGE_ACTION_REPLAY3:
 
190
            actionreplay3_io1_store(addr, value);
 
191
            break;
 
192
        case CARTRIDGE_ACTION_REPLAY:
 
193
            actionreplay_io1_store(addr, value);
 
194
            break;
 
195
        case CARTRIDGE_RETRO_REPLAY:
 
196
            retroreplay_io1_store(addr, value);
 
197
            break;
 
198
        case CARTRIDGE_IDE64:
 
199
            ide64_io1_store(addr, value);
 
200
            break;
 
201
        case CARTRIDGE_ATOMIC_POWER:
 
202
            atomicpower_io1_store(addr, value);
 
203
            break;
 
204
        case CARTRIDGE_KCS_POWER:
 
205
            kcs_io1_store(addr, value);
 
206
            break;
 
207
        case CARTRIDGE_FINAL_I:
 
208
            final_v1_io1_store(addr, value);
 
209
            break;
 
210
        case CARTRIDGE_FINAL_III:
 
211
            final_v3_io1_store(addr, value);
 
212
            break;
 
213
        case CARTRIDGE_COMAL80:
 
214
            comal80_io1_store(addr, value);
 
215
            break;
 
216
        case CARTRIDGE_SIMONS_BASIC:
 
217
            cartridge_config_changed(1, 1, CMODE_WRITE);
 
218
            break;
 
219
        case CARTRIDGE_WARPSPEED:
 
220
            cartridge_config_changed(1, 1, CMODE_WRITE);
 
221
            break;
 
222
        case CARTRIDGE_SUPER_SNAPSHOT:
 
223
            supersnapshot_v4_io1_store(addr, value);
 
224
            break;
 
225
        case CARTRIDGE_SUPER_SNAPSHOT_V5:
 
226
            supersnapshot_v5_io1_store(addr, value);
 
227
            break;
 
228
        case CARTRIDGE_OCEAN:
 
229
        case CARTRIDGE_FUNPLAY:
 
230
            switch (mem_cartridge_type) {
 
231
                case CARTRIDGE_OCEAN:
 
232
                    cartridge_romhbank_set(value & 0x3f);
 
233
                    cartridge_romlbank_set(value & 0x3f);
 
234
                    break;
 
235
                case CARTRIDGE_FUNPLAY:
 
236
                    cartridge_romhbank_set(((value >> 2) | (value & 1)) & 15);
 
237
                    cartridge_romlbank_set(((value >> 2) | (value & 1)) & 15);
 
238
                    break;
 
239
            }
 
240
            export.game = export.exrom = 1;
 
241
            mem_pla_config_changed();
 
242
            cart_ultimax_phi1 = 0;
 
243
            cart_ultimax_phi2 = 0;
 
244
            break;
 
245
        case CARTRIDGE_GS:
 
246
            cartridge_romlbank_set(addr & 0x3f);
 
247
            export.game = 0;
 
248
            export.exrom = 1;
 
249
            break;
 
250
        case CARTRIDGE_EXPERT:
 
251
            expert_io1_store(addr, value);
 
252
            break;
 
253
        case CARTRIDGE_MAGIC_DESK:
233
254
            cartridge_romlbank_set(value & 0x3f);
234
 
            break;
235
 
          case CARTRIDGE_FUNPLAY:
236
 
            cartridge_romhbank_set(((value >> 2) | (value & 1)) & 15);
237
 
            cartridge_romlbank_set(((value >> 2) | (value & 1)) & 15);
238
 
            break;
239
 
        }
240
 
        export.game = export.exrom = 1;
241
 
        mem_pla_config_changed();
242
 
        cart_ultimax_phi1 = 0;
243
 
        cart_ultimax_phi2 = 0;
244
 
        break;
245
 
      case CARTRIDGE_GS:
246
 
        cartridge_romlbank_set(addr & 0x3f);
247
 
        export.game = 0;
248
 
        export.exrom = 1;
249
 
        break;
250
 
      case CARTRIDGE_EXPERT:
251
 
        expert_io1_store(addr, value);
252
 
        break;
253
 
      case CARTRIDGE_MAGIC_DESK:
254
 
        cartridge_romlbank_set(value & 0x3f);
255
 
        export.game = 0;
256
 
        if (value & 0x80)
257
 
            export.exrom = 0;
258
 
        else
259
 
            export.exrom = 1;  /* turn off cart ROM */
260
 
        mem_pla_config_changed();
261
 
        break;
262
 
      case CARTRIDGE_MAGIC_FORMEL:
263
 
        magicformel_io1_store(addr, value);
264
 
        break;
265
 
      case CARTRIDGE_STRUCTURED_BASIC:
266
 
        stb_io1_store(addr, value);
267
 
        break;
268
 
      case CARTRIDGE_DELA_EP64:
269
 
        delaep64_io1_store(addr, value);
270
 
        break;
271
 
      case CARTRIDGE_DELA_EP7x8:
272
 
        delaep7x8_io1_store(addr, value);
273
 
        break;
274
 
      case CARTRIDGE_DELA_EP256:
275
 
        delaep256_io1_store(addr, value);
276
 
        break;
 
255
            export.game = 0;
 
256
            if (value & 0x80) {
 
257
                export.exrom = 0;
 
258
            } else {
 
259
                export.exrom = 1;  /* turn off cart ROM */
 
260
            }
 
261
            mem_pla_config_changed();
 
262
            break;
 
263
        case CARTRIDGE_MAGIC_FORMEL:
 
264
            magicformel_io1_store(addr, value);
 
265
            break;
 
266
        case CARTRIDGE_STRUCTURED_BASIC:
 
267
            stb_io1_store(addr, value);
 
268
            break;
 
269
        case CARTRIDGE_DELA_EP64:
 
270
            delaep64_io1_store(addr, value);
 
271
            break;
 
272
        case CARTRIDGE_DELA_EP7x8:
 
273
            delaep7x8_io1_store(addr, value);
 
274
            break;
 
275
        case CARTRIDGE_DELA_EP256:
 
276
            delaep256_io1_store(addr, value);
 
277
            break;
 
278
        case CARTRIDGE_EASYFLASH:
 
279
            easyflash_io1_store(addr, value);
 
280
            break;
277
281
    }
278
282
    return;
279
283
}
284
288
    log_debug("Read IO2 %02x.", addr);
285
289
#endif
286
290
    switch (mem_cartridge_type) {
287
 
      case CARTRIDGE_STARDOS:
288
 
        return stardos_io2_read(addr);
289
 
      case CARTRIDGE_ACTION_REPLAY4:
290
 
        return actionreplay4_io2_read(addr);
291
 
      case CARTRIDGE_ACTION_REPLAY3:
292
 
        return actionreplay3_io2_read(addr);
293
 
      case CARTRIDGE_ACTION_REPLAY:
294
 
        return actionreplay_io2_read(addr);
295
 
      case CARTRIDGE_ATOMIC_POWER:
296
 
        return atomicpower_io2_read(addr);
297
 
      case CARTRIDGE_RETRO_REPLAY:
298
 
        return retroreplay_io2_read(addr);
299
 
      case CARTRIDGE_SUPER_SNAPSHOT:
300
 
        return supersnapshot_v4_io2_read(addr);
301
 
      case CARTRIDGE_FINAL_III:
302
 
        return final_v3_io2_read(addr);
303
 
      case CARTRIDGE_FINAL_I:
304
 
        return final_v1_io2_read(addr);
305
 
      case CARTRIDGE_KCS_POWER:
306
 
        return kcs_io2_read(addr);
307
 
      case CARTRIDGE_IEEE488:
308
 
        return tpi_read((WORD)(addr & 0x07));
309
 
      case CARTRIDGE_EPYX_FASTLOAD:
310
 
        return epyxfastload_io2_read(addr);
311
 
      case CARTRIDGE_MIKRO_ASSEMBLER:
312
 
        return mikroass_io2_read(addr);
313
 
      case CARTRIDGE_WESTERMANN:
314
 
        cartridge_config_changed(0, 0, CMODE_READ);
315
 
        return vicii_read_phi1();
316
 
      case CARTRIDGE_REX:
317
 
        if ((addr & 0xff) < 0xc0)
318
 
            cartridge_config_changed(2, 2, CMODE_READ);
319
 
        else
 
291
        case CARTRIDGE_STARDOS:
 
292
            return stardos_io2_read(addr);
 
293
        case CARTRIDGE_ACTION_REPLAY4:
 
294
            return actionreplay4_io2_read(addr);
 
295
        case CARTRIDGE_ACTION_REPLAY3:
 
296
            return actionreplay3_io2_read(addr);
 
297
        case CARTRIDGE_ACTION_REPLAY:
 
298
            return actionreplay_io2_read(addr);
 
299
        case CARTRIDGE_ATOMIC_POWER:
 
300
            return atomicpower_io2_read(addr);
 
301
        case CARTRIDGE_RETRO_REPLAY:
 
302
            return retroreplay_io2_read(addr);
 
303
        case CARTRIDGE_SUPER_SNAPSHOT:
 
304
            return supersnapshot_v4_io2_read(addr);
 
305
        case CARTRIDGE_FINAL_III:
 
306
            return final_v3_io2_read(addr);
 
307
        case CARTRIDGE_FINAL_I:
 
308
            return final_v1_io2_read(addr);
 
309
        case CARTRIDGE_KCS_POWER:
 
310
            return kcs_io2_read(addr);
 
311
        case CARTRIDGE_IEEE488:
 
312
            return tpi_read((WORD)(addr & 0x07));
 
313
        case CARTRIDGE_EPYX_FASTLOAD:
 
314
            return epyxfastload_io2_read(addr);
 
315
        case CARTRIDGE_MIKRO_ASSEMBLER:
 
316
            return mikroass_io2_read(addr);
 
317
        case CARTRIDGE_WESTERMANN:
320
318
            cartridge_config_changed(0, 0, CMODE_READ);
321
 
        return 0;
322
 
      case CARTRIDGE_WARPSPEED:
323
 
        io_source=IO_SOURCE_WARPSPEED;
324
 
        return roml_banks[0x1f00 + (addr & 0xff)];
325
 
      case CARTRIDGE_MAGIC_FORMEL:
326
 
        return magicformel_io2_read(addr);
327
 
      case CARTRIDGE_ROSS:
328
 
        return ross_io2_read(addr);
329
 
      case CARTRIDGE_REX_EP256:
330
 
        return rexep256_io2_read(addr);
 
319
            return vicii_read_phi1();
 
320
        case CARTRIDGE_REX:
 
321
            if ((addr & 0xff) < 0xc0) {
 
322
                cartridge_config_changed(2, 2, CMODE_READ);
 
323
            } else {
 
324
                cartridge_config_changed(0, 0, CMODE_READ);
 
325
            }
 
326
            return 0;
 
327
        case CARTRIDGE_WARPSPEED:
 
328
            io_source = IO_SOURCE_WARPSPEED;
 
329
            return roml_banks[0x1f00 + (addr & 0xff)];
 
330
        case CARTRIDGE_MAGIC_FORMEL:
 
331
            return magicformel_io2_read(addr);
 
332
        case CARTRIDGE_ROSS:
 
333
            return ross_io2_read(addr);
 
334
        case CARTRIDGE_REX_EP256:
 
335
            return rexep256_io2_read(addr);
 
336
        case CARTRIDGE_EASYFLASH:
 
337
            return easyflash_io2_read(addr);
331
338
    }
332
339
    return vicii_read_phi1();
333
340
}
338
345
    log_debug("Store IO2 %02x <- %02x.", addr, value);
339
346
#endif
340
347
    switch (mem_cartridge_type) {
341
 
      case CARTRIDGE_ACTION_REPLAY:
342
 
        actionreplay_io2_store(addr, value);
343
 
        break;
344
 
      case CARTRIDGE_ATOMIC_POWER:
345
 
        atomicpower_io2_store(addr, value);
346
 
        break;
347
 
      case CARTRIDGE_RETRO_REPLAY:
348
 
        retroreplay_io2_store(addr, value);
349
 
        break;
350
 
      case CARTRIDGE_FINAL_I:
351
 
        final_v1_io2_store(addr, value);
352
 
        break;
353
 
      case CARTRIDGE_KCS_POWER:
354
 
        kcs_io2_store(addr, value);
355
 
        break;
356
 
      case CARTRIDGE_WARPSPEED:
357
 
        cartridge_config_changed(2, 2, CMODE_WRITE);
358
 
        break;
359
 
      case CARTRIDGE_SUPER_SNAPSHOT:
360
 
        supersnapshot_v4_io2_store(addr, value);
361
 
        break;
362
 
      case CARTRIDGE_FINAL_III:
363
 
        final_v3_io2_store(addr, value);
364
 
        break;
365
 
      case CARTRIDGE_SUPER_GAMES:
366
 
        supergames_io2_store(addr, value);
367
 
        break;
368
 
      case CARTRIDGE_IEEE488:
369
 
        tpi_store((WORD)(addr & 0x07), value);
370
 
        break;
371
 
      case CARTRIDGE_MAGIC_FORMEL:
372
 
        magicformel_io2_store(addr, value);
373
 
        break;
374
 
      case CARTRIDGE_REX_EP256:
375
 
        rexep256_io2_store(addr, value);
376
 
        break;
 
348
        case CARTRIDGE_ACTION_REPLAY:
 
349
            actionreplay_io2_store(addr, value);
 
350
            break;
 
351
        case CARTRIDGE_ATOMIC_POWER:
 
352
            atomicpower_io2_store(addr, value);
 
353
            break;
 
354
        case CARTRIDGE_RETRO_REPLAY:
 
355
            retroreplay_io2_store(addr, value);
 
356
            break;
 
357
        case CARTRIDGE_FINAL_I:
 
358
            final_v1_io2_store(addr, value);
 
359
            break;
 
360
        case CARTRIDGE_KCS_POWER:
 
361
            kcs_io2_store(addr, value);
 
362
            break;
 
363
        case CARTRIDGE_WARPSPEED:
 
364
            cartridge_config_changed(2, 2, CMODE_WRITE);
 
365
            break;
 
366
        case CARTRIDGE_SUPER_SNAPSHOT:
 
367
            supersnapshot_v4_io2_store(addr, value);
 
368
            break;
 
369
        case CARTRIDGE_FINAL_III:
 
370
            final_v3_io2_store(addr, value);
 
371
            break;
 
372
        case CARTRIDGE_SUPER_GAMES:
 
373
            supergames_io2_store(addr, value);
 
374
            break;
 
375
        case CARTRIDGE_IEEE488:
 
376
            tpi_store((WORD)(addr & 0x07), value);
 
377
            break;
 
378
        case CARTRIDGE_MAGIC_FORMEL:
 
379
            magicformel_io2_store(addr, value);
 
380
            break;
 
381
        case CARTRIDGE_REX_EP256:
 
382
            rexep256_io2_store(addr, value);
 
383
            break;
 
384
        case CARTRIDGE_EASYFLASH:
 
385
            easyflash_io2_store(addr, value);
 
386
            break;
377
387
    }
378
388
}
379
389
 
380
390
BYTE REGPARM1 roml_read(WORD addr)
381
391
{
382
 
    if (mmc64_enabled)
383
 
      return mmc64_roml_read(addr);
 
392
    if (mmc64_enabled) {
 
393
        return mmc64_roml_read(addr);
 
394
    }
384
395
 
385
 
    if (ramcart_enabled)
 
396
    if (ramcart_enabled) {
386
397
        return ramcart_roml_read(addr);
 
398
    }
387
399
 
388
400
    switch (mem_cartridge_type) {
389
 
      case CARTRIDGE_STARDOS:
390
 
        return stardos_roml_read(addr);
391
 
      case CARTRIDGE_ZAXXON:
392
 
        return zaxxon_roml_read(addr);
393
 
      case CARTRIDGE_SUPER_SNAPSHOT:
394
 
        return supersnapshot_v4_roml_read(addr);
395
 
      case CARTRIDGE_SUPER_SNAPSHOT_V5:
396
 
        return supersnapshot_v5_roml_read(addr);
397
 
      case CARTRIDGE_ACTION_REPLAY4:
398
 
        return actionreplay4_roml_read(addr);
399
 
      case CARTRIDGE_ACTION_REPLAY:
400
 
        return actionreplay_roml_read(addr);
401
 
      case CARTRIDGE_RETRO_REPLAY:
402
 
        return retroreplay_roml_read(addr);
403
 
      case CARTRIDGE_IDE64:
404
 
        return roml_banks[(addr & 0x3fff) | (roml_bank << 14)];
405
 
      case CARTRIDGE_ATOMIC_POWER:
406
 
        return atomicpower_roml_read(addr);
407
 
      case CARTRIDGE_EXPERT:
408
 
        return expert_roml_read(addr);
409
 
      case CARTRIDGE_FINAL_I:
410
 
        return final_v1_roml_read(addr);
411
 
      case CARTRIDGE_FINAL_III:
412
 
        return final_v3_roml_read(addr);
413
 
      case CARTRIDGE_MAGIC_FORMEL:
414
 
        return magicformel_roml_read(addr);
 
401
        case CARTRIDGE_STARDOS:
 
402
            return stardos_roml_read(addr);
 
403
        case CARTRIDGE_ZAXXON:
 
404
            return zaxxon_roml_read(addr);
 
405
        case CARTRIDGE_SUPER_SNAPSHOT:
 
406
            return supersnapshot_v4_roml_read(addr);
 
407
        case CARTRIDGE_SUPER_SNAPSHOT_V5:
 
408
            return supersnapshot_v5_roml_read(addr);
 
409
        case CARTRIDGE_ACTION_REPLAY4:
 
410
            return actionreplay4_roml_read(addr);
 
411
        case CARTRIDGE_ACTION_REPLAY:
 
412
            return actionreplay_roml_read(addr);
 
413
        case CARTRIDGE_RETRO_REPLAY:
 
414
            return retroreplay_roml_read(addr);
 
415
        case CARTRIDGE_IDE64:
 
416
            return roml_banks[(addr & 0x3fff) | (roml_bank << 14)];
 
417
        case CARTRIDGE_ATOMIC_POWER:
 
418
            return atomicpower_roml_read(addr);
 
419
        case CARTRIDGE_EXPERT:
 
420
            return expert_roml_read(addr);
 
421
        case CARTRIDGE_FINAL_I:
 
422
            return final_v1_roml_read(addr);
 
423
        case CARTRIDGE_FINAL_III:
 
424
            return final_v3_roml_read(addr);
 
425
        case CARTRIDGE_MAGIC_FORMEL:
 
426
            return magicformel_roml_read(addr);
 
427
        case CARTRIDGE_EASYFLASH:
 
428
            return easyflash_roml_read(addr);
415
429
    }
416
 
    if (dqbb_enabled)
417
 
    {
 
430
    if (dqbb_enabled) {
418
431
        return dqbb_roml_read(addr);
419
432
    }
420
433
 
421
 
    if (export_ram)
 
434
    if (export_ram) {
422
435
        return export_ram0[addr & 0x1fff];
 
436
    }
423
437
 
424
438
    return roml_banks[(addr & 0x1fff) + (roml_bank << 13)];
425
439
}
426
440
 
427
441
void REGPARM2 roml_store(WORD addr, BYTE value)
428
442
{
429
 
    if (ramcart_enabled)
430
 
    {
 
443
    if (ramcart_enabled) {
431
444
        ramcart_roml_store(addr,value);
432
445
        return;
433
446
    }
434
447
 
435
448
    switch (mem_cartridge_type) {
436
 
      case CARTRIDGE_SUPER_SNAPSHOT:
437
 
        supersnapshot_v4_roml_store(addr, value);
438
 
        return;
439
 
      case CARTRIDGE_SUPER_SNAPSHOT_V5:
440
 
        supersnapshot_v5_roml_store(addr, value);
441
 
        return;
442
 
      case CARTRIDGE_ACTION_REPLAY:
443
 
        actionreplay_roml_store(addr, value);
444
 
        return;
445
 
      case CARTRIDGE_RETRO_REPLAY:
446
 
        retroreplay_roml_store(addr, value);
447
 
        return;
448
 
      case CARTRIDGE_ATOMIC_POWER:
449
 
        atomicpower_roml_store(addr, value);
450
 
        return;
451
 
      case CARTRIDGE_EXPERT:
452
 
        expert_roml_store(addr, value);
453
 
        return;
454
 
      case CARTRIDGE_FINAL_I:
455
 
        final_v1_roml_store(addr, value);
456
 
        return;
457
 
      case CARTRIDGE_FINAL_III:
458
 
        final_v3_roml_store(addr, value);
459
 
        return;
460
 
      case CARTRIDGE_MAGIC_FORMEL:
461
 
        magicformel_roml_store(addr, value);
462
 
        return;
 
449
        case CARTRIDGE_SUPER_SNAPSHOT:
 
450
            supersnapshot_v4_roml_store(addr, value);
 
451
            return;
 
452
        case CARTRIDGE_SUPER_SNAPSHOT_V5:
 
453
            supersnapshot_v5_roml_store(addr, value);
 
454
            return;
 
455
        case CARTRIDGE_ACTION_REPLAY:
 
456
            actionreplay_roml_store(addr, value);
 
457
            return;
 
458
        case CARTRIDGE_RETRO_REPLAY:
 
459
            retroreplay_roml_store(addr, value);
 
460
            return;
 
461
        case CARTRIDGE_ATOMIC_POWER:
 
462
            atomicpower_roml_store(addr, value);
 
463
            return;
 
464
        case CARTRIDGE_EXPERT:
 
465
            expert_roml_store(addr, value);
 
466
            return;
 
467
        case CARTRIDGE_FINAL_I:
 
468
            final_v1_roml_store(addr, value);
 
469
            return;
 
470
        case CARTRIDGE_FINAL_III:
 
471
            final_v3_roml_store(addr, value);
 
472
            return;
 
473
        case CARTRIDGE_MAGIC_FORMEL:
 
474
            magicformel_roml_store(addr, value);
 
475
            return;
 
476
        case CARTRIDGE_EASYFLASH:
 
477
            easyflash_roml_store(addr, value);
 
478
            return;
463
479
    }
464
480
 
465
 
    if (export_ram)
 
481
    if (export_ram) {
466
482
        export_ram0[addr & 0x1fff] = value;
 
483
    }
467
484
}
468
485
 
469
486
BYTE REGPARM1 romh_read(WORD addr)
470
487
{
471
488
    switch (mem_cartridge_type) {
472
 
      case CARTRIDGE_ATOMIC_POWER:
473
 
        return atomicpower_romh_read(addr);
474
 
      case CARTRIDGE_EXPERT:
475
 
        return expert_romh_read(addr);
476
 
      case CARTRIDGE_OCEAN:
477
 
        /* 256 kB OCEAN carts may access memory either at $8000 or $a000 */
478
 
        return roml_banks[(addr & 0x1fff) + (romh_bank << 13)];
479
 
      case CARTRIDGE_IDE64:
480
 
        return romh_banks[(addr & 0x3fff) | (romh_bank << 14)];
 
489
        case CARTRIDGE_ATOMIC_POWER:
 
490
            return atomicpower_romh_read(addr);
 
491
        case CARTRIDGE_EXPERT:
 
492
            return expert_romh_read(addr);
 
493
        case CARTRIDGE_OCEAN:
 
494
            /* 256 kB OCEAN carts may access memory either at $8000 or $a000 */
 
495
            return roml_banks[(addr & 0x1fff) + (romh_bank << 13)];
 
496
        case CARTRIDGE_IDE64:
 
497
            return romh_banks[(addr & 0x3fff) | (romh_bank << 14)];
 
498
        case CARTRIDGE_EASYFLASH:
 
499
            return easyflash_romh_read(addr);
481
500
    }
482
 
    if (isepic_enabled && isepic_switch)
483
 
    {
 
501
    if (isepic_enabled && isepic_switch) {
484
502
        return isepic_romh_read(addr);
485
503
    }
486
 
    if (dqbb_enabled)
487
 
    {
 
504
    if (dqbb_enabled) {
488
505
        return dqbb_romh_read(addr);
489
506
    }
490
507
    return romh_banks[(addr & 0x1fff) + (romh_bank << 13)];
493
510
void REGPARM2 romh_store(WORD addr, BYTE value)
494
511
{
495
512
    switch (mem_cartridge_type) {
496
 
      case CARTRIDGE_MAGIC_FORMEL:
497
 
        magicformel_romh_store(addr, value);
498
 
        return;
 
513
        case CARTRIDGE_EASYFLASH:
 
514
            easyflash_romh_store(addr, value);
 
515
            break;
 
516
        case CARTRIDGE_MAGIC_FORMEL:
 
517
            magicformel_romh_store(addr, value);
 
518
            break;
499
519
    }
500
 
    if (isepic_enabled && isepic_switch)
501
 
    {
 
520
    if (isepic_enabled && isepic_switch) {
502
521
        isepic_romh_store(addr, value);
503
 
        return;
504
522
    }
505
523
}
506
524
 
507
525
void REGPARM2 romh_no_ultimax_store(WORD addr, BYTE value)
508
526
{
509
 
    if (dqbb_enabled)
510
 
    {
 
527
    if (dqbb_enabled) {
511
528
        dqbb_romh_store(addr, value);
512
529
        return;
513
530
    }
516
533
 
517
534
void REGPARM2 roml_no_ultimax_store(WORD addr, BYTE value)
518
535
{
519
 
    if (dqbb_enabled)
520
 
    {
 
536
    if (dqbb_enabled) {
521
537
        dqbb_roml_store(addr, value);
522
538
        return;
523
539
    }
527
543
BYTE REGPARM1 ultimax_1000_7fff_read(WORD addr)
528
544
{
529
545
    switch (mem_cartridge_type) {
530
 
      case CARTRIDGE_IDE64:
531
 
        return export_ram0[addr & 0x7fff];
532
 
      case CARTRIDGE_MAGIC_FORMEL:
533
 
        return magicformel_1000_7fff_read(addr);
 
546
        case CARTRIDGE_IDE64:
 
547
            return export_ram0[addr & 0x7fff];
 
548
        case CARTRIDGE_MAGIC_FORMEL:
 
549
            return magicformel_1000_7fff_read(addr);
534
550
    }
535
 
    if (isepic_enabled && isepic_switch)
536
 
    {
 
551
    if (isepic_enabled && isepic_switch) {
537
552
        return isepic_1000_7fff_read(addr);
538
553
    }
539
554
    return vicii_read_phi1();
542
557
void REGPARM2 ultimax_1000_7fff_store(WORD addr, BYTE value)
543
558
{
544
559
    switch (mem_cartridge_type) {
545
 
      case CARTRIDGE_IDE64:
546
 
        export_ram0[addr & 0x7fff] = value;
547
 
        break;
548
 
      case CARTRIDGE_MAGIC_FORMEL:
549
 
        magicformel_1000_7fff_store(addr, value);
550
 
        break;
 
560
        case CARTRIDGE_IDE64:
 
561
            export_ram0[addr & 0x7fff] = value;
 
562
            break;
 
563
        case CARTRIDGE_MAGIC_FORMEL:
 
564
            magicformel_1000_7fff_store(addr, value);
 
565
            break;
551
566
    }
552
 
    if (isepic_enabled && isepic_switch)
553
 
    {
 
567
    if (isepic_enabled && isepic_switch) {
554
568
        isepic_1000_7fff_store(addr, value);
555
569
    }
556
570
}
558
572
BYTE REGPARM1 ultimax_a000_bfff_read(WORD addr)
559
573
{
560
574
    switch (mem_cartridge_type) {
561
 
      case CARTRIDGE_ATOMIC_POWER:
562
 
        return atomicpower_a000_bfff_read(addr);
563
 
      case CARTRIDGE_IDE64:
564
 
        return romh_banks[(addr & 0x3fff) | (romh_bank << 14)];
565
 
      case CARTRIDGE_MAGIC_FORMEL:
566
 
        return magicformel_a000_bfff_read(addr);
 
575
        case CARTRIDGE_ATOMIC_POWER:
 
576
            return atomicpower_a000_bfff_read(addr);
 
577
        case CARTRIDGE_IDE64:
 
578
            return romh_banks[(addr & 0x3fff) | (romh_bank << 14)];
 
579
        case CARTRIDGE_MAGIC_FORMEL:
 
580
            return magicformel_a000_bfff_read(addr);
567
581
    }
568
 
    if (isepic_enabled && isepic_switch)
569
 
    {
 
582
    if (isepic_enabled && isepic_switch) {
570
583
        return isepic_a000_bfff_read(addr);
571
584
    }
572
585
    return vicii_read_phi1();
575
588
void REGPARM2 ultimax_a000_bfff_store(WORD addr, BYTE value)
576
589
{
577
590
    switch (mem_cartridge_type) {
578
 
      case CARTRIDGE_ATOMIC_POWER:
579
 
        atomicpower_a000_bfff_store(addr, value);
580
 
        break;
581
 
      case CARTRIDGE_MAGIC_FORMEL:
582
 
        magicformel_a000_bfff_store(addr, value);
583
 
        break;
 
591
        case CARTRIDGE_ATOMIC_POWER:
 
592
            atomicpower_a000_bfff_store(addr, value);
 
593
            break;
 
594
        case CARTRIDGE_MAGIC_FORMEL:
 
595
            magicformel_a000_bfff_store(addr, value);
 
596
            break;
584
597
    }
585
 
    if (isepic_enabled && isepic_switch)
586
 
    {
 
598
    if (isepic_enabled && isepic_switch) {
587
599
        isepic_a000_bfff_store(addr, value);
588
600
    }
589
601
}
591
603
BYTE REGPARM1 ultimax_c000_cfff_read(WORD addr)
592
604
{
593
605
    switch (mem_cartridge_type) {
594
 
      case CARTRIDGE_IDE64:
595
 
        return export_ram0[addr & 0x7fff];
596
 
      case CARTRIDGE_MAGIC_FORMEL:
597
 
        return magicformel_c000_cfff_read(addr);
 
606
        case CARTRIDGE_IDE64:
 
607
            return export_ram0[addr & 0x7fff];
 
608
        case CARTRIDGE_MAGIC_FORMEL:
 
609
            return magicformel_c000_cfff_read(addr);
598
610
    }
599
 
    if (isepic_enabled && isepic_switch)
600
 
    {
 
611
    if (isepic_enabled && isepic_switch) {
601
612
        return isepic_c000_cfff_read(addr);
602
613
    }
603
614
    return vicii_read_phi1();
606
617
void REGPARM2 ultimax_c000_cfff_store(WORD addr, BYTE value)
607
618
{
608
619
    switch (mem_cartridge_type) {
609
 
      case CARTRIDGE_IDE64:
610
 
        export_ram0[addr & 0x7fff] = value;
611
 
        break;
612
 
      case CARTRIDGE_MAGIC_FORMEL:
613
 
        magicformel_c000_cfff_store(addr, value);
614
 
        break;
 
620
        case CARTRIDGE_IDE64:
 
621
            export_ram0[addr & 0x7fff] = value;
 
622
            break;
 
623
        case CARTRIDGE_MAGIC_FORMEL:
 
624
            magicformel_c000_cfff_store(addr, value);
 
625
            break;
615
626
    }
616
 
    if (isepic_enabled && isepic_switch)
617
 
    {
 
627
    if (isepic_enabled && isepic_switch) {
618
628
        isepic_c000_cfff_store(addr, value);
619
629
    }
620
630
}
622
632
BYTE REGPARM1 ultimax_d000_dfff_read(WORD addr)
623
633
{
624
634
    switch (mem_cartridge_type) {
625
 
      case CARTRIDGE_MAGIC_FORMEL:
626
 
        return magicformel_d000_dfff_read(addr);
 
635
        case CARTRIDGE_MAGIC_FORMEL:
 
636
            return magicformel_d000_dfff_read(addr);
627
637
    }
628
638
    return read_bank_io(addr);
629
639
}
631
641
void REGPARM2 ultimax_d000_dfff_store(WORD addr, BYTE value)
632
642
{
633
643
    switch (mem_cartridge_type) {
634
 
      case CARTRIDGE_MAGIC_FORMEL:
635
 
        magicformel_d000_dfff_store(addr, value);
636
 
        break;
 
644
        case CARTRIDGE_MAGIC_FORMEL:
 
645
            magicformel_d000_dfff_store(addr, value);
 
646
            break;
637
647
    }
638
648
    store_bank_io(addr, value);
639
649
}
640
650
 
641
 
void REGPARM1 cartridge_decode_address(WORD addr)
642
 
{
643
 
    switch (mem_cartridge_type) {
644
 
    }
645
 
}
646
 
 
647
651
void cartridge_init_config(void)
648
652
{
649
653
    switch (mem_cartridge_type) {
650
 
      case CARTRIDGE_STARDOS:
651
 
        stardos_config_init();
652
 
        break;
653
 
      case CARTRIDGE_ACTION_REPLAY4:
654
 
        actionreplay4_config_init();
655
 
        break;
656
 
      case CARTRIDGE_ACTION_REPLAY3:
657
 
        actionreplay3_config_init();
658
 
        break;
659
 
      case CARTRIDGE_ACTION_REPLAY:
660
 
        actionreplay_config_init();
661
 
        break;
662
 
      case CARTRIDGE_ATOMIC_POWER:
663
 
        atomicpower_config_init();
664
 
        break;
665
 
      case CARTRIDGE_RETRO_REPLAY:
666
 
        retroreplay_config_init();
667
 
        break;
668
 
      case CARTRIDGE_IDE64:
669
 
        ide64_config_init();
670
 
        break;
671
 
      case CARTRIDGE_KCS_POWER:
672
 
        kcs_config_init();
673
 
        break;
674
 
      case CARTRIDGE_SUPER_GAMES:
675
 
        supergames_config_init();
676
 
        break;
677
 
      case CARTRIDGE_COMAL80:
678
 
        comal80_config_init();
679
 
        break;
680
 
      case CARTRIDGE_GENERIC_8KB:
681
 
      case CARTRIDGE_REX:
682
 
        generic_8kb_config_init();
683
 
        break;
684
 
      case CARTRIDGE_EPYX_FASTLOAD:
685
 
        epyxfastload_config_init();
686
 
        break;
687
 
      case CARTRIDGE_MIKRO_ASSEMBLER:
688
 
        mikroass_config_init();
689
 
        break;
690
 
      case CARTRIDGE_FINAL_I:
691
 
        final_v1_config_init();
692
 
        break;
693
 
      case CARTRIDGE_FINAL_III:
694
 
        final_v3_config_init();
695
 
        break;
696
 
      case CARTRIDGE_SIMONS_BASIC:
697
 
      case CARTRIDGE_GENERIC_16KB:
698
 
      case CARTRIDGE_WESTERMANN:
699
 
      case CARTRIDGE_WARPSPEED:
700
 
        generic_16kb_config_init();
701
 
        break;
702
 
      case CARTRIDGE_ZAXXON:
703
 
        zaxxon_config_init();
704
 
        break;
705
 
      case CARTRIDGE_ULTIMAX:
706
 
        generic_ultimax_config_init();
707
 
        break;
708
 
      case CARTRIDGE_SUPER_SNAPSHOT:
709
 
        supersnapshot_v4_config_init();
710
 
        break;
711
 
      case CARTRIDGE_SUPER_SNAPSHOT_V5:
712
 
        supersnapshot_v5_config_init();
713
 
        break;
714
 
      case CARTRIDGE_OCEAN:
715
 
      case CARTRIDGE_FUNPLAY:
716
 
        cartridge_config_changed(1, 1, CMODE_READ);
717
 
        cartridge_store_io1((WORD)0xde00, 0);
718
 
        break;
719
 
      case CARTRIDGE_GS:
720
 
        cartridge_config_changed(0, 0, CMODE_READ);
721
 
        cartridge_store_io1((WORD)0xde00, 0);
722
 
        break;
723
 
      case CARTRIDGE_DINAMIC:
724
 
        cartridge_config_changed(0, 0, CMODE_READ);
725
 
        cartridge_read_io1((WORD)0xde00);
726
 
        break;
727
 
      case CARTRIDGE_IEEE488:
728
 
        cartridge_config_changed(0, 0, CMODE_READ);
729
 
        /* FIXME: Insert interface init here.  */
730
 
        break;
731
 
      case CARTRIDGE_EXPERT:
732
 
        expert_config_init();
733
 
        break;
734
 
      case CARTRIDGE_MAGIC_DESK:
735
 
        cartridge_config_changed(0, 0, CMODE_READ);
736
 
        cartridge_store_io1((WORD)0xde00, 0);
737
 
        break;
738
 
      case CARTRIDGE_MAGIC_FORMEL:
739
 
        magicformel_config_init();
740
 
        break;
741
 
      case CARTRIDGE_ROSS:
742
 
        ross_config_init();
743
 
        break;
744
 
      case CARTRIDGE_STRUCTURED_BASIC:
745
 
        stb_config_init();
746
 
        break;
747
 
      case CARTRIDGE_DELA_EP64:
748
 
        delaep64_config_init();
749
 
        break;
750
 
      case CARTRIDGE_DELA_EP7x8:
751
 
        delaep7x8_config_init();
752
 
        break;
753
 
      case CARTRIDGE_DELA_EP256:
754
 
        delaep256_config_init();
755
 
        break;
756
 
      case CARTRIDGE_REX_EP256:
757
 
        rexep256_config_init();
758
 
        break;
759
 
      default:
760
 
        cartridge_config_changed(2, 2, CMODE_READ);
 
654
        case CARTRIDGE_STARDOS:
 
655
            stardos_config_init();
 
656
            break;
 
657
        case CARTRIDGE_ACTION_REPLAY4:
 
658
            actionreplay4_config_init();
 
659
            break;
 
660
        case CARTRIDGE_ACTION_REPLAY3:
 
661
            actionreplay3_config_init();
 
662
            break;
 
663
        case CARTRIDGE_ACTION_REPLAY:
 
664
            actionreplay_config_init();
 
665
            break;
 
666
        case CARTRIDGE_ATOMIC_POWER:
 
667
            atomicpower_config_init();
 
668
            break;
 
669
        case CARTRIDGE_RETRO_REPLAY:
 
670
            retroreplay_config_init();
 
671
            break;
 
672
        case CARTRIDGE_IDE64:
 
673
            ide64_config_init();
 
674
            break;
 
675
        case CARTRIDGE_KCS_POWER:
 
676
            kcs_config_init();
 
677
            break;
 
678
        case CARTRIDGE_SUPER_GAMES:
 
679
            supergames_config_init();
 
680
            break;
 
681
        case CARTRIDGE_COMAL80:
 
682
            comal80_config_init();
 
683
            break;
 
684
        case CARTRIDGE_GENERIC_8KB:
 
685
        case CARTRIDGE_REX:
 
686
            generic_8kb_config_init();
 
687
            break;
 
688
        case CARTRIDGE_EPYX_FASTLOAD:
 
689
            epyxfastload_config_init();
 
690
            break;
 
691
        case CARTRIDGE_MIKRO_ASSEMBLER:
 
692
            mikroass_config_init();
 
693
            break;
 
694
        case CARTRIDGE_FINAL_I:
 
695
            final_v1_config_init();
 
696
            break;
 
697
        case CARTRIDGE_FINAL_III:
 
698
            final_v3_config_init();
 
699
            break;
 
700
        case CARTRIDGE_SIMONS_BASIC:
 
701
        case CARTRIDGE_GENERIC_16KB:
 
702
        case CARTRIDGE_WESTERMANN:
 
703
        case CARTRIDGE_WARPSPEED:
 
704
            generic_16kb_config_init();
 
705
            break;
 
706
        case CARTRIDGE_ZAXXON:
 
707
            zaxxon_config_init();
 
708
            break;
 
709
        case CARTRIDGE_ULTIMAX:
 
710
            generic_ultimax_config_init();
 
711
            break;
 
712
        case CARTRIDGE_SUPER_SNAPSHOT:
 
713
            supersnapshot_v4_config_init();
 
714
            break;
 
715
        case CARTRIDGE_SUPER_SNAPSHOT_V5:
 
716
            supersnapshot_v5_config_init();
 
717
            break;
 
718
        case CARTRIDGE_OCEAN:
 
719
        case CARTRIDGE_FUNPLAY:
 
720
            cartridge_config_changed(1, 1, CMODE_READ);
 
721
            cartridge_store_io1((WORD)0xde00, 0);
 
722
            break;
 
723
        case CARTRIDGE_EASYFLASH:
 
724
            easyflash_config_init();
 
725
            break;
 
726
        case CARTRIDGE_GS:
 
727
            cartridge_config_changed(0, 0, CMODE_READ);
 
728
            cartridge_store_io1((WORD)0xde00, 0);
 
729
            break;
 
730
        case CARTRIDGE_DINAMIC:
 
731
            cartridge_config_changed(0, 0, CMODE_READ);
 
732
            cartridge_read_io1((WORD)0xde00);
 
733
            break;
 
734
        case CARTRIDGE_IEEE488:
 
735
            cartridge_config_changed(0, 0, CMODE_READ);
 
736
            /* FIXME: Insert interface init here.  */
 
737
            break;
 
738
        case CARTRIDGE_EXPERT:
 
739
            expert_config_init();
 
740
            break;
 
741
        case CARTRIDGE_MAGIC_DESK:
 
742
            cartridge_config_changed(0, 0, CMODE_READ);
 
743
            cartridge_store_io1((WORD)0xde00, 0);
 
744
            break;
 
745
        case CARTRIDGE_MAGIC_FORMEL:
 
746
            magicformel_config_init();
 
747
            break;
 
748
        case CARTRIDGE_ROSS:
 
749
            ross_config_init();
 
750
            break;
 
751
        case CARTRIDGE_STRUCTURED_BASIC:
 
752
            stb_config_init();
 
753
            break;
 
754
        case CARTRIDGE_DELA_EP64:
 
755
            delaep64_config_init();
 
756
            break;
 
757
        case CARTRIDGE_DELA_EP7x8:
 
758
            delaep7x8_config_init();
 
759
            break;
 
760
        case CARTRIDGE_DELA_EP256:
 
761
            delaep256_config_init();
 
762
            break;
 
763
        case CARTRIDGE_REX_EP256:
 
764
            rexep256_config_init();
 
765
            break;
 
766
        default:
 
767
            cartridge_config_changed(2, 2, CMODE_READ);
761
768
    }
762
769
}
763
770
 
764
771
void cartridge_reset(void)
765
772
{
766
773
    switch (mem_cartridge_type) {
767
 
      case CARTRIDGE_ACTION_REPLAY4:
768
 
        actionreplay4_reset();
769
 
        break;
770
 
      case CARTRIDGE_ACTION_REPLAY3:
771
 
        actionreplay3_reset();
772
 
        break;
773
 
      case CARTRIDGE_ACTION_REPLAY:
774
 
        actionreplay_reset();
775
 
        break;
776
 
      case CARTRIDGE_RETRO_REPLAY:
777
 
        retroreplay_reset();
778
 
        break;
 
774
        case CARTRIDGE_ACTION_REPLAY4:
 
775
            actionreplay4_reset();
 
776
            break;
 
777
        case CARTRIDGE_ACTION_REPLAY3:
 
778
            actionreplay3_reset();
 
779
            break;
 
780
        case CARTRIDGE_ACTION_REPLAY:
 
781
            actionreplay_reset();
 
782
            break;
 
783
        case CARTRIDGE_RETRO_REPLAY:
 
784
            retroreplay_reset();
 
785
            break;
779
786
    }
780
787
}
781
788
 
787
794
    cartridge_romhbank_set(0);
788
795
    cartridge_romlbank_set(0);
789
796
    switch (type) {
790
 
      case CARTRIDGE_GENERIC_8KB:
791
 
      case CARTRIDGE_IEEE488:
792
 
      case CARTRIDGE_REX:
793
 
        generic_8kb_config_setup(rawcart);
794
 
        break;
795
 
      case CARTRIDGE_EPYX_FASTLOAD:
796
 
        epyxfastload_config_setup(rawcart);
797
 
        break;
798
 
      case CARTRIDGE_MIKRO_ASSEMBLER:
799
 
        mikroass_config_setup(rawcart);
800
 
        break;
801
 
      case CARTRIDGE_GENERIC_16KB:
802
 
      case CARTRIDGE_SIMONS_BASIC:
803
 
      case CARTRIDGE_WESTERMANN:
804
 
      case CARTRIDGE_WARPSPEED:
805
 
        generic_16kb_config_setup(rawcart);
806
 
        break;
807
 
      case CARTRIDGE_FINAL_I:
808
 
        final_v1_config_setup(rawcart);
809
 
        break;
810
 
      case CARTRIDGE_STARDOS:
811
 
        stardos_config_setup(rawcart);
812
 
        break;
813
 
      case CARTRIDGE_ACTION_REPLAY4:
814
 
        actionreplay4_config_setup(rawcart);
815
 
        break;
816
 
      case CARTRIDGE_ACTION_REPLAY3:
817
 
        actionreplay3_config_setup(rawcart);
818
 
        break;
819
 
      case CARTRIDGE_ACTION_REPLAY:
820
 
        actionreplay_config_setup(rawcart);
821
 
        break;
822
 
      case CARTRIDGE_ATOMIC_POWER:
823
 
        atomicpower_config_setup(rawcart);
824
 
        break;
825
 
      case CARTRIDGE_RETRO_REPLAY:
826
 
        retroreplay_config_setup(rawcart);
827
 
        break;
828
 
      case CARTRIDGE_IDE64:
829
 
        ide64_config_setup(rawcart);
830
 
        break;
831
 
      case CARTRIDGE_KCS_POWER:
832
 
        kcs_config_setup(rawcart);
833
 
        break;
834
 
      case CARTRIDGE_FINAL_III:
835
 
        final_v3_config_setup(rawcart);
836
 
        break;
837
 
      case CARTRIDGE_SUPER_SNAPSHOT:
838
 
        supersnapshot_v4_config_setup(rawcart);
839
 
        break;
840
 
      case CARTRIDGE_SUPER_SNAPSHOT_V5:
841
 
        supersnapshot_v5_config_setup(rawcart);
842
 
        break;
843
 
      case CARTRIDGE_OCEAN:
844
 
      case CARTRIDGE_FUNPLAY:
845
 
      case CARTRIDGE_GS:
846
 
      case CARTRIDGE_DINAMIC:
847
 
        memcpy(roml_banks, rawcart, 0x2000 * 64);
848
 
        memcpy(romh_banks, &rawcart[0x2000 * 16], 0x2000 * 16);
849
 
        /* Hack: using 16kB configuration, but some carts are 8kB only */
850
 
        cartridge_config_changed(1, 1, CMODE_READ);
851
 
        break;
852
 
      case CARTRIDGE_ULTIMAX:
853
 
        generic_ultimax_config_setup(rawcart);
854
 
        break;
855
 
      case CARTRIDGE_SUPER_GAMES:
856
 
        supergames_config_setup(rawcart);
857
 
        break;
858
 
      case CARTRIDGE_COMAL80:
859
 
        comal80_config_setup(rawcart);
860
 
        break;
861
 
      case CARTRIDGE_EXPERT:
862
 
        expert_config_setup(rawcart);
863
 
        break;
864
 
      case CARTRIDGE_ZAXXON:
865
 
        zaxxon_config_setup(rawcart);
866
 
        break;
867
 
      case CARTRIDGE_MAGIC_DESK:
868
 
        memcpy(roml_banks, rawcart, 0x2000 * 64);
869
 
        cartridge_config_changed(0, 0, CMODE_READ);
870
 
        break;
871
 
      case CARTRIDGE_MAGIC_FORMEL:
872
 
        magicformel_config_setup(rawcart);
873
 
        break;
874
 
      case CARTRIDGE_ROSS:
875
 
        ross_config_setup(rawcart);
876
 
        break;
877
 
      case CARTRIDGE_STRUCTURED_BASIC:
878
 
        stb_config_setup(rawcart);
879
 
        break;
880
 
      case CARTRIDGE_DELA_EP64:
881
 
        delaep64_config_setup(rawcart);
882
 
        break;
883
 
      case CARTRIDGE_DELA_EP7x8:
884
 
        delaep7x8_config_setup(rawcart);
885
 
        break;
886
 
      case CARTRIDGE_DELA_EP256:
887
 
        delaep256_config_setup(rawcart);
888
 
        break;
889
 
      case CARTRIDGE_REX_EP256:
890
 
        rexep256_config_setup(rawcart);
891
 
        break;
892
 
      default:
893
 
        mem_cartridge_type = CARTRIDGE_NONE;
 
797
        case CARTRIDGE_GENERIC_8KB:
 
798
        case CARTRIDGE_IEEE488:
 
799
        case CARTRIDGE_REX:
 
800
            generic_8kb_config_setup(rawcart);
 
801
            break;
 
802
        case CARTRIDGE_EPYX_FASTLOAD:
 
803
            epyxfastload_config_setup(rawcart);
 
804
            break;
 
805
        case CARTRIDGE_MIKRO_ASSEMBLER:
 
806
            mikroass_config_setup(rawcart);
 
807
            break;
 
808
        case CARTRIDGE_GENERIC_16KB:
 
809
        case CARTRIDGE_SIMONS_BASIC:
 
810
        case CARTRIDGE_WESTERMANN:
 
811
        case CARTRIDGE_WARPSPEED:
 
812
            generic_16kb_config_setup(rawcart);
 
813
            break;
 
814
        case CARTRIDGE_FINAL_I:
 
815
            final_v1_config_setup(rawcart);
 
816
            break;
 
817
        case CARTRIDGE_STARDOS:
 
818
            stardos_config_setup(rawcart);
 
819
            break;
 
820
        case CARTRIDGE_ACTION_REPLAY4:
 
821
            actionreplay4_config_setup(rawcart);
 
822
            break;
 
823
        case CARTRIDGE_ACTION_REPLAY3:
 
824
            actionreplay3_config_setup(rawcart);
 
825
            break;
 
826
        case CARTRIDGE_ACTION_REPLAY:
 
827
            actionreplay_config_setup(rawcart);
 
828
            break;
 
829
        case CARTRIDGE_ATOMIC_POWER:
 
830
            atomicpower_config_setup(rawcart);
 
831
            break;
 
832
        case CARTRIDGE_RETRO_REPLAY:
 
833
            retroreplay_config_setup(rawcart);
 
834
            break;
 
835
        case CARTRIDGE_IDE64:
 
836
            ide64_config_setup(rawcart);
 
837
            break;
 
838
        case CARTRIDGE_KCS_POWER:
 
839
            kcs_config_setup(rawcart);
 
840
            break;
 
841
        case CARTRIDGE_FINAL_III:
 
842
            final_v3_config_setup(rawcart);
 
843
            break;
 
844
        case CARTRIDGE_SUPER_SNAPSHOT:
 
845
            supersnapshot_v4_config_setup(rawcart);
 
846
            break;
 
847
        case CARTRIDGE_SUPER_SNAPSHOT_V5:
 
848
            supersnapshot_v5_config_setup(rawcart);
 
849
            break;
 
850
        case CARTRIDGE_OCEAN:
 
851
        case CARTRIDGE_FUNPLAY:
 
852
        case CARTRIDGE_GS:
 
853
        case CARTRIDGE_DINAMIC:
 
854
            memcpy(roml_banks, rawcart, 0x2000 * 64);
 
855
            memcpy(romh_banks, &rawcart[0x2000 * 16], 0x2000 * 16);
 
856
            /* Hack: using 16kB configuration, but some carts are 8kB only */
 
857
            cartridge_config_changed(1, 1, CMODE_READ);
 
858
            break;
 
859
        case CARTRIDGE_EASYFLASH:
 
860
            easyflash_config_setup(rawcart);
 
861
            break;
 
862
        case CARTRIDGE_ULTIMAX:
 
863
            generic_ultimax_config_setup(rawcart);
 
864
            break;
 
865
        case CARTRIDGE_SUPER_GAMES:
 
866
            supergames_config_setup(rawcart);
 
867
            break;
 
868
        case CARTRIDGE_COMAL80:
 
869
            comal80_config_setup(rawcart);
 
870
            break;
 
871
        case CARTRIDGE_EXPERT:
 
872
            expert_config_setup(rawcart);
 
873
            break;
 
874
        case CARTRIDGE_ZAXXON:
 
875
            zaxxon_config_setup(rawcart);
 
876
            break;
 
877
        case CARTRIDGE_MAGIC_DESK:
 
878
            memcpy(roml_banks, rawcart, 0x2000 * 64);
 
879
            cartridge_config_changed(0, 0, CMODE_READ);
 
880
            break;
 
881
        case CARTRIDGE_MAGIC_FORMEL:
 
882
            magicformel_config_setup(rawcart);
 
883
            break;
 
884
        case CARTRIDGE_ROSS:
 
885
            ross_config_setup(rawcart);
 
886
            break;
 
887
        case CARTRIDGE_STRUCTURED_BASIC:
 
888
            stb_config_setup(rawcart);
 
889
            break;
 
890
        case CARTRIDGE_DELA_EP64:
 
891
            delaep64_config_setup(rawcart);
 
892
            break;
 
893
        case CARTRIDGE_DELA_EP7x8:
 
894
            delaep7x8_config_setup(rawcart);
 
895
            break;
 
896
        case CARTRIDGE_DELA_EP256:
 
897
            delaep256_config_setup(rawcart);
 
898
            break;
 
899
        case CARTRIDGE_REX_EP256:
 
900
            rexep256_config_setup(rawcart);
 
901
            break;
 
902
        default:
 
903
            mem_cartridge_type = CARTRIDGE_NONE;
894
904
    }
895
905
    
896
906
    resources_get_int("CartridgeReset", &cartridge_reset);
908
918
    int cartridge_reset;
909
919
 
910
920
    switch (type) {
911
 
      case CARTRIDGE_STARDOS:
912
 
        stardos_detach();
913
 
        break;
914
 
      case CARTRIDGE_ACTION_REPLAY4:
915
 
        actionreplay4_detach();
916
 
        break;
917
 
      case CARTRIDGE_ACTION_REPLAY3:
918
 
        actionreplay3_detach();
919
 
        break;
920
 
      case CARTRIDGE_ACTION_REPLAY:
921
 
        actionreplay_detach();
922
 
        break;
923
 
      case CARTRIDGE_ATOMIC_POWER:
924
 
        atomicpower_detach();
925
 
        break;
926
 
      case CARTRIDGE_EPYX_FASTLOAD:
927
 
        epyxfastload_detach();
928
 
        break;
929
 
      case CARTRIDGE_MIKRO_ASSEMBLER:
930
 
        mikroass_detach();
931
 
        break;
932
 
      case CARTRIDGE_REX:
933
 
        rex_detach();
934
 
        break;
935
 
      case CARTRIDGE_EXPERT:
936
 
        expert_detach();
937
 
        break;
938
 
      case CARTRIDGE_FINAL_I:
939
 
        final_v1_detach();
940
 
        break;
941
 
      case CARTRIDGE_WESTERMANN:
942
 
        westermann_detach();
943
 
        break;
944
 
      case CARTRIDGE_WARPSPEED:
945
 
        warpspeed_detach();
946
 
        break;
947
 
      case CARTRIDGE_FINAL_III:
948
 
        final_v3_detach();
949
 
        break;
950
 
      case CARTRIDGE_GENERIC_16KB:
951
 
        generic_16kb_detach();
952
 
        break;
953
 
      case CARTRIDGE_GENERIC_8KB:
954
 
        generic_8kb_detach();
955
 
        break;
956
 
      case CARTRIDGE_IDE64:
957
 
        ide64_detach();
958
 
        break;
959
 
      case CARTRIDGE_IEEE488:
960
 
        /* FIXME: Insert interface removal here.  */
961
 
        break;
962
 
      case CARTRIDGE_KCS_POWER:
963
 
        kcs_detach();
964
 
        break;
965
 
      case CARTRIDGE_SIMONS_BASIC:
966
 
        simon_detach();
967
 
        break;
968
 
      case CARTRIDGE_MAGIC_FORMEL:
969
 
        magicformel_detach();
970
 
        break;
971
 
      case CARTRIDGE_RETRO_REPLAY:
972
 
        retroreplay_detach();
973
 
        break;
974
 
      case CARTRIDGE_SUPER_GAMES:
975
 
        supergames_detach();
976
 
        break;
977
 
      case CARTRIDGE_COMAL80:
978
 
        comal80_detach();
979
 
        break;
980
 
      case CARTRIDGE_STRUCTURED_BASIC:
981
 
        stb_detach();
982
 
        break;
983
 
      case CARTRIDGE_ROSS:
984
 
        ross_detach();
985
 
        break;
986
 
      case CARTRIDGE_SUPER_SNAPSHOT:
987
 
        supersnapshot_v4_detach();
988
 
        break;
989
 
      case CARTRIDGE_SUPER_SNAPSHOT_V5:
990
 
        supersnapshot_v5_detach();
991
 
        break;
992
 
      case CARTRIDGE_ULTIMAX:
993
 
        generic_ultimax_detach();
994
 
        break;
995
 
      case CARTRIDGE_ZAXXON:
996
 
        zaxxon_detach();
997
 
        break;
998
 
      case CARTRIDGE_DELA_EP64:
999
 
        delaep64_detach();
1000
 
        break;
1001
 
      case CARTRIDGE_DELA_EP7x8:
1002
 
        delaep7x8_detach();
1003
 
        break;
1004
 
      case CARTRIDGE_DELA_EP256:
1005
 
        delaep256_detach();
1006
 
        break;
1007
 
      case CARTRIDGE_REX_EP256:
1008
 
        rexep256_detach();
1009
 
        break;
 
921
        case CARTRIDGE_STARDOS:
 
922
            stardos_detach();
 
923
            break;
 
924
        case CARTRIDGE_ACTION_REPLAY4:
 
925
            actionreplay4_detach();
 
926
            break;
 
927
        case CARTRIDGE_ACTION_REPLAY3:
 
928
            actionreplay3_detach();
 
929
            break;
 
930
        case CARTRIDGE_ACTION_REPLAY:
 
931
            actionreplay_detach();
 
932
            break;
 
933
        case CARTRIDGE_ATOMIC_POWER:
 
934
            atomicpower_detach();
 
935
            break;
 
936
        case CARTRIDGE_EPYX_FASTLOAD:
 
937
            epyxfastload_detach();
 
938
            break;
 
939
        case CARTRIDGE_MIKRO_ASSEMBLER:
 
940
            mikroass_detach();
 
941
            break;
 
942
        case CARTRIDGE_REX:
 
943
            rex_detach();
 
944
            break;
 
945
        case CARTRIDGE_EXPERT:
 
946
            expert_detach();
 
947
            break;
 
948
        case CARTRIDGE_FINAL_I:
 
949
            final_v1_detach();
 
950
            break;
 
951
        case CARTRIDGE_EASYFLASH:
 
952
            easyflash_detach();
 
953
            break;
 
954
        case CARTRIDGE_WESTERMANN:
 
955
            westermann_detach();
 
956
            break;
 
957
        case CARTRIDGE_WARPSPEED:
 
958
            warpspeed_detach();
 
959
            break;
 
960
        case CARTRIDGE_FINAL_III:
 
961
            final_v3_detach();
 
962
            break;
 
963
        case CARTRIDGE_GENERIC_16KB:
 
964
            generic_16kb_detach();
 
965
            break;
 
966
        case CARTRIDGE_GENERIC_8KB:
 
967
            generic_8kb_detach();
 
968
            break;
 
969
        case CARTRIDGE_IDE64:
 
970
            ide64_detach();
 
971
            break;
 
972
        case CARTRIDGE_IEEE488:
 
973
            /* FIXME: Insert interface removal here.  */
 
974
            break;
 
975
        case CARTRIDGE_KCS_POWER:
 
976
            kcs_detach();
 
977
            break;
 
978
        case CARTRIDGE_SIMONS_BASIC:
 
979
            simon_detach();
 
980
            break;
 
981
        case CARTRIDGE_MAGIC_FORMEL:
 
982
            magicformel_detach();
 
983
            break;
 
984
        case CARTRIDGE_RETRO_REPLAY:
 
985
            retroreplay_detach();
 
986
            break;
 
987
        case CARTRIDGE_SUPER_GAMES:
 
988
            supergames_detach();
 
989
            break;
 
990
        case CARTRIDGE_COMAL80:
 
991
            comal80_detach();
 
992
            break;
 
993
        case CARTRIDGE_STRUCTURED_BASIC:
 
994
            stb_detach();
 
995
            break;
 
996
        case CARTRIDGE_ROSS:
 
997
            ross_detach();
 
998
            break;
 
999
        case CARTRIDGE_SUPER_SNAPSHOT:
 
1000
            supersnapshot_v4_detach();
 
1001
            break;
 
1002
        case CARTRIDGE_SUPER_SNAPSHOT_V5:
 
1003
            supersnapshot_v5_detach();
 
1004
            break;
 
1005
        case CARTRIDGE_ULTIMAX:
 
1006
            generic_ultimax_detach();
 
1007
            break;
 
1008
        case CARTRIDGE_ZAXXON:
 
1009
            zaxxon_detach();
 
1010
            break;
 
1011
        case CARTRIDGE_DELA_EP64:
 
1012
            delaep64_detach();
 
1013
            break;
 
1014
        case CARTRIDGE_DELA_EP7x8:
 
1015
            delaep7x8_detach();
 
1016
            break;
 
1017
        case CARTRIDGE_DELA_EP256:
 
1018
            delaep256_detach();
 
1019
            break;
 
1020
        case CARTRIDGE_REX_EP256:
 
1021
            rexep256_detach();
 
1022
            break;
1010
1023
    }
1011
1024
    cartridge_config_changed(6, 6, CMODE_READ);
1012
1025
    mem_cartridge_type = CARTRIDGE_NONE;
1024
1037
void cartridge_freeze(int type)
1025
1038
{
1026
1039
    switch (type) {
1027
 
      case CARTRIDGE_SUPER_SNAPSHOT:
1028
 
        supersnapshot_v4_freeze();
1029
 
        break;
1030
 
      case CARTRIDGE_SUPER_SNAPSHOT_V5:
1031
 
        supersnapshot_v5_freeze();
1032
 
        break;
1033
 
      case CARTRIDGE_ACTION_REPLAY4:
1034
 
        actionreplay4_freeze();
1035
 
        break;
1036
 
      case CARTRIDGE_ACTION_REPLAY3:
1037
 
        actionreplay3_freeze();
1038
 
        break;
1039
 
      case CARTRIDGE_ACTION_REPLAY:
1040
 
        actionreplay_freeze();
1041
 
        break;
1042
 
      case CARTRIDGE_ATOMIC_POWER:
1043
 
        atomicpower_freeze();
1044
 
        break;
1045
 
      case CARTRIDGE_RETRO_REPLAY:
1046
 
        retroreplay_freeze();
1047
 
        break;
1048
 
      case CARTRIDGE_KCS_POWER:
1049
 
        kcs_freeze();
1050
 
        break;
1051
 
      case CARTRIDGE_FINAL_I:
1052
 
        final_v1_freeze();
1053
 
        break;
1054
 
      case CARTRIDGE_FINAL_III:
1055
 
        final_v3_freeze();
1056
 
        break;
 
1040
        case CARTRIDGE_SUPER_SNAPSHOT:
 
1041
            supersnapshot_v4_freeze();
 
1042
            break;
 
1043
        case CARTRIDGE_SUPER_SNAPSHOT_V5:
 
1044
            supersnapshot_v5_freeze();
 
1045
            break;
 
1046
        case CARTRIDGE_ACTION_REPLAY4:
 
1047
            actionreplay4_freeze();
 
1048
            break;
 
1049
        case CARTRIDGE_ACTION_REPLAY3:
 
1050
            actionreplay3_freeze();
 
1051
            break;
 
1052
        case CARTRIDGE_ACTION_REPLAY:
 
1053
            actionreplay_freeze();
 
1054
            break;
 
1055
        case CARTRIDGE_ATOMIC_POWER:
 
1056
            atomicpower_freeze();
 
1057
            break;
 
1058
        case CARTRIDGE_RETRO_REPLAY:
 
1059
            retroreplay_freeze();
 
1060
            break;
 
1061
        case CARTRIDGE_KCS_POWER:
 
1062
            kcs_freeze();
 
1063
            break;
 
1064
        case CARTRIDGE_FINAL_I:
 
1065
            final_v1_freeze();
 
1066
            break;
 
1067
        case CARTRIDGE_FINAL_III:
 
1068
            final_v3_freeze();
 
1069
            break;
1057
1070
    }
1058
 
    if (isepic_enabled && isepic_switch)
1059
 
    {
 
1071
    if (isepic_enabled && isepic_switch) {
1060
1072
        isepic_freeze();
1061
1073
    }
1062
1074
}
1063
1075
 
1064
1076
int cartridge_save_image(const char *filename)
1065
1077
{
1066
 
    if (mem_cartridge_type == CARTRIDGE_EXPERT)
 
1078
    if (mem_cartridge_type == CARTRIDGE_EXPERT) {
1067
1079
        return crt_save_expert(filename);
 
1080
    }
1068
1081
 
1069
1082
    return -1;
1070
1083
}
1078
1091
{
1079
1092
    roml_bank = (int)bank;
1080
1093
}
1081