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,
41 : hccp_err("DlHalResAddrUnmapV2 failed, res_type:%d ret:%d, errno:%d", resInfoIn.res_type, ret, errno), ret);
42 :
43 0 : return ret;
44 : }
45 :
46 0 : STATIC int RsResAddrMmap(struct RsCtxJettyCb *jettyCb, struct UdmaVaInfo *vaInfo, struct res_map_info_out *resInfoOut)
47 : {
48 0 : struct res_map_info_in resInfoIn = {0};
49 0 : int ret = 0;
50 :
51 0 : resInfoIn.res_id = RsGenerateMmapResId(jettyCb->jetty->jetty_id.id, jettyCb->devCb->devAttr.ub.dieId,
52 0 : jettyCb->devCb->devAttr.ub.funcId);
53 0 : resInfoIn.target_proc_type = PROCESS_CP1;
54 0 : resInfoIn.res_type = vaInfo->resType;
55 0 : resInfoIn.priv_len = sizeof(struct UdmaVaInfo);
56 0 : resInfoIn.priv = (void *)vaInfo;
57 0 : ret = DlHalResAddrMapV2(jettyCb->devCb->rscb->logicId, &resInfoIn, resInfoOut);
58 0 : CHK_PRT_RETURN(ret != 0,
59 : hccp_err("DlHalResAddrMapV2 failed, res_type:%d ret:%d, errno:%d", resInfoIn.res_type, ret, errno), ret);
60 :
61 0 : return ret;
62 : }
63 :
64 3 : STATIC void RsMunmapJettyVa(struct RsCtxJettyCb *jettyCb)
65 : {
66 3 : struct UdmaVaInfo vaInfo = {0};
67 :
68 3 : if ((jettyCb->jettyMode != JETTY_MODE_CACHE_LOCK_DWQE) && (jettyCb->jettyMode != JETTY_MODE_USER_CTL_NORMAL)) {
69 3 : return;
70 : }
71 :
72 0 : vaInfo.resType = RES_ADDR_TYPE_HCCP_URMA_JETTY;
73 0 : vaInfo.va = jettyCb->sqBuffVa;
74 0 : vaInfo.len = WQE_BB_SIZE * jettyCb->txDepth * WQEBB_NUM_PER_SQE;
75 0 : vaInfo.pid = getpid();
76 0 : (void)RsResAddrMunmap(jettyCb, &vaInfo);
77 :
78 0 : vaInfo.resType = RES_ADDR_TYPE_HCCP_URMA_DB;
79 0 : vaInfo.va = ALIGN_DOWN(jettyCb->dbAddr, RA_RS_4K_PAGE_SIZE);
80 0 : vaInfo.len = sizeof(uint64_t);
81 0 : vaInfo.pid = getpid();
82 0 : (void)RsResAddrMunmap(jettyCb, &vaInfo);
83 : }
84 :
85 0 : STATIC int RsMmapJettyVa(struct RsCtxJettyCb *jettyCb)
86 : {
87 0 : struct res_map_info_out jettyVaInfoOut = {0};
88 0 : struct res_map_info_out dbVaInfoOut = {0};
89 0 : struct UdmaVaInfo jettyVaInfo = {0};
90 0 : struct UdmaVaInfo dbVaInfo = {0};
91 0 : uint64_t dbOffset = 0;
92 0 : int ret = 0;
93 :
94 0 : jettyVaInfo.resType = RES_ADDR_TYPE_HCCP_URMA_JETTY;
95 0 : jettyVaInfo.va = jettyCb->sqBuffVa;
96 0 : jettyVaInfo.len = WQE_BB_SIZE * jettyCb->txDepth * WQEBB_NUM_PER_SQE;
97 0 : jettyVaInfo.pid = getpid();
98 0 : ret = RsResAddrMmap(jettyCb, &jettyVaInfo, &jettyVaInfoOut);
99 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_res_addr_mmap failed, res_type:%u ret:%d", jettyVaInfo.resType, ret), ret);
100 0 : jettyCb->sqBuffVa = jettyVaInfoOut.va;
101 :
102 0 : dbVaInfo.resType = RES_ADDR_TYPE_HCCP_URMA_DB;
103 0 : dbVaInfo.va = ALIGN_DOWN(jettyCb->dbAddr, RA_RS_4K_PAGE_SIZE);
104 0 : dbOffset = jettyCb->dbAddr - dbVaInfo.va;
105 0 : dbVaInfo.len = sizeof(uint64_t);
106 0 : dbVaInfo.pid = getpid();
107 0 : ret = RsResAddrMmap(jettyCb, &dbVaInfo, &dbVaInfoOut);
108 0 : if (ret != 0) {
109 0 : hccp_err("rs_res_addr_mmap failed, res_type:%u ret:%d", dbVaInfo.resType, ret);
110 0 : goto munmap_sq_buff_va;
111 : }
112 0 : jettyCb->dbAddr = dbVaInfoOut.va + dbOffset;
113 0 : return ret;
114 :
115 0 : munmap_sq_buff_va:
116 0 : jettyVaInfo.va = jettyVaInfoOut.va;
117 0 : ret += RsResAddrMunmap(jettyCb, &jettyVaInfo);
118 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_res_addr_munmap failed, res_type:%u ret:%d", jettyVaInfo.resType, ret), ret);
119 0 : return ret;
120 : }
121 :
122 1 : void RsUbCtxExtJettyDelete(struct RsCtxJettyCb *jettyCb)
123 : {
124 1 : int ret = 0;
125 :
126 1 : RsMunmapJettyVa(jettyCb);
127 1 : ret = RsUrmaDeactiveJetty(jettyCb->jetty);
128 1 : if (ret != 0) {
129 0 : hccp_err("rs_urma_deactive_jetty failed, ret:%d errno:%d", ret, errno);
130 : }
131 :
132 1 : ret = RsUrmaFreeJetty(jettyCb->jetty);
133 1 : if (ret != 0) {
134 0 : hccp_err("rs_urma_free_jetty failed, ret:%d errno:%d", ret, errno);
135 : }
136 :
137 1 : if (jettyCb->jettyMode == JETTY_MODE_CACHE_LOCK_DWQE) {
138 0 : ret = RsNetFreeJettyId(jettyCb->devCb->urmaDev->name, jettyCb->jettyMode, jettyCb->jettyId);
139 0 : if (ret != 0) {
140 0 : hccp_err("rs_net_free_jetty_id failed, jettyId:%u ret:%d", jettyCb->jettyId, ret);
141 : }
142 : }
143 :
144 1 : return;
145 : }
146 :
147 0 : STATIC int RsSetCcuJettyOpt(struct RsCtxJettyCb *jettyCb)
148 : {
149 0 : uint64_t ccuJettySqBuffVa = 0;
150 0 : int ret = 0;
151 :
152 0 : if (!RsIsCcuJetty(jettyCb->jettyMode)) {
153 0 : return ret;
154 : }
155 :
156 0 : if (jettyCb->jettyMode == JETTY_MODE_CCU) {
157 0 : ccuJettySqBuffVa = jettyCb->extMode.sq.buffVa;
158 0 : } else if (jettyCb->jettyMode == JETTY_MODE_CCU_TA_CACHE) {
159 0 : ccuJettySqBuffVa = (uint64_t)jettyCb->taCacheMode.sqeBufIdx;
160 : }
161 :
162 0 : ret = RsUrmaSetJettyOpt(jettyCb->jetty, URMA_JFS_SQE_BASE_ADDR, (void *)&ccuJettySqBuffVa, sizeof(uint64_t));
163 0 : CHK_PRT_RETURN(ret != 0,
164 : hccp_err("rs_urma_set_jetty_opt URMA_JFS_SQE_BASE_ADDR failed, ret:%d, errno:%d", ret, errno), -EOPENSRC);
165 :
166 0 : return ret;
167 : }
168 :
169 0 : STATIC int RsSetJettyOpt(struct RsCtxJettyCb *jettyCb)
170 : {
171 0 : uint8_t dbCstm = jettyCb->extMode.cstmFlag.bs.dbCstm;
172 0 : uint16_t piType = jettyCb->extMode.piType;
173 0 : int ret = 0;
174 :
175 0 : hccp_dbg("sq.buff:0x%llx, sq.buffSize:%u, piType:%u, sqebbNum:%u, dbCstm:%u, txDepth:%u",
176 : jettyCb->extMode.sq.buffVa, jettyCb->extMode.sq.buffSize, piType, jettyCb->extMode.sqebbNum, dbCstm,
177 : jettyCb->txDepth);
178 :
179 0 : ret = RsUrmaSetJettyOpt(jettyCb->jetty, URMA_JFS_DB_STATUS, (void *)&dbCstm, sizeof(uint8_t));
180 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_urma_set_jetty_opt URMA_JFS_DB_STATUS failed, ret:%d, errno:%d", ret, errno),
181 : -EOPENSRC);
182 :
183 0 : ret = RsUrmaSetJettyOpt(jettyCb->jetty, URMA_JFS_PI_TYPE, (void *)&piType, sizeof(uint16_t));
184 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_urma_set_jetty_opt URMA_JFS_PI_TYPE failed, ret:%d, errno:%d", ret, errno),
185 : -EOPENSRC);
186 :
187 0 : ret = RsSetCcuJettyOpt(jettyCb);
188 0 : CHK_PRT_RETURN(ret != 0, hccp_err("RsSetCcuJettyOpt failed, ret:%d, mode:%d", ret, jettyCb->jettyMode), ret);
189 :
190 0 : return ret;
191 : }
192 :
193 0 : STATIC int RsGetJettyOpt(struct RsCtxJettyCb *jettyCb)
194 : {
195 0 : uint64_t sqBuffVa = 0, dbVa = 0;
196 0 : int ret = 0;
197 :
198 0 : ret = RsUrmaGetJettyOpt(jettyCb->jetty, URMA_JFS_SQE_BASE_ADDR, &sqBuffVa, sizeof(uint64_t));
199 0 : CHK_PRT_RETURN(ret != 0,
200 : hccp_err("rs_urma_get_jetty_opt URMA_JFS_SQE_BASE_ADDR failed, ret:%d, errno:%d", ret, errno), -EOPENSRC);
201 :
202 0 : ret = RsUrmaGetJettyOpt(jettyCb->jetty, URMA_JFS_DB_ADDR, &dbVa, sizeof(uint64_t));
203 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_urma_get_jetty_opt URMA_JFS_DB_ADDR failed, ret:%d, errno:%d", ret, errno),
204 : -EOPENSRC);
205 :
206 0 : jettyCb->sqBuffVa = sqBuffVa;
207 0 : jettyCb->dbAddr = dbVa;
208 0 : if ((jettyCb->jettyMode == JETTY_MODE_CACHE_LOCK_DWQE) || (jettyCb->jettyMode == JETTY_MODE_USER_CTL_NORMAL)) {
209 0 : ret = RsMmapJettyVa(jettyCb);
210 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_mmap_jetty_va failed, ret:%d", ret), ret);
211 : }
212 :
213 0 : return ret;
214 : }
215 :
216 2 : STATIC int RsFreeJettyId(const char *udevName, unsigned int jettyMode, unsigned int jettyId)
217 : {
218 2 : int ret = 0;
219 :
220 2 : if (jettyMode != JETTY_MODE_CACHE_LOCK_DWQE) {
221 2 : return 0;
222 : }
223 :
224 : // only stars jetty need to free jetty id
225 0 : ret = RsNetFreeJettyId(udevName, jettyMode, jettyId);
226 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_net_free_jetty_id failed, jettyId:%u ret:%d", jettyId, ret), ret);
227 :
228 0 : return ret;
229 : }
230 :
231 0 : STATIC int RsJettyAttrInit(struct RsCtxJettyCb *jettyCb, urma_jetty_cfg_t *jettyCfg)
232 : {
233 0 : int ret = 0;
234 :
235 0 : CHK_PRT_RETURN(jettyCb->extMode.cstmFlag.bs.sqCstm == 1 && !RsIsCcuJetty(jettyCb->jettyMode),
236 : hccp_err("Non-CCU jetty cannot be created by specifying va, sqCstm:%u jettyMode:%u",
237 : jettyCb->extMode.cstmFlag.bs.sqCstm, jettyCb->jettyMode),
238 : -EINVAL);
239 :
240 0 : if (jettyCb->jettyMode == JETTY_MODE_CACHE_LOCK_DWQE) {
241 0 : ret = RsNetAllocJettyId(jettyCb->devCb->urmaDev->name, jettyCb->jettyMode, &jettyCfg->id);
242 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_net_alloc_jetty_id failed, ret:%d", ret), ret);
243 0 : jettyCb->jettyId = jettyCfg->id;
244 : }
245 :
246 0 : ret = RsUrmaAllocJetty(jettyCb->devCb->urmaCtx, jettyCfg, &jettyCb->jetty);
247 0 : if (ret != 0) {
248 0 : ret = -EOPENSRC;
249 0 : RsFreeJettyId(jettyCb->devCb->urmaDev->name, jettyCb->jettyMode, jettyCb->jettyId);
250 0 : hccp_err("urma_alloc_jetty failed, ret:%d, errno:%d", ret, errno);
251 : }
252 :
253 0 : return ret;
254 : }
255 :
256 0 : STATIC int RsCcuJettyDbReg(struct RsCtxJettyCb *jettyCb)
257 : {
258 0 : struct udma_u_jetty_info jettyInfo = {0};
259 0 : int ret = 0;
260 :
261 0 : if (!RsIsCcuJetty(jettyCb->jettyMode)) {
262 0 : return ret;
263 : }
264 :
265 : // only ccu jetty requires db registration
266 0 : jettyInfo.dwqe_addr = (void *)(ALIGN_DOWN(jettyCb->dbAddr, RA_RS_4K_PAGE_SIZE));
267 0 : ret = RsUbCtxRegJettyDb(jettyCb, &jettyInfo);
268 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_ub_ctx_reg_jetty_db failed, ret:%d", ret), ret);
269 :
270 0 : return ret;
271 : }
272 :
273 0 : void RsUbCtxExtJettyCreate(struct RsCtxJettyCb *jettyCb, urma_jetty_cfg_t *jettyCfg)
274 : {
275 0 : int ret = 0;
276 :
277 0 : ret = RsJettyAttrInit(jettyCb, jettyCfg);
278 0 : if (ret != 0) {
279 0 : jettyCb->jetty = NULL;
280 0 : return;
281 : }
282 :
283 0 : ret = RsSetJettyOpt(jettyCb);
284 0 : if (ret != 0) {
285 0 : hccp_err("rs_set_jetty_opt failed, ret:%d", ret);
286 0 : goto free_jetty;
287 : }
288 :
289 0 : ret = RsUrmaActiveJetty(jettyCb->jetty);
290 0 : if (ret != 0) {
291 0 : hccp_err("rs_urma_active_jetty failed, ret:%d, errno:%d", ret, errno);
292 0 : ret = -EOPENSRC;
293 0 : goto free_jetty;
294 : }
295 :
296 0 : ret = RsGetJettyOpt(jettyCb);
297 0 : if (ret != 0) {
298 0 : hccp_err("rs_get_jetty_opt failed, ret:%d", ret);
299 0 : goto deactive_jetty;
300 : }
301 :
302 0 : ret = RsCcuJettyDbReg(jettyCb);
303 0 : if (ret != 0) {
304 0 : goto deactive_jetty;
305 : }
306 0 : return;
307 :
308 0 : deactive_jetty:
309 0 : ret = RsUrmaDeactiveJetty(jettyCb->jetty);
310 0 : if (ret != 0) {
311 0 : hccp_err("rs_urma_deactive_jetty failed, ret:%d errno:%d", ret, errno);
312 : }
313 0 : free_jetty:
314 0 : ret = RsUrmaFreeJetty(jettyCb->jetty);
315 0 : if (ret != 0) {
316 0 : hccp_err("rs_urma_free_jetty failed, ret:%d errno:%d", ret, errno);
317 : }
318 :
319 0 : (void)RsFreeJettyId(jettyCb->devCb->urmaDev->name, jettyCb->jettyMode, jettyCb->jettyId);
320 0 : jettyCb->jetty = NULL;
321 : }
322 :
323 2 : void RsUbVaMunmapBatch(struct RsCtxJettyCb **jettyCbArr, unsigned int num)
324 : {
325 : unsigned int i;
326 :
327 4 : for (i = 0; i < num; ++i) {
328 2 : RsMunmapJettyVa(jettyCbArr[i]);
329 : }
330 2 : }
331 :
332 2 : void RsUbFreeJettyIdBatch(struct RsCtxJettyCb **jettyCbArr, unsigned int num)
333 : {
334 : unsigned int i;
335 :
336 4 : for (i = 0; i < num; ++i) {
337 2 : (void)RsFreeJettyId(jettyCbArr[i]->devCb->urmaDev->name, jettyCbArr[i]->jettyMode, jettyCbArr[i]->jettyId);
338 : }
339 2 : }
|
