Debian Codegraph @

src/nouveau/mme/tests/mme_runner.h

raw
1 /*
2 * Copyright © 2022 Collabora Ltd.
3 * SPDX-License-Identifier: MIT
4 */
5 #include <gtest/gtest.h>
6 #include <vector>
7
8 #include "mme_builder.h"
9
10 struct nouveau_bo;
11 struct nouveau_ws_contxt;
12 struct nouveau_ws_device;
13
14 #include "nv_push.h"
15 #include "nv_push_cl9097.h"
16 #include "nv_push_clc7c0.h"
17
18 #define DATA_BO_SIZE 4096
19 #define DATA_DWORDS 1024
20
21 class mme_runner {
22 public:
23 mme_runner();
24 virtual ~mme_runner();
25
26 virtual void run_macro(const std::vector<uint32_t>& macro,
27 const std::vector<uint32_t>& params) = 0;
28
29 void mme_store_data(mme_builder *b, uint32_t dw_idx,
30 mme_value data, bool free_reg = false);
31
32 const nv_device_info *devinfo;
33 uint64_t data_addr;
34 uint32_t *data;
35 };
36
37 class mme_hw_runner : public mme_runner {
38 public:
39 mme_hw_runner();
40 virtual ~mme_hw_runner();
41
42 bool set_up_hw(uint16_t min_cls, uint16_t max_cls);
43 void push_macro(uint32_t id, const std::vector<uint32_t>& macro);
44 void reset_push();
45 void submit_push();
46
47 virtual void run_macro(const std::vector<uint32_t>& macro,
48 const std::vector<uint32_t>& params);
49
50 struct nv_push *p;
51
52 private:
53 struct nouveau_ws_device *dev;
54 struct nouveau_ws_context *ctx;
55 struct nouveau_ws_bo *data_bo;
56 struct nouveau_ws_bo *push_bo;
57 uint32_t syncobj;
58 void *push_map;
59 struct nv_push push;
60 };
61
62 class mme_fermi_sim_runner : public mme_runner {
63 public:
64 mme_fermi_sim_runner(uint64_t data_addr);
65 virtual ~mme_fermi_sim_runner();
66
67 virtual void run_macro(const std::vector<uint32_t>& macro,
68 const std::vector<uint32_t>& params);
69
70 private:
71 struct nv_device_info info;
72 uint32_t data_store[DATA_DWORDS];
73 };
74
75 class mme_tu104_sim_runner : public mme_runner {
76 public:
77 mme_tu104_sim_runner(uint64_t data_addr);
78 virtual ~mme_tu104_sim_runner();
79
80 virtual void run_macro(const std::vector<uint32_t>& macro,
81 const std::vector<uint32_t>& params);
82
83 private:
84 struct nv_device_info info;
85 uint32_t data_store[DATA_DWORDS];
86 };
87
88 inline std::vector<uint32_t>
89 mme_builder_finish_vec(mme_builder *b)
90 {
91 size_t size = 0;
92 uint32_t *dw = mme_builder_finish(b, &size);
93 std::vector<uint32_t> vec(dw, dw + (size / 4));
94 free(dw);
95 return vec;
96 }
97
98 inline uint32_t
99 high32(uint64_t x)
100 {
101 return (uint32_t)(x >> 32);
102 }
103
104 inline uint32_t
105 low32(uint64_t x)
106 {
107 return (uint32_t)x;
108 }
109
110 inline void
111 mme_store_imm_addr(mme_builder *b, uint64_t addr, mme_value v,
112 bool free_reg = false)
113 {
114 mme_mthd(b, NV9097_SET_REPORT_SEMAPHORE_A);
115 mme_emit(b, mme_imm(high32(addr)));
116 mme_emit(b, mme_imm(low32(addr)));
117 mme_emit(b, v);
118 mme_emit(b, mme_imm(0x10000000));
119
120 if (free_reg && v.type == MME_VALUE_TYPE_REG)
121 mme_free_reg(b, v);
122 }
123
124 inline void
125 mme_store(mme_builder *b, struct mme_value64 addr, mme_value v,
126 bool free_reg = false)
127 {
128 mme_mthd(b, NV9097_SET_REPORT_SEMAPHORE_A);
129 mme_emit(b, addr.hi);
130 mme_emit(b, addr.lo);
131 mme_emit(b, v);
132 mme_emit(b, mme_imm(0x10000000));
133
134 if (free_reg && v.type == MME_VALUE_TYPE_REG)
135 mme_free_reg(b, v);
136 }
137
138 inline void
139 mme_store_compute_imm_addr(mme_builder *b, uint64_t addr, mme_value v,
140 bool free_reg = false)
141 {
142 mme_mthd(b, NVC7C0_SET_REPORT_SEMAPHORE_PAYLOAD_LOWER);
143 mme_emit(b, v);
144 mme_emit(b, mme_imm(0));
145 mme_emit(b, mme_imm(low32(addr)));
146 mme_emit(b, mme_imm(high32(addr)));
147 mme_emit(b, mme_imm(0x8));
148
149 if (free_reg && v.type == MME_VALUE_TYPE_REG)
150 mme_free_reg(b, v);
151 }
152
153 inline void
154 mme_store_compute(mme_builder *b, struct mme_value64 addr, mme_value v,
155 bool free_reg = false)
156 {
157 mme_mthd(b, NVC7C0_SET_REPORT_SEMAPHORE_PAYLOAD_LOWER);
158 mme_emit(b, v);
159 mme_emit(b, mme_imm(0));
160 mme_emit(b, addr.lo);
161 mme_emit(b, addr.hi);
162 mme_emit(b, mme_imm(0x8));
163
164 if (free_reg && v.type == MME_VALUE_TYPE_REG)
165 mme_free_reg(b, v);
166 }