← Back to branch summary

~ubuntu-branches/ubuntu/maverick/vice/maverick

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Zed Pobre
  • Date: 2005-02-01 11:30:26 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20050201113026-3eyakzsmmheclvjg
Tags: 1.16-1
http://bugs.debian.org/287640
http://bugs.debian.org/286767
http://bugs.debian.org/152952
http://bugs.debian.org/207942
* New upstream version
* Fixes crash on 64-bit architectures (closes: #287640)
* x128 working again (closes: #286767)
* Works fine with /dev/dsp in use (not in the main changelog, but tested
  on my local machine as working).  Presumably, this also takes care of
  the issue with dsp being held.  I'm not sure if this is because I'm
  testing it on a 2.6 kernel now -- if you are still having problems
  with /dev/dsp, please reopen the bugs. (closes: #152952, #207942)
* Don't kill Makefile.in on clean

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/c64/cart/c64cartmem.c
46
46
#include "log.h"
47
47
#include "machine.h"
48
48
#include "maincpu.h"
 
49
#include "magicformel.h"
49
50
#include "resources.h"
50
51
#include "retroreplay.h"
51
52
#include "ide64.h"
134
135
        return supersnapshot_v5_io1_read(addr);
135
136
      case CARTRIDGE_EXPERT:
136
137
        return expert_io1_read(addr);
 
138
      case CARTRIDGE_MAGIC_FORMEL:
 
139
        return magicformel_io1_read(addr);
137
140
    }
138
141
    return vicii_read_phi1();
139
142
}
212
215
            export.exrom = 1;  /* turn off cart ROM */
213
216
        mem_pla_config_changed();
214
217
        break;
 
218
      case CARTRIDGE_MAGIC_FORMEL:
 
219
        magicformel_io1_store(addr, value);
 
220
        break;
215
221
    }
216
222
    return;
217
223
}
230
236
        return retroreplay_io2_read(addr);
231
237
      case CARTRIDGE_SUPER_SNAPSHOT:
232
238
        return supersnapshot_v4_io2_read(addr);
233
 
      case CARTRIDGE_SUPER_SNAPSHOT_V5:
234
 
        return supersnapshot_v5_io2_read(addr);
235
239
      case CARTRIDGE_FINAL_III:
236
240
        return final_v3_io2_read(addr);
237
241
      case CARTRIDGE_FINAL_I:
253
257
        return 0;
254
258
      case CARTRIDGE_WARPSPEED:
255
259
        return roml_banks[0x1f00 + (addr & 0xff)];
256
 
      case CARTRIDGE_EXPERT:
257
 
        return expert_io2_read(addr);
 
260
      case CARTRIDGE_MAGIC_FORMEL:
 
261
        return magicformel_io2_read(addr);
258
262
    }
259
263
    return vicii_read_phi1();
260
264
}
286
290
      case CARTRIDGE_SUPER_SNAPSHOT:
287
291
        supersnapshot_v4_io2_store(addr, value);
288
292
        break;
289
 
      case CARTRIDGE_SUPER_SNAPSHOT_V5:
290
 
        supersnapshot_v5_io2_store(addr, value);
291
 
        break;
292
293
      case CARTRIDGE_FINAL_III:
293
294
        final_v3_io2_store(addr, value);
294
295
        break;
298
299
      case CARTRIDGE_IEEE488:
299
300
        tpi_store((WORD)(addr & 0x07), value);
300
301
        break;
301
 
      case CARTRIDGE_EXPERT:
302
 
        expert_io2_store(addr, value);
 
302
      case CARTRIDGE_MAGIC_FORMEL:
 
303
        magicformel_io2_store(addr, value);
303
304
        break;
304
305
    }
305
 
    return;
306
306
}
307
307
 
308
308
BYTE REGPARM1 roml_read(WORD addr)
328
328
        return final_v1_roml_read(addr);
329
329
      case CARTRIDGE_FINAL_III:
330
330
        return final_v3_roml_read(addr);
 
331
      case CARTRIDGE_MAGIC_FORMEL:
 
332
        return magicformel_roml_read(addr);
331
333
    }
332
334
 
333
335
    if (export_ram)
336
338
    return roml_banks[(addr & 0x1fff) + (roml_bank << 13)];
337
339
}
338
340
 
339
 
BYTE REGPARM1 romh_read(WORD addr)
340
 
{
341
 
    switch (mem_cartridge_type) {
342
 
      case CARTRIDGE_ATOMIC_POWER:
343
 
        return atomicpower_romh_read(addr);
344
 
      case CARTRIDGE_EXPERT:
345
 
        return expert_romh_read(addr);
346
 
      case CARTRIDGE_OCEAN:
347
 
        /* 256 kB OCEAN carts may access memory either at $8000 or $a000 */
348
 
        return roml_banks[(addr & 0x1fff) + (romh_bank << 13)];
349
 
      case CARTRIDGE_IDE64:
350
 
        return romh_banks[(addr & 0x3fff) | (romh_bank << 14)];
351
 
    }
352
 
    return romh_banks[(addr & 0x1fff) + (romh_bank << 13)];
353
 
}
354
 
 
355
341
void REGPARM2 roml_store(WORD addr, BYTE value)
356
342
{
357
343
    switch (mem_cartridge_type) {
379
365
      case CARTRIDGE_FINAL_III:
380
366
        final_v3_roml_store(addr, value);
381
367
        return;
 
368
      case CARTRIDGE_MAGIC_FORMEL:
 
369
        magicformel_roml_store(addr, value);
 
370
        return;
382
371
    }
383
372
 
384
373
    if (export_ram)
385
374
        export_ram0[addr & 0x1fff] = value;
386
 
 
387
 
    return;
 
375
}
 
