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 "hi3516_aiao_impl.h"
10 #include <asm/io.h>
11 #include "hdf_base.h"
12 #include "audio_driver_log.h"
13 #include "audio_dai_base.h"
14 #include "osal_io.h"
15
16 #define HDF_LOG_TAG hi3516_aiao_impl
17
18 #define PERI_CRG103 0x1201019c // 0x12010000 + 0x019c
19
20 #define AOP_BUFF_SADDR_REG 0x2080
21 #define AOP_BUFF_SIZE_REG 0x2084
22 #define AOP_TRANS_SIZE_REG 0x2094
23 #define AOP_INF_ATTRI_REG 0x2000
24 #define AOP_CTRL_REG 0x2004
25 #define AIP_BUFF_SADDR_REG 0x1080
26 #define AIP_BUFF_SIZE_REG 0x1084
27 #define AIP_BUFF_RPTR_REG 0x108C
28 #define AIP_TRANS_SIZE_REG 0x1094
29 #define AIP_INF_ATTRI_REG 0x1000
30 #define AIP_CTRL_REG 0x1004
31 #define RX_INT_ENA 0x10a0
32 #define AIAO_INT_ENA 0x0000
33 #define RX_INT_CLR 0x10AC
34
35 #define GPIO_BASE1 0x2010
36 #define GPIO_BASE2 0x2400
37 #define GPIO_BASE3 0x2010
38
39 #define GPIO_BASE2_VAL 0x000000ff
40 #define GPIO_BASE3_VAL 0x00000000
41
42 #define IOCFG2_BASE_ADDR 0x112F0000
43 #define IOCFG3_BASE_ADDR 0x10FF0000
44 #define GPIO_BASE_ADDR 0x120D0000
45 #define BASE_ADDR_REMAP_SIZE 0x10000
46
47 #define I2S_IOCFG3_BASE1 0x44
48 #define I2S_IOCFG3_BASE1_VAL 0x0600
49
50 static void *g_regAiaoBase = NULL; // AIAO Reg Base Addr
51 static const int g_hiAiDevMaxNum = 3;
52 static const int g_hiAoDevMaxNum = 3;
53 static const int g_wChannelIdMax = 13;
54
55 static const AiaoClkInfo g_aioClkInfo = {
56 .clkSelect = 0, /* 0 is Audio base clk; 1 is Audio spare clk. */
57 .mclkDiv48k256fs = 0x00152EF0, /* 48k * 256 */
58 .mclkDiv441k256fs = 0x00137653, /* 44.1k * 256 */
59 .mclkDiv32k256fs = 0x000E1F4B, /* 32k * 256 */
60 .mclkDiv48k320fs = 0x001A7AAC, /* 48k * 320 */
61 .mclkDiv441k320fs = 0x00185FA0, /* 44.1k * 320 */
62 .mclkDiv32k320fs = 0x0011A71E, /* 32k * 320 */
63 };
64
AiopRegCfg(const int reg,const int offset,uint32_t n)65 uint32_t AiopRegCfg(const int reg, const int offset, uint32_t n)
66 {
67 return reg + offset * n;
68 }
69
70 /* Mapping physical address to virtual address, for acodec and aiao */
AiaoHalSysInit(void)71 int32_t AiaoHalSysInit(void)
72 {
73 // AIAO REMAP
74 if (g_regAiaoBase == NULL) {
75 g_regAiaoBase = OsalIoRemap(AIAO_REG_BASE, AIAO_MAX_REG_SIZE);
76 if (g_regAiaoBase == NULL) {
77 return HDF_FAILURE;
78 }
79 }
80 return HDF_SUCCESS;
81 }
82
AiaoClockReset(void)83 int32_t AiaoClockReset(void)
84 {
85 volatile const unsigned int crgVal = 0xa; // AIAO CLOCK RESET
86
87 /* RESET AIAO */
88 volatile char *vAddr = OsalIoRemap(PERI_CRG103, sizeof(unsigned int));
89 if (vAddr == NULL) {
90 AUDIO_DEVICE_LOG_ERR("vAddr is null \n");
91 return HDF_FAILURE;
92 }
93
94 OSAL_WRITEL(crgVal, vAddr);
95 OsalIoUnmap((void *)((uintptr_t)(void*)vAddr));
96 return HDF_SUCCESS;
97 }
98
AiaoHalReadReg(uint32_t offset)99 uint32_t AiaoHalReadReg(uint32_t offset)
100 {
101 if (g_regAiaoBase == NULL) {
102 AUDIO_DEVICE_LOG_ERR("g_regAiaoBase is null.\n");
103 return 0x0;
104 }
105
106 return (*(volatile uint32_t *)((unsigned char *)g_regAiaoBase + (unsigned int)offset));
107 }
108
AiaoGetBclkSel(const unsigned int bclkDiv,unsigned int * bclkSel)109 static int32_t AiaoGetBclkSel(const unsigned int bclkDiv, unsigned int *bclkSel)
110 {
111 const int bclkDivReg[12][2] = {
112 {1, 0x00}, {2, 0x02}, {3, 0x01},
113 {4, 0x03}, {6, 0x04}, {8, 0x05},
114 {12, 0x06}, {16, 0x07}, {24, 0x08},
115 {32, 0x09}, {48, 0x0a}, {64, 0x0b},
116 }; // AIO_MCLK_TO_BCLK
117 if (bclkSel == NULL) {
118 AUDIO_DEVICE_LOG_ERR("bclkSel is null.");
119 return HDF_FAILURE;
120 }
121
122 for (int32_t num = 0; num < sizeof(bclkDivReg) / sizeof(bclkDivReg[0]); num++) {
123 if (bclkDivReg[num][0] == bclkDiv) {
124 *bclkSel = bclkDivReg[num][1];
125 return HDF_SUCCESS;
126 }
127 }
128 return HDF_FAILURE;
129 }
130
AiaoGetLrclkSel(const unsigned int lrclkDiv,unsigned int * lrclkSel)131 static int32_t AiaoGetLrclkSel(const unsigned int lrclkDiv, unsigned int *lrclkSel)
132 {
133 const int lrclkDivReg[6][2] = {
134 {16, 0x00}, {32, 0x01}, {48, 0x02},
135 {64, 0x03}, {128, 0x04}, {256, 0x05},
136 }; // AIO_BCLK_TO_FSCLK
137 if (lrclkSel == NULL) {
138 AUDIO_DEVICE_LOG_ERR("lrclkSel is null.\n");
139 return HDF_FAILURE;
140 }
141
142 for (int32_t num = 0; num < sizeof(lrclkDivReg) / sizeof(lrclkDivReg[0]); num++) {
143 if (lrclkDivReg[num][0] == lrclkDiv) {
144 *lrclkSel = lrclkDivReg[num][1];
145 return HDF_SUCCESS;
146 }
147 }
148 return HDF_FAILURE;
149 }
150
AiaoHalWriteReg(unsigned int offset,unsigned int value)151 void AiaoHalWriteReg(unsigned int offset, unsigned int value)
152 {
153 if (g_regAiaoBase == NULL) {
154 AUDIO_DEVICE_LOG_ERR("g_aio_base is null.\n");
155 return;
156 }
157
158 *(volatile unsigned int *)((unsigned char *)(g_regAiaoBase) + (unsigned int)(offset)) = value;
159 }
160
AiaoSysPinMux(void)161 int32_t AiaoSysPinMux(void)
162 {
163 void *regIocfg3Base = OsalIoRemap(IOCFG3_BASE_ADDR, BASE_ADDR_REMAP_SIZE);
164 if (regIocfg3Base == NULL) {
165 AUDIO_DEVICE_LOG_ERR("regIocfg3Base is NULL.");
166 return HDF_FAILURE;
167 }
168
169 void *regGpioBase = OsalIoRemap(GPIO_BASE_ADDR, BASE_ADDR_REMAP_SIZE);
170 if (regGpioBase == NULL) {
171 OsalIoUnmap(regIocfg3Base);
172 AUDIO_DEVICE_LOG_ERR("regGpioBase is NULL.");
173 return HDF_FAILURE;
174 }
175
176 AUDIO_DEVICE_LOG_DEBUG("I2s0PinMuxAmpUnmute AmpUnmute");
177 SysWritel((uintptr_t)regIocfg3Base + I2S_IOCFG3_BASE1, I2S_IOCFG3_BASE1_VAL);
178 SysWritel((uintptr_t)regGpioBase + GPIO_BASE1, GPIO_BASE3_VAL);
179 SysWritel((uintptr_t)regGpioBase + GPIO_BASE2, GPIO_BASE2_VAL);
180 SysWritel((uintptr_t)regGpioBase + GPIO_BASE3, GPIO_BASE3_VAL);
181
182 OsalIoUnmap(regGpioBase);
183 OsalIoUnmap(regIocfg3Base);
184
185 return HDF_SUCCESS;
186 }
187
AipHalSetBufferAddr(unsigned int chnId,unsigned long long value)188 static int32_t AipHalSetBufferAddr(unsigned int chnId, unsigned long long value)
189 {
190 unsigned int saddr;
191
192 if (chnId >= g_wChannelIdMax) {
193 AUDIO_DEVICE_LOG_ERR("ai_dev%d is invalid!\n", chnId);
194 return HDF_FAILURE;
195 }
196
197 saddr = (unsigned int)(value & 0xffffffff);
198 AiaoHalWriteReg(AiopRegCfg(AIP_BUFF_SADDR_REG, OFFSET_MULTL, chnId), saddr); // buf start
199
200 return HDF_SUCCESS;
201 }
202
AipHalSetBuffWptr(unsigned int chnId,unsigned int value)203 int32_t AipHalSetBuffWptr(unsigned int chnId, unsigned int value)
204 {
205 UTxBuffWptr unTmp;
206
207 if (chnId >= g_wChannelIdMax) {
208 AUDIO_DEVICE_LOG_ERR("ao_dev%d is invalid!\n", chnId);
209 return HDF_FAILURE;
210 }
211 unTmp.u32 = AiaoHalReadReg(AiopRegCfg(AIP_BUFF_WPTR_REG, OFFSET_MULTL, chnId));
212 unTmp.Bits.txBuffWptr = value;
213 AiaoHalWriteReg(AiopRegCfg(AIP_BUFF_WPTR_REG, OFFSET_MULTL, chnId), unTmp.u32);
214
215 return HDF_SUCCESS;
216 }
217
AipHalSetBuffRptr(unsigned int chnId,unsigned int value)218 int32_t AipHalSetBuffRptr(unsigned int chnId, unsigned int value)
219 {
220 UTxBuffRptr unTmp;
221
222 if (chnId >= g_hiAiDevMaxNum) {
223 AUDIO_DEVICE_LOG_ERR("ai_dev%d is invalid!\n", chnId);
224 return HDF_FAILURE;
225 }
226
227 unTmp.u32 = AiaoHalReadReg(AiopRegCfg(AIP_BUFF_RPTR_REG, OFFSET_MULTL, chnId));
228 if (unTmp.Bits.txBuffRptr != value) {
229 unTmp.Bits.txBuffRptr = value;
230 AiaoHalWriteReg(AiopRegCfg(AIP_BUFF_RPTR_REG, OFFSET_MULTL, chnId), unTmp.u32);
231 }
232
233 return HDF_SUCCESS;
234 }
235
AipHalSetBufferSize(unsigned int chnId,unsigned int value)236 static int32_t AipHalSetBufferSize(unsigned int chnId, unsigned int value)
237 {
238 UTxBuffSize unTmp;
239
240 if (chnId >= g_hiAoDevMaxNum) {
241 AUDIO_DEVICE_LOG_ERR("ao_dev%d is invalid!\n", chnId);
242 return HDF_FAILURE;
243 }
244
245 unTmp.u32 = AiaoHalReadReg(AiopRegCfg(AIP_BUFF_SIZE_REG, OFFSET_MULTL, chnId));
246 unTmp.Bits.txBuffSize = value;
247 AiaoHalWriteReg(AiopRegCfg(AIP_BUFF_SIZE_REG, OFFSET_MULTL, chnId), unTmp.u32);
248
249 return HDF_SUCCESS;
250 }
251
AipHalSetTransSize(unsigned int chnId,unsigned int value)252 static int32_t AipHalSetTransSize(unsigned int chnId, unsigned int value)
253 {
254 UTxTransSize unTmp;
255
256 if (chnId >= g_hiAoDevMaxNum) {
257 AUDIO_DEVICE_LOG_ERR("ai_dev%d is invalid!\n", chnId);
258 return HDF_FAILURE;
259 }
260
261 unTmp.u32 = AiaoHalReadReg(AiopRegCfg(AIP_TRANS_SIZE_REG, OFFSET_MULTL, chnId));
262 unTmp.Bits.txTransSize = value;
263 AiaoHalWriteReg(AiopRegCfg(AIP_TRANS_SIZE_REG, OFFSET_MULTL, chnId), unTmp.u32);
264
265 return HDF_SUCCESS;
266 }
267
AipHalSetRxStart(unsigned int chnId,bool en)268 int32_t AipHalSetRxStart(unsigned int chnId, bool en)
269 {
270 URxDspCtrl unTmp;
271
272 if (chnId >= g_hiAiDevMaxNum) {
273 AUDIO_DEVICE_LOG_ERR("AipHalSetRxStart chnId %d is invalid!\n", chnId);
274 return -1;
275 }
276
277 unTmp.u32 = AiaoHalReadReg(AiopRegCfg(AIP_CTRL_REG, OFFSET_MULTL, chnId));
278
279 unTmp.Bits.rxDisableDone = 0;
280 unTmp.Bits.rxEnable = en;
281
282 AiaoHalWriteReg(AiopRegCfg(AIP_CTRL_REG, OFFSET_MULTL, chnId), unTmp.u32);
283
284 return 0;
285 }
286
AopSetCtrlReg(unsigned int chnId)287 static void AopSetCtrlReg(unsigned int chnId)
288 {
289 UTxDspCtrl aopCtrlReg;
290 aopCtrlReg.Bits.reserved0 = 0;
291 aopCtrlReg.Bits.volume = 0x79; /* 0db */
292 aopCtrlReg.Bits.txEnable = 0;
293 aopCtrlReg.Bits.reserved1 = 0;
294 aopCtrlReg.Bits.reserved2 = 0;
295
296 AiaoHalWriteReg(AiopRegCfg(AOP_CTRL_REG, OFFSET_MULTL, chnId), aopCtrlReg.u32);
297 AUDIO_DEVICE_LOG_DEBUG("[OHOS] AopSetCtrlReg AopSetAttrReg write = %08x\n", aopCtrlReg.u32);
298 }
299
AopHalSetBufferAddr(unsigned int chnId,unsigned long long value)300 static int32_t AopHalSetBufferAddr(unsigned int chnId, unsigned long long value)
301 {
302 unsigned int saddr;
303
304 if (chnId >= g_wChannelIdMax) {
305 AUDIO_DEVICE_LOG_ERR("ao_dev%d is invalid!\n", chnId);
306 return HDF_FAILURE;
307 }
308
309 saddr = (unsigned int)(value & 0xffffffff);
310 AiaoHalWriteReg(AiopRegCfg(AOP_BUFF_SADDR_REG, OFFSET_MULTL, chnId), saddr); // buf start
311
312 return HDF_SUCCESS;
313 }
314
AopHalSetBuffWptr(unsigned int chnId,unsigned int value)315 int32_t AopHalSetBuffWptr(unsigned int chnId, unsigned int value)
316 {
317 UTxBuffWptr unTmp;
318
319 if (chnId >= g_wChannelIdMax) {
320 AUDIO_DEVICE_LOG_ERR("ao_dev%d is invalid!\n", chnId);
321 return HDF_FAILURE;
322 }
323
324 unTmp.u32 = AiaoHalReadReg(AiopRegCfg(AOP_BUFF_WPTR_REG, OFFSET_MULTL, chnId));
325 unTmp.Bits.txBuffWptr = value;
326 AiaoHalWriteReg(AiopRegCfg(AOP_BUFF_WPTR_REG, OFFSET_MULTL, chnId), unTmp.u32);
327
328 return HDF_SUCCESS;
329 }
330
AopHalSetBuffRptr(unsigned int chnId,unsigned int value)331 int32_t AopHalSetBuffRptr(unsigned int chnId, unsigned int value)
332 {
333 UTxBuffRptr unTmp;
334
335 if (chnId >= g_wChannelIdMax) {
336 AUDIO_DEVICE_LOG_ERR("ao_dev%d is invalid!\n", chnId);
337 return HDF_FAILURE;
338 }
339
340 unTmp.u32 = AiaoHalReadReg(AiopRegCfg(AOP_BUFF_RPTR_REG, OFFSET_MULTL, chnId));
341
342 unTmp.Bits.txBuffRptr = value;
343 AiaoHalWriteReg(AiopRegCfg(AOP_BUFF_RPTR_REG, OFFSET_MULTL, chnId), unTmp.u32);
344 return HDF_SUCCESS;
345 }
346
AopHalSetBufferSize(unsigned int chnId,unsigned int value)347 static int32_t AopHalSetBufferSize(unsigned int chnId, unsigned int value)
348 {
349 UTxBuffSize unTmp;
350
351 if (chnId >= g_hiAoDevMaxNum) {
352 AUDIO_DEVICE_LOG_ERR("ao_dev%d is invalid!\n", chnId);
353 return HDF_FAILURE;
354 }
355
356 unTmp.u32 = AiaoHalReadReg(AiopRegCfg(AOP_BUFF_SIZE_REG, OFFSET_MULTL, chnId));
357
358 unTmp.Bits.txBuffSize = value;
359 AiaoHalWriteReg(AiopRegCfg(AOP_BUFF_SIZE_REG, OFFSET_MULTL, chnId), unTmp.u32);
360
361 return HDF_SUCCESS;
362 }
363
AopHalSetTransSize(unsigned int chnId,unsigned int value)364 static int32_t AopHalSetTransSize(unsigned int chnId, unsigned int value)
365 {
366 UTxTransSize unTmp;
367
368 if (chnId >= g_hiAoDevMaxNum) {
369 AUDIO_DEVICE_LOG_ERR("ao_dev%d is invalid!\n", chnId);
370 return HDF_FAILURE;
371 }
372
373 unTmp.u32 = AiaoHalReadReg(AiopRegCfg(AOP_TRANS_SIZE_REG, OFFSET_MULTL, chnId));
374
375 unTmp.Bits.txTransSize = value;
376 AiaoHalWriteReg(AiopRegCfg(AOP_TRANS_SIZE_REG, OFFSET_MULTL, chnId), unTmp.u32);
377
378 return HDF_SUCCESS;
379 }
380
AopHalSetTxStart(unsigned int chnId,bool en)381 int32_t AopHalSetTxStart(unsigned int chnId, bool en)
382 {
383 UTxDspCtrl unTmp;
384
385 if (chnId >= g_hiAoDevMaxNum) {
386 AUDIO_DEVICE_LOG_ERR("ao_dev%d is invalid!\n", chnId);
387 return HDF_FAILURE;
388 }
389
390 unTmp.u32 = AiaoHalReadReg(AiopRegCfg(AOP_CTRL_REG, OFFSET_MULTL, chnId));
391 unTmp.Bits.txEnable = en;
392
393 AiaoHalWriteReg(AiopRegCfg(AOP_CTRL_REG, OFFSET_MULTL, chnId), unTmp.u32);
394
395 return HDF_SUCCESS;
396 }
397
AopHalDevEnable(unsigned int chnId)398 int32_t AopHalDevEnable(unsigned int chnId)
399 {
400 int ret = AopHalSetTxStart(chnId, HI_TRUE);
401 if (ret != HDF_SUCCESS) {
402 return HDF_FAILURE;
403 }
404 return HDF_SUCCESS;
405 }
406
AiaoGetBclkFsclk(const unsigned int fsBit,const unsigned int rate,const int32_t mclkSel,int32_t * bclkSel,int32_t * lrclkSel)407 static int32_t AiaoGetBclkFsclk(const unsigned int fsBit, const unsigned int rate,
408 const int32_t mclkSel, int32_t *bclkSel, int32_t *lrclkSel)
409 {
410 int32_t ret;
411 unsigned int mclkRateNum;
412 const int aioFifoBitWidth256 = 256; // 256 is aiao fifo bit width
413 const int aioFifoBitWidth320 = 320; // 320 is aiao fifo bit width
414
415 if (g_aioClkInfo.mclkDiv48k256fs == mclkSel) {
416 mclkRateNum = AUDIO_SAMPLE_RATE_48000 * aioFifoBitWidth256;
417 } else if (g_aioClkInfo.mclkDiv32k256fs == mclkSel) {
418 mclkRateNum = AUDIO_SAMPLE_RATE_32000 * aioFifoBitWidth256;
419 } else if (g_aioClkInfo.mclkDiv441k256fs == mclkSel) {
420 mclkRateNum = AUDIO_SAMPLE_RATE_44100 * aioFifoBitWidth256;
421 } else if (g_aioClkInfo.mclkDiv48k320fs == mclkSel) {
422 mclkRateNum = AUDIO_SAMPLE_RATE_48000 * aioFifoBitWidth320;
423 } else if (g_aioClkInfo.mclkDiv32k320fs == mclkSel) {
424 mclkRateNum = AUDIO_SAMPLE_RATE_32000 * aioFifoBitWidth320;
425 } else if (g_aioClkInfo.mclkDiv441k320fs == mclkSel) {
426 mclkRateNum = AUDIO_SAMPLE_RATE_44100 * aioFifoBitWidth320;
427 } else {
428 AUDIO_DEVICE_LOG_ERR("not support this mclk\n");
429 return HDF_FAILURE;
430 }
431
432 if ((mclkRateNum % (fsBit * rate)) != 0) {
433 AUDIO_DEVICE_LOG_ERR("can not get the bclkDivision ratio\n");
434 return HDF_FAILURE;
435 }
436
437 ret = AiaoGetBclkSel(mclkRateNum / (fsBit * rate), bclkSel);
438 if (ret != HDF_SUCCESS) {
439 AUDIO_DEVICE_LOG_ERR("AiaoGetBclkSel error\n");
440 return ret;
441 }
442
443 ret = AiaoGetLrclkSel(fsBit, lrclkSel);
444
445 return ret;
446 }
447
AiaoGetMclk(unsigned int rate,uint32_t * mclkSel)448 int32_t AiaoGetMclk(unsigned int rate, uint32_t *mclkSel)
449 {
450 if (mclkSel == NULL) {
451 AUDIO_DEVICE_LOG_ERR("mclkSel is null");
452 return HDF_FAILURE;
453 }
454 switch (rate) {
455 case AUDIO_SAMPLE_RATE_8000:
456 case AUDIO_SAMPLE_RATE_16000:
457 case AUDIO_SAMPLE_RATE_32000:
458 case AUDIO_SAMPLE_RATE_64000: {
459 *mclkSel = g_aioClkInfo.mclkDiv32k256fs;
460 break;
461 }
462
463 case AUDIO_SAMPLE_RATE_12000:
464 case AUDIO_SAMPLE_RATE_24000:
465 case AUDIO_SAMPLE_RATE_48000:
466 case AUDIO_SAMPLE_RATE_96000: {
467 *mclkSel = g_aioClkInfo.mclkDiv48k256fs;
468 break;
469 }
470
471 case AUDIO_SAMPLE_RATE_11025:
472 case AUDIO_SAMPLE_RATE_22050:
473 case AUDIO_SAMPLE_RATE_44100: {
474 *mclkSel = g_aioClkInfo.mclkDiv441k256fs;
475 break;
476 }
477
478 default: {
479 AUDIO_DEVICE_LOG_ERR("not support this sample rate\n");
480 return HDF_FAILURE;
481 }
482 }
483
484 return HDF_SUCCESS;
485 }
486
AiaoGetBitCnt(unsigned int bitWidth)487 static unsigned int AiaoGetBitCnt(unsigned int bitWidth)
488 {
489 if (bitWidth == BIT_WIDTH8) {
490 return BIT_WIDTH8; /* 8:8bit */
491 } else if (bitWidth == BIT_WIDTH16) {
492 return BIT_WIDTH16; /* 16:16bit */
493 } else {
494 return BIT_WIDTH32; /* 32:32bit */
495 }
496 }
497
AiaoSetSysCtlRegValue(uint32_t mclkSel,uint32_t bitWidth,uint32_t rate,uint32_t * clkRegVal)498 int32_t AiaoSetSysCtlRegValue(uint32_t mclkSel, uint32_t bitWidth, uint32_t rate, uint32_t *clkRegVal)
499 {
500 int32_t ret;
501 uint32_t fsBit;
502 uint32_t bclkSel;
503 uint32_t lrClkSel;
504
505 if (clkRegVal == NULL) {
506 AUDIO_DEVICE_LOG_ERR("param is nullptr.");
507 return HDF_ERR_INVALID_PARAM;
508 }
509 fsBit = AiaoGetBitCnt(bitWidth) * 2; // 2 is bit width
510 (void)memset_s(&bclkSel, sizeof(uint32_t), 0, sizeof(uint32_t));
511 (void)memset_s(&lrClkSel, sizeof(uint32_t), 0, sizeof(uint32_t));
512 ret = AiaoGetBclkFsclk(fsBit, rate, mclkSel, &bclkSel, &lrClkSel);
513 if (ret != HDF_SUCCESS) {
514 AUDIO_DEVICE_LOG_ERR("AiaoGetBclkFsclk fail");
515 return HDF_FAILURE;
516 }
517
518 *clkRegVal = bclkSel | (lrClkSel << 4); /* 4:left shift 4 bit */
519
520 return HDF_SUCCESS;
521 }
522
AipSetCtrlReg(unsigned int chnId)523 static void AipSetCtrlReg(unsigned int chnId)
524 {
525 URxDspCtrl aipCtrlReg;
526 aipCtrlReg.Bits.reserved0 = 0;
527 aipCtrlReg.Bits.rxEnable = 0;
528 aipCtrlReg.Bits.rxDisableDone = 0;
529 aipCtrlReg.Bits.reserved1 = 0;
530 AiaoHalWriteReg(AiopRegCfg(AIP_CTRL_REG, OFFSET_MULTL, chnId), aipCtrlReg.u32);
531 }
532
AiaoRxIntClr(unsigned int chnId)533 int32_t AiaoRxIntClr(unsigned int chnId)
534 {
535 const unsigned int rxTransIntClear = 0x1;
536 AiaoHalWriteReg(AiopRegCfg(RX_INT_CLR, OFFSET_MULTL, chnId), rxTransIntClear);
537 return HDF_SUCCESS;
538 }
539
AiaoDeviceInit(unsigned int chnId)540 int32_t AiaoDeviceInit(unsigned int chnId)
541 {
542 const unsigned int aipAttrVal = 0xe4880014;
543 const unsigned int aopAttrVal = 0xe4000054;
544
545 const unsigned int rxIntEnaVal = 0x1;
546 const unsigned int rxCh0IntEna = 0x1;
547
548 AiaoHalWriteReg(AiopRegCfg(AIP_INF_ATTRI_REG, OFFSET_MULTL, chnId), aipAttrVal);
549 AiaoHalWriteReg(AiopRegCfg(AOP_INF_ATTRI_REG, OFFSET_MULTL, chnId), aopAttrVal);
550 AopSetCtrlReg(chnId);
551 AipSetCtrlReg(chnId);
552
553 AiaoHalWriteReg(AiopRegCfg(AIAO_INT_ENA, OFFSET_MULTL, chnId), rxCh0IntEna);
554 AiaoHalWriteReg(AiopRegCfg(RX_INT_ENA, OFFSET_MULTL, chnId), rxIntEnaVal);
555 return HDF_SUCCESS;
556 }
557
AudioAoInit(const struct PlatformData * platformData)558 int32_t AudioAoInit(const struct PlatformData *platformData)
559 {
560 int ret;
561
562 if (platformData == NULL || platformData->renderBufInfo.phyAddr == 0) {
563 AUDIO_DEVICE_LOG_ERR("input param is NULL.");
564 return HDF_FAILURE;
565 }
566
567 ret = AopHalSetBufferAddr(0, platformData->renderBufInfo.phyAddr);
568 if (ret != HDF_SUCCESS) {
569 AUDIO_DEVICE_LOG_ERR("AopHalSetBufferAddr fail.");
570 return HDF_FAILURE;
571 }
572
573 ret = AopHalSetBufferSize(0, platformData->renderBufInfo.cirBufSize);
574 if (ret != HDF_SUCCESS) {
575 AUDIO_DEVICE_LOG_ERR("AopHalSetBufferSize: failed.");
576 return HDF_FAILURE;
577 }
578
579 ret = AopHalSetTransSize(0, platformData->renderBufInfo.trafBufSize);
580 if (ret != HDF_SUCCESS) {
581 AUDIO_DEVICE_LOG_ERR("AopHalSetTransSize fail");
582 return HDF_FAILURE;
583 }
584
585 return HDF_SUCCESS;
586 }
587
AudioAiInit(const struct PlatformData * platformData)588 int32_t AudioAiInit(const struct PlatformData *platformData)
589 {
590 int ret;
591 if (platformData == NULL || platformData->captureBufInfo.phyAddr == 0) {
592 AUDIO_DEVICE_LOG_ERR("input param is NULL.");
593 return HDF_FAILURE;
594 }
595
596 ret = AipHalSetBufferAddr(0, platformData->captureBufInfo.phyAddr);
597 if (ret != HDF_SUCCESS) {
598 AUDIO_DEVICE_LOG_ERR("AipHalSetBufferAddr: failed.");
599 return HDF_FAILURE;
600 }
601
602 ret = AipHalSetBufferSize(0, platformData->captureBufInfo.cirBufSize);
603 if (ret != HDF_SUCCESS) {
604 AUDIO_DEVICE_LOG_ERR("AipHalSetBufferSize: failed.");
605 return HDF_FAILURE;
606 }
607
608 AUDIO_DEVICE_LOG_DEBUG("trafBufSize = 0x%x", platformData->captureBufInfo.trafBufSize);
609
610 ret = AipHalSetTransSize(0, platformData->captureBufInfo.trafBufSize);
611 if (ret != HDF_SUCCESS) {
612 AUDIO_DEVICE_LOG_ERR("AipHalSetTransSize fail.");
613 return HDF_FAILURE;
614 }
615 return HDF_SUCCESS;
616 }
617