1 /*
2  * Copyright (C) 2022 HiHope Open Source Organization .
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 #include "es8323_codec_impl.h"
9 #include "audio_control.h"
10 #include "audio_core.h"
11 #include "audio_host.h"
12 #include "audio_parse.h"
13 #include "audio_platform_base.h"
14 #include "audio_sapm.h"
15 #include "audio_driver_log.h"
16 #include "i2c_if.h"
17 #include "gpio_if.h"
18 #include "linux/of_gpio.h"
19 #include "audio_stream_dispatch.h"
20 
21 
22 #define HDF_LOG_TAG "es8323_codec"
23 
24 #define RK3588_I2C_BUS_NUMBER      (7)    // i2c7(master)
25 /* ES8323 I2C Device address 0 0 1 0 0 0 AD0 R/W */
26 #define ES8323_I2C_DEV_ADDR        (0x10) // 0010000 (slave)
27 #define ES8323_I2C_REG_DATA_LEN    (1)    // reg value length is 8 bits
28 
29 #define ES8323_I2C_WAIT_TIMES      (10)   // ms
30 
31 #define RK3588_GPIO_NUMBER         (131)   // gpio4 RK_PA3;
32 
33 /* Original accessory_base implements */
34 #define ES8323_COMM_SHIFT_8BIT     (8)
35 #define ES8323_COMM_MASK_FF        (0xFF)
36 
37 #define ES8323_I2C_REG_SIZE        (1)
38 #define ES8323_I2C_MSG_NUM         (2)
39 #define ES8323_I2C_MSG_BUF_SIZE    (2)
40 
41 #define NUM_NEG_SIXTEEN            (-16)
42 #define es8323_DEF_VOL	0x1b
43 struct AudioRegCfgGroupNode **g_es8323RegCfgGroupNode = NULL;
44 struct AudioKcontrol *g_es8323Controls = NULL;
45 struct Es8323TransferData g_es8323TransferData;
46 
47 static const char *g_audioControlsList[AUDIO_CTRL_LIST_MAX] = {
48     "Main Playback Volume", "Main Capture Volume",
49     "Playback Mute", "Capture Mute", "Mic Left Gain",
50     "Mic Right Gain", "External Codec Enable",
51     "Internally Codec Enable", "Render Channel Mode", "Captrue Channel Mode"
52 };
53 
54 
55 /*
56  * release I2C object public function
57  */
Es8323I2cRelease(struct I2cMsg *msgs, int16_t msgSize, DevHandle i2cHandle)58 static void Es8323I2cRelease(struct I2cMsg *msgs, int16_t msgSize, DevHandle i2cHandle)
59 {
60     if (msgs != NULL) {
61         if (msgSize == 0 && msgs->buf != NULL) {
62             OsalMemFree(msgs->buf);
63             msgs->buf = NULL;
64         } else if (msgSize == 1 && msgs[0].buf != NULL) {
65             OsalMemFree(msgs[0].buf);
66             msgs[0].buf = NULL;
67         } else if (msgSize >= ES8323_I2C_MSG_NUM) {
68             if (msgs[0].buf != NULL) {
69                 msgs[0].buf = NULL;
70             }
71             if (msgs[1].buf != NULL) {
72                 OsalMemFree(msgs[1].buf);
73                 msgs[1].buf = NULL;
74             }
75         }
76         AUDIO_DRIVER_LOG_DEBUG("OsalMemFree msgBuf success.\n");
77     }
78     // close i2c device
79     if (i2cHandle != NULL) {
80         I2cClose(i2cHandle);
81         i2cHandle = NULL;
82         AUDIO_DRIVER_LOG_DEBUG("I2cClose success.\n");
83     }
84 }
85 
Es8323I2cMsgFill(const struct AudioAddrConfig *regAttr, uint16_t rwFlag, uint8_t *regs, struct I2cMsg *msgs)86 static int32_t Es8323I2cMsgFill(const struct AudioAddrConfig *regAttr, uint16_t rwFlag,
87     uint8_t *regs, struct I2cMsg *msgs)
88 {
89     uint8_t *msgBuf = NULL;
90     if (rwFlag != 0 && rwFlag != I2C_FLAG_READ) {
91         AUDIO_DRIVER_LOG_ERR("invalid rwFlag value: %d.", rwFlag);
92         return HDF_ERR_INVALID_PARAM;
93     }
94     regs[0] = regAttr->addr;
95     msgs[0].addr = ES8323_I2C_DEV_ADDR;
96     msgs[0].flags = 0;
97     msgs[0].len = ES8323_I2C_REG_DATA_LEN + 1;
98     //AUDIO_DRIVER_LOG_DEBUG("msgs[0].addr=0x%02x, regs[0]=0x%02x.", msgs[0].addr, regs[0]);
99     if (rwFlag == 0) { // write
100         // S 11011A2A1 0 A ADDR A MS1 A LS1 A <....> P
101         msgBuf = OsalMemCalloc(ES8323_I2C_REG_DATA_LEN + 1);
102         if (msgBuf == NULL) {
103             AUDIO_DRIVER_LOG_ERR("[write]: malloc buf failed!");
104             return HDF_ERR_MALLOC_FAIL;
105         }
106         msgBuf[0] = regs[0];
107         msgBuf[1] = (uint8_t)regAttr->value;
108         if (ES8323_I2C_REG_DATA_LEN == ES8323_I2C_MSG_BUF_SIZE) { // when 2 bytes
109             msgBuf[1] = (regAttr->value >> ES8323_COMM_SHIFT_8BIT); // High 8 bits
110             msgBuf[ES8323_I2C_MSG_BUF_SIZE] = (uint8_t)(regAttr->value & ES8323_COMM_MASK_FF);    // Low 8 bits
111         }
112         msgs[0].buf = msgBuf;
113         //AUDIO_DRIVER_LOG_DEBUG("msgs[0].buf=0x%x.", regAttr->value);
114     } else {
115         // S 11011A2A1 0 A ADDR A Sr 11011A2A1 1 A MS1 A LS1 A <....> NA P
116         msgBuf = OsalMemCalloc(ES8323_I2C_REG_DATA_LEN);
117         if (msgBuf == NULL) {
118             AUDIO_DRIVER_LOG_ERR("[read]: malloc buf failed!");
119             return HDF_ERR_MALLOC_FAIL;
120         }
121         msgs[0].len = 1;
122         msgs[0].buf = regs;
123         msgs[1].addr = ES8323_I2C_DEV_ADDR;
124         msgs[1].flags = I2C_FLAG_READ;
125         msgs[1].len = ES8323_I2C_REG_DATA_LEN;
126         msgs[1].buf = msgBuf;
127     }
128     // AUDIO_DRIVER_LOG_DEBUG("success.");
129     return HDF_SUCCESS;
130 }
131 
Es8323I2cReadWrite(struct AudioAddrConfig *regAttr, uint16_t rwFlag)132 static int32_t Es8323I2cReadWrite(struct AudioAddrConfig *regAttr, uint16_t rwFlag)
133 {
134     int32_t ret;
135     DevHandle i2cHandle;
136     int16_t transferMsgCount = 1;
137     uint8_t regs[ES8323_I2C_REG_SIZE];
138     struct I2cMsg msgs[ES8323_I2C_MSG_NUM];
139     (void)memset_s(msgs, sizeof(struct I2cMsg) * ES8323_I2C_MSG_NUM, 0, sizeof(struct I2cMsg) * ES8323_I2C_MSG_NUM);
140 
141     //AUDIO_DRIVER_LOG_DEBUG("entry.\n");
142     if (regAttr == NULL || rwFlag > 1) {
143         AUDIO_DRIVER_LOG_ERR("invalid parameter.");
144         return HDF_ERR_INVALID_PARAM;
145     }
146     i2cHandle = I2cOpen(RK3588_I2C_BUS_NUMBER);
147     if (i2cHandle == NULL) {
148         AUDIO_DRIVER_LOG_ERR("open i2cBus:%u failed! i2cHandle:%p", RK3588_I2C_BUS_NUMBER, i2cHandle);
149         return HDF_FAILURE;
150     }
151     if (rwFlag == I2C_FLAG_READ) {
152         transferMsgCount = ES8323_I2C_MSG_NUM;
153     }
154     ret = Es8323I2cMsgFill(regAttr, rwFlag, regs, msgs);
155     if (ret != HDF_SUCCESS) {
156         AUDIO_DRIVER_LOG_ERR("Es8323I2cMsgFill failed!");
157         I2cClose(i2cHandle);
158         return HDF_FAILURE;
159     }
160     ret = I2cTransfer(i2cHandle, msgs, transferMsgCount);
161     if (ret != transferMsgCount) {
162         AUDIO_DRIVER_LOG_ERR("I2cTransfer err:%d", ret);
163         Es8323I2cRelease(msgs, transferMsgCount, i2cHandle);
164         return HDF_FAILURE;
165     }
166     if (rwFlag == I2C_FLAG_READ) {
167         regAttr->value = msgs[1].buf[0];
168         if (ES8323_I2C_REG_DATA_LEN == ES8323_I2C_MSG_BUF_SIZE) { // when 2 bytes
169             regAttr->value = (msgs[1].buf[0] << ES8323_COMM_SHIFT_8BIT) | msgs[1].buf[1]; // result value 16 bits
170         }
171         AUDIO_DRIVER_LOG_DEBUG("[read]: regAttr->regValue=0x%x.\n", regAttr->value);
172     }
173     Es8323I2cRelease(msgs, transferMsgCount, i2cHandle);
174     return HDF_SUCCESS;
175 }
176 
177 // Read contrl reg bits value
Es8323RegBitsRead(struct AudioMixerControl *regAttr, uint32_t *regValue)178 static int32_t Es8323RegBitsRead(struct AudioMixerControl *regAttr, uint32_t *regValue)
179 {
180     int32_t ret;
181     struct AudioAddrConfig regVal;
182     if (regAttr == NULL || regAttr->reg < 0 || regValue == NULL) {
183         AUDIO_DRIVER_LOG_ERR("input invalid parameter.");
184         return HDF_ERR_INVALID_PARAM;
185     }
186     regVal.addr  = regAttr->reg;
187     ret = Es8323I2cReadWrite(&regVal, I2C_FLAG_READ);
188     if (ret != HDF_SUCCESS) {
189         AUDIO_DRIVER_LOG_ERR("Es8323RegBitsRead failed.");
190         return HDF_FAILURE;
191     }
192     *regValue = regVal.value;
193     regAttr->value = (regVal.value >> regAttr->shift) & regAttr->mask;
194     if (regAttr->value > regAttr->max || regAttr->value < regAttr->min) {
195         AUDIO_DRIVER_LOG_ERR("invalid bitsValue=0x%x", regAttr->value);
196         return HDF_FAILURE;
197     }
198     if (regAttr->invert) {
199         regAttr->value = regAttr->max - regAttr->value;
200     }
201     AUDIO_DRIVER_LOG_DEBUG("regAddr=0x%x, regValue=0x%x, currBitsValue=0x%x",
202         regAttr->reg, regVal.value, regAttr->value);
203     AUDIO_DRIVER_LOG_DEBUG("mask=0x%x, shift=%d, max=0x%x,min=0x%x, invert=%d",
204         regAttr->mask, regAttr->shift, regAttr->max, regAttr->min, regAttr->invert);
205     AUDIO_DRIVER_LOG_DEBUG("success.");
206     return HDF_SUCCESS;
207 }
208 
209 // Update contrl reg bits value
Es8323RegBitsUpdate(struct AudioMixerControl regAttr)210 static int32_t Es8323RegBitsUpdate(struct AudioMixerControl regAttr)
211 {
212     int32_t ret;
213     struct AudioAddrConfig regVal;
214     uint32_t newValue, newMask, value;
215     if (regAttr.reg < 0) {
216         AUDIO_DRIVER_LOG_ERR("input invalid parameter.");
217         return HDF_ERR_INVALID_PARAM;
218     }
219     if (regAttr.invert) {
220         regAttr.value = regAttr.max - regAttr.value;
221     }
222     newValue = regAttr.value << regAttr.shift;
223     newMask = regAttr.mask << regAttr.shift;
224     ret = Es8323RegBitsRead(&regAttr, &value);
225     if (ret != HDF_SUCCESS) {
226         ADM_LOG_ERR("Es8323RegBitsRead faileded, ret=%d.", ret);
227         return HDF_FAILURE;
228     }
229     regVal.value = (value & ~newMask) | (newValue & newMask);
230     regVal.addr  = regAttr.reg;
231     ret = Es8323I2cReadWrite(&regVal, 0);
232     if (ret != HDF_SUCCESS) {
233         AUDIO_DRIVER_LOG_ERR("Es8323I2cReadWrite faileded.");
234         return HDF_FAILURE;
235     }
236     AUDIO_DRIVER_LOG_DEBUG("regAddr=0x%x, regValue=0x%x, oldValue=0x%x, newValue=0x%x,",
237         regAttr.reg, regVal.value, regAttr.value, newValue);
238     AUDIO_DRIVER_LOG_DEBUG(" mask=0x%x, shift=%d, max=0x%x, min=0x%x, invert=%d",
239         newMask, regAttr.shift, regAttr.max, regAttr.min, regAttr.invert);
240     AUDIO_DRIVER_LOG_DEBUG("success.");
241     return HDF_SUCCESS;
242 }
243 
Es8323DaiParamsUpdate4Scene(struct AudioMixerControl *daiHwParamsRegCfgItem, struct Es8323DaiHwParamsTransferData transferData, struct Es8323DaiParamsVal daiParamsVal)244 static int32_t Es8323DaiParamsUpdate4Scene(struct AudioMixerControl *daiHwParamsRegCfgItem,
245     struct Es8323DaiHwParamsTransferData transferData, struct Es8323DaiParamsVal daiParamsVal)
246 {
247     int32_t ret;
248     uint8_t i;
249     ret = (daiHwParamsRegCfgItem == NULL || transferData.daiHwParamsRegCfgItemCount == 0);
250     if (ret) {
251         AUDIO_DEVICE_LOG_ERR("Invaild params.");
252         return HDF_FAILURE;
253     }
254     for (i = transferData.inputParamsBeginIndex; i <= transferData.inputParamsEndIndex; i++) {
255         switch (i) {
256             case ES8323_DHP_RENDER_FREQUENCY_INX:
257             case ES8323_DHP_CAPTURE_FREQUENCY_INX:
258                 daiHwParamsRegCfgItem[i].value = daiParamsVal.frequencyVal;
259                 break;
260             case ES8323_DHP_RENDER_FORMAT_INX:
261             case ES8323_DHP_CAPTURE_FORMAT_INX:
262                 daiHwParamsRegCfgItem[i].value = daiParamsVal.formatVal;
263                 break;
264             case ES8323_DHP_RENDER_CHANNEL_INX:
265             case ES8323_DHP_CAPTURE_CHANNEL_INX:
266                 daiHwParamsRegCfgItem[i].value = daiParamsVal.channelVal;
267                 break;
268             default:
269                 continue;
270         }
271         ret = Es8323RegBitsUpdate(daiHwParamsRegCfgItem[i]);
272         if (ret != HDF_SUCCESS) {
273             AUDIO_DEVICE_LOG_ERR("Es8323RegBitsUpdate failed.");
274             return HDF_FAILURE;
275         }
276     }
277 
278     AUDIO_DEVICE_LOG_DEBUG("success.");
279     return HDF_SUCCESS;
280 }
281 
282 // update external codec I2S frequency
Es8323DaiParamsUpdate(struct Es8323DaiParamsVal daiParamsVal, bool playback)283 static int32_t Es8323DaiParamsUpdate(struct Es8323DaiParamsVal daiParamsVal, bool playback)
284 {
285     int32_t ret;
286     struct AudioMixerControl *daiHwParamsRegCfgItem = NULL;
287     struct Es8323DaiHwParamsTransferData transferData;
288     ret = (g_es8323TransferData.codecRegCfgGroupNode == NULL
289             || g_es8323TransferData.codecRegCfgGroupNode[AUDIO_DAI_PATAM_GROUP] == NULL
290             || g_es8323TransferData.codecRegCfgGroupNode[AUDIO_DAI_PATAM_GROUP]->regCfgItem == NULL);
291     if (ret) {
292         AUDIO_DEVICE_LOG_ERR("g_es8323RegCfgGroupNode[AUDIO_DAI_PATAM_GROUP] is NULL.");
293         return HDF_FAILURE;
294     }
295     daiHwParamsRegCfgItem =
296         g_es8323TransferData.codecRegCfgGroupNode[AUDIO_DAI_PATAM_GROUP]->regCfgItem;
297     transferData.daiHwParamsRegCfgItemCount =
298         g_es8323TransferData.codecRegCfgGroupNode[AUDIO_DAI_PATAM_GROUP]->itemNum;
299     if (!playback) { // capture
300         transferData.inputParamsBeginIndex = ES8323_DHP_CAPTURE_FREQUENCY_INX;
301         transferData.inputParamsEndIndex = ES8323_DHP_CAPTURE_FORMAT_INX;
302     } else { // playback
303         transferData.inputParamsBeginIndex = ES8323_DHP_RENDER_FREQUENCY_INX;
304         transferData.inputParamsEndIndex = ES8323_DHP_RENDER_FORMAT_INX;
305     }
306     ret = Es8323DaiParamsUpdate4Scene(daiHwParamsRegCfgItem, transferData, daiParamsVal);
307     if (ret != HDF_SUCCESS) {
308         AUDIO_DEVICE_LOG_ERR("Es8323DaiParamsUpdate4Scene failed.");
309         return HDF_FAILURE;
310     }
311 
312     AUDIO_DEVICE_LOG_DEBUG("success.");
313     return HDF_SUCCESS;
314 }
315 
316 
Es8323DeviceFrequencyParse(uint32_t rate, uint16_t *freq)317 static int32_t Es8323DeviceFrequencyParse(uint32_t rate, uint16_t *freq)
318 {
319     if (freq == NULL) {
320         AUDIO_DRIVER_LOG_ERR("input param is NULL");
321         return HDF_FAILURE;
322     }
323     switch (rate) {
324         case ES8323_I2S_SAMPLE_FREQUENCY_8000:
325             *freq = 0x0a;
326             break;
327         case ES8323_I2S_SAMPLE_FREQUENCY_11025:
328             *freq = 0x07;
329             break;
330         case ES8323_I2S_SAMPLE_FREQUENCY_16000:
331             *freq = 0x06;
332             break;
333         case ES8323_I2S_SAMPLE_FREQUENCY_22050:
334             *freq = 0x04;
335             break;
336         case ES8323_I2S_SAMPLE_FREQUENCY_32000:
337             *freq = 0x03;
338             break;
339         case ES8323_I2S_SAMPLE_FREQUENCY_44100:
340             *freq = 0x02;
341             break;
342         case ES8323_I2S_SAMPLE_FREQUENCY_48000:
343             *freq = 0x02;
344             break;
345         case ES8323_I2S_SAMPLE_FREQUENCY_88200:
346             *freq = 0x00;
347             break;
348         case ES8323_I2S_SAMPLE_FREQUENCY_96000:
349             *freq = 0x00;
350             break;
351         default:
352             AUDIO_DRIVER_LOG_ERR("rate: %d is not support.", rate);
353             return HDF_ERR_NOT_SUPPORT;
354     }
355     AUDIO_DRIVER_LOG_DEBUG("success.");
356     return HDF_SUCCESS;
357 }
358 
Es8323DeviceCfgGet(struct CodecData *codecData, struct Es8323TransferData *es8323TransferData)359 static int32_t Es8323DeviceCfgGet(struct CodecData *codecData,
360     struct Es8323TransferData *es8323TransferData)
361 {
362     int32_t ret;
363     int32_t index;
364     int32_t audioCfgCtrlCount;
365     struct AudioControlConfig *ctlcfgItem;
366     ret = (codecData == NULL || codecData->regConfig == NULL || es8323TransferData == NULL);
367     if (ret) {
368         AUDIO_DRIVER_LOG_ERR("input para is NULL.");
369         return HDF_FAILURE;
370     }
371     g_es8323RegCfgGroupNode = codecData->regConfig->audioRegParams;
372     ret = (g_es8323RegCfgGroupNode[AUDIO_CTRL_CFG_GROUP] == NULL ||
373             g_es8323RegCfgGroupNode[AUDIO_CTRL_CFG_GROUP]->ctrlCfgItem == NULL ||
374             g_es8323RegCfgGroupNode[AUDIO_CTRL_PATAM_GROUP] == NULL ||
375             g_es8323RegCfgGroupNode[AUDIO_CTRL_PATAM_GROUP]->regCfgItem == NULL);
376     if (ret) {
377         AUDIO_DRIVER_LOG_ERR("parsing params is NULL.");
378         return HDF_FAILURE;
379     }
380     ctlcfgItem = g_es8323RegCfgGroupNode[AUDIO_CTRL_CFG_GROUP]->ctrlCfgItem;
381     audioCfgCtrlCount = g_es8323RegCfgGroupNode[AUDIO_CTRL_CFG_GROUP]->itemNum;
382     g_es8323Controls = (struct AudioKcontrol *)OsalMemCalloc(audioCfgCtrlCount * sizeof(struct AudioKcontrol));
383     es8323TransferData->codecRegCfgGroupNode = g_es8323RegCfgGroupNode;
384     es8323TransferData->codecCfgCtrlCount = audioCfgCtrlCount;
385     es8323TransferData->codecControls = g_es8323Controls;
386     for (index = 0; index < audioCfgCtrlCount; index++) {
387         g_es8323Controls[index].iface = ctlcfgItem[index].iface;
388         g_es8323Controls[index].name  = g_audioControlsList[ctlcfgItem[index].arrayIndex];
389         g_es8323Controls[index].Info  = AudioInfoCtrlOps;
390         g_es8323Controls[index].privateValue =
391             (unsigned long)&g_es8323RegCfgGroupNode[AUDIO_CTRL_PATAM_GROUP]->regCfgItem[index];
392         g_es8323Controls[index].Get = AudioCodecGetCtrlOps;
393         g_es8323Controls[index].Set = AudioCodecSetCtrlOps;
394     }
395     return HDF_SUCCESS;
396 }
397 
398 /*
399  * init control reg to default value
400  */
Es8323DeviceCtrlRegInit(void)401 static int32_t Es8323DeviceCtrlRegInit(void)
402 {
403     int32_t ret, i;
404     struct AudioAddrConfig *initCfg;
405     // Set codec control register(00h-14h) default value
406     ret = (g_es8323RegCfgGroupNode == NULL || g_es8323RegCfgGroupNode[AUDIO_INIT_GROUP] == NULL
407             || g_es8323RegCfgGroupNode[AUDIO_INIT_GROUP]->addrCfgItem == NULL);
408     if (ret) {
409         AUDIO_DRIVER_LOG_ERR("g_es8323RegCfgGroupNode[AUDIO_INIT_GROUP] is NULL.");
410         return HDF_FAILURE;
411     }
412     initCfg = g_es8323RegCfgGroupNode[AUDIO_INIT_GROUP]->addrCfgItem;
413     for (i = 0; i < g_es8323RegCfgGroupNode[AUDIO_INIT_GROUP]->itemNum; i++) {
414         AUDIO_DRIVER_LOG_DEBUG("i=%d, Addr = [0x%2x]", i, initCfg[i].addr);
415         ret = Es8323I2cReadWrite(&initCfg[i], 0);
416         if (ret != HDF_SUCCESS) {
417             AUDIO_DRIVER_LOG_ERR("Es8323I2cReadWrite(write) err, regAttr.regAddr: 0x%x.\n",
418                 initCfg[i].addr);
419             return HDF_FAILURE;
420         }
421         OsalMSleep(ES8323_I2C_WAIT_TIMES);
422     }
423     AUDIO_DRIVER_LOG_DEBUG("success.");
424     return HDF_SUCCESS;
425 }
426 
Es8323DeviceRegRead(const struct CodecDevice *codec, uint32_t reg, uint32_t *val)427 int32_t Es8323DeviceRegRead(const struct CodecDevice *codec, uint32_t reg, uint32_t *val)
428 {
429     int32_t ret;
430     struct AudioAddrConfig regAttr;
431     if (val == NULL) {
432         AUDIO_DRIVER_LOG_ERR("input para is NULL.");
433         return HDF_ERR_INVALID_OBJECT;
434     }
435     regAttr.addr = (uint8_t)reg;
436     regAttr.value = 0;
437     ret = Es8323I2cReadWrite(&regAttr, I2C_FLAG_READ);
438     if (ret != HDF_SUCCESS) {
439         AUDIO_DRIVER_LOG_ERR("failed.");
440         return HDF_FAILURE;
441     }
442     *val = regAttr.value;
443     AUDIO_DRIVER_LOG_DEBUG("success");
444     return HDF_SUCCESS;
445 }
446 
Es8323DeviceRegWrite(const struct CodecDevice *codec, uint32_t reg, uint32_t value)447 int32_t Es8323DeviceRegWrite(const struct CodecDevice *codec, uint32_t reg, uint32_t value)
448 {
449     int32_t ret;
450     struct AudioAddrConfig regAttr;
451     regAttr.addr = (uint8_t)reg;
452     regAttr.value = (uint16_t)value;
453     ret = Es8323I2cReadWrite(&regAttr, 0);
454     if (ret != HDF_SUCCESS) {
455         AUDIO_DRIVER_LOG_ERR("failed.");
456         return HDF_FAILURE;
457     }
458     AUDIO_DRIVER_LOG_DEBUG("success");
459     return HDF_SUCCESS;
460 }
461 
Es8323GetConfigInfo(const struct HdfDeviceObject *device, struct CodecData *codecData)462 int32_t Es8323GetConfigInfo(const struct HdfDeviceObject *device, struct CodecData *codecData)
463 {
464     if (device == NULL || codecData == NULL) {
465         AUDIO_DRIVER_LOG_ERR("param is null!");
466         return HDF_FAILURE;
467     }
468 
469     if (codecData->regConfig != NULL) {
470         ADM_LOG_ERR("g_codecData regConfig  fail!");
471         return HDF_FAILURE;
472     }
473 
474     codecData->regConfig = (struct AudioRegCfgData *)OsalMemCalloc(sizeof(*(codecData->regConfig)));
475     if (codecData->regConfig == NULL) {
476         ADM_LOG_ERR("malloc AudioRegCfgData fail!");
477         return HDF_FAILURE;
478     }
479 
480     if (AudioGetRegConfig(device, codecData->regConfig) != HDF_SUCCESS) {
481         ADM_LOG_ERR("AudioGetRegConfig fail!");
482         return HDF_FAILURE;
483     }
484 
485     return HDF_SUCCESS;
486 }
487 
488 
489 /* Original es8323 functions */
Es8323FormatParse(enum AudioFormat format, uint16_t *bitWidth)490 static int32_t Es8323FormatParse(enum AudioFormat format, uint16_t *bitWidth)
491 {
492     // current set default format(standard) for 24 bit
493     if (bitWidth == NULL) {
494         AUDIO_DEVICE_LOG_ERR("input param is NULL");
495         return HDF_FAILURE;
496     }
497     switch (format) {
498         case AUDIO_FORMAT_TYPE_PCM_16_BIT:
499             *bitWidth = ES8323_I2S_SAMPLE_FORMAT_REG_VAL_16;
500             break;
501         case AUDIO_FORMAT_TYPE_PCM_24_BIT:
502             *bitWidth = ES8323_I2S_SAMPLE_FORMAT_REG_VAL_24;
503             break;
504         case AUDIO_FORMAT_TYPE_PCM_32_BIT:
505             *bitWidth = ES8323_I2S_SAMPLE_FORMAT_REG_VAL_32;
506             break;
507         default:
508             AUDIO_DEVICE_LOG_ERR("format: %d is not support.", format);
509             return HDF_ERR_NOT_SUPPORT;
510     }
511     AUDIO_DEVICE_LOG_DEBUG(" success.");
512     return HDF_SUCCESS;
513 }
514 
Es8323WorkStatusEnable(void)515 static int32_t Es8323WorkStatusEnable(void)
516 {
517     int32_t ret;
518     uint8_t i;
519     struct AudioMixerControl *daiStartupParamsRegCfgItem = NULL;
520     uint8_t daiStartupParamsRegCfgItemCount;
521     ret = (g_es8323TransferData.codecRegCfgGroupNode == NULL
522             || g_es8323TransferData.codecRegCfgGroupNode[AUDIO_DAI_STARTUP_PATAM_GROUP] == NULL
523             || g_es8323TransferData.codecRegCfgGroupNode[AUDIO_DAI_STARTUP_PATAM_GROUP]->regCfgItem == NULL);
524     if (ret) {
525         AUDIO_DEVICE_LOG_ERR("g_es8323RegCfgGroupNode[AUDIO_DAI_STARTUP_PATAM_GROUP] is NULL.");
526         return HDF_FAILURE;
527     }
528     daiStartupParamsRegCfgItem =
529         g_es8323TransferData.codecRegCfgGroupNode[AUDIO_DAI_STARTUP_PATAM_GROUP]->regCfgItem;
530     daiStartupParamsRegCfgItemCount =
531         g_es8323TransferData.codecRegCfgGroupNode[AUDIO_DAI_STARTUP_PATAM_GROUP]->itemNum;
532     for (i = 0; i < daiStartupParamsRegCfgItemCount; i++) {
533         ret = Es8323RegBitsUpdate(daiStartupParamsRegCfgItem[i]);
534         if (ret != HDF_SUCCESS) {
535             AUDIO_DEVICE_LOG_ERR("Es8323RegBitsUpdate failed.");
536             return HDF_FAILURE;
537         }
538     }
539     AUDIO_DEVICE_LOG_DEBUG("success.");
540     return HDF_SUCCESS;
541 }
542 
543 /*
544  * ES8323 Hardware Rest, enable speaker
545 */
Es8323HardwareRest(void)546 static int32_t Es8323HardwareRest(void)
547 {
548     int32_t ret;
549     const char *spk_con = "spk-con";
550     ret = gpio_request(RK3588_GPIO_NUMBER, spk_con);
551     if (ret != 0 && ret != NUM_NEG_SIXTEEN) {
552         AUDIO_DEVICE_LOG_ERR("gpio0_b3 request failed. ret:%d", ret);
553         gpio_free(RK3588_GPIO_NUMBER);
554         return HDF_FAILURE;
555     }
556     ret = GpioSetDir(RK3588_GPIO_NUMBER, GPIO_DIR_OUT);
557     if (ret != HDF_SUCCESS) {
558         AUDIO_DEVICE_LOG_ERR("set gpio dir failed. ret:%d", ret);
559         return ret;
560     }
561     ret = GpioWrite(RK3588_GPIO_NUMBER, GPIO_VAL_HIGH);
562     if (ret != HDF_SUCCESS) {
563         AUDIO_DEVICE_LOG_ERR("write gpio val failed. ret:%d", ret);
564         return ret;
565     }
566     AUDIO_DEVICE_LOG_DEBUG("success.");
567     return HDF_SUCCESS;
568 }
569 
570 /*
571  * Es8323 Software Rest chip
572  */
Es8323SoftwareRest(void)573 static int32_t Es8323SoftwareRest(void)
574 {
575     int32_t ret;
576     int i;
577     struct AudioAddrConfig *es8323RegRestAttr;
578     uint32_t restRegCfgItemCount;
579     ret = (g_es8323TransferData.codecRegCfgGroupNode == NULL
580             || g_es8323TransferData.codecRegCfgGroupNode[AUDIO_RSET_GROUP] == NULL
581             || g_es8323TransferData.codecRegCfgGroupNode[AUDIO_RSET_GROUP]->addrCfgItem == NULL);
582     if (ret) {
583         AUDIO_DEVICE_LOG_ERR("g_es8323RegCfgGroupNode[AUDIO_RSET_GROUP] is NULL.");
584         return HDF_FAILURE;
585     }
586     es8323RegRestAttr = g_es8323TransferData.codecRegCfgGroupNode[AUDIO_RSET_GROUP]->addrCfgItem;
587     restRegCfgItemCount = g_es8323TransferData.codecRegCfgGroupNode[AUDIO_RSET_GROUP]->itemNum;
588     for (i = 0; i < restRegCfgItemCount; i++) {
589         ret = Es8323I2cReadWrite(&es8323RegRestAttr[i], 0);
590         if (ret != HDF_SUCCESS) {
591             AUDIO_DEVICE_LOG_ERR("Es8323I2cReadWrite(write) failed, regAddr: 0x%02x.", es8323RegRestAttr[i].addr);
592             return HDF_FAILURE;
593         }
594         OsalMSleep(ES8323_I2C_WAIT_TIMES);
595     }
596     AUDIO_DEVICE_LOG_DEBUG("success.");
597     return HDF_SUCCESS;
598 }
599 
Es8323DeviceInit(struct AudioCard *audioCard, const struct CodecDevice *device)600 int32_t Es8323DeviceInit(struct AudioCard *audioCard, const struct CodecDevice *device)
601 {
602     int32_t ret;
603     if ((audioCard == NULL) || (device == NULL)) {
604         AUDIO_DEVICE_LOG_ERR("input para is NULL.");
605         return HDF_ERR_INVALID_OBJECT;
606     }
607     ret = Es8323DeviceCfgGet(device->devData, &g_es8323TransferData);
608     if (ret != HDF_SUCCESS) {
609         AUDIO_DEVICE_LOG_ERR("Es8323DeviceCfgGet failed.");
610         return HDF_FAILURE;
611     }
612     ret = Es8323HardwareRest();
613     if (ret != HDF_SUCCESS) {
614         AUDIO_DEVICE_LOG_ERR("Es8323HardwareRest failed.");
615         return HDF_FAILURE;
616     }
617     ret = Es8323SoftwareRest();
618     if (ret != HDF_SUCCESS) {
619         AUDIO_DEVICE_LOG_ERR("Es8323SoftwareRest failed.");
620         return HDF_FAILURE;
621     }
622     // Initial es8323 register
623     ret = Es8323DeviceCtrlRegInit();
624     if (ret != HDF_SUCCESS) {
625         AUDIO_DEVICE_LOG_ERR("Es8323DeviceRegInit failed.");
626         return HDF_FAILURE;
627     }
628     ret = AudioAddControls(audioCard, g_es8323TransferData.codecControls,
629         g_es8323TransferData.codecCfgCtrlCount);
630     if (ret != HDF_SUCCESS) {
631         AUDIO_DEVICE_LOG_ERR("AudioAddControls failed.");
632         return HDF_FAILURE;
633     }
634     AUDIO_DEVICE_LOG_DEBUG("success.");
635     return HDF_SUCCESS;
636 }
637 
Es8323DaiDeviceInit(struct AudioCard *card, const struct DaiDevice *device)638 int32_t Es8323DaiDeviceInit(struct AudioCard *card, const struct DaiDevice *device)
639 {
640     if (device == NULL || device->devDaiName == NULL) {
641         AUDIO_DEVICE_LOG_ERR("input para is NULL.");
642         return HDF_FAILURE;
643     }
644     (void)card;
645     AUDIO_DEVICE_LOG_DEBUG("success.");
646     return HDF_SUCCESS;
647 }
648 
Es8323DaiStartup(const struct AudioCard *card, const struct DaiDevice *device)649 int32_t Es8323DaiStartup(const struct AudioCard *card, const struct DaiDevice *device)
650 {
651     int ret;
652     (void)card;
653     (void)device;
654     ret = Es8323WorkStatusEnable();
655     if (ret != HDF_SUCCESS) {
656         AUDIO_DEVICE_LOG_ERR("Es8323WorkStatusEnable failed.");
657         return HDF_FAILURE;
658     }
659 
660     Es8323DeviceRegWrite((const struct CodecDevice *)0x0710, 0x09, 0x33);
661     Es8323DeviceRegWrite((const struct CodecDevice *)0x0710, 0x0a, 0x50);
662     AUDIO_DEVICE_LOG_DEBUG("success.");
663     return HDF_SUCCESS;
664 }
665 
Es8323DaiHwParams(const struct AudioCard *card, const struct AudioPcmHwParams *param)666 int32_t Es8323DaiHwParams(const struct AudioCard *card, const struct AudioPcmHwParams *param)
667 {
668     int32_t ret;
669     uint16_t frequency, bitWidth;
670     struct Es8323DaiParamsVal daiParamsVal;
671     bool playback = true;
672     AUDIO_DEVICE_LOG_DEBUG("entry.");
673     (void)card;
674     if (param == NULL || param->cardServiceName == NULL) {
675         AUDIO_DEVICE_LOG_ERR("input para is NULL.");
676         return HDF_ERR_INVALID_PARAM;
677     }
678     ret = Es8323DeviceFrequencyParse(param->rate, &frequency);
679     if (ret != HDF_SUCCESS) {
680         AUDIO_DEVICE_LOG_ERR("Es8323DeviceFrequencyParse failed.");
681         return HDF_ERR_NOT_SUPPORT;
682     }
683     ret = Es8323FormatParse(param->format, &bitWidth);
684     if (ret != HDF_SUCCESS) {
685         AUDIO_DEVICE_LOG_ERR("Es8323FormatParse failed.");
686         return HDF_ERR_NOT_SUPPORT;
687     }
688     daiParamsVal.frequencyVal = frequency;
689     daiParamsVal.formatVal = bitWidth;
690     daiParamsVal.channelVal = param->channels;
691     playback = (param->streamType == AUDIO_RENDER_STREAM) ? true : false;
692     ret = Es8323DaiParamsUpdate(daiParamsVal, playback);
693     if (ret != HDF_SUCCESS) {
694         AUDIO_DEVICE_LOG_ERR("Es8323DaiParamsUpdate failed.");
695         return HDF_FAILURE;
696     }
697     AUDIO_DEVICE_LOG_DEBUG("channels = %d, rate = %d, periodSize = %d, \
698         periodCount = %d, format = %d, cardServiceName = %s \n",
699         param->channels, param->rate, param->periodSize,
700         param->periodCount, (uint32_t)param->format, param->cardServiceName);
701     AUDIO_DEVICE_LOG_DEBUG("success.");
702     return HDF_SUCCESS;
703 }
704 
Es8323NormalTrigger(const struct AudioCard *card, int cmd, const struct DaiDevice *device)705 int32_t Es8323NormalTrigger(const struct AudioCard *card, int cmd, const struct DaiDevice *device)
706 {
707     switch (cmd) {
708         case AUDIO_DRV_PCM_IOCTL_RENDER_START:
709         case AUDIO_DRV_PCM_IOCTL_RENDER_RESUME:
710             Es8323DeviceRegWrite((const struct CodecDevice *)0x0710, ES8323_ANAVOLMANAG, 0x7C);
711             Es8323DeviceRegWrite((const struct CodecDevice *)0x0710, ES8323_CHIPPOWER, 0x00);
712             Es8323DeviceRegWrite((const struct CodecDevice *)0x0710, ES8323_DACPOWER, 0x0c);
713             break;
714         case AUDIO_DRV_PCM_IOCTL_CAPTURE_START:
715         case AUDIO_DRV_PCM_IOCTL_CAPTURE_RESUME:
716             Es8323DeviceRegWrite((const struct CodecDevice *)0x0710, ES8323_ANAVOLMANAG, 0x7C);
717             Es8323DeviceRegWrite((const struct CodecDevice *)0x0710, ES8323_CHIPPOWER, 0x00);
718             Es8323DeviceRegWrite((const struct CodecDevice *)0x0710, ES8323_DACPOWER, 0xc0);
719             Es8323DeviceRegWrite((const struct CodecDevice *)0x0710, ES8323_ADCPOWER, 0x00);
720             break;
721         case AUDIO_DRV_PCM_IOCTL_RENDER_STOP:
722         case AUDIO_DRV_PCM_IOCTL_RENDER_PAUSE:
723             Es8323DeviceRegWrite((const struct CodecDevice *)0x0710, ES8323_DACPOWER, 0xc0);
724             Es8323DeviceRegWrite((const struct CodecDevice *)0x0710, ES8323_CHIPPOWER, 0xFF);
725             Es8323DeviceRegWrite((const struct CodecDevice *)0x0710, ES8323_ANAVOLMANAG, 0x7B);
726             break;
727         case AUDIO_DRV_PCM_IOCTL_CAPTURE_STOP:
728         case AUDIO_DRV_PCM_IOCTL_CAPTURE_PAUSE:
729             Es8323DeviceRegWrite((const struct CodecDevice *)0x0710, ES8323_ADCPOWER, 0xFF);
730 
731             Es8323DeviceRegWrite((const struct CodecDevice *)0x0710, ES8323_CHIPPOWER, 0xFF);
732             Es8323DeviceRegWrite((const struct CodecDevice *)0x0710, ES8323_ANAVOLMANAG, 0x7B);
733         break;
734 
735         default:
736             break;
737     }
738 
739     return HDF_SUCCESS;
740 }
741