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 <pthread.h>
12 : #include "errno.h"
13 : #include "ascend_hal_dl.h"
14 : #include "network_comm.h"
15 : #include "dl_hal_function.h"
16 :
17 : #define DL_API_IS_NULL_CHECK(handle, ptr, str) do { \
18 : if ((handle) == NULL) { \
19 : roce_err("g_hal_api_handle is NULL!"); \
20 : return (-EINVAL); \
21 : } \
22 : if ((ptr) == NULL) { \
23 : roce_err("[%s] is NULL!", (str)); \
24 : return (-EINVAL); \
25 : } \
26 : } while (0)
27 :
28 : static pthread_mutex_t gHalApiLock = PTHREAD_MUTEX_INITIALIZER;
29 : static void *gHalApiHandle = NULL;
30 : static struct DlHalOps gHalOps;
31 : static int gHalApiRefcnt = 0;
32 :
33 42 : static void DlHalApiDevInit(void)
34 : {
35 42 : gHalOps.dlDrvGetDevNum = (int (*)(unsigned int *numDev))
36 42 : AscendHalDlsym(gHalApiHandle, "drvGetDevNum");
37 :
38 42 : gHalOps.dlDrvGetLocalDevIdByHostDevId = (int (*)(uint32_t devId, uint32_t* chipId))
39 42 : AscendHalDlsym(gHalApiHandle, "drvGetLocalDevIDByHostDevID");
40 :
41 42 : gHalOps.dlDrvGetDevIdByLocalDevId = (int (*)(uint32_t localDevId, uint32_t *devId))
42 42 : AscendHalDlsym(gHalApiHandle, "drvGetDevIDByLocalDevID");
43 :
44 42 : gHalOps.dlDrvDeviceGetIndexByPhyId = (int (*)(uint32_t phyId, uint32_t *devIndex))
45 42 : AscendHalDlsym(gHalApiHandle, "drvDeviceGetIndexByPhyId");
46 :
47 42 : gHalOps.dlDrvDeviceGetPhyIdByIndex = (int (*)(unsigned int devIndex, unsigned int *phyId))
48 42 : AscendHalDlsym(gHalApiHandle, "drvDeviceGetPhyIdByIndex");
49 :
50 42 : gHalOps.dlHalGetPhyDevIdByudevId = (int (*)(unsigned int udevId, unsigned int *phyDevId))
51 42 : AscendHalDlsym(gHalApiHandle, "halGetPhyDevIdByUdevId");
52 :
53 42 : gHalOps.dlDrvDeviceGetBareTgid = (pid_t (*)(void))
54 42 : AscendHalDlsym(gHalApiHandle, "drvDeviceGetBareTgid");
55 :
56 42 : gHalOps.dlHalGetDeviceInfo = (int (*)(uint32_t devId, int32_t moduleType, int32_t infoType, int64_t *value))
57 42 : AscendHalDlsym(gHalApiHandle, "halGetDeviceInfo");
58 :
59 42 : gHalOps.dlHalQueryDevPid = (drvError_t (*)(struct halQueryDevpidInfo info, pid_t *devPid))
60 42 : AscendHalDlsym(gHalApiHandle, "halQueryDevpid");
61 :
62 42 : gHalOps.dlDrvQueryProcessHostPid = (drvError_t (*)(int pid, unsigned int *chipId, unsigned int *vfid,
63 : unsigned int *hostPid, unsigned int *cpType))
64 42 : AscendHalDlsym(gHalApiHandle, "drvQueryProcessHostPid");
65 :
66 42 : gHalOps.dlDrvGetProcessSign = (int (*)(struct process_sign *sign))
67 42 : AscendHalDlsym(gHalApiHandle, "drvGetProcessSign");
68 :
69 42 : gHalOps.dlDrvGetPlatformInfo = (int (*)(uint32_t* info))
70 42 : AscendHalDlsym(gHalApiHandle, "drvGetPlatformInfo");
71 :
72 42 : gHalOps.dlHalGetChipInfo = (int (*)(unsigned int devId, halChipInfo *chipInfo))
73 42 : AscendHalDlsym(gHalApiHandle, "halGetChipInfo");
74 42 : }
75 :
76 42 : static void DlHalApiHdcInit(void)
77 : {
78 42 : gHalOps.dlHalHdcGetSessionAttr = (int (*)(HDC_SESSION session, int attr, int *value))
79 42 : AscendHalDlsym(gHalApiHandle, "halHdcGetSessionAttr");
80 :
81 42 : gHalOps.dlDrvHdcGetCapacity = (hdcError_t (*)(struct drvHdcCapacity *capacity))
82 42 : AscendHalDlsym(gHalApiHandle, "drvHdcGetCapacity");
83 :
84 42 : gHalOps.dlDrvHdcClientCreate = (hdcError_t (*)(HDC_CLIENT *client, int maxSessionNum,
85 42 : int serviceType, int flag))AscendHalDlsym(gHalApiHandle, "drvHdcClientCreate");
86 :
87 42 : gHalOps.dlDrvHdcClientDestroy = (hdcError_t (*)(HDC_CLIENT client))
88 42 : AscendHalDlsym(gHalApiHandle, "drvHdcClientDestroy");
89 :
90 42 : gHalOps.dlDrvHdcSessionConnect =
91 42 : (hdcError_t (*)(int peerNode, int peerDevid, HDC_CLIENT client, HDC_SESSION *session))
92 42 : AscendHalDlsym(gHalApiHandle, "drvHdcSessionConnect");
93 :
94 42 : gHalOps.dlDrvHdcServerCreate = (hdcError_t (*)(int devid, int serviceType, HDC_SERVER *pServer))
95 42 : AscendHalDlsym(gHalApiHandle, "drvHdcServerCreate");
96 :
97 42 : gHalOps.dlDrvHdcServerDestroy = (hdcError_t (*)(HDC_SERVER server))
98 42 : AscendHalDlsym(gHalApiHandle, "drvHdcServerDestroy");
99 :
100 42 : gHalOps.dlDrvHdcSessionAccept = (hdcError_t (*)(HDC_SERVER server, HDC_SESSION *session))
101 42 : AscendHalDlsym(gHalApiHandle, "drvHdcSessionAccept");
102 :
103 42 : gHalOps.dlDrvHdcSessionClose = (hdcError_t (*)(HDC_SESSION session))
104 42 : AscendHalDlsym(gHalApiHandle, "drvHdcSessionClose");
105 :
106 42 : gHalOps.dlDrvHdcFreeMsg = (hdcError_t (*)(struct drvHdcMsg *msg))
107 42 : AscendHalDlsym(gHalApiHandle, "drvHdcFreeMsg");
108 :
109 42 : gHalOps.dlDrvHdcReuseMsg = (hdcError_t (*)(struct drvHdcMsg *msg))
110 42 : AscendHalDlsym(gHalApiHandle, "drvHdcReuseMsg");
111 :
112 42 : gHalOps.dlDrvHdcAddMsgBuffer = (hdcError_t (*)(struct drvHdcMsg *msg, char *pBuf, int len))
113 42 : AscendHalDlsym(gHalApiHandle, "drvHdcAddMsgBuffer");
114 :
115 42 : gHalOps.dlDrvHdcGetMsgBuffer = (hdcError_t (*)(struct drvHdcMsg *msg, int index, char **pBuf, int *pLen))
116 42 : AscendHalDlsym(gHalApiHandle, "drvHdcGetMsgBuffer");
117 :
118 42 : gHalOps.dlHalHdcRecv =
119 42 : (hdcError_t (*)(HDC_SESSION session, struct drvHdcMsg *pMsg, int bufLen, UINT64 flag, int *recvBufCount,
120 42 : UINT32 timeout))AscendHalDlsym(gHalApiHandle, "halHdcRecv");
121 :
122 42 : gHalOps.dlHalHdcSend = (hdcError_t (*)(HDC_SESSION session, struct drvHdcMsg *pMsg, UINT64 flag,
123 42 : UINT32 timeout))AscendHalDlsym(gHalApiHandle, "halHdcSend");
124 :
125 42 : gHalOps.dlDrvHdcAllocMsg = (hdcError_t (*)(HDC_SESSION session, struct drvHdcMsg **ppMsg, int count))
126 42 : AscendHalDlsym(gHalApiHandle, "drvHdcAllocMsg");
127 :
128 42 : gHalOps.dlDrvHdcSetSessionReference = (hdcError_t (*)(HDC_SESSION session))
129 42 : AscendHalDlsym(gHalApiHandle, "drvHdcSetSessionReference");
130 :
131 42 : gHalOps.dlHalHdcSessionConnectEx = (hdcError_t(*)(int peer_node, int peer_devid, int peer_pid,
132 42 : HDC_CLIENT client, HDC_SESSION *pSession))AscendHalDlsym(gHalApiHandle, "halHdcSessionConnectEx");
133 42 : }
134 :
135 42 : static void DlHalApiMemInit(void)
136 : {
137 42 : gHalOps.dlHalMemAlloc = (int (*)(void **pp, unsigned long long size, unsigned long long flag))
138 42 : AscendHalDlsym(gHalApiHandle, "halMemAlloc");
139 :
140 42 : gHalOps.dlHalMemFree = (int (*)(void *pp))
141 42 : AscendHalDlsym(gHalApiHandle, "halMemFree");
142 :
143 : #ifndef HNS_ROCE_LLT
144 : gHalOps.dlHalMemCtl =
145 : (int (*)(int type, void *paramValue, size_t paramValueSize, void *outValue, size_t *outSizeRet))
146 : AscendHalDlsym(gHalApiHandle, "halMemCtl");
147 : #endif
148 42 : gHalOps.dlHalMemGetInfoEx = (drvError_t (*)(unsigned int devId, unsigned int type, struct MemInfo *info))
149 42 : AscendHalDlsym(gHalApiHandle, "halMemGetInfoEx");
150 :
151 42 : gHalOps.dlHalMemBindSibling =
152 42 : (drvError_t (*)(int hostPid, int aicpuPid, unsigned int vfid, unsigned int devId, unsigned int flag))
153 42 : AscendHalDlsym(gHalApiHandle, "halMemBindSibling");
154 :
155 42 : gHalOps.dlHalBuffAllocAlignEx = (int (*)(uint64_t size, unsigned int align, unsigned long flag, int grpId,
156 : void **buff))
157 42 : AscendHalDlsym(gHalApiHandle, "halBuffAllocAlignEx");
158 :
159 42 : gHalOps.dlHalBuffFree = (int (*)(void *buff))
160 42 : AscendHalDlsym(gHalApiHandle, "halBuffFree");
161 :
162 42 : gHalOps.dlHalBindCgroup = (int (*)(BIND_CGROUP_TYPE bindType))
163 42 : AscendHalDlsym(gHalApiHandle, "halBindCgroup");
164 :
165 42 : gHalOps.dlHalNotifyGetInfo = (int (*)(uint32_t devId, uint32_t tsId, uint32_t type, uint32_t *val))
166 42 : AscendHalDlsym(gHalApiHandle, "halNotifyGetInfo");
167 :
168 42 : gHalOps.dlHalGrpQuery = (int (*)(GroupQueryCmdType cmd, void *inBuff, unsigned int inLen, void *outBuff,
169 : unsigned int *outLen))
170 42 : AscendHalDlsym(gHalApiHandle, "halGrpQuery");
171 :
172 42 : gHalOps.dlHalMemRegUbSegment = (drvError_t (*)(uint32_t devId, uint64_t va, uint64_t size))
173 42 : AscendHalDlsym(gHalApiHandle, "halMemRegUbSegment");
174 :
175 42 : gHalOps.dlHalMemUnRegUbSegment = (drvError_t (*)(uint32_t devId, uint64_t va))
176 42 : AscendHalDlsym(gHalApiHandle, "halMemUnRegUbSegment");
177 :
178 42 : gHalOps.dlDrvMemGetAttribute = (DVresult (*)(DVdeviceptr vptr, struct DVattribute *attr))
179 42 : AscendHalDlsym(gHalApiHandle, "drvMemGetAttribute");
180 42 : }
181 :
182 42 : static void DlHalApiSensorInit(void)
183 : {
184 42 : gHalOps.dlHalSensorNodeRegister =
185 42 : (drvError_t (*)(uint32_t devid, struct halSensorNodeCfg *cfg, uint64_t *handle))
186 42 : AscendHalDlsym(gHalApiHandle, "halSensorNodeRegister");
187 :
188 42 : gHalOps.dlHalSensorNodeUnregister = (drvError_t (*)(uint32_t devid, uint64_t handle))
189 42 : AscendHalDlsym(gHalApiHandle, "halSensorNodeUnregister");
190 :
191 42 : gHalOps.dlHalSensorNodeUpdateState =
192 42 : (drvError_t (*)(uint32_t devid, uint64_t handle, int val, halGeneralEventType_t assertion))
193 42 : AscendHalDlsym(gHalApiHandle, "halSensorNodeUpdateState");
194 42 : }
195 :
196 42 : static void DlHalApiEschedInit(void)
197 : {
198 42 : gHalOps.dlHalEschedSubmitEvent = (int (*)(uint32_t devId, struct event_summary *event))
199 42 : AscendHalDlsym(gHalApiHandle, "halEschedSubmitEvent");
200 :
201 42 : gHalOps.dlHalEschedAttachDevice = (int (*)(uint32_t devId))
202 42 : AscendHalDlsym(gHalApiHandle, "halEschedAttachDevice");
203 :
204 42 : gHalOps.dlHalEschedCreateGrp = (int (*)(uint32_t devId, uint32_t grpId, GROUP_TYPE type))
205 42 : AscendHalDlsym(gHalApiHandle, "halEschedCreateGrp");
206 :
207 42 : gHalOps.dlHalEschedSubscribeEvent = (int (*)(uint32_t devId, uint32_t grpId, uint32_t threadId,
208 42 : uint64_t eventBitmap))AscendHalDlsym(gHalApiHandle, "halEschedSubscribeEvent");
209 :
210 42 : gHalOps.dlHalEschedWaitEvent = (int (*)(uint32_t devId, uint32_t grpId, uint32_t threadId, int32_t timeout,
211 42 : struct event_info *event))AscendHalDlsym(gHalApiHandle, "halEschedWaitEvent");
212 42 : }
213 :
214 42 : static void DlHalApiResInit(void)
215 : {
216 42 : gHalOps.dlHalResAddrMapV2 = (drvError_t (*)(unsigned int devId, struct res_map_info_in *resInfoIn,
217 42 : struct res_map_info_out *resInfoOut))AscendHalDlsym(gHalApiHandle, "halResAddrMapV2");
218 :
219 42 : gHalOps.dlHalResAddrUnmapV2 = (drvError_t (*)(unsigned int devId, struct res_map_info_in *resInfoIn))
220 42 : AscendHalDlsym(gHalApiHandle, "halResAddrUnmapV2");
221 42 : }
222 :
223 42 : static void DlHalApiHostInit(void)
224 : {
225 42 : gHalOps.dlHalHostRegister = (drvError_t (*)(void *srcPtr, uint64_t size, uint32_t flag, uint32_t devId, void **dstPtr))
226 42 : AscendHalDlsym(gHalApiHandle, "halHostRegister");
227 :
228 42 : gHalOps.dlHalHostUnregister = (drvError_t (*)(void *src_ptr, uint32_t devid))
229 42 : AscendHalDlsym(gHalApiHandle, "halHostUnregister");
230 :
231 42 : gHalOps.dlHalHostUnregisterEx = (drvError_t (*)(void *src_ptr, uint32_t devid, uint32_t flag))
232 42 : AscendHalDlsym(gHalApiHandle, "halHostUnregisterEx");
233 42 : return;
234 : }
235 :
236 42 : static void DlHalApiInit(void)
237 : {
238 42 : DlHalApiDevInit();
239 :
240 42 : DlHalApiHdcInit();
241 :
242 42 : DlHalApiMemInit();
243 :
244 42 : DlHalApiSensorInit();
245 :
246 42 : DlHalApiEschedInit();
247 :
248 42 : DlHalApiResInit();
249 :
250 42 : DlHalApiHostInit();
251 :
252 42 : return;
253 : }
254 :
255 214 : void DlHalDeinit(void)
256 : {
257 214 : pthread_mutex_lock(&gHalApiLock);
258 214 : if (gHalApiHandle != NULL) {
259 214 : gHalApiRefcnt--;
260 214 : if (gHalApiRefcnt > 0) {
261 174 : pthread_mutex_unlock(&gHalApiLock);
262 174 : roce_info("dl_hal_deinit success, no need to dlclose libascend_hal.so!");
263 174 : return;
264 : }
265 :
266 40 : (void)AscendHalDlclose(gHalApiHandle);
267 40 : gHalApiHandle = NULL;
268 : }
269 :
270 40 : pthread_mutex_unlock(&gHalApiLock);
271 40 : roce_info("dl_hal_deinit success!");
272 40 : return;
273 : }
274 :
275 219 : int DlHalInit(void)
276 : {
277 219 : pthread_mutex_lock(&gHalApiLock);
278 219 : if (gHalApiHandle != NULL) {
279 177 : gHalApiRefcnt++;
280 177 : pthread_mutex_unlock(&gHalApiLock);
281 177 : roce_info("dl_hal_init success, no need to dlopen libascend_hal.so!");
282 177 : return 0;
283 : }
284 :
285 42 : gHalApiHandle = AscendHalDlopen("libascend_hal.so", RTLD_NOW);
286 42 : if (gHalApiHandle == NULL) {
287 0 : pthread_mutex_unlock(&gHalApiLock);
288 0 : roce_err("dlopen libascend_hal.so failed! error_no=[%d]", errno);
289 0 : return -EINVAL;
290 : }
291 :
292 42 : DlHalApiInit();
293 42 : gHalApiRefcnt++;
294 :
295 42 : pthread_mutex_unlock(&gHalApiLock);
296 42 : roce_info("dl_hal_init success!");
297 42 : return 0;
298 : }
299 :
300 46 : int DlDrvGetDevNum(unsigned int *numDev)
301 : {
302 46 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlDrvGetDevNum, "dl_drv_get_dev_num");
303 :
304 46 : return DlRetConvert(gHalOps.dlDrvGetDevNum(numDev));
305 : }
306 :
307 3 : int DlDrvGetLocalDevIdByHostDevId(unsigned int devId, unsigned int* chipId)
308 : {
309 3 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlDrvGetLocalDevIdByHostDevId,
310 : "dl_drv_get_local_dev_id_by_host_dev_id");
311 :
312 1 : return DlRetConvert(gHalOps.dlDrvGetLocalDevIdByHostDevId(devId, chipId));
313 : }
314 :
315 154 : int DlDrvDeviceGetIndexByPhyId(uint32_t phyId, uint32_t *devIndex)
316 : {
317 154 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlDrvDeviceGetIndexByPhyId,
318 : "dl_drv_device_get_index_by_phy_id");
319 :
320 154 : return DlRetConvert(gHalOps.dlDrvDeviceGetIndexByPhyId(phyId, devIndex));
321 : }
322 :
323 15 : int DlDrvGetDevIdByLocalDevId(unsigned int localDevId, unsigned int *devId)
324 : {
325 15 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlDrvGetDevIdByLocalDevId,
326 : "dl_drv_get_dev_id_by_local_dev_id");
327 :
328 15 : return DlRetConvert(gHalOps.dlDrvGetDevIdByLocalDevId(localDevId, devId));
329 : }
330 :
331 12 : int DlDrvDeviceGetPhyIdByIndex(unsigned int devIndex, unsigned int *phyId)
332 : {
333 12 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlDrvDeviceGetPhyIdByIndex,
334 : "dl_drv_device_get_phy_id_by_index");
335 :
336 8 : return DlRetConvert(gHalOps.dlDrvDeviceGetPhyIdByIndex(devIndex, phyId));
337 : }
338 :
339 124 : int DlHalGetPhyDevIdByudevId(unsigned int udevId, unsigned int *phyDevId)
340 : {
341 124 : CHK_PRT_RETURN(gHalApiHandle == NULL, roce_err("gHalApiHandle is NULL"), -EINVAL);
342 124 : CHK_PRT_RETURN(phyDevId == NULL, roce_err("phyDevId is NULL"), -EINVAL);
343 : // use udevId as phyDevId for API compatibility issue(abnormal in mdev scenario)
344 124 : *phyDevId = udevId;
345 124 : CHK_PRT_RETURN(gHalOps.dlHalGetPhyDevIdByudevId == NULL, roce_warn("dlHalGetPhyDevIdByudevId is NULL"), 0);
346 0 : return DlRetConvert(gHalOps.dlHalGetPhyDevIdByudevId(udevId, phyDevId));
347 : }
348 :
349 2 : drvError_t DlHalQueryDevPid(struct halQueryDevpidInfo info, pid_t *devPid)
350 : {
351 2 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalQueryDevPid, "dl_hal_query_dev_pid");
352 :
353 2 : return DlRetConvert(gHalOps.dlHalQueryDevPid(info, devPid));
354 : }
355 :
356 1 : drvError_t DlHalMemBindSibling(int hostPid, int aicpuPid, unsigned int vfid, unsigned int devId,
357 : unsigned int flag)
358 : {
359 1 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalMemBindSibling, "dl_hal_mem_bind_sibling");
360 :
361 1 : return DlRetConvert(gHalOps.dlHalMemBindSibling(hostPid, aicpuPid, vfid, devId, flag));
362 : }
363 :
364 391 : drvError_t DlDrvQueryProcessHostPid(int pid, unsigned int *chipId, unsigned int *vfid, unsigned int *hostPid,
365 : unsigned int *cpType)
366 : {
367 391 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlDrvQueryProcessHostPid, "dl_drv_query_process_host_pid");
368 :
369 391 : return DlRetConvert(gHalOps.dlDrvQueryProcessHostPid(pid, chipId, vfid, hostPid, cpType));
370 : }
371 :
372 1 : drvError_t DlHalMemGetInfoEx(unsigned int devId, unsigned int type, struct MemInfo *info)
373 : {
374 1 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalMemGetInfoEx, "dl_hal_mem_get_info_ex");
375 :
376 1 : return DlRetConvert(gHalOps.dlHalMemGetInfoEx(devId, type, info));
377 : }
378 :
379 1 : int DlHalGrpQuery(GroupQueryCmdType cmd, void *inBuff, unsigned int inLen, void *outBuff, unsigned int *outLen)
380 : {
381 1 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalGrpQuery, "dl_hal_grp_query");
382 :
383 1 : return DlRetConvert(gHalOps.dlHalGrpQuery(cmd, inBuff, inLen, outBuff, outLen));
384 : }
385 :
386 119 : int DlHalHdcGetSessionAttr(HDC_SESSION session, int attr, int *value)
387 : {
388 119 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalHdcGetSessionAttr, "dl_hal_hdc_get_session_attr");
389 :
390 119 : return DlRetConvert(gHalOps.dlHalHdcGetSessionAttr(session, attr, value));
391 : }
392 :
393 0 : hdcError_t DlDrvHdcGetCapacity(struct drvHdcCapacity *capacity)
394 : {
395 0 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlDrvHdcGetCapacity, "dl_drv_hdc_get_capacity");
396 :
397 0 : return DlRetConvert(gHalOps.dlDrvHdcGetCapacity(capacity));
398 : }
399 :
400 29 : hdcError_t DlDrvHdcClientCreate(HDC_CLIENT *client, int maxSessionNum, int serviceType, int flag)
401 : {
402 29 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlDrvHdcClientCreate, "dl_drv_hdc_client_create");
403 :
404 29 : return DlRetConvert(gHalOps.dlDrvHdcClientCreate(client, maxSessionNum, serviceType, flag));
405 : }
406 :
407 30 : hdcError_t DlDrvHdcClientDestroy(HDC_CLIENT client)
408 : {
409 30 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlDrvHdcClientDestroy, "dl_drv_hdc_client_destroy");
410 :
411 30 : return DlRetConvert(gHalOps.dlDrvHdcClientDestroy(client));
412 : }
413 :
414 29 : hdcError_t DlDrvHdcSessionConnect(int peerNode, int peerDevid, HDC_CLIENT client, HDC_SESSION *session)
415 : {
416 29 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlDrvHdcSessionConnect, "dl_drv_hdc_session_connect");
417 :
418 29 : return DlRetConvert(gHalOps.dlDrvHdcSessionConnect(peerNode, peerDevid, client, session));
419 : }
420 :
421 0 : hdcError_t DlHalHdcSessionConnectEx(int peerNode, int peerDevid, int peerPid, HDC_CLIENT client,
422 : HDC_SESSION *pSession)
423 : {
424 0 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalHdcSessionConnectEx, "dl_hal_hdc_session_connect_ex");
425 :
426 0 : return DlRetConvert(gHalOps.dlHalHdcSessionConnectEx(peerNode, peerDevid, peerPid, client, pSession));
427 : }
428 :
429 122 : hdcError_t DlDrvHdcServerCreate(int devid, int serviceType, HDC_SERVER *pServer)
430 : {
431 122 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlDrvHdcServerCreate, "dl_drv_hdc_server_create");
432 :
433 122 : return DlRetConvert(gHalOps.dlDrvHdcServerCreate(devid, serviceType, pServer));
434 : }
435 :
436 0 : hdcError_t DlDrvHdcServerDestroy(HDC_SERVER server)
437 : {
438 0 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlDrvHdcServerDestroy, "dl_drv_hdc_server_destroy");
439 :
440 0 : return DlRetConvert(gHalOps.dlDrvHdcServerDestroy(server));
441 : }
442 :
443 237 : hdcError_t DlDrvHdcSessionAccept(HDC_SERVER server, HDC_SESSION *session)
444 : {
445 237 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlDrvHdcSessionAccept, "dl_drv_hdc_session_accept");
446 :
447 237 : return DlRetConvert(gHalOps.dlDrvHdcSessionAccept(server, session));
448 : }
449 :
450 147 : hdcError_t DlDrvHdcSessionClose(HDC_SESSION session)
451 : {
452 147 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlDrvHdcSessionClose, "dl_drv_hdc_session_close");
453 :
454 147 : return DlRetConvert(gHalOps.dlDrvHdcSessionClose(session));
455 : }
456 :
457 327 : hdcError_t DlDrvHdcFreeMsg(struct drvHdcMsg *msg)
458 : {
459 327 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlDrvHdcFreeMsg, "dl_drv_hdc_free_msg");
460 :
461 327 : return DlRetConvert(gHalOps.dlDrvHdcFreeMsg(msg));
462 : }
463 :
464 322 : hdcError_t DlDrvHdcReuseMsg(struct drvHdcMsg *msg)
465 : {
466 322 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlDrvHdcReuseMsg, "dl_drv_hdc_reuse_msg");
467 :
468 322 : return DlRetConvert(gHalOps.dlDrvHdcReuseMsg(msg));
469 : }
470 :
471 326 : hdcError_t DlDrvHdcAddMsgBuffer(struct drvHdcMsg *msg, char *pBuf, int len)
472 : {
473 326 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlDrvHdcAddMsgBuffer, "dl_drv_hdc_add_msg_buffer");
474 :
475 326 : return DlRetConvert(gHalOps.dlDrvHdcAddMsgBuffer(msg, pBuf, len));
476 : }
477 :
478 321 : hdcError_t DlDrvHdcGetMsgBuffer(struct drvHdcMsg *msg, int index, char **pBuf, int *pLen)
479 : {
480 321 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlDrvHdcGetMsgBuffer, "dl_drv_hdc_get_msg_buffer");
481 :
482 321 : return DlRetConvert(gHalOps.dlDrvHdcGetMsgBuffer(msg, index, pBuf, pLen));
483 : }
484 :
485 322 : hdcError_t DlHalHdcRecv(HDC_SESSION session, struct drvHdcMsg *pMsg, int bufLen, UINT64 flag,
486 : int *recvBufCount, UINT32 timeout)
487 : {
488 322 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalHdcRecv, "dl_hal_hdc_recv");
489 :
490 322 : return DlRetConvert(gHalOps.dlHalHdcRecv(session, pMsg, bufLen, flag, recvBufCount, timeout));
491 : }
492 :
493 323 : hdcError_t DlHalHdcSend(HDC_SESSION session, struct drvHdcMsg *pMsg, UINT64 flag, UINT32 timeout)
494 : {
495 323 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalHdcSend, "dl_hal_hdc_send");
496 :
497 323 : return DlRetConvert(gHalOps.dlHalHdcSend(session, pMsg, flag, timeout));
498 : }
499 :
500 328 : hdcError_t DlDrvHdcAllocMsg(HDC_SESSION session, struct drvHdcMsg **ppMsg, int count)
501 : {
502 328 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlDrvHdcAllocMsg, "dl_drv_hdc_alloc_msg");
503 :
504 328 : return DlRetConvert(gHalOps.dlDrvHdcAllocMsg(session, ppMsg, count));
505 : }
506 :
507 147 : hdcError_t DlDrvHdcSetSessionReference(HDC_SESSION session)
508 : {
509 147 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlDrvHdcSetSessionReference,
510 : "dl_drv_hdc_set_session_reference");
511 :
512 147 : return DlRetConvert(gHalOps.dlDrvHdcSetSessionReference(session));
513 : }
514 :
515 4 : int DlDrvGetProcessSign(struct process_sign *sign)
516 : {
517 4 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlDrvGetProcessSign, "dl_drv_get_process_sign");
518 :
519 4 : return DlRetConvert(gHalOps.dlDrvGetProcessSign(sign));
520 : }
521 :
522 296 : pid_t DlDrvDeviceGetBareTgid(void)
523 : {
524 296 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlDrvDeviceGetBareTgid, "dl_drv_device_get_bare_tgid");
525 :
526 291 : return gHalOps.dlDrvDeviceGetBareTgid();
527 : }
528 :
529 17 : int DlHalNotifyGetInfo(uint32_t devId, uint32_t tsId, uint32_t type, uint32_t *val)
530 : {
531 17 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalNotifyGetInfo, "dl_hal_notify_get_info");
532 :
533 17 : return DlRetConvert(gHalOps.dlHalNotifyGetInfo(devId, tsId, type, val));
534 : }
535 :
536 11 : int DlHalMemAlloc(void **pp, unsigned long long size, unsigned long long flag)
537 : {
538 11 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalMemAlloc, "dl_hal_mem_alloc");
539 :
540 11 : return DlRetConvert(gHalOps.dlHalMemAlloc(pp, size, flag));
541 : }
542 :
543 20 : int DlHalMemFree(void *pp)
544 : {
545 20 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalMemFree, "dl_hal_mem_free");
546 :
547 20 : return DlRetConvert(gHalOps.dlHalMemFree(pp));
548 : }
549 :
550 0 : int DlHalEschedSubmitEvent(uint32_t devId, struct event_summary *event)
551 : {
552 0 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalEschedSubmitEvent, "dl_hal_esched_submit_event");
553 :
554 0 : return DlRetConvert(gHalOps.dlHalEschedSubmitEvent(devId, event));
555 : }
556 :
557 0 : int DlHalMemCtl(int type, void *paramValue, size_t paramValueSize, void *outValue, size_t *outSizeRet)
558 : {
559 0 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalMemCtl, "dl_hal_mem_ctl");
560 :
561 0 : return DlRetConvert(gHalOps.dlHalMemCtl(type, paramValue, paramValueSize, outValue, outSizeRet));
562 : }
563 :
564 0 : int DlHalBuffAllocAlignEx(uint64_t size, unsigned int align, unsigned long flag, int grpId, void **buff)
565 : {
566 0 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalBuffAllocAlignEx, "dl_hal_buff_alloc_align_ex");
567 :
568 0 : return DlRetConvert(gHalOps.dlHalBuffAllocAlignEx(size, align, flag, grpId, buff));
569 : }
570 :
571 4 : int DlHalBuffFree(void *buff)
572 : {
573 4 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalBuffFree, "dl_hal_buff_free");
574 :
575 0 : return DlRetConvert(gHalOps.dlHalBuffFree(buff));
576 : }
577 :
578 1 : int DlHalBindCgroup(BIND_CGROUP_TYPE bindType)
579 : {
580 1 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalBindCgroup, "dl_hal_bind_cgroup");
581 :
582 1 : return DlRetConvert(gHalOps.dlHalBindCgroup(bindType));
583 : }
584 :
585 40 : int DlDrvGetPlatformInfo(uint32_t* info)
586 : {
587 40 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlDrvGetPlatformInfo, "dl_drv_get_platform_info");
588 :
589 40 : return DlRetConvert(gHalOps.dlDrvGetPlatformInfo(info));
590 : }
591 :
592 476 : int DlHalGetDeviceInfo(uint32_t devId, int32_t moduleType, int32_t infoType, int64_t *value)
593 : {
594 476 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalGetDeviceInfo, "dl_hal_get_device_info");
595 :
596 475 : return DlRetConvert(gHalOps.dlHalGetDeviceInfo(devId, moduleType, infoType, value));
597 : }
598 :
599 17 : int DlHalGetChipInfo(unsigned int devId, halChipInfo *chipInfo)
600 : {
601 17 : if (gHalApiHandle == NULL) {
602 0 : roce_err("g_hal_api_handle is NULL!");
603 0 : return -EINVAL;
604 : }
605 :
606 17 : if (gHalOps.dlHalGetChipInfo == NULL) {
607 0 : roce_warn("dl_hal_get_chip_info is NULL!");
608 0 : return -EINVAL;
609 : }
610 :
611 17 : return DlRetConvert(gHalOps.dlHalGetChipInfo(devId, chipInfo));
612 : }
613 :
614 25 : int DlHalSensorNodeRegister(uint32_t devid, struct halSensorNodeCfg *cfg, uint64_t *handle)
615 : {
616 25 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalSensorNodeRegister, "dl_hal_sensor_node_register");
617 :
618 25 : return DlRetConvert(gHalOps.dlHalSensorNodeRegister(devid, cfg, handle));
619 : }
620 :
621 31 : int DlHalSensorNodeUnregister(uint32_t devid, uint64_t handle)
622 : {
623 : /* sensor may not support, handle is 0 */
624 31 : if (handle == 0) {
625 6 : return 0;
626 : }
627 :
628 25 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalSensorNodeUnregister, "dl_hal_sensor_node_unregister");
629 :
630 25 : return DlRetConvert(gHalOps.dlHalSensorNodeUnregister(devid, handle));
631 : }
632 :
633 0 : int DlHalSensorNodeUpdateState(uint32_t devid, uint64_t handle, int val, halGeneralEventType_t assertion)
634 : {
635 0 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalSensorNodeUpdateState,
636 : "dl_hal_sensor_node_update_state");
637 :
638 0 : return DlRetConvert(gHalOps.dlHalSensorNodeUpdateState(devid, handle, val, assertion));
639 : }
640 :
641 0 : int DlHalEschedAttachDevice(uint32_t devId)
642 : {
643 0 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalEschedAttachDevice, "dl_hal_esched_attach_device");
644 :
645 0 : return DlRetConvert(gHalOps.dlHalEschedAttachDevice(devId));
646 : }
647 :
648 0 : int DlHalEschedCreateGrp(uint32_t devId, uint32_t grpId, GROUP_TYPE type)
649 : {
650 0 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalEschedCreateGrp, "dl_hal_esched_create_grp");
651 :
652 0 : return DlRetConvert(gHalOps.dlHalEschedCreateGrp(devId, grpId, type));
653 : }
654 :
655 0 : int DlHalEschedSubscribeEvent(uint32_t devId, uint32_t grpId, uint32_t threadId, uint64_t eventBitmap)
656 : {
657 0 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalEschedSubscribeEvent, "dl_hal_esched_subscribe_event");
658 :
659 0 : return DlRetConvert(gHalOps.dlHalEschedSubscribeEvent(devId, grpId, threadId, eventBitmap));
660 : }
661 :
662 0 : int DlHalEschedWaitEvent(uint32_t devId, uint32_t grpId, uint32_t threadId, int32_t timeout,
663 : struct event_info *event)
664 : {
665 0 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalEschedWaitEvent, "dl_hal_esched_wait_event");
666 :
667 0 : return DlRetConvert(gHalOps.dlHalEschedWaitEvent(devId, grpId, threadId, timeout, event));
668 : }
669 :
670 2 : int DlHalResAddrMapV2(unsigned int devId, struct res_map_info_in *resInfoIn, struct res_map_info_out *resInfoOut)
671 : {
672 2 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalResAddrMapV2, "dlHalResAddrMapV2");
673 :
674 0 : return DlRetConvert(gHalOps.dlHalResAddrMapV2(devId, resInfoIn, resInfoOut));
675 : }
676 :
677 0 : int DlHalResAddrUnmapV2(unsigned int devId, struct res_map_info_in *resInfoIn)
678 : {
679 0 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalResAddrUnmapV2, "dlHalResAddrUnmapV2");
680 :
681 0 : return DlRetConvert(gHalOps.dlHalResAddrUnmapV2(devId, resInfoIn));
682 : }
683 :
684 0 : int DlHalMemRegUbSegment(uint32_t devId, uint64_t va, uint64_t size)
685 : {
686 0 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalMemRegUbSegment, "dlHalMemRegUbSegment");
687 :
688 0 : return DlRetConvert(gHalOps.dlHalMemRegUbSegment(devId, va, size));
689 : }
690 :
691 0 : int DlHalMemUnRegUbSegment(uint32_t devId, uint64_t va)
692 : {
693 0 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalMemUnRegUbSegment, "dlHalMemUnRegUbSegment");
694 :
695 0 : return DlRetConvert(gHalOps.dlHalMemUnRegUbSegment(devId, va));
696 : }
697 :
698 0 : int DlDrvMemGetAttribute(DVdeviceptr vptr, struct DVattribute *attr)
699 : {
700 0 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlDrvMemGetAttribute, "dlDrvMemGetAttribute");
701 :
702 0 : return DlRetConvert(gHalOps.dlDrvMemGetAttribute(vptr, attr));
703 : }
704 :
705 2 : int DlHalHostRegister(void *srcPtr, uint64_t size, uint32_t flag, uint32_t devId, void **dstPtr)
706 : {
707 2 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalHostRegister, "dlHalHostRegister");
708 :
709 0 : return DlRetConvert(gHalOps.dlHalHostRegister(srcPtr, size, flag, devId, dstPtr));
710 : }
711 :
712 0 : int DlHalHostUnRegister(void *srcPtr, uint32_t devId)
713 : {
714 0 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalHostUnregister, "dlHalHostUnregister");
715 :
716 0 : return DlRetConvert(gHalOps.dlHalHostUnregister(srcPtr, devId));
717 : }
718 :
719 0 : int DlHalHostUnRegisterEx(void *srcPtr, uint32_t devId, uint32_t flag)
720 : {
721 0 : DL_API_IS_NULL_CHECK(gHalApiHandle, gHalOps.dlHalHostUnregisterEx, "dlHalHostUnregisterEx");
722 :
723 0 : return DlRetConvert(gHalOps.dlHalHostUnregisterEx(srcPtr, devId, flag));
724 : }
|
