Subversion Repositories altor32

//-----------------------------------------------------------------
//                           AltOR32 
//                Alternative Lightweight OpenRisc 
//                            V2.0
//                     Ultra-Embedded.com
//                   Copyright 2011 - 2013
//
//               Email: admin@ultra-embedded.com
//
//                       License: LGPL
//-----------------------------------------------------------------
//
// Copyright (C) 2011 - 2013 Ultra-Embedded.com
//
// This source file may be used and distributed without         
// restriction provided that this copyright statement is not    
// removed from the file and that any derivative work contains  
// the original copyright notice and the associated disclaimer. 
//
// This source file is free software; you can redistribute it   
// and/or modify it under the terms of the GNU Lesser General   
// Public License as published by the Free Software Foundation; 
// either version 2.1 of the License, or (at your option) any   
// later version.
//
// This source is distributed in the hope that it will be       
// useful, but WITHOUT ANY WARRANTY; without even the implied   
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR      
// PURPOSE.  See the GNU Lesser General Public License for more 
// details.
//
// You should have received a copy of the GNU Lesser General    
// Public License along with this source; if not, write to the 
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, 
// Boston, MA  02111-1307  USA
//-----------------------------------------------------------------
#include <stdio.h>
#include <unistd.h>
#include <math.h>
#include <time.h>
 
#include "top_if.h"
 
#include "Vtop__Syms.h"
#include "verilated.h"
 
#if VM_TRACE
#include <verilated_vcd_c.h>
#endif
 
//-----------------------------------------------------------------
// Defines
//-----------------------------------------------------------------
#define MEMORY_START        0x10000000
#define MEMORY_SIZE         (1024 * 1024)
 
#define OR32_BUBBLE_OPCODE  0xFC000000
 
#define CPU_INSTANCE        top->v->u_cpu->u1_cpu
 
//-----------------------------------------------------------------
// Locals
//-----------------------------------------------------------------
static Vtop *top;
static unsigned int         _stop_pc = 0xFFFFFFFF;
 
#if VM_TRACE
static unsigned int        main_time = 0;
static VerilatedVcdC*      tfp;
#endif
 
//-----------------------------------------------------------------
// top_init
//-----------------------------------------------------------------
int top_init(void)
{
    top = new Vtop();    
 
#if VM_TRACE                  
    // If verilator was invoked with --trace
    Verilated::traceEverOn(true);
    VL_PRINTF("Enabling GTKWave Trace Output...\n");
    tfp = new VerilatedVcdC;
    top->trace (tfp, 99);
    tfp->open ("wave_dump.vcd");
#endif
 
    // Initial
    top->clk_i = 0;
    top->rst_i = 1;
    top->intr_i = 0;
    top->eval();
 
    // Reset
    top->clk_i = 1;
    top->rst_i = 1;
    top->eval();
 
    top->clk_i = 0;
    top->rst_i = 0;
    top->eval();
 
    return 0;
}
 
//-----------------------------------------------------------------
// top_load
//-----------------------------------------------------------------
int top_load(unsigned int addr, unsigned char val)
{
    if (addr >= (MEMORY_SIZE - MEMORY_START))
        return -1;
 
    addr -= MEMORY_START;    
 
    switch (addr & 0x3)
    {
    case 0:
        top->v->u_ram->u3->ram[addr >> 2] = val;
        break;
    case 1:
        top->v->u_ram->u2->ram[addr >> 2] = val;
        break;
    case 2:
        top->v->u_ram->u1->ram[addr >> 2] = val;
        break;
    case 3:
        top->v->u_ram->u0->ram[addr >> 2] = val;
        break;
    }
 
    return 0;
}
//-----------------------------------------------------------------
// top_setbreakpoint
//-----------------------------------------------------------------
int top_setbreakpoint(int bp, unsigned int pc)
{
    if (bp != 0)
        return -1;
    else
    {
        _stop_pc = pc;
        return 0;
    }
}
//-----------------------------------------------------------------
// top_run
//-----------------------------------------------------------------
int top_run(unsigned int pc, int cycles, int intr_after_cycles)
{
    int current_cycle = 0;      
 
    // Run until fault or number of cycles completed
    while (!Verilated::gotFinish() && !top->fault_o && (current_cycle < cycles || cycles == -1)) 
    {
        // CLK->L
        top->clk_i = 0;
        top->eval();
 
#if VM_TRACE
        if (tfp) tfp->dump (main_time++);
#endif
 
        // CLK->H
        top->clk_i = 1;
        top->eval();            
 
#if VM_TRACE
        if (tfp) tfp->dump (main_time++);
#endif
 
        // Get current executing instruction PC
        unsigned int pc = CPU_INSTANCE->u_exec->get_pc_ex();
        unsigned int opcode = CPU_INSTANCE->u_exec->get_opcode_ex();
 
#ifdef INST_TRACE
        // Instruction trace - decode instruction opcode to text
        if (opcode != OR32_BUBBLE_OPCODE)
            printf("%08x:   %02x %02x %02x %02x\n", pc, (opcode >> 24) & 0xFF, (opcode >> 16) & 0xFF, (opcode >> 8) & 0xFF, (opcode >> 0) & 0xFF);
#endif
 
        // Generate interrupt after a certain number of cycles?
        if (intr_after_cycles >= 0 && intr_after_cycles == current_cycle)
        {
            top->intr_i = 1;
            intr_after_cycles = -1;
        }
        else
            top->intr_i = 0;
 
        current_cycle++;
 
        // Breakpoint hit?
        if (_stop_pc == pc || top->break_o)
        {
            if (_stop_pc == pc)
                printf("Stopped at breakpoint 0x%x\n", _stop_pc);
            printf("Cycles = %d\n", current_cycle);
            return TOP_RES_BREAKPOINT;
        }
    }
 
    printf("Cycles = %d\n", current_cycle);
 
    // Fault
    if (top->fault_o)
    {
        printf("FAULT PC %x!\n", CPU_INSTANCE->u_exec->get_pc_ex());
        return TOP_RES_FAULT;
    }
    // Number of cycles reached
    else if (current_cycle >= cycles)
        return TOP_RES_MAX_CYCLES;
    // No error
    else
        return TOP_RES_OK;
}
//-----------------------------------------------------------------
// top_done
//-----------------------------------------------------------------
void top_done(void)
{
    top->final();
#if VM_TRACE
    if (tfp)
    {
        tfp->close();
        tfp = NULL;
    }
#endif
}