Line data Source code
1 : /**
2 : * Copyright (c) 2025 Huawei Technologies Co., Ltd.
3 : * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4 : * CANN Open Software License Agreement Version 2.0 (the "License").
5 : * Please refer to the License for details. You may not use this file except in compliance with the License.
6 : * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7 : * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8 : * See LICENSE in the root of the software repository for the full text of the License.
9 : */
10 :
11 : #include <unistd.h>
12 : #include <stdlib.h>
13 : #include <sys/types.h>
14 : #include <netinet/in.h>
15 : #include <arpa/inet.h>
16 : #include <dlfcn.h>
17 : #include <urma_opcode.h>
18 : #include <udma_u_ctl.h>
19 : #include "user_log.h"
20 : #include "dl_urma_function.h"
21 : #include "dl_net_function.h"
22 : #include "ra_rs_err.h"
23 : #include "rs_inner.h"
24 : #include "rs_ctx_inner.h"
25 : #include "rs_ub.h"
26 : #include "rs_ub_jetty.h"
27 :
28 0 : STATIC int RsResAddrMunmap(struct RsCtxJettyCb *jettyCb, struct UdmaVaInfo *vaInfo)
29 : {
30 0 : struct res_map_info_in resInfoIn = {0};
31 0 : int ret = 0;
32 :
33 0 : resInfoIn.res_id = RsGenerateMmapResId(jettyCb->jetty->jetty_id.id, jettyCb->devCb->devAttr.ub.dieId,
34 0 : jettyCb->devCb->devAttr.ub.funcId);
35 0 : resInfoIn.target_proc_type = PROCESS_CP1;
36 0 : resInfoIn.res_type = vaInfo->resType;
37 0 : resInfoIn.priv_len = sizeof(struct UdmaVaInfo);
38 0 : resInfoIn.priv = (void *)vaInfo;
39 0 : ret = DlHalResAddrUnmapV2(jettyCb->devCb->rscb->logicId, &resInfoIn);
40 0 : CHK_PRT_RETURN(ret != 0, hccp_err("DlHalResAddrUnmapV2 failed, res_type:%d ret:%d, errno:%d",
41 : resInfoIn.res_type, ret, errno), ret);
42 :
43 0 : return ret;
44 : }
45 :
46 0 : STATIC int RsResAddrMmap(struct RsCtxJettyCb *jettyCb, struct UdmaVaInfo *vaInfo,
47 : struct res_map_info_out *resInfoOut)
48 : {
49 0 : struct res_map_info_in resInfoIn = {0};
50 0 : int ret = 0;
51 :
52 0 : resInfoIn.res_id = RsGenerateMmapResId(jettyCb->jetty->jetty_id.id, jettyCb->devCb->devAttr.ub.dieId,
53 0 : jettyCb->devCb->devAttr.ub.funcId);
54 0 : resInfoIn.target_proc_type = PROCESS_CP1;
55 0 : resInfoIn.res_type = vaInfo->resType;
56 0 : resInfoIn.priv_len = sizeof(struct UdmaVaInfo);
57 0 : resInfoIn.priv = (void *)vaInfo;
58 0 : ret = DlHalResAddrMapV2(jettyCb->devCb->rscb->logicId, &resInfoIn, resInfoOut);
59 0 : CHK_PRT_RETURN(ret != 0, hccp_err("DlHalResAddrMapV2 failed, res_type:%d ret:%d, errno:%d",
60 : resInfoIn.res_type, ret, errno), ret);
61 :
62 0 : return ret;
63 : }
64 :
65 3 : STATIC void RsMunmapJettyVa(struct RsCtxJettyCb *jettyCb)
66 : {
67 3 : struct UdmaVaInfo vaInfo = {0};
68 :
69 3 : if ((jettyCb->jettyMode != JETTY_MODE_CACHE_LOCK_DWQE) && (jettyCb->jettyMode != JETTY_MODE_USER_CTL_NORMAL)) {
70 3 : return;
71 : }
72 :
73 0 : vaInfo.resType = RES_ADDR_TYPE_HCCP_URMA_JETTY;
74 0 : vaInfo.va = jettyCb->sqBuffVa;
75 0 : vaInfo.len = WQE_BB_SIZE * jettyCb->txDepth * WQEBB_NUM_PER_SQE;
76 0 : vaInfo.pid = getpid();
77 0 : (void)RsResAddrMunmap(jettyCb, &vaInfo);
78 :
79 0 : vaInfo.resType = RES_ADDR_TYPE_HCCP_URMA_DB;
80 0 : vaInfo.va = ALIGN_DOWN(jettyCb->dbAddr, RA_RS_4K_PAGE_SIZE);
81 0 : vaInfo.len = sizeof(uint64_t);
82 0 : vaInfo.pid = getpid();
83 0 : (void)RsResAddrMunmap(jettyCb, &vaInfo);
84 : }
85 :
86 0 : STATIC int RsMmapJettyVa(struct RsCtxJettyCb *jettyCb)
87 : {
88 0 : struct res_map_info_out jettyVaInfoOut = {0};
89 0 : struct res_map_info_out dbVaInfoOut = {0};
90 0 : struct UdmaVaInfo jettyVaInfo = {0};
91 0 : struct UdmaVaInfo dbVaInfo = {0};
92 0 : uint64_t dbOffset = 0;
93 0 : int ret = 0;
94 :
95 0 : jettyVaInfo.resType = RES_ADDR_TYPE_HCCP_URMA_JETTY;
96 0 : jettyVaInfo.va = jettyCb->sqBuffVa;
97 0 : jettyVaInfo.len = WQE_BB_SIZE * jettyCb->txDepth * WQEBB_NUM_PER_SQE;
98 0 : jettyVaInfo.pid = getpid();
99 0 : ret = RsResAddrMmap(jettyCb, &jettyVaInfo, &jettyVaInfoOut);
100 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_res_addr_mmap failed, res_type:%u ret:%d",
101 : jettyVaInfo.resType, ret), ret);
102 0 : jettyCb->sqBuffVa = jettyVaInfoOut.va;
103 :
104 0 : dbVaInfo.resType = RES_ADDR_TYPE_HCCP_URMA_DB;
105 0 : dbVaInfo.va = ALIGN_DOWN(jettyCb->dbAddr, RA_RS_4K_PAGE_SIZE);
106 0 : dbOffset = jettyCb->dbAddr - dbVaInfo.va;
107 0 : dbVaInfo.len = sizeof(uint64_t);
108 0 : dbVaInfo.pid = getpid();
109 0 : ret = RsResAddrMmap(jettyCb, &dbVaInfo, &dbVaInfoOut);
110 0 : if (ret != 0) {
111 0 : hccp_err("rs_res_addr_mmap failed, res_type:%u ret:%d", dbVaInfo.resType, ret);
112 0 : goto munmap_sq_buff_va;
113 : }
114 0 : jettyCb->dbAddr = dbVaInfoOut.va + dbOffset;
115 0 : return ret;
116 :
117 0 : munmap_sq_buff_va:
118 0 : jettyVaInfo.va = jettyVaInfoOut.va;
119 0 : ret += RsResAddrMunmap(jettyCb, &jettyVaInfo);
120 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_res_addr_munmap failed, res_type:%u ret:%d",
121 : jettyVaInfo.resType, ret), ret);
122 0 : return ret;
123 : }
124 :
125 1 : void RsUbCtxExtJettyDelete(struct RsCtxJettyCb *jettyCb)
126 : {
127 1 : int ret = 0;
128 :
129 1 : RsMunmapJettyVa(jettyCb);
130 1 : ret = RsUrmaDeactiveJetty(jettyCb->jetty);
131 1 : if (ret != 0) {
132 0 : hccp_err("rs_urma_deactive_jetty failed, ret:%d errno:%d", ret, errno);
133 : }
134 :
135 1 : ret = RsUrmaFreeJetty(jettyCb->jetty);
136 1 : if (ret != 0) {
137 0 : hccp_err("rs_urma_free_jetty failed, ret:%d errno:%d", ret, errno);
138 : }
139 :
140 1 : if (jettyCb->jettyMode == JETTY_MODE_CACHE_LOCK_DWQE) {
141 0 : ret = RsNetFreeJettyId(jettyCb->devCb->urmaDev->name, jettyCb->jettyMode, jettyCb->jettyId);
142 0 : if (ret != 0) {
143 0 : hccp_err("rs_net_free_jetty_id failed, jettyId:%u ret:%d", jettyCb->jettyId, ret);
144 : }
145 : }
146 :
147 1 : return;
148 : }
149 :
150 0 : STATIC int RsSetCcuJettyOpt(struct RsCtxJettyCb *jettyCb)
151 : {
152 0 : uint64_t ccuJettySqBuffVa = 0;
153 0 : int ret = 0;
154 :
155 0 : if (!RsIsCcuJetty(jettyCb->jettyMode)) {
156 0 : return ret;
157 : }
158 :
159 0 : if (jettyCb->jettyMode == JETTY_MODE_CCU) {
160 0 : ccuJettySqBuffVa = jettyCb->extMode.sq.buffVa;
161 0 : } else if (jettyCb->jettyMode == JETTY_MODE_CCU_TA_CACHE) {
162 0 : ccuJettySqBuffVa = (uint64_t)jettyCb->taCacheMode.sqeBufIdx;
163 : }
164 :
165 0 : ret = RsUrmaSetJettyOpt(jettyCb->jetty, URMA_JFS_SQE_BASE_ADDR, (void *)&ccuJettySqBuffVa, sizeof(uint64_t));
166 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_urma_set_jetty_opt URMA_JFS_SQE_BASE_ADDR failed, ret:%d, errno:%d",
167 : ret, errno), -EOPENSRC);
168 :
169 0 : return ret;
170 : }
171 :
172 0 : STATIC int RsSetJettyOpt(struct RsCtxJettyCb *jettyCb)
173 : {
174 0 : uint8_t dbCstm = jettyCb->extMode.cstmFlag.bs.dbCstm;
175 0 : uint16_t piType = jettyCb->extMode.piType;
176 0 : int ret = 0;
177 :
178 0 : hccp_dbg("sq.buff:0x%llx, sq.buffSize:%u, piType:%u, sqebbNum:%u, dbCstm:%u, txDepth:%u",
179 : jettyCb->extMode.sq.buffVa, jettyCb->extMode.sq.buffSize, piType, jettyCb->extMode.sqebbNum, dbCstm, jettyCb->txDepth);
180 :
181 0 : ret = RsUrmaSetJettyOpt(jettyCb->jetty, URMA_JFS_DB_STATUS, (void *)&dbCstm, sizeof(uint8_t));
182 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_urma_set_jetty_opt URMA_JFS_DB_STATUS failed, ret:%d, errno:%d",
183 : ret, errno), -EOPENSRC);
184 :
185 0 : ret = RsUrmaSetJettyOpt(jettyCb->jetty, URMA_JFS_PI_TYPE, (void *)&piType, sizeof(uint16_t));
186 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_urma_set_jetty_opt URMA_JFS_PI_TYPE failed, ret:%d, errno:%d",
187 : ret, errno), -EOPENSRC);
188 :
189 0 : ret = RsSetCcuJettyOpt(jettyCb);
190 0 : CHK_PRT_RETURN(ret != 0, hccp_err("RsSetCcuJettyOpt failed, ret:%d, mode:%d", ret, jettyCb->jettyMode), ret);
191 :
192 0 : return ret;
193 : }
194 :
195 0 : STATIC int RsGetJettyOpt(struct RsCtxJettyCb *jettyCb)
196 : {
197 0 : uint64_t sqBuffVa = 0, dbVa = 0;
198 0 : int ret = 0;
199 :
200 0 : ret = RsUrmaGetJettyOpt(jettyCb->jetty, URMA_JFS_SQE_BASE_ADDR, &sqBuffVa, sizeof(uint64_t));
201 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_urma_get_jetty_opt URMA_JFS_SQE_BASE_ADDR failed, ret:%d, errno:%d",
202 : ret, errno), -EOPENSRC);
203 :
204 0 : ret = RsUrmaGetJettyOpt(jettyCb->jetty, URMA_JFS_DB_ADDR, &dbVa, sizeof(uint64_t));
205 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_urma_get_jetty_opt URMA_JFS_DB_ADDR failed, ret:%d, errno:%d",
206 : ret, errno), -EOPENSRC);
207 :
208 0 : jettyCb->sqBuffVa = sqBuffVa;
209 0 : jettyCb->dbAddr = dbVa;
210 0 : if ((jettyCb->jettyMode == JETTY_MODE_CACHE_LOCK_DWQE) || (jettyCb->jettyMode == JETTY_MODE_USER_CTL_NORMAL)) {
211 0 : ret = RsMmapJettyVa(jettyCb);
212 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_mmap_jetty_va failed, ret:%d", ret), ret);
213 : }
214 :
215 0 : return ret;
216 : }
217 :
218 2 : STATIC int RsFreeJettyId(const char *udevName, unsigned int jettyMode, unsigned int jettyId)
219 : {
220 2 : int ret = 0;
221 :
222 2 : if (jettyMode != JETTY_MODE_CACHE_LOCK_DWQE) {
223 2 : return 0;
224 : }
225 :
226 : // only stars jetty need to free jetty id
227 0 : ret = RsNetFreeJettyId(udevName, jettyMode, jettyId);
228 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_net_free_jetty_id failed, jettyId:%u ret:%d", jettyId, ret), ret);
229 :
230 0 : return ret;
231 : }
232 :
233 0 : STATIC int RsJettyAttrInit(struct RsCtxJettyCb *jettyCb, urma_jetty_cfg_t *jettyCfg)
234 : {
235 0 : int ret = 0;
236 :
237 0 : CHK_PRT_RETURN(jettyCb->extMode.cstmFlag.bs.sqCstm == 1 && !RsIsCcuJetty(jettyCb->jettyMode),
238 : hccp_err("Non-CCU jetty cannot be created by specifying va, sqCstm:%u jettyMode:%u",
239 : jettyCb->extMode.cstmFlag.bs.sqCstm, jettyCb->jettyMode), -EINVAL);
240 :
241 0 : if (jettyCb->jettyMode == JETTY_MODE_CACHE_LOCK_DWQE) {
242 0 : ret = RsNetAllocJettyId(jettyCb->devCb->urmaDev->name, jettyCb->jettyMode, &jettyCfg->id);
243 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_net_alloc_jetty_id failed, ret:%d", ret), ret);
244 0 : jettyCb->jettyId = jettyCfg->id;
245 : }
246 :
247 0 : ret = RsUrmaAllocJetty(jettyCb->devCb->urmaCtx, jettyCfg, &jettyCb->jetty);
248 0 : if (ret != 0) {
249 0 : ret = -EOPENSRC;
250 0 : RsFreeJettyId(jettyCb->devCb->urmaDev->name, jettyCb->jettyMode, jettyCb->jettyId);
251 0 : hccp_err("urma_alloc_jetty failed, ret:%d, errno:%d", ret, errno);
252 : }
253 :
254 0 : return ret;
255 : }
256 :
257 0 : STATIC int RsCcuJettyDbReg(struct RsCtxJettyCb *jettyCb)
258 : {
259 0 : struct udma_u_jetty_info jettyInfo = {0};
260 0 : int ret = 0;
261 :
262 0 : if (!RsIsCcuJetty(jettyCb->jettyMode)) {
263 0 : return ret;
264 : }
265 :
266 : // only ccu jetty requires db registration
267 0 : jettyInfo.dwqe_addr = (void *)(ALIGN_DOWN(jettyCb->dbAddr, RA_RS_4K_PAGE_SIZE));
268 0 : ret = RsUbCtxRegJettyDb(jettyCb, &jettyInfo);
269 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_ub_ctx_reg_jetty_db failed, ret:%d", ret), ret);
270 :
271 0 : return ret;
272 : }
273 :
274 0 : void RsUbCtxExtJettyCreate(struct RsCtxJettyCb *jettyCb, urma_jetty_cfg_t *jettyCfg)
275 : {
276 0 : int ret = 0;
277 :
278 0 : ret = RsJettyAttrInit(jettyCb, jettyCfg);
279 0 : if (ret != 0) {
280 0 : jettyCb->jetty = NULL;
281 0 : return;
282 : }
283 :
284 0 : ret = RsSetJettyOpt(jettyCb);
285 0 : if (ret != 0) {
286 0 : hccp_err("rs_set_jetty_opt failed, ret:%d", ret);
287 0 : goto free_jetty;
288 : }
289 :
290 0 : ret = RsUrmaActiveJetty(jettyCb->jetty);
291 0 : if (ret != 0) {
292 0 : hccp_err("rs_urma_active_jetty failed, ret:%d, errno:%d", ret, errno);
293 0 : ret = -EOPENSRC;
294 0 : goto free_jetty;
295 : }
296 :
297 0 : ret = RsGetJettyOpt(jettyCb);
298 0 : if (ret != 0) {
299 0 : hccp_err("rs_get_jetty_opt failed, ret:%d", ret);
300 0 : goto deactive_jetty;
301 : }
302 :
303 0 : ret = RsCcuJettyDbReg(jettyCb);
304 0 : if (ret != 0) {
305 0 : goto deactive_jetty;
306 : }
307 0 : return;
308 :
309 0 : deactive_jetty:
310 0 : ret = RsUrmaDeactiveJetty(jettyCb->jetty);
311 0 : if (ret != 0) {
312 0 : hccp_err("rs_urma_deactive_jetty failed, ret:%d errno:%d", ret, errno);
313 : }
314 0 : free_jetty:
315 0 : ret = RsUrmaFreeJetty(jettyCb->jetty);
316 0 : if (ret != 0) {
317 0 : hccp_err("rs_urma_free_jetty failed, ret:%d errno:%d", ret, errno);
318 : }
319 :
320 0 : (void)RsFreeJettyId(jettyCb->devCb->urmaDev->name, jettyCb->jettyMode, jettyCb->jettyId);
321 0 : jettyCb->jetty = NULL;
322 : }
323 :
324 2 : void RsUbVaMunmapBatch(struct RsCtxJettyCb **jettyCbArr, unsigned int num)
325 : {
326 : unsigned int i;
327 :
328 4 : for (i = 0; i < num; ++i) {
329 2 : RsMunmapJettyVa(jettyCbArr[i]);
330 : }
331 2 : }
332 :
333 2 : void RsUbFreeJettyIdBatch(struct RsCtxJettyCb **jettyCbArr, unsigned int num)
334 : {
335 : unsigned int i;
336 :
337 4 : for (i = 0; i < num; ++i) {
338 2 : (void)RsFreeJettyId(jettyCbArr[i]->devCb->urmaDev->name, jettyCbArr[i]->jettyMode,
339 2 : jettyCbArr[i]->jettyId);
340 : }
341 2 : }
|
