qualcomm/qbox
Loading...
Searching...
No Matches
cpu-max.h
1/*
2 * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
3 *
4 * SPDX-License-Identifier: BSD-3-Clause-Clear
5 */
6
7#pragma once
8
9#include <string>
10
11#include <cci_configuration>
12
13#include <libqemu-cxx/target/aarch64.h>
14
15#include <tlm-extensions/exclusive-access.h>
16#include <module_factory_registery.h>
17
18#include <arm.h>
19#include <ports/qemu-initiator-signal-socket.h>
20#include <ports/qemu-target-signal-socket.h>
21#include <qemu-instance.h>
22
23class cpu_arm_max : public QemuCpuArm
24{
25protected:
26 int get_psci_conduit_val() const
27 {
28 if (p_psci_conduit.get_value() == "disabled") {
29 return 0;
30 } else if (p_psci_conduit.get_value() == "smc") {
31 return 1;
32 } else if (p_psci_conduit.get_value() == "hvc") {
33 return 2;
34 } else {
35 /* TODO: report warning */
36 return 0;
37 }
38 }
39
40 void add_exclusive_ext(TlmPayload& pl)
41 {
43 ext->add_hop(m_cpu.get_index());
44 pl.set_extension(ext);
45 }
46
47 static uint64_t extract_data_from_payload(const TlmPayload& pl)
48 {
49 uint8_t* ptr = pl.get_data_ptr() + pl.get_data_length() - 1;
50 uint64_t ret = 0;
51
52 /* QEMU never accesses more than 64 bits at the same time */
53 assert(pl.get_data_length() <= 8);
54
55 while (ptr >= pl.get_data_ptr()) {
56 ret = (ret << 8) | *(ptr--);
57 }
58
59 return ret;
60 }
61
62public:
63 cci::cci_param<unsigned int> p_mp_affinity;
64 cci::cci_param<bool> p_has_el2;
65 cci::cci_param<bool> p_has_el3;
66 cci::cci_param<bool> p_start_powered_off;
67 cci::cci_param<bool> p_en_pauth;
68 cci::cci_param<std::string> p_psci_conduit;
69 cci::cci_param<uint64_t> p_rvbar;
70 cci::cci_param<uint64_t> p_cntfrq_hz;
71
76
77 QemuInitiatorSignalSocket irq_timer_phys_out;
78 QemuInitiatorSignalSocket irq_timer_virt_out;
79 QemuInitiatorSignalSocket irq_timer_hyp_out;
80 QemuInitiatorSignalSocket irq_timer_sec_out;
81 QemuInitiatorSignalSocket irq_maintenance_out;
82 QemuInitiatorSignalSocket irq_pmu_out;
83
84 cpu_arm_max(const sc_core::sc_module_name& name, sc_core::sc_object* o)
85 : cpu_arm_max(name, *(dynamic_cast<QemuInstance*>(o)))
86 {
87 }
88 cpu_arm_max(const sc_core::sc_module_name& name, QemuInstance& inst)
89 : QemuCpuArm(name, inst, "max-arm")
90 , p_mp_affinity("mp_affinity", 0, "Multi-processor affinity value")
91 , p_has_el2("has_el2", true, "ARM virtualization extensions")
92 , p_has_el3("has_el3", true, "ARM secure-mode extensions")
93 , p_en_pauth("enable_pauth", true, "ARM pointer authentication")
94 , p_start_powered_off("start_powered_off", false,
95 "Start and reset the CPU "
96 "in powered-off state")
97 , p_psci_conduit("psci_conduit", "disabled",
98 "Set the QEMU PSCI conduit: "
99 "disabled->no conduit, "
100 "hvc->through hvc call, "
101 "smc->through smc call")
102 , p_rvbar("rvbar", 0ull, "Reset vector base address register value")
103 , p_cntfrq_hz("cntfrq_hz", 0ull, "CPU Generic Timer CNTFRQ in Hz")
104
105 , irq_in("irq_in")
106 , fiq_in("fiq_in")
107 , virq_in("virq_in")
108 , vfiq_in("vfiq_in")
109 , irq_timer_phys_out("irq_timer_phys_out")
110 , irq_timer_virt_out("irq_timer_virt_out")
111 , irq_timer_hyp_out("irq_timer_hyp_out")
112 , irq_timer_sec_out("irq_timer_sec_out")
113 , irq_maintenance_out("gicv3_maintenance_interrupt")
114 , irq_pmu_out("pmu_interrupt")
115 {
116 m_external_ev |= irq_in->default_event();
117 m_external_ev |= fiq_in->default_event();
118 m_external_ev |= virq_in->default_event();
119 m_external_ev |= vfiq_in->default_event();
120 }
121
122 void before_end_of_elaboration() override
123 {
124 QemuCpuArm::before_end_of_elaboration();
125
126 qemu::CpuAarch64 cpu(m_cpu);
127 cpu.set_aarch64_mode(true);
128
129 if (!p_mp_affinity.is_default_value()) {
130 cpu.set_prop_int("mp-affinity", p_mp_affinity);
131 }
132 cpu.set_prop_bool("has_el2", p_has_el2);
133 cpu.set_prop_bool("has_el3", p_has_el3);
134
135 if (!p_en_pauth.is_default_value()) {
136 cpu.set_prop_bool("pauth", p_en_pauth);
137 }
138 cpu.set_prop_bool("start-powered-off", p_start_powered_off);
139 cpu.set_prop_int("psci-conduit", get_psci_conduit_val());
140
141 cpu.set_prop_int("rvbar", p_rvbar);
142 if (!p_cntfrq_hz.is_default_value()) {
143 cpu.set_prop_int("cntfrq", p_cntfrq_hz);
144 }
145 }
146
147 void end_of_elaboration() override
148 {
149 QemuCpuArm::end_of_elaboration();
150
151 irq_in.init(m_dev, 0);
152 fiq_in.init(m_dev, 1);
153 virq_in.init(m_dev, 2);
154 vfiq_in.init(m_dev, 3);
155
156 irq_timer_phys_out.init(m_dev, 0);
157 irq_timer_virt_out.init(m_dev, 1);
158 irq_timer_hyp_out.init(m_dev, 2);
159 irq_timer_sec_out.init(m_dev, 3);
160 irq_maintenance_out.init_named(m_dev, "gicv3-maintenance-interrupt", 0);
161 irq_pmu_out.init_named(m_dev, "pmu-interrupt", 0);
162 }
163
164 void initiator_customize_tlm_payload(TlmPayload& payload) override
165 {
166 uint64_t addr;
167 qemu::CpuAarch64 arm_cpu(m_cpu);
168
169 QemuCpu::initiator_customize_tlm_payload(payload);
170
171 addr = payload.get_address();
172
173 if (!arm_cpu.is_in_exclusive_context()) {
174 return;
175 }
176
177 if (addr != arm_cpu.get_exclusive_addr()) {
178 return;
179 }
180
181 add_exclusive_ext(payload);
182 }
183
184 void initiator_tidy_tlm_payload(TlmPayload& payload) override
185 {
186 using namespace tlm;
187
189 qemu::CpuAarch64 arm_cpu(m_cpu);
190
191 QemuCpu::initiator_tidy_tlm_payload(payload);
192
193 payload.get_extension(ext);
194 bool exit_tb = false;
195
196 if (ext == nullptr) {
197 return;
198 }
199
200 if (payload.get_command() == TLM_WRITE_COMMAND) {
201 auto sta = ext->get_exclusive_store_status();
202
203 if (sta == ExclusiveAccessTlmExtension::EXCLUSIVE_STORE_FAILURE) {
204 uint64_t exclusive_val = arm_cpu.get_exclusive_val();
205 uint64_t mem_val = extract_data_from_payload(payload);
206 uint64_t mask = (payload.get_data_length() == 8) ? -1 : (1 << (8 * payload.get_data_length())) - 1;
207
208 if ((exclusive_val & mask) == mem_val) {
209 arm_cpu.set_exclusive_val(~exclusive_val);
210 exit_tb = true;
211 }
212
213 payload.set_response_status(TLM_OK_RESPONSE);
214 }
215 }
216
217 payload.clear_extension(ext);
218 delete ext;
219
220 if (exit_tb) {
221 m_cpu.exit_loop_from_io();
222 }
223 }
224};
225
226extern "C" void module_register();
Exclusive load/store TLM extension.
Definition exclusive-access.h:36
A QEMU output GPIO exposed as a InitiatorSignalSocket<bool>.
Definition qemu-initiator-signal-socket.h:40
This class encapsulates a libqemu-cxx qemu::LibQemu instance. It handles QEMU parameters and instance...
Definition qemu-instance.h:89
A QEMU input GPIO exposed as a TargetSignalSocket<bool>.
Definition qemu-target-signal-socket.h:29
Definition aarch64.h:40