| 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> ¯o) |
| 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, ¯o[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, ¶ms[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], ¯o[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() ? ¶ms[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], ¯o[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() ? ¶ms[0] : NULL; |
| 275 |
mme_tu104_sim(insts.size(), &insts[0], |
| 276 |
params.size(), p_params, |
| 277 |
1, &sim_mem); |
| 278 |
} |