First attempt at getting audio out. Both speaker and headphone produce sound but the gain seems off.

Author: jwktje

src/AudioBoard.h

@@ -131,6 +131,8 @@ static AudioBoard NoBoard{NoDriver, NoPins};
 static AudioBoard GenericWM8960{AudioDriverWM8960, NoPins};
 /// @ingroup audio_driver
 static AudioBoard GenericCS43l22{AudioDriverCS43l22, NoPins};
+/// @ingroup audio_driver
+static AudioBoard GenericTLV320DAC3100{AudioDriverTLV320DAC3100, NoPins};
 #if defined(ARDUINO_GENERIC_F411VETX)
 /// @ingroup audio_driver
 static AudioBoard STM32F411Disco{AudioDriverCS43l22, PinsSTM32F411Disco};

src/Driver.h

@@ -13,6 +13,7 @@
 #include "Driver/es8388/es8388.h"
 #include "Driver/pcm3168/pcm3168.h"
 #include "Driver/tas5805m/tas5805m.h"
+#include "Driver/tlv320dac3100/tlv320dac3100.h"
 #include "Driver/wm8960/mtb_wm8960.h"
 #include "Driver/wm8978/WM8978.h"
 #include "Driver/wm8994/wm8994.h"
@@ -1530,6 +1531,36 @@ class AudioDriverAD1938Class : public AudioDriver {
   int volumes[8] = {100};
 };
 
+
+/**
+ * @brief Driver API for TLV320DAC3100 codec chip
+ * @author Phil Schatzmann
+ * @copyright GPLv3
+ */
+class AudioDriverTLV320DAC3100Class : public AudioDriver {
+ public:
+  AudioDriverTLV320DAC3100Class() { i2c_default_address = 0x18; }
+  bool setMute(bool mute) { return tlv320dac3100_set_mute(mute); }
+  bool setVolume(int volume) {
+    return tlv320dac3100_set_volume(limitValue(volume, 0, 100));
+  }
+  int getVolume() {
+    int vol = 0;
+    tlv320dac3100_get_volume(&vol);
+    return vol;
+  }
+
+ protected:
+  bool init(codec_config_t codec_cfg) {
+    return tlv320dac3100_init(&codec_cfg, getI2C(), getI2CAddress()) == RESULT_OK;
+  }
+  bool deinit() { return tlv320dac3100_deinit() == RESULT_OK; }
+  bool controlState(codec_mode_t mode) { return true; }
+  bool configInterface(codec_mode_t mode, I2SDefinition iface) {
+    return tlv320dac3100_config_i2s(mode, &iface) == RESULT_OK;
+  }
+};
+
 #endif
 
 // -- Drivers
@@ -1573,6 +1604,8 @@ static NoDriverClass NoDriver;
 static AudioDriverCS42448Class AudioDriverCS42448;
 /// @ingroup audio_driver
 static AudioDriverPCM3168Class AudioDriverPCM3168;
+/// @ingroup audio_driver
+static AudioDriverTLV320DAC3100Class AudioDriverTLV320DAC3100;
 
 #ifdef ARDUINO
 /// @ingroup audio_driver

src/Driver/tlv320dac3100/README.md

