Subversion Repositories aor3000

/*
 * This file is subject to the terms and conditions of the GPL License. See
 * the file "LICENSE" in the main directory of this archive for more details.
 *
 * Copyright (C) 2014 Aleksander Osman
 */
 
#include <cstdio>
#include <cstdlib>
#include <cstring>
 
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
 
#include "shared_mem.h"
#include "vmips_emulator.h"
 
//------------------------------------------------------------------------------
 
volatile shared_mem_t *shared_ptr = NULL;
 
//------------------------------------------------------------------------------
 
void CPZero::initialize() {
}
 
void CPU::initialize() {
}
 
//------------------------------------------------------------------------------
 
void CPZero::report() {
}
 
void CPU::report() {
}
 
//------------------------------------------------------------------------------
 
CPU *cpu = NULL;
uint32 event_counter = 0;
 
void usleep_or_finish() {
    if(shared_ptr->test_finished) {
        printf("Finishing.\n");
        exit(0);
    }
    usleep(1);
}
 
//128MB
#define MAX_MEMORY   0x08000000
#define RESET_VECTOR 0x1FC00000
 
uint32 isolated_cache[512];
 
uint32 ao_interrupts() {
    return ((event_counter >= shared_ptr->irq2_at_event)? 1 << 10 : 0) | ((event_counter >= shared_ptr->irq3_at_event)? 2 << 10 : 0);
}
 
uint8 ao_fetch_byte(uint32 addr, bool cacheable, bool isolated) {
    //DBE IBE
    //cpu->exception((mode == INSTFETCH / DATALOAD ? IBE : DBE), mode);
 
    if(isolated) return
        ((addr %4) == 0)?   ((isolated_cache[(addr >> 2)&0x1FF] >> 0) & 0xFF) :
        ((addr %4) == 1)?   ((isolated_cache[(addr >> 2)&0x1FF] >> 8) & 0xFF) :
        ((addr %4) == 2)?   ((isolated_cache[(addr >> 2)&0x1FF] >> 16) & 0xFF) :
                            ((isolated_cache[(addr >> 2)&0x1FF] >> 24) & 0xFF);
 
    if(addr < MAX_MEMORY) {
        return shared_ptr->mem.bytes[addr];
    }
 
    shared_ptr->proc_vmips.read_address    = addr & 0xFFFFFFFC;
    shared_ptr->proc_vmips.read_byteenable = ((addr % 4) == 0)? 0x1 : ((addr % 4) == 1)? 0x2 : ((addr % 4) == 2)? 0x3 : 0x4;
    shared_ptr->proc_vmips.read_do         = true;
 
    while(shared_ptr->proc_vmips.read_do) usleep_or_finish();
 
    return (shared_ptr->proc_vmips.read_data >> ( ((addr % 4) == 0)? 0 : ((addr % 4) == 1)? 8 : ((addr % 4) == 2)? 16 : 24 )) & 0xFF;
}
 
uint16 ao_fetch_halfword(uint32 addr, bool cacheable, bool isolated) {
    //AdE
    if (addr % 2 != 0) {
        cpu->exception(AdEL,DATALOAD);
        return 0xffff;
    }
 
    //DBE IBE
    //cpu->exception((mode == INSTFETCH / DATALOAD ? IBE : DBE), mode);
 
    if(isolated) return
        ((addr %4) == 0)?   ((isolated_cache[(addr >> 2)&0x1FF] >> 0) & 0xFFFF) :
                            ((isolated_cache[(addr >> 2)&0x1FF] >> 16) & 0xFFFF);
 
    if(addr < MAX_MEMORY) {
        return shared_ptr->mem.shorts[addr/2];
    }
 
    shared_ptr->proc_vmips.read_address    = addr & 0xFFFFFFFC;
    shared_ptr->proc_vmips.read_byteenable = ((addr % 4) == 0)? 0x3 : 0xC;
    shared_ptr->proc_vmips.read_do         = true;
 
    while(shared_ptr->proc_vmips.read_do) usleep_or_finish();
 
    return (shared_ptr->proc_vmips.read_data >> ( ((addr % 4) == 0)? 0 : 16 )) & 0xFFFF;
}
 
