Changeset ba36b71 in buchla-emu


Ignore:
Timestamp:
07/20/2017 07:09:33 PM (5 years ago)
Author:
Thomas Lopatic <thomas@…>
Branches:
master
Children:
555b171
Parents:
51b6cfd
Message:

Fixed memory access control.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • emu/cpu.c

    r51b6cfd rba36b71  
    2828#define CYCLES 10
    2929
     30#define VEC_SIZE 0x400
     31
    3032#define RAM_START 0x0
    3133#define RAM_SIZE 0x100000
     
    5557static uint8_t rom_data[ROM_SIZE];
    5658
    57 static uint32_t ram_rd_beg = 0x10000000;
    58 static uint32_t ram_rd_end = 0x10000000;
    59 static uint32_t ram_wr_beg = 0x10000000;
    60 static uint32_t ram_wr_end = 0x10000000;
    61 
    62 static uint32_t rom_rd_beg;
    63 static uint32_t rom_rd_end;
    64 static uint32_t rom_wr_beg;
    65 static uint32_t rom_wr_end;
     59static uint32_t ram_ro_beg = 0x1234;
     60static uint32_t ram_ro_end = 0x1234;
     61static uint32_t ram_rw_beg = 0x1234;
     62static uint32_t ram_rw_end = 0x1234;
     63
     64static uint32_t rom_ro_beg;
     65static uint32_t rom_ro_end;
     66static uint32_t rom_rw_beg;
     67static uint32_t rom_rw_end;
    6668
    6769static hw_t hw_map[] = {
     
    9193static void hw_init(void)
    9294{
    93         ver("initializing hardware");
     95        inf("initializing hardware");
    9496
    9597        for (int32_t i = 0; i < ARRAY_COUNT(hw_map); ++i) {
     
    116118static void bios_init(const char *bios)
    117119{
    118         ver("loading BIOS file %s", bios);
     120        inf("loading BIOS file %s", bios);
    119121
    120122        SDL_RWops *ops = SDL_RWFromFile(bios, "rb");
     
    142144        uint32_t bss_loc = SDL_ReadBE32(ops);
    143145
    144         ver("text 0x%x@0x%x data 0x%x@0x%x bss 0x%x@0x%x",
    145                         text_len, text_loc, data_len, data_loc, bss_len, bss_loc);
     146        inf("BIOS text 0x%x:0x%x data 0x%x:0x%x bss 0x%x:0x%x",
     147                        text_loc, text_len, data_loc, data_len, bss_loc, bss_len);
    146148
    147149        size_t load_len = (size_t)SDL_RWsize(ops) - 36;
    148150
    149         if (load_len != text_len + data_len) {
    150                 fail("corrupted BIOS file %s", bios);
     151        if (text_loc != ROM_START || text_loc + text_len != data_loc ||
     152                        load_len != text_len + data_len || load_len > ROM_SIZE) {
     153                fail("invalid BIOS file %s", bios);
    151154        }
    152155
     
    164167
    165168        SDL_RWclose(ops);
     169
     170        rom_ro_beg = text_loc;
     171        rom_ro_end = text_loc + text_len + data_len;
     172        rom_rw_beg = bss_loc;
     173        rom_rw_end = bss_loc + bss_len;
     174
     175        ver("rom_ro_beg 0x%08x rom_ro_end 0x%08x", rom_ro_beg, rom_ro_end);
     176        ver("rom_rw_beg 0x%08x rom_rw_end 0x%08x", rom_rw_beg, rom_rw_end);
    166177}
    167178
     
    185196        ver("mem rd 0x%08x:8", addr);
    186197
    187         if (addr >= ram_rd_beg && addr <= ram_rd_end - 1) {
     198        if (addr >= ram_ro_beg && addr <= ram_ro_end - 1) {
    188199                return ram_data[addr - RAM_START];
    189200        }
    190201
    191         if (addr >= rom_rd_beg && addr <= rom_rd_end - 1) {
     202        if (addr >= ram_rw_beg && addr <= ram_rw_end - 1) {
     203                return ram_data[addr - RAM_START];
     204        }
     205
     206        if (addr >= rom_ro_beg && addr <= rom_ro_end - 1) {
    192207                return rom_data[addr - ROM_START];
    193208        }
    194209
     210        if (addr >= rom_rw_beg && addr <= rom_rw_end - 1) {
     211                // ROM has its BSS section in RAM.
     212                return ram_data[addr - RAM_START];
     213        }
     214
    195215        hw_t *hw = hw_by_addr(addr);
    196216
     
    199219        }
    200220
     221        if (addr <= VEC_SIZE - 1) {
     222                return ram_data[addr];
     223        }
     224
    201225        fail("invalid read 0x%08x:8", addr);
    202226}
     
    206230        ver("mem rd 0x%08x:16", addr);
    207231
    208         if (addr >= ram_rd_beg && addr <= ram_rd_end - 2) {
     232        if (addr >= ram_ro_beg && addr <= ram_ro_end - 2) {
    209233                return
    210234                                ((uint32_t)ram_data[addr - RAM_START + 0] << 8) |
     
    212236        }
    213237
    214         if (addr >= rom_rd_beg && addr <= rom_rd_end - 2) {
     238        if (addr >= ram_rw_beg && addr <= ram_rw_end - 2) {
     239                return
     240                                ((uint32_t)ram_data[addr - RAM_START + 0] << 8) |
     241                                ((uint32_t)ram_data[addr - RAM_START + 1] << 0);
     242        }
     243
     244        if (addr >= rom_ro_beg && addr <= rom_ro_end - 2) {
    215245                return
    216246                                ((uint32_t)rom_data[addr - ROM_START + 0] << 8) |
     
    218248        }
    219249
     250        if (addr >= rom_rw_beg && addr <= rom_rw_end - 2) {
     251                // ROM has its BSS section in RAM.
     252                return
     253                                ((uint32_t)ram_data[addr - RAM_START + 0] << 8) |
     254                                ((uint32_t)ram_data[addr - RAM_START + 1] << 0);
     255        }
     256
    220257        hw_t *hw = hw_by_addr(addr);
    221258
    222259        if (hw != NULL) {
    223260                return hw->read(hw_off(hw, addr), 2);
     261        }
     262
     263        if (addr <= VEC_SIZE - 2) {
     264                return
     265                                ((uint32_t)ram_data[addr - 0] << 8) |
     266                                ((uint32_t)ram_data[addr - 1] << 0);
    224267        }
    225268
     
    245288        }
    246289
    247         if (addr >= ram_rd_beg && addr <= ram_rd_end - 4) {
     290        if (addr >= ram_ro_beg && addr <= ram_ro_end - 4) {
    248291                return
    249292                                ((uint32_t)ram_data[addr - RAM_START + 0] << 24) |
     
    253296        }
    254297
    255         if (addr >= rom_rd_beg && addr <= rom_rd_end - 4) {
     298        if (addr >= ram_rw_beg && addr <= ram_rw_end - 4) {
     299                return
     300                                ((uint32_t)ram_data[addr - RAM_START + 0] << 24) |
     301                                ((uint32_t)ram_data[addr - RAM_START + 1] << 16) |
     302                                ((uint32_t)ram_data[addr - RAM_START + 2] <<  8) |
     303                                ((uint32_t)ram_data[addr - RAM_START + 3] <<  0);
     304        }
     305
     306        if (addr >= rom_ro_beg && addr <= rom_ro_end - 4) {
    256307                return
    257308                                ((uint32_t)rom_data[addr - ROM_START + 0] << 24) |
     
    261312        }
    262313
     314        if (addr >= rom_rw_beg && addr <= rom_rw_end - 4) {
     315                // ROM has its BSS section in RAM.
     316                return
     317                                ((uint32_t)ram_data[addr - RAM_START + 0] << 24) |
     318                                ((uint32_t)ram_data[addr - RAM_START + 1] << 16) |
     319                                ((uint32_t)ram_data[addr - RAM_START + 2] <<  8) |
     320                                ((uint32_t)ram_data[addr - RAM_START + 3] <<  0);
     321        }
     322
    263323        hw_t *hw = hw_by_addr(addr);
    264324
     
    267327        }
    268328
     329        if (addr <= VEC_SIZE - 4) {
     330                return
     331                                ((uint32_t)ram_data[addr + 0] << 24) |
     332                                ((uint32_t)ram_data[addr + 1] << 16) |
     333                                ((uint32_t)ram_data[addr + 2] <<  8) |
     334                                ((uint32_t)ram_data[addr + 3] <<  0);
     335        }
     336
    269337        fail("invalid read 0x%08x:32", addr);
    270338}
     
    274342        ver("mem wr 0x%08x:8 0x%02x", addr, val);
    275343
    276         if (addr >= ram_wr_beg && addr <= ram_wr_end - 1) {
     344        if (addr >= ram_rw_beg && addr <= ram_rw_end - 1) {
    277345                ram_data[addr - RAM_START] = (uint8_t)val;
    278346                return;
    279347        }
    280348
    281         if (addr >= rom_wr_beg && addr <= rom_wr_end - 1) {
     349        if (addr >= rom_rw_beg && addr <= rom_rw_end - 1) {
    282350                // ROM has its BSS section in RAM.
    283351                ram_data[addr - RAM_START] = (uint8_t)val;
     
    292360        }
    293361
     362        if (addr <= VEC_SIZE - 1) {
     363                ram_data[addr] = (uint8_t)val;
     364                return;
     365        }
     366
    294367        fail("invalid write 0x%08x:8 0x%02x", addr, val);
    295368}
     
    299372        ver("mem wr 0x%08x:16 0x%04x", addr, val);
    300373
    301         if (addr >= ram_wr_beg && addr <= ram_wr_end - 2) {
     374        if (addr >= ram_rw_beg && addr <= ram_rw_end - 2) {
    302375                ram_data[addr - RAM_START + 0] = (uint8_t)(val >> 8);
    303376                ram_data[addr - RAM_START + 1] = (uint8_t)(val >> 0);
     
    305378        }
    306379
    307         if (addr >= rom_wr_beg && addr <= rom_wr_end - 2) {
     380        if (addr >= rom_rw_beg && addr <= rom_rw_end - 2) {
    308381                // ROM has its BSS section in RAM.
    309382                ram_data[addr - RAM_START + 0] = (uint8_t)(val >> 8);
     
    319392        }
    320393
     394        if (addr <= VEC_SIZE - 2) {
     395                ram_data[addr + 0] = (uint8_t)(val >> 8);
     396                ram_data[addr + 1] = (uint8_t)(val >> 0);
     397                return;
     398        }
     399
    321400        fail("invalid write 0x%08x:16 0x%04x", addr, val);
    322401}
     
    326405        ver("mem wr 0x%08x:32 0x%08x", addr, val);
    327406
    328         if (addr >= ram_wr_beg && addr <= ram_wr_end - 4) {
     407        if (addr >= ram_rw_beg && addr <= ram_rw_end - 4) {
    329408                ram_data[addr - RAM_START + 0] = (uint8_t)(val >> 24);
    330409                ram_data[addr - RAM_START + 1] = (uint8_t)(val >> 16);
     
    334413        }
    335414
    336         if (addr >= rom_wr_beg && addr <= rom_wr_end - 4) {
     415        if (addr >= rom_rw_beg && addr <= rom_rw_end - 4) {
    337416                // ROM has its BSS section in RAM.
    338417                ram_data[addr - RAM_START + 0] = (uint8_t)(val >> 24);
     
    350429        }
    351430
     431        if (addr <= VEC_SIZE - 4) {
     432                ram_data[addr + 0] = (uint8_t)(val >> 24);
     433                ram_data[addr + 1] = (uint8_t)(val >> 16);
     434                ram_data[addr + 2] = (uint8_t)(val >>  8);
     435                ram_data[addr + 3] = (uint8_t)(val >>  0);
     436                return;
     437        }
     438
    352439        fail("invalid write 0x%08x:32 0x%08x", addr, val);
    353440}
     
    355442void cpu_loop(const char *bios)
    356443{
    357         ver("entering CPU loop");
    358 
    359444        hw_init();
    360445        bios_init(bios);
    361446
    362         ver("starting CPU");
     447        inf("entering CPU loop");
    363448        m68k_init();
    364449        m68k_set_cpu_type(M68K_CPU_TYPE_68000);
Note: See TracChangeset for help on using the changeset viewer.