@@ -0,0 +1,66 @@
+# TLV320DAC3100 driver
+
+Below is the example sketch I'm using with the Adafruit breakout and a Wemos Lolin S3 Pro. It plays a WAV from the SD card. 
+
+```
+#include "AudioTools.h"
+#include "AudioTools/Disk/AudioSourceSD.h"
+#include "AudioTools/AudioCodecs/CodecWAV.h"
+#include "AudioTools/AudioLibs/I2SCodecStream.h"
+
+// Pins
+#define I2C_SDA_PIN 9
+#define I2C_SCL_PIN 10
+#define I2S_BCLK_PIN 42
+#define I2S_WS_PIN 41
+#define I2S_DI_PIN 40
+#define I2S_RST_PIN 39
+#define SD_SCK_PIN 12
+#define SD_MISO_PIN 13
+#define SD_MOSI_PIN 11
+#define SD_CS_PIN 46
+
+I2SCodecStream i2s(GenericTLV320DAC3100);
+EncodedAudioStream decoder(&i2s, new WAVDecoder());
+StreamCopy copier;
+File file;
+
+void setup() {
+  Serial.begin(115200);
+  delay(2000);
+  AudioLogger::instance().begin(Serial, AudioLogger::Warning);  // Enable warning logging
+  AudioDriverLogger.begin(Serial, AudioDriverLogLevel::Info);   // Enable info logging
+  Serial.println("Setup starting...");
+
+  // Set SD pins first
+  Serial.println("Initializing SD card...");
+  SPI.begin(SD_SCK_PIN, SD_MISO_PIN, SD_MOSI_PIN, SD_CS_PIN);
+  if (!SD.begin(SD_CS_PIN)) {
+    Serial.println("Card Mount Failed");
+    return;
+  }
+
+  Serial.println("I2C begin...");
+  Wire.begin(I2C_SDA_PIN, I2C_SCL_PIN);
+
+  Serial.println("I2S begin...");
+  I2SCodecConfig config;
+  config.sample_rate = 48000;  // 48kHz to match DAC configuration
+  config.channels = 2;
+  config.bits_per_sample = 16;
+  config.pin_bck = I2S_BCLK_PIN;  // define your i2s pins
+  config.pin_ws = I2S_WS_PIN;
+  config.pin_data = I2S_DI_PIN;
+  config.buffer_size = 1024;
+
+  i2s.begin(config);
+  decoder.begin();
+  copier.begin(decoder, file);
+
+  file = SD.open("/test.wav");
+}
+
+void loop() {
+  copier.copy();
+}
+```

src/Driver/tlv320dac3100/tlv320dac3100.c

