Line data Source code
1 : /**
2 : * Copyright (c) 2026 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 : #include "ts_aicpu_sqe_adapter.h"
11 : #include "aicpusd_event_manager.h"
12 : #include "aicpusd_event_process.h"
13 : #include "aicpusd_msg_send.h"
14 : #include "dump_task.h"
15 : namespace AicpuSchedule {
16 21 : TsAicpuSqeAdapter::TsAicpuSqeAdapter(const TsAicpuSqe& sqe)
17 21 : : TsMsgAdapter(sqe.pid, sqe.cmd_type, sqe.vf_id, sqe.tid, sqe.ts_id), aicpuSqe_(sqe), invalidSqe_(false)
18 : {
19 21 : aicpusd_info("Adapter initialized: message_format=sqe.");
20 21 : }
21 :
22 2 : TsAicpuSqeAdapter::TsAicpuSqeAdapter() : TsMsgAdapter(), aicpuSqe_({}), invalidSqe_(true)
23 : {
24 2 : aicpusd_info("Adapter initialized: message_format=sqe valid=false.");
25 2 : }
26 :
27 4 : bool TsAicpuSqeAdapter::IsAdapterInvalidParameter() const { return invalidSqe_; }
28 :
29 1 : void TsAicpuSqeAdapter::GetAicpuDataDumpInfo(AicpuDataDumpInfo& info)
30 : {
31 1 : TsToAicpuDataDump tmpInfo = aicpuSqe_.u.ts_to_aicpu_datadump;
32 1 : aicpusd_info(
33 : "Dump request(sqe): model=%u stream=%u task=%u debug_stream=%u debug_task=%u "
34 : "ack_stream=%u ack_task=%u.",
35 : tmpInfo.model_id, tmpInfo.stream_id, tmpInfo.task_id, tmpInfo.stream_id1, tmpInfo.task_id1,
36 : tmpInfo.ack_stream_id, tmpInfo.ack_task_id);
37 1 : info.dump_task_id = tmpInfo.task_id;
38 1 : info.dump_stream_id = tmpInfo.stream_id;
39 1 : info.debug_dump_task_id = tmpInfo.task_id1;
40 1 : info.debug_dump_stream_id = tmpInfo.stream_id1;
41 1 : info.is_model = (tmpInfo.model_id != INVALID_VALUE16);
42 1 : info.is_debug = ((tmpInfo.task_id1 != INVALID_VALUE16) && (tmpInfo.stream_id1 != INVALID_VALUE16));
43 1 : info.file_name_stream_id = info.is_debug ? tmpInfo.stream_id1 : tmpInfo.stream_id;
44 1 : info.file_name_task_id = static_cast<uint32_t>(info.is_debug ? tmpInfo.task_id1 : tmpInfo.task_id);
45 1 : }
46 :
47 1 : void TsAicpuSqeAdapter::GetAicpuDumpFFTSPlusDataInfo(AicpuDumpFFTSPlusDataInfo& info)
48 : {
49 1 : aicpusd_info("Get FFTS+ dump info.");
50 1 : info.i = aicpuSqe_.u.ts_to_aicpu_ffts_plus_datadump;
51 1 : return;
52 : }
53 :
54 2 : bool TsAicpuSqeAdapter::IsOpMappingDumpTaskInfoVaild(const AicpuOpMappingDumpTaskInfo& info) const
55 : {
56 3 : const bool isOutOfRange = (info.proto_info_task_id > INVALID_VALUE16) ||
57 3 : (info.proto_info_stream_id > INVALID_VALUE16) || (info.stream_id > INVALID_VALUE16) ||
58 1 : (info.task_id > INVALID_VALUE16);
59 2 : return !isOutOfRange;
60 : }
61 :
62 0 : void TsAicpuSqeAdapter::GetAicpuDumpTaskInfo(AicpuOpMappingDumpTaskInfo& opmappingInfo, AicpuDumpTaskInfo& dumpTaskInfo)
63 : {
64 0 : opmappingInfo.proto_info_task_id &= 0xFFFFU;
65 0 : aicpusd_info(
66 : "Dump task mapping: proto_task=%u proto_stream=%u mapped_task=%u mapped_stream=%u",
67 : opmappingInfo.proto_info_task_id, opmappingInfo.proto_info_stream_id, opmappingInfo.task_id,
68 : opmappingInfo.stream_id);
69 0 : dumpTaskInfo.task_id =
70 0 : opmappingInfo.proto_info_task_id == INVALID_VALUE16 ? opmappingInfo.task_id : opmappingInfo.proto_info_task_id;
71 0 : dumpTaskInfo.stream_id = opmappingInfo.proto_info_stream_id == INVALID_VALUE16 ? opmappingInfo.stream_id :
72 : opmappingInfo.proto_info_stream_id;
73 0 : dumpTaskInfo.context_id = INVALID_VALUE16;
74 0 : dumpTaskInfo.thread_id = INVALID_VALUE16;
75 0 : }
76 :
77 1 : void TsAicpuSqeAdapter::GetAicpuDataDumpInfoLoad(AicpuDataDumpInfoLoad& info)
78 : {
79 1 : TsToAicpuDataDumpInfoLoad tmpinfo = aicpuSqe_.u.ts_to_aicpu_datadumploadinfo;
80 1 : aicpusd_info(
81 : "Dump load request: address=%p length=%u task=%u stream=%u.", tmpinfo.dumpinfoPtr, tmpinfo.length,
82 : tmpinfo.task_id, tmpinfo.stream_id);
83 1 : info.dumpinfoPtr = tmpinfo.dumpinfoPtr;
84 1 : info.length = tmpinfo.length;
85 1 : info.task_id = tmpinfo.task_id;
86 1 : info.stream_id = tmpinfo.stream_id;
87 1 : }
88 :
89 1 : int32_t TsAicpuSqeAdapter::AicpuDumpResponseToTs(const int32_t result)
90 : {
91 1 : TsAicpuSqe aicpuSqe{};
92 1 : aicpuSqe.pid = static_cast<uint32_t>(AicpuDrvManager::GetInstance().GetHostPid());
93 1 : aicpuSqe.vf_id = static_cast<uint8_t>(AicpuDrvManager::GetInstance().GetVfId());
94 1 : aicpuSqe.tid = tid_;
95 1 : aicpuSqe.ts_id = tsId_;
96 1 : aicpuSqe.cmd_type = AICPU_DATADUMP_RESPONSE;
97 1 : aicpuSqe.u.aicpu_dump_resp.result_code = static_cast<uint16_t>(result);
98 1 : aicpuSqe.u.aicpu_dump_resp.cmd_type = AICPU_DATADUMP_REPORT;
99 1 : uint32_t handleId = 0U;
100 1 : if (cmdType_ == AICPU_FFTS_PLUS_DATADUMP_REPORT) {
101 0 : aicpusd_info("Dump response path: mode=ffts_plus.");
102 0 : TsToAicpuFFTSPlusDataDump info = aicpuSqe_.u.ts_to_aicpu_ffts_plus_datadump;
103 0 : uint32_t ackStreamId = info.stream_id;
104 0 : uint32_t ackTaskId = info.task_id;
105 0 : if ((info.task_id1 != INVALID_VALUE16) && (info.stream_id1 != INVALID_VALUE16)) {
106 0 : ackStreamId = info.stream_id1;
107 0 : ackTaskId = info.task_id1;
108 : }
109 0 : aicpuSqe.u.aicpu_dump_resp.task_id = ackTaskId;
110 0 : aicpuSqe.u.aicpu_dump_resp.stream_id = ackStreamId;
111 0 : aicpuSqe.u.aicpu_dump_resp.reserved = info.reserved[0];
112 0 : handleId = info.model_id;
113 : } else {
114 1 : aicpuSqe.u.aicpu_dump_resp.task_id = aicpuSqe_.u.ts_to_aicpu_datadump.ack_task_id;
115 1 : aicpuSqe.u.aicpu_dump_resp.stream_id = aicpuSqe_.u.ts_to_aicpu_datadump.ack_stream_id;
116 1 : aicpuSqe.u.aicpu_dump_resp.reserved = aicpuSqe_.u.ts_to_aicpu_datadump.reserved[0];
117 1 : handleId = aicpuSqe_.u.ts_to_aicpu_datadump.model_id;
118 : }
119 1 : aicpusd_info(
120 : "Dump response: message_type=%u result=%u ack_stream=%u ack_task=%u.", aicpuSqe.cmd_type, result,
121 : aicpuSqe.u.aicpu_dump_resp.stream_id, aicpuSqe.u.aicpu_dump_resp.task_id);
122 1 : return ResponseToTs(
123 3 : aicpuSqe, handleId, AicpuDrvManager::GetInstance().GetDeviceId(), static_cast<uint32_t>(aicpuSqe.ts_id));
124 : }
125 :
126 1 : int32_t TsAicpuSqeAdapter::AicpuDataDumpLoadResponseToTs(const int32_t result)
127 : {
128 1 : TsAicpuSqe aicpuSqe{};
129 1 : aicpuSqe.pid = static_cast<uint32_t>(AicpuDrvManager::GetInstance().GetHostPid());
130 1 : aicpuSqe.vf_id = static_cast<uint8_t>(AicpuDrvManager::GetInstance().GetVfId());
131 1 : aicpuSqe.tid = tid_;
132 1 : aicpuSqe.ts_id = tsId_;
133 1 : aicpuSqe.cmd_type = AICPU_DATADUMP_RESPONSE;
134 1 : aicpuSqe.u.aicpu_dump_resp.result_code = static_cast<uint16_t>(result);
135 1 : aicpuSqe.u.aicpu_dump_resp.cmd_type = AICPU_DATADUMP_LOADINFO;
136 1 : aicpuSqe.u.aicpu_dump_resp.task_id = aicpuSqe_.u.ts_to_aicpu_datadumploadinfo.task_id;
137 1 : aicpuSqe.u.aicpu_dump_resp.stream_id = aicpuSqe_.u.ts_to_aicpu_datadumploadinfo.stream_id;
138 1 : aicpuSqe.u.aicpu_dump_resp.reserved = STARS_DATADUMP_LOAD_INFO;
139 1 : aicpusd_info(
140 : "Dump load response: message_type=%u result=%u stream=%u task=%u.", aicpuSqe.cmd_type, result,
141 : aicpuSqe.u.aicpu_dump_resp.stream_id, aicpuSqe.u.aicpu_dump_resp.task_id);
142 1 : return ResponseToTs(
143 3 : aicpuSqe, 0U, AicpuDrvManager::GetInstance().GetDeviceId(), static_cast<uint32_t>(aicpuSqe.ts_id));
144 : }
145 :
146 1 : void TsAicpuSqeAdapter::GetAicpuModelOperateInfo(AicpuModelOperateInfo& info)
147 : {
148 1 : TsAicpuModelOperate tmpInfo = aicpuSqe_.u.aicpu_model_operate;
149 1 : aicpusd_info(
150 : "Model operation request: argument=%p operation=%u model=%u task=%u.", tmpInfo.arg_ptr, tmpInfo.cmd_type,
151 : tmpInfo.model_id, tmpInfo.task_id);
152 1 : info.arg_ptr = tmpInfo.arg_ptr;
153 1 : info.cmd_type = tmpInfo.cmd_type;
154 1 : info.model_id = tmpInfo.model_id;
155 1 : info.stream_id = tmpInfo.sq_id; // sq_id in rts actually is stream id
156 1 : info.task_id = tmpInfo.task_id;
157 1 : info.reserved[0] = tmpInfo.reserved;
158 2 : return;
159 : }
160 :
161 1 : int32_t TsAicpuSqeAdapter::AicpuModelOperateResponseToTs(const int32_t result, const uint32_t subEvent)
162 : {
163 1 : TsAicpuModelOperate tmpInfo = aicpuSqe_.u.aicpu_model_operate;
164 1 : TsAicpuSqe aicpuSqe = {};
165 1 : aicpuSqe.pid = static_cast<uint32_t>(AicpuDrvManager::GetInstance().GetHostPid());
166 1 : aicpuSqe.cmd_type = AICPU_MODEL_OPERATE_RESPONSE;
167 1 : aicpuSqe.vf_id = vfId_;
168 1 : aicpuSqe.tid = tid_;
169 1 : aicpuSqe.ts_id = tsId_;
170 1 : aicpuSqe.u.aicpu_model_operate_resp.cmd_type = AICPU_MODEL_OPERATE;
171 1 : aicpuSqe.u.aicpu_model_operate_resp.sub_cmd_type = tmpInfo.cmd_type;
172 1 : aicpuSqe.u.aicpu_model_operate_resp.model_id = tmpInfo.model_id;
173 1 : aicpuSqe.u.aicpu_model_operate_resp.result_code = static_cast<uint16_t>(result);
174 1 : aicpuSqe.u.aicpu_model_operate_resp.task_id = tmpInfo.task_id;
175 1 : aicpuSqe.u.aicpu_model_operate_resp.sq_id = tmpInfo.sq_id;
176 1 : aicpusd_info("Model operation response: message_type=%u result=%u", cmdType_, result);
177 1 : hwts_response_t hwtsResp = {};
178 1 : hwtsResp.result = static_cast<uint32_t>(result);
179 1 : hwtsResp.status =
180 1 : (result == AICPU_SCHEDULE_OK) ? static_cast<uint32_t>(TASK_SUCC) : static_cast<uint32_t>(TASK_FAIL);
181 1 : hwtsResp.msg = PtrToPtr<TsAicpuSqe, char_t>(&aicpuSqe);
182 1 : hwtsResp.len = static_cast<int32_t>(sizeof(TsAicpuSqe));
183 2 : return ResponseToTs(hwtsResp, AicpuDrvManager::GetInstance().GetDeviceId(), EVENT_TS_CTRL_MSG, subEvent);
184 : }
185 :
186 0 : void TsAicpuSqeAdapter::AicpuActiveStreamSetMsg(ActiveStreamInfo& info)
187 : {
188 0 : TsAicpuSqe aicpuSqe = {};
189 0 : aicpuSqe.pid = static_cast<uint32_t>(AicpuDrvManager::GetInstance().GetHostPid());
190 0 : aicpuSqe.cmd_type = AICPU_ACTIVE_STREAM;
191 0 : aicpuSqe.vf_id = static_cast<uint8_t>(AicpuDrvManager::GetInstance().GetVfId());
192 0 : aicpuSqe.tid = 0U; // no need tid
193 0 : aicpuSqe.ts_id = info.ts_id;
194 0 : aicpuSqe.u.aicpu_active_stream.stream_id = info.stream_id;
195 0 : aicpuSqe.u.aicpu_active_stream.aicpu_stamp = info.aicpu_stamp;
196 0 : aicpusd_info(
197 : "Active stream update: message_type=%u stream=%u stamp=%u.", aicpuSqe.cmd_type,
198 : aicpuSqe.u.aicpu_active_stream.stream_id, aicpuSqe.u.aicpu_active_stream.aicpu_stamp);
199 0 : AicpuMsgSend::SetTsDevSendMsgAsync(info.device_id, static_cast<uint32_t>(info.ts_id), aicpuSqe, info.handle_id);
200 0 : }
201 :
202 1 : void TsAicpuSqeAdapter::GetAicpuMsgVersionInfo(AicpuMsgVersionInfo& info)
203 : {
204 1 : TsAicpuMsgVersion tmpInfo = aicpuSqe_.u.aicpu_msg_version;
205 1 : aicpusd_info("Version request: magic=%u version=%hu.", tmpInfo.magic_num, tmpInfo.version);
206 1 : info.magic_num = tmpInfo.magic_num;
207 1 : info.version = tmpInfo.version;
208 1 : }
209 :
210 1 : int32_t TsAicpuSqeAdapter::AicpuMsgVersionResponseToTs(const int32_t result)
211 : {
212 1 : TsAicpuMsgInfo msgInfo{};
213 1 : msgInfo.pid = static_cast<uint32_t>(AicpuDrvManager::GetInstance().GetHostPid());
214 1 : msgInfo.vf_id = static_cast<uint8_t>(AicpuDrvManager::GetInstance().GetVfId());
215 1 : msgInfo.tid = tid_;
216 1 : msgInfo.ts_id = tsId_;
217 1 : msgInfo.cmd_type = cmdType_;
218 1 : msgInfo.u.aicpu_resp.result_code = static_cast<uint16_t>(result);
219 1 : msgInfo.u.aicpu_resp.task_id = INVALID_VALUE32;
220 1 : aicpusd_info(
221 : "Version response: message_type=%u result=%u stream=%u task=%u.", msgInfo.cmd_type,
222 : msgInfo.u.aicpu_resp.result_code, msgInfo.u.aicpu_resp.stream_id, msgInfo.u.aicpu_resp.task_id);
223 1 : return ResponseToTs(
224 3 : msgInfo, 0U, AicpuDrvManager::GetInstance().GetDeviceId(), static_cast<uint32_t>(msgInfo.ts_id));
225 : }
226 :
227 1 : void TsAicpuSqeAdapter::GetAicpuTaskReportInfo(AicpuTaskReportInfo& info)
228 : {
229 1 : TsToAicpuTaskReport tmpInfo = aicpuSqe_.u.ts_to_aicpu_task_report;
230 1 : aicpusd_info(
231 : "Task report request: task=%u model=%u result=%u stream=%u", tmpInfo.task_id, tmpInfo.model_id,
232 : tmpInfo.result_code, tmpInfo.stream_id);
233 1 : info.task_id = tmpInfo.task_id;
234 1 : info.model_id = tmpInfo.model_id;
235 1 : info.stream_id = tmpInfo.stream_id;
236 1 : info.result_code = tmpInfo.result_code;
237 1 : }
238 1 : int32_t TsAicpuSqeAdapter::ErrorMsgResponseToTs(ErrMsgRspInfo& rspInfo)
239 : {
240 1 : TsAicpuSqe aicpuSqe{};
241 1 : aicpuSqe.pid = static_cast<uint32_t>(AicpuDrvManager::GetInstance().GetHostPid());
242 1 : aicpuSqe.cmd_type = AICPU_ERR_MSG_REPORT;
243 1 : aicpuSqe.vf_id = static_cast<uint8_t>(AicpuDrvManager::GetInstance().GetVfId());
244 1 : aicpuSqe.tid = 0U; // no need tid
245 1 : aicpuSqe.ts_id = static_cast<uint8_t>(rspInfo.ts_id);
246 1 : aicpuSqe.u.aicpu_err_msg_report.result_code = rspInfo.err_code;
247 1 : aicpuSqe.u.aicpu_err_msg_report.stream_id = static_cast<uint16_t>(rspInfo.stream_id);
248 1 : aicpuSqe.u.aicpu_err_msg_report.task_id = static_cast<uint16_t>(rspInfo.task_id);
249 1 : aicpuSqe.u.aicpu_err_msg_report.offset = static_cast<uint16_t>(rspInfo.offset);
250 1 : aicpusd_info(
251 : "Error response: message_type=%u result=%u response_stream=%u response_task=%u", aicpuSqe.cmd_type,
252 : rspInfo.err_code, rspInfo.stream_id, rspInfo.task_id);
253 1 : return ResponseToTs(
254 1 : aicpuSqe, rspInfo.model_id, AicpuDrvManager::GetInstance().GetDeviceId(),
255 3 : static_cast<uint32_t>(aicpuSqe.ts_id));
256 : }
257 :
258 0 : int32_t TsAicpuSqeAdapter::AicpuNoticeTsPidResponse(const uint32_t deviceId) const
259 : {
260 0 : TsAicpuSqe aicpuSqe = {};
261 0 : aicpuSqe.pid = static_cast<uint32_t>(AicpuDrvManager::GetInstance().GetHostPid()); // host pid
262 0 : aicpuSqe.cmd_type = AICPU_NOTICE_TS_PID;
263 0 : aicpuSqe.vf_id = static_cast<uint8_t>(AicpuDrvManager::GetInstance().GetVfId());
264 0 : aicpusd_info("Notice TS pid response: device_id=%u pid=%u vf=%u.", deviceId, aicpuSqe.pid, aicpuSqe.vf_id);
265 0 : return ResponseToTs(aicpuSqe, 0U, deviceId, 0U);
266 : }
267 :
268 1 : void TsAicpuSqeAdapter::GetAicpuTimeOutConfigInfo(AicpuTimeOutConfigInfo& info)
269 : {
270 1 : aicpusd_info("Get timeout config.");
271 1 : info.i = aicpuSqe_.u.ts_to_aicpu_timeout_cfg;
272 1 : return;
273 : }
274 :
275 1 : int32_t TsAicpuSqeAdapter::AicpuTimeOutConfigResponseToTs(const int32_t result)
276 : {
277 1 : TsAicpuSqe aicpuSqe{};
278 1 : aicpuSqe.pid = static_cast<uint32_t>(AicpuDrvManager::GetInstance().GetHostPid());
279 1 : aicpuSqe.cmd_type = AICPU_TIMEOUT_CONFIG_RESPONSE;
280 1 : aicpuSqe.vf_id = static_cast<uint8_t>(AicpuDrvManager::GetInstance().GetVfId());
281 1 : aicpuSqe.tid = tid_;
282 1 : aicpuSqe.ts_id = tsId_;
283 1 : aicpuSqe.u.aicpu_timeout_cfg_resp.result = result;
284 1 : aicpusd_info("Timeout config response: message_type=%u result=%u.", aicpuSqe.cmd_type, result);
285 2 : return ResponseToTs(aicpuSqe, 0U, AicpuDrvManager::GetInstance().GetDeviceId(), aicpuSqe.ts_id);
286 : }
287 :
288 1 : void TsAicpuSqeAdapter::GetAicpuInfoLoad(AicpuInfoLoad& info)
289 : {
290 1 : TsToAicpuInfoLoad tmpinfo = aicpuSqe_.u.ts_to_aicpu_info;
291 1 : aicpusd_info(
292 : "Info load request: address=%p length=%u stream=%u task=%u", tmpinfo.aicpuInfoPtr, tmpinfo.length,
293 : tmpinfo.stream_id, tmpinfo.task_id);
294 1 : info.aicpuInfoPtr = tmpinfo.aicpuInfoPtr;
295 1 : info.length = tmpinfo.length;
296 1 : info.stream_id = tmpinfo.stream_id;
297 1 : info.task_id = tmpinfo.task_id;
298 1 : }
299 :
300 1 : int32_t TsAicpuSqeAdapter::AicpuInfoLoadResponseToTs(const int32_t result)
301 : {
302 1 : TsAicpuSqe aicpuSqe{};
303 1 : TsToAicpuInfoLoad tmpInfo = aicpuSqe_.u.ts_to_aicpu_info;
304 1 : aicpuSqe.pid = static_cast<uint32_t>(AicpuDrvManager::GetInstance().GetHostPid());
305 1 : aicpuSqe.tid = tid_;
306 1 : aicpuSqe.ts_id = tsId_;
307 1 : aicpuSqe.vf_id = static_cast<uint8_t>(AicpuDrvManager::GetInstance().GetVfId());
308 1 : aicpuSqe.cmd_type = AICPU_INFO_LOAD_RESPONSE;
309 1 : aicpuSqe.u.aicpu_resp.cmd_type = AICPU_INFO_LOAD;
310 1 : aicpuSqe.u.aicpu_resp.task_id = tmpInfo.task_id;
311 1 : aicpuSqe.u.aicpu_resp.result_code = static_cast<uint16_t>(result);
312 1 : aicpuSqe.u.aicpu_resp.stream_id = tmpInfo.stream_id;
313 1 : aicpusd_info(
314 : "Info load response: message_type=%u result=%u stream=%u task=%u.", aicpuSqe.cmd_type, result,
315 : tmpInfo.stream_id, tmpInfo.task_id);
316 1 : return ResponseToTs(
317 3 : aicpuSqe, 0U, AicpuDrvManager::GetInstance().GetDeviceId(), static_cast<uint32_t>(aicpuSqe.ts_id));
318 : }
319 :
320 1 : void TsAicpuSqeAdapter::GetAicErrReportInfo(AicErrReportInfo& info)
321 : {
322 1 : aicpusd_info("Get AIC error report info.");
323 1 : info.u.aicError = aicpuSqe_.u.ts_to_aicpu_aic_err_report;
324 1 : return;
325 : }
326 :
327 2 : int32_t TsAicpuSqeAdapter::AicpuRecordResponseToTs(AicpuRecordInfo& info)
328 : {
329 : TsAicpuSqe aicpuSqe;
330 2 : aicpuSqe.pid = static_cast<uint32_t>(AicpuDrvManager::GetInstance().GetHostPid());
331 2 : aicpuSqe.cmd_type = AICPU_RECORD;
332 2 : aicpuSqe.vf_id = static_cast<uint8_t>(AicpuDrvManager::GetInstance().GetVfId());
333 2 : aicpuSqe.tid = 0U; // notify is no need tid
334 2 : aicpuSqe.ts_id = info.ts_id;
335 2 : aicpuSqe.u.aicpu_record.record_type = info.record_type;
336 2 : aicpuSqe.u.aicpu_record.record_id = info.record_id;
337 2 : aicpuSqe.u.aicpu_record.fault_task_id = info.fault_task_id;
338 2 : aicpuSqe.u.aicpu_record.fault_stream_id = info.fault_stream_id;
339 2 : aicpuSqe.u.aicpu_record.ret_code = info.ret_code;
340 2 : const bool retSucc = info.ret_code == 0U ? true : false;
341 2 : aicpusd_info(
342 : "Record response: pid=%u message_type=%u vf=%u tid=%u ts=%u record_type=%u "
343 : "record_id=%u fault_task=%u fault_stream=%u result=%u",
344 : aicpuSqe.pid, aicpuSqe.cmd_type, aicpuSqe.vf_id, aicpuSqe.tid, aicpuSqe.ts_id,
345 : aicpuSqe.u.aicpu_record.record_type, aicpuSqe.u.aicpu_record.record_id, aicpuSqe.u.aicpu_record.fault_task_id,
346 : aicpuSqe.u.aicpu_record.fault_stream_id, aicpuSqe.u.aicpu_record.ret_code);
347 2 : if (!retSucc) {
348 1 : return ResponseToTs(aicpuSqe, 0U, info.dev_id, static_cast<uint32_t>(info.ts_id));
349 : }
350 1 : aicpusd_info("Record response: path=halTsDevRecord.");
351 2 : int32_t ret = halTsDevRecord(
352 1 : info.dev_id, static_cast<uint32_t>(info.ts_id), static_cast<uint32_t>(info.record_type), info.record_id);
353 1 : if (static_cast<uint32_t>(ret) != static_cast<uint32_t>(DRV_ERROR_NONE)) {
354 0 : aicpusd_err(
355 : "Record notify failed: send_ret=%d notify_id=%u response_result=%d.", ret, info.record_id, info.ret_code);
356 0 : return AICPU_SCHEDULE_ERROR_FROM_DRV;
357 : }
358 1 : return AICPU_SCHEDULE_OK;
359 : }
360 : } // namespace AicpuSchedule
|
