axi_protocol.cpp

/*
 * Copyright 2020-2022 Arteris IP
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#include <axi/checker/axi_protocol.h>
#include <scc/report.h>
namespace axi {
namespace checker {
 
void axi_protocol::fw_pre(const axi_protocol::payload_type& trans, const axi_protocol::phase_type& phase) {
    auto cmd = trans.get_command();
    if(cmd == tlm::TLM_IGNORE_COMMAND)
        SCCERR(name) << "Illegal command: tlm::TLM_IGNORE_COMMAND on forward path";
    if(check_phase_change(trans, phase))
#ifndef NCSC
        SCCERR(name) << "Illegal phase transition: " << phase.get_name() << " on forward path";
#else
        SCCERR(name) << "Illegal phase transition: " << phase << " on forward path";
#endif
}
 
void axi_protocol::fw_post(const axi_protocol::payload_type& trans, const axi_protocol::phase_type& phase, tlm::tlm_sync_enum rstat) {
    if(rstat == tlm::TLM_ACCEPTED)
        return;
    auto cmd = trans.get_command();
    if(req_beat[cmd] == tlm::BEGIN_REQ && (phase == tlm::BEGIN_RESP || phase == axi::BEGIN_PARTIAL_RESP))
        req_beat[cmd] = tlm::UNINITIALIZED_PHASE;
    if(check_phase_change(trans, phase))
#ifndef NCSC
        SCCERR(name) << "Illegal phase transition: " << phase.get_name() << " on return in forward path";
#else
        SCCERR(name) << "Illegal phase transition: " << phase << " on return in forward path";
#endif
}
 
void axi_protocol::bw_pre(const axi_protocol::payload_type& trans, const axi_protocol::phase_type& phase) {
    auto cmd = trans.get_command();
    if(cmd == tlm::TLM_IGNORE_COMMAND)
        SCCERR(name) << "Illegal command:  tlm::TLM_IGNORE_COMMAND on forward path";
    if(check_phase_change(trans, phase))
#ifndef NCSC
        SCCERR(name) << "Illegal phase transition: " << phase.get_name() << " on backward path";
#else
        SCCERR(name) << "Illegal phase transition: " << phase << " on backward path";
#endif
}
 
void axi_protocol::bw_post(const axi_protocol::payload_type& trans, const axi_protocol::phase_type& phase, tlm::tlm_sync_enum rstat) {
    if(rstat == tlm::TLM_ACCEPTED)
        return;
    if(check_phase_change(trans, phase))
#ifndef NCSC
        SCCERR(name) << "Illegal phase transition: " << phase.get_name() << " on return in backward path";
#else
        SCCERR(name) << "Illegal phase transition: " << phase << " on return in backward path";
#endif
}
 
bool axi_protocol::check_phase_change(payload_type const& trans, const axi_protocol::phase_type& phase) {
    // phase tests
    auto cur_req = req_beat[trans.get_command()];
    auto cur_resp = resp_beat[trans.get_command()];
    bool error{false};
    if(phase == tlm::BEGIN_REQ || phase == axi::BEGIN_PARTIAL_REQ) {
        error |= cur_req != tlm::UNINITIALIZED_PHASE;
        cur_req = phase;
    } else if(phase == axi::END_PARTIAL_REQ) {
        error |= cur_req != axi::BEGIN_PARTIAL_REQ;
        cur_req = tlm::UNINITIALIZED_PHASE;
    } else if(phase == tlm::END_REQ) {
        error |= cur_req != tlm::BEGIN_REQ;
        cur_req = tlm::UNINITIALIZED_PHASE;
    } else if(phase == tlm::BEGIN_RESP || phase == axi::BEGIN_PARTIAL_RESP) {
        error |= cur_resp != tlm::UNINITIALIZED_PHASE;
        cur_resp = phase;
    } else if(phase == tlm::END_RESP) {
        error |= cur_resp != tlm::BEGIN_RESP;
        cur_resp = tlm::UNINITIALIZED_PHASE;
    } else if(phase == axi::END_PARTIAL_RESP) {
        error |= cur_resp != axi::BEGIN_PARTIAL_RESP;
        cur_resp = tlm::UNINITIALIZED_PHASE;
    } else {
        error |= true;
    }
    if(req_beat[trans.get_command()] != cur_req) {
        req_beat[trans.get_command()] = cur_req;
        request_update(trans);
    }
    if(resp_beat[trans.get_command()] != cur_resp) {
        resp_beat[trans.get_command()] = cur_resp;
        response_update(trans);
    }
    return error;
}
 
void axi_protocol::request_update(const payload_type& trans) {
    auto axi_id = axi::get_axi_id(trans);
    auto axi_burst_len = axi::get_burst_length(trans);
    if(trans.is_write()) {
        if(req_beat[tlm::TLM_WRITE_COMMAND] == tlm::UNINITIALIZED_PHASE) {
            req_id[tlm::TLM_WRITE_COMMAND] = umax;
        } else {
            if(req_id[tlm::TLM_WRITE_COMMAND] == umax) {
                req_id[tlm::TLM_WRITE_COMMAND] = axi_id;
                wr_req_beat_count++;
            } else if(req_id[tlm::TLM_WRITE_COMMAND] != axi_id) {
                SCCERR(name) << "Illegal ordering: a transaction with AWID:0x" << std::hex << axi_id
                             << " starts while a transaction with AWID:0x" << req_id[tlm::TLM_WRITE_COMMAND] << " is active";
            }
            if(req_beat[tlm::TLM_WRITE_COMMAND] == tlm::BEGIN_REQ) {
                if(wr_req_beat_count != axi_burst_len) {
                    SCCERR(name) << "Illegal AXI settings: number of transferred beats (" << wr_req_beat_count
                                 << ") does not comply with AWLEN:0x" << std::hex << axi::get_burst_length(trans) - 1;
                }
                wr_req_beat_count = 0;
                open_tx_by_id[tlm::TLM_WRITE_COMMAND][axi_id].push_back(reinterpret_cast<uintptr_t>(&trans));
                check_properties(trans);
            }
        }
    } else if(trans.is_read()) {
        if(req_beat[tlm::TLM_READ_COMMAND] == tlm::UNINITIALIZED_PHASE) {
            req_id[tlm::TLM_READ_COMMAND] = umax;
        } else if(req_beat[tlm::TLM_READ_COMMAND] == tlm::BEGIN_REQ) {
            if(req_id[tlm::TLM_READ_COMMAND] == umax) {
                req_id[tlm::TLM_READ_COMMAND] = axi_id;
                open_tx_by_id[tlm::TLM_READ_COMMAND][axi_id].push_back(reinterpret_cast<uintptr_t>(&trans));
            } else if(req_id[tlm::TLM_READ_COMMAND] != axi_id) {
                SCCERR(name) << "Illegal phase: a read transaction uses a phase with id " << req_beat[tlm::TLM_READ_COMMAND];
            }
            check_properties(trans);
        } else {
            SCCERR(name) << "Illegal phase: a read transaction uses a phase with id " << req_beat[tlm::TLM_READ_COMMAND];
        }
    }
}
 
void axi_protocol::response_update(const payload_type& trans) {
    auto axi_id = axi::get_axi_id(trans);
    auto axi_burst_len = axi::get_burst_length(trans);
    if(trans.is_write()) {
        if(resp_beat[tlm::TLM_WRITE_COMMAND] == tlm::UNINITIALIZED_PHASE) {
            resp_id[tlm::TLM_WRITE_COMMAND] = umax;
        } else if(resp_beat[tlm::TLM_WRITE_COMMAND] == tlm::BEGIN_RESP) {
            if(resp_id[tlm::TLM_WRITE_COMMAND] == umax) {
                resp_id[tlm::TLM_WRITE_COMMAND] = axi_id;
                if(open_tx_by_id[tlm::TLM_WRITE_COMMAND][axi_id].front() != reinterpret_cast<uintptr_t>(&trans)) {
                    SCCERR(name) << "Write response ordering violation: a response with AWID:0x" << std::hex << axi_id
                                 << " starts before the previous response with the same id finished";
                }
            } else if(resp_id[tlm::TLM_WRITE_COMMAND] != axi_id) {
                SCCERR(name) << "Illegal phase: a read transaction uses a phase with id " << resp_beat[tlm::TLM_WRITE_COMMAND];
            }
            open_tx_by_id[tlm::TLM_WRITE_COMMAND][axi_id].pop_front();
        } else {
            SCCERR(name) << "Illegal phase: a read transaction uses a phase with id " << resp_beat[tlm::TLM_WRITE_COMMAND];
        }
    } else if(trans.is_read()) {
        if(resp_beat[tlm::TLM_READ_COMMAND] == tlm::UNINITIALIZED_PHASE) {
            resp_id[tlm::TLM_READ_COMMAND] = umax;
        } else {
            if(resp_id[tlm::TLM_READ_COMMAND] == umax) {
                resp_id[tlm::TLM_READ_COMMAND] = axi_id;
                if(open_tx_by_id[tlm::TLM_READ_COMMAND][axi_id].front() != reinterpret_cast<uintptr_t>(&trans)) {
                    SCCERR(name) << "Read response ordering violation: a response with ARID:0x" << std::hex << axi_id
                                 << " starts before the previous response with the same id finished";
                }
                rd_resp_beat_count[axi_id]++;
            } else if(resp_id[tlm::TLM_READ_COMMAND] != axi_id) {
                SCCERR(name) << "Illegal phase: a read transaction uses a phase with id " << resp_beat[tlm::TLM_READ_COMMAND];
            }
            if(resp_beat[tlm::TLM_READ_COMMAND] == tlm::BEGIN_RESP) {
                if(rd_resp_beat_count[axi_id] != axi_burst_len) {
                    SCCERR(name) << "Illegal AXI settings: number of transferred beats (" << wr_req_beat_count
                                 << ") does not comply with AWLEN:0x" << std::hex << axi::get_burst_length(trans) - 1;
                }
                open_tx_by_id[tlm::TLM_READ_COMMAND][axi_id].pop_front();
                rd_resp_beat_count[axi_id] = 0;
            }
        }
    }
}
 
void axi_protocol::check_datawith_settings(payload_type const& trans) {
    auto axi_burst_len = axi::get_burst_length(trans);
    auto axi_burst_size = axi::get_burst_size(trans);
    auto mask = bw - 1ULL;
    auto offset = trans.get_address() & mask;
    if(!offset) {
        if(trans.get_data_length() != (axi_burst_size * axi_burst_len)) {
            SCCERR(name) << "Illegal AXI settings: transaction data length (" << trans.get_data_length()
                         << ") does not correspond to AxSIZE/AxLEN  setting (" << axi_burst_size << "/" << axi_burst_len - 1
                         << ") and buswidth " << bw << " for " << trans;
        }
    } else {
        if((trans.get_data_length() + offset) > (axi_burst_size * axi_burst_len)) {
            SCCERR(name) << "Illegal AXI settings: transaction data length (" << trans.get_data_length()
                         << ") does not correspond to AxSIZE/AxLEN  setting (" << axi_burst_size << "/" << axi_burst_len - 1
                         << ") and buswidth " << bw << " for " << trans;
        }
    }
}
constexpr unsigned comb(axi::bar_e bar, axi::domain_e domain, axi::snoop_e snoop) {
    return to_int(bar) << 10 | to_int(domain) << 8 | to_int(snoop);
};
 
void axi_protocol::check_properties(const payload_type& trans) {
    if(auto* axi4_ext = trans.get_extension<axi::axi4_extension>()) {
        check_datawith_settings(trans);
        if(axi4_ext->get_cache() & 0xc0) {
            if(!axi4_ext->get_cache())
                SCCERR(name) << "Illegal AXI settings: active allocate bit(s) requires modifiable bit set";
        }
        if(axi4_ext->get_qos() > 15)
            SCCERR(name) << "Illegal AXI4 settings: maximum value of QoS is 15, illegal value is " << axi4_ext->get_qos();
    } else if(auto* ace_ext = trans.get_extension<axi::ace_extension>()) {
        if(ace_ext->get_cache() & 0xc0) {
            if(!ace_ext->get_cache())
                SCCERR(name) << "Illegal ACEL settings: active allocate bit(s) requires modifiable bit set";
            auto snoop = ace_ext->get_snoop();
            auto domain = ace_ext->get_domain();
            auto bar = ace_ext->get_barrier();
            switch(comb(bar, domain, snoop)) {
            case comb(bar_e::RESPECT_BARRIER, domain_e::NON_SHAREABLE, snoop_e::READ_NO_SNOOP):
            case comb(bar_e::RESPECT_BARRIER, domain_e::SYSTEM, snoop_e::READ_NO_SNOOP):
            case comb(bar_e::RESPECT_BARRIER, domain_e::INNER_SHAREABLE, snoop_e::READ_ONCE):
            case comb(bar_e::RESPECT_BARRIER, domain_e::OUTER_SHAREABLE, snoop_e::READ_ONCE):
            case comb(bar_e::MEMORY_BARRIER, domain_e::NON_SHAREABLE, snoop_e::READ_NO_SNOOP):
            case comb(bar_e::MEMORY_BARRIER, domain_e::INNER_SHAREABLE, snoop_e::READ_ONCE):
            case comb(bar_e::MEMORY_BARRIER, domain_e::OUTER_SHAREABLE, snoop_e::READ_ONCE):
            case comb(bar_e::MEMORY_BARRIER, domain_e::SYSTEM, snoop_e::READ_NO_SNOOP):
                check_datawith_settings(trans);
                break;
            case comb(bar_e::RESPECT_BARRIER, domain_e::NON_SHAREABLE, snoop_e::CLEAN_SHARED):
            case comb(bar_e::RESPECT_BARRIER, domain_e::INNER_SHAREABLE, snoop_e::CLEAN_SHARED):
            case comb(bar_e::RESPECT_BARRIER, domain_e::OUTER_SHAREABLE, snoop_e::CLEAN_SHARED):
            case comb(bar_e::RESPECT_BARRIER, domain_e::NON_SHAREABLE, snoop_e::CLEAN_INVALID):
            case comb(bar_e::RESPECT_BARRIER, domain_e::INNER_SHAREABLE, snoop_e::CLEAN_INVALID):
            case comb(bar_e::RESPECT_BARRIER, domain_e::OUTER_SHAREABLE, snoop_e::CLEAN_INVALID):
            case comb(bar_e::RESPECT_BARRIER, domain_e::NON_SHAREABLE, snoop_e::MAKE_INVALID):
            case comb(bar_e::RESPECT_BARRIER, domain_e::INNER_SHAREABLE, snoop_e::MAKE_INVALID):
            case comb(bar_e::RESPECT_BARRIER, domain_e::OUTER_SHAREABLE, snoop_e::MAKE_INVALID):
                break;
            case comb(bar_e::RESPECT_BARRIER, domain_e::NON_SHAREABLE, snoop_e::WRITE_NO_SNOOP):
            case comb(bar_e::RESPECT_BARRIER, domain_e::SYSTEM, snoop_e::WRITE_NO_SNOOP):
            case comb(bar_e::RESPECT_BARRIER, domain_e::INNER_SHAREABLE, snoop_e::WRITE_UNIQUE):
            case comb(bar_e::RESPECT_BARRIER, domain_e::OUTER_SHAREABLE, snoop_e::WRITE_UNIQUE):
            case comb(bar_e::RESPECT_BARRIER, domain_e::INNER_SHAREABLE, snoop_e::WRITE_LINE_UNIQUE):
            case comb(bar_e::RESPECT_BARRIER, domain_e::OUTER_SHAREABLE, snoop_e::WRITE_LINE_UNIQUE):
            case comb(bar_e::MEMORY_BARRIER, domain_e::NON_SHAREABLE, snoop_e::WRITE_NO_SNOOP):
            case comb(bar_e::MEMORY_BARRIER, domain_e::INNER_SHAREABLE, snoop_e::WRITE_UNIQUE):
            case comb(bar_e::MEMORY_BARRIER, domain_e::OUTER_SHAREABLE, snoop_e::WRITE_UNIQUE):
            case comb(bar_e::MEMORY_BARRIER, domain_e::SYSTEM, snoop_e::WRITE_NO_SNOOP):
                check_datawith_settings(trans);
                break;
            default:
                SCCERR(name) << "Illegal ACEL settings: According to D11.2 ACE-Lite signal requirements of ARM IHI 0022H  the following "
                                "setting is illegal:\n"
                             << "AxBAR:" << to_char(bar) << ", AxDOMAIN:" << to_char(domain) << ", AxSNOOP:" << to_char(snoop);
            }
        }
    } else if(auto* axi3_ext = trans.get_extension<axi::axi4_extension>()) {
        if(axi3_ext->get_cache() & 0xc0) {
            if(!axi3_ext->get_cache())
                SCCERR(name) << "Illegal AXI settings: active allocate bit(s) requires modifiable bit set";
        }
    }
}
 
} /* namespace checker */
} /* namespace axi */