Subversion Repositories xge_mac

//////////////////////////////////////////////////////////////////////
////                                                              ////
////  File name "sc_cpu_if.h"                                     ////
////                                                              ////
////  This file is part of the "10GE MAC" project                 ////
////  http://www.opencores.org/cores/xge_mac/                     ////
////                                                              ////
////  Author(s):                                                  ////
////      - A. Tanguay (antanguay@opencores.org)                  ////
////                                                              ////
//////////////////////////////////////////////////////////////////////
////                                                              ////
//// Copyright (C) 2008 AUTHORS. All rights reserved.             ////
////                                                              ////
//// 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, download it   ////
//// from http://www.opencores.org/lgpl.shtml                     ////
////                                                              ////
//////////////////////////////////////////////////////////////////////
 
#include <stdio.h>
#include <iostream>
#include <sys/times.h>
#include <sys/stat.h>
 
#include "systemc.h"
 
#include "sc_cpu_if.h"
 
void cpu_if::init() {
};
 
void cpu_if::connect_scoreboard(scoreboard *sbptr, scoreboard::sbSourceId sid) {
    sb = sbptr;
    sb_id = sid;
}
 
void cpu_if::set_param(cpu_if::paramId param, int value) {
 
    switch (param) {
 
      case TX_ENABLE:
          writebits(cpu_if::CPUREG_CONFIG0, 0, 0, value);
          break;
 
    }
 
};
 
void cpu_if::set_interrupt(cpu_if::intId intr) {
 
    writebits(cpu_if::CPUREG_INT_PENDING, intr, intr, 1);
};
 
void cpu_if::set_interrupt_mask(cpu_if::intId intr, bool value) {
 
    writebits(cpu_if::CPUREG_INT_MASK, intr, intr, value);
};
 
void cpu_if::enable_all_interrupts(void) {
 
    write(cpu_if::CPUREG_INT_MASK, 0xffffffff);
};
 
void cpu_if::get_rmon_stats(rmonStats_t *rmon_stats) {
 
    rmon_stats->tx_octets_cnt = read(cpu_if::CPUREG_STATSTXOCTETS);
    rmon_stats->tx_pkt_cnt = read(cpu_if::CPUREG_STATSTXPKTS);
 
    rmon_stats->rx_octets_cnt = read(cpu_if::CPUREG_STATSRXOCTETS);
    rmon_stats->rx_pkt_cnt = read(cpu_if::CPUREG_STATSRXPKTS);
};
 
uint cpu_if::read(uint addr) {
 
    uint data;
 
    //--
    // Wait for bus to be free, lock it, start transaction
 
    bus_lock.lock();
    bus_addr = addr;
    bus_write = false;
    bus_start.post();
 
    //--
    // Wait for transaction to complete
 
    bus_done.wait();
 
    //--
    // Get the data, free the bus
 
    data = bus_data;
    cout << hex << "READ ADDR 0x" << addr << ": 0x" << data << dec << endl;
    bus_lock.unlock();
 
    return data;
};
 
void cpu_if::write(uint addr, uint data) {
 
    //--
    // Wait for bus to be free, lock it, start transaction
 
    bus_lock.lock();
    bus_addr = addr;
    bus_data = data;
    bus_write = true;
    bus_start.post();
 
    //--
    // Wait for transaction to complete
 
    bus_done.wait();
 
    //--
    // Free the bus
 
    cout << hex << "WRITE ADDR 0x" << addr << ": 0x" << data << dec << endl;
    bus_lock.unlock();
};
 
void cpu_if::writebits(uint addr, uint hbit, uint lbit, uint value) {
 
    uint data;
    uint mask;
 
    mask = ~((0xffffffff << lbit) & (0xffffffff >> (31-lbit)));
 
    data = mask & read(addr);
    data = data | ((value << lbit) & ~mask);
 
    write(addr, data);
};
 
