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