Method File Cleanup (#683)

This commit is contained in:
Michael Miller authored and GitHub committed 2023-04-09 10:02:49 -07:00
1 parent 3a96023c56
commit c74febefef
32 files changed
+1016 -985

No files matched your search

+671
View File
@@ -0,0 +1,671 @@
// WARNING: This file contains code that is more than likely already
// exposed from the Esp32 Arduino API. It will be removed once integration is complete.
//
// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#if defined(ARDUINO_ARCH_ESP32)
#include "sdkconfig.h" // this sets useful config symbols, like CONFIG_IDF_TARGET_ESP32C3
// ESP32 C3 & S3 I2S is not supported yet due to significant changes to interface
#if defined(ARDUINO_ARCH_ESP32) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32S3)
#include <string.h>
#include <stdio.h>
#include "stdlib.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "freertos/queue.h"
#if ESP_IDF_VERSION_MAJOR>=4
#include "esp_intr_alloc.h"
#else
#include "esp_intr.h"
#endif
#include "rom/lldesc.h"
#include "soc/gpio_reg.h"
#include "soc/gpio_sig_map.h"
#include "soc/io_mux_reg.h"
#include "soc/rtc_cntl_reg.h"
#include "soc/i2s_struct.h"
#if defined(CONFIG_IDF_TARGET_ESP32)
/* included here for ESP-IDF v4.x compatibility */
#include "soc/dport_reg.h"
#endif
#include "soc/sens_reg.h"
#include "driver/gpio.h"
#include "driver/i2s.h"
#if !defined(CONFIG_IDF_TARGET_ESP32S3)
#include "driver/dac.h"
#endif
#include "Esp32_i2s.h"
#include "esp32-hal.h"
esp_err_t i2sSetClock(uint8_t bus_num, uint8_t div_num, uint8_t div_b, uint8_t div_a, uint8_t bck, uint8_t bits_per_sample);
esp_err_t i2sSetSampleRate(uint8_t bus_num, uint32_t sample_rate, bool parallel_mode, size_t bytes_per_sample);
#define MATRIX_DETACH_OUT_SIG 0x100
#if ESP_IDF_VERSION_MAJOR<=4
#define I2S_BASE_CLK (160000000L)
#endif
#define I2S_DMA_BLOCK_COUNT_DEFAULT 0
// 20 bytes gives us enough time if we use single stage idle
// But it can't be longer due to non-parrallel mode and 50us reset time
// there just isn't enough silence at the end to fill more than 20 bytes
#define I2S_DMA_SILENCE_SIZE 20 // 4 byte increments
#define I2S_DMA_SILENCE_BLOCK_COUNT_FRONT 2 // two front
#define I2S_DMA_SILENCE_BLOCK_COUNT_BACK 1 // one back, required for non parallel
typedef struct
{
i2s_dev_t* bus;
int8_t ws;
int8_t bck;
int8_t out;
int8_t in;
intr_handle_t isr_handle;
lldesc_t* dma_items;
size_t dma_count;
volatile uint32_t is_sending_data;
} i2s_bus_t;
// is_sending_data values
#define I2s_Is_Idle 0
#define I2s_Is_Pending 1
#define I2s_Is_Sending 2
#if !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32S3)
// (I2S_NUM_MAX == 2)
static i2s_bus_t I2S[I2S_NUM_MAX] =
{
{&I2S0, -1, -1, -1, -1, NULL, NULL, I2S_DMA_BLOCK_COUNT_DEFAULT, I2s_Is_Idle},
{&I2S1, -1, -1, -1, -1, NULL, NULL, I2S_DMA_BLOCK_COUNT_DEFAULT, I2s_Is_Idle}
};
#else
static i2s_bus_t I2S[I2S_NUM_MAX] =
{
{&I2S0, -1, -1, -1, -1, NULL, NULL, I2S_DMA_BLOCK_COUNT_DEFAULT, I2s_Is_Idle}
};
#endif
void IRAM_ATTR i2sDmaISR(void* arg);
inline void dmaItemInit(lldesc_t* item, uint8_t* posData, size_t sizeData, lldesc_t* itemNext)
{
item->eof = 0;
item->owner = 1;
item->sosf = 0;
item->offset = 0;
item->buf = posData;
item->size = sizeData;
item->length = sizeData;
item->qe.stqe_next = itemNext;
}
bool i2sInitDmaItems(uint8_t bus_num, uint8_t* data, size_t dataSize)
{
if (bus_num >= I2S_NUM_MAX)
{
return false;
}
size_t dmaCount = I2S[bus_num].dma_count;
if (I2S[bus_num].dma_items == NULL)
{
I2S[bus_num].dma_items = (lldesc_t*)heap_caps_malloc(dmaCount * sizeof(lldesc_t), MALLOC_CAP_DMA);
if (I2S[bus_num].dma_items == NULL)
{
log_e("MEM ERROR!");
return false;
}
}
lldesc_t* itemFirst = &I2S[bus_num].dma_items[0];
lldesc_t* item = itemFirst;
// lldesc_t* itemsEnd = itemFirst + I2S[bus_num].dma_count;
lldesc_t* itemNext = item + 1;
size_t dataLeft = dataSize;
uint8_t* pos = data;
// at the end of the data is the encoded silence reset
uint8_t* posSilence = data + dataSize - I2S_DMA_SILENCE_SIZE;
// front two are silent items used for looping to micmic single fire
// default to looping
dmaItemInit(item, posSilence, I2S_DMA_SILENCE_SIZE, itemNext);
dmaItemInit(itemNext, posSilence, I2S_DMA_SILENCE_SIZE, item);
item = itemNext;
itemNext++;
// init blocks with avialable data
//
while (dataLeft)
{
item = itemNext;
itemNext++;
size_t blockSize = dataLeft;
if (blockSize > I2S_DMA_MAX_DATA_LEN)
{
blockSize = I2S_DMA_MAX_DATA_LEN;
}
dataLeft -= blockSize;
dmaItemInit(item, pos, blockSize, itemNext);
pos += blockSize;
}
// last data item is EOF to manage send state using EOF ISR
item->eof = 1;
// last block, the back silent item, loops to front
item = itemNext;
dmaItemInit(item, posSilence, I2S_DMA_SILENCE_SIZE, itemFirst);
return true;
}
bool i2sDeinitDmaItems(uint8_t bus_num)
{
if (bus_num >= I2S_NUM_MAX)
{
return false;
}
heap_caps_free(I2S[bus_num].dma_items);
I2S[bus_num].dma_items = NULL;
return true;
}
// normal 4, 10, 63, 12, 16
esp_err_t i2sSetClock(uint8_t bus_num,
uint8_t div_num, // 4 13
uint8_t div_b, // 10 20
uint8_t div_a, // 63 63
uint8_t bck, // 12 60 or 7
uint8_t bits) // 16 8
{
if (bus_num >= I2S_NUM_MAX || div_a > 63 || div_b > 63 || bck > 63)
{
return ESP_FAIL;
}
//log_i("i2sSetClock bus %u, clkm_div_num %u, clk_div_a %u, clk_div_b %u, bck_div_num %u, bits_mod %u",
// bus_num,
// div_num,
// div_a,
// div_b,
// bck,
// bits);
i2s_dev_t* i2s = I2S[bus_num].bus;
typeof(i2s->clkm_conf) clkm_conf;
clkm_conf.val = 0;
#if defined(CONFIG_IDF_TARGET_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32S3)
clkm_conf.clk_sel = 2; // APPL = 1 APB = 2
clkm_conf.clk_en = 1; // examples of i2s show this being set if sel is set to 2
#else
clkm_conf.clka_en = 0;
#endif
clkm_conf.clkm_div_a = div_a;
clkm_conf.clkm_div_b = div_b;
clkm_conf.clkm_div_num = div_num;
i2s->clkm_conf.val = clkm_conf.val;
typeof(i2s->sample_rate_conf) sample_rate_conf;
sample_rate_conf.val = 0;
sample_rate_conf.tx_bck_div_num = bck;
sample_rate_conf.rx_bck_div_num = bck;
sample_rate_conf.tx_bits_mod = bits;
sample_rate_conf.rx_bits_mod = bits;
i2s->sample_rate_conf.val = sample_rate_conf.val;
return ESP_OK;
}
void i2sSetPins(uint8_t bus_num,
int8_t out,
int8_t parallel,
int8_t busSampleSize,
bool invert)
{
if (bus_num >= I2S_NUM_MAX)
{
return;
}
if (out >= 0)
{
uint32_t i2sSignal;
pinMode(out, OUTPUT);
#if defined(CONFIG_IDF_TARGET_ESP32S2)
// S2 only has one bus
//
// in parallel mode
// 8bit mode : I2S0O_DATA_OUT16_IDX ~I2S0O_DATA_OUT23_IDX
// 16bit mode : I2S0O_DATA_OUT8_IDX ~I2S0O_DATA_OUT23_IDX
// 24bit mode : I2S0O_DATA_OUT0_IDX ~I2S0O_DATA_OUT23_IDX
if (parallel == -1)
{
i2sSignal = I2S0O_DATA_OUT23_IDX;
}
else if (busSampleSize == 1)
{
i2sSignal = I2S0O_DATA_OUT16_IDX + parallel;
}
else if (busSampleSize == 2)
{
i2sSignal = I2S0O_DATA_OUT8_IDX + parallel;
}
else
{
i2sSignal = I2S0O_DATA_OUT0_IDX + parallel;
}
#else
if (bus_num == 0)
{
// in parallel mode
// 0-7 bits : I2S0O_DATA_OUT16_IDX ~I2S0O_DATA_OUT23_IDX
// 8-15 bits : I2S0O_DATA_OUT8_IDX ~I2S0O_DATA_OUT23_IDX
// 16-23 bits : I2S0O_DATA_OUT0_IDX ~I2S0O_DATA_OUT23_IDX
if (parallel == -1)
{
i2sSignal = I2S0O_DATA_OUT23_IDX;
}
else if (parallel < 8)
{
i2sSignal = I2S0O_DATA_OUT16_IDX + parallel;
}
else if (parallel < 16)
{
i2sSignal = I2S0O_DATA_OUT8_IDX + parallel - 8;
}
else
{
i2sSignal = I2S0O_DATA_OUT0_IDX + parallel - 16;
}
}
else
{
if (parallel == -1)
{
i2sSignal = I2S1O_DATA_OUT23_IDX;
}
else
{
i2sSignal = I2S1O_DATA_OUT0_IDX + parallel;
}
}
#endif
//log_i("i2sSetPins bus %u, i2sSignal %u, pin %u, mux %u",
// bus_num,
// i2sSignal,
// out,
// parallel);
gpio_matrix_out(out, i2sSignal, invert, false);
}
}
void i2sSetClkWsPins(uint8_t bus_num,
int8_t outClk,
bool invertClk,
int8_t outWs,
bool invertWs)
{
if (bus_num >= I2S_NUM_MAX)
{
return;
}
uint32_t i2sSignalClk = I2S0O_BCK_OUT_IDX;
uint32_t i2sSignalWs = I2S0O_WS_OUT_IDX;
#if !defined(CONFIG_IDF_TARGET_ESP32S2)
if (bus_num == 1)
{
i2sSignalClk = I2S1O_BCK_OUT_IDX;
i2sSignalWs = I2S1O_WS_OUT_IDX;
}
#endif
if (outClk >= 0)
{
pinMode(outClk, OUTPUT);
gpio_matrix_out(outClk, i2sSignalClk, invertClk, false);
}
if (outWs >= 0)
{
pinMode(outWs, OUTPUT);
gpio_matrix_out(outWs, i2sSignalWs, invertWs, false);
}
}
bool i2sWriteDone(uint8_t bus_num)
{
if (bus_num >= I2S_NUM_MAX)
{
return false;
}
return (I2S[bus_num].is_sending_data == I2s_Is_Idle);
}
void i2sInit(uint8_t bus_num,
bool parallel_mode,
size_t bytes_per_sample,
uint32_t sample_rate,
i2s_tx_chan_mod_t chan_mod,
i2s_tx_fifo_mod_t fifo_mod,
size_t dma_count,
uint8_t* data,
size_t dataSize)
{
if (bus_num >= I2S_NUM_MAX)
{
return;
}
I2S[bus_num].dma_count = dma_count +
I2S_DMA_SILENCE_BLOCK_COUNT_FRONT +
I2S_DMA_SILENCE_BLOCK_COUNT_BACK;
if (!i2sInitDmaItems(bus_num, data, dataSize))
{
return;
}
#if !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32S3)
// (I2S_NUM_MAX == 2)
if (bus_num)
{
periph_module_enable(PERIPH_I2S1_MODULE);
}
else
#endif
{
periph_module_enable(PERIPH_I2S0_MODULE);
}
esp_intr_disable(I2S[bus_num].isr_handle);
i2s_dev_t* i2s = I2S[bus_num].bus;
i2s->out_link.stop = 1;
i2s->conf.tx_start = 0;
i2s->int_ena.val = 0;
i2s->int_clr.val = 0xFFFFFFFF;
i2s->fifo_conf.dscr_en = 0;
// reset i2s
i2s->conf.tx_reset = 1;
i2s->conf.tx_reset = 0;
i2s->conf.rx_reset = 1;
i2s->conf.rx_reset = 0;
// reset dma
i2s->lc_conf.in_rst = 1;
i2s->lc_conf.in_rst = 0;
i2s->lc_conf.out_rst = 1;
i2s->lc_conf.out_rst = 0;
// reset fifo
i2s->conf.rx_fifo_reset = 1;
i2s->conf.rx_fifo_reset = 0;
i2s->conf.tx_fifo_reset = 1;
i2s->conf.tx_fifo_reset = 0;
// set parallel (LCD) mode
{
typeof(i2s->conf2) conf2;
conf2.val = 0;
conf2.lcd_en = parallel_mode;
conf2.lcd_tx_wrx2_en = 0; // parallel_mode; // ((parallel_mode) && (bytes_per_sample == 2));
i2s->conf2.val = conf2.val;
}
// Enable and configure DMA
{
typeof(i2s->lc_conf) lc_conf;
lc_conf.val = 0;
lc_conf.out_eof_mode = 1;
i2s->lc_conf.val = lc_conf.val;
}
#if !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32S3)
i2s->pdm_conf.pcm2pdm_conv_en = 0;
i2s->pdm_conf.pdm2pcm_conv_en = 0;
#endif
// SET_PERI_REG_BITS(RTC_CNTL_CLK_CONF_REG, RTC_CNTL_SOC_CLK_SEL, 0x1, RTC_CNTL_SOC_CLK_SEL_S);
{
typeof(i2s->fifo_conf) fifo_conf;
fifo_conf.val = 0;
fifo_conf.rx_fifo_mod_force_en = 1;
fifo_conf.tx_fifo_mod_force_en = 1;
fifo_conf.tx_fifo_mod = fifo_mod; // 0-right&left channel;1-one channel
fifo_conf.rx_fifo_mod = fifo_mod; // 0-right&left channel;1-one channel
fifo_conf.rx_data_num = 32; //Thresholds.
fifo_conf.tx_data_num = 32;
i2s->fifo_conf.val = fifo_conf.val;
}
// $REVIEW old code didn't set this
{
typeof(i2s->conf1) conf1;
conf1.val = 0;
conf1.tx_stop_en = 0;
conf1.tx_pcm_bypass = 1;
i2s->conf1.val = conf1.val;
}
{
typeof(i2s->conf_chan) conf_chan;
conf_chan.val = 0;
conf_chan.tx_chan_mod = chan_mod; // 0-two channel;1-right;2-left;3-righ;4-left
conf_chan.rx_chan_mod = chan_mod; // 0-two channel;1-right;2-left;3-righ;4-left
i2s->conf_chan.val = conf_chan.val;
}
{
typeof(i2s->conf) conf;
conf.val = 0;
conf.tx_msb_shift = !parallel_mode; // 0:DAC/PCM, 1:I2S
conf.tx_right_first = 0; // parallel_mode?;
i2s->conf.val = conf.val;
}
i2s->timing.val = 0;
#if !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32S3)
i2s->pdm_conf.rx_pdm_en = 0;
i2s->pdm_conf.tx_pdm_en = 0;
#endif
i2sSetSampleRate(bus_num, sample_rate, parallel_mode, bytes_per_sample);
/* */
//Reset FIFO/DMA -> needed? Doesn't dma_reset/fifo_reset do this?
i2s->lc_conf.in_rst=1; i2s->lc_conf.out_rst=1; i2s->lc_conf.ahbm_rst=1; i2s->lc_conf.ahbm_fifo_rst=1;
i2s->lc_conf.in_rst=0; i2s->lc_conf.out_rst=0; i2s->lc_conf.ahbm_rst=0; i2s->lc_conf.ahbm_fifo_rst=0;
i2s->conf.tx_reset=1; i2s->conf.tx_fifo_reset=1; i2s->conf.rx_fifo_reset=1;
i2s->conf.tx_reset=0; i2s->conf.tx_fifo_reset=0; i2s->conf.rx_fifo_reset=0;
/* */
// enable intr in cpu //
int i2sIntSource;
#if !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32S3)
// (I2S_NUM_MAX == 2)
if (bus_num == 1) {
i2sIntSource = ETS_I2S1_INTR_SOURCE;
}
else
#endif
{
i2sIntSource = ETS_I2S0_INTR_SOURCE;
}
esp_intr_alloc(i2sIntSource, ESP_INTR_FLAG_IRAM | ESP_INTR_FLAG_LEVEL1, &i2sDmaISR, &I2S[bus_num], &I2S[bus_num].isr_handle);
// enable send intr
i2s->int_ena.out_eof = 1;
i2s->int_ena.out_dscr_err = 1;
/* ??? */
// Enable and configure DMA
{
typeof(i2s->lc_conf) lc_conf;
lc_conf.val = 0;
lc_conf.out_data_burst_en = 1;
lc_conf.indscr_burst_en = 1;
i2s->lc_conf.val = lc_conf.val;
}
/* */
i2s->fifo_conf.dscr_en = 1;// enable dma
i2s->out_link.start = 0;
i2s->out_link.addr = (uint32_t)(&I2S[bus_num].dma_items[0]); // loads dma_struct to dma
i2s->out_link.start = 1; // starts dma
i2s->conf.tx_start = 1;// Start I2s module
esp_intr_enable(I2S[bus_num].isr_handle);
}
void i2sDeinit(uint8_t bus_num)
{
i2sDeinitDmaItems(bus_num);
}
esp_err_t i2sSetSampleRate(uint8_t bus_num, uint32_t rate, bool parallel_mode, size_t bytes_per_sample)
{
if (bus_num >= I2S_NUM_MAX)
{
return ESP_FAIL;
}
uint8_t bck = 12;
// parallel mode needs a higher sample rate
//
if (parallel_mode)
{
#if defined(CONFIG_IDF_TARGET_ESP32S2)
rate *= bytes_per_sample;
bck *= bytes_per_sample;
//rate /= bytes_per_sample;
//bck /= bytes_per_sample;
#else
rate *= bytes_per_sample;
#endif
}
// 160,000,000L / (100,000 * 384)
double clkmdiv = (double)I2S_BASE_CLK / ((rate * 384) + 1);
if (clkmdiv > 256.0)
{
log_e("rate is too low");
return ESP_FAIL;
}
else if (clkmdiv < 2.0)
{
log_e("rate is too fast, clkmdiv = %f (%u, %u, %u)",
clkmdiv,
rate,
parallel_mode,
bytes_per_sample);
return ESP_FAIL;
}
// calc integer and franctional for more precise timing
//
uint8_t clkmInteger = clkmdiv;
uint8_t clkmFraction = (clkmdiv - clkmInteger) * 63.0;
i2sSetClock(bus_num, clkmInteger, clkmFraction, 63, bck, bytes_per_sample * 8);
return ESP_OK;
}
void IRAM_ATTR i2sDmaISR(void* arg)
{
i2s_bus_t* i2s = (i2s_bus_t*)(arg);
if (i2s->bus->int_st.out_eof)
{
// lldesc_t* item = (lldesc_t*)(i2s->bus->out_eof_des_addr);
if (i2s->is_sending_data != I2s_Is_Idle)
{
// the second item (last of the two front silent items) is
// silent looping item
lldesc_t* itemLoop = &i2s->dma_items[0];
lldesc_t* itemLoopBreaker = itemLoop + 1;
// set to loop on silent items
itemLoopBreaker->qe.stqe_next = itemLoop;
i2s->is_sending_data = I2s_Is_Idle;
}
}
i2s->bus->int_clr.val = i2s->bus->int_st.val;
}
bool i2sWrite(uint8_t bus_num)
{
if (bus_num >= I2S_NUM_MAX)
{
return false;
}
// the second item (last of the two front silent items) is
// silent looping item
lldesc_t* itemLoopBreaker = &I2S[bus_num].dma_items[1];
lldesc_t* itemLoopNext = itemLoopBreaker + 1;
// set to NOT loop on silent items
itemLoopBreaker->qe.stqe_next = itemLoopNext;
I2S[bus_num].is_sending_data = I2s_Is_Sending;
return true;
}
#endif // !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32S3)
#endif // defined(ARDUINO_ARCH_ESP32)