← Back to branch summary

~ubuntu-branches/ubuntu/utopic/vice/utopic-proposed

« back to all changes in this revision

Viewing changes to src/cbm2/cbm5x0mem.c

  • Committer: Package Import Robot
  • Author(s): Logan Rosen
  • Date: 2014-05-10 21:08:23 UTC
  • mfrom: (17.1.1 sid)
  • Revision ID: package-import@ubuntu.com-20140510210823-v5aojvy1pv1sg132
Tags: 2.4.dfsg+2.4.6-1ubuntu1
Use autotools-dev to update config.{sub,guess} for new arches.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/cbm2/cbm5x0mem.c
58
58
 
59
59
void cia1_set_extended_keyboard_rows_mask(BYTE foo)
60
60
{
61
 
 
62
61
}
63
62
 
64
63
/* ------------------------------------------------------------------------- */
117
116
 
118
117
void c500_set_phi2_bank(int b)
119
118
{
120
 
    if (b == c500_statvid)
 
119
    if (b == c500_statvid) {
121
120
        return;
 
121
    }
122
122
 
123
123
    if (b) {    /* bank 15 */
124
124
        /* video memory at $c000/d000 depending on d818 */
143
143
 
144
144
void c500_set_phi1_bank(int b)
145
145
{
146
 
    if (b == c500_vicdotsel)
 
146
    if (b == c500_vicdotsel) {
147
147
        return;
 
148
    }
148
149
 
149
150
    if (b) {    /* bank 15 */
150
151
        /* video memory at $c000/c800 depending on d818 */
198
199
 
199
200
    val &= 0x0f;
200
201
    if (val != cbm2mem_bank_exec) {
201
 
 
202
202
        cbm2mem_bank_exec = val;
203
203
 
204
204
        _mem_read_tab_ptr = _mem_read_tab[cbm2mem_bank_exec];
205
205
        _mem_write_tab_ptr = _mem_write_tab[cbm2mem_bank_exec];
206
206
        _mem_read_base_tab_ptr = _mem_read_base_tab[cbm2mem_bank_exec];
207
207
        mem_read_limit_tab_ptr = mem_read_limit_tab[(cbm2mem_bank_exec < 15)
208
 
                                 ? 0 : 1];
 
208
                                                    ? 0 : 1];
209
209
        if (!_mem_read_base_tab_ptr[0]) {
210
 
                /* disable fast opcode fetch when bank_base is null, i.e.
211
 
                   set all limits to 0 when no RAM available.
212
 
                   This might also happen when jumping to open mem in
213
 
                   bank 15, though. */
 
210
            /* disable fast opcode fetch when bank_base is null, i.e.
 
211
               set all limits to 0 when no RAM available.
 
212
               This might also happen when jumping to open mem in
 
213
               bank 15, though. */
214
214
            mem_read_limit_tab_ptr = mem_read_limit_tab[2];
215
215
        }
216
216
 
226
226
 
227
227
        /* This sets the pointers to otherwise non-mapped memory, to
228
228
           avoid that the CPU code uses illegal memory and segfaults. */
229
 
        if (!mem_page_zero)
 
229
        if (!mem_page_zero) {
230
230
            mem_page_zero = mem_ram + 0xf0000;
231
 
        if (!mem_page_one)
 
231
        }
 
232
        if (!mem_page_one) {
232
233
            mem_page_one = mem_ram + 0xf0100;
 
234
        }
233
235
    }
234
236
}
235
237
 
253
255
 
254
256
void zero_store(WORD addr, BYTE value)
255
257
{
256
 
    if (addr == 0)
 
258
    if (addr == 0) {
257
259
        cbm2mem_set_bank_exec(value);
258
 
    else
259
 
      if (addr == 1)
260
 
          cbm2mem_set_bank_ind(value);
 
260
    } else
 
261
    if (addr == 1) {
 
262
        cbm2mem_set_bank_ind(value);
 
263
    }
261
264
 
262
265
    _mem_write_tab_ptr[0]((WORD)(addr & 0xff), value);
263
266
}
264
267
 
265
 
#define STORE_ZERO(bank)                                          \
 
268
#define STORE_ZERO(bank)                                 \
266
269
    static void store_zero_##bank(WORD addr, BYTE value) \
267
 
    {                                                             \
268
 
        addr &= 0xff;                                             \
269
 
                                                                  \
270
 
        if (addr == 0)                                            \
271
 
            cbm2mem_set_bank_exec(value);                         \
272
 
        else                                                      \
273
 
        if (addr == 1)                                            \
274
 
            cbm2mem_set_bank_ind(value);                          \
275
 
                                                                  \
276
 
        mem_ram[(0x##bank << 16) | addr] = value;                 \
277
 
    }
278
 
 
279
 
 
280
 
#define READ_ZERO(bank)                                     \
281
 
    static BYTE read_zero_##bank(WORD addr)        \
282
 
    {                                                       \
283
 
        return mem_ram[(0x##bank << 16) | (addr & 0xff)];   \
284
 
    }
285
 
 
286
 
#define READ_RAM(bank)                                      \
287
 
    static BYTE read_ram_##bank(WORD addr)         \
288
 
    {                                                       \
289
 
        return mem_ram[(0x##bank << 16) | addr];            \
290
 
    }
291
 
 
292
 
#define STORE_RAM(bank)                                         \
 
270
    {                                                    \
 
271
        addr &= 0xff;                                    \
 
272
                                                         \
 
273
        if (addr == 0) {                                 \
 
274
            cbm2mem_set_bank_exec(value);                \
 
275
        } else if (addr == 1) {                          \
 
276
            cbm2mem_set_bank_ind(value);                 \
 
277
        }                                                \
 
278
                                                         \
 
279
        mem_ram[(0x##bank << 16) | addr] = value;        \
 
280
    }
 
281
 
 
282
#define READ_ZERO(bank)                                   \
 
283
    static BYTE read_zero_##bank(WORD addr)               \
 
284
    {                                                     \
 
285
        return mem_ram[(0x##bank << 16) | (addr & 0xff)]; \
 
286
    }
 
287
 
 
288
#define READ_RAM(bank)                           \
 
289
    static BYTE read_ram_##bank(WORD addr)       \
 
290
    {                                            \
 
291
        return mem_ram[(0x##bank << 16) | addr]; \
 
292
    }
 
293
 
 
294
#define STORE_RAM(bank)                                \
293
295
    static void store_ram_##bank(WORD addr, BYTE byte) \
294
 
    {                                                           \
295
 
        mem_ram[(0x##bank << 16) | addr] = byte;                \
 
296
    {                                                  \
 
297
        mem_ram[(0x##bank << 16) | addr] = byte;       \
296
298
    }
297
299
 
298
300
STORE_ZERO(0)
364
366
READ_RAM(F)
365
367
 
366
368
static store_func_ptr_t store_zero_tab[16] = {
367
 
        store_zero_0, store_zero_1, store_zero_2, store_zero_3,
368
 
        store_zero_4, store_zero_5, store_zero_6, store_zero_7,
369
 
        store_zero_8, store_zero_9, store_zero_A, store_zero_B,
370
 
        store_zero_C, store_zero_D, store_zero_E, store_zero_F
 
369
    store_zero_0, store_zero_1, store_zero_2, store_zero_3,
 
370
    store_zero_4, store_zero_5, store_zero_6, store_zero_7,
 
371
    store_zero_8, store_zero_9, store_zero_A, store_zero_B,
 
372
    store_zero_C, store_zero_D, store_zero_E, store_zero_F
371
373
};
372
374
 
373
375
static store_func_ptr_t store_ram_tab[16] = {
374
 
        store_ram_0, store_ram_1, store_ram_2, store_ram_3,
375
 
        store_ram_4, store_ram_5, store_ram_6, store_ram_7,
376
 
        store_ram_8, store_ram_9, store_ram_A, store_ram_B,
377
 
        store_ram_C, store_ram_D, store_ram_E, store_ram_F
 
376
    store_ram_0, store_ram_1, store_ram_2, store_ram_3,
 
377
    store_ram_4, store_ram_5, store_ram_6, store_ram_7,
 
378
    store_ram_8, store_ram_9, store_ram_A, store_ram_B,
 
379
    store_ram_C, store_ram_D, store_ram_E, store_ram_F
378
380
};
379
381
 
380
382
static read_func_ptr_t read_ram_tab[16] = {
381
 
        read_ram_0, read_ram_1, read_ram_2, read_ram_3,
382
 
        read_ram_4, read_ram_5, read_ram_6, read_ram_7,
383
 
        read_ram_8, read_ram_9, read_ram_A, read_ram_B,
384
 
        read_ram_C, read_ram_D, read_ram_E, read_ram_F
 
383
    read_ram_0, read_ram_1, read_ram_2, read_ram_3,
 
384
    read_ram_4, read_ram_5, read_ram_6, read_ram_7,
 
385
    read_ram_8, read_ram_9, read_ram_A, read_ram_B,
 
386
    read_ram_C, read_ram_D, read_ram_E, read_ram_F
385
387
};
386
388
 
387
389
static read_func_ptr_t read_zero_tab[16] = {
388
 
        read_zero_0, read_zero_1, read_zero_2, read_zero_3,
389
 
        read_zero_4, read_zero_5, read_zero_6, read_zero_7,
390
 
        read_zero_8, read_zero_9, read_zero_A, read_zero_B,
391
 
        read_zero_C, read_zero_D, read_zero_E, read_zero_F
 
390
    read_zero_0, read_zero_1, read_zero_2, read_zero_3,
 
391
    read_zero_4, read_zero_5, read_zero_6, read_zero_7,
 
392
    read_zero_8, read_zero_9, read_zero_A, read_zero_B,
 
393
    read_zero_C, read_zero_D, read_zero_E, read_zero_F
392
394
};
393
395
 
394
396
 
395
397
void store_zeroX(WORD addr, BYTE value)
396
398
{
397
 
    if (addr == 0)
 
399
    if (addr == 0) {
398
400
        cbm2mem_set_bank_exec(value);
399
 
    else
400
 
        if (addr == 1)
401
 
            cbm2mem_set_bank_ind(value);
 
401
    } else if (addr == 1) {
 
402
        cbm2mem_set_bank_ind(value);
 
403
    }
402
404
}
403
405
 
404
406
BYTE rom_read(WORD addr)
430
432
 
431
433
/* Functions for watchpoint memory access.  */
432
434
 
 
435
static BYTE zero_read_watch(WORD addr)
 
436
{
 
437
    addr &= 0xff;
 
438
    monitor_watch_push_load_addr(addr, e_comp_space);
 
439
    return _mem_read_tab[cbm2mem_bank_exec][0](addr);
 
440
}
 
441
 
 
442
static void zero_store_watch(WORD addr, BYTE value)
 
443
{
 
444
    addr &= 0xff;
 
445
    monitor_watch_push_store_addr(addr, e_comp_space);
 
446
    _mem_write_tab[cbm2mem_bank_exec][0](addr, value);
 
447
}
 
448
 
433
449
BYTE read_watch(WORD addr)
434
450
{
435
451
    monitor_watch_push_load_addr(addr, e_comp_space);
473
489
void store_io(WORD addr, BYTE value)
474
490
{
475
491
    switch (addr & 0xf800) {
476
 
      case 0xd000:
477
 
        rom_store(addr, value);         /* video RAM mapped here... */
478
 
        if (addr >= 0xd400) {
479
 
            colorram_store(addr, value);
480
 
        }
481
 
        return;
482
 
      case 0xd800:
483
 
        switch(addr & 0xff00) {
484
 
          case 0xd800:
485
 
            vicii_store(addr, value);
486
 
            return;
487
 
          case 0xd900:
488
 
            return;                     /* disk units */
489
 
          case 0xda00:
490
 
            sid_store((WORD)(addr & 0xff), value);
491
 
            return;
492
 
          case 0xdb00:
493
 
            return;                     /* coprocessor */
494
 
          case 0xdc00:
495
 
            cia1_store((WORD)(addr & 0x0f), value);
496
 
            return;
497
 
          case 0xdd00:
498
 
            acia1_store((WORD)(addr & 0x03), value);
499
 
            return;
500
 
          case 0xde00:
501
 
            tpi1_store((WORD)(addr & 0x07), value);
502
 
            return;
503
 
          case 0xdf00:
504
 
            tpi2_store((WORD)(addr & 0x07), value);
505
 
            return;
506
 
        }
 
492
        case 0xd000:
 
493
            rom_store(addr, value);     /* video RAM mapped here... */
 
494
            if (addr >= 0xd400) {
 
495
                colorram_store(addr, value);
 
496
            }
 
497
            return;
 
498
        case 0xd800:
 
499
            switch (addr & 0xff00) {
 
500
                case 0xd800:
 
501
                    vicii_store(addr, value);
 
502
                    return;
 
503
                case 0xd900:
 
504
                    return;             /* disk units */
 
505
                case 0xda00:
 
506
                    sid_store((WORD)(addr & 0xff), value);
 
507
                    return;
 
508
                case 0xdb00:
 
509
                    return;             /* coprocessor */
 
510
                case 0xdc00:
 
511
                    cia1_store((WORD)(addr & 0x0f), value);
 
512
                    return;
 
513
                case 0xdd00:
 
514
                    acia1_store((WORD)(addr & 0x03), value);
 
515
                    return;
 
516
                case 0xde00:
 
517
                    tpi1_store((WORD)(addr & 0x07), value);
 
518
                    return;
 
519
                case 0xdf00:
 
520
                    tpi2_store((WORD)(addr & 0x07), value);
 
521
                    return;
 
522
            }
507
523
    }
508
524
}
509
525
 
510
526
BYTE read_io(WORD addr)
511
527
{
512
528
    switch (addr & 0xf800) {
513
 
      case 0xd000:
514
 
        return rom_read(addr);
515
 
      case 0xd800:
516
 
        switch (addr & 0xff00) {
517
 
          case 0xd800:
518
 
            return vicii_read(addr);
519
 
          case 0xd900:
520
 
            return read_unused(addr);
521
 
          case 0xda00:
522
 
            return sid_read(addr);
523
 
          case 0xdb00:
524
 
            return read_unused(addr);
525
 
          case 0xdc00:
526
 
            return cia1_read((WORD)(addr & 0x0f));
527
 
          case 0xdd00:
528
 
            return acia1_read((WORD)(addr & 0x03));
529
 
          case 0xde00:
530
 
            /* FIXME: VIC-II irq? */
531
 
            /* if ((machine_class == VICE_MACHINE_CBM5x0) && ((addr & 7) == 2)) {
532
 
                   return tpi1_read(addr&7)|1; }   */
533
 
            return tpi1_read((WORD)(addr & 0x07));
534
 
          case 0xdf00:
535
 
            return tpi2_read((WORD)(addr & 0x07));
536
 
        }
 
529
        case 0xd000:
 
530
            return rom_read(addr);
 
531
        case 0xd800:
 
532
            switch (addr & 0xff00) {
 
533
                case 0xd800:
 
534
                    return vicii_read(addr);
 
535
                case 0xd900:
 
536
                    return read_unused(addr);
 
537
                case 0xda00:
 
538
                    return sid_read(addr);
 
539
                case 0xdb00:
 
540
                    return read_unused(addr);
 
541
                case 0xdc00:
 
542
                    return cia1_read((WORD)(addr & 0x0f));
 
543
                case 0xdd00:
 
544
                    return acia1_read((WORD)(addr & 0x03));
 
545
                case 0xde00:
 
546
                    /* FIXME: VIC-II irq? */
 
547
                    /* if ((machine_class == VICE_MACHINE_CBM5x0) && ((addr & 7) == 2)) {
 
548
                           return tpi1_read(addr&7)|1; }   */
 
549
                    return tpi1_read((WORD)(addr & 0x07));
 
550
                case 0xdf00:
 
551
                    return tpi2_read((WORD)(addr & 0x07));
 
552
            }
537
553
    }
538
554
    return read_unused(addr);
539
555
}
556
572
/* ------------------------------------------------------------------------- */
557
573
/* handle CPU reset */
558
574
 
559
 
void mem_reset(void) {
 
575
void mem_reset(void)
 
576
{
560
577
    cbm2mem_set_bank_exec(15);
561
578
    cbm2mem_set_bank_ind(15);
562
579
 
592
609
    }
593
610
 
594
611
    /* set bank limit tables for optimized opcode fetch */
595
 
    for (i=256;i>=0;i--) {
 
612
    for (i = 256; i >= 0; i--) {
596
613
        mem_read_limit_tab[0][i] = 0xfffd;      /* all RAM banks go here */
597
614
        mem_read_limit_tab[2][i] = 0;           /* all empty banks go here */
598
615
 
620
637
        if (i < 0xc0) { /* ROM 8000-BFFF */
621
638
            mem_read_limit_tab[1][i] = 0xbffd;
622
639
        } else
623
 
        if (i <0xd0) {  /* C000-CFFF */
 
640
        if (i < 0xd0) {  /* C000-CFFF */
624
641
            mem_read_limit_tab[1][i] = 0xcffd;
625
642
        } else
626
643
        if (i < 0xe0) { /* I/O D000-DFFF */
631
648
    }
632
649
 
633
650
    /* set watchpoint tables */
634
 
    for (i = 256; i >= 0; i--) {
 
651
    for (i = 0; i <= 0x100; i++) {
635
652
        _mem_read_tab_watch[i] = read_watch;
636
653
        _mem_read_ind_tab_watch[i] = read_ind_watch;
637
654
        _mem_write_tab_watch[i] = store_watch;
638
655
        _mem_write_ind_tab_watch[i] = store_ind_watch;
639
656
    }
 
657
    /* FIXME: what about _ind_tab_watch ? */
 
658
    _mem_read_tab_watch[0] = zero_read_watch;
 
659
    _mem_write_tab_watch[0] = zero_store_watch;
640
660
 
641
661
    vicii_set_chargen_addr_options(0x7000, 0x1000);
642
662
}
646
666
    int j;
647
667
 
648
668
    switch (i) {
649
 
      case 0:
650
 
        for (j = 255; j >= 0; j--) {
651
 
            _mem_read_tab[i][j] = read_ram_tab[i];
652
 
            _mem_write_tab[i][j] = store_ram_tab[i];
653
 
            _mem_read_base_tab[i][j] = mem_ram + (i << 16) + (j << 8);
654
 
        }
655
 
        _mem_write_tab[i][0] = store_zero_tab[i];
656
 
        _mem_read_tab[i][0] = read_zero_tab[i];
657
 
        break;
658
 
      case 1:
659
 
        for (j = 255; j >= 0; j--) {
660
 
            _mem_read_tab[i][j] = read_ram_tab[i];
661
 
            _mem_write_tab[i][j] = store_ram_tab[i];
662
 
            _mem_read_base_tab[i][j] = mem_ram + (i << 16) + (j << 8);
663
 
        }
664
 
        _mem_write_tab[i][0] = store_zero_tab[i];
665
 
        _mem_read_tab[i][0] = read_zero_tab[i];
666
 
        break;
667
 
      case 2:
668
 
        if (ramsize >= 128) {
669
 
            for (j = 255; j >= 0; j--) {
670
 
                _mem_read_tab[i][j] = read_ram_tab[i];
671
 
                _mem_write_tab[i][j] = store_ram_tab[i];
672
 
                _mem_read_base_tab[i][j] = mem_ram + (i << 16) + (j << 8);
673
 
            }
674
 
            _mem_write_tab[i][0] = store_zero_tab[i];
675
 
            _mem_read_tab[i][0] = read_zero_tab[i];
676
 
            break;
677
 
        }
678
 
      case 3:
679
 
      case 4:
680
 
        if (ramsize >= 256) {
681
 
            for (j = 255; j >= 0; j--) {
682
 
                _mem_read_tab[i][j] = read_ram_tab[i];
683
 
                _mem_write_tab[i][j] = store_ram_tab[i];
684
 
                _mem_read_base_tab[i][j] = mem_ram + (i << 16) + (j << 8);
685
 
            }
686
 
            _mem_write_tab[i][0] = store_zero_tab[i];
687
 
            _mem_read_tab[i][0] = read_zero_tab[i];
688
 
            break;
689
 
        }
690
 
      case 5:
691
 
      case 6:
692
 
      case 7:
693
 
        if (ramsize >= 512) {
694
 
            for (j = 255; j >= 0; j--) {
695
 
                _mem_read_tab[i][j] = read_ram_tab[i];
696
 
                _mem_write_tab[i][j] = store_ram_tab[i];
697
 
                _mem_read_base_tab[i][j] = mem_ram + (i << 16) + (j << 8);
698
 
            }
699
 
            _mem_write_tab[i][0] = store_zero_tab[i];
700
 
            _mem_read_tab[i][0] = read_zero_tab[i];
701
 
            break;
702
 
        }
703
 
      case 8:
704
 
      case 9:
705
 
      case 10:
706
 
      case 11:
707
 
      case 12:
708
 
      case 13:
709
 
      case 14:
710
 
        if (ramsize >= 1024) {
711
 
            for (j = 255; j >= 0; j--) {
712
 
                _mem_read_tab[i][j] = read_ram_tab[i];
713
 
                _mem_write_tab[i][j] = store_ram_tab[i];
714
 
                _mem_read_base_tab[i][j] = mem_ram + (i << 16) + (j << 8);
715
 
            }
716
 
           _mem_write_tab[i][0] = store_zero_tab[i];
717
 
           _mem_read_tab[i][0] = read_zero_tab[i];
718
 
           break;
719
 
        }
720
 
        /* fallback for ramsize < some_value */
721
 
        for (j = 255; j >= 0; j--) {
722
 
            _mem_read_tab[i][j] = read_unused;
723
 
            _mem_write_tab[i][j] = store_dummy;
724
 
            _mem_read_base_tab[i][j] = NULL;
725
 
        }
726
 
        _mem_write_tab[i][0] = store_zeroX;
727
 
        break;
728
 
      case 15:
729
 
        for (j = 0; j < 0x08; j++) {
730
 
            _mem_read_tab[i][j] = read_ram_F;
731
 
            _mem_write_tab[i][j] = store_ram_F;
732
 
            _mem_read_base_tab[i][j] = mem_ram + (i << 16) + (j << 8);
733
 
        }
734
 
        for (; j < 0xc0; j++) { /* 0800-BFFF */
735
 
            _mem_read_tab[i][j] = rom_read;
736
 
            _mem_write_tab[i][j] = store_dummy;
737
 
            _mem_read_base_tab[i][j] = mem_rom + (j << 8);
738
 
        }
739
 
        for (; j < 0xd0; j++) { /* C000-CFFF */
740
 
            _mem_read_tab[i][j] = read_chargen;
741
 
            _mem_write_tab[i][j] = store_dummy;
742
 
            _mem_read_base_tab[i][j] = mem_chargen_rom + ((j << 8) & 0x0f);
743
 
        }
744
 
        for (; j < 0xe0; j++) { /* D000-DFFF */
745
 
            _mem_read_tab[i][j] = read_io;
746
 
            _mem_write_tab[i][j] = store_io;
747
 
            _mem_read_base_tab[i][j] = NULL;
748
 
        }
749
 
        for (; j < 0x100; j++) {
750
 
            _mem_read_tab[i][j] = rom_read;
751
 
            _mem_write_tab[i][j] = store_dummy;
752
 
            _mem_read_base_tab[i][j] = mem_rom + (j << 8);
753
 
        }
754
 
 
755
 
        if (cart08_ram) {
756
 
            for (j = 0x08; j < 0x10; j++) {
757
 
                _mem_read_tab[i][j] = read_ram_F;
758
 
                _mem_write_tab[i][j] = store_ram_F;
759
 
                _mem_read_base_tab[i][j] = mem_ram + (i << 16) + (j << 8);
760
 
            }
761
 
        }
762
 
        if (cart1_ram) {
763
 
            for (j=0x10;j<0x20;j++) {
764
 
                _mem_read_tab[i][j] = read_ram_F;
765
 
                _mem_write_tab[i][j] = store_ram_F;
766
 
                _mem_read_base_tab[i][j] = mem_ram + (i << 16) + (j << 8);
767
 
            }
768
 
        }
769
 
        if (cart2_ram) {
770
 
            for (j = 0x20; j < 0x40; j++) {
771
 
                _mem_read_tab[i][j] = read_ram_F;
772
 
                _mem_write_tab[i][j] = store_ram_F;
773
 
                _mem_read_base_tab[i][j] = mem_ram + (i << 16) + (j << 8);
774
 
            }
775
 
        }
776
 
        if (cart4_ram) {
777
 
            for (j = 0x40; j < 0x60; j++) {
778
 
                _mem_read_tab[i][j] = read_ram_F;
779
 
                _mem_write_tab[i][j] = store_ram_F;
780
 
                _mem_read_base_tab[i][j] = mem_ram + (i << 16) + (j << 8);
781
 
            }
782
 
        }
783
 
        if (cart6_ram) {
784
 
            for (j = 0x60; j < 0x80; j++) {
785
 
                _mem_read_tab[i][j] = read_ram_F;
786
 
                _mem_write_tab[i][j] = store_ram_F;
787
 
                _mem_read_base_tab[i][j] = mem_ram + (i << 16) + (j << 8);
788
 
            }
789
 
        }
790
 
        if (cartC_ram) {
791
 
            for (j = 0xc0; j < 0xd0; j++) {
792
 
                _mem_read_tab[i][j] = read_ram_F;
793
 
                _mem_write_tab[i][j] = store_ram_F;
794
 
                _mem_read_base_tab[i][j] = mem_ram + (i << 16) + (j << 8);
795
 
            }
796
 
        }
797
 
 
798
 
        _mem_write_tab[i][0] = store_zero_F;
799
 
        _mem_read_tab[i][0] = read_zero_F;
800
 
        _mem_read_base_tab[i][0] = mem_ram + 0xf0000;
801
 
        break;
 
669
        case 0:
 
670
            for (j = 255; j >= 0; j--) {
 
671
                _mem_read_tab[i][j] = read_ram_tab[i];
 
672
                _mem_write_tab[i][j] = store_ram_tab[i];
 
673
                _mem_read_base_tab[i][j] = mem_ram + (i << 16) + (j << 8);
 
674
            }
 
675
            _mem_write_tab[i][0] = store_zero_tab[i];
 
676
            _mem_read_tab[i][0] = read_zero_tab[i];
 
677
            break;
 
678
        case 1:
 
679
            for (j = 255; j >= 0; j--) {
 
680
                _mem_read_tab[i][j] = read_ram_tab[i];
 
681
                _mem_write_tab[i][j] = store_ram_tab[i];
 
682
                _mem_read_base_tab[i][j] = mem_ram + (i << 16) + (j << 8);
 
683
            }
 
684
            _mem_write_tab[i][0] = store_zero_tab[i];
 
685
            _mem_read_tab[i][0] = read_zero_tab[i];
 
686
            break;
 
687
        case 2:
 
688
            if (ramsize >= 128) {
 
689
                for (j = 255; j >= 0; j--) {
 
690
                    _mem_read_tab[i][j] = read_ram_tab[i];
 
691
                    _mem_write_tab[i][j] = store_ram_tab[i];
 
692
                    _mem_read_base_tab[i][j] = mem_ram + (i << 16) + (j << 8);
 
693
                }
 
694
                _mem_write_tab[i][0] = store_zero_tab[i];
 
695
                _mem_read_tab[i][0] = read_zero_tab[i];
 
696
                break;
 
697
            }
 
698
        case 3:
 
699
        case 4:
 
700
            if (ramsize >= 256) {
 
701
                for (j = 255; j >= 0; j--) {
 
702
                    _mem_read_tab[i][j] = read_ram_tab[i];
 
703
                    _mem_write_tab[i][j] = store_ram_tab[i];
 
704
                    _mem_read_base_tab[i][j] = mem_ram + (i << 16) + (j << 8);
 
705
                }
 
706
                _mem_write_tab[i][0] = store_zero_tab[i];
 
707
                _mem_read_tab[i][0] = read_zero_tab[i];
 
708
                break;
 
709
            }
 
710
        case 5:
 
711
        case 6:
 
712
        case 7:
 
713
            if (ramsize >= 512) {
 
714
                for (j = 255; j >= 0; j--) {
 
715
                    _mem_read_tab[i][j] = read_ram_tab[i];
 
716
                    _mem_write_tab[i][j] = store_ram_tab[i];
 
717
                    _mem_read_base_tab[i][j] = mem_ram + (i << 16) + (j << 8);
 
718
                }
 
719
                _mem_write_tab[i][0] = store_zero_tab[i];
 
720
                _mem_read_tab[i][0] = read_zero_tab[i];
 
721
                break;
 
722
            }
 
723
        case 8:
 
724
        case 9:
 
725
        case 10:
 
726
        case 11:
 
727
        case 12:
 
728
        case 13:
 
729
        case 14:
 
730
            if (ramsize >= 1024) {
 
731
                for (j = 255; j >= 0; j--) {
 
732
                    _mem_read_tab[i][j] = read_ram_tab[i];
 
733
                    _mem_write_tab[i][j] = store_ram_tab[i];
 
734
                    _mem_read_base_tab[i][j] = mem_ram + (i << 16) + (j << 8);
 
735
                }
 
736
                _mem_write_tab[i][0] = store_zero_tab[i];
 
737
                _mem_read_tab[i][0] = read_zero_tab[i];
 
738
                break;
 
739
            }
 
740
            /* fallback for ramsize < some_value */
 
741
            for (j = 255; j >= 0; j--) {
 
742
                _mem_read_tab[i][j] = read_unused;
 
743
                _mem_write_tab[i][j] = store_dummy;
 
744
                _mem_read_base_tab[i][j] = NULL;
 
745
            }
 
746
            _mem_write_tab[i][0] = store_zeroX;
 
747
            break;
 
748
        case 15:
 
749
            for (j = 0; j < 0x08; j++) {
 
750
                _mem_read_tab[i][j] = read_ram_F;
 
751
                _mem_write_tab[i][j] = store_ram_F;
 
752
                _mem_read_base_tab[i][j] = mem_ram + (i << 16) + (j << 8);
 
753
            }
 
754
            for (; j < 0xc0; j++) { /* 0800-BFFF */
 
755
                _mem_read_tab[i][j] = rom_read;
 
756
                _mem_write_tab[i][j] = store_dummy;
 
757
                _mem_read_base_tab[i][j] = mem_rom + (j << 8);
 
758
            }
 
759
            for (; j < 0xd0; j++) { /* C000-CFFF */
 
760
                _mem_read_tab[i][j] = read_chargen;
 
761
                _mem_write_tab[i][j] = store_dummy;
 
762
                _mem_read_base_tab[i][j] = mem_chargen_rom + ((j << 8) & 0x0f);
 
763
            }
 
764
            for (; j < 0xe0; j++) { /* D000-DFFF */
 
765
                _mem_read_tab[i][j] = read_io;
 
766
                _mem_write_tab[i][j] = store_io;
 
767
                _mem_read_base_tab[i][j] = NULL;
 
768
            }
 
769
            for (; j < 0x100; j++) {
 
770
                _mem_read_tab[i][j] = rom_read;
 
771
                _mem_write_tab[i][j] = store_dummy;
 
772
                _mem_read_base_tab[i][j] = mem_rom + (j << 8);
 
773
            }
 
774
 
 
775
            if (cart08_ram) {
 
776
                for (j = 0x08; j < 0x10; j++) {
 
777
                    _mem_read_tab[i][j] = read_ram_F;
 
778
                    _mem_write_tab[i][j] = store_ram_F;
 
779
                    _mem_read_base_tab[i][j] = mem_ram + (i << 16) + (j << 8);
 
780
                }
 
781
            }
 
782
            if (cart1_ram) {
 
783
                for (j = 0x10; j < 0x20; j++) {
 
784
                    _mem_read_tab[i][j] = read_ram_F;
 
785
                    _mem_write_tab[i][j] = store_ram_F;
 
786
                    _mem_read_base_tab[i][j] = mem_ram + (i << 16) + (j << 8);
 
787
                }
 
788
            }
 
789
            if (cart2_ram) {
 
790
                for (j = 0x20; j < 0x40; j++) {
 
791
                    _mem_read_tab[i][j] = read_ram_F;
 
792
                    _mem_write_tab[i][j] = store_ram_F;
 
793
                    _mem_read_base_tab[i][j] = mem_ram + (i << 16) + (j << 8);
 
794
                }
 
795
            }
 
796
            if (cart4_ram) {
 
797
                for (j = 0x40; j < 0x60; j++) {
 
798
                    _mem_read_tab[i][j] = read_ram_F;
 
799
                    _mem_write_tab[i][j] = store_ram_F;
 
800
                    _mem_read_base_tab[i][j] = mem_ram + (i << 16) + (j << 8);
 
801
                }
 
802
            }
 
803
            if (cart6_ram) {
 
804
                for (j = 0x60; j < 0x80; j++) {
 
805
                    _mem_read_tab[i][j] = read_ram_F;
 
806
                    _mem_write_tab[i][j] = store_ram_F;
 
807
                    _mem_read_base_tab[i][j] = mem_ram + (i << 16) + (j << 8);
 
808
                }
 
809
            }
 
810
            if (cartC_ram) {
 
811
                for (j = 0xc0; j < 0xd0; j++) {
 
812
                    _mem_read_tab[i][j] = read_ram_F;
 
813
                    _mem_write_tab[i][j] = store_ram_F;
 
814
                    _mem_read_base_tab[i][j] = mem_ram + (i << 16) + (j << 8);
 
815
                }
 
816
            }
 
817
 
 
818
            _mem_write_tab[i][0] = store_zero_F;
 
819
            _mem_read_tab[i][0] = read_zero_F;
 
820
            _mem_read_base_tab[i][0] = mem_ram + 0xf0000;
 
821
            break;
802
822
    }
803
823
    _mem_read_tab[i][0x100] = _mem_read_tab[i][0];
804
824
    _mem_write_tab[i][0x100] = _mem_write_tab[i][0];
805
825
    _mem_read_base_tab[i][0x100] = _mem_read_base_tab[i][0];
806
826
}
807
827
 
808
 
void mem_mmu_translate(unsigned int addr, BYTE **base, int *start, int *limit) {
 
828
void mem_mmu_translate(unsigned int addr, BYTE **base, int *start, int *limit)
 
829
{
809
830
    BYTE *p = _mem_read_base_tab_ptr[addr >> 8];
810
831
 
811
832
    *base = (p == NULL) ? NULL : (p - (addr & 0xff00));
872
893
static BYTE peek_bank_io(WORD addr)
873
894
{
874
895
    switch (addr & 0xf800) {
875
 
      case 0xc000:
876
 
      case 0xc800:
877
 
        return read_unused(addr);
878
 
      case 0xd000:
879
 
        return rom_read(addr);
880
 
      case 0xd800:
881
 
        switch (addr & 0xff00) {
882
 
          case 0xd800:
883
 
            return vicii_peek(addr);
884
 
          case 0xd900:
885
 
            return read_unused(addr);
886
 
          case 0xda00:
887
 
            return sid_read(addr);
888
 
          case 0xdb00:
889
 
            return read_unused(addr);
890
 
          case 0xdc00:
891
 
            return cia1_peek(addr);
892
 
          case 0xdd00:
893
 
            return acia1_peek(addr);
894
 
          case 0xde00:
895
 
            return tpi1_peek((WORD)(addr & 0x07));
896
 
          case 0xdf00:
897
 
            return tpi2_peek((WORD)(addr & 0x07));
898
 
        }
 
896
        case 0xc000:
 
897
        case 0xc800:
 
898
            return read_unused(addr);
 
899
        case 0xd000:
 
900
            return rom_read(addr);
 
901
        case 0xd800:
 
902
            switch (addr & 0xff00) {
 
903
                case 0xd800:
 
904
                    return vicii_peek(addr);
 
905
                case 0xd900:
 
906
                    return read_unused(addr);
 
907
                case 0xda00:
 
908
                    return sid_read(addr);
 
909
                case 0xdb00:
 
910
                    return read_unused(addr);
 
911
                case 0xdc00:
 
912
                    return cia1_peek(addr);
 
913
                case 0xdd00:
 
914
                    return acia1_peek(addr);
 
915
                case 0xde00:
 
916
                    return tpi1_peek((WORD)(addr & 0x07));
 
917
                case 0xdf00:
 
918
                    return tpi2_peek((WORD)(addr & 0x07));
 
919
            }
899
920
    }
900
921
    return read_unused(addr);
901
922
}
910
931
};
911
932
 
912
933
static const int banknums[] = {
913
 
    17, 17, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 16 };
 
934
    17, 17, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 16
 
935
};
914
936
 
915
937
const char **mem_bank_list(void)
916
938
{
933
955
BYTE mem_bank_read(int bank, WORD addr, void *context)
934
956
{
935
957
    switch (bank) {
936
 
      case 17:                  /* current */
937
 
        return mem_read(addr);
938
 
      case 16:                   /* romio */
939
 
        if (addr >= 0xd000 && addr < 0xe000)
940
 
            return read_io(addr);
941
 
        return _mem_read_tab[15][addr >> 8](addr);
942
 
      default:
943
 
        if (bank >=0 && bank <15) {
944
 
            return read_ram_tab[bank](addr);
945
 
        }
 
958
        case 17:                /* current */
 
959
            return mem_read(addr);
 
960
        case 16:                 /* romio */
 
961
            if (addr >= 0xd000 && addr < 0xe000) {
 
962
                return read_io(addr);
 
963
            }
 
964
            return _mem_read_tab[15][addr >> 8](addr);
 
965
        default:
 
966
            if (bank >= 0 && bank < 15) {
 
967
                return read_ram_tab[bank](addr);
 
968
            }
946
969
    }
947
970
    return read_unused(addr);
948
971
}
960
983
void mem_bank_write(int bank, WORD addr, BYTE byte, void *context)
961
984
{
962
985
    switch (bank) {
963
 
      case 17:                   /* current */
964
 
        mem_store(addr, byte);
965
 
        return;
966
 
      case 16:
967
 
        if (addr >= 0xd000 && addr <=0xdfff) {
968
 
            store_io(addr, byte);
969
 
            return;
970
 
        }
971
 
        _mem_write_tab[15][addr >> 8](addr, byte);
972
 
        return;
973
 
      default:
974
 
        if (bank >=0 && bank < 16) {
975
 
            if (addr & 0xff00) {
976
 
                store_ram_tab[bank](addr, byte);
977
 
            } else {
978
 
                store_zero_tab[bank](addr, byte);
979
 
            }
980
 
            return;
981
 
        }
 
986
        case 17:                 /* current */
 
987
            mem_store(addr, byte);
 
988
            return;
 
989
        case 16:
 
990
            if (addr >= 0xd000 && addr <= 0xdfff) {
 
991
                store_io(addr, byte);
 
992
                return;
 
993
            }
 
994
            _mem_write_tab[15][addr >> 8](addr, byte);
 
995
            return;
 
996
        default:
 
997
            if (bank >= 0 && bank < 16) {
 
998
                if (addr & 0xff00) {
 
999
                    store_ram_tab[bank](addr, byte);
 
1000
                } else {
 
1001
                    store_zero_tab[bank](addr, byte);
 
1002
                }
 
1003
                return;
 
1004
            }
982
1005
    }
983
1006
    store_dummy(addr, byte);
984
1007
}
1032
1055
{
1033
1056
    memcpy(mem_color_ram, color_ram, 0x400);
1034
1057
}
1035