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_core.h"
10 #include "audio_sapm.h"
11 #include "audio_driver_log.h"
12 #include "osal_io.h"
13
14 #define HDF_LOG_TAG HDF_AUDIO_KADM
15
16 #define CHANNEL_MAX_NUM 2
17 #define CHANNEL_MIN_NUM 1
18 #define AUDIO_DAI_LINK_COMPLETE 1
19 #define AUDIO_DAI_LINK_UNCOMPLETE 0
20 #define AUDIO_CTL_ELEM_TYPE_ENUMERATED 3 /* enumerated type */
21
22 AUDIO_LIST_HEAD(daiController);
23 AUDIO_LIST_HEAD(platformController);
24 AUDIO_LIST_HEAD(codecController);
25 AUDIO_LIST_HEAD(dspController);
26
AudioSocRegisterPlatform(struct HdfDeviceObject * device,struct PlatformData * platformData)27 int32_t AudioSocRegisterPlatform(struct HdfDeviceObject *device, struct PlatformData *platformData)
28 {
29 struct PlatformDevice *platformDevice = NULL;
30
31 if (device == NULL) {
32 ADM_LOG_ERR("Input params check error: device is NULL.");
33 return HDF_ERR_INVALID_OBJECT;
34 }
35 if (platformData == NULL) {
36 ADM_LOG_ERR("Input params check error: platformData is NULL.");
37 return HDF_ERR_INVALID_OBJECT;
38 }
39
40 platformDevice = (struct PlatformDevice *)OsalMemCalloc(sizeof(*platformDevice));
41 if (platformDevice == NULL) {
42 ADM_LOG_ERR("Malloc platformDevice device fail!");
43 return HDF_ERR_MALLOC_FAIL;
44 }
45
46 platformDevice->devPlatformName = platformData->drvPlatformName;
47 platformDevice->devData = platformData;
48 platformDevice->device = device;
49 DListInsertHead(&platformDevice->list, &platformController);
50
51 ADM_LOG_INFO("Register [%s] success.", platformDevice->devPlatformName);
52 return HDF_SUCCESS;
53 }
54
AudioSocRegisterDai(struct HdfDeviceObject * device,struct DaiData * daiData)55 int32_t AudioSocRegisterDai(struct HdfDeviceObject *device, struct DaiData *daiData)
56 {
57 struct DaiDevice *dai = NULL;
58
59 if (device == NULL) {
60 ADM_LOG_ERR("Input params check error: device is NULL");
61 return HDF_ERR_INVALID_OBJECT;
62 }
63 if (daiData == NULL) {
64 ADM_LOG_ERR("Input params check error: daiData is NULL");
65 return HDF_ERR_INVALID_OBJECT;
66 }
67
68 dai = (struct DaiDevice *)OsalMemCalloc(sizeof(*dai));
69 if (dai == NULL) {
70 ADM_LOG_ERR("Malloc dai device fail!");
71 return HDF_ERR_MALLOC_FAIL;
72 }
73
74 dai->devDaiName = daiData->drvDaiName;
75 dai->devData = daiData;
76 dai->device = device;
77 DListInsertHead(&dai->list, &daiController);
78 ADM_LOG_INFO("Register [%s] success.", dai->devDaiName);
79
80 return HDF_SUCCESS;
81 }
82
AudioRegisterCodec(struct HdfDeviceObject * device,struct CodecData * codecData,struct DaiData * daiData)83 int32_t AudioRegisterCodec(struct HdfDeviceObject *device, struct CodecData *codecData, struct DaiData *daiData)
84 {
85 struct CodecDevice *codec = NULL;
86 int32_t ret;
87
88 if (device == NULL) {
89 ADM_LOG_ERR("Input params check error: device is NULL.");
90 return HDF_ERR_INVALID_OBJECT;
91 }
92 if (codecData == NULL) {
93 ADM_LOG_ERR("Input params check error: codecData is NULL.");
94 return HDF_ERR_INVALID_OBJECT;
95 }
96 if (daiData == NULL) {
97 ADM_LOG_ERR("Input params check error: daiData is NULL.");
98 return HDF_ERR_INVALID_OBJECT;
99 }
100
101 codec = (struct CodecDevice *)OsalMemCalloc(sizeof(*codec));
102 if (codec == NULL) {
103 ADM_LOG_ERR("Malloc codec device fail!");
104 return HDF_ERR_MALLOC_FAIL;
105 }
106
107 codec->devCodecName = codecData->drvCodecName;
108 codec->devData = codecData;
109 codec->device = device;
110
111 ret = AudioSocRegisterDai(device, daiData);
112 if (ret != HDF_SUCCESS) {
113 OsalIoUnmap((void *)((uintptr_t)(codec->devData->virtualAddress)));
114 OsalMemFree(codec);
115 ADM_LOG_ERR("Register dai device fail ret=%d", ret);
116 return HDF_ERR_IO;
117 }
118 DListInsertHead(&codec->list, &codecController);
119 ADM_LOG_INFO("Register [%s] success.", codec->devCodecName);
120
121 return HDF_SUCCESS;
122 }
123
AudioRegisterDsp(struct HdfDeviceObject * device,struct DspData * dspData,struct DaiData * DaiData)124 int32_t AudioRegisterDsp(struct HdfDeviceObject *device, struct DspData *dspData, struct DaiData *DaiData)
125 {
126 struct DspDevice *dspDev = NULL;
127 int32_t ret;
128
129 if (device == NULL) {
130 ADM_LOG_ERR("Input params check error: device is NULL.");
131 return HDF_ERR_INVALID_OBJECT;
132 }
133 if (dspData == NULL) {
134 ADM_LOG_ERR("Input params check error: dspData is NULL.");
135 return HDF_ERR_INVALID_OBJECT;
136 }
137 if (DaiData == NULL) {
138 ADM_LOG_ERR("Input params check error: daiData is NULL.");
139 return HDF_ERR_INVALID_OBJECT;
140 }
141
142 dspDev = (struct DspDevice *)OsalMemCalloc(sizeof(*dspDev));
143 if (dspDev == NULL) {
144 ADM_LOG_ERR("Malloc codec device fail!");
145 return HDF_ERR_MALLOC_FAIL;
146 }
147
148 dspDev->devDspName = dspData->drvDspName;
149 dspDev->devData = dspData;
150 dspDev->device = device;
151
152 ret = AudioSocRegisterDai(device, DaiData);
153 if (ret != HDF_SUCCESS) {
154 OsalMemFree(dspDev);
155 ADM_LOG_ERR("Register dai device fail ret=%d", ret);
156 return HDF_ERR_IO;
157 }
158 DListInsertHead(&dspDev->list, &dspController);
159 ADM_LOG_INFO("Register [%s] success.", dspDev->devDspName);
160
161 return HDF_SUCCESS;
162 }
163
AudioSeekPlatformDevice(struct AudioRuntimeDeivces * rtd,const struct AudioConfigData * configData)164 static int32_t AudioSeekPlatformDevice(struct AudioRuntimeDeivces *rtd, const struct AudioConfigData *configData)
165 {
166 struct PlatformDevice *platform = NULL;
167 if (rtd == NULL || configData == NULL) {
168 ADM_LOG_ERR("Input params check error: rtd=%p, configData=%p.", rtd, configData);
169 return HDF_ERR_INVALID_OBJECT;
170 }
171 if (configData->platformName == NULL) {
172 ADM_LOG_ERR("Input devicesName check error: configData->platformName is NULL.");
173 return HDF_ERR_INVALID_OBJECT;
174 }
175
176 DLIST_FOR_EACH_ENTRY(platform, &platformController, struct PlatformDevice, list) {
177 if (platform->devPlatformName != NULL &&
178 strcmp(platform->devPlatformName, configData->platformName) == 0) {
179 rtd->platform = platform;
180 break;
181 }
182 }
183
184 return HDF_SUCCESS;
185 }
186
AudioSeekCpuDaiDevice(struct AudioRuntimeDeivces * rtd,const struct AudioConfigData * configData)187 static int32_t AudioSeekCpuDaiDevice(struct AudioRuntimeDeivces *rtd, const struct AudioConfigData *configData)
188 {
189 struct DaiDevice *cpuDai = NULL;
190 if (rtd == NULL || configData == NULL) {
191 ADM_LOG_ERR("Input params check error: rtd=%p, configData=%p.", rtd, configData);
192 return HDF_ERR_INVALID_OBJECT;
193 }
194 if (configData->cpuDaiName == NULL) {
195 ADM_LOG_ERR("Input cpuDaiName check error: configData->cpuDaiName is NULL.");
196 return HDF_ERR_INVALID_OBJECT;
197 }
198 if (DListIsEmpty(&daiController)) {
199 ADM_LOG_ERR("daiController is empty.");
200 return HDF_FAILURE;
201 }
202 DLIST_FOR_EACH_ENTRY(cpuDai, &daiController, struct DaiDevice, list) {
203 if (cpuDai == NULL) {
204 return HDF_ERR_INVALID_OBJECT;
205 }
206 if (cpuDai->devDaiName != NULL &&
207 strcmp(cpuDai->devDaiName, configData->cpuDaiName) == 0) {
208 rtd->cpuDai = cpuDai;
209 break;
210 }
211 }
212
213 return HDF_SUCCESS;
214 }
215
AudioSeekCodecDevice(struct AudioRuntimeDeivces * rtd,const struct AudioConfigData * configData)216 static int32_t AudioSeekCodecDevice(struct AudioRuntimeDeivces *rtd, const struct AudioConfigData *configData)
217 {
218 struct CodecDevice *codec = NULL;
219 struct DaiDevice *codecDai = NULL;
220 if ((rtd == NULL) || (configData == NULL)) {
221 ADM_LOG_ERR("Input params check error: rtd=%p, configData=%p.", rtd, configData);
222 return HDF_ERR_INVALID_OBJECT;
223 }
224 if (configData->codecName == NULL) {
225 ADM_LOG_ERR("Input devicesName check error: configData->codecName is NULL.");
226 return HDF_ERR_INVALID_OBJECT;
227 }
228 if (configData->codecDaiName == NULL) {
229 ADM_LOG_ERR("Input devicesName check error: configData->codecDaiName is NULL.");
230 return HDF_ERR_INVALID_OBJECT;
231 }
232
233 DLIST_FOR_EACH_ENTRY(codec, &codecController, struct CodecDevice, list) {
234 if (codec->devCodecName != NULL && strcmp(codec->devCodecName, configData->codecName) == 0) {
235 rtd->codec = codec;
236 DLIST_FOR_EACH_ENTRY(codecDai, &daiController, struct DaiDevice, list) {
237 if (codecDai == NULL) {
238 return HDF_ERR_INVALID_OBJECT;
239 }
240 if (codecDai->device != NULL && codec->device == codecDai->device &&
241 codecDai->devDaiName != NULL && strcmp(codecDai->devDaiName, configData->codecDaiName) == 0) {
242 rtd->codecDai = codecDai;
243 break;
244 }
245 }
246 break;
247 }
248 }
249 return HDF_SUCCESS;
250 }
251
AudioSeekDspDevice(struct AudioRuntimeDeivces * rtd,const struct AudioConfigData * configData)252 static int32_t AudioSeekDspDevice(struct AudioRuntimeDeivces *rtd, const struct AudioConfigData *configData)
253 {
254 struct DspDevice *dsp = NULL;
255 struct DaiDevice *dspDai = NULL;
256 if ((rtd == NULL) || (configData == NULL)) {
257 ADM_LOG_ERR("Input params check error: rtd=%p, configData=%p.", rtd, configData);
258 return HDF_ERR_INVALID_OBJECT;
259 }
260 if (configData->dspName == NULL) {
261 ADM_LOG_ERR("Input devicesName check error: configData->dspName is NULL.");
262 return HDF_ERR_INVALID_OBJECT;
263 }
264 if (configData->dspDaiName == NULL) {
265 ADM_LOG_ERR("Input devicesName check error: configData->dspDaiName is NULL.");
266 return HDF_ERR_INVALID_OBJECT;
267 }
268
269 DLIST_FOR_EACH_ENTRY(dsp, &dspController, struct DspDevice, list) {
270 if (dsp == NULL) {
271 return HDF_ERR_INVALID_OBJECT;
272 }
273 if (dsp->devDspName != NULL && strcmp(dsp->devDspName, configData->dspName) == 0) {
274 rtd->dsp = dsp;
275 DLIST_FOR_EACH_ENTRY(dspDai, &daiController, struct DaiDevice, list) {
276 if (dspDai == NULL) {
277 return HDF_ERR_INVALID_OBJECT;
278 }
279 if (dspDai->device != NULL && dsp->device == dspDai->device &&
280 dspDai->devDaiName != NULL && strcmp(dspDai->devDaiName, configData->dspDaiName) == 0) {
281 rtd->dspDai = dspDai;
282 break;
283 }
284 }
285 break;
286 }
287 }
288
289 return HDF_SUCCESS;
290 }
291
AudioBindDaiLink(struct AudioCard * audioCard,const struct AudioConfigData * configData)292 int32_t AudioBindDaiLink(struct AudioCard *audioCard, const struct AudioConfigData *configData)
293 {
294 if (audioCard == NULL) {
295 ADM_LOG_ERR("Input params check error: audioCard is NULL.");
296 return HDF_ERR_INVALID_OBJECT;
297 }
298 if (configData == NULL) {
299 ADM_LOG_ERR("Input params check error: configData is NULL.");
300 return HDF_ERR_INVALID_OBJECT;
301 }
302
303 audioCard->rtd = (struct AudioRuntimeDeivces *)OsalMemCalloc(sizeof(struct AudioRuntimeDeivces));
304 if (audioCard->rtd == NULL) {
305 ADM_LOG_ERR("Malloc audioCard->rtd fail!");
306 return HDF_ERR_MALLOC_FAIL;
307 }
308
309 audioCard->rtd->complete = AUDIO_DAI_LINK_UNCOMPLETE;
310 if (AudioSeekPlatformDevice(audioCard->rtd, configData) == HDF_SUCCESS) {
311 ADM_LOG_DEBUG("PLATFORM [%s] is registered!", configData->platformName);
312 }
313 if (AudioSeekCpuDaiDevice(audioCard->rtd, configData) == HDF_SUCCESS) {
314 ADM_LOG_DEBUG("CPU DAI [%s] is registered!", configData->cpuDaiName);
315 }
316 if (AudioSeekCodecDevice(audioCard->rtd, configData) == HDF_SUCCESS) {
317 ADM_LOG_DEBUG("CODEC [%s] is registered!", configData->codecName);
318 }
319 if (AudioSeekDspDevice(audioCard->rtd, configData) == HDF_SUCCESS) {
320 ADM_LOG_DEBUG("CODEC [%s] is registered!", configData->dspName);
321 }
322 audioCard->rtd->complete = AUDIO_DAI_LINK_COMPLETE;
323 ADM_LOG_DEBUG("All devices register complete!");
324
325 return HDF_SUCCESS;
326 }
327
AudioDaiReadReg(const struct DaiDevice * dai,uint32_t reg,uint32_t * val)328 int32_t AudioDaiReadReg(const struct DaiDevice *dai, uint32_t reg, uint32_t *val)
329 {
330 int32_t ret;
331
332 if (dai == NULL || dai->devData == NULL || dai->devData->Read == NULL || val == NULL) {
333 ADM_LOG_ERR("Input param is NULL.");
334 return HDF_ERR_INVALID_OBJECT;
335 }
336
337 ret = dai->devData->Read(dai, reg, val);
338 if (ret != HDF_SUCCESS) {
339 ADM_LOG_ERR("dai device read fail.");
340 return HDF_FAILURE;
341 }
342 return HDF_SUCCESS;
343 }
344
AudioDaiWriteReg(const struct DaiDevice * dai,uint32_t reg,uint32_t val)345 int32_t AudioDaiWriteReg(const struct DaiDevice *dai, uint32_t reg, uint32_t val)
346 {
347 int32_t ret;
348 if (dai == NULL || dai->devData == NULL || dai->devData->Write == NULL) {
349 ADM_LOG_ERR("Input param codec is NULL.");
350 return HDF_ERR_INVALID_OBJECT;
351 }
352
353 ret = dai->devData->Write(dai, reg, val);
354 if (ret != HDF_SUCCESS) {
355 ADM_LOG_ERR("dai device write fail.");
356 return HDF_FAILURE;
357 }
358 return HDF_SUCCESS;
359 }
360
AudioCodecReadReg(const struct CodecDevice * codec,uint32_t reg,uint32_t * val)361 int32_t AudioCodecReadReg(const struct CodecDevice *codec, uint32_t reg, uint32_t *val)
362 {
363 int32_t ret;
364
365 if (codec == NULL || codec->devData == NULL || codec->devData->Read == NULL || val == NULL) {
366 ADM_LOG_ERR("Input param codec is NULL.");
367 return HDF_ERR_INVALID_OBJECT;
368 }
369
370 ret = codec->devData->Read(codec, reg, val);
371 if (ret != HDF_SUCCESS) {
372 ADM_LOG_ERR("Codec device read fail.");
373 return HDF_FAILURE;
374 }
375 return HDF_SUCCESS;
376 }
377
AudioCodecWriteReg(const struct CodecDevice * codec,uint32_t reg,uint32_t val)378 int32_t AudioCodecWriteReg(const struct CodecDevice *codec, uint32_t reg, uint32_t val)
379 {
380 int32_t ret;
381
382 if (codec == NULL || codec->devData == NULL || codec->devData->Write == NULL) {
383 ADM_LOG_ERR("Input param codec is NULL.");
384 return HDF_ERR_INVALID_OBJECT;
385 }
386
387 ret = codec->devData->Write(codec, reg, val);
388 if (ret != HDF_SUCCESS) {
389 ADM_LOG_ERR("Codec device write fail.");
390 return HDF_FAILURE;
391 }
392 return HDF_SUCCESS;
393 }
394
AudioUpdateCodecRegBits(struct CodecDevice * codec,uint32_t reg,const uint32_t mask,const uint32_t shift,uint32_t value)395 int32_t AudioUpdateCodecRegBits(struct CodecDevice *codec, uint32_t reg,
396 const uint32_t mask, const uint32_t shift, uint32_t value)
397 {
398 int32_t ret;
399 uint32_t curValue = 0;
400 uint32_t controlMask;
401 uint32_t tempVal;
402 if (codec == NULL || codec->devData == NULL) {
403 ADM_LOG_ERR("Invalid input param.");
404 return HDF_ERR_INVALID_OBJECT;
405 }
406
407 value = value << shift;
408 controlMask = mask << shift;
409
410 OsalMutexLock(&codec->devData->mutex);
411 ret = AudioCodecReadReg(codec, reg, &curValue);
412 if (ret != HDF_SUCCESS) {
413 OsalMutexUnlock(&codec->devData->mutex);
414 ADM_LOG_ERR("Read reg fail ret=%d.", ret);
415 return HDF_FAILURE;
416 }
417
418 tempVal = curValue & controlMask;
419 if (tempVal == value) {
420 OsalMutexUnlock(&codec->devData->mutex);
421 ADM_LOG_DEBUG("Success.");
422 return HDF_SUCCESS;
423 }
424 curValue = (curValue & ~controlMask) | (value & controlMask);
425 ret = AudioCodecWriteReg(codec, reg, curValue);
426 if (ret != HDF_SUCCESS) {
427 OsalMutexUnlock(&codec->devData->mutex);
428 ADM_LOG_ERR("Write reg fail ret=%d", ret);
429 return HDF_FAILURE;
430 }
431 OsalMutexUnlock(&codec->devData->mutex);
432
433 ADM_LOG_DEBUG("Success.");
434 return HDF_SUCCESS;
435 }
436
AudioUpdateDaiRegBits(const struct DaiDevice * dai,uint32_t reg,const uint32_t mask,const uint32_t shift,uint32_t value)437 int32_t AudioUpdateDaiRegBits(const struct DaiDevice *dai, uint32_t reg,
438 const uint32_t mask, const uint32_t shift, uint32_t value)
439 {
440 int32_t ret;
441 uint32_t curValue = 0;
442 uint32_t mixerControlMask;
443 uint32_t tempVal;
444 struct DaiData *data = NULL;
445
446 if (dai == NULL || dai->devData == NULL) {
447 ADM_LOG_ERR("Invalid input param.");
448 return HDF_ERR_INVALID_OBJECT;
449 }
450 data = dai->devData;
451 value = value << shift;
452 mixerControlMask = mask << shift;
453
454 OsalMutexLock(&data->mutex);
455 ret = AudioDaiReadReg(dai, reg, &curValue);
456 if (ret != HDF_SUCCESS) {
457 OsalMutexUnlock(&data->mutex);
458 ADM_LOG_ERR("Read reg fail ret=%d.", ret);
459 return HDF_FAILURE;
460 }
461
462 tempVal = curValue & mixerControlMask;
463 if (tempVal == value) {
464 OsalMutexUnlock(&data->mutex);
465 ADM_LOG_DEBUG("Success.");
466 return HDF_SUCCESS;
467 }
468 curValue = (curValue & ~mixerControlMask) | (value & mixerControlMask);
469 ret = AudioDaiWriteReg(dai, reg, curValue);
470 if (ret != HDF_SUCCESS) {
471 OsalMutexUnlock(&data->mutex);
472 ADM_LOG_ERR("Write reg fail ret=%d", ret);
473 return HDF_FAILURE;
474 }
475 OsalMutexUnlock(&data->mutex);
476
477 ADM_LOG_DEBUG("Success.");
478 return HDF_SUCCESS;
479 }
480
AudioCodecRegUpdate(struct CodecDevice * codec,struct AudioMixerControl * mixerCtrl)481 int32_t AudioCodecRegUpdate(struct CodecDevice *codec, struct AudioMixerControl *mixerCtrl)
482 {
483 uint32_t mixerValue;
484 if (codec == NULL || mixerCtrl == NULL) {
485 ADM_LOG_ERR("AudioKcontrolGetCodec is fail.");
486 return HDF_ERR_INVALID_OBJECT;
487 }
488
489 mixerValue = mixerCtrl->value;
490 if (mixerValue < mixerCtrl->min || mixerValue > mixerCtrl->max) {
491 ADM_LOG_ERR("Audio codec invalid value=%u", mixerValue);
492 return HDF_ERR_INVALID_OBJECT;
493 }
494
495 if (mixerCtrl->invert) {
496 mixerValue = mixerCtrl->max - mixerCtrl->value;
497 }
498 if (AudioUpdateCodecRegBits(codec, mixerCtrl->reg, mixerCtrl->mask, mixerCtrl->shift, mixerValue) != HDF_SUCCESS) {
499 ADM_LOG_ERR("Audio codec stereo update reg bits fail.");
500 return HDF_FAILURE;
501 }
502
503 if (mixerCtrl->reg != mixerCtrl->rreg || mixerCtrl->shift != mixerCtrl->rshift) {
504 if (AudioUpdateCodecRegBits(codec, mixerCtrl->rreg, mixerCtrl->mask,
505 mixerCtrl->rshift, mixerValue) != HDF_SUCCESS) {
506 ADM_LOG_ERR("Audio codec stereo update reg bits fail.");
507 return HDF_FAILURE;
508 }
509 }
510
511 return HDF_SUCCESS;
512 }
513
AudioCodecMuxRegUpdate(struct CodecDevice * codec,struct AudioEnumKcontrol * enumCtrl,const uint32_t * value)514 int32_t AudioCodecMuxRegUpdate(struct CodecDevice *codec, struct AudioEnumKcontrol *enumCtrl, const uint32_t *value)
515 {
516 uint32_t val[2];
517 int32_t ret;
518
519 if (codec == NULL || enumCtrl == NULL || value == NULL) {
520 ADM_LOG_ERR("input para is null.");
521 return HDF_ERR_INVALID_OBJECT;
522 }
523
524 if (enumCtrl->values != NULL) {
525 val[0] = enumCtrl->values[value[0]];
526 val[1] = enumCtrl->values[value[1]];
527 } else {
528 val[0] = value[0];
529 val[1] = value[1];
530 }
531
532 if (val[0] > enumCtrl->max) {
533 ADM_LOG_ERR("Audio invalid value=%u", val[0]);
534 return HDF_ERR_INVALID_OBJECT;
535 }
536 ret = AudioUpdateCodecRegBits(codec, enumCtrl->reg, enumCtrl->mask, enumCtrl->shiftLeft, val[0]);
537 if (ret != HDF_SUCCESS) {
538 ADM_LOG_ERR("update left reg bits fail!");
539 return ret;
540 }
541
542 if (enumCtrl->reg != enumCtrl->reg2 || enumCtrl->shiftLeft != enumCtrl->shiftRight) {
543 if (val[1] > enumCtrl->max) {
544 ADM_LOG_ERR("Audio invalid value=%u", val[1]);
545 return HDF_ERR_INVALID_OBJECT;
546 }
547 ret = AudioUpdateCodecRegBits(codec, enumCtrl->reg2, enumCtrl->mask, enumCtrl->shiftRight, val[1]);
548 if (ret != HDF_SUCCESS) {
549 ADM_LOG_ERR("update right reg bits fail!");
550 return ret;
551 }
552 }
553 return HDF_SUCCESS;
554 }
555
AudioDaiRegUpdate(const struct DaiDevice * dai,struct AudioMixerControl * mixerCtrl)556 int32_t AudioDaiRegUpdate(const struct DaiDevice *dai, struct AudioMixerControl *mixerCtrl)
557 {
558 uint32_t value;
559
560 if (dai == NULL || mixerCtrl == NULL) {
561 ADM_LOG_ERR("AudioKcontrolGetCodec is fail.");
562 return HDF_ERR_INVALID_OBJECT;
563 }
564
565 value = mixerCtrl->value;
566 if (value < mixerCtrl->min || value > mixerCtrl->max) {
567 ADM_LOG_ERR("Audio dai invalid value=%u", value);
568 return HDF_ERR_INVALID_OBJECT;
569 }
570
571 if (mixerCtrl->invert) {
572 value = mixerCtrl->max - mixerCtrl->value;
573 }
574
575 if (AudioUpdateDaiRegBits(dai, mixerCtrl->reg, mixerCtrl->mask, mixerCtrl->shift, value) != HDF_SUCCESS) {
576 ADM_LOG_ERR("Audio codec stereo update reg bits fail.");
577 return HDF_FAILURE;
578 }
579
580 if (mixerCtrl->reg != mixerCtrl->rreg || mixerCtrl->shift != mixerCtrl->rshift) {
581 if (AudioUpdateDaiRegBits(dai, mixerCtrl->rreg, mixerCtrl->mask,
582 mixerCtrl->rshift, value) != HDF_SUCCESS) {
583 ADM_LOG_ERR("Audio codec stereo update reg bits fail.");
584 return HDF_FAILURE;
585 }
586 }
587
588 return HDF_SUCCESS;
589 }
590
AudioKcontrolGetCodec(const struct AudioKcontrol * kcontrol)591 struct CodecDevice *AudioKcontrolGetCodec(const struct AudioKcontrol *kcontrol)
592 {
593 struct AudioCard *audioCard = NULL;
594 if (kcontrol == NULL || kcontrol->pri == NULL) {
595 ADM_LOG_ERR("Get Codec input param kcontrol is NULL.");
596 return NULL;
597 }
598
599 audioCard = (struct AudioCard *)((volatile uintptr_t)(kcontrol->pri));
600 if (audioCard->rtd == NULL) {
601 ADM_LOG_ERR("Get audio card or rtd fail.");
602 return NULL;
603 }
604
605 return audioCard->rtd->codec;
606 }
607
AudioKcontrolGetCpuDai(const struct AudioKcontrol * kcontrol)608 struct DaiDevice *AudioKcontrolGetCpuDai(const struct AudioKcontrol *kcontrol)
609 {
610 struct AudioCard *audioCard = NULL;
611 if (kcontrol == NULL || kcontrol->pri == NULL) {
612 ADM_LOG_ERR("Get CpuDai input param kcontrol is NULL.");
613 return NULL;
614 }
615
616 audioCard = (struct AudioCard *)((volatile uintptr_t)(kcontrol->pri));
617 if (audioCard->rtd == NULL) {
618 ADM_LOG_ERR("Get audio card or rtd fail.");
619 return NULL;
620 }
621
622 return audioCard->rtd->cpuDai;
623 }
624
AudioAddControl(const struct AudioCard * audioCard,const struct AudioKcontrol * ctrl)625 struct AudioKcontrol *AudioAddControl(const struct AudioCard *audioCard, const struct AudioKcontrol *ctrl)
626 {
627 struct AudioKcontrol *control = NULL;
628
629 if ((audioCard == NULL) || (ctrl == NULL)) {
630 ADM_LOG_ERR("Input params check error: audioCard=%p, ctrl=%p.", audioCard, ctrl);
631 return NULL;
632 }
633
634 control = (struct AudioKcontrol *)OsalMemCalloc(sizeof(*control));
635 if (control == NULL) {
636 ADM_LOG_ERR("Malloc control fail!");
637 return NULL;
638 }
639 control->name = ctrl->name;
640 control->iface = ctrl->iface;
641 control->Info = ctrl->Info;
642 control->Get = ctrl->Get;
643 control->Set = ctrl->Set;
644 control->pri = (void *)audioCard;
645 control->privateValue = ctrl->privateValue;
646
647 return control;
648 }
649
AudioAddControls(struct AudioCard * audioCard,const struct AudioKcontrol * controls,int32_t controlMaxNum)650 int32_t AudioAddControls(struct AudioCard *audioCard, const struct AudioKcontrol *controls, int32_t controlMaxNum)
651 {
652 struct AudioKcontrol *control = NULL;
653 int32_t i;
654 ADM_LOG_DEBUG("Entry.");
655
656 if (audioCard == NULL) {
657 ADM_LOG_ERR("Input params check error: audioCard is NULL.");
658 return HDF_ERR_INVALID_OBJECT;
659 }
660 if (controls == NULL) {
661 ADM_LOG_ERR("Input params check error: controls is NULL.");
662 return HDF_FAILURE;
663 }
664 if (controlMaxNum <= 0) {
665 ADM_LOG_ERR("Input params check error: controlMaxNum=%d.", controlMaxNum);
666 return HDF_FAILURE;
667 }
668
669 for (i = 0; i < controlMaxNum; i++) {
670 control = AudioAddControl(audioCard, &controls[i]);
671 if (control == NULL) {
672 ADM_LOG_ERR("Add control fail!");
673 return HDF_FAILURE;
674 }
675 DListInsertHead(&control->list, &audioCard->controls);
676 }
677 ADM_LOG_DEBUG("Success.");
678 return HDF_SUCCESS;
679 }
680
AudioInfoCtrlOps(const struct AudioKcontrol * kcontrol,struct AudioCtrlElemInfo * elemInfo)681 int32_t AudioInfoCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemInfo *elemInfo)
682 {
683 struct AudioMixerControl *mixerCtrl = NULL;
684
685 if (kcontrol == NULL || kcontrol->privateValue <= 0 || elemInfo == NULL) {
686 ADM_LOG_ERR("Input param kcontrol is NULL.");
687 return HDF_ERR_INVALID_OBJECT;
688 }
689
690 elemInfo->count = CHANNEL_MIN_NUM;
691 mixerCtrl = (struct AudioMixerControl *)((volatile uintptr_t)(kcontrol->privateValue));
692 /* stereo */
693 if (mixerCtrl->reg != mixerCtrl->rreg || mixerCtrl->shift != mixerCtrl->rshift) {
694 elemInfo->count = CHANNEL_MAX_NUM;
695 }
696 elemInfo->type = 1; /* volume type */
697 elemInfo->min = mixerCtrl->min;
698 elemInfo->max = mixerCtrl->max;
699
700 return HDF_SUCCESS;
701 }
702
AudioInfoEnumCtrlOps(const struct AudioKcontrol * kcontrol,struct AudioCtrlElemInfo * elemInfo)703 int32_t AudioInfoEnumCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemInfo *elemInfo)
704 {
705 struct AudioEnumKcontrol *enumCtrl = NULL;
706
707 if (kcontrol == NULL || kcontrol->privateValue <= 0 || elemInfo == NULL) {
708 ADM_LOG_ERR("Input param kcontrol is NULL.");
709 return HDF_ERR_INVALID_OBJECT;
710 }
711
712 elemInfo->count = CHANNEL_MIN_NUM;
713 enumCtrl = (struct AudioEnumKcontrol *)((volatile uintptr_t)(kcontrol->privateValue));
714 /* stereo */
715 if (enumCtrl->reg != enumCtrl->reg2 || enumCtrl->shiftLeft != enumCtrl->shiftRight) {
716 elemInfo->count = CHANNEL_MAX_NUM;
717 }
718 elemInfo->type = AUDIO_CTL_ELEM_TYPE_ENUMERATED; /* enumerated type */
719 elemInfo->min = 0;
720 elemInfo->max = enumCtrl->max;
721
722 return HDF_SUCCESS;
723 }
724
AudioGetCtrlOpsRReg(struct AudioCtrlElemValue * elemValue,const struct AudioMixerControl * mixerCtrl,uint32_t rcurValue)725 int32_t AudioGetCtrlOpsRReg(struct AudioCtrlElemValue *elemValue,
726 const struct AudioMixerControl *mixerCtrl, uint32_t rcurValue)
727 {
728 if (elemValue == NULL || mixerCtrl == NULL) {
729 ADM_LOG_ERR("Audio input param is NULL.");
730 return HDF_ERR_INVALID_OBJECT;
731 }
732
733 if (mixerCtrl->reg != mixerCtrl->rreg || mixerCtrl->shift != mixerCtrl->rshift) {
734 if (mixerCtrl->reg == mixerCtrl->rreg) {
735 rcurValue = (rcurValue >> mixerCtrl->rshift) & mixerCtrl->mask;
736 } else {
737 rcurValue = (rcurValue >> mixerCtrl->shift) & mixerCtrl->mask;
738 }
739 if (rcurValue > mixerCtrl->max || rcurValue < mixerCtrl->min) {
740 ADM_LOG_ERR("Audio invalid rcurValue=%u", rcurValue);
741 return HDF_FAILURE;
742 }
743 if (mixerCtrl->invert) {
744 rcurValue = mixerCtrl->max - rcurValue;
745 }
746 elemValue->value[1] = rcurValue;
747 }
748
749 return HDF_SUCCESS;
750 }
751
AudioGetCtrlOpsReg(struct AudioCtrlElemValue * elemValue,const struct AudioMixerControl * mixerCtrl,uint32_t curValue)752 int32_t AudioGetCtrlOpsReg(struct AudioCtrlElemValue *elemValue,
753 const struct AudioMixerControl *mixerCtrl, uint32_t curValue)
754 {
755 if (elemValue == NULL || mixerCtrl == NULL) {
756 ADM_LOG_ERR("Audio input param is NULL.");
757 return HDF_ERR_INVALID_OBJECT;
758 }
759
760 curValue = (curValue >> mixerCtrl->shift) & mixerCtrl->mask;
761 if (curValue > mixerCtrl->max || curValue < mixerCtrl->min) {
762 ADM_LOG_ERR("Audio invalid curValue=%u", curValue);
763 return HDF_FAILURE;
764 }
765 if (mixerCtrl->invert) {
766 curValue = mixerCtrl->max - curValue;
767 }
768 elemValue->value[0] = curValue;
769
770 return HDF_SUCCESS;
771 }
772
AudioGetEnumCtrlOpsReg(struct AudioCtrlElemValue * elemValue,const struct AudioEnumKcontrol * enumCtrl,uint32_t curValue)773 static int32_t AudioGetEnumCtrlOpsReg(struct AudioCtrlElemValue *elemValue,
774 const struct AudioEnumKcontrol *enumCtrl, uint32_t curValue)
775 {
776 if (elemValue == NULL || enumCtrl == NULL) {
777 ADM_LOG_ERR("Audio input param is NULL.");
778 return HDF_ERR_INVALID_OBJECT;
779 }
780
781 curValue = (curValue >> enumCtrl->shiftLeft) & enumCtrl->mask;
782 if (curValue > enumCtrl->max) {
783 ADM_LOG_ERR("Audio invalid curValue=%u", curValue);
784 return HDF_FAILURE;
785 }
786
787 elemValue->value[0] = curValue;
788
789 return HDF_SUCCESS;
790 }
791
AudioGetEnumCtrlOpsRReg(struct AudioCtrlElemValue * elemValue,const struct AudioEnumKcontrol * enumCtrl,uint32_t rcurValue)792 static int32_t AudioGetEnumCtrlOpsRReg(struct AudioCtrlElemValue *elemValue,
793 const struct AudioEnumKcontrol *enumCtrl, uint32_t rcurValue)
794 {
795 if (elemValue == NULL || enumCtrl == NULL) {
796 ADM_LOG_ERR("Audio input param is NULL.");
797 return HDF_ERR_INVALID_OBJECT;
798 }
799
800 if (enumCtrl->reg != enumCtrl->reg2 || enumCtrl->shiftLeft != enumCtrl->shiftRight) {
801 rcurValue = (rcurValue >> enumCtrl->shiftLeft) & enumCtrl->mask;
802
803 if (rcurValue > enumCtrl->max) {
804 ADM_LOG_ERR("Audio invalid rcurValue=%u", rcurValue);
805 return HDF_FAILURE;
806 }
807
808 elemValue->value[1] = rcurValue;
809 }
810
811 return HDF_SUCCESS;
812 }
813
AudioCodecGetCtrlOps(const struct AudioKcontrol * kcontrol,struct AudioCtrlElemValue * elemValue)814 int32_t AudioCodecGetCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemValue *elemValue)
815 {
816 uint32_t curValue = 0;
817 uint32_t rcurValue = 0;
818 struct AudioMixerControl *mixerCtrl = NULL;
819 struct CodecDevice *codec = NULL;
820 if (kcontrol == NULL || kcontrol->privateValue <= 0 || elemValue == NULL) {
821 ADM_LOG_ERR("Audio input param is NULL.");
822 return HDF_ERR_INVALID_OBJECT;
823 }
824 mixerCtrl = (struct AudioMixerControl *)((volatile uintptr_t)kcontrol->privateValue);
825 codec = AudioKcontrolGetCodec(kcontrol);
826 if (codec == NULL) {
827 ADM_LOG_ERR("mixerCtrl and codec is NULL.");
828 return HDF_FAILURE;
829 }
830 if (AudioCodecReadReg(codec, mixerCtrl->reg, &curValue) != HDF_SUCCESS ||
831 AudioCodecReadReg(codec, mixerCtrl->rreg, &rcurValue) != HDF_SUCCESS) {
832 ADM_LOG_ERR("Read Codec Reg fail.");
833 return HDF_FAILURE;
834 }
835 if (AudioGetCtrlOpsReg(elemValue, mixerCtrl, curValue) != HDF_SUCCESS ||
836 AudioGetCtrlOpsRReg(elemValue, mixerCtrl, rcurValue) != HDF_SUCCESS) {
837 ADM_LOG_ERR("Audio codec get kcontrol reg and rreg fail.");
838 return HDF_FAILURE;
839 }
840
841 return HDF_SUCCESS;
842 }
843
AudioCodecGetEnumCtrlOps(const struct AudioKcontrol * kcontrol,struct AudioCtrlElemValue * elemValue)844 int32_t AudioCodecGetEnumCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemValue *elemValue)
845 {
846 uint32_t curValue = 0;
847 uint32_t rcurValue = 0;
848 struct AudioEnumKcontrol *enumCtrl = NULL;
849 struct CodecDevice *codec = NULL;
850 if (kcontrol == NULL || kcontrol->privateValue <= 0 || elemValue == NULL) {
851 ADM_LOG_ERR("Audio input param is NULL.");
852 return HDF_ERR_INVALID_OBJECT;
853 }
854 enumCtrl = (struct AudioEnumKcontrol *)((volatile uintptr_t)kcontrol->privateValue);
855 codec = AudioKcontrolGetCodec(kcontrol);
856 if (codec == NULL) {
857 ADM_LOG_ERR("mixerCtrl and codec is NULL.");
858 return HDF_FAILURE;
859 }
860 if (AudioCodecReadReg(codec, enumCtrl->reg, &curValue) != HDF_SUCCESS ||
861 AudioCodecReadReg(codec, enumCtrl->reg2, &rcurValue) != HDF_SUCCESS) {
862 ADM_LOG_ERR("Read Reg fail.");
863 return HDF_FAILURE;
864 }
865
866 if (AudioGetEnumCtrlOpsReg(elemValue, enumCtrl, curValue) != HDF_SUCCESS ||
867 AudioGetEnumCtrlOpsRReg(elemValue, enumCtrl, rcurValue) != HDF_SUCCESS) {
868 ADM_LOG_ERR("Audio codec get kcontrol reg and rreg fail.");
869 return HDF_FAILURE;
870 }
871
872 return HDF_SUCCESS;
873 }
874
AudioSetCtrlOpsReg(const struct AudioKcontrol * kcontrol,const struct AudioCtrlElemValue * elemValue,const struct AudioMixerControl * mixerCtrl,uint32_t * value)875 int32_t AudioSetCtrlOpsReg(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue,
876 const struct AudioMixerControl *mixerCtrl, uint32_t *value)
877 {
878 if (kcontrol == NULL || (kcontrol->privateValue <= 0) || elemValue == NULL ||
879 mixerCtrl == NULL || value == NULL) {
880 ADM_LOG_ERR("Audio input param is NULL.");
881 return HDF_ERR_INVALID_OBJECT;
882 }
883
884 *value = elemValue->value[0];
885 if (*value < mixerCtrl->min || *value > mixerCtrl->max) {
886 ADM_LOG_ERR("Audio invalid value=%u", *value);
887 return HDF_ERR_INVALID_OBJECT;
888 }
889 if (mixerCtrl->invert) {
890 *value = mixerCtrl->max - *value;
891 }
892
893 return HDF_SUCCESS;
894 }
895
AudioSetCtrlOpsRReg(const struct AudioCtrlElemValue * elemValue,struct AudioMixerControl * mixerCtrl,uint32_t * rvalue,bool * updateRReg)896 int32_t AudioSetCtrlOpsRReg(const struct AudioCtrlElemValue *elemValue,
897 struct AudioMixerControl *mixerCtrl, uint32_t *rvalue, bool *updateRReg)
898 {
899 uint32_t rshift;
900 if (elemValue == NULL || mixerCtrl == NULL || rvalue == NULL || updateRReg == NULL) {
901 ADM_LOG_ERR("Audio input param is NULL.");
902 return HDF_ERR_INVALID_OBJECT;
903 }
904
905 if (mixerCtrl->reg != mixerCtrl->rreg || mixerCtrl->shift != mixerCtrl->rshift) {
906 *updateRReg = true;
907 *rvalue = elemValue->value[1];
908 if (*rvalue < mixerCtrl->min || *rvalue > mixerCtrl->max) {
909 ADM_LOG_ERR("Audio invalid fail.");
910 return HDF_FAILURE;
911 }
912 if (mixerCtrl->invert) {
913 *rvalue = mixerCtrl->max - *rvalue;
914 }
915 if (mixerCtrl->reg == mixerCtrl->rreg) {
916 rshift = mixerCtrl->rshift;
917 } else {
918 rshift = mixerCtrl->shift;
919 }
920 mixerCtrl->shift = rshift;
921 }
922
923 return HDF_SUCCESS;
924 }
925
AudioCodecSetCtrlOps(const struct AudioKcontrol * kcontrol,const struct AudioCtrlElemValue * elemValue)926 int32_t AudioCodecSetCtrlOps(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue)
927 {
928 uint32_t value;
929 uint32_t rvalue;
930 bool updateRReg = false;
931 struct CodecDevice *codec = NULL;
932 struct AudioMixerControl *mixerCtrl = NULL;
933 if (kcontrol == NULL || (kcontrol->privateValue <= 0) || elemValue == NULL) {
934 ADM_LOG_ERR("Audio codec set control register input param is NULL.");
935 return HDF_ERR_INVALID_OBJECT;
936 }
937
938 mixerCtrl = (struct AudioMixerControl *)((volatile uintptr_t)kcontrol->privateValue);
939 if (AudioSetCtrlOpsReg(kcontrol, elemValue, mixerCtrl, &value) != HDF_SUCCESS) {
940 ADM_LOG_ERR("AudioSetCtrlOpsReg is fail.");
941 return HDF_ERR_INVALID_OBJECT;
942 }
943 codec = AudioKcontrolGetCodec(kcontrol);
944 if (codec == NULL) {
945 ADM_LOG_ERR("AudioKcontrolGetCodec is fail.");
946 return HDF_ERR_INVALID_OBJECT;
947 }
948 if (AudioUpdateCodecRegBits(codec, mixerCtrl->reg, mixerCtrl->mask, mixerCtrl->shift, value) != HDF_SUCCESS) {
949 ADM_LOG_ERR("Audio codec stereo update reg bits fail.");
950 return HDF_FAILURE;
951 }
952
953 if (AudioSetCtrlOpsRReg(elemValue, mixerCtrl, &rvalue, &updateRReg) != HDF_SUCCESS) {
954 ADM_LOG_ERR("AudioSetCtrlOpsRReg is fail.");
955 return HDF_ERR_INVALID_OBJECT;
956 }
957
958 if (updateRReg) {
959 if (AudioUpdateCodecRegBits(codec, mixerCtrl->rreg, mixerCtrl->mask,
960 mixerCtrl->rshift, rvalue) != HDF_SUCCESS) {
961 ADM_LOG_ERR("Audio codec stereo update reg bits fail.");
962 return HDF_FAILURE;
963 }
964 }
965
966 return HDF_SUCCESS;
967 }
968
AudioCodecSetEnumRegUpdate(struct CodecDevice * codec,const struct AudioEnumKcontrol * enumCtrl,const uint32_t * value)969 static int32_t AudioCodecSetEnumRegUpdate(struct CodecDevice *codec, const struct AudioEnumKcontrol *enumCtrl,
970 const uint32_t *value)
971 {
972 uint32_t setVal[2];
973 int32_t ret;
974
975 if (codec == NULL || enumCtrl == NULL || value == NULL) {
976 ADM_LOG_ERR("Audio input param is NULL.");
977 return HDF_ERR_INVALID_OBJECT;
978 }
979
980 if (enumCtrl->values != NULL) {
981 setVal[0] = enumCtrl->values[value[0]];
982 setVal[1] = enumCtrl->values[value[1]];
983 } else {
984 setVal[0] = value[0];
985 setVal[1] = value[1];
986 }
987
988 if (setVal[0] > enumCtrl->max) {
989 ADM_LOG_ERR("Audio invalid value=%u", setVal[0]);
990 return HDF_ERR_INVALID_OBJECT;
991 }
992 ret = AudioUpdateCodecRegBits(codec, enumCtrl->reg, enumCtrl->mask, enumCtrl->shiftLeft, setVal[0]);
993 if (ret != HDF_SUCCESS) {
994 ADM_LOG_ERR("Audio codec stereo update reg bits fail.");
995 return HDF_FAILURE;
996 }
997
998 if (enumCtrl->reg != enumCtrl->reg2 || enumCtrl->shiftLeft != enumCtrl->shiftRight) {
999 if (setVal[1] > enumCtrl->max) {
1000 ADM_LOG_ERR("Audio invalid value=%u", setVal[1]);
1001 return HDF_ERR_INVALID_OBJECT;
1002 }
1003 ret = AudioUpdateCodecRegBits(codec, enumCtrl->reg2, enumCtrl->mask, enumCtrl->shiftRight, setVal[1]);
1004 if (ret != HDF_SUCCESS) {
1005 ADM_LOG_ERR("Audio codec stereo update reg bits fail.");
1006 return HDF_FAILURE;
1007 }
1008 }
1009
1010 return HDF_SUCCESS;
1011 }
1012
AudioCodecSetEnumCtrlOps(const struct AudioKcontrol * kcontrol,const struct AudioCtrlElemValue * elemValue)1013 int32_t AudioCodecSetEnumCtrlOps(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue)
1014 {
1015 struct CodecDevice *codec = NULL;
1016 struct AudioEnumKcontrol *enumCtrl = NULL;
1017 int32_t ret;
1018 if (kcontrol == NULL || (kcontrol->privateValue <= 0) || elemValue == NULL) {
1019 ADM_LOG_ERR("Audio input param is NULL.");
1020 return HDF_ERR_INVALID_OBJECT;
1021 }
1022 codec = AudioKcontrolGetCodec(kcontrol);
1023 if (codec == NULL) {
1024 ADM_LOG_ERR("AudioKcontrolGetCodec is fail.");
1025 return HDF_ERR_INVALID_OBJECT;
1026 }
1027 enumCtrl = (struct AudioEnumKcontrol *)((volatile uintptr_t)kcontrol->privateValue);
1028 ret = AudioCodecSetEnumRegUpdate(codec, enumCtrl, (uint32_t *)elemValue->value);
1029 if (ret != HDF_SUCCESS) {
1030 ADM_LOG_ERR("AudioCodecSetEnumRegUpdate fail.");
1031 return HDF_FAILURE;
1032 }
1033 return HDF_SUCCESS;
1034 }
1035
AudioCpuDaiSetCtrlOps(const struct AudioKcontrol * kcontrol,const struct AudioCtrlElemValue * elemValue)1036 int32_t AudioCpuDaiSetCtrlOps(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue)
1037 {
1038 uint32_t value;
1039 uint32_t rvalue;
1040 bool updateRReg = false;
1041 struct DaiDevice *dai = NULL;
1042 struct AudioMixerControl *mixerCtrl = NULL;
1043 if (kcontrol == NULL || (kcontrol->privateValue <= 0) || elemValue == NULL) {
1044 ADM_LOG_ERR("Audio cpu dai set control register input param is NULL.");
1045 return HDF_ERR_INVALID_OBJECT;
1046 }
1047
1048 mixerCtrl = (struct AudioMixerControl *)((volatile uintptr_t)kcontrol->privateValue);
1049 if (AudioSetCtrlOpsReg(kcontrol, elemValue, mixerCtrl, &value) != HDF_SUCCESS) {
1050 ADM_LOG_ERR("AudioSetCtrlOpsReg is fail.");
1051 return HDF_ERR_INVALID_OBJECT;
1052 }
1053 dai = AudioKcontrolGetCpuDai(kcontrol);
1054 if (dai == NULL) {
1055 ADM_LOG_ERR("AudioKcontrolGetCodec is fail.");
1056 return HDF_ERR_INVALID_OBJECT;
1057 }
1058 if (AudioUpdateDaiRegBits(dai, mixerCtrl->reg, mixerCtrl->mask, mixerCtrl->shift, value) != HDF_SUCCESS) {
1059 ADM_LOG_ERR("Audio codec stereo update reg bits fail.");
1060 return HDF_FAILURE;
1061 }
1062
1063 if (AudioSetCtrlOpsRReg(elemValue, mixerCtrl, &rvalue, &updateRReg) != HDF_SUCCESS) {
1064 ADM_LOG_ERR("AudioSetCtrlOpsRReg is fail.");
1065 return HDF_ERR_INVALID_OBJECT;
1066 }
1067
1068 if (updateRReg) {
1069 if (AudioUpdateDaiRegBits(dai, mixerCtrl->rreg, mixerCtrl->mask, mixerCtrl->rshift, rvalue) != HDF_SUCCESS) {
1070 ADM_LOG_ERR("Audio codec stereo update reg bits fail.");
1071 return HDF_FAILURE;
1072 }
1073 }
1074 return HDF_SUCCESS;
1075 }
1076
AudioCpuDaiGetCtrlOps(const struct AudioKcontrol * kcontrol,struct AudioCtrlElemValue * elemValue)1077 int32_t AudioCpuDaiGetCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemValue *elemValue)
1078 {
1079 uint32_t curValue = 0;
1080 uint32_t rcurValue = 0;
1081 struct AudioMixerControl *mixerCtrl = NULL;
1082 struct DaiDevice *dai = NULL;
1083 if (kcontrol == NULL || kcontrol->privateValue <= 0 || elemValue == NULL) {
1084 ADM_LOG_ERR("Audio input param is NULL.");
1085 return HDF_ERR_INVALID_OBJECT;
1086 }
1087 mixerCtrl = (struct AudioMixerControl *)((volatile uintptr_t)kcontrol->privateValue);
1088 dai = AudioKcontrolGetCpuDai(kcontrol);
1089 if (dai == NULL) {
1090 ADM_LOG_ERR("mixerCtrl and codec is NULL.");
1091 return HDF_FAILURE;
1092 }
1093 if (AudioDaiReadReg(dai, mixerCtrl->reg, &curValue) != HDF_SUCCESS ||
1094 AudioDaiReadReg(dai, mixerCtrl->rreg, &rcurValue) != HDF_SUCCESS) {
1095 ADM_LOG_ERR("Read dai Reg fail.");
1096 return HDF_FAILURE;
1097 }
1098 if (AudioGetCtrlOpsReg(elemValue, mixerCtrl, curValue) != HDF_SUCCESS ||
1099 AudioGetCtrlOpsRReg(elemValue, mixerCtrl, rcurValue) != HDF_SUCCESS) {
1100 ADM_LOG_ERR("Audio dai get kcontrol reg and rreg fail.");
1101 return HDF_FAILURE;
1102 }
1103
1104 return HDF_SUCCESS;
1105 }
1106
1107