qualcomm/qbox
Loading...
Searching...
No Matches
target.h
1/*
2 * This file is part of libqbox
3 * Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. All Rights Reserved.
4 * Author: GreenSocs 2021
5 *
6 * SPDX-License-Identifier: BSD-3-Clause
7 */
8
9#ifndef _LIBQBOX_PORTS_TARGET_H
10#define _LIBQBOX_PORTS_TARGET_H
11
12#include <tlm>
13
14#include "qemu-instance.h"
15#include "tlm-extensions/qemu-cpu-hint.h"
16#include "tlm-extensions/qemu-mr-hint.h"
17#include "tlm-extensions/qemu-memtx-attrs.h"
18#include <tlm_sockets_buswidth.h>
19
20class TlmTargetToQemuBridge : public tlm::tlm_fw_transport_if<>
21{
22public:
23 using MemTxAttrs = qemu::MemoryRegion::MemTxAttrs;
24 using MemTxResult = qemu::MemoryRegion::MemTxResult;
25 using TlmPayload = tlm::tlm_generic_payload;
26
27protected:
29 std::shared_ptr<qemu::AddressSpace> m_as;
30 QemuInstance* m_inst = nullptr;
31
32 void init_as()
33 {
34 m_as = m_mr.get_inst().address_space_new();
35 m_as->init(m_mr, "qemu-target-socket");
36 }
37
38 qemu::Cpu push_current_cpu(TlmPayload& trans)
39 {
40 qemu::Cpu ret;
41 QemuCpuHintTlmExtension* ext = nullptr;
42
43 trans.get_extension(ext);
44
45 if (ext == nullptr) {
46 /* return an invalid object */
47 return ret;
48 }
49
50 qemu::Cpu initiator(ext->get_cpu());
51
52 if (initiator.get_inst_id() != m_mr.get_inst_id()) {
53 /* return an invalid object */
54 return ret;
55 }
56
57 ret = initiator.set_as_current();
58
59 return ret;
60 }
61
62 void pop_current_cpu(qemu::Cpu cpu)
63 {
64 if (!cpu.valid()) {
65 return;
66 }
67
68 cpu.set_as_current();
69 }
70
71public:
72 void init(qemu::SysBusDevice sbd, int mmio_idx, QemuInstance& inst)
73 {
74 m_inst = &inst;
75 m_mr = sbd.mmio_get_region(mmio_idx);
76 init_as();
77 }
78
79 void init_with_mr(qemu::MemoryRegion mr, QemuInstance& inst)
80 {
81 m_inst = &inst;
82 m_mr = mr;
83 init_as();
84 }
85
86 virtual void b_transport(TlmPayload& trans, sc_core::sc_time& t)
87 {
88 uint64_t addr = trans.get_address();
89 uint64_t* data = reinterpret_cast<uint64_t*>(trans.get_data_ptr());
90 unsigned int size = trans.get_data_length();
91 MemTxAttrs attrs;
92 MemTxResult res;
93 qemu::Cpu current_cpu_save;
94
95 if (trans.get_command() == tlm::TLM_IGNORE_COMMAND) {
96 trans.set_response_status(tlm::TLM_OK_RESPONSE);
97 return;
98 }
99
100 if (const auto* ext = trans.get_extension<gs::QemuMemTxSecureTlmExtension>()) attrs.secure = ext->value;
101 if (const auto* ext = trans.get_extension<gs::QemuMemTxSpaceTlmExtension>()) {
102 attrs.space = static_cast<uint8_t>(ext->value);
103 }
104 if (const auto* ext = trans.get_extension<gs::QemuMemTxUserTlmExtension>()) attrs.user = ext->value;
105 if (const auto* ext = trans.get_extension<gs::QemuMemTxMemoryTlmExtension>()) attrs.memory = ext->value;
106 if (const auto* ext = trans.get_extension<gs::QemuMemTxDebugTlmExtension>()) attrs.debug = ext->value;
107 if (const auto* ext = trans.get_extension<gs::QemuMemTxRequesterIdTlmExtension>()) {
108 attrs.requester_id = ext->value;
109 }
110 if (const auto* ext = trans.get_extension<gs::QemuMemTxPidTlmExtension>()) attrs.pid = ext->value;
111 if (const auto* ext = trans.get_extension<gs::QemuMemTxAddressTypeTlmExtension>()) {
112 attrs.address_type = ext->value;
113 }
114 if (const auto* ext = trans.get_extension<gs::QemuMemTxUnspecifiedTlmExtension>()) {
115 attrs.unspecified = ext->value;
116 }
117
118 current_cpu_save = push_current_cpu(trans);
119
120 /*
121 * QEMU device state (ptimer transactions, virtual clock, etc.) is BQL-protected.
122 * SystemC threads reaching this path do not implicitly hold the BQL, so acquire
123 * it for the duration of the QEMU dispatch. The BQL is recursive, so this is
124 * safe even when the caller (e.g. QemuInitiatorSocket reentrancy>1 path) already
125 * holds it.
126 */
127 m_inst->get().lock_iothread();
128
129 switch (trans.get_command()) {
130 case tlm::TLM_READ_COMMAND:
131 res = m_as->read(addr, data, size, attrs);
132 break;
133
134 case tlm::TLM_WRITE_COMMAND:
135 res = m_as->write(addr, data, size, attrs);
136 break;
137
138 default:
139 /* TLM_IGNORE_COMMAND already handled above */
140 m_inst->get().unlock_iothread();
141 assert(false);
142 return;
143 }
144
145 m_inst->get().unlock_iothread();
146
147 trans.set_extension(new QemuMrHintTlmExtension(m_mr, addr));
148
149 switch (res) {
150 case qemu::MemoryRegionOps::MemTxOK:
151 trans.set_response_status(tlm::TLM_OK_RESPONSE);
152 break;
153
154 case qemu::MemoryRegionOps::MemTxDecodeError:
155 trans.set_response_status(tlm::TLM_ADDRESS_ERROR_RESPONSE);
156 break;
157
158 case qemu::MemoryRegionOps::MemTxError:
159 trans.set_response_status(tlm::TLM_GENERIC_ERROR_RESPONSE);
160 break;
161
162 default:
163 trans.set_response_status(tlm::TLM_COMMAND_ERROR_RESPONSE);
164 break;
165 }
166
167 pop_current_cpu(current_cpu_save);
168 }
169
170 virtual tlm::tlm_sync_enum nb_transport_fw(TlmPayload& trans, tlm::tlm_phase& phase, sc_core::sc_time& t)
171 {
172 /* TODO: report an error */
173 abort();
174 return tlm::TLM_ACCEPTED;
175 }
176
177 virtual bool get_direct_mem_ptr(TlmPayload& trans, tlm::tlm_dmi& dmi_data) { return false; }
178
179 virtual unsigned int transport_dbg(TlmPayload& trans)
180 {
181 unsigned int size = trans.get_data_length();
182 sc_core::sc_time delay = sc_core::SC_ZERO_TIME;
183 b_transport(trans, delay);
184 if (trans.get_response_status() == tlm::TLM_OK_RESPONSE)
185 return size;
186 else
187 return 0;
188 }
189};
190
191template <unsigned int BUSWIDTH = DEFAULT_TLM_BUSWIDTH>
192class QemuTargetSocket
193 : public tlm::tlm_target_socket<BUSWIDTH, tlm::tlm_base_protocol_types, 1, sc_core::SC_ZERO_OR_MORE_BOUND>
194{
195public:
196 using TlmTargetSocket = tlm::tlm_target_socket<BUSWIDTH, tlm::tlm_base_protocol_types, 1,
197 sc_core::SC_ZERO_OR_MORE_BOUND>;
198 using TlmPayload = tlm::tlm_generic_payload;
199
200protected:
201 TlmTargetToQemuBridge m_bridge;
202 QemuInstance& m_inst;
203 qemu::SysBusDevice m_sbd;
204
205public:
206 QemuTargetSocket(const char* name, QemuInstance& inst): TlmTargetSocket(name), m_inst(inst)
207 {
208 TlmTargetSocket::bind(m_bridge);
209 }
210
211 void init(qemu::SysBusDevice sbd, int mmio_idx) { m_bridge.init(sbd, mmio_idx, m_inst); }
212
213 void init_with_mr(qemu::MemoryRegion mr) { m_bridge.init_with_mr(mr, m_inst); }
214};
215
216#endif
Definition qemu-cpu-hint.h:17
This class encapsulates a libqemu-cxx qemu::LibQemu instance. It handles QEMU parameters and instance...
Definition qemu-instance.h:89
void init()
Initialize the QEMU instance.
Definition qemu-instance.h:468
Definition qemu-mr-hint.h:17
Definition target.h:21
Definition libqemu-cxx.h:725
Definition libqemu-cxx.h:396
Definition libqemu-cxx.h:699