pinebuds/platform/drivers/codec/best2300p/codec_best2300p.c

725 lines
21 KiB
C

/***************************************************************************
*
* Copyright 2015-2019 BES.
* All rights reserved. All unpublished rights reserved.
*
* No part of this work may be used or reproduced in any form or by any
* means, or stored in a database or retrieval system, without prior written
* permission of BES.
*
* Use of this work is governed by a license granted by BES.
* This work contains confidential and proprietary information of
* BES. which is protected by copyright, trade secret,
* trademark and other intellectual property rights.
*
****************************************************************************/
#include "analog.h"
#include "codec_int.h"
#include "hal_codec.h"
#include "hal_sleep.h"
#include "hal_trace.h"
#include "plat_types.h"
#include "stdbool.h"
#include "tgt_hardware.h"
#define CODEC_TRACE(n, s, ...) TRACE(n, s, ##__VA_ARGS__)
#define CODEC_INT_INST HAL_CODEC_ID_0
#ifndef CODEC_OUTPUT_DEV
#define CODEC_OUTPUT_DEV CFG_HW_AUD_OUTPUT_PATH_SPEAKER_DEV
#endif
#ifdef __CODEC_ASYNC_CLOSE__
#include "cmsis_os.h"
#define CODEC_ASYNC_CLOSE_DELAY (5000)
static void codec_timehandler(void const *param);
osTimerDef(CODEC_TIMER, codec_timehandler);
static osTimerId codec_timer;
static CODEC_CLOSE_HANDLER close_hdlr;
enum CODEC_HW_STATE_T {
CODEC_HW_STATE_CLOSED,
CODEC_HW_STATE_CLOSE_PENDING,
CODEC_HW_STATE_OPENED,
};
enum CODEC_HW_STATE_T codec_hw_state = CODEC_HW_STATE_CLOSED;
#endif
enum CODEC_USER_T {
CODEC_USER_STREAM = (1 << 0),
CODEC_USER_ANC = (1 << 1),
CODEC_USER_VAD = (1 << 2),
};
struct CODEC_CONFIG_T {
enum CODEC_USER_T user_map;
bool resample_en;
bool mute_state[AUD_STREAM_NUM];
bool chan_vol_set[AUD_STREAM_NUM];
struct STREAM_CONFIG_T {
bool opened;
bool started;
struct HAL_CODEC_CONFIG_T codec_cfg;
} stream_cfg[AUD_STREAM_NUM];
};
static struct CODEC_CONFIG_T codec_int_cfg = {
.user_map = 0,
.resample_en = false,
.mute_state =
{
false,
false,
},
.chan_vol_set =
{
false,
false,
},
// playback
.stream_cfg[AUD_STREAM_PLAYBACK] = {.opened = false,
.started = false,
.codec_cfg =
{
.sample_rate =
AUD_SAMPRATE_NULL,
}},
// capture
.stream_cfg[AUD_STREAM_CAPTURE] = {.opened = false,
.started = false,
.codec_cfg = {
.sample_rate = AUD_SAMPRATE_NULL,
}}};
static bool anc_ff_enabled;
static bool anc_fb_enabled;
static enum AUD_SAMPRATE_T codec_anc_samp_rate;
static CODEC_ANC_HANDLER codec_anc_handler;
#ifdef VOICE_DETECTOR_EN
static enum AUD_VAD_TYPE_T vad_type;
#endif
#ifdef CODEC_ANC_BOOST
static CODEC_ANC_BOOST_DELAY_FUNC boost_delay;
void codec_set_anc_boost_delay_func(CODEC_ANC_BOOST_DELAY_FUNC delay_func) {
boost_delay = delay_func;
}
#endif
uint32_t codec_int_stream_open(enum AUD_STREAM_T stream) {
CODEC_TRACE(2, "%s: stream=%d", __func__, stream);
codec_int_cfg.stream_cfg[stream].opened = true;
return 0;
}
uint32_t codec_int_stream_setup(enum AUD_STREAM_T stream,
struct HAL_CODEC_CONFIG_T *cfg) {
enum AUD_CHANNEL_MAP_T ch_map;
CODEC_TRACE(2, "%s: stream=%d", __func__, stream);
if (codec_int_cfg.stream_cfg[stream].codec_cfg.sample_rate ==
AUD_SAMPRATE_NULL) {
// Codec uninitialized -- all config items should be set
codec_int_cfg.stream_cfg[stream].codec_cfg.set_flag = HAL_CODEC_CONFIG_ALL;
} else {
// Codec initialized before -- only different config items need to be set
codec_int_cfg.stream_cfg[stream].codec_cfg.set_flag = HAL_CODEC_CONFIG_NULL;
}
// Always config sample rate, for the pll setting might have been changed by
// the other stream
CODEC_TRACE(2, "[sample_rate]old=%d new=%d",
codec_int_cfg.stream_cfg[stream].codec_cfg.sample_rate,
cfg->sample_rate);
if (codec_int_cfg.user_map & CODEC_USER_ANC) {
// Check ANC sample rate
if (codec_anc_handler) {
enum AUD_SAMPRATE_T cfg_rate;
enum AUD_SAMPRATE_T old_rate;
cfg_rate = hal_codec_anc_convert_rate(cfg->sample_rate);
if (cfg_rate != codec_anc_samp_rate) {
old_rate = codec_anc_samp_rate;
codec_anc_handler(stream, cfg_rate, NULL, NULL);
codec_anc_samp_rate = cfg_rate;
TRACE(5,
"%s: ANC sample rate changes from %u to %u due to stream=%d "
"samp_rate=%u",
__func__, old_rate, codec_anc_samp_rate, stream,
cfg->sample_rate);
}
}
}
codec_int_cfg.stream_cfg[stream].codec_cfg.sample_rate = cfg->sample_rate;
codec_int_cfg.stream_cfg[stream].codec_cfg.set_flag |=
HAL_CODEC_CONFIG_SAMPLE_RATE;
if (codec_int_cfg.stream_cfg[stream].codec_cfg.bits != cfg->bits) {
CODEC_TRACE(2, "[bits]old=%d new=%d",
codec_int_cfg.stream_cfg[stream].codec_cfg.bits, cfg->bits);
codec_int_cfg.stream_cfg[stream].codec_cfg.bits = cfg->bits;
codec_int_cfg.stream_cfg[stream].codec_cfg.set_flag |=
HAL_CODEC_CONFIG_BITS;
}
if (codec_int_cfg.stream_cfg[stream].codec_cfg.channel_num !=
cfg->channel_num) {
CODEC_TRACE(2, "[channel_num]old=%d new=%d",
codec_int_cfg.stream_cfg[stream].codec_cfg.channel_num,
cfg->channel_num);
codec_int_cfg.stream_cfg[stream].codec_cfg.channel_num = cfg->channel_num;
codec_int_cfg.stream_cfg[stream].codec_cfg.set_flag |=
HAL_CODEC_CONFIG_CHANNEL_NUM;
}
ch_map = cfg->channel_map;
if (ch_map == 0) {
if (stream == AUD_STREAM_PLAYBACK) {
ch_map = (enum AUD_CHANNEL_MAP_T)CODEC_OUTPUT_DEV;
} else {
ch_map =
(enum AUD_CHANNEL_MAP_T)hal_codec_get_input_path_cfg(cfg->io_path);
}
ch_map &= AUD_CHANNEL_MAP_ALL;
}
if (codec_int_cfg.stream_cfg[stream].codec_cfg.channel_map != ch_map) {
CODEC_TRACE(2, "[channel_map]old=0x%x new=0x%x",
codec_int_cfg.stream_cfg[stream].codec_cfg.channel_map, ch_map);
codec_int_cfg.stream_cfg[stream].codec_cfg.channel_map = ch_map;
codec_int_cfg.stream_cfg[stream].codec_cfg.set_flag |=
HAL_CODEC_CONFIG_CHANNEL_MAP | HAL_CODEC_CONFIG_VOL |
HAL_CODEC_CONFIG_BITS;
}
if (codec_int_cfg.stream_cfg[stream].codec_cfg.use_dma != cfg->use_dma) {
CODEC_TRACE(2, "[use_dma]old=%d new=%d",
codec_int_cfg.stream_cfg[stream].codec_cfg.use_dma,
cfg->use_dma);
codec_int_cfg.stream_cfg[stream].codec_cfg.use_dma = cfg->use_dma;
}
if (codec_int_cfg.stream_cfg[stream].codec_cfg.vol != cfg->vol) {
CODEC_TRACE(3, "[vol]old=%d new=%d chan_vol_set=%d",
codec_int_cfg.stream_cfg[stream].codec_cfg.vol, cfg->vol,
codec_int_cfg.chan_vol_set[stream]);
codec_int_cfg.stream_cfg[stream].codec_cfg.vol = cfg->vol;
if (!codec_int_cfg.chan_vol_set[stream]) {
codec_int_cfg.stream_cfg[stream].codec_cfg.set_flag |=
HAL_CODEC_CONFIG_VOL;
}
}
if (codec_int_cfg.stream_cfg[stream].codec_cfg.io_path != cfg->io_path) {
CODEC_TRACE(2, "[io_path]old=%d new=%d",
codec_int_cfg.stream_cfg[stream].codec_cfg.io_path,
cfg->io_path);
codec_int_cfg.stream_cfg[stream].codec_cfg.io_path = cfg->io_path;
}
CODEC_TRACE(3, "[%s]stream=%d set_flag=0x%x", __func__, stream,
codec_int_cfg.stream_cfg[stream].codec_cfg.set_flag);
hal_codec_setup_stream(CODEC_INT_INST, stream,
&(codec_int_cfg.stream_cfg[stream].codec_cfg));
return 0;
}
void codec_int_stream_mute(enum AUD_STREAM_T stream, bool mute) {
bool anc_on;
CODEC_TRACE(3, "%s: stream=%d mute=%d", __func__, stream, mute);
if (mute == codec_int_cfg.mute_state[stream]) {
CODEC_TRACE(2, "[%s] Codec already in mute status: %d", __func__, mute);
return;
}
anc_on = !!(codec_int_cfg.user_map & CODEC_USER_ANC);
if (stream == AUD_STREAM_PLAYBACK) {
if (mute) {
if (!anc_on) {
analog_aud_codec_mute();
}
hal_codec_dac_mute(true);
} else {
hal_codec_dac_mute(false);
if (!anc_on) {
analog_aud_codec_nomute();
}
}
} else {
hal_codec_adc_mute(mute);
}
codec_int_cfg.mute_state[stream] = mute;
}
void codec_int_stream_set_chan_vol(enum AUD_STREAM_T stream,
enum AUD_CHANNEL_MAP_T ch_map, uint8_t vol) {
CODEC_TRACE(4, "%s: stream=%d ch_map=0x%X vol=%u", __func__, stream, ch_map,
vol);
codec_int_cfg.chan_vol_set[stream] = true;
hal_codec_set_chan_vol(stream, ch_map, vol);
}
void codec_int_stream_restore_chan_vol(enum AUD_STREAM_T stream) {
CODEC_TRACE(2, "%s: stream=%d", __func__, stream);
if (codec_int_cfg.chan_vol_set[stream]) {
codec_int_cfg.chan_vol_set[stream] = false;
// Restore normal volume
codec_int_cfg.stream_cfg[stream].codec_cfg.set_flag = HAL_CODEC_CONFIG_VOL;
hal_codec_setup_stream(CODEC_INT_INST, stream,
&(codec_int_cfg.stream_cfg[stream].codec_cfg));
}
}
static void codec_hw_start(enum AUD_STREAM_T stream) {
CODEC_TRACE(2, "%s: stream=%d", __func__, stream);
if (stream == AUD_STREAM_PLAYBACK) {
// Enable DAC before starting stream (specifically before enabling PA)
analog_aud_codec_dac_enable(true);
}
hal_codec_start_stream(CODEC_INT_INST, stream);
}
static void codec_hw_stop(enum AUD_STREAM_T stream) {
CODEC_TRACE(2, "%s: stream=%d", __func__, stream);
hal_codec_stop_stream(CODEC_INT_INST, stream);
if (stream == AUD_STREAM_PLAYBACK) {
// Disable DAC after stopping stream (specifically after disabling PA)
analog_aud_codec_dac_enable(false);
}
}
uint32_t codec_int_stream_start(enum AUD_STREAM_T stream) {
CODEC_TRACE(2, "%s: stream=%d", __func__, stream);
codec_int_cfg.stream_cfg[stream].started = true;
if (stream == AUD_STREAM_CAPTURE) {
analog_aud_codec_adc_enable(
codec_int_cfg.stream_cfg[stream].codec_cfg.io_path,
codec_int_cfg.stream_cfg[stream].codec_cfg.channel_map, true);
}
hal_codec_start_interface(CODEC_INT_INST, stream,
codec_int_cfg.stream_cfg[stream].codec_cfg.use_dma);
if ((codec_int_cfg.user_map & CODEC_USER_ANC) == 0) {
codec_hw_start(stream);
}
return 0;
}
uint32_t codec_int_stream_stop(enum AUD_STREAM_T stream) {
CODEC_TRACE(2, "%s: stream=%d", __func__, stream);
hal_codec_stop_interface(CODEC_INT_INST, stream);
if ((codec_int_cfg.user_map & CODEC_USER_ANC) == 0) {
codec_hw_stop(stream);
}
if (stream == AUD_STREAM_CAPTURE) {
analog_aud_codec_adc_enable(
codec_int_cfg.stream_cfg[stream].codec_cfg.io_path,
codec_int_cfg.stream_cfg[stream].codec_cfg.channel_map, false);
}
codec_int_cfg.stream_cfg[stream].started = false;
return 0;
}
uint32_t codec_int_stream_close(enum AUD_STREAM_T stream) {
// close all stream
CODEC_TRACE(2, "%s: stream=%d", __func__, stream);
if (codec_int_cfg.stream_cfg[stream].started) {
codec_int_stream_stop(stream);
}
codec_int_stream_restore_chan_vol(stream);
codec_int_cfg.stream_cfg[stream].opened = false;
return 0;
}
static void codec_hw_open(enum CODEC_USER_T user) {
enum CODEC_USER_T old_map;
#ifdef __AUDIO_RESAMPLE__
bool resample_en = !!hal_cmu_get_audio_resample_status();
#endif
old_map = codec_int_cfg.user_map;
codec_int_cfg.user_map |= user;
if (old_map) {
#ifdef __AUDIO_RESAMPLE__
ASSERT(codec_int_cfg.resample_en == resample_en,
"%s: Bad resamp status %d for user 0x%X (old_map=0x%X)", __func__,
resample_en, user, old_map);
#endif
return;
}
#ifdef __AUDIO_RESAMPLE__
codec_int_cfg.resample_en = resample_en;
#endif
CODEC_TRACE(1, "%s", __func__);
#ifdef __CODEC_ASYNC_CLOSE__
if (codec_timer == NULL) {
codec_timer = osTimerCreate(osTimer(CODEC_TIMER), osTimerOnce, NULL);
}
osTimerStop(codec_timer);
#endif
// Audio resample: Might have different clock source, so must be reconfigured
// here
hal_codec_open(CODEC_INT_INST);
#ifdef __CODEC_ASYNC_CLOSE__
CODEC_TRACE(2, "%s: codec_hw_state=%d", __func__, codec_hw_state);
if (codec_hw_state == CODEC_HW_STATE_CLOSED) {
codec_hw_state = CODEC_HW_STATE_OPENED;
// Continue to open the codec hardware
} else if (codec_hw_state == CODEC_HW_STATE_CLOSE_PENDING) {
// Still opened
codec_hw_state = CODEC_HW_STATE_OPENED;
return;
} else {
// Already opened
return;
}
#endif
analog_aud_codec_open();
}
static void codec_hw_close(enum CODEC_CLOSE_TYPE_T type,
enum CODEC_USER_T user) {
codec_int_cfg.user_map &= ~user;
if (type == CODEC_CLOSE_NORMAL) {
if (codec_int_cfg.user_map) {
return;
}
}
#ifdef __CODEC_ASYNC_CLOSE__
CODEC_TRACE(3, "%s: type=%d codec_hw_state=%d", __func__, type,
codec_hw_state);
#else
CODEC_TRACE(2, "%s: type=%d", __func__, type);
#endif
if (type == CODEC_CLOSE_NORMAL) {
// Audio resample: Might have different clock source, so close now and
// reconfigure when open
hal_codec_close(CODEC_INT_INST);
#ifdef CODEC_POWER_DOWN
memset(&codec_int_cfg, 0, sizeof(codec_int_cfg));
#endif
#ifdef __CODEC_ASYNC_CLOSE__
ASSERT(codec_hw_state == CODEC_HW_STATE_OPENED,
"%s: (type=%d) Bad codec_hw_state=%d", __func__, type,
codec_hw_state);
// Start a timer to close the codec hardware
codec_hw_state = CODEC_HW_STATE_CLOSE_PENDING;
osTimerStop(codec_timer);
osTimerStart(codec_timer, CODEC_ASYNC_CLOSE_DELAY);
return;
} else if (type == CODEC_CLOSE_ASYNC_REAL) {
if (codec_hw_state != CODEC_HW_STATE_CLOSE_PENDING) {
// Already closed or reopened
return;
}
codec_hw_state = CODEC_HW_STATE_CLOSED;
#endif
} else if (type == CODEC_CLOSE_FORCED) {
hal_codec_crash_mute();
}
analog_aud_codec_close();
}
uint32_t codec_int_open(void) {
CODEC_TRACE(2, "%s: user_map=0x%X", __func__, codec_int_cfg.user_map);
codec_hw_open(CODEC_USER_STREAM);
return 0;
}
uint32_t codec_int_close(enum CODEC_CLOSE_TYPE_T type) {
CODEC_TRACE(3, "%s: type=%d user_map=0x%X", __func__, type,
codec_int_cfg.user_map);
if (type == CODEC_CLOSE_NORMAL) {
if (codec_int_cfg.stream_cfg[AUD_STREAM_PLAYBACK].opened == false &&
codec_int_cfg.stream_cfg[AUD_STREAM_CAPTURE].opened == false) {
codec_hw_close(type, CODEC_USER_STREAM);
}
} else {
codec_hw_close(type, CODEC_USER_STREAM);
}
return 0;
}
#ifdef __CODEC_ASYNC_CLOSE__
void codec_int_set_close_handler(CODEC_CLOSE_HANDLER hdlr) {
close_hdlr = hdlr;
}
static void codec_timehandler(void const *param) {
if (close_hdlr) {
close_hdlr();
}
}
#endif
int codec_anc_open(enum ANC_TYPE_T type, enum AUD_SAMPRATE_T dac_rate,
enum AUD_SAMPRATE_T adc_rate, CODEC_ANC_HANDLER hdlr) {
bool anc_running = false;
CODEC_TRACE(4, "%s: type=%d dac_rate=%d adc_rate=%d", __func__, type,
dac_rate, adc_rate);
dac_rate = hal_codec_anc_convert_rate(dac_rate);
adc_rate = hal_codec_anc_convert_rate(adc_rate);
ASSERT(dac_rate == adc_rate, "%s: Unmatched rates: dac_rate=%u adc_rate=%u",
__func__, dac_rate, adc_rate);
if (hdlr && (codec_int_cfg.user_map & CODEC_USER_STREAM)) {
enum AUD_SAMPRATE_T cfg_dac_rate, cfg_adc_rate;
if (codec_int_cfg.stream_cfg[AUD_STREAM_PLAYBACK].opened) {
cfg_dac_rate = hal_codec_anc_convert_rate(
codec_int_cfg.stream_cfg[AUD_STREAM_PLAYBACK].codec_cfg.sample_rate);
} else {
cfg_dac_rate = dac_rate;
}
if (codec_int_cfg.stream_cfg[AUD_STREAM_CAPTURE].opened) {
cfg_adc_rate = hal_codec_anc_convert_rate(
codec_int_cfg.stream_cfg[AUD_STREAM_CAPTURE].codec_cfg.sample_rate);
} else {
cfg_adc_rate = adc_rate;
}
if (codec_int_cfg.stream_cfg[AUD_STREAM_PLAYBACK].opened &&
codec_int_cfg.stream_cfg[AUD_STREAM_CAPTURE].opened) {
ASSERT(cfg_dac_rate == cfg_adc_rate,
"%s: Unmatched cfg rates: dac_rate=%u adc_rate=%u", __func__,
cfg_dac_rate, cfg_adc_rate);
} else if (codec_int_cfg.stream_cfg[AUD_STREAM_CAPTURE].opened) {
cfg_dac_rate = cfg_adc_rate;
}
if (dac_rate != cfg_dac_rate) {
hdlr(AUD_STREAM_PLAYBACK, cfg_dac_rate, NULL, NULL);
TRACE(3, "%s: ANC sample rate changes from %u to %u", __func__, dac_rate,
cfg_dac_rate);
dac_rate = cfg_dac_rate;
}
}
codec_anc_samp_rate = dac_rate;
codec_anc_handler = hdlr;
if (anc_ff_enabled || anc_fb_enabled) {
anc_running = true;
}
if (type == ANC_FEEDFORWARD) {
anc_ff_enabled = true;
} else if (type == ANC_FEEDBACK) {
anc_fb_enabled = true;
}
if (!anc_running) {
hal_chip_wake_lock(HAL_CHIP_WAKE_LOCK_USER_ANC);
hal_cmu_anc_enable(HAL_CMU_ANC_CLK_USER_ANC);
enum AUD_STREAM_T stream;
enum AUD_CHANNEL_NUM_T play_chan_num;
codec_hw_open(CODEC_USER_ANC);
if (CODEC_OUTPUT_DEV == (AUD_CHANNEL_MAP_CH0 | AUD_CHANNEL_MAP_CH1)) {
play_chan_num = AUD_CHANNEL_NUM_2;
} else {
play_chan_num = AUD_CHANNEL_NUM_1;
}
for (stream = AUD_STREAM_PLAYBACK; stream <= AUD_STREAM_CAPTURE; stream++) {
if (codec_int_cfg.stream_cfg[stream].opened) {
if (stream == AUD_STREAM_PLAYBACK) {
/* ASSERT(codec_int_cfg.stream_cfg[stream].codec_cfg.channel_num ==
play_chan_num, "Invalid existing ANC channel num %d != %d for
stream %d", codec_int_cfg.stream_cfg[stream].codec_cfg.channel_num,
play_chan_num,
stream);*/
}
} else {
codec_int_cfg.stream_cfg[stream].codec_cfg.set_flag = 0;
codec_int_cfg.stream_cfg[stream].codec_cfg.sample_rate =
codec_anc_samp_rate;
codec_int_cfg.stream_cfg[stream].codec_cfg.set_flag |=
HAL_CODEC_CONFIG_SAMPLE_RATE;
if (stream == AUD_STREAM_PLAYBACK) {
codec_int_cfg.stream_cfg[stream].codec_cfg.vol = TGT_VOLUME_LEVEL_10;
} else {
codec_int_cfg.stream_cfg[stream].codec_cfg.vol = CODEC_SADC_VOL;
}
codec_int_cfg.stream_cfg[stream].codec_cfg.set_flag |=
HAL_CODEC_CONFIG_VOL;
if (stream == AUD_STREAM_PLAYBACK) {
codec_int_cfg.stream_cfg[stream].codec_cfg.channel_num =
play_chan_num;
codec_int_cfg.stream_cfg[stream].codec_cfg.channel_map =
CODEC_OUTPUT_DEV;
} else {
codec_int_cfg.stream_cfg[stream].codec_cfg.channel_num = 0;
codec_int_cfg.stream_cfg[stream].codec_cfg.channel_map = 0;
}
codec_int_cfg.stream_cfg[stream].codec_cfg.set_flag |=
HAL_CODEC_CONFIG_CHANNEL_NUM;
hal_codec_setup_stream(CODEC_INT_INST, stream,
&(codec_int_cfg.stream_cfg[stream].codec_cfg));
}
}
// Start play first, then start capture last
for (stream = AUD_STREAM_PLAYBACK; stream <= AUD_STREAM_CAPTURE; stream++) {
if (!codec_int_cfg.stream_cfg[stream].started) {
codec_hw_start(stream);
}
}
}
hal_codec_anc_adc_enable(type);
analog_aud_codec_anc_enable(type, true);
if (!anc_running) {
// Enable pa if dac muted before
if (codec_int_cfg.mute_state[AUD_STREAM_PLAYBACK]) {
analog_aud_codec_nomute();
}
#ifdef CODEC_ANC_BOOST
analog_aud_codec_anc_boost(true, (ANALOG_ANC_BOOST_DELAY_FUNC)boost_delay);
#endif
}
return 0;
}
int codec_anc_close(enum ANC_TYPE_T type) {
CODEC_TRACE(2, "%s: type=%d", __func__, type);
if (type == ANC_FEEDFORWARD) {
anc_ff_enabled = false;
} else if (type == ANC_FEEDBACK) {
anc_fb_enabled = false;
}
hal_codec_anc_adc_disable(type);
analog_aud_codec_anc_enable(type, false);
if (anc_ff_enabled || anc_fb_enabled) {
return 0;
}
#ifdef CODEC_ANC_BOOST
analog_aud_codec_anc_boost(false, (ANALOG_ANC_BOOST_DELAY_FUNC)boost_delay);
#endif
enum AUD_STREAM_T stream;
// Stop capture first, then stop play last
for (stream = AUD_STREAM_CAPTURE;
stream >= AUD_STREAM_PLAYBACK && stream <= AUD_STREAM_CAPTURE;
stream--) {
if (!codec_int_cfg.stream_cfg[stream].started) {
codec_hw_stop(stream);
}
}
codec_hw_close(CODEC_CLOSE_NORMAL, CODEC_USER_ANC);
hal_cmu_anc_disable(HAL_CMU_ANC_CLK_USER_ANC);
hal_chip_wake_unlock(HAL_CHIP_WAKE_LOCK_USER_ANC);
// Disable pa if dac muted before
if (codec_int_cfg.mute_state[AUD_STREAM_PLAYBACK]) {
analog_aud_codec_mute();
}
codec_anc_handler = NULL;
return 0;
}
#ifdef VOICE_DETECTOR_EN
int codec_vad_open(const struct AUD_VAD_CONFIG_T *cfg) {
if (cfg->type == AUD_VAD_TYPE_NONE) {
return codec_vad_close();
}
if (vad_type == cfg->type) {
return 0;
}
vad_type = cfg->type;
if (codec_int_cfg.user_map == 0) {
codec_hw_open(CODEC_USER_VAD);
}
hal_codec_vad_open(cfg);
codec_int_cfg.user_map |= (1 << CODEC_USER_VAD);
return 0;
}
int codec_vad_close(void) {
if (vad_type == AUD_VAD_TYPE_NONE) {
return 0;
}
vad_type = AUD_VAD_TYPE_NONE;
codec_int_cfg.user_map &= ~(1 << CODEC_USER_VAD);
if (codec_int_cfg.user_map == 0) {
codec_hw_close(CODEC_CLOSE_NORMAL, CODEC_USER_VAD);
}
return 0;
}
#endif