uint32 ao_fetch_word(uint32 addr, int32 mode, bool cacheable, bool isolated) {
    //AdE
    if (addr % 4 != 0) {
        cpu->exception(AdEL,mode);
        return 0xffffffff;
    }
 
    //DBE IBE
    //cpu->exception((mode == INSTFETCH / DATALOAD ? IBE : DBE), mode);
 
    if(isolated && mode == DATALOAD) return ((isolated_cache[(addr >> 2)&0x1FF] >> 0) & 0xFFFFFFFF);
 
    if(addr < MAX_MEMORY) {
        return shared_ptr->mem.ints[addr/4];
    }
    else if(addr >= RESET_VECTOR && addr < RESET_VECTOR + sizeof(shared_ptr->reset_vector)) {
        return shared_ptr->reset_vector[(addr - RESET_VECTOR)/4];
    }
 
    shared_ptr->proc_vmips.read_address    = addr & 0xFFFFFFFC;
    shared_ptr->proc_vmips.read_byteenable = 0xF;
    shared_ptr->proc_vmips.read_do         = true;
 
    while(shared_ptr->proc_vmips.read_do) usleep_or_finish();
 
    return (shared_ptr->proc_vmips.read_data) & 0xFFFFFFFF;
}
 
void ao_store_byte(uint32 addr, uint8 data, bool cacheable, bool isolated) {
    //DBE
    //cpu->exception((mode == INSTFETCH / DATALOAD ? IBE : DBE), mode);
 
    if(isolated) return;
 
    shared_ptr->proc_vmips.write_address    = addr & 0xFFFFFFFC;
    shared_ptr->proc_vmips.write_byteenable = ((addr % 4) == 0)? 0x1 : ((addr % 4) == 1)? 0x2 : ((addr % 4) == 2)? 0x4 : 0x8;
    shared_ptr->proc_vmips.write_data       = ((addr % 4) == 0)? data : ((addr % 4) == 1)? data << 8 : ((addr % 4) == 2)? data << 16 : data << 24;
    shared_ptr->proc_vmips.write_do         = true;
 
    while(shared_ptr->proc_vmips.write_do) usleep_or_finish();
}
 
void ao_store_halfword(uint32 addr, uint16 data, bool cacheable, bool isolated) {
    //AdE
    if (addr % 2 != 0) {
        cpu->exception(AdES,DATASTORE);
        return;
    }
 
    //DBE
    //cpu->exception((mode == INSTFETCH / DATALOAD ? IBE : DBE), mode);
 
    if(isolated) return;
 
    shared_ptr->proc_vmips.write_address    = addr & 0xFFFFFFFC;
    shared_ptr->proc_vmips.write_byteenable = ((addr % 4) == 0)? 0x3 : 0xC;
    shared_ptr->proc_vmips.write_data       = ((addr % 4) == 0)? data : data << 16;
    shared_ptr->proc_vmips.write_do         = true;
 
    while(shared_ptr->proc_vmips.write_do) usleep_or_finish();
}
 
void ao_store_word(uint32 addr, uint32 data, bool cacheable, bool isolated, uint32 byteenable) {
    //AdE
    if (addr % 4 != 0) {
        cpu->exception(AdES,DATASTORE);
        return;
    }
 
    //DBE
    //cpu->exception((mode == INSTFETCH / DATALOAD ? IBE : DBE), mode);
 
    if(isolated) {
        isolated_cache[(addr >> 2)&0x1FF] = data;
        return;
    }
 
    shared_ptr->proc_vmips.write_address    = addr & 0xFFFFFFFC;
    shared_ptr->proc_vmips.write_byteenable = byteenable;
    shared_ptr->proc_vmips.write_data       = data;
    shared_ptr->proc_vmips.write_do         = true;
 
    while(shared_ptr->proc_vmips.write_do) usleep_or_finish();
}
 
void fatal_error(const char *error, ...) {
    printf("[fatal_error]: %s\n", error);
    exit(-1);
}
 
//------------------------------------------------------------------------------
 
 
int main() {
    //map shared memory
    int fd = open("./../tester/shared_mem.dat", O_RDWR, S_IRUSR | S_IWUSR);
 
    if(fd == -1) {
        perror("open() failed for shared_mem.dat");
        return -1;
    }
 
    shared_ptr = (shared_mem_t *)mmap(NULL, sizeof(shared_mem_t), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
 
    if(shared_ptr == MAP_FAILED) {
        perror("mmap() failed");
        close(fd);
        return -2;
    }
 
    cpu = new CPU();
    cpu->reset();
 
    printf("Waiting for initialize..."); fflush(stdout);
    while(shared_ptr->proc_vmips.initialize_do == false) usleep_or_finish();
 
    cpu->initialize();
    shared_ptr->proc_vmips.initialize_do = false;
    printf("done\n");
 
    while(true) {
        bool do_debug = false;//event_counter > 40565500;
 
        int exception_pending = cpu->step(do_debug);
        fflush(stdout);
 
        shared_ptr->proc_vmips.report.counter = event_counter;
 
        if(shared_ptr->check_at_event == event_counter) {
            shared_ptr->proc_vmips.check_do = true;
 
            while(shared_ptr->proc_vmips.check_do) usleep_or_finish();
        }
 
        event_counter++;
    }
    return 0;
}
 
//------------------------------------------------------------------------------