rsoc/board/ports/audio/drv_sound.c

515 lines
15 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
* Copyright (c) 2006-2023, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Date Author Notes
* 2019-07-31 Zero-Free first implementation
*/
#include <board.h>
#include "drv_sound.h"
#include "drv_es8388.h"
#define DBG_TAG "drv.sound"
#define DBG_LVL DBG_LOG
#include <rtdbg.h>
#define TX_FIFO_SIZE (2048)
struct sound_device
{
struct rt_audio_device audio;
struct rt_audio_configure replay_config;
rt_uint8_t *tx_fifo;
rt_uint8_t volume;
};
static struct sound_device snd_dev = {0};
static I2S_HandleTypeDef I2S3_Handler = {0};
static DMA_HandleTypeDef I2S3_TXDMA_Handler = {0};
/**
* 采样率计算公式:Fs=I2SxCLK/[256*(2*I2SDIV+ODD)]
* I2SxCLK=(HSE/pllm)*PLLI2SN/PLLI2SR
* 一般HSE=8Mhz
* pllm:在Sys_Clock_Set设置的时候确定一般是8
* PLLI2SN:一般是192~432
* PLLI2SR:2~7
* I2SDIV:2~255
* ODD:0/1
* I2S分频系数表@pllm=8,HSE=8Mhz,即vco输入频率为1Mhz
* 表格式:采样率/10,PLLI2SN,PLLI2SR,I2SDIV,ODD
*/
const uint16_t I2S_PSC_TBL[][5]=
{
{ 800, 256, 5, 12, 1 }, /* 8Khz采样率 */
{ 1102, 429, 4, 19, 0 }, /* 11.025Khz采样率 */
{ 1600, 213, 2, 13, 0 }, /* 16Khz采样率 */
{ 2205, 429, 4, 9, 1 }, /* 22.05Khz采样率 */
{ 3200, 213, 2, 6, 1 }, /* 32Khz采样率 */
{ 4410, 271, 2, 6, 0 }, /* 44.1Khz采样率 */
{ 4800, 258, 3, 3, 1 }, /* 48Khz采样率 */
{ 8820, 316, 2, 3, 1 }, /* 88.2Khz采样率 */
{ 9600, 344, 2, 3, 1 }, /* 96Khz采样率 */
{ 17640, 361, 2, 2, 0 }, /* 176.4Khz采样率 */
{ 19200, 393, 2, 2, 0 }, /* 192Khz采样率 */
};
static void I2S3_Init(void)
{
RCC_PeriphCLKInitTypeDef PeriphClkInitStruct;
PeriphClkInitStruct.PeriphClockSelection |= RCC_PERIPHCLK_I2S;
PeriphClkInitStruct.PLLI2S.PLLI2SN = 192;
PeriphClkInitStruct.PLLI2S.PLLI2SR = 2;
if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
{
Error_Handler();
}
HAL_I2S_DeInit(&I2S3_Handler);
I2S3_Handler.Instance = SPI3;
I2S3_Handler.Init.Mode = I2S_MODE_MASTER_TX;
I2S3_Handler.Init.Standard = I2S_STANDARD_PHILIPS;
I2S3_Handler.Init.DataFormat = I2S_DATAFORMAT_16B;
I2S3_Handler.Init.MCLKOutput = I2S_MCLKOUTPUT_ENABLE;
I2S3_Handler.Init.AudioFreq = I2S_AUDIOFREQ_44K;
I2S3_Handler.Init.CPOL = I2S_CPOL_LOW;
I2S3_Handler.Init.ClockSource = I2S_CLOCK_PLL;
I2S3_Handler.Init.FullDuplexMode = I2S_FULLDUPLEXMODE_ENABLE;
if (HAL_I2S_Init(&I2S3_Handler) != HAL_OK)
{
Error_Handler();
}
SET_BIT(I2S3_Handler.Instance->CR2, SPI_CR2_TXDMAEN);
__HAL_I2S_ENABLE(&I2S3_Handler);
/* Configure DMA used for I2S3 */
__HAL_RCC_DMA1_CLK_ENABLE();
I2S3_TXDMA_Handler.Instance = DMA1_Stream7;
I2S3_TXDMA_Handler.Init.Channel = DMA_CHANNEL_0;
I2S3_TXDMA_Handler.Init.Direction = DMA_MEMORY_TO_PERIPH;
I2S3_TXDMA_Handler.Init.PeriphInc = DMA_PINC_DISABLE;
I2S3_TXDMA_Handler.Init.MemInc = DMA_MINC_ENABLE;
I2S3_TXDMA_Handler.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
I2S3_TXDMA_Handler.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
I2S3_TXDMA_Handler.Init.Mode = DMA_CIRCULAR;
I2S3_TXDMA_Handler.Init.Priority = DMA_PRIORITY_HIGH;
I2S3_TXDMA_Handler.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
__HAL_LINKDMA(&I2S3_Handler,hdmatx,I2S3_TXDMA_Handler);
HAL_DMA_DeInit(&I2S3_TXDMA_Handler);
HAL_DMA_Init(&I2S3_TXDMA_Handler);
// __HAL_DMA_ENABLE(&I2S3_TXDMA_Handler);
__HAL_DMA_DISABLE(&I2S3_TXDMA_Handler);
__HAL_DMA_ENABLE_IT(&I2S3_TXDMA_Handler, DMA_IT_TC); /* 开启传输完成中断 */
__HAL_DMA_CLEAR_FLAG(&I2S3_TXDMA_Handler, DMA_FLAG_TCIF0_4);
HAL_NVIC_SetPriority(DMA1_Stream7_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(DMA1_Stream7_IRQn);
}
void DMA1_Stream7_IRQHandler(void)
{
rt_audio_tx_complete(&snd_dev.audio);
HAL_DMA_IRQHandler(&I2S3_TXDMA_Handler);
}
//void HAL_SAI_TxHalfCpltCallback(SAI_HandleTypeDef *hsai)
//{
// if (hsai == &SAI1A_Handler)
// {
// rt_audio_tx_complete(&snd_dev.audio);
// }
//}
//void HAL_SAI_TxCpltCallback(SAI_HandleTypeDef *hsai)
//{
// if (hsai == &SAI1A_Handler)
// {
// rt_audio_tx_complete(&snd_dev.audio);
// }
//}
void I2S_Frequency_Set(uint32_t samplerate)
{
// uint8_t i = 0;
// uint32_t tempreg = 0;
// RCC_PeriphCLKInitTypeDef rcc_i2s_clkinit_struct;
// for (i = 0; i < (sizeof(I2S_PSC_TBL) / 10); i++) /* 看看改采样率是否可以支持 */
// {
// if ((samplerate / 10) == I2S_PSC_TBL[i][0])
// {
// break;
// }
// }
// if (i == (sizeof(I2S_PSC_TBL) / 10))
// {
// LOG_E("samplerate not supported.");
// // return 1; /* 找不到 */
// }
// rcc_i2s_clkinit_struct.PeriphClockSelection = RCC_PERIPHCLK_I2S; /* 外设时钟源选择 */
// rcc_i2s_clkinit_struct.PLLI2S.PLLI2SN = (uint32_t)I2S_PSC_TBL[i][1]; /* 设置PLLI2SN */
// rcc_i2s_clkinit_struct.PLLI2S.PLLI2SR = (uint32_t)I2S_PSC_TBL[i][2]; /* 设置PLLI2SR */
// HAL_RCCEx_PeriphCLKConfig(&rcc_i2s_clkinit_struct); /* 设置时钟 */
// RCC->CR |= 1 << 26; /* 开启I2S时钟 */
// while((RCC->CR & 1 << 27) == 0); /* 等待I2S时钟开启成功. */
// tempreg = I2S_PSC_TBL[i][3] << 0; /* 设置I2SDIV */
// tempreg |= I2S_PSC_TBL[i][4] << 8; /* 设置ODD位 */
// tempreg |= 1 << 9; /* 使能MCKOE位,输出MCK */
// I2S3_Handler.Instance->I2SPR = tempreg; /* 设置I2SPR寄存器 */
// return 0;
// RCC_PeriphCLKInitTypeDef PeriphClkInit;
// HAL_RCCEx_GetPeriphCLKConfig(&PeriphClkInit);
// if ((frequency == SAI_AUDIO_FREQUENCY_11K) || (frequency == SAI_AUDIO_FREQUENCY_22K) || (frequency == SAI_AUDIO_FREQUENCY_44K))
// {
// /* Configure and enable PLLSAI1 clock to generate 45.714286MHz */
// PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_SAI1;
// PeriphClkInit.Sai1ClockSelection = RCC_SAI1CLKSOURCE_PLLSAI2;
// PeriphClkInit.PLLSAI2.PLLSAI2Source = RCC_PLLSOURCE_HSE;
// PeriphClkInit.PLLSAI2.PLLSAI2M = 1;
// PeriphClkInit.PLLSAI2.PLLSAI2N = 40;
// PeriphClkInit.PLLSAI2.PLLSAI2ClockOut = RCC_PLLSAI2_SAI2CLK;
// HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit);
// }
// else
// {
// /* Configure and enable PLLSAI1 clock to generate 49.142857MHz */
// PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_SAI1;
// PeriphClkInit.Sai1ClockSelection = RCC_SAI1CLKSOURCE_PLLSAI2;
// PeriphClkInit.PLLSAI2.PLLSAI2Source = RCC_PLLSOURCE_HSE;
// PeriphClkInit.PLLSAI2.PLLSAI2M = 1;
// PeriphClkInit.PLLSAI2.PLLSAI2N = 43;
// PeriphClkInit.PLLSAI2.PLLSAI2P = RCC_PLLP_DIV7;
// PeriphClkInit.PLLSAI2.PLLSAI2ClockOut = RCC_PLLSAI2_SAI2CLK;
// HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit);
// }
// /* Disable SAI peripheral to allow access to SAI internal registers */
// __HAL_SAI_DISABLE(&SAI1A_Handler);
// /* Update the SAI audio frequency configuration */
// SAI1A_Handler.Init.AudioFrequency = frequency;
// HAL_SAI_Init(&SAI1A_Handler);
// /* Enable SAI peripheral to generate MCLK */
// __HAL_SAI_ENABLE(&SAI1A_Handler);
}
void SAIA_Channels_Set(uint8_t channels)
{
// if (channels == 1)
// {
// SAI1A_Handler.Init.MonoStereoMode = SAI_MONOMODE;
// }
// else
// {
// SAI1A_Handler.Init.MonoStereoMode = SAI_STEREOMODE;
// }
// __HAL_SAI_DISABLE(&SAI1A_Handler);
// HAL_SAI_Init(&SAI1A_Handler);
// __HAL_SAI_ENABLE(&SAI1A_Handler);
}
/**
* RT-Thread Audio Device Driver Interface
*/
static rt_err_t sound_getcaps(struct rt_audio_device *audio, struct rt_audio_caps *caps)
{
rt_err_t result = RT_EOK;
struct sound_device *snd_dev;
RT_ASSERT(audio != RT_NULL);
snd_dev = (struct sound_device *)audio->parent.user_data;
switch (caps->main_type)
{
case AUDIO_TYPE_QUERY: /* qurey the types of hw_codec device */
{
switch (caps->sub_type)
{
case AUDIO_TYPE_QUERY:
caps->udata.mask = AUDIO_TYPE_OUTPUT | AUDIO_TYPE_MIXER;
break;
default:
result = -RT_ERROR;
break;
}
break;
}
case AUDIO_TYPE_OUTPUT: /* Provide capabilities of OUTPUT unit */
{
switch (caps->sub_type)
{
case AUDIO_DSP_PARAM:
caps->udata.config.samplerate = snd_dev->replay_config.samplerate;
caps->udata.config.channels = snd_dev->replay_config.channels;
caps->udata.config.samplebits = snd_dev->replay_config.samplebits;
break;
case AUDIO_DSP_SAMPLERATE:
caps->udata.config.samplerate = snd_dev->replay_config.samplerate;
break;
case AUDIO_DSP_CHANNELS:
caps->udata.config.channels = snd_dev->replay_config.channels;
break;
case AUDIO_DSP_SAMPLEBITS:
caps->udata.config.samplebits = snd_dev->replay_config.samplebits;
break;
default:
result = -RT_ERROR;
break;
}
break;
}
case AUDIO_TYPE_MIXER: /* report the Mixer Units */
{
switch (caps->sub_type)
{
case AUDIO_MIXER_QUERY:
caps->udata.mask = AUDIO_MIXER_VOLUME;
break;
case AUDIO_MIXER_VOLUME:
caps->udata.value = es8388_volume_get();
break;
default:
result = -RT_ERROR;
break;
}
break;
}
default:
result = -RT_ERROR;
break;
}
return result;
}
static rt_err_t sound_configure(struct rt_audio_device *audio, struct rt_audio_caps *caps)
{
rt_err_t result = RT_EOK;
struct sound_device *snd_dev;
RT_ASSERT(audio != RT_NULL);
snd_dev = (struct sound_device *)audio->parent.user_data;
switch (caps->main_type)
{
case AUDIO_TYPE_MIXER:
{
switch (caps->sub_type)
{
case AUDIO_MIXER_VOLUME:
{
rt_uint8_t volume = caps->udata.value;
es8388_volume_set(volume);
snd_dev->volume = volume;
LOG_D("set volume %d", volume);
break;
}
default:
result = -RT_ERROR;
break;
}
break;
}
case AUDIO_TYPE_OUTPUT:
{
switch (caps->sub_type)
{
case AUDIO_DSP_PARAM:
{
/* set samplerate */
I2S_Frequency_Set(caps->udata.config.samplerate);
/* set channels */
SAIA_Channels_Set(caps->udata.config.channels);
/* save configs */
snd_dev->replay_config.samplerate = caps->udata.config.samplerate;
snd_dev->replay_config.channels = caps->udata.config.channels;
snd_dev->replay_config.samplebits = caps->udata.config.samplebits;
LOG_D("set samplerate %d", snd_dev->replay_config.samplerate);
break;
}
case AUDIO_DSP_SAMPLERATE:
{
I2S_Frequency_Set(caps->udata.config.samplerate);
snd_dev->replay_config.samplerate = caps->udata.config.samplerate;
LOG_D("set samplerate %d", snd_dev->replay_config.samplerate);
break;
}
case AUDIO_DSP_CHANNELS:
{
SAIA_Channels_Set(caps->udata.config.channels);
snd_dev->replay_config.channels = caps->udata.config.channels;
LOG_D("set channels %d", snd_dev->replay_config.channels);
break;
}
case AUDIO_DSP_SAMPLEBITS:
{
/* not support */
snd_dev->replay_config.samplebits = caps->udata.config.samplebits;
break;
}
default:
result = -RT_ERROR;
break;
}
break;
}
default:
break;
}
return result;
}
static rt_err_t sound_init(struct rt_audio_device *audio)
{
rt_err_t result = RT_EOK;
struct sound_device *snd_dev;
RT_ASSERT(audio != RT_NULL);
snd_dev = (struct sound_device *)audio->parent.user_data;
es8388_init("i2c2", RT_NULL);
I2S3_Init();
LOG_I("ES8388 init success.");
/* set default params */
I2S_Frequency_Set(snd_dev->replay_config.samplerate);
SAIA_Channels_Set(snd_dev->replay_config.channels);
return result;
}
static rt_err_t sound_start(struct rt_audio_device *audio, int stream)
{
struct sound_device *snd_dev;
RT_ASSERT(audio != RT_NULL);
snd_dev = (struct sound_device *)audio->parent.user_data;
if (stream == AUDIO_STREAM_REPLAY)
{
LOG_D("sound start.");
es8388_start(ES_MODE_DAC);
HAL_I2S_Transmit_DMA(&I2S3_Handler, (uint16_t*)snd_dev->tx_fifo, TX_FIFO_SIZE / 2);
}
return RT_EOK;
}
static rt_err_t sound_stop(struct rt_audio_device *audio, int stream)
{
RT_ASSERT(audio != RT_NULL);
if (stream == AUDIO_STREAM_REPLAY)
{
HAL_I2S_DMAStop(&I2S3_Handler);
es8388_stop(ES_MODE_DAC);
LOG_D("sound stop.");
}
return RT_EOK;
}
static void sound_buffer_info(struct rt_audio_device *audio, struct rt_audio_buf_info *info)
{
struct sound_device *snd_dev;
RT_ASSERT(audio != RT_NULL);
snd_dev = (struct sound_device *)audio->parent.user_data;
/**
* TX_FIFO
* +----------------+----------------+
* | block1 | block2 |
* +----------------+----------------+
* \ block_size /
*/
info->buffer = snd_dev->tx_fifo;
info->total_size = TX_FIFO_SIZE;
info->block_size = TX_FIFO_SIZE / 2;
info->block_count = 2;
}
static struct rt_audio_ops snd_ops =
{
.getcaps = sound_getcaps,
.configure = sound_configure,
.init = sound_init,
.start = sound_start,
.stop = sound_stop,
.transmit = RT_NULL,
.buffer_info = sound_buffer_info,
};
int rt_hw_sound_init(void)
{
rt_uint8_t *tx_fifo;
if (snd_dev.tx_fifo)
return RT_EOK;
tx_fifo = rt_malloc(TX_FIFO_SIZE);
if (tx_fifo == RT_NULL)
return -RT_ENOMEM;
rt_memset(tx_fifo, 0, TX_FIFO_SIZE);
snd_dev.tx_fifo = tx_fifo;
/* init default configuration */
{
snd_dev.replay_config.samplerate = 44100;
snd_dev.replay_config.channels = 2;
snd_dev.replay_config.samplebits = 16;
snd_dev.volume = 55;
}
/* register sound device */
snd_dev.audio.ops = &snd_ops;
rt_audio_register(&snd_dev.audio, "sound0", RT_DEVICE_FLAG_WRONLY, &snd_dev);
return RT_EOK;
}
// INIT_DEVICE_EXPORT(rt_hw_sound_init);