void cpu_if::transactor() {
 
 
    while (true) {
 
        // Wait for a transaction
        while (bus_start.trywait()) {
            wait();
        }
 
        if (!bus_write) {
 
            //---
            // Read access
 
            // Start of access
            wb_adr_i = bus_addr;
            wb_dat_i = 0;
 
            wb_cyc_i = 1;
            wb_stb_i = 1;
            wb_we_i = 0;
 
            // Wait for ack
            while (wb_ack_o != 1) {
                wait();
            }
 
            // Capture data
            bus_data = wb_dat_o;
 
            wb_adr_i = 0;
            wb_dat_i = 0;
 
            wb_cyc_i = 0;
            wb_stb_i = 0;
 
        }
        else {
 
            //---
            // Write access
 
            // Start of access
            wb_adr_i = bus_addr;
            wb_dat_i = bus_data;
 
            wb_cyc_i = 1;
            wb_stb_i = 1;
            wb_we_i = 1;
 
            // Wait for ack
            while (wb_ack_o != 1) {
                wait();
            }
 
            // End cycle
            wb_adr_i = 0;
            wb_dat_i = 0;
 
            wb_cyc_i = 0;
            wb_stb_i = 0;
            wb_we_i = 0;
 
        }
 
        bus_done.post();
    }
};
 
void cpu_if::monitor() {
 
    uint data;
 
    wait();
 
    while (true) {
 
        if (wb_int_o) {
 
            //---
            // Read interrupt register when interrupt signal is asserted
 
            data = read(cpu_if::CPUREG_INT_PENDING);
 
            cout << "READ INTERRUPTS: 0x" << hex << data << dec << endl;
 
            //---
            // Notify scoreboard
 
            if ((data >> cpu_if::INT_CRC_ERROR) & 0x1) {
                sb->notify_status(sb_id, scoreboard::CRC_ERROR);
            }
 
            if ((data >> cpu_if::INT_FRAGMENT_ERROR) & 0x1) {
               sb->notify_status(sb_id, scoreboard::FRAGMENT_ERROR);
            }
 
            if ((data >> cpu_if::INT_LENGHT_ERROR) & 0x1) {
               sb->notify_status(sb_id, scoreboard::LENGHT_ERROR);
            }
 
            if ((data >> cpu_if::INT_LOCAL_FAULT) & 0x1) {
 
                data = read(cpu_if::CPUREG_INT_STATUS);
 
                if ((data >> cpu_if::INT_LOCAL_FAULT) & 0x1) {
                    sb->notify_status(sb_id, scoreboard::LOCAL_FAULT);
                }
            }
 
            if ((data >> cpu_if::INT_REMOTE_FAULT) & 0x1) {
 
                data = read(cpu_if::CPUREG_INT_STATUS);
 
                if ((data >> cpu_if::INT_REMOTE_FAULT) & 0x1) {
                    sb->notify_status(sb_id, scoreboard::REMOTE_FAULT);
                }
            }
 
            if ((data >> cpu_if::INT_RXD_FIFO_OVFLOW) & 0x1) {
                sb->notify_status(sb_id, scoreboard::RXD_FIFO_OVFLOW);
            }
 
            if ((data >> cpu_if::INT_RXD_FIFO_UDFLOW) & 0x1) {
                sb->notify_status(sb_id, scoreboard::RXD_FIFO_UDFLOW);
            }
 
            if ((data >> cpu_if::INT_TXD_FIFO_OVFLOW) & 0x1) {
                sb->notify_status(sb_id, scoreboard::TXD_FIFO_OVFLOW);
            }
 
            if ((data >> cpu_if::INT_TXD_FIFO_UDFLOW) & 0x1) {
                sb->notify_status(sb_id, scoreboard::TXD_FIFO_UDFLOW);
            }
 
            if ((data >> cpu_if::INT_PAUSE_FRAME) & 0x1) {
                sb->notify_status(sb_id, scoreboard::RX_GOOD_PAUSE_FRAME);
            }
 
        }
 
        wait();
    }
};