| /* |
| * Copyright (c) 2013, 2015, 2017-2018,2020 ARM Limited |
| * All rights reserved. |
| * |
| * The license below extends only to copyright in the software and shall |
| * not be construed as granting a license to any other intellectual |
| * property including but not limited to intellectual property relating |
| * to a hardware implementation of the functionality of the software |
| * licensed hereunder. You may use the software subject to the license |
| * terms below provided that you ensure that this notice is replicated |
| * unmodified and in its entirety in all distributions of the software, |
| * modified or unmodified, in source code or in binary form. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer; |
| * redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution; |
| * neither the name of the copyright holders nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "dev/arm/generic_timer.hh" |
| |
| #include <cmath> |
| |
| #include "arch/arm/system.hh" |
| #include "arch/arm/utility.hh" |
| #include "cpu/base.hh" |
| #include "debug/Timer.hh" |
| #include "dev/arm/base_gic.hh" |
| #include "mem/packet_access.hh" |
| #include "params/GenericTimer.hh" |
| #include "params/GenericTimerFrame.hh" |
| #include "params/GenericTimerMem.hh" |
| #include "params/SystemCounter.hh" |
| |
| using namespace ArmISA; |
| |
| SystemCounter::SystemCounter(SystemCounterParams *const p) |
| : SimObject(p), |
| _enabled(true), |
| _value(0), |
| _increment(1), |
| _freqTable(p->freqs), |
| _activeFreqEntry(0), |
| _updateTick(0), |
| _freqUpdateEvent([this]{ freqUpdateCallback(); }, name()), |
| _nextFreqEntry(0) |
| { |
| fatal_if(_freqTable.empty(), "SystemCounter::SystemCounter: Base " |
| "frequency not provided\n"); |
| // Store the table end marker as a 32-bit zero word |
| _freqTable.push_back(0); |
| fatal_if(_freqTable.size() > MAX_FREQ_ENTRIES, |
| "SystemCounter::SystemCounter: Architecture states a maximum of 1004 " |
| "frequency table entries, limit surpassed\n"); |
| // Set the active frequency to be the base |
| _freq = _freqTable.front(); |
| _period = (1.0 / _freq) * SimClock::Frequency; |
| } |
| |
| void |
| SystemCounter::validateCounterRef(SystemCounter *const sys_cnt) |
| { |
| fatal_if(!sys_cnt, "SystemCounter::validateCounterRef: No valid system " |
| "counter, can't instantiate system timers\n"); |
| } |
| |
| void |
| SystemCounter::enable() |
| { |
| DPRINTF(Timer, "SystemCounter::enable: Counter enabled\n"); |
| _enabled = true; |
| updateTick(); |
| } |
| |
| void |
| SystemCounter::disable() |
| { |
| DPRINTF(Timer, "SystemCounter::disable: Counter disabled\n"); |
| updateValue(); |
| _enabled = false; |
| } |
| |
| uint64_t |
| SystemCounter::value() |
| { |
| if (_enabled) |
| updateValue(); |
| return _value; |
| } |
| |
| void |
| SystemCounter::updateValue() |
| { |
| uint64_t new_value = |
| _value + ((curTick() - _updateTick) / _period) * _increment; |
| if (new_value > _value) { |
| _value = new_value; |
| updateTick(); |
| } |
| } |
| |
| void |
| SystemCounter::setValue(uint64_t new_value) |
| { |
| if (_enabled) |
| warn("Explicit value set with counter enabled, UNKNOWNN result\n"); |
| _value = new_value; |
| updateTick(); |
| notifyListeners(); |
| } |
| |
| Tick |
| SystemCounter::whenValue(uint64_t cur_val, uint64_t target_val) const |
| { |
| Tick when = curTick(); |
| if (target_val > cur_val) { |
| uint64_t num_cycles = |
| std::ceil((target_val - cur_val) / ((double) _increment)); |
| // Take into account current cycle remaining ticks |
| Tick rem_ticks = _period - (curTick() % _period); |
| if (rem_ticks < _period) { |
| when += rem_ticks; |
| num_cycles -= 1; |
| } |
| when += num_cycles * _period; |
| } |
| return when; |
| } |
| |
| Tick |
| SystemCounter::whenValue(uint64_t target_val) |
| { |
| return whenValue(value(), target_val); |
| } |
| |
| void |
| SystemCounter::updateTick() |
| { |
| _updateTick = curTick() - (curTick() % _period); |
| } |
| |
| void |
| SystemCounter::freqUpdateSchedule(size_t new_freq_entry) |
| { |
| if (new_freq_entry < _freqTable.size()) { |
| auto &new_freq = _freqTable[new_freq_entry]; |
| if (new_freq != _freq) { |
| _nextFreqEntry = new_freq_entry; |
| // Wait until the value for which the lowest frequency increment |
| // is a exact divisor. This covers both high to low and low to |
| // high transitions |
| uint64_t new_incr = _freqTable[0] / new_freq; |
| uint64_t target_val = value(); |
| target_val += target_val % std::max(_increment, new_incr); |
| reschedule(_freqUpdateEvent, whenValue(target_val), true); |
| } |
| } |
| } |
| |
| void |
| SystemCounter::freqUpdateCallback() |
| { |
| DPRINTF(Timer, "SystemCounter::freqUpdateCallback: Changing counter " |
| "frequency\n"); |
| if (_enabled) |
| updateValue(); |
| _activeFreqEntry = _nextFreqEntry; |
| _freq = _freqTable[_activeFreqEntry]; |
| _increment = _freqTable[0] / _freq; |
| _period = (1.0 / _freq) * SimClock::Frequency; |
| notifyListeners(); |
| } |
| |
| void |
| SystemCounter::registerListener(SystemCounterListener *listener) |
| { |
| _listeners.push_back(listener); |
| } |
| |
| void |
| SystemCounter::notifyListeners() const |
| { |
| for (auto &listener : _listeners) |
| listener->notify(); |
| } |
| |
| void |
| SystemCounter::serialize(CheckpointOut &cp) const |
| { |
| DPRINTF(Timer, "SystemCounter::serialize: Serializing\n"); |
| SERIALIZE_SCALAR(_enabled); |
| SERIALIZE_SCALAR(_freq); |
| SERIALIZE_SCALAR(_value); |
| SERIALIZE_SCALAR(_increment); |
| SERIALIZE_CONTAINER(_freqTable); |
| SERIALIZE_SCALAR(_activeFreqEntry); |
| SERIALIZE_SCALAR(_updateTick); |
| bool pending_freq_update = _freqUpdateEvent.scheduled(); |
| SERIALIZE_SCALAR(pending_freq_update); |
| if (pending_freq_update) { |
| Tick when_freq_update = _freqUpdateEvent.when(); |
| SERIALIZE_SCALAR(when_freq_update); |
| } |
| SERIALIZE_SCALAR(_nextFreqEntry); |
| } |
| |
| void |
| SystemCounter::unserialize(CheckpointIn &cp) |
| { |
| DPRINTF(Timer, "SystemCounter::unserialize: Unserializing\n"); |
| UNSERIALIZE_SCALAR(_enabled); |
| UNSERIALIZE_SCALAR(_freq); |
| UNSERIALIZE_SCALAR(_value); |
| UNSERIALIZE_SCALAR(_increment); |
| UNSERIALIZE_CONTAINER(_freqTable); |
| UNSERIALIZE_SCALAR(_activeFreqEntry); |
| UNSERIALIZE_SCALAR(_updateTick); |
| bool pending_freq_update; |
| UNSERIALIZE_SCALAR(pending_freq_update); |
| if (pending_freq_update) { |
| Tick when_freq_update; |
| UNSERIALIZE_SCALAR(when_freq_update); |
| reschedule(_freqUpdateEvent, when_freq_update, true); |
| } |
| UNSERIALIZE_SCALAR(_nextFreqEntry); |
| |
| _period = (1.0 / _freq) * SimClock::Frequency; |
| } |
| |
| ArchTimer::ArchTimer(const std::string &name, |
| SimObject &parent, |
| SystemCounter &sysctr, |
| ArmInterruptPin *interrupt) |
| : _name(name), _parent(parent), _systemCounter(sysctr), |
| _interrupt(interrupt), |
| _control(0), _counterLimit(0), _offset(0), |
| _counterLimitReachedEvent([this]{ counterLimitReached(); }, name) |
| { |
| _systemCounter.registerListener(this); |
| } |
| |
| void |
| ArchTimer::counterLimitReached() |
| { |
| if (!_control.enable) |
| return; |
| |
| DPRINTF(Timer, "Counter limit reached\n"); |
| _control.istatus = 1; |
| if (!_control.imask) { |
| if (scheduleEvents()) { |
| DPRINTF(Timer, "Causing interrupt\n"); |
| _interrupt->raise(); |
| } else { |
| DPRINTF(Timer, "Kvm mode; skipping simulated interrupt\n"); |
| } |
| } |
| } |
| |
| void |
| ArchTimer::updateCounter() |
| { |
| if (_counterLimitReachedEvent.scheduled()) |
| _parent.deschedule(_counterLimitReachedEvent); |
| if (value() >= _counterLimit) { |
| counterLimitReached(); |
| } else { |
| // Clear the interurpt when timers conditions are not met |
| if (_interrupt->active()) { |
| DPRINTF(Timer, "Clearing interrupt\n"); |
| _interrupt->clear(); |
| } |
| |
| _control.istatus = 0; |
| |
| if (scheduleEvents()) { |
| _parent.schedule(_counterLimitReachedEvent, |
| whenValue(_counterLimit)); |
| } |
| } |
| } |
| |
| void |
| ArchTimer::setCompareValue(uint64_t val) |
| { |
| _counterLimit = val; |
| updateCounter(); |
| } |
| |
| void |
| ArchTimer::setTimerValue(uint32_t val) |
| { |
| setCompareValue(value() + sext<32>(val)); |
| } |
| |
| void |
| ArchTimer::setControl(uint32_t val) |
| { |
| ArchTimerCtrl old_ctl = _control, new_ctl = val; |
| _control.enable = new_ctl.enable; |
| _control.imask = new_ctl.imask; |
| _control.istatus = old_ctl.istatus; |
| // Timer unmasked or enabled |
| if ((old_ctl.imask && !new_ctl.imask) || |
| (!old_ctl.enable && new_ctl.enable)) |
| updateCounter(); |
| // Timer masked or disabled |
| else if ((!old_ctl.imask && new_ctl.imask) || |
| (old_ctl.enable && !new_ctl.enable)) { |
| |
| if (_interrupt->active()) { |
| DPRINTF(Timer, "Clearing interrupt\n"); |
| // We are clearing the interrupt but we are not |
| // setting istatus to 0 as we are doing |
| // in the updateCounter. |
| // istatus signals that Timer conditions are met. |
| // It shouldn't depend on masking. |
| // if enable is zero. istatus is unknown. |
| _interrupt->clear(); |
| } |
| } |
| } |
| |
| void |
| ArchTimer::setOffset(uint64_t val) |
| { |
| _offset = val; |
| updateCounter(); |
| } |
| |
| uint64_t |
| ArchTimer::value() const |
| { |
| return _systemCounter.value() - _offset; |
| } |
| |
| void |
| ArchTimer::notify() |
| { |
| updateCounter(); |
| } |
| |
| void |
| ArchTimer::serialize(CheckpointOut &cp) const |
| { |
| paramOut(cp, "control_serial", _control); |
| SERIALIZE_SCALAR(_counterLimit); |
| SERIALIZE_SCALAR(_offset); |
| } |
| |
| void |
| ArchTimer::unserialize(CheckpointIn &cp) |
| { |
| paramIn(cp, "control_serial", _control); |
| // We didn't serialize an offset before we added support for the |
| // virtual timer. Consider it optional to maintain backwards |
| // compatibility. |
| if (!UNSERIALIZE_OPT_SCALAR(_offset)) |
| _offset = 0; |
| |
| // We no longer schedule an event here because we may enter KVM |
| // emulation. The event creation is delayed until drainResume(). |
| } |
| |
| DrainState |
| ArchTimer::drain() |
| { |
| if (_counterLimitReachedEvent.scheduled()) |
| _parent.deschedule(_counterLimitReachedEvent); |
| |
| return DrainState::Drained; |
| } |
| |
| void |
| ArchTimer::drainResume() |
| { |
| updateCounter(); |
| } |
| |
| GenericTimer::GenericTimer(GenericTimerParams *const p) |
| : SimObject(p), |
| systemCounter(*p->counter), |
| system(*p->system) |
| { |
| SystemCounter::validateCounterRef(p->counter); |
| fatal_if(!p->system, "GenericTimer::GenericTimer: No system specified, " |
| "can't instantiate architected timers\n"); |
| system.setGenericTimer(this); |
| } |
| |
| const GenericTimerParams * |
| GenericTimer::params() const |
| { |
| return dynamic_cast<const GenericTimerParams *>(_params); |
| } |
| |
| void |
| GenericTimer::serialize(CheckpointOut &cp) const |
| { |
| paramOut(cp, "cpu_count", timers.size()); |
| |
| for (int i = 0; i < timers.size(); ++i) { |
| const CoreTimers &core(*timers[i]); |
| core.serializeSection(cp, csprintf("pe_implementation%d", i)); |
| } |
| } |
| |
| void |
| GenericTimer::unserialize(CheckpointIn &cp) |
| { |
| // Try to unserialize the CPU count. Old versions of the timer |
| // model assumed a 8 CPUs, so we fall back to that if the field |
| // isn't present. |
| static const unsigned OLD_CPU_MAX = 8; |
| unsigned cpu_count; |
| if (!UNSERIALIZE_OPT_SCALAR(cpu_count)) { |
| warn("Checkpoint does not contain CPU count, assuming %i CPUs\n", |
| OLD_CPU_MAX); |
| cpu_count = OLD_CPU_MAX; |
| } |
| |
| // We cannot assert for equality here because CPU timers are dynamically |
| // created on the first miscreg access. Therefore, if we take the checkpoint |
| // before any timer registers have been accessed, the number of counters |
| // is actually smaller than the total number of CPUs. |
| if (cpu_count > system.threads.size()) { |
| fatal("The simulated system has been initialized with %d CPUs, " |
| "but the Generic Timer checkpoint expects %d CPUs. Consider " |
| "restoring the checkpoint specifying %d CPUs.", |
| system.threads.size(), cpu_count, cpu_count); |
| } |
| |
| for (int i = 0; i < cpu_count; ++i) { |
| CoreTimers &core(getTimers(i)); |
| core.unserializeSection(cp, csprintf("pe_implementation%d", i)); |
| } |
| } |
| |
| GenericTimer::CoreTimers & |
| GenericTimer::getTimers(int cpu_id) |
| { |
| if (cpu_id >= timers.size()) |
| createTimers(cpu_id + 1); |
| |
| return *timers[cpu_id]; |
| } |
| |
| void |
| GenericTimer::createTimers(unsigned cpus) |
| { |
| assert(timers.size() < cpus); |
| auto p = static_cast<const GenericTimerParams *>(_params); |
| |
| const unsigned old_cpu_count(timers.size()); |
| timers.resize(cpus); |
| for (unsigned i = old_cpu_count; i < cpus; ++i) { |
| |
| ThreadContext *tc = system.threads[i]; |
| |
| timers[i].reset( |
| new CoreTimers(*this, system, i, |
| p->int_phys_s->get(tc), |
| p->int_phys_ns->get(tc), |
| p->int_virt->get(tc), |
| p->int_hyp->get(tc))); |
| } |
| } |
| |
| void |
| GenericTimer::handleStream(CoreTimers::EventStream *ev_stream, |
| ArchTimer *timer, RegVal old_cnt_ctl, RegVal cnt_ctl) |
| { |
| uint64_t evnten = bits(cnt_ctl, 2); |
| uint64_t old_evnten = bits(old_cnt_ctl, 2); |
| uint8_t old_trans_to = ev_stream->transitionTo; |
| uint8_t old_trans_bit = ev_stream->transitionBit; |
| ev_stream->transitionTo = !bits(cnt_ctl, 3); |
| ev_stream->transitionBit = bits(cnt_ctl, 7, 4); |
| // Reschedule the Event Stream if enabled and any change in |
| // configuration |
| if (evnten && ((old_evnten != evnten) || |
| (old_trans_to != ev_stream->transitionTo) || |
| (old_trans_bit != ev_stream->transitionBit))) { |
| |
| Tick when = timer->whenValue( |
| ev_stream->eventTargetValue(timer->value())); |
| reschedule(ev_stream->event, when, true); |
| } else if (old_evnten && !evnten) { |
| // Event Stream generation disabled |
| if (ev_stream->event.scheduled()) |
| deschedule(ev_stream->event); |
| } |
| } |
| |
| void |
| GenericTimer::setMiscReg(int reg, unsigned cpu, RegVal val) |
| { |
| CoreTimers &core(getTimers(cpu)); |
| ThreadContext *tc = system.threads[cpu]; |
| |
| switch (reg) { |
| case MISCREG_CNTFRQ: |
| case MISCREG_CNTFRQ_EL0: |
| core.cntfrq = val; |
| warn_if(core.cntfrq != systemCounter.freq(), "CNTFRQ configured freq " |
| "does not match the system counter freq\n"); |
| return; |
| case MISCREG_CNTKCTL: |
| case MISCREG_CNTKCTL_EL1: |
| { |
| if (ELIsInHost(tc, currEL(tc))) { |
| tc->setMiscReg(MISCREG_CNTHCTL_EL2, val); |
| return; |
| } |
| RegVal old_cnt_ctl = core.cntkctl; |
| core.cntkctl = val; |
| |
| ArchTimer *timer = &core.virt; |
| CoreTimers::EventStream *ev_stream = &core.virtEvStream; |
| |
| handleStream(ev_stream, timer, old_cnt_ctl, val); |
| return; |
| } |
| case MISCREG_CNTHCTL: |
| case MISCREG_CNTHCTL_EL2: |
| { |
| RegVal old_cnt_ctl = core.cnthctl; |
| core.cnthctl = val; |
| |
| ArchTimer *timer = &core.physNS; |
| CoreTimers::EventStream *ev_stream = &core.physEvStream; |
| |
| handleStream(ev_stream, timer, old_cnt_ctl, val); |
| return; |
| } |
| // Physical timer (NS) |
| case MISCREG_CNTP_CVAL_NS: |
| case MISCREG_CNTP_CVAL_EL0: |
| core.physNS.setCompareValue(val); |
| return; |
| |
| case MISCREG_CNTP_TVAL_NS: |
| case MISCREG_CNTP_TVAL_EL0: |
| core.physNS.setTimerValue(val); |
| return; |
| |
| case MISCREG_CNTP_CTL_NS: |
| case MISCREG_CNTP_CTL_EL0: |
| core.physNS.setControl(val); |
| return; |
| |
| // Count registers |
| case MISCREG_CNTPCT: |
| case MISCREG_CNTPCT_EL0: |
| case MISCREG_CNTVCT: |
| case MISCREG_CNTVCT_EL0: |
| warn("Ignoring write to read only count register: %s\n", |
| miscRegName[reg]); |
| return; |
| |
| // Virtual timer |
| case MISCREG_CNTVOFF: |
| case MISCREG_CNTVOFF_EL2: |
| core.virt.setOffset(val); |
| return; |
| |
| case MISCREG_CNTV_CVAL: |
| case MISCREG_CNTV_CVAL_EL0: |
| core.virt.setCompareValue(val); |
| return; |
| |
| case MISCREG_CNTV_TVAL: |
| case MISCREG_CNTV_TVAL_EL0: |
| core.virt.setTimerValue(val); |
| return; |
| |
| case MISCREG_CNTV_CTL: |
| case MISCREG_CNTV_CTL_EL0: |
| core.virt.setControl(val); |
| return; |
| |
| // Physical timer (S) |
| case MISCREG_CNTP_CTL_S: |
| case MISCREG_CNTPS_CTL_EL1: |
| core.physS.setControl(val); |
| return; |
| |
| case MISCREG_CNTP_CVAL_S: |
| case MISCREG_CNTPS_CVAL_EL1: |
| core.physS.setCompareValue(val); |
| return; |
| |
| case MISCREG_CNTP_TVAL_S: |
| case MISCREG_CNTPS_TVAL_EL1: |
| core.physS.setTimerValue(val); |
| return; |
| |
| // Hyp phys. timer, non-secure |
| case MISCREG_CNTHP_CTL: |
| case MISCREG_CNTHP_CTL_EL2: |
| core.hyp.setControl(val); |
| return; |
| |
| case MISCREG_CNTHP_CVAL: |
| case MISCREG_CNTHP_CVAL_EL2: |
| core.hyp.setCompareValue(val); |
| return; |
| |
| case MISCREG_CNTHP_TVAL: |
| case MISCREG_CNTHP_TVAL_EL2: |
| core.hyp.setTimerValue(val); |
| return; |
| |
| default: |
| warn("Writing to unknown register: %s\n", miscRegName[reg]); |
| return; |
| } |
| } |
| |
| |
| RegVal |
| GenericTimer::readMiscReg(int reg, unsigned cpu) |
| { |
| CoreTimers &core(getTimers(cpu)); |
| |
| switch (reg) { |
| case MISCREG_CNTFRQ: |
| case MISCREG_CNTFRQ_EL0: |
| return core.cntfrq; |
| case MISCREG_CNTKCTL: |
| case MISCREG_CNTKCTL_EL1: |
| return core.cntkctl & 0x00000000ffffffff; |
| case MISCREG_CNTHCTL: |
| case MISCREG_CNTHCTL_EL2: |
| return core.cnthctl & 0x00000000ffffffff; |
| // Physical timer |
| case MISCREG_CNTP_CVAL_NS: |
| case MISCREG_CNTP_CVAL_EL0: |
| return core.physNS.compareValue(); |
| |
| case MISCREG_CNTP_TVAL_NS: |
| case MISCREG_CNTP_TVAL_EL0: |
| return core.physNS.timerValue(); |
| |
| case MISCREG_CNTP_CTL_EL0: |
| case MISCREG_CNTP_CTL_NS: |
| return core.physNS.control(); |
| |
| case MISCREG_CNTPCT: |
| case MISCREG_CNTPCT_EL0: |
| return core.physNS.value(); |
| |
| |
| // Virtual timer |
| case MISCREG_CNTVCT: |
| case MISCREG_CNTVCT_EL0: |
| return core.virt.value(); |
| |
| case MISCREG_CNTVOFF: |
| case MISCREG_CNTVOFF_EL2: |
| return core.virt.offset(); |
| |
| case MISCREG_CNTV_CVAL: |
| case MISCREG_CNTV_CVAL_EL0: |
| return core.virt.compareValue(); |
| |
| case MISCREG_CNTV_TVAL: |
| case MISCREG_CNTV_TVAL_EL0: |
| return core.virt.timerValue(); |
| |
| case MISCREG_CNTV_CTL: |
| case MISCREG_CNTV_CTL_EL0: |
| return core.virt.control(); |
| |
| // PL1 phys. timer, secure |
| case MISCREG_CNTP_CTL_S: |
| case MISCREG_CNTPS_CTL_EL1: |
| return core.physS.control(); |
| |
| case MISCREG_CNTP_CVAL_S: |
| case MISCREG_CNTPS_CVAL_EL1: |
| return core.physS.compareValue(); |
| |
| case MISCREG_CNTP_TVAL_S: |
| case MISCREG_CNTPS_TVAL_EL1: |
| return core.physS.timerValue(); |
| |
| // HYP phys. timer (NS) |
| case MISCREG_CNTHP_CTL: |
| case MISCREG_CNTHP_CTL_EL2: |
| return core.hyp.control(); |
| |
| case MISCREG_CNTHP_CVAL: |
| case MISCREG_CNTHP_CVAL_EL2: |
| return core.hyp.compareValue(); |
| |
| case MISCREG_CNTHP_TVAL: |
| case MISCREG_CNTHP_TVAL_EL2: |
| return core.hyp.timerValue(); |
| |
| default: |
| warn("Reading from unknown register: %s\n", miscRegName[reg]); |
| return 0; |
| } |
| } |
| |
| GenericTimer::CoreTimers::CoreTimers(GenericTimer &_parent, |
| ArmSystem &system, unsigned cpu, |
| ArmInterruptPin *_irqPhysS, ArmInterruptPin *_irqPhysNS, |
| ArmInterruptPin *_irqVirt, ArmInterruptPin *_irqHyp) |
| : parent(_parent), |
| cntfrq(parent.params()->cntfrq), |
| threadContext(system.threads[cpu]), |
| irqPhysS(_irqPhysS), |
| irqPhysNS(_irqPhysNS), |
| irqVirt(_irqVirt), |
| irqHyp(_irqHyp), |
| physS(csprintf("%s.phys_s_timer%d", parent.name(), cpu), |
| system, parent, parent.systemCounter, |
| _irqPhysS), |
| // This should really be phys_timerN, but we are stuck with |
| // arch_timer for backwards compatibility. |
| physNS(csprintf("%s.arch_timer%d", parent.name(), cpu), |
| system, parent, parent.systemCounter, |
| _irqPhysNS), |
| virt(csprintf("%s.virt_timer%d", parent.name(), cpu), |
| system, parent, parent.systemCounter, |
| _irqVirt), |
| hyp(csprintf("%s.hyp_timer%d", parent.name(), cpu), |
| system, parent, parent.systemCounter, |
| _irqHyp), |
| physEvStream{ |
| EventFunctionWrapper([this]{ physEventStreamCallback(); }, |
| csprintf("%s.phys_event_gen%d", parent.name(), cpu)), 0, 0 |
| }, |
| virtEvStream{ |
| EventFunctionWrapper([this]{ virtEventStreamCallback(); }, |
| csprintf("%s.virt_event_gen%d", parent.name(), cpu)), 0, 0 |
| } |
| { |
| } |
| |
| void |
| GenericTimer::CoreTimers::physEventStreamCallback() |
| { |
| eventStreamCallback(); |
| schedNextEvent(physEvStream, physNS); |
| } |
| |
| void |
| GenericTimer::CoreTimers::virtEventStreamCallback() |
| { |
| eventStreamCallback(); |
| schedNextEvent(virtEvStream, virt); |
| } |
| |
| void |
| GenericTimer::CoreTimers::eventStreamCallback() const |
| { |
| sendEvent(threadContext); |
| threadContext->getCpuPtr()->wakeup(threadContext->threadId()); |
| } |
| |
| void |
| GenericTimer::CoreTimers::schedNextEvent(EventStream &ev_stream, |
| ArchTimer &timer) |
| { |
| parent.reschedule(ev_stream.event, timer.whenValue( |
| ev_stream.eventTargetValue(timer.value())), true); |
| } |
| |
| void |
| GenericTimer::CoreTimers::notify() |
| { |
| schedNextEvent(virtEvStream, virt); |
| schedNextEvent(physEvStream, physNS); |
| } |
| |
| void |
| GenericTimer::CoreTimers::serialize(CheckpointOut &cp) const |
| { |
| SERIALIZE_SCALAR(cntfrq); |
| SERIALIZE_SCALAR(cntkctl); |
| SERIALIZE_SCALAR(cnthctl); |
| |
| const bool phys_ev_scheduled = physEvStream.event.scheduled(); |
| SERIALIZE_SCALAR(phys_ev_scheduled); |
| if (phys_ev_scheduled) { |
| const Tick phys_ev_when = physEvStream.event.when(); |
| SERIALIZE_SCALAR(phys_ev_when); |
| } |
| SERIALIZE_SCALAR(physEvStream.transitionTo); |
| SERIALIZE_SCALAR(physEvStream.transitionBit); |
| |
| const bool virt_ev_scheduled = virtEvStream.event.scheduled(); |
| SERIALIZE_SCALAR(virt_ev_scheduled); |
| if (virt_ev_scheduled) { |
| const Tick virt_ev_when = virtEvStream.event.when(); |
| SERIALIZE_SCALAR(virt_ev_when); |
| } |
| SERIALIZE_SCALAR(virtEvStream.transitionTo); |
| SERIALIZE_SCALAR(virtEvStream.transitionBit); |
| |
| physS.serializeSection(cp, "phys_s_timer"); |
| physNS.serializeSection(cp, "phys_ns_timer"); |
| virt.serializeSection(cp, "virt_timer"); |
| hyp.serializeSection(cp, "hyp_timer"); |
| } |
| |
| void |
| GenericTimer::CoreTimers::unserialize(CheckpointIn &cp) |
| { |
| UNSERIALIZE_SCALAR(cntfrq); |
| UNSERIALIZE_SCALAR(cntkctl); |
| UNSERIALIZE_SCALAR(cnthctl); |
| |
| bool phys_ev_scheduled; |
| UNSERIALIZE_SCALAR(phys_ev_scheduled); |
| if (phys_ev_scheduled) { |
| Tick phys_ev_when; |
| UNSERIALIZE_SCALAR(phys_ev_when); |
| parent.reschedule(physEvStream.event, phys_ev_when, true); |
| } |
| UNSERIALIZE_SCALAR(physEvStream.transitionTo); |
| UNSERIALIZE_SCALAR(physEvStream.transitionBit); |
| |
| bool virt_ev_scheduled; |
| UNSERIALIZE_SCALAR(virt_ev_scheduled); |
| if (virt_ev_scheduled) { |
| Tick virt_ev_when; |
| UNSERIALIZE_SCALAR(virt_ev_when); |
| parent.reschedule(virtEvStream.event, virt_ev_when, true); |
| } |
| UNSERIALIZE_SCALAR(virtEvStream.transitionTo); |
| UNSERIALIZE_SCALAR(virtEvStream.transitionBit); |
| |
| physS.unserializeSection(cp, "phys_s_timer"); |
| physNS.unserializeSection(cp, "phys_ns_timer"); |
| virt.unserializeSection(cp, "virt_timer"); |
| hyp.unserializeSection(cp, "hyp_timer"); |
| } |
| |
| void |
| GenericTimerISA::setMiscReg(int reg, RegVal val) |
| { |
| DPRINTF(Timer, "Setting %s := 0x%x\n", miscRegName[reg], val); |
| parent.setMiscReg(reg, cpu, val); |
| } |
| |
| RegVal |
| GenericTimerISA::readMiscReg(int reg) |
| { |
| RegVal value = parent.readMiscReg(reg, cpu); |
| DPRINTF(Timer, "Reading %s as 0x%x\n", miscRegName[reg], value); |
| return value; |
| } |
| |
| GenericTimerFrame::GenericTimerFrame(GenericTimerFrameParams *const p) |
| : PioDevice(p), |
| timerRange(RangeSize(p->cnt_base, ArmSystem::PageBytes)), |
| addrRanges({timerRange}), |
| systemCounter(*p->counter), |
| physTimer(csprintf("%s.phys_timer", name()), |
| *this, systemCounter, p->int_phys->get()), |
| virtTimer(csprintf("%s.virt_timer", name()), |
| *this, systemCounter, |
| p->int_virt->get()), |
| accessBits(0x3f), |
| system(*dynamic_cast<ArmSystem *>(sys)) |
| { |
| SystemCounter::validateCounterRef(p->counter); |
| // Expose optional CNTEL0Base register frame |
| if (p->cnt_el0_base != MaxAddr) { |
| timerEl0Range = RangeSize(p->cnt_el0_base, ArmSystem::PageBytes); |
| accessBitsEl0 = 0x303; |
| addrRanges.push_back(timerEl0Range); |
| } |
| for (auto &range : addrRanges) |
| GenericTimerMem::validateFrameRange(range); |
| } |
| |
| void |
| GenericTimerFrame::serialize(CheckpointOut &cp) const |
| { |
| SERIALIZE_SCALAR(accessBits); |
| if (hasEl0View()) |
| SERIALIZE_SCALAR(accessBitsEl0); |
| SERIALIZE_SCALAR(nonSecureAccess); |
| |
| physTimer.serializeSection(cp, "phys_timer"); |
| virtTimer.serializeSection(cp, "virt_timer"); |
| } |
| |
| void |
| GenericTimerFrame::unserialize(CheckpointIn &cp) |
| { |
| UNSERIALIZE_SCALAR(accessBits); |
| if (hasEl0View()) |
| UNSERIALIZE_SCALAR(accessBitsEl0); |
| UNSERIALIZE_SCALAR(nonSecureAccess); |
| |
| physTimer.unserializeSection(cp, "phys_timer"); |
| virtTimer.unserializeSection(cp, "virt_timer"); |
| } |
| |
| uint64_t |
| GenericTimerFrame::getVirtOffset() const |
| { |
| return virtTimer.offset(); |
| } |
| |
| void |
| GenericTimerFrame::setVirtOffset(uint64_t new_offset) |
| { |
| virtTimer.setOffset(new_offset); |
| } |
| |
| bool |
| GenericTimerFrame::hasEl0View() const |
| { |
| return timerEl0Range.valid(); |
| } |
| |
| uint8_t |
| GenericTimerFrame::getAccessBits() const |
| { |
| return accessBits; |
| } |
| |
| void |
| GenericTimerFrame::setAccessBits(uint8_t data) |
| { |
| accessBits = data & 0x3f; |
| } |
| |
| bool |
| GenericTimerFrame::hasNonSecureAccess() const |
| { |
| return nonSecureAccess; |
| } |
| |
| void |
| GenericTimerFrame::setNonSecureAccess() |
| { |
| nonSecureAccess = true; |
| } |
| |
| bool |
| GenericTimerFrame::hasReadableVoff() const |
| { |
| return accessBits.rvoff; |
| } |
| |
| AddrRangeList |
| GenericTimerFrame::getAddrRanges() const |
| { |
| return addrRanges; |
| } |
| |
| Tick |
| GenericTimerFrame::read(PacketPtr pkt) |
| { |
| const Addr addr = pkt->getAddr(); |
| const size_t size = pkt->getSize(); |
| const bool is_sec = pkt->isSecure(); |
| panic_if(size != 4 && size != 8, |
| "GenericTimerFrame::read: Invalid size %i\n", size); |
| |
| bool to_el0 = false; |
| uint64_t resp = 0; |
| Addr offset = 0; |
| if (timerRange.contains(addr)) { |
| offset = addr - timerRange.start(); |
| } else if (hasEl0View() && timerEl0Range.contains(addr)) { |
| offset = addr - timerEl0Range.start(); |
| to_el0 = true; |
| } else { |
| panic("GenericTimerFrame::read: Invalid address: 0x%x\n", addr); |
| } |
| |
| resp = timerRead(offset, size, is_sec, to_el0); |
| |
| DPRINTF(Timer, "GenericTimerFrame::read: 0x%x<-0x%x(%i) [S = %u]\n", resp, |
| addr, size, is_sec); |
| |
| pkt->setUintX(resp, ByteOrder::little); |
| pkt->makeResponse(); |
| return 0; |
| } |
| |
| Tick |
| GenericTimerFrame::write(PacketPtr pkt) |
| { |
| const Addr addr = pkt->getAddr(); |
| const size_t size = pkt->getSize(); |
| const bool is_sec = pkt->isSecure(); |
| panic_if(size != 4 && size != 8, |
| "GenericTimerFrame::write: Invalid size %i\n", size); |
| |
| bool to_el0 = false; |
| const uint64_t data = pkt->getUintX(ByteOrder::little); |
| Addr offset = 0; |
| if (timerRange.contains(addr)) { |
| offset = addr - timerRange.start(); |
| } else if (hasEl0View() && timerEl0Range.contains(addr)) { |
| offset = addr - timerEl0Range.start(); |
| to_el0 = true; |
| } else { |
| panic("GenericTimerFrame::write: Invalid address: 0x%x\n", addr); |
| } |
| |
| timerWrite(offset, size, data, is_sec, to_el0); |
| |
| DPRINTF(Timer, "GenericTimerFrame::write: 0x%x->0x%x(%i) [S = %u]\n", data, |
| addr, size, is_sec); |
| |
| pkt->makeResponse(); |
| return 0; |
| } |
| |
| uint64_t |
| GenericTimerFrame::timerRead(Addr addr, size_t size, bool is_sec, |
| bool to_el0) const |
| { |
| if (!GenericTimerMem::validateAccessPerm(system, is_sec) && |
| !nonSecureAccess) |
| return 0; |
| |
| switch (addr) { |
| case TIMER_CNTPCT_LO: |
| if (!accessBits.rpct || (to_el0 && !accessBitsEl0.pcten)) |
| return 0; |
| else |
| return physTimer.value(); |
| |
| case TIMER_CNTPCT_HI: |
| if (!accessBits.rpct || (to_el0 && !accessBitsEl0.pcten)) |
| return 0; |
| else |
| return physTimer.value() >> 32; |
| |
| case TIMER_CNTFRQ: |
| if ((!accessBits.rfrq) || |
| (to_el0 && (!accessBitsEl0.pcten && !accessBitsEl0.vcten))) |
| return 0; |
| else |
| return systemCounter.freq(); |
| |
| case TIMER_CNTEL0ACR: |
| if (!hasEl0View() || to_el0) |
| return 0; |
| else |
| return accessBitsEl0; |
| |
| case TIMER_CNTP_CVAL_LO: |
| if (!accessBits.rwpt || (to_el0 && !accessBitsEl0.pten)) |
| return 0; |
| else |
| return physTimer.compareValue(); |
| |
| case TIMER_CNTP_CVAL_HI: |
| if (!accessBits.rwpt || (to_el0 && !accessBitsEl0.pten)) |
| return 0; |
| else |
| return physTimer.compareValue() >> 32; |
| |
| case TIMER_CNTP_TVAL: |
| if (!accessBits.rwpt || (to_el0 && !accessBitsEl0.pten)) |
| return 0; |
| else |
| return physTimer.timerValue(); |
| case TIMER_CNTP_CTL: |
| if (!accessBits.rwpt || (to_el0 && !accessBitsEl0.pten)) |
| return 0; |
| else |
| return physTimer.control(); |
| |
| case TIMER_CNTVCT_LO: |
| if (!accessBits.rvct || (to_el0 && !accessBitsEl0.vcten)) |
| return 0; |
| else |
| return virtTimer.value(); |
| |
| case TIMER_CNTVCT_HI: |
| if (!accessBits.rvct || (to_el0 && !accessBitsEl0.vcten)) |
| return 0; |
| else |
| return virtTimer.value() >> 32; |
| |
| case TIMER_CNTVOFF_LO: |
| if (!accessBits.rvoff || (to_el0)) |
| return 0; |
| else |
| return virtTimer.offset(); |
| |
| case TIMER_CNTVOFF_HI: |
| if (!accessBits.rvoff || (to_el0)) |
| return 0; |
| else |
| return virtTimer.offset() >> 32; |
| |
| case TIMER_CNTV_CVAL_LO: |
| if (!accessBits.rwvt || (to_el0 && !accessBitsEl0.vten)) |
| return 0; |
| else |
| return virtTimer.compareValue(); |
| |
| case TIMER_CNTV_CVAL_HI: |
| if (!accessBits.rwvt || (to_el0 && !accessBitsEl0.vten)) |
| return 0; |
| else |
| return virtTimer.compareValue() >> 32; |
| |
| case TIMER_CNTV_TVAL: |
| if (!accessBits.rwvt || (to_el0 && !accessBitsEl0.vten)) |
| return 0; |
| else |
| return virtTimer.timerValue(); |
| |
| case TIMER_CNTV_CTL: |
| if (!accessBits.rwvt || (to_el0 && !accessBitsEl0.vten)) |
| return 0; |
| else |
| return virtTimer.control(); |
| |
| default: |
| warn("GenericTimerFrame::timerRead: Unexpected address (0x%x:%i), " |
| "assuming RAZ\n", addr, size); |
| return 0; |
| } |
| } |
| |
| void |
| GenericTimerFrame::timerWrite(Addr addr, size_t size, uint64_t data, |
| bool is_sec, bool to_el0) |
| { |
| if (!GenericTimerMem::validateAccessPerm(system, is_sec) && |
| !nonSecureAccess) |
| return; |
| |
| switch (addr) { |
| case TIMER_CNTPCT_LO ... TIMER_CNTPCT_HI: |
| warn("GenericTimerFrame::timerWrite: RO reg (0x%x) [CNTPCT]\n", |
| addr); |
| return; |
| |
| case TIMER_CNTFRQ: |
| warn("GenericTimerFrame::timerWrite: RO reg (0x%x) [CNTFRQ]\n", |
| addr); |
| return; |
| |
| case TIMER_CNTEL0ACR: |
| if (!hasEl0View() || to_el0) |
| return; |
| |
| insertBits(accessBitsEl0, 9, 8, data); |
| insertBits(accessBitsEl0, 1, 0, data); |
| return; |
| |
| case TIMER_CNTP_CVAL_LO: |
| if ((!accessBits.rwpt) || (to_el0 && !accessBitsEl0.pten)) |
| return; |
| data = size == 4 ? insertBits(physTimer.compareValue(), |
| 31, 0, data) : data; |
| physTimer.setCompareValue(data); |
| return; |
| |
| case TIMER_CNTP_CVAL_HI: |
| if ((!accessBits.rwpt) || (to_el0 && !accessBitsEl0.pten)) |
| return; |
| data = insertBits(physTimer.compareValue(), 63, 32, data); |
| physTimer.setCompareValue(data); |
| return; |
| |
| case TIMER_CNTP_TVAL: |
| if ((!accessBits.rwpt) || (to_el0 && !accessBitsEl0.pten)) |
| return; |
| physTimer.setTimerValue(data); |
| return; |
| |
| case TIMER_CNTP_CTL: |
| if ((!accessBits.rwpt) || (to_el0 && !accessBitsEl0.pten)) |
| return; |
| physTimer.setControl(data); |
| return; |
| |
| case TIMER_CNTVCT_LO ... TIMER_CNTVCT_HI: |
| warn("GenericTimerFrame::timerWrite: RO reg (0x%x) [CNTVCT]\n", |
| addr); |
| return; |
| case TIMER_CNTVOFF_LO ... TIMER_CNTVOFF_HI: |
| warn("GenericTimerFrame::timerWrite: RO reg (0x%x) [CNTVOFF]\n", |
| addr); |
| return; |
| |
| case TIMER_CNTV_CVAL_LO: |
| if ((!accessBits.rwvt) || (to_el0 && !accessBitsEl0.vten)) |
| return; |
| data = size == 4 ? insertBits(virtTimer.compareValue(), |
| 31, 0, data) : data; |
| virtTimer.setCompareValue(data); |
| return; |
| |
| case TIMER_CNTV_CVAL_HI: |
| if ((!accessBits.rwvt) || (to_el0 && !accessBitsEl0.vten)) |
| return; |
| data = insertBits(virtTimer.compareValue(), 63, 32, data); |
| virtTimer.setCompareValue(data); |
| return; |
| |
| case TIMER_CNTV_TVAL: |
| if ((!accessBits.rwvt) || (to_el0 && !accessBitsEl0.vten)) |
| return; |
| virtTimer.setTimerValue(data); |
| return; |
| |
| case TIMER_CNTV_CTL: |
| if ((!accessBits.rwvt) || (to_el0 && !accessBitsEl0.vten)) |
| return; |
| virtTimer.setControl(data); |
| return; |
| |
| default: |
| warn("GenericTimerFrame::timerWrite: Unexpected address (0x%x:%i), " |
| "assuming WI\n", addr, size); |
| } |
| } |
| |
| GenericTimerMem::GenericTimerMem(GenericTimerMemParams *const p) |
| : PioDevice(p), |
| counterCtrlRange(RangeSize(p->cnt_control_base, ArmSystem::PageBytes)), |
| counterStatusRange(RangeSize(p->cnt_read_base, ArmSystem::PageBytes)), |
| timerCtrlRange(RangeSize(p->cnt_ctl_base, ArmSystem::PageBytes)), |
| cnttidr(0x0), |
| addrRanges{counterCtrlRange, counterStatusRange, timerCtrlRange}, |
| systemCounter(*p->counter), |
| frames(p->frames), |
| system(*dynamic_cast<ArmSystem *>(sys)) |
| { |
| SystemCounter::validateCounterRef(p->counter); |
| for (auto &range : addrRanges) |
| GenericTimerMem::validateFrameRange(range); |
| fatal_if(frames.size() > MAX_TIMER_FRAMES, |
| "GenericTimerMem::GenericTimerMem: Architecture states a maximum of " |
| "8 memory-mapped timer frames, limit surpassed\n"); |
| // Initialize CNTTIDR with each frame's features |
| for (int i = 0; i < frames.size(); i++) { |
| uint32_t features = 0x1; |
| features |= 0x2; |
| if (frames[i]->hasEl0View()) |
| features |= 0x4; |
| features <<= i * 4; |
| replaceBits(cnttidr, (i + 1) * 4 - 1, i * 4, features); |
| } |
| } |
| |
| void |
| GenericTimerMem::validateFrameRange(const AddrRange &range) |
| { |
| fatal_if(range.start() % ArmSystem::PageBytes, |
| "GenericTimerMem::validateFrameRange: Architecture states each " |
| "register frame should be in a separate memory page, specified " |
| "range base address [0x%x] is not compliant\n"); |
| } |
| |
| bool |
| GenericTimerMem::validateAccessPerm(ArmSystem &sys, bool is_sec) |
| { |
| return !sys.haveSecurity() || is_sec; |
| } |
| |
| AddrRangeList |
| GenericTimerMem::getAddrRanges() const |
| { |
| return addrRanges; |
| } |
| |
| Tick |
| GenericTimerMem::read(PacketPtr pkt) |
| { |
| const Addr addr = pkt->getAddr(); |
| const size_t size = pkt->getSize(); |
| const bool is_sec = pkt->isSecure(); |
| panic_if(size != 4 && size != 8, |
| "GenericTimerMem::read: Invalid size %i\n", size); |
| |
| uint64_t resp = 0; |
| if (counterCtrlRange.contains(addr)) |
| resp = counterCtrlRead(addr - counterCtrlRange.start(), size, is_sec); |
| else if (counterStatusRange.contains(addr)) |
| resp = counterStatusRead(addr - counterStatusRange.start(), size); |
| else if (timerCtrlRange.contains(addr)) |
| resp = timerCtrlRead(addr - timerCtrlRange.start(), size, is_sec); |
| else |
| panic("GenericTimerMem::read: Invalid address: 0x%x\n", addr); |
| |
| DPRINTF(Timer, "GenericTimerMem::read: 0x%x<-0x%x(%i) [S = %u]\n", resp, |
| addr, size, is_sec); |
| |
| pkt->setUintX(resp, ByteOrder::little); |
| pkt->makeResponse(); |
| return 0; |
| } |
| |
| Tick |
| GenericTimerMem::write(PacketPtr pkt) |
| { |
| const Addr addr = pkt->getAddr(); |
| const size_t size = pkt->getSize(); |
| const bool is_sec = pkt->isSecure(); |
| panic_if(size != 4 && size != 8, |
| "GenericTimerMem::write: Invalid size %i\n", size); |
| |
| const uint64_t data = pkt->getUintX(ByteOrder::little); |
| if (counterCtrlRange.contains(addr)) |
| counterCtrlWrite(addr - counterCtrlRange.start(), size, data, is_sec); |
| else if (counterStatusRange.contains(addr)) |
| counterStatusWrite(addr - counterStatusRange.start(), size, data); |
| else if (timerCtrlRange.contains(addr)) |
| timerCtrlWrite(addr - timerCtrlRange.start(), size, data, is_sec); |
| else |
| panic("GenericTimerMem::write: Invalid address: 0x%x\n", addr); |
| |
| DPRINTF(Timer, "GenericTimerMem::write: 0x%x->0x%x(%i) [S = %u]\n", data, |
| addr, size, is_sec); |
| |
| pkt->makeResponse(); |
| return 0; |
| } |
| |
| uint64_t |
| GenericTimerMem::counterCtrlRead(Addr addr, size_t size, bool is_sec) const |
| { |
| if (!GenericTimerMem::validateAccessPerm(system, is_sec)) |
| return 0; |
| switch (addr) { |
| case COUNTER_CTRL_CNTCR: |
| { |
| CNTCR cntcr = 0; |
| cntcr.en = systemCounter.enabled(); |
| cntcr.fcreq = systemCounter.activeFreqEntry(); |
| return cntcr; |
| } |
| case COUNTER_CTRL_CNTSR: |
| { |
| CNTSR cntsr = 0; |
| cntsr.fcack = systemCounter.activeFreqEntry(); |
| return cntsr; |
| } |
| case COUNTER_CTRL_CNTCV_LO: return systemCounter.value(); |
| case COUNTER_CTRL_CNTCV_HI: return systemCounter.value() >> 32; |
| case COUNTER_CTRL_CNTSCR: return 0; |
| case COUNTER_CTRL_CNTID: return 0; |
| default: |
| { |
| auto &freq_table = systemCounter.freqTable(); |
| for (int i = 0; i < (freq_table.size() - 1); i++) { |
| Addr offset = COUNTER_CTRL_CNTFID + (i * 0x4); |
| if (addr == offset) |
| return freq_table[i]; |
| } |
| warn("GenericTimerMem::counterCtrlRead: Unexpected address " |
| "(0x%x:%i), assuming RAZ\n", addr, size); |
| return 0; |
| } |
| } |
| } |
| |
| void |
| GenericTimerMem::counterCtrlWrite(Addr addr, size_t size, uint64_t data, |
| bool is_sec) |
| { |
| if (!GenericTimerMem::validateAccessPerm(system, is_sec)) |
| return; |
| |
| switch (addr) { |
| case COUNTER_CTRL_CNTCR: |
| { |
| CNTCR val = data; |
| if (!systemCounter.enabled() && val.en) |
| systemCounter.enable(); |
| else if (systemCounter.enabled() && !val.en) |
| systemCounter.disable(); |
| |
| if (val.hdbg) |
| warn("GenericTimerMem::counterCtrlWrite: Halt-on-debug is not " |
| "supported\n"); |
| if (val.scen) |
| warn("GenericTimerMem::counterCtrlWrite: Counter Scaling is not " |
| "supported\n"); |
| if (val.fcreq != systemCounter.activeFreqEntry()) |
| systemCounter.freqUpdateSchedule(val.fcreq); |
| return; |
| } |
| |
| case COUNTER_CTRL_CNTSR: |
| warn("GenericTimerMem::counterCtrlWrite: RO reg (0x%x) [CNTSR]\n", |
| addr); |
| return; |
| |
| case COUNTER_CTRL_CNTCV_LO: |
| data = size == 4 ? insertBits(systemCounter.value(), 31, 0, data) |
| : data; |
| systemCounter.setValue(data); |
| return; |
| |
| case COUNTER_CTRL_CNTCV_HI: |
| data = insertBits(systemCounter.value(), 63, 32, data); |
| systemCounter.setValue(data); |
| return; |
| |
| case COUNTER_CTRL_CNTSCR: |
| return; |
| |
| case COUNTER_CTRL_CNTID: |
| warn("GenericTimerMem::counterCtrlWrite: RO reg (0x%x) [CNTID]\n", |
| addr); |
| return; |
| |
| default: |
| { |
| auto &freq_table = systemCounter.freqTable(); |
| for (int i = 0; i < (freq_table.size() - 1); i++) { |
| Addr offset = COUNTER_CTRL_CNTFID + (i * 0x4); |
| if (addr == offset) { |
| freq_table[i] = data; |
| // This is changing the currently selected frequency |
| if (i == systemCounter.activeFreqEntry()) { |
| // We've changed the frequency in the table entry, |
| // however the counter will still work with the |
| // current one until transition is completed |
| systemCounter.freqUpdateSchedule(i); |
| } |
| return; |
| } |
| } |
| warn("GenericTimerMem::counterCtrlWrite: Unexpected address " |
| "(0x%x:%i), assuming WI\n", addr, size); |
| } |
| } |
| } |
| |
| uint64_t |
| GenericTimerMem::counterStatusRead(Addr addr, size_t size) const |
| { |
| switch (addr) { |
| case COUNTER_STATUS_CNTCV_LO: return systemCounter.value(); |
| case COUNTER_STATUS_CNTCV_HI: return systemCounter.value() >> 32; |
| default: |
| warn("GenericTimerMem::counterStatusRead: Unexpected address " |
| "(0x%x:%i), assuming RAZ\n", addr, size); |
| return 0; |
| } |
| } |
| |
| void |
| GenericTimerMem::counterStatusWrite(Addr addr, size_t size, uint64_t data) |
| { |
| switch (addr) { |
| case COUNTER_STATUS_CNTCV_LO ... COUNTER_STATUS_CNTCV_HI: |
| warn("GenericTimerMem::counterStatusWrite: RO reg (0x%x) [CNTCV]\n", |
| addr); |
| return; |
| default: |
| warn("GenericTimerMem::counterStatusWrite: Unexpected address " |
| "(0x%x:%i), assuming WI\n", addr, size); |
| } |
| } |
| |
| uint64_t |
| GenericTimerMem::timerCtrlRead(Addr addr, size_t size, bool is_sec) const |
| { |
| switch (addr) { |
| case TIMER_CTRL_CNTFRQ: |
| if (!GenericTimerMem::validateAccessPerm(system, is_sec)) return 0; |
| return systemCounter.freq(); |
| case TIMER_CTRL_CNTNSAR: |
| { |
| if (!GenericTimerMem::validateAccessPerm(system, is_sec)) return 0; |
| uint32_t cntnsar = 0x0; |
| for (int i = 0; i < frames.size(); i++) { |
| if (frames[i]->hasNonSecureAccess()) |
| cntnsar |= 0x1 << i; |
| } |
| return cntnsar; |
| } |
| case TIMER_CTRL_CNTTIDR: return cnttidr; |
| default: |
| for (int i = 0; i < frames.size(); i++) { |
| Addr cntacr_off = TIMER_CTRL_CNTACR + (i * 0x4); |
| Addr cntvoff_lo_off = TIMER_CTRL_CNTVOFF_LO + (i * 0x4); |
| Addr cntvoff_hi_off = TIMER_CTRL_CNTVOFF_HI + (i * 0x4); |
| // CNTNSAR.NS determines if CNTACR/CNTVOFF are accessible from |
| // normal world |
| bool hit = addr == cntacr_off || addr == cntvoff_lo_off || |
| addr == cntvoff_hi_off; |
| bool has_access = |
| GenericTimerMem::validateAccessPerm(system, is_sec) || |
| frames[i]->hasNonSecureAccess(); |
| if (hit && !has_access) return 0; |
| if (addr == cntacr_off) |
| return frames[i]->getAccessBits(); |
| if (addr == cntvoff_lo_off || addr == cntvoff_hi_off) { |
| return addr == cntvoff_lo_off ? frames[i]->getVirtOffset() |
| : frames[i]->getVirtOffset() >> 32; |
| } |
| } |
| warn("GenericTimerMem::timerCtrlRead: Unexpected address (0x%x:%i), " |
| "assuming RAZ\n", addr, size); |
| return 0; |
| } |
| } |
| |
| void |
| GenericTimerMem::timerCtrlWrite(Addr addr, size_t size, uint64_t data, |
| bool is_sec) |
| { |
| switch (addr) { |
| case TIMER_CTRL_CNTFRQ: |
| if (!GenericTimerMem::validateAccessPerm(system, is_sec)) return; |
| warn_if(data != systemCounter.freq(), |
| "GenericTimerMem::timerCtrlWrite: CNTFRQ configured freq " |
| "does not match the counter freq, ignoring\n"); |
| return; |
| case TIMER_CTRL_CNTNSAR: |
| if (!GenericTimerMem::validateAccessPerm(system, is_sec)) return; |
| for (int i = 0; i < frames.size(); i++) { |
| // Check if the CNTNSAR.NS bit is set for this frame |
| if (data & (0x1 << i)) |
| frames[i]->setNonSecureAccess(); |
| } |
| return; |
| case TIMER_CTRL_CNTTIDR: |
| warn("GenericTimerMem::timerCtrlWrite: RO reg (0x%x) [CNTTIDR]\n", |
| addr); |
| return; |
| default: |
| for (int i = 0; i < frames.size(); i++) { |
| Addr cntacr_off = TIMER_CTRL_CNTACR + (i * 0x4); |
| Addr cntvoff_lo_off = TIMER_CTRL_CNTVOFF_LO + (i * 0x4); |
| Addr cntvoff_hi_off = TIMER_CTRL_CNTVOFF_HI + (i * 0x4); |
| // CNTNSAR.NS determines if CNTACR/CNTVOFF are accessible from |
| // normal world |
| bool hit = addr == cntacr_off || addr == cntvoff_lo_off || |
| addr == cntvoff_hi_off; |
| bool has_access = |
| GenericTimerMem::validateAccessPerm(system, is_sec) || |
| frames[i]->hasNonSecureAccess(); |
| if (hit && !has_access) return; |
| if (addr == cntacr_off) { |
| frames[i]->setAccessBits(data); |
| return; |
| } |
| if (addr == cntvoff_lo_off || addr == cntvoff_hi_off) { |
| if (addr == cntvoff_lo_off) |
| data = size == 4 ? insertBits(frames[i]->getVirtOffset(), |
| 31, 0, data) : data; |
| else |
| data = insertBits(frames[i]->getVirtOffset(), |
| 63, 32, data); |
| frames[i]->setVirtOffset(data); |
| return; |
| } |
| } |
| warn("GenericTimerMem::timerCtrlWrite: Unexpected address " |
| "(0x%x:%i), assuming WI\n", addr, size); |
| } |
| } |
| |
| SystemCounter * |
| SystemCounterParams::create() |
| { |
| return new SystemCounter(this); |
| } |
| |
| GenericTimer * |
| GenericTimerParams::create() |
| { |
| return new GenericTimer(this); |
| } |
| |
| GenericTimerFrame * |
| GenericTimerFrameParams::create() |
| { |
| return new GenericTimerFrame(this); |
| } |
| |
| GenericTimerMem * |
| GenericTimerMemParams::create() |
| { |
| return new GenericTimerMem(this); |
| } |
