1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 *
4 * HDF is dual licensed: you can use it either under the terms of
5 * the GPL, or the BSD license, at your option.
6 * See the LICENSE file in the root of this repository for complete details.
7 */
8
9 #include "audio_parse.h"
10 #include "audio_driver_log.h"
11
12 #define HDF_LOG_TAG HDF_AUDIO_KADM
13
14 enum AudioRegCfgIndex {
15 AUDIO_REG_CFG_REG_INDEX = 0,
16 AUDIO_REG_CFG_RREG_INDEX,
17 AUDIO_REG_CFG_SHIFT_INDEX,
18 AUDIO_REG_CFG_RSHIFT_INDEX,
19 AUDIO_REG_CFG_MIN_INDEX,
20 AUDIO_REG_CFG_MAX_INDEX,
21 AUDIO_REG_CFG_MASK_INDEX,
22 AUDIO_REG_CFG_INVERT_INDEX,
23 AUDIO_REG_CFG_VALUE_INDEX,
24 AUDIO_REG_CFG_INDEX_MAX
25 };
26
27 enum AudioEnumRegCfgIndex {
28 AUDIO_ENUM_REG_CFG_REG_INDEX = 0,
29 AUDIO_ENUM_REG_CFG_RREG_INDEX,
30 AUDIO_ENUM_REG_CFG_SHIFT_INDEX,
31 AUDIO_ENUM_REG_CFG_RSHIFT_INDEX,
32 AUDIO_ENUM_REG_CFG_MAX_INDEX,
33 AUDIO_ENUM_REG_CFG_MASK_INDEX,
34 AUDIO_ENUM_REG_CFG_TEXTS_INDEX,
35 AUDIO_ENUM_REG_CFG_VALUE_INDEX,
36 AUDIO_ENUM_REG_CFG_SAPM_INDEX,
37 AUDIO_ENUM_REG_CFG_INDEX_MAX
38 };
39
40 enum AudioAddrCfgIndex {
41 AUDIO_ADDR_CFG_REG_INDEX = 0,
42 AUDIO_ADDR_CFG_VALUE_INDEX,
43 AUDIO_ADDR_CFG_INDEX_MAX
44 };
45
46 enum AudioCrtlCfgIndex {
47 AUDIO_CTRL_CFG_INDEX_INDEX = 0,
48 AUDIO_CTRL_CFG_IFACE_INDEX,
49 AUDIO_CTRL_CFG_TYPE_INDEX,
50 AUDIO_CTRL_CFG_ENABLE_INDEX,
51 AUDIO_CTRL_CFG_INDEX_MAX
52 };
53
54 enum AudioSapmComponentIndex {
55 AUDIO_SAPM_COMP_INDEX_TYPE = 0,
56 AUDIO_SAPM_COMP_INDEX_NAME,
57 AUDIO_SAPM_COMP_INDEX_REG,
58 AUDIO_SAPM_COMP_INDEX_MASK,
59 AUDIO_SAPM_COMP_INDEX_SHIFT,
60 AUDIO_SAPM_COMP_INDEX_INVERT,
61 AUDIO_SAPM_COMP_INDEX_KCTL,
62 AUDIO_SAPM_COMP_INDEX_KCTLNUM,
63 AUDIO_SAPM_COMP_INDEX_MAX
64 };
65
66
67 static char *g_audioRegGroupName[AUDIO_GROUP_MAX] = {
68 "resetSeqConfig",
69 "initSeqConfig",
70 "ctrlParamsSeqConfig",
71 "ctrlParamsMuxSeqConfig",
72 "ctrlSapmParamsSeqConfig",
73 "ctrlSapmMuxParamsSeqConfig",
74 "daiStartupSeqConfig",
75 "daiParamsSeqConfig",
76 "daiTriggerSeqConfig",
77 "controlsConfig",
78 "sapmComponent",
79 "sapmConfig"
80 };
81
AudioFillConfigData(const struct HdfDeviceObject * device,struct AudioConfigData * configData)82 int32_t AudioFillConfigData(const struct HdfDeviceObject *device, struct AudioConfigData *configData)
83 {
84 const struct DeviceResourceNode *node = NULL;
85 struct DeviceResourceIface *drsOps = NULL;
86 int32_t serviceRet;
87 int32_t codecRet;
88 int32_t platformRet;
89 int32_t cpuRet;
90 int32_t codeDaiRet;
91 int32_t dspRet;
92 int32_t dspDaiRet;
93 ADM_LOG_DEBUG("Entry.");
94
95 if (device == NULL || configData == NULL) {
96 ADM_LOG_ERR("Input para check error: device=%p, configData=%p.", device, configData);
97 return HDF_FAILURE;
98 }
99
100 node = device->property;
101 if (node == NULL) {
102 ADM_LOG_ERR("drs node is NULL.");
103 return HDF_FAILURE;
104 }
105 drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
106 if (drsOps == NULL || drsOps->GetString == NULL) {
107 ADM_LOG_ERR("AudioFillConfigData: invalid drs ops fail!");
108 return HDF_FAILURE;
109 }
110
111 serviceRet = drsOps->GetString(node, "serviceName", &(configData->cardServiceName), 0);
112 codecRet = drsOps->GetString(node, "codecName", &(configData->codecName), 0);
113 platformRet = drsOps->GetString(node, "platformName", &(configData->platformName), 0);
114 cpuRet = drsOps->GetString(node, "cpuDaiName", &(configData->cpuDaiName), 0);
115 codeDaiRet = drsOps->GetString(node, "codecDaiName", &(configData->codecDaiName), 0);
116 dspRet = drsOps->GetString(node, "dspName", &(configData->dspName), 0);
117 dspDaiRet = drsOps->GetString(node, "dspDaiName", &(configData->dspDaiName), 0);
118 if (serviceRet || codecRet || platformRet || cpuRet || codeDaiRet ||
119 dspRet || dspDaiRet) {
120 ADM_LOG_ERR("Read audioDeviceName fail: serviceRet=%d, codecRet=%d, platformRet=%d, cpuRet=%d, codeDaiRet=%d,"
121 "dspRet=%d, dspDaiRet=%d",
122 serviceRet, codecRet, platformRet, cpuRet, codeDaiRet, dspRet, dspDaiRet);
123 return HDF_FAILURE;
124 }
125
126 ADM_LOG_DEBUG("Success! codecName = %s, platformName = %s, cpuDaiName = %s, codecDaiName = %s, "
127 "dspName = %s, dspDaiName = %s.",
128 configData->codecName, configData->platformName, configData->cpuDaiName,
129 configData->codecDaiName, configData->dspName, configData->dspDaiName);
130
131 return HDF_SUCCESS;
132 }
133
GetAudioRegGroupNameIndex(const char * name)134 static uint32_t GetAudioRegGroupNameIndex(const char *name)
135 {
136 uint32_t index;
137
138 if (name == NULL) {
139 return AUDIO_GROUP_MAX;
140 }
141
142 for (index = 0; index < AUDIO_GROUP_MAX; ++index) {
143 if ((g_audioRegGroupName[index] != NULL) && (strcmp(name, g_audioRegGroupName[index]) == 0)) {
144 break;
145 }
146 }
147
148 return index;
149 }
150
GetRegArray(const struct DeviceResourceIface * parser,const struct DeviceResourceNode * regNode,struct AudioRegCfgGroupNode * group,uint32_t indexMax)151 static uint32_t* GetRegArray(const struct DeviceResourceIface *parser, const struct DeviceResourceNode *regNode,
152 struct AudioRegCfgGroupNode* group, uint32_t indexMax)
153 {
154 int32_t ret;
155 int32_t index;
156 int32_t num;
157 uint32_t *buf;
158 if (group == NULL || parser == NULL || regNode == NULL || indexMax == 0) {
159 ADM_LOG_ERR("Input para check error");
160 return NULL;
161 }
162
163 index = group->groupIndex;
164 if (index >= AUDIO_GROUP_MAX) {
165 ADM_LOG_ERR("Input indexMax=%d error", index);
166 return NULL;
167 }
168
169 num = parser->GetElemNum(regNode, g_audioRegGroupName[index]);
170 if (num <= 0 || num > AUDIO_CONFIG_MAX_ITEM) {
171 ADM_LOG_ERR("parser %s element num failed", g_audioRegGroupName[index]);
172 return NULL;
173 }
174
175 group->itemNum = num / indexMax;
176
177 buf = (uint32_t *)OsalMemCalloc(sizeof(uint32_t) * num);
178 if (buf == NULL) {
179 ADM_LOG_ERR("malloc reg array buf failed!");
180 return NULL;
181 }
182
183 ret = parser->GetUint32Array(regNode, g_audioRegGroupName[index], buf, num, 0);
184 if (ret != HDF_SUCCESS) {
185 ADM_LOG_ERR("parser %s reg array failed", g_audioRegGroupName[index]);
186 OsalMemFree(buf);
187 return NULL;
188 }
189 return buf;
190 }
191
ParseAudioRegItem(const struct DeviceResourceIface * parser,const struct DeviceResourceNode * regNode,struct AudioRegCfgGroupNode * group)192 static int32_t ParseAudioRegItem(const struct DeviceResourceIface *parser, const struct DeviceResourceNode *regNode,
193 struct AudioRegCfgGroupNode* group)
194 {
195 int32_t step;
196 int32_t index;
197 int32_t *buf;
198 if (group == NULL || parser == NULL || regNode == NULL) {
199 ADM_LOG_ERR("Input para check error");
200 return HDF_FAILURE;
201 }
202
203 buf = GetRegArray(parser, regNode, group, AUDIO_REG_CFG_INDEX_MAX);
204 if (buf == NULL) {
205 ADM_LOG_ERR("malloc reg array buf failed!");
206 return HDF_FAILURE;
207 }
208
209 group->regCfgItem =
210 (struct AudioMixerControl*)OsalMemCalloc(group->itemNum * sizeof(*(group->regCfgItem)));
211 if (group->regCfgItem == NULL) {
212 OsalMemFree(buf);
213 ADM_LOG_ERR("malloc audio reg config item failed!");
214 return HDF_ERR_MALLOC_FAIL;
215 }
216
217 for (index = 0; index < group->itemNum; ++index) {
218 step = AUDIO_REG_CFG_INDEX_MAX * index;
219
220 group->regCfgItem[index].reg = buf[step + AUDIO_REG_CFG_REG_INDEX];
221 group->regCfgItem[index].rreg = buf[step + AUDIO_REG_CFG_RREG_INDEX];
222 group->regCfgItem[index].shift = buf[step + AUDIO_REG_CFG_SHIFT_INDEX];
223 group->regCfgItem[index].rshift = buf[step + AUDIO_REG_CFG_RSHIFT_INDEX];
224 group->regCfgItem[index].min = buf[step + AUDIO_REG_CFG_MIN_INDEX];
225 group->regCfgItem[index].max = buf[step + AUDIO_REG_CFG_MAX_INDEX];
226 group->regCfgItem[index].mask = buf[step + AUDIO_REG_CFG_MASK_INDEX];
227 group->regCfgItem[index].invert = buf[step + AUDIO_REG_CFG_INVERT_INDEX];
228 group->regCfgItem[index].value = buf[step + AUDIO_REG_CFG_VALUE_INDEX];
229 }
230 OsalMemFree(buf);
231
232 return HDF_SUCCESS;
233 }
234
ParseAudioEnumRegItem(const struct DeviceResourceIface * parser,const struct DeviceResourceNode * regNode,struct AudioRegCfgGroupNode * group)235 static int32_t ParseAudioEnumRegItem(const struct DeviceResourceIface *parser, const struct DeviceResourceNode *regNode,
236 struct AudioRegCfgGroupNode* group)
237 {
238 int32_t step;
239 int32_t index;
240 int32_t *buf;
241
242 if (group == NULL || parser == NULL || regNode == NULL) {
243 ADM_LOG_ERR("Input para check error");
244 return HDF_FAILURE;
245 }
246
247 buf = GetRegArray(parser, regNode, group, AUDIO_ENUM_REG_CFG_INDEX_MAX);
248 if (buf == NULL) {
249 ADM_LOG_ERR("malloc reg array buf failed!");
250 return HDF_FAILURE;
251 }
252
253 group->regEnumCfgItem =
254 (struct AudioEnumCtrlConfig*)OsalMemCalloc(group->itemNum * sizeof(*(group->regEnumCfgItem)));
255 if (group->regEnumCfgItem == NULL) {
256 OsalMemFree(buf);
257 ADM_LOG_ERR("malloc audio Enum reg config item is failed!");
258 return HDF_ERR_MALLOC_FAIL;
259 }
260
261 for (index = 0; index < group->itemNum; ++index) {
262 step = AUDIO_ENUM_REG_CFG_INDEX_MAX * index;
263
264 group->regEnumCfgItem[index].reg = buf[step + AUDIO_ENUM_REG_CFG_REG_INDEX];
265 group->regEnumCfgItem[index].reg2 = buf[step + AUDIO_ENUM_REG_CFG_RREG_INDEX];
266 group->regEnumCfgItem[index].shiftLeft = buf[step + AUDIO_ENUM_REG_CFG_SHIFT_INDEX];
267 group->regEnumCfgItem[index].shiftRight = buf[step + AUDIO_ENUM_REG_CFG_RSHIFT_INDEX];
268 group->regEnumCfgItem[index].max = buf[step + AUDIO_ENUM_REG_CFG_MAX_INDEX];
269 group->regEnumCfgItem[index].mask = buf[step + AUDIO_ENUM_REG_CFG_MASK_INDEX];
270 group->regEnumCfgItem[index].texts = buf[step + AUDIO_ENUM_REG_CFG_TEXTS_INDEX];
271 group->regEnumCfgItem[index].values = buf[step + AUDIO_ENUM_REG_CFG_VALUE_INDEX];
272 group->regEnumCfgItem[index].sapm = buf[step + AUDIO_ENUM_REG_CFG_SAPM_INDEX];
273 }
274 OsalMemFree(buf);
275
276 return HDF_SUCCESS;
277 }
278
ParseAudioSapmItem(const struct DeviceResourceIface * parser,const struct DeviceResourceNode * regNode,struct AudioRegCfgGroupNode * group)279 static int32_t ParseAudioSapmItem(const struct DeviceResourceIface *parser, const struct DeviceResourceNode *regNode,
280 struct AudioRegCfgGroupNode* group)
281 {
282 int32_t step;
283 int32_t index;
284 uint32_t *buf;
285 if (group == NULL || parser == NULL || regNode == NULL) {
286 ADM_LOG_ERR("Input para check error");
287 return HDF_FAILURE;
288 }
289
290 buf = GetRegArray(parser, regNode, group, AUDIO_SAPM_COMP_INDEX_MAX);
291 if (buf == NULL) {
292 ADM_LOG_ERR("malloc reg array buf failed!");
293 return HDF_FAILURE;
294 }
295
296 group->sapmCompItem =
297 (struct AudioSapmCtrlConfig*)OsalMemCalloc(group->itemNum * sizeof(*(group->sapmCompItem)));
298 if (group->sapmCompItem == NULL) {
299 OsalMemFree(buf);
300 ADM_LOG_ERR("malloc audio reg config item failed!");
301 return HDF_ERR_MALLOC_FAIL;
302 }
303
304 for (index = 0; index < group->itemNum; ++index) {
305 step = AUDIO_SAPM_COMP_INDEX_MAX * index;
306 group->sapmCompItem[index].sapmType = buf[step + AUDIO_SAPM_COMP_INDEX_TYPE];
307 group->sapmCompItem[index].compNameIndex = buf[step + AUDIO_SAPM_COMP_INDEX_NAME];
308 group->sapmCompItem[index].reg = buf[step + AUDIO_SAPM_COMP_INDEX_REG];
309 group->sapmCompItem[index].mask = buf[step + AUDIO_SAPM_COMP_INDEX_MASK];
310 group->sapmCompItem[index].shift = buf[step + AUDIO_SAPM_COMP_INDEX_SHIFT];
311 group->sapmCompItem[index].invert = buf[step + AUDIO_SAPM_COMP_INDEX_INVERT];
312 group->sapmCompItem[index].kcontrolNews = buf[step + AUDIO_SAPM_COMP_INDEX_KCTL];
313 group->sapmCompItem[index].kcontrolsNum = buf[step + AUDIO_SAPM_COMP_INDEX_KCTLNUM];
314 }
315
316 OsalMemFree(buf);
317 return HDF_SUCCESS;
318 }
319
320
ParseAudioCtrlItem(const struct DeviceResourceIface * parser,const struct DeviceResourceNode * regNode,struct AudioRegCfgGroupNode * group)321 static int32_t ParseAudioCtrlItem(const struct DeviceResourceIface *parser, const struct DeviceResourceNode *regNode,
322 struct AudioRegCfgGroupNode* group)
323 {
324 int32_t step;
325 int32_t index;
326 uint32_t *buf;
327 if (parser == NULL || regNode == NULL || group == NULL) {
328 ADM_LOG_ERR("Input para check error");
329 return HDF_FAILURE;
330 }
331
332 buf = GetRegArray(parser, regNode, group, AUDIO_CTRL_CFG_INDEX_MAX);
333 if (buf == NULL) {
334 ADM_LOG_ERR("malloc reg array buf failed!");
335 return HDF_FAILURE;
336 }
337
338 group->ctrlCfgItem =
339 (struct AudioControlConfig*)OsalMemCalloc(group->itemNum * sizeof(*(group->ctrlCfgItem)));
340 if (group->ctrlCfgItem == NULL) {
341 OsalMemFree(buf);
342 ADM_LOG_ERR("malloc audio ctrl config item failed!");
343 return HDF_ERR_MALLOC_FAIL;
344 }
345
346 for (index = 0; index < group->itemNum; ++index) {
347 step = AUDIO_CTRL_CFG_INDEX_MAX * index;
348
349 group->ctrlCfgItem[index].arrayIndex = buf[step + AUDIO_CTRL_CFG_INDEX_INDEX];
350 group->ctrlCfgItem[index].iface = buf[step + AUDIO_CTRL_CFG_IFACE_INDEX];
351 group->ctrlCfgItem[index].type = buf[step + AUDIO_CTRL_CFG_TYPE_INDEX];
352 group->ctrlCfgItem[index].enable = buf[step + AUDIO_CTRL_CFG_ENABLE_INDEX];
353 }
354 OsalMemFree(buf);
355 return HDF_SUCCESS;
356 }
357
ParseAudioAddrItem(const struct DeviceResourceIface * parser,const struct DeviceResourceNode * regNode,struct AudioRegCfgGroupNode * group)358 static int32_t ParseAudioAddrItem(const struct DeviceResourceIface *parser, const struct DeviceResourceNode *regNode,
359 struct AudioRegCfgGroupNode* group)
360 {
361 int32_t step;
362 int32_t index;
363 uint32_t *buf;
364
365 if (parser == NULL || regNode == NULL || group == NULL) {
366 ADM_LOG_ERR("Input para check error.");
367 return HDF_FAILURE;
368 }
369
370 buf = GetRegArray(parser, regNode, group, AUDIO_ADDR_CFG_INDEX_MAX);
371 if (buf == NULL) {
372 ADM_LOG_ERR("malloc reg array buf failed!");
373 return HDF_FAILURE;
374 }
375
376 group->addrCfgItem = (struct AudioAddrConfig*)OsalMemCalloc(group->itemNum * sizeof(*(group->addrCfgItem)));
377 if (group->addrCfgItem == NULL) {
378 OsalMemFree(buf);
379 ADM_LOG_ERR("malloc audio addr config item failed!");
380 return HDF_ERR_MALLOC_FAIL;
381 }
382
383 for (index = 0; index < group->itemNum; ++index) {
384 step = AUDIO_ADDR_CFG_INDEX_MAX * index;
385 group->addrCfgItem[index].addr = buf[step + AUDIO_ADDR_CFG_REG_INDEX];
386 group->addrCfgItem[index].value = buf[step + AUDIO_ADDR_CFG_VALUE_INDEX];
387 }
388 OsalMemFree(buf);
389 return HDF_SUCCESS;
390 }
391
ParseAudioRegGroup(const struct DeviceResourceIface * parser,const struct DeviceResourceNode * regCfgNode,struct AudioRegCfgGroupNode ** groupNode,uint32_t index)392 static int32_t ParseAudioRegGroup(const struct DeviceResourceIface *parser,
393 const struct DeviceResourceNode *regCfgNode, struct AudioRegCfgGroupNode **groupNode, uint32_t index)
394 {
395 int32_t ret = HDF_FAILURE;
396 struct AudioRegCfgGroupNode *group = NULL;
397
398 if (parser == NULL || regCfgNode == NULL || groupNode == NULL) {
399 ADM_LOG_ERR("Input para check error: parser=%p, regCfgNode=%p, groupNode=%p.",
400 parser, regCfgNode, groupNode);
401 return HDF_FAILURE;
402 }
403
404 group = (struct AudioRegCfgGroupNode*)OsalMemCalloc(sizeof(*group));
405 if (group == NULL) {
406 ADM_LOG_ERR("malloc audio reg config group failed");
407 return HDF_ERR_MALLOC_FAIL;
408 }
409 *groupNode = group;
410 (*groupNode)->groupIndex = index;
411
412 switch (index) {
413 case AUDIO_CTRL_CFG_GROUP:
414 case AUDIO_SAPM_CFG_GROUP:
415 ret = ParseAudioCtrlItem(parser, regCfgNode, group);
416 break;
417 case AUDIO_RSET_GROUP:
418 case AUDIO_INIT_GROUP:
419 ret = ParseAudioAddrItem(parser, regCfgNode, group);
420 break;
421 case AUDIO_DAI_PATAM_GROUP:
422 case AUDIO_DAI_TRIGGER_GROUP:
423 case AUDIO_CTRL_PATAM_GROUP:
424 case AUDIO_CTRL_SAPM_PATAM_GROUP:
425 case AUDIO_DAI_STARTUP_PATAM_GROUP:
426 ret = ParseAudioRegItem(parser, regCfgNode, group);
427 break;
428 case AUDIO_CTRL_PATAM_MUX_GROUP:
429 case AUDIO_CTRL_SAPM_PATAM_MUX_GROUP:
430 ret = ParseAudioEnumRegItem(parser, regCfgNode, group);
431 break;
432 case AUDIO_SAPM_COMP_GROUP:
433 ret = ParseAudioSapmItem(parser, regCfgNode, group);
434 break;
435 default:
436 ADM_LOG_ERR("parse audio config index = %u not found!", index);
437 return HDF_FAILURE;
438 }
439
440 if (ret != HDF_SUCCESS) {
441 ADM_LOG_ERR("parse audio config item failed!");
442 return HDF_FAILURE;
443 }
444 return HDF_SUCCESS;
445 }
446
ReleaseAudioAllRegConfig(struct AudioRegCfgData * config)447 static void ReleaseAudioAllRegConfig(struct AudioRegCfgData *config)
448 {
449 int32_t index;
450
451 if (config == NULL) {
452 return;
453 }
454
455 for (index = 0; index < AUDIO_GROUP_MAX; ++index) {
456 if (config->audioRegParams[index] != NULL) {
457 if (config->audioRegParams[index]->regCfgItem != NULL) {
458 OsalMemFree(config->audioRegParams[index]->regCfgItem);
459 config->audioRegParams[index]->regCfgItem = NULL;
460 }
461 OsalMemFree(config->audioRegParams[index]);
462 config->audioRegParams[index] = NULL;
463 }
464 }
465 }
466
ParseAudioAttr(const struct DeviceResourceIface * parser,const struct DeviceResourceNode * attrNode,struct AudioIdInfo * config)467 static int32_t ParseAudioAttr(const struct DeviceResourceIface *parser, const struct DeviceResourceNode *attrNode,
468 struct AudioIdInfo *config)
469 {
470 int32_t ret;
471 ret = parser->GetString(attrNode, "chipName", &config->chipName, NULL);
472 if (ret != HDF_SUCCESS) {
473 ADM_LOG_ERR("parser chipName reg audioIdInfo failed!");
474 return HDF_SUCCESS;
475 }
476
477 ret = parser->GetUint32(attrNode, "chipIdRegister", &config->chipIdRegister, 0);
478 if (ret != HDF_SUCCESS) {
479 ADM_LOG_ERR("parser chipIdRegister reg audioIdInfo failed!");
480 return HDF_SUCCESS;
481 }
482
483 ret = parser->GetUint32(attrNode, "chipIdSize", &config->chipIdSize, 0);
484 if (ret != HDF_SUCCESS) {
485 ADM_LOG_ERR("parser chipIdSize reg audioIdInfo failed!");
486 return HDF_SUCCESS;
487 }
488 return ret;
489 }
490
CodecGetRegConfig(const struct HdfDeviceObject * device,struct AudioRegCfgData * configData)491 int32_t CodecGetRegConfig(const struct HdfDeviceObject *device, struct AudioRegCfgData *configData)
492 {
493 uint16_t index;
494 const struct DeviceResourceNode *regCfgNode = NULL;
495 const struct DeviceResourceAttr *regAttr = NULL;
496 const struct DeviceResourceNode *idNode = NULL;
497 struct DeviceResourceIface *drsOps = NULL;
498
499 if (device == NULL || device->property == NULL || configData == NULL) {
500 ADM_LOG_ERR("Input para check error: device=%p, configData=%p.", device, configData);
501 return HDF_FAILURE;
502 }
503
504 drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
505 if (drsOps == NULL || drsOps->GetString == NULL) {
506 ADM_LOG_ERR("AudioFillConfigData: invalid drs ops fail!");
507 return HDF_FAILURE;
508 }
509
510 idNode = drsOps->GetChildNode(device->property, "idInfo");
511 if (idNode != NULL) {
512 if (ParseAudioAttr(drsOps, idNode, &configData->audioIdInfo) != HDF_SUCCESS) {
513 ADM_LOG_ERR("audio reg node attr is null");
514 return HDF_FAILURE;
515 }
516 }
517
518 regCfgNode = drsOps->GetChildNode(device->property, "regConfig");
519 if (regCfgNode == NULL) {
520 ADM_LOG_ERR("CodecGetRegConfig: Read audioRegConfig fail!");
521 return HDF_FAILURE;
522 }
523
524 DEV_RES_NODE_FOR_EACH_ATTR(regCfgNode, regAttr) {
525 if (regAttr == NULL || regAttr->name == NULL) {
526 ADM_LOG_ERR("audio reg node attr is null");
527 return HDF_FAILURE;
528 }
529
530 index = GetAudioRegGroupNameIndex(regAttr->name);
531 if (index >= AUDIO_GROUP_MAX) {
532 continue;
533 }
534
535 if (ParseAudioRegGroup(drsOps, regCfgNode, &configData->audioRegParams[index], index) != HDF_SUCCESS) {
536 ADM_LOG_ERR("parse audio register group failed");
537 ReleaseAudioAllRegConfig(configData);
538 return HDF_FAILURE;
539 }
540 }
541 return HDF_SUCCESS;
542 }
543