1 /*
2 * Copyright (c) 2022 Institute of Software, CAS.
3 * Author : huangji@nj.iscas.ac.cn
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 #include <linux/regmap.h>
17 #include "audio_accessory_base.h"
18 #include "gpio_if.h"
19 #include "linux/of_gpio.h"
20 #include "audio_driver_log.h"
21 #include "audio_stream_dispatch.h"
22 #include "audio_codec_base.h"
23 #include "rk817_codec.h"
24 #include "rk809_codec_impl.h"
25
26 #define HDF_LOG_TAG "rk809_codec"
27
28 /* RK809 I2C Device address */
29 #define RK809_I2C_DEV_ADDR (0x20)
30 #define RK809_I2C_BUS_NUMBER (0) // i2c0
31 #define RK809_I2C_WAIT_TIMES (10) // ms
32
33 struct Rk809TransferData {
34 uint16_t i2cDevAddr;
35 uint16_t i2cBusNumber;
36 uint32_t CfgCtrlCount;
37 struct AudioRegCfgGroupNode **RegCfgGroupNode;
38 struct AudioKcontrol *Controls;
39 };
40
41
42 static const struct AudioSapmRoute g_audioRoutes[] = {
43 { "SPKL", "Dacl enable", "DACL"},
44 { "SPKR", "Dacr enable", "DACR"},
45
46 { "ADCL", NULL, "LPGA"},
47 { "LPGA", "LPGA MIC Switch", "MIC"},
48
49 { "ADCR", NULL, "RPGA"},
50 { "RPGA", "RPGA MIC Switch", "MIC"},
51 };
52
53 static const struct reg_default rk817_render_start_reg_defaults[] = {
54 { RK817_CODEC_ADAC_CFG1, 0x00 },
55 { RK817_CODEC_DDAC_POPD_DACST, 0x04 },
56 { RK817_CODEC_DDAC_MUTE_MIXCTL, 0x10 },
57 };
58
59 static const struct regmap_config rk817_render_start_regmap_config = {
60 .reg_defaults = rk817_render_start_reg_defaults,
61 .num_reg_defaults = ARRAY_SIZE(rk817_render_start_reg_defaults),
62 };
63
64 static const struct reg_default rk817_render_stop_reg_defaults[] = {
65 { RK817_CODEC_ADAC_CFG1, 0x0f },
66 { RK817_CODEC_DDAC_POPD_DACST, 0x06 },
67 { RK817_CODEC_DDAC_MUTE_MIXCTL, 0x11 },
68 };
69
70 static const struct regmap_config rk817_render_stop_regmap_config = {
71 .reg_defaults = rk817_render_stop_reg_defaults,
72 .num_reg_defaults = ARRAY_SIZE(rk817_render_stop_reg_defaults),
73 };
74
75 static const struct reg_default rk817_capture_start_reg_defaults[] = {
76 { RK817_CODEC_DTOP_DIGEN_CLKE, 0xff },
77 { RK817_CODEC_AADC_CFG0, 0x08 },
78 { RK817_CODEC_DADC_SR_ACL0, 0x02 },
79 { RK817_CODEC_AMIC_CFG0, 0x8f },
80 { RK817_CODEC_DMIC_PGA_GAIN, 0x99 },
81 { RK817_CODEC_ADAC_CFG1, 0x0f },
82 { RK817_CODEC_DDAC_POPD_DACST, 0x04 },
83 { RK817_CODEC_DDAC_MUTE_MIXCTL, 0x00 },
84 { RK817_CODEC_DI2S_TXCR3_TXCMD, 0x88 },
85 };
86
87 static const struct regmap_config rk817_capture_start_regmap_config = {
88 .reg_defaults = rk817_capture_start_reg_defaults,
89 .num_reg_defaults = ARRAY_SIZE(rk817_capture_start_reg_defaults),
90 };
91
92 static const struct reg_default rk817_capture_stop_reg_defaults[] = {
93 { RK817_CODEC_DTOP_DIGEN_CLKE, 0x0f },
94 { RK817_CODEC_AADC_CFG0, 0xc8 },
95 { RK817_CODEC_DADC_SR_ACL0, 0x00 },
96 { RK817_CODEC_DDAC_POPD_DACST, 0x06 },
97 };
98
99 static const struct regmap_config rk817_capture_stop_regmap_config = {
100 .reg_defaults = rk817_capture_stop_reg_defaults,
101 .num_reg_defaults = ARRAY_SIZE(rk817_capture_stop_reg_defaults),
102 };
103
104 unsigned int g_cuurentcmd = AUDIO_DRV_PCM_IOCTL_BUTT;
105
Rk809DeviceRegRead(uint32_t reg,uint32_t * val)106 int32_t Rk809DeviceRegRead(uint32_t reg, uint32_t *val)
107 {
108 struct Rk809ChipData *chip = GetCodecDevice();
109 if (chip == NULL) {
110 AUDIO_DRIVER_LOG_ERR("get codec device failed.");
111 return HDF_FAILURE;
112 }
113 if (regmap_read(chip->regmap, reg, val)) {
114 AUDIO_DRIVER_LOG_ERR("read register fail: [%04x]", reg);
115 return HDF_FAILURE;
116 }
117
118 return HDF_SUCCESS;
119 }
120
Rk809DeviceRegWrite(uint32_t reg,uint32_t value)121 int32_t Rk809DeviceRegWrite(uint32_t reg, uint32_t value)
122 {
123 struct Rk809ChipData *chip = GetCodecDevice();
124 if (chip == NULL) {
125 AUDIO_DRIVER_LOG_ERR("get codec device failed.");
126 return HDF_FAILURE;
127 }
128 if (regmap_write(chip->regmap, reg, value)) {
129 AUDIO_DRIVER_LOG_ERR("write register fail: [%04x] = %04x", reg, value);
130 return HDF_FAILURE;
131 }
132
133 return HDF_SUCCESS;
134 }
135
Rk809DeviceRegUpdatebits(uint32_t reg,uint32_t mask,uint32_t value)136 int32_t Rk809DeviceRegUpdatebits(uint32_t reg, uint32_t mask, uint32_t value)
137 {
138 struct Rk809ChipData *chip = GetCodecDevice();
139 if (chip == NULL) {
140 AUDIO_DRIVER_LOG_ERR("get codec device failed.");
141 return HDF_FAILURE;
142 }
143 if (regmap_update_bits(chip->regmap, reg, mask, value)) {
144 AUDIO_DRIVER_LOG_ERR("update register bits fail: [%04x] = %04x", reg, value);
145 return HDF_FAILURE;
146 }
147
148 return HDF_SUCCESS;
149 }
150
151 // Update contrl reg bits value
Rk809RegBitsUpdate(struct AudioMixerControl regAttr)152 int32_t Rk809RegBitsUpdate(struct AudioMixerControl regAttr)
153 {
154 int32_t ret;
155 bool updaterreg = false;
156
157 if (regAttr.invert) {
158 regAttr.value = regAttr.max - regAttr.value;
159 }
160 regAttr.value = regAttr.value << regAttr.shift;
161 ret = Rk809DeviceRegUpdatebits(regAttr.reg, regAttr.mask, regAttr.value);
162 if (ret != HDF_SUCCESS) {
163 AUDIO_DEVICE_LOG_ERR("Rk809DeviceRegUpdatebits failed.");
164 return HDF_FAILURE;
165 }
166 regAttr.value = regAttr.value << regAttr.rshift;
167 updaterreg = (regAttr.reg != regAttr.rreg) || (regAttr.shift != regAttr.rshift);
168 if (updaterreg) {
169 ret = Rk809DeviceRegUpdatebits(regAttr.rreg, regAttr.mask, regAttr.value);
170 if (ret != HDF_SUCCESS) {
171 AUDIO_DEVICE_LOG_ERR("Rk809DeviceRegUpdatebits failed.");
172 return HDF_FAILURE;
173 }
174 }
175
176 return HDF_SUCCESS;
177 }
178
RK809RegBitsUpdateValue(struct AudioMixerControl * regAttr,Update_Dest dest,uint32_t value)179 int32_t RK809RegBitsUpdateValue(struct AudioMixerControl *regAttr, Update_Dest dest, uint32_t value)
180 {
181 int32_t ret;
182
183 if (regAttr->invert) {
184 value = regAttr->max - value;
185 }
186 if (dest == UPDATE_LREG) {
187 value = value << regAttr->shift;
188 ret = Rk809DeviceRegUpdatebits(regAttr->reg, regAttr->mask, value);
189 } else if (dest == UPDATE_RREG) {
190 value = value << regAttr->rshift;
191 ret = Rk809DeviceRegUpdatebits(regAttr->rreg, regAttr->mask, value);
192 } else {
193 ret = HDF_FAILURE;
194 }
195
196 return ret;
197 }
198
RK809RegDefaultInit(struct AudioRegCfgGroupNode ** regCfgGroup)199 int32_t RK809RegDefaultInit(struct AudioRegCfgGroupNode **regCfgGroup)
200 {
201 int32_t i;
202 struct AudioAddrConfig *regAttr = NULL;
203
204 if (regCfgGroup == NULL || regCfgGroup[AUDIO_INIT_GROUP] == NULL ||
205 regCfgGroup[AUDIO_INIT_GROUP]->addrCfgItem == NULL || regCfgGroup[AUDIO_INIT_GROUP]->itemNum <= 0) {
206 AUDIO_DEVICE_LOG_ERR("input invalid parameter.");
207 return HDF_ERR_INVALID_PARAM;
208 }
209 regAttr = regCfgGroup[AUDIO_INIT_GROUP]->addrCfgItem;
210
211 for (i = 0; i < regCfgGroup[AUDIO_INIT_GROUP]->itemNum; i++) {
212 Rk809DeviceRegWrite(regAttr[i].addr, regAttr[i].value);
213 }
214
215 return HDF_SUCCESS;
216 }
217
RK809GetSRT(const unsigned int rate)218 static const RK809SampleRateTimes RK809GetSRT(const unsigned int rate)
219 {
220 switch (rate) {
221 case AUDIO_SAMPLE_RATE_8000:
222 return RK809_SRT_00;
223 case AUDIO_SAMPLE_RATE_16000:
224 return RK809_SRT_01;
225 case AUDIO_SAMPLE_RATE_32000:
226 case AUDIO_SAMPLE_RATE_44100:
227 case AUDIO_SAMPLE_RATE_48000:
228 return RK809_SRT_02;
229 case AUDIO_SAMPLE_RATE_96000:
230 return RK809_SRT_03;
231 default:
232 AUDIO_DEVICE_LOG_DEBUG("unsupport samplerate %d\n", rate);
233 return RK809_SRT_02;
234 }
235 }
236
RK809GetPremode(const unsigned int rate)237 static const RK809PLLInputCLKPreDIV RK809GetPremode(const unsigned int rate)
238 {
239 switch (rate) {
240 case AUDIO_SAMPLE_RATE_8000:
241 return RK809_PREMODE_1;
242 case AUDIO_SAMPLE_RATE_16000:
243 return RK809_PREMODE_2;
244 case AUDIO_SAMPLE_RATE_32000:
245 case AUDIO_SAMPLE_RATE_44100:
246 case AUDIO_SAMPLE_RATE_48000:
247 return RK809_PREMODE_3;
248 case AUDIO_SAMPLE_RATE_96000:
249 return RK809_PREMODE_4;
250 default:
251 AUDIO_DEVICE_LOG_DEBUG("unsupport samplerate %d\n", rate);
252 return RK809_PREMODE_3;
253 }
254 }
255
RK809GetI2SDataWidth(const unsigned int bitWidth)256 static const RK809_VDW RK809GetI2SDataWidth(const unsigned int bitWidth)
257 {
258 switch (bitWidth) {
259 case BIT_WIDTH16:
260 return RK809_VDW_16BITS;
261 case BIT_WIDTH24:
262 case BIT_WIDTH32:
263 return RK809_VDW_24BITS;
264 default:
265 AUDIO_DEVICE_LOG_ERR("unsupport sample bit width %d.\n", bitWidth);
266 return RK809_VDW_16BITS;
267 }
268 }
269
RK809UpdateRenderParams(struct AudioRegCfgGroupNode ** regCfgGroup,struct RK809DaiParamsVal codecDaiParamsVal)270 int32_t RK809UpdateRenderParams(struct AudioRegCfgGroupNode **regCfgGroup,
271 struct RK809DaiParamsVal codecDaiParamsVal)
272 {
273 int32_t ret;
274 struct AudioMixerControl *regAttr = NULL;
275 int32_t itemNum = regCfgGroup[AUDIO_DAI_PATAM_GROUP]->itemNum;
276 int16_t i = 0;
277
278 ret = (regCfgGroup == NULL
279 || regCfgGroup[AUDIO_DAI_PATAM_GROUP] == NULL
280 || regCfgGroup[AUDIO_DAI_PATAM_GROUP]->regCfgItem == NULL);
281 if (ret) {
282 AUDIO_DEVICE_LOG_ERR("input invalid parameter.");
283 return HDF_FAILURE;
284 }
285
286 regAttr = regCfgGroup[AUDIO_DAI_PATAM_GROUP]->regCfgItem;
287
288 for (i = 0; i < itemNum; i++) {
289 if (regAttr[i].reg == RK817_CODEC_APLL_CFG3) {
290 regAttr[i].value = RK809GetPremode(codecDaiParamsVal.frequencyVal);
291 ret = Rk809RegBitsUpdate(regAttr[i]);
292 if (ret != HDF_SUCCESS) {
293 AUDIO_DEVICE_LOG_ERR("Rk809RegBitsUpdate failed.");
294 return HDF_FAILURE;
295 }
296 } else if (regAttr[i].reg == RK817_CODEC_DDAC_SR_LMT0) {
297 regAttr[i].value = RK809GetSRT(codecDaiParamsVal.frequencyVal);
298 Rk809DeviceRegUpdatebits(RK817_CODEC_DTOP_DIGEN_CLKE,
299 DAC_DIG_CLK_EN, 0x00); // disenable DAC digital clk
300 ret = Rk809RegBitsUpdate(regAttr[i]);
301 if (ret != HDF_SUCCESS) {
302 AUDIO_DEVICE_LOG_ERR("Rk809RegBitsUpdate failed.");
303 return HDF_FAILURE;
304 }
305 Rk809DeviceRegUpdatebits(RK817_CODEC_DTOP_DIGEN_CLKE, DAC_DIG_CLK_EN, DAC_DIG_CLK_EN);
306 } else if (regAttr[i].reg == RK817_CODEC_DI2S_RXCR2) {
307 regAttr[i].value = RK809GetI2SDataWidth(codecDaiParamsVal.DataWidthVal);
308 ret = Rk809RegBitsUpdate(regAttr[i]);
309 if (ret != HDF_SUCCESS) {
310 AUDIO_DEVICE_LOG_ERR("Rk809RegBitsUpdate failed.");
311 return HDF_FAILURE;
312 }
313 }
314 }
315
316 return HDF_SUCCESS;
317 }
318
RK809UpdateCaptureParams(struct AudioRegCfgGroupNode ** regCfgGroup,struct RK809DaiParamsVal codecDaiParamsVal)319 int32_t RK809UpdateCaptureParams(struct AudioRegCfgGroupNode **regCfgGroup,
320 struct RK809DaiParamsVal codecDaiParamsVal)
321 {
322 int32_t ret;
323 struct AudioMixerControl *regAttr = NULL;
324 int32_t itemNum = regCfgGroup[AUDIO_DAI_PATAM_GROUP]->itemNum;
325 int16_t i = 0;
326
327 ret = (regCfgGroup == NULL
328 || regCfgGroup[AUDIO_DAI_PATAM_GROUP] == NULL
329 || regCfgGroup[AUDIO_DAI_PATAM_GROUP]->regCfgItem == NULL);
330 if (ret) {
331 AUDIO_DEVICE_LOG_ERR("input invalid parameter.");
332 return HDF_FAILURE;
333 }
334
335 regAttr = regCfgGroup[AUDIO_DAI_PATAM_GROUP]->regCfgItem;
336
337 for (i = 0; i < itemNum; i++) {
338 if (regAttr[i].reg == RK817_CODEC_APLL_CFG3) {
339 regAttr[i].value = RK809GetPremode(codecDaiParamsVal.frequencyVal);
340 ret = Rk809RegBitsUpdate(regAttr[i]);
341 if (ret != HDF_SUCCESS) {
342 AUDIO_DEVICE_LOG_ERR("Rk809RegBitsUpdate failed.");
343 return HDF_FAILURE;
344 }
345 } else if (regAttr[i].reg == RK817_CODEC_DADC_SR_ACL0) {
346 regAttr[i].value = RK809GetSRT(codecDaiParamsVal.frequencyVal);
347 Rk809DeviceRegUpdatebits(RK817_CODEC_DTOP_DIGEN_CLKE, ADC_DIG_CLK_EN, 0x00);
348 ret = Rk809RegBitsUpdate(regAttr[i]);
349 if (ret != HDF_SUCCESS) {
350 AUDIO_DEVICE_LOG_ERR("Rk809RegBitsUpdate failed.");
351 return HDF_FAILURE;
352 }
353 Rk809DeviceRegUpdatebits(RK817_CODEC_DTOP_DIGEN_CLKE, ADC_DIG_CLK_EN, ADC_DIG_CLK_EN);
354 } else if (regAttr[i].reg == RK817_CODEC_DI2S_TXCR2) {
355 regAttr[i].value = RK809GetI2SDataWidth(codecDaiParamsVal.DataWidthVal);
356 ret = Rk809RegBitsUpdate(regAttr[i]);
357 if (ret != HDF_SUCCESS) {
358 AUDIO_DEVICE_LOG_ERR("Rk809RegBitsUpdate failed.");
359 return HDF_FAILURE;
360 }
361 }
362 }
363
364 return HDF_SUCCESS;
365 }
366
RK809DaiParamsUpdate(struct AudioRegCfgGroupNode ** regCfgGroup,struct RK809DaiParamsVal codecDaiParamsVal)367 int32_t RK809DaiParamsUpdate(struct AudioRegCfgGroupNode **regCfgGroup,
368 struct RK809DaiParamsVal codecDaiParamsVal)
369 {
370 int32_t ret;
371
372 ret = (regCfgGroup == NULL
373 || regCfgGroup[AUDIO_DAI_PATAM_GROUP] == NULL
374 || regCfgGroup[AUDIO_DAI_PATAM_GROUP]->regCfgItem == NULL);
375 if (ret) {
376 AUDIO_DEVICE_LOG_ERR("input invalid parameter.");
377 return HDF_FAILURE;
378 }
379
380 if (g_cuurentcmd == AUDIO_DRV_PCM_IOCTL_RENDER_START
381 || g_cuurentcmd == AUDIO_DRV_PCM_IOCTL_RENDER_PAUSE
382 || g_cuurentcmd == AUDIO_DRV_PCM_IOCTL_RENDER_RESUME
383 || g_cuurentcmd == AUDIO_DRV_PCM_IOCTL_RENDER_STOP) {
384 ret = RK809UpdateRenderParams(regCfgGroup, codecDaiParamsVal);
385 if (ret != HDF_SUCCESS) {
386 AUDIO_DEVICE_LOG_ERR("RK809UpdateRenderParams failed.");
387 return HDF_FAILURE;
388 }
389 } else if (g_cuurentcmd == AUDIO_DRV_PCM_IOCTL_CAPTURE_START
390 || g_cuurentcmd == AUDIO_DRV_PCM_IOCTL_CAPTURE_PAUSE
391 || g_cuurentcmd == AUDIO_DRV_PCM_IOCTL_CAPTURE_RESUME
392 || g_cuurentcmd == AUDIO_DRV_PCM_IOCTL_CAPTURE_STOP) {
393 ret = RK809UpdateCaptureParams(regCfgGroup, codecDaiParamsVal);
394 if (ret != HDF_SUCCESS) {
395 AUDIO_DEVICE_LOG_ERR("RK809UpdateCaptureParams failed.");
396 return HDF_FAILURE;
397 }
398 }
399 return HDF_SUCCESS;
400 }
401
RK809WorkStatusEnable(struct AudioRegCfgGroupNode ** regCfgGroup)402 static int32_t RK809WorkStatusEnable(struct AudioRegCfgGroupNode **regCfgGroup)
403 {
404 int ret;
405 uint8_t i;
406 struct AudioMixerControl *daiStartupParamsRegCfgItem = NULL;
407 uint8_t daiStartupParamsRegCfgItemCount;
408
409 ret = (regCfgGroup == NULL || regCfgGroup[AUDIO_DAI_STARTUP_PATAM_GROUP] == NULL
410 || regCfgGroup[AUDIO_DAI_STARTUP_PATAM_GROUP]->regCfgItem == NULL);
411 if (ret) {
412 AUDIO_DEVICE_LOG_ERR("input invalid parameter.");
413 return HDF_FAILURE;
414 }
415
416 daiStartupParamsRegCfgItem =
417 regCfgGroup[AUDIO_DAI_STARTUP_PATAM_GROUP]->regCfgItem;
418 daiStartupParamsRegCfgItemCount =
419 regCfgGroup[AUDIO_DAI_STARTUP_PATAM_GROUP]->itemNum;
420 for (i = 0; i < daiStartupParamsRegCfgItemCount; i++) {
421 ret = Rk809RegBitsUpdate(daiStartupParamsRegCfgItem[i]);
422 if (ret != HDF_SUCCESS) {
423 AUDIO_DEVICE_LOG_ERR("Rk809RegBitsUpdate fail.");
424 return HDF_FAILURE;
425 }
426 }
427
428 return HDF_SUCCESS;
429 }
430
RK809CodecReadReg(unsigned long virtualAddress,uint32_t reg,uint32_t * val)431 int32_t RK809CodecReadReg(unsigned long virtualAddress, uint32_t reg, uint32_t *val)
432 {
433 if (val == NULL) {
434 AUDIO_DRIVER_LOG_ERR("param val is null.");
435 return HDF_FAILURE;
436 }
437 if (Rk809DeviceRegRead(reg, val)) {
438 AUDIO_DRIVER_LOG_ERR("read register fail: [%04x]", reg);
439 return HDF_FAILURE;
440 }
441
442 return HDF_SUCCESS;
443 }
444
Rk809CodecWriteReg(unsigned long virtualAddress,uint32_t reg,uint32_t value)445 int32_t Rk809CodecWriteReg(unsigned long virtualAddress, uint32_t reg, uint32_t value)
446 {
447 if (Rk809DeviceRegWrite(reg, value)) {
448 AUDIO_DRIVER_LOG_ERR("write register fail: [%04x] = %04x", reg, value);
449 return HDF_FAILURE;
450 }
451
452 return HDF_SUCCESS;
453 }
454
RK809GetCtrlOps(const struct AudioKcontrol * kcontrol,struct AudioCtrlElemValue * elemValue)455 int32_t RK809GetCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemValue *elemValue)
456 {
457 uint32_t curValue;
458 uint32_t rcurValue;
459 struct AudioMixerControl *mixerCtrl = NULL;
460
461 if (kcontrol == NULL || kcontrol->privateValue <= 0 || elemValue == NULL) {
462 AUDIO_DEVICE_LOG_ERR("Audio input param is NULL.");
463 return HDF_ERR_INVALID_OBJECT;
464 }
465 mixerCtrl = (struct AudioMixerControl *)((volatile uintptr_t)kcontrol->privateValue);
466 if (mixerCtrl == NULL) {
467 AUDIO_DEVICE_LOG_ERR("mixerCtrl is NULL.");
468 return HDF_FAILURE;
469 }
470 Rk809DeviceRegRead(mixerCtrl->reg, &curValue);
471 Rk809DeviceRegRead(mixerCtrl->rreg, &rcurValue);
472 if (AudioGetCtrlOpsReg(elemValue, mixerCtrl, curValue) != HDF_SUCCESS ||
473 AudioGetCtrlOpsRReg(elemValue, mixerCtrl, rcurValue) != HDF_SUCCESS) {
474 AUDIO_DEVICE_LOG_ERR("Audio codec get kcontrol reg and rreg failed.");
475 return HDF_FAILURE;
476 }
477
478 return HDF_SUCCESS;
479 }
480
RK809SetCtrlOps(const struct AudioKcontrol * kcontrol,const struct AudioCtrlElemValue * elemValue)481 int32_t RK809SetCtrlOps(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue)
482 {
483 uint32_t value;
484 uint32_t rvalue;
485 bool updateRReg = false;
486 struct AudioMixerControl *mixerCtrl = NULL;
487 if (kcontrol == NULL || (kcontrol->privateValue <= 0) || elemValue == NULL) {
488 AUDIO_DEVICE_LOG_ERR("Audio input param is NULL.");
489 return HDF_ERR_INVALID_OBJECT;
490 }
491
492 mixerCtrl = (struct AudioMixerControl *)((volatile uintptr_t)kcontrol->privateValue);
493 if (AudioSetCtrlOpsReg(kcontrol, elemValue, mixerCtrl, &value) != HDF_SUCCESS) {
494 AUDIO_DEVICE_LOG_ERR("AudioSetCtrlOpsReg is failed.");
495 return HDF_ERR_INVALID_OBJECT;
496 }
497 RK809RegBitsUpdateValue(mixerCtrl, UPDATE_LREG, value);
498 if (AudioSetCtrlOpsRReg(elemValue, mixerCtrl, &rvalue, &updateRReg) != HDF_SUCCESS) {
499 AUDIO_DEVICE_LOG_ERR("AudioSetCtrlOpsRReg is failed.");
500 return HDF_ERR_INVALID_OBJECT;
501 }
502 if (updateRReg) {
503 RK809RegBitsUpdateValue(mixerCtrl, UPDATE_RREG, rvalue);
504 }
505
506 return HDF_SUCCESS;
507 }
508
Rk809DeviceInit(struct AudioCard * audioCard,const struct CodecDevice * device)509 int32_t Rk809DeviceInit(struct AudioCard *audioCard, const struct CodecDevice *device)
510 {
511 int32_t ret;
512
513 if (audioCard == NULL || device == NULL || device->devData == NULL ||
514 device->devData->sapmComponents == NULL || device->devData->controls == NULL) {
515 AUDIO_DRIVER_LOG_ERR("input para is NULL.");
516 return HDF_ERR_INVALID_OBJECT;
517 }
518
519 if (CodecSetCtlFunc(device->devData, RK809GetCtrlOps, RK809SetCtrlOps) != HDF_SUCCESS) {
520 AUDIO_DRIVER_LOG_ERR("AudioCodecSetCtlFunc failed.");
521 return HDF_FAILURE;
522 }
523
524 ret = RK809RegDefaultInit(device->devData->regCfgGroup);
525 if (ret != HDF_SUCCESS) {
526 AUDIO_DEVICE_LOG_ERR("RK809RegDefaultInit failed.");
527 return HDF_FAILURE;
528 }
529
530 if (AudioAddControls(audioCard, device->devData->controls, device->devData->numControls) != HDF_SUCCESS) {
531 AUDIO_DRIVER_LOG_ERR("add controls failed.");
532 return HDF_FAILURE;
533 }
534
535 AUDIO_DRIVER_LOG_DEBUG("success.");
536 return HDF_SUCCESS;
537 }
538
Rk809DaiDeviceInit(struct AudioCard * card,const struct DaiDevice * device)539 int32_t Rk809DaiDeviceInit(struct AudioCard *card, const struct DaiDevice *device)
540 {
541 if (device == NULL || device->devDaiName == NULL) {
542 AUDIO_DEVICE_LOG_ERR("input para is NULL.");
543 return HDF_FAILURE;
544 }
545 (void)card;
546 AUDIO_DEVICE_LOG_DEBUG("success.");
547 return HDF_SUCCESS;
548 }
549
Rk809DaiStartup(const struct AudioCard * card,const struct DaiDevice * device)550 int32_t Rk809DaiStartup(const struct AudioCard *card, const struct DaiDevice *device)
551 {
552 int ret;
553 (void)card;
554 (void)device;
555
556 ret = RK809WorkStatusEnable(device->devData->regCfgGroup);
557 if (ret != HDF_SUCCESS) {
558 AUDIO_DEVICE_LOG_ERR("RK809WorkStatusEnable failed.");
559 return HDF_FAILURE;
560 }
561
562 AUDIO_DRIVER_LOG_DEBUG("success.");
563 return HDF_SUCCESS;
564 }
565
Rk809DaiHwParams(const struct AudioCard * card,const struct AudioPcmHwParams * param)566 int32_t Rk809DaiHwParams(const struct AudioCard *card, const struct AudioPcmHwParams *param)
567 {
568 int32_t ret;
569 unsigned int bitWidth;
570 struct RK809DaiParamsVal codecDaiParamsVal;
571 (void)card;
572
573 if (param == NULL || param->cardServiceName == NULL || card == NULL ||
574 card->rtd == NULL || card->rtd->codecDai == NULL || card->rtd->codecDai->devData == NULL ||
575 card->rtd->codecDai->devData->regCfgGroup == NULL) {
576 AUDIO_DRIVER_LOG_ERR("input para is NULL.");
577 return HDF_FAILURE;
578 }
579
580 ret = AudioFramatToBitWidth(param->format, &bitWidth);
581 if (ret != HDF_SUCCESS) {
582 return HDF_FAILURE;
583 }
584
585 codecDaiParamsVal.frequencyVal = param->rate;
586 codecDaiParamsVal.DataWidthVal = bitWidth;
587
588 ret = RK809DaiParamsUpdate(card->rtd->codecDai->devData->regCfgGroup, codecDaiParamsVal);
589 if (ret != HDF_SUCCESS) {
590 AUDIO_DEVICE_LOG_ERR("RK809DaiParamsUpdate failed.");
591 return HDF_FAILURE;
592 }
593
594 return HDF_SUCCESS;
595 }
596
RK809DeviceRegConfig(const struct regmap_config reg_config)597 int32_t RK809DeviceRegConfig(const struct regmap_config reg_config)
598 {
599 int32_t num_reg_defaults = reg_config.num_reg_defaults;
600 int32_t index;
601
602 for (index = 0; index < num_reg_defaults; index++) {
603 Rk809DeviceRegWrite(reg_config.reg_defaults[index].reg, reg_config.reg_defaults[index].def);
604 }
605
606 return HDF_SUCCESS;
607 }
608
609
610 /* normal scene */
Rk809NormalTrigger(const struct AudioCard * card,int cmd,const struct DaiDevice * device)611 int32_t Rk809NormalTrigger(const struct AudioCard *card, int cmd, const struct DaiDevice *device)
612 {
613 g_cuurentcmd = cmd;
614 switch (cmd) {
615 case AUDIO_DRV_PCM_IOCTL_RENDER_START:
616 case AUDIO_DRV_PCM_IOCTL_RENDER_RESUME:
617 RK809DeviceRegConfig(rk817_render_start_regmap_config);
618 break;
619
620 case AUDIO_DRV_PCM_IOCTL_RENDER_STOP:
621 case AUDIO_DRV_PCM_IOCTL_RENDER_PAUSE:
622 RK809DeviceRegConfig(rk817_render_stop_regmap_config);
623 break;
624
625 case AUDIO_DRV_PCM_IOCTL_CAPTURE_START:
626 case AUDIO_DRV_PCM_IOCTL_CAPTURE_RESUME:
627 RK809DeviceRegConfig(rk817_capture_start_regmap_config);
628 break;
629
630 case AUDIO_DRV_PCM_IOCTL_CAPTURE_STOP:
631 case AUDIO_DRV_PCM_IOCTL_CAPTURE_PAUSE:
632 RK809DeviceRegConfig(rk817_capture_stop_regmap_config);
633 break;
634
635 default:
636 break;
637 }
638
639 return HDF_SUCCESS;
640 }
641