376
 
 
377
BYTE REGPARM1 romh_read(WORD addr)
 
378
{
 
379
    switch (mem_cartridge_type) {
 
380
      case CARTRIDGE_ATOMIC_POWER:
 
381
        return atomicpower_romh_read(addr);
 
382
      case CARTRIDGE_EXPERT:
 
383
        return expert_romh_read(addr);
 
384
      case CARTRIDGE_OCEAN:
 
385
        /* 256 kB OCEAN carts may access memory either at $8000 or $a000 */
 
386
        return roml_banks[(addr & 0x1fff) + (romh_bank << 13)];
 
387
      case CARTRIDGE_IDE64:
 
388
        return romh_banks[(addr & 0x3fff) | (romh_bank << 14)];
 
389
    }
 
390
    return romh_banks[(addr & 0x1fff) + (romh_bank << 13)];
 
391
}
 
392
 
 
393
void REGPARM2 romh_store(WORD addr, BYTE value)
 
394
{
 
395
    switch (mem_cartridge_type) {
 
396
      case CARTRIDGE_MAGIC_FORMEL:
 
397
        magicformel_romh_store(addr, value);
 
398
        return;
 
399
    }
 
400
}
 
401
 
 
402
BYTE REGPARM1 ultimax_1000_7fff_read(WORD addr)
 
403
{
 
404
    switch (mem_cartridge_type) {
 
405
      case CARTRIDGE_IDE64:
 
406
        return export_ram0[addr & 0x7fff];
 
407
      case CARTRIDGE_MAGIC_FORMEL:
 
408
        return magicformel_1000_7fff_read(addr);
 
409
    }
 
410
    return vicii_read_phi1();
 
411
}
 
412
 
 
413
void REGPARM2 ultimax_1000_7fff_store(WORD addr, BYTE value)
 
414
{
 
415
    switch (mem_cartridge_type) {
 
416
      case CARTRIDGE_IDE64:
 
417
        export_ram0[addr & 0x7fff] = value;
 
418
        break;
 
419
      case CARTRIDGE_MAGIC_FORMEL:
 
420
        magicformel_1000_7fff_store(addr, value);
 
421
        break;
 
422
    }
388
423
}
389
424
 
390
425
BYTE REGPARM1 ultimax_a000_bfff_read(WORD addr)
394
429
        return atomicpower_a000_bfff_read(addr);
395
430
      case CARTRIDGE_IDE64:
396
431
        return romh_banks[(addr & 0x3fff) | (romh_bank << 14)];
397
 
    }
398
 
    return vicii_read_phi1();
399
 
}
400
 
 
401
 
BYTE REGPARM1 ultimax_1000_7fff_read(WORD addr)
402
 
{
403
 
    switch (mem_cartridge_type) {
404
 
      case CARTRIDGE_IDE64:
405
 
        return export_ram0[addr & 0x7fff];
406
 
    }
407
 
    return vicii_read_phi1();
408
 
}
409
 
 
410
 
BYTE REGPARM1 ultimax_c000_cfff_read(WORD addr)
411
 
{
412
 
    switch (mem_cartridge_type) {
413
 
      case CARTRIDGE_IDE64:
414
 
        return export_ram0[addr & 0x7fff];
 
432
      case CARTRIDGE_MAGIC_FORMEL:
 
433
        return magicformel_a000_bfff_read(addr);
415
434
    }
416
435
    return vicii_read_phi1();
417
436
}
421
440
    switch (mem_cartridge_type) {
422
441
      case CARTRIDGE_ATOMIC_POWER:
423
442
        atomicpower_a000_bfff_store(addr, value);
 
443
        break;
 
444
      case CARTRIDGE_MAGIC_FORMEL:
 
445
        magicformel_a000_bfff_store(addr, value);
 
446
        break;
424
447
    }
425
 
    return;
426
448
}
427
449
 
428
 
void REGPARM2 ultimax_1000_7fff_store(WORD addr, BYTE value)
 
450
BYTE REGPARM1 ultimax_c000_cfff_read(WORD addr)
429
451
{
430
452
    switch (mem_cartridge_type) {
431
453
      case CARTRIDGE_IDE64:
432
 
        export_ram0[addr & 0x7fff]=value;
 
454
        return export_ram0[addr & 0x7fff];
 
455
      case CARTRIDGE_MAGIC_FORMEL:
 
456
        return magicformel_c000_cfff_read(addr);
433
457
    }
434
 
    return;
 
458
    return vicii_read_phi1();
435
459
}
436
460
 
