Debian Codegraph @

src/nouveau/mme/tests/mme_runner.cpp

raw
1 /*
2 * Copyright © 2022 Collabora Ltd.
3 * SPDX-License-Identifier: MIT
4 */
5 #include "mme_runner.h"
6
7 #include <fcntl.h>
8 #include <string.h>
9 #include <xf86drm.h>
10
11 #include "mme_fermi_sim.h"
12 #include "mme_tu104_sim.h"
13
14 #include "nv_push_clc597.h"
15 #include "nv_push_cl90c0.h"
16
17 #include "nouveau_bo.h"
18 #include "nouveau_context.h"
19
20 /* nouveau_drm.h isn't C++-friendly */
21 #define class cls
22 #include "drm-uapi/nouveau_drm.h"
23 #undef class
24
25 mme_runner::mme_runner() :
26 devinfo(NULL), data_addr(0), data(NULL)
27 { }
28
29 mme_runner::~mme_runner()
30 { }
31
32 mme_hw_runner::mme_hw_runner() :
33 mme_runner(), p(NULL), dev(NULL), ctx(NULL),
34 data_bo(NULL), push_bo(NULL),
35 syncobj(0),
36 push_map(NULL)
37 {
38 memset(&push, 0, sizeof(push));
39 }
40
41 void
42 mme_runner::mme_store_data(mme_builder *b, uint32_t dw_idx,
43 mme_value data, bool free_reg)
44 {
45 mme_store_imm_addr(b, data_addr + dw_idx * 4, data, free_reg);
46 }
47
48 mme_hw_runner::~mme_hw_runner()
49 {
50 if (syncobj)
51 drmSyncobjDestroy(dev->fd, syncobj);
52 if (data_bo)
53 nouveau_ws_bo_destroy(data_bo);
54 if (push_bo) {
55 nouveau_ws_bo_unmap(push_bo, push_map);
56 nouveau_ws_bo_destroy(push_bo);
57 }
58 if (ctx)
59 nouveau_ws_context_destroy(ctx);
60 if (dev)
61 nouveau_ws_device_destroy(dev);
62 }
63
64 #define PUSH_SIZE 64 * 4096
65
66 #define DATA_BO_ADDR 0x100000
67 #define PUSH_BO_ADDR 0x200000
68
69 bool
70 mme_hw_runner::set_up_hw(uint16_t min_cls, uint16_t max_cls)
71 {
72 drmDevicePtr devices[8];
73 int max_devices = drmGetDevices2(0, devices, 8);
74
75 int i;
76 for (i = 0; i < max_devices; i++) {
77 if (devices[i]->available_nodes & 1 << DRM_NODE_RENDER &&
78 devices[i]->bustype == DRM_BUS_PCI &&
79 devices[i]->deviceinfo.pci->vendor_id == 0x10de) {
80 dev = nouveau_ws_device_new(devices[i]);
81 if (dev == NULL)
82 continue;
83
84 if (dev->info.cls_eng3d < min_cls || dev->info.cls_eng3d > max_cls) {
85 nouveau_ws_device_destroy(dev);
86 dev = NULL;
87 continue;
88 }
89
90 /* Found a Turning+ device */
91 break;
92 }
93 }
94
95 if (dev == NULL)
96 return false;
97
98 devinfo = &dev->info;
99
100 int ret = nouveau_ws_context_create(dev, NOUVEAU_WS_ENGINE_3D, &ctx);
101 if (ret)
102 return false;
103
104 uint32_t data_bo_flags = NOUVEAU_WS_BO_GART | NOUVEAU_WS_BO_MAP;
105 data_bo = nouveau_ws_bo_new_mapped(dev, DATA_BO_SIZE, 0,
106 (nouveau_ws_bo_flags)data_bo_flags,
107 NOUVEAU_WS_BO_RDWR, (void **)&data);
108 if (data_bo == NULL)
109 return false;
110
111 memset(data, 139, DATA_BO_SIZE);
112
113 assert(DATA_BO_ADDR + DATA_BO_SIZE < PUSH_BO_ADDR);
114 nouveau_ws_bo_bind_vma(dev, data_bo, DATA_BO_ADDR, DATA_BO_SIZE, 0, 0);
115 data_addr = DATA_BO_ADDR;
116
117 uint32_t push_bo_flags = NOUVEAU_WS_BO_GART | NOUVEAU_WS_BO_MAP;
118 push_bo = nouveau_ws_bo_new_mapped(dev, PUSH_SIZE, 0,
119 (nouveau_ws_bo_flags)push_bo_flags,
120 NOUVEAU_WS_BO_WR, &push_map);
121 if (push_bo == NULL)
122 return false;
123
124 nouveau_ws_bo_bind_vma(dev, push_bo, PUSH_BO_ADDR, PUSH_SIZE, 0, 0);
125
126 ret = drmSyncobjCreate(dev->fd, 0, &syncobj);
127 if (ret < 0)
128 return false;
129
130 reset_push();
131
132 return true;
133 }
134
135 void
136 mme_hw_runner::reset_push()
137 {
138 nv_push_init(&push, (uint32_t *)push_map, PUSH_SIZE / 4, SUBC_MASK_ALL);
139 p = &push;
140
141 P_MTHD(p, NV9097, SET_OBJECT);
142 P_NV9097_SET_OBJECT(p, {
143 .class_id = dev->info.cls_eng3d,
144 .engine_id = 0,
145 });
146
147 P_MTHD(p, NV90C0, SET_OBJECT);
148 P_NV90C0_SET_OBJECT(p, {
149 .class_id = dev->info.cls_compute,
150 .engine_id = 0,
151 });
152 }
153
154 void
155 mme_hw_runner::submit_push()
156 {
157 struct drm_nouveau_exec_push push = {
158 .va = PUSH_BO_ADDR,
159 .va_len = (uint32_t)nv_push_dw_count(&this->push) * 4,
160 };
161
162 struct drm_nouveau_sync sync = {
163 .flags = DRM_NOUVEAU_SYNC_SYNCOBJ,
164 .handle = syncobj,
165 .timeline_value = 0,
166 };
167
168 struct drm_nouveau_exec req = {
169 .channel = (uint32_t)ctx->channel,
170 .push_count = 1,
171 .sig_count = 1,
172 .sig_ptr = (uintptr_t)&sync,
173 .push_ptr = (uintptr_t)&push,
174 };
175
176 int ret = drmCommandWriteRead(dev->fd, DRM_NOUVEAU_EXEC,
177 &req, sizeof(req));
178 ASSERT_EQ(ret, 0);
179
180 ret = drmSyncobjWait(dev->fd, &syncobj, 1, INT64_MAX,
181 DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT, NULL);
182 ASSERT_EQ(ret, 0);
183 }
184
185 void
186 mme_hw_runner::push_macro(uint32_t id, const std::vector<uint32_t> &macro)
187 {
188 P_MTHD(p, NV9097, LOAD_MME_START_ADDRESS_RAM_POINTER);
189 P_NV9097_LOAD_MME_START_ADDRESS_RAM_POINTER(p, id);
190 P_NV9097_LOAD_MME_START_ADDRESS_RAM(p, 0);
191 P_1INC(p, NV9097, LOAD_MME_INSTRUCTION_RAM_POINTER);
192 P_NV9097_LOAD_MME_INSTRUCTION_RAM_POINTER(p, 0);
193 P_INLINE_ARRAY(p, &macro[0], macro.size());
194 }
195
196 void
197 mme_hw_runner::run_macro(const std::vector<uint32_t>& macro,
198 const std::vector<uint32_t>& params)
199 {
200 push_macro(0, macro);
201
202 P_1INC(p, NV9097, CALL_MME_MACRO(0));
203 if (params.empty()) {
204 P_NV9097_CALL_MME_MACRO(p, 0, 0);
205 } else {
206 P_INLINE_ARRAY(p, &params[0], params.size());
207 }
208
209 submit_push();
210 }
211
212 mme_fermi_sim_runner::mme_fermi_sim_runner(uint64_t data_addr)
213 {
214 memset(&info, 0, sizeof(info));
215 info.cls_eng3d = FERMI_A;
216
217 memset(data_store, 0, sizeof(data_store));
218
219 this->devinfo = &info;
220 this->data_addr = data_addr,
221 this->data = data_store;
222 }
223
224 mme_fermi_sim_runner::~mme_fermi_sim_runner()
225 { }
226
227 void
228 mme_fermi_sim_runner::run_macro(const std::vector<uint32_t>& macro,
229 const std::vector<uint32_t>& params)
230 {
231 std::vector<mme_fermi_inst> insts(macro.size());
232 mme_fermi_decode(&insts[0], &macro[0], macro.size());
233
234 /* First, make a copy of the data and simulate the macro */
235 mme_fermi_sim_mem sim_mem = {
236 .addr = data_addr,
237 .data = data,
238 .size = DATA_BO_SIZE,
239 };
240 const uint32_t* p_params = params.size() ? &params[0] : NULL;
241 mme_fermi_sim(insts.size(), &insts[0],
242 params.size(), p_params,
243 1, &sim_mem);
244 }
245
246 mme_tu104_sim_runner::mme_tu104_sim_runner(uint64_t data_addr)
247 {
248 memset(&info, 0, sizeof(info));
249 info.cls_eng3d = TURING_A;
250
251 memset(data_store, 0, sizeof(data_store));
252
253 this->devinfo = &info;
254 this->data_addr = data_addr,
255 this->data = data_store;
256 }
257
258 mme_tu104_sim_runner::~mme_tu104_sim_runner()
259 { }
260
261 void
262 mme_tu104_sim_runner::run_macro(const std::vector<uint32_t>& macro,
263 const std::vector<uint32_t>& params)
264 {
265 std::vector<mme_tu104_inst> insts(macro.size());
266 mme_tu104_decode(&insts[0], &macro[0], macro.size() / 3);
267
268 /* First, make a copy of the data and simulate the macro */
269 mme_tu104_sim_mem sim_mem = {
270 .addr = data_addr,
271 .data = data,
272 .size = DATA_BO_SIZE,
273 };
274 const uint32_t* p_params = params.size() ? &params[0] : NULL;
275 mme_tu104_sim(insts.size(), &insts[0],
276 params.size(), p_params,
277 1, &sim_mem);
278 }