@@ -0,0 +1,258 @@
+#include "tlv320dac3100.h"
+
+static i2c_bus_handle_t i2c_handle = NULL;
+static int address = TLV320DAC3100_ADDR;
+
+#define TLV_ASSERT(a, format, b, ...) \
+  if ((a) != 0) {                    \
+    AD_LOGE(format, ##__VA_ARGS__);  \
+    return b;                        \
+  }
+
+static error_t tlv_write_reg(uint8_t slave_addr, uint8_t reg_add, uint8_t data) {
+  return i2c_bus_write_bytes(i2c_handle, slave_addr, &reg_add, sizeof(reg_add),
+                             &data, sizeof(data));
+}
+
+static error_t tlv_read_reg(uint8_t reg_add, uint8_t *p_data) {
+  return i2c_bus_read_bytes(i2c_handle, address, &reg_add, sizeof(reg_add),
+                            p_data, 1);
+}
+
+static error_t tlv_set_page(uint8_t page) {
+  return tlv_write_reg(address, TLV320DAC3100_REG_PAGE_SELECT, page);
+}
+
+error_t tlv320dac3100_init(codec_config_t *cfg, i2c_bus_handle_t handle, int addr) {
+  AD_LOGI("TLV320DAC3100 start init");
+
+  AD_TRACED();
+  i2c_handle = handle;
+  if (addr > 0) address = addr;
+
+  // 0. Reset the codec
+  AD_LOGI("Resetting codec");
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_RESET, 0x01), "Failed to reset codec", RESULT_FAIL);
+  delay(100);  // Increased delay to match working sketch
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_RESET, 0x00), "Failed to reset codec", RESULT_FAIL);
+  delay(10);   // Additional delay after reset
+
+  // 1. Interface Control - Set codec interface (I2S, 16-bit)
+  AD_LOGI("Configuring codec interface");
+  TLV_ASSERT(tlv_set_page(0), "Failed to set page 0", RESULT_FAIL);
+  uint8_t if_ctrl = (TLV320DAC3100_FORMAT_I2S << 6) | (TLV320DAC3100_DATA_LEN_16 << 4);
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_CODEC_IF_CTRL1, if_ctrl), "Failed to configure I2S interface", RESULT_FAIL);
+
+  // 2. Clock MUX and PLL settings
+  AD_LOGI("Configuring clocks and PLL");
+  // 2.1 Set codec clock input to PLL and PLL clock input to BCLK
+  uint8_t clock_mux = (TLV320DAC3100_PLL_CLKIN_BCLK << 2) | TLV320DAC3100_CODEC_CLKIN_PLL;
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_CLOCK_MUX1, clock_mux), "Failed to configure clock sources", RESULT_FAIL);
+
+  // 2.2 Set PLL values: P=1, R=2, J=32, D=0 (matching working sketch)
+  uint8_t pll_pr = (1 << 4) | 2;  // P=1, R=2
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_PLL_PROG_PR, pll_pr), "Failed to set PLL P&R", RESULT_FAIL);
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_PLL_PROG_J, 32), "Failed to set PLL J", RESULT_FAIL);
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_PLL_PROG_D_MSB, 0x00), "Failed to set PLL D MSB", RESULT_FAIL);
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_PLL_PROG_D_LSB, 0x00), "Failed to set PLL D LSB", RESULT_FAIL);
+
+  // 3. DAC/ADC config
+  AD_LOGI("Configuring DAC dividers");
+  // 3.1 Set NDAC = 8 (bit 7 = enable, bits 6:0 = value)
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_NDAC, 0x80 | 8), "Failed to set NDAC", RESULT_FAIL);
+  
+  // 3.2 Set MDAC = 2 (bit 7 = enable, bits 6:0 = value)
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_MDAC, 0x80 | 2), "Failed to set MDAC", RESULT_FAIL);
+
+  // 4. Power up the PLL (bit 7 = 1 to power up)
+  AD_LOGI("Powering up PLL");
+  uint8_t pll_power = 0x80 | pll_pr;  // Set power bit (7) and keep P&R values
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_PLL_PROG_PR, pll_power), "Failed to power up PLL", RESULT_FAIL);
+
+  // 5. DAC Setup
+  AD_LOGI("Configuring DAC data path");
+  // 5.1 Set DAC data path (power up both DACs, normal paths, 1 sample volume step)
+  uint8_t dac_path = (1 << 7) |  // Left DAC power up
+                     (1 << 6) |  // Right DAC power up
+                     (TLV320DAC3100_DAC_PATH_NORMAL << 4) |  // Left path
+                     (TLV320DAC3100_DAC_PATH_NORMAL << 2) |  // Right path
+                     TLV320DAC3100_VOLUME_STEP_1SAMPLE;      // Volume step
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_DAC_DATAPATH, dac_path), "Failed to configure DAC data path", RESULT_FAIL);
+
+  // 5.2 Configure analog inputs - switch to page 1
+  TLV_ASSERT(tlv_set_page(1), "Failed to set page 1", RESULT_FAIL);
+  uint8_t routing = (TLV320DAC3100_DAC_ROUTE_MIXER << 6) |  // Left DAC to mixer
+                    (TLV320DAC3100_DAC_ROUTE_MIXER << 2);   // Right DAC to mixer
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_OUT_ROUTING, routing), "Failed to configure analog routing", RESULT_FAIL);
+
+  // 6. DAC volume control - switch back to page 0
+  AD_LOGI("Configuring DAC volume");
+  TLV_ASSERT(tlv_set_page(0), "Failed to set page 0", RESULT_FAIL);
+  // Unmute both channels, independent volume control
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_DAC_VOL_CTRL, TLV320DAC3100_VOL_INDEPENDENT), "Failed to configure volume control", RESULT_FAIL);
+  
+  // Set channel volumes to +0dB (register value 0x01) - matching working sketch
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_DAC_LVOL, 0x01), "Failed to set left volume", RESULT_FAIL);
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_DAC_RVOL, 0x01), "Failed to set right volume", RESULT_FAIL);
+
+  // 7. Headphone and speaker setup - switch to page 1
+  AD_LOGI("Configuring headphone and speaker outputs");
+  TLV_ASSERT(tlv_set_page(1), "Failed to set page 1", RESULT_FAIL);
+  
+  // 7.1 Configure headphone driver (power up both, 1.35V common mode, no power down on SCD)
+  uint8_t hp_ctrl = (1 << 7) |  // Left HP power up
+                    (1 << 6) |  // Right HP power up
+                    (1 << 2) |  // Required bit 2 = 1
+                    (TLV320DAC3100_HP_COMMON_1_35V << 3);  // Common mode voltage
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_HP_DRIVERS, hp_ctrl), "Failed to configure headphone drivers", RESULT_FAIL);
+
+  // 7.2 Configure HPL PGA (0dB gain, unmute)
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_HPL_DRIVER, (0 << 3) | (1 << 2)), "Failed to configure HPL PGA", RESULT_FAIL);
+  
+  // 7.3 Configure HPR PGA (0dB gain, unmute)
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_HPR_DRIVER, (0 << 3) | (1 << 2)), "Failed to configure HPR PGA", RESULT_FAIL);
+
+  // 7.4 Set HPL volume (enable routing, volume=1)
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_HPL_VOL, 0x80 | 1), "Failed to set HPL volume", RESULT_FAIL);
+  
+  // 7.5 Set HPR volume (enable routing, volume=1)
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_HPR_VOL, 0x80 | 1), "Failed to set HPR volume", RESULT_FAIL);
+
+  // 7.6 Enable speaker amplifier
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_SPK_AMP, 0x80), "Failed to enable speaker", RESULT_FAIL);
+  
+  // 7.7 Configure speaker PGA (6dB gain, unmute)
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_SPK_DRIVER, (TLV320DAC3100_SPK_GAIN_6DB << 3) | (1 << 2)), "Failed to configure speaker PGA", RESULT_FAIL);
+  
+  // 7.8 Set speaker volume (enable routing, volume=1)
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_SPK_VOL, 0x80 | 1), "Failed to set speaker volume", RESULT_FAIL);
+
+  // 8. MICBIAS and headset detection
+  AD_LOGI("Configuring MICBIAS and headset detection");
+  // 8.1 Configure MICBIAS (not powered down, always on, AVDD voltage)
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_MICBIAS, (1 << 3) | TLV320DAC3100_MICBIAS_AVDD), "Failed to configure MICBIAS", RESULT_FAIL);
+
+  // 8.2 Set headset detect - switch to page 0
+  TLV_ASSERT(tlv_set_page(0), "Failed to set page 0", RESULT_FAIL);
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_HEADSET_DETECT, 0x80), "Failed to enable headset detection", RESULT_FAIL);
+
+  // 8.3 Set INT1 source (headset detect + button press)
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_INT1_CTRL, (1 << 7) | (1 << 6)), "Failed to configure INT1", RESULT_FAIL);
+
+  // 8.4 Set GPIO1 mode to INT1
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_GPIO1_CTRL, TLV320DAC3100_GPIO1_INT1 << 2), "Failed to configure GPIO1", RESULT_FAIL);
+
+  AD_LOGI("TLV320DAC3100 initialized successfully");
+  return RESULT_OK;
+}
+
+error_t tlv320dac3100_deinit(void) {
+  AD_TRACED();
+  TLV_ASSERT(tlv_set_page(0), "Failed to set page 0", RESULT_FAIL);
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_DAC_DATAPATH, 0x00), "Failed to power down DACs", RESULT_FAIL);
+  TLV_ASSERT(tlv_set_page(1), "Failed to set page 1", RESULT_FAIL);
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_HP_DRIVERS, 0x00), "Failed to power down HP", RESULT_FAIL);
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_SPK_AMP, 0x00), "Failed to power down speaker", RESULT_FAIL);
+  return RESULT_OK;
+}
+
+error_t tlv320dac3100_config_i2s(codec_mode_t mode, I2SDefinition *iface) {
+  AD_TRACED();
+  TLV_ASSERT(tlv_set_page(0), "Failed to set page 0", RESULT_FAIL);
+  
+  uint8_t format_bits = TLV320DAC3100_FORMAT_I2S;
+  switch (iface->fmt) {
+    case I2S_NORMAL: format_bits = TLV320DAC3100_FORMAT_I2S; break;
+    case I2S_LEFT: format_bits = TLV320DAC3100_FORMAT_LEFT_JUSTIFIED; break;
+    case I2S_RIGHT: format_bits = TLV320DAC3100_FORMAT_RIGHT_JUSTIFIED; break;
+    case I2S_DSP: format_bits = TLV320DAC3100_FORMAT_DSP; break;
+    default: AD_LOGE("Unsupported I2S format: %d", iface->fmt); return RESULT_FAIL;
+  }
+  
+  uint8_t len_bits = TLV320DAC3100_DATA_LEN_16;
+  switch (iface->bits) {
+    case BIT_LENGTH_16BITS: len_bits = TLV320DAC3100_DATA_LEN_16; break;
+    case BIT_LENGTH_20BITS: len_bits = TLV320DAC3100_DATA_LEN_20; break;
+    case BIT_LENGTH_24BITS: len_bits = TLV320DAC3100_DATA_LEN_24; break;
+    case BIT_LENGTH_32BITS: len_bits = TLV320DAC3100_DATA_LEN_32; break;
+    default: AD_LOGE("Unsupported bit length: %d", iface->bits); return RESULT_FAIL;
+  }
+  
+  uint8_t if_ctrl = (format_bits << 6) | (len_bits << 4);
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_CODEC_IF_CTRL1, if_ctrl), "Failed to configure I2S", RESULT_FAIL);
+  
+  return RESULT_OK;
+}
+
+error_t tlv320dac3100_set_volume(int volume) {
+  AD_LOGD("tlv320dac3100_set_volume: %d", volume);
+  TLV_ASSERT(tlv_set_page(0), "Failed to set page 0", RESULT_FAIL);
+  
+  if (volume < 0) volume = 0;
+  if (volume > 100) volume = 100;
+  
+  // Convert 0-100 to dB range (-63.5 to +24 dB)
+  float dB;
+  if (volume == 0) {
+    dB = -63.5f;  // Mute
+  } else if (volume == 100) {
+    dB = 24.0f;   // Max volume
+  } else {
+    // Map 0-100 to -63.5 to +24 dB with better linearity
+    dB = -63.5f + (volume * 0.875f);
+  }
+  
+  // Convert dB to register value (2dB steps) with proper bounds
+  int8_t reg_val;
+  if (dB <= -63.5f) {
+    reg_val = -127; // Mute
+  } else if (dB >= 24.0f) {
+    reg_val = 48;   // Max volume
+  } else {
+    reg_val = (int8_t)(dB * 2.0f);
+  }
+  
+  // Set DAC volume
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_DAC_LVOL, reg_val), "Failed to set left volume", RESULT_FAIL);
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_DAC_RVOL, reg_val), "Failed to set right volume", RESULT_FAIL);
+  
+  // Also update headphone and speaker volumes
+  TLV_ASSERT(tlv_set_page(1), "Failed to set page 1", RESULT_FAIL);
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_HPL_VOL, 0x80 | reg_val), "Failed to set HPL volume", RESULT_FAIL);
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_HPR_VOL, 0x80 | reg_val), "Failed to set HPR volume", RESULT_FAIL);
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_SPK_VOL, 0x80 | reg_val), "Failed to set speaker volume", RESULT_FAIL);
+  
+  return RESULT_OK;
+}
+
+error_t tlv320dac3100_get_volume(int *volume) {
+  AD_TRACED();
+  TLV_ASSERT(tlv_set_page(0), "Failed to set page 0", RESULT_FAIL);
+  
+  uint8_t reg_val;
+  TLV_ASSERT(tlv_read_reg(TLV320DAC3100_REG_DAC_LVOL, &reg_val), "Failed to read volume", RESULT_FAIL);
+  
+  // Convert register value to dB
+  float dB = (int8_t)reg_val * 0.5f;
+  
+  // Convert dB to 0-100 range
+  if (dB <= -63.5f) {
+    *volume = 0;
+  } else if (dB >= 24.0f) {
+    *volume = 100;
+  } else {
+    *volume = (int)((dB + 63.5f) / 0.875f);
+  }
+  
+  return RESULT_OK;
+}
+
+error_t tlv320dac3100_set_mute(bool enable) {
+  AD_TRACED();
+  TLV_ASSERT(tlv_set_page(0), "Failed to set page 0", RESULT_FAIL);
+  
+  uint8_t vol_ctrl = enable ? 0x0C : 0x00; // Set mute bits for both channels
+  TLV_ASSERT(tlv_write_reg(address, TLV320DAC3100_REG_DAC_VOL_CTRL, vol_ctrl), "Failed to set mute", RESULT_FAIL);
+  
+  return RESULT_OK;
+}