437
461
void REGPARM2 ultimax_c000_cfff_store(WORD addr, BYTE value)
438
462
{
439
463
    switch (mem_cartridge_type) {
440
464
      case CARTRIDGE_IDE64:
441
 
        export_ram0[addr & 0x7fff]=value;
442
 
    }
443
 
    return;
 
465
        export_ram0[addr & 0x7fff] = value;
 
466
        break;
 
467
      case CARTRIDGE_MAGIC_FORMEL:
 
468
        magicformel_c000_cfff_store(addr, value);
 
469
        break;
 
470
    }
 
471
}
 
472
 
 
473
BYTE REGPARM1 ultimax_d000_dfff_read(WORD addr)
 
474
{
 
475
    switch (mem_cartridge_type) {
 
476
      case CARTRIDGE_MAGIC_FORMEL:
 
477
        return magicformel_d000_dfff_read(addr);
 
478
    }
 
479
    return read_bank_io(addr);
 
480
}
 
481
 
 
482
void REGPARM2 ultimax_d000_dfff_store(WORD addr, BYTE value)
 
483
{
 
484
    switch (mem_cartridge_type) {
 
485
      case CARTRIDGE_MAGIC_FORMEL:
 
486
        magicformel_d000_dfff_store(addr, value);
 
487
        break;
 
488
    }
 
489
    store_bank_io(addr, value);
444
490
}
445
491
 
446
492
void REGPARM1 cartridge_decode_address(WORD addr)
525
571
        cartridge_config_changed(0, 0, CMODE_READ);
526
572
        cartridge_store_io1((WORD)0xde00, 0);
527
573
        break;
 
574
      case CARTRIDGE_MAGIC_FORMEL:
 
575
        magicformel_config_init();
 
576
        break;
528
577
      default:
529
578
        cartridge_config_changed(2, 2, CMODE_READ);
530
579
    }
616
665
        memcpy(roml_banks, rawcart, 0x2000 * 64);
617
666
        cartridge_config_changed(0, 0, CMODE_READ);
618
667
        break;
 
668
      case CARTRIDGE_MAGIC_FORMEL:
 
669
        magicformel_config_setup(rawcart);
 
670
        break;
619
671
      default:
620
672
        mem_cartridge_type = CARTRIDGE_NONE;
621
673
    }
635
687
    int cartridge_reset;
636
688
 
637
689
    switch (type) {
638
 
      case CARTRIDGE_IEEE488:
639
 
      /* FIXME: Insert interface removal here.  */
640
 
      break;
 
690
      case CARTRIDGE_ACTION_REPLAY:
 
691
        actionreplay_detach();
 
692
        break;
 
693
      case CARTRIDGE_ATOMIC_POWER:
 
694
        atomicpower_detach();
 
695
        break;
 
696
      case CARTRIDGE_EPYX_FASTLOAD:
 
697
        epyxfastload_detach();
 
698
        break;
 
699
      case CARTRIDGE_EXPERT:
 
700
        expert_detach();
 
701
        break;
 
702
      case CARTRIDGE_FINAL_I:
 
703
        final_v1_detach();
 
704
        break;
 
705
      case CARTRIDGE_FINAL_III:
 
706
        final_v3_detach();
 
707
        break;
 
708
      case CARTRIDGE_GENERIC_16KB:
 
709
        generic_16kb_detach();
 
710
        break;
 
711
      case CARTRIDGE_GENERIC_8KB:
 
712
        generic_8kb_detach();
 
713
        break;
641
714
      case CARTRIDGE_IDE64:
642
715
        ide64_detach();
643
 
      break;
 
716
        break;
 
717
      case CARTRIDGE_IEEE488:
 
718
        /* FIXME: Insert interface removal here.  */
 
719
        break;
 
720
      case CARTRIDGE_KCS_POWER:
 
721
        kcs_detach();
 
722
        break;
 
723
      case CARTRIDGE_MAGIC_FORMEL:
 
724
        magicformel_detach();
 
725
        break;
 
726
      case CARTRIDGE_RETRO_REPLAY:
 
727
        retroreplay_detach();
 
728
        break;
 
729
      case CARTRIDGE_SUPER_GAMES:
 
730
        supergames_detach();
 
731
        break;
 
732
      case CARTRIDGE_SUPER_SNAPSHOT:
 
733
        supersnapshot_v4_detach();
 
734
        break;
 
735
      case CARTRIDGE_SUPER_SNAPSHOT_V5:
 
736
        supersnapshot_v5_detach();
 
737
        break;
 
738
      case CARTRIDGE_ULTIMAX:
 
739
        generic_ultimax_detach();
 
740
        break;
 
741
      case CARTRIDGE_ZAXXON:
 
742
        zaxxon_detach();
 
743
        break;
644
744
    }
645
745
    cartridge_config_changed(6, 6, CMODE_READ);
646
746
    mem_cartridge_type = CARTRIDGE_NONE;