CS43L22.h

Go to the documentation of this file.

 
/* Define to prevent recursive inclusion -------------------------------------*/
#pragma once
 
/* Includes ------------------------------------------------------------------*/
//#include "../Common/audio.h"
#include <stdint.h>
#include "stdbool.h"
#include "stddef.h"
#include "DriverCommon.h"
#include "Platforms/API_I2C.h"
#include "Codecs/CodecConstants.h"
 
namespace audio_driver {
 
class CS43L22 {
 public:
  enum AudioFrequency : uint32_t {
    AUDIO_FREQUENCY_192K = 192000,
    AUDIO_FREQUENCY_96K = 96000,
    AUDIO_FREQUENCY_48K = 48000,
    AUDIO_FREQUENCY_44K = 44100,
    AUDIO_FREQUENCY_32K = 32000,
    AUDIO_FREQUENCY_22K = 22050,
    AUDIO_FREQUENCY_16K = 16000,
    AUDIO_FREQUENCY_11K = 11025,
    AUDIO_FREQUENCY_8K = 8000
  };
  static constexpr uint8_t OUTPUT_DEVICE_SPEAKER = 1;
  static constexpr uint8_t OUTPUT_DEVICE_HEADPHONE = 2;
  static constexpr uint8_t OUTPUT_DEVICE_BOTH = 3;
  static constexpr uint8_t OUTPUT_DEVICE_AUTO = 4;
  static constexpr uint8_t DEFAULT_VOLMIN = 0x00;
  static constexpr uint8_t DEFAULT_VOLMAX = 0xFF;
  static constexpr uint8_t DEFAULT_VOLSTEP = 0x04;
  static constexpr int AUDIO_PAUSE = 0;
  static constexpr int AUDIO_RESUME = 1;
  static constexpr int CODEC_PDWN_HW = 1;
  static constexpr int CODEC_PDWN_SW = 2;
  static constexpr int AUDIO_MUTE_ON = 1;
  static constexpr int AUDIO_MUTE_OFF = 0;
  static constexpr uint8_t CS43L22_REG_ID = 0x01;
  static constexpr uint8_t CS43L22_REG_POWER_CTL1 = 0x02;
  static constexpr uint8_t CS43L22_REG_POWER_CTL2 = 0x04;
  static constexpr uint8_t CS43L22_REG_CLOCKING_CTL = 0x05;
  static constexpr uint8_t CS43L22_REG_INTERFACE_CTL1 = 0x06;
  static constexpr uint8_t CS43L22_REG_INTERFACE_CTL2 = 0x07;
  static constexpr uint8_t CS43L22_REG_PASSTHR_A_SELECT = 0x08;
  static constexpr uint8_t CS43L22_REG_PASSTHR_B_SELECT = 0x09;
  static constexpr uint8_t CS43L22_REG_ANALOG_ZC_SR_SETT = 0x0A;
  static constexpr uint8_t CS43L22_REG_PASSTHR_GANG_CTL = 0x0C;
  static constexpr uint8_t CS43L22_REG_PLAYBACK_CTL1 = 0x0D;
  static constexpr uint8_t CS43L22_REG_MISC_CTL = 0x0E;
  static constexpr uint8_t CS43L22_REG_PLAYBACK_CTL2 = 0x0F;
  static constexpr uint8_t CS43L22_REG_PASSTHR_A_VOL = 0x14;
  static constexpr uint8_t CS43L22_REG_PASSTHR_B_VOL = 0x15;
  static constexpr uint8_t CS43L22_REG_PCMA_VOL = 0x1A;
  static constexpr uint8_t CS43L22_REG_PCMB_VOL = 0x1B;
  static constexpr uint8_t CS43L22_REG_BEEP_FREQ_ON_TIME = 0x1C;
  static constexpr uint8_t CS43L22_REG_BEEP_VOL_OFF_TIME = 0x1D;
  static constexpr uint8_t CS43L22_REG_BEEP_TONE_CFG = 0x1E;
  static constexpr uint8_t CS43L22_REG_TONE_CTL = 0x1F;
  static constexpr uint8_t CS43L22_REG_MASTER_A_VOL = 0x20;
  static constexpr uint8_t CS43L22_REG_MASTER_B_VOL = 0x21;
  static constexpr uint8_t CS43L22_REG_HEADPHONE_A_VOL = 0x22;
  static constexpr uint8_t CS43L22_REG_HEADPHONE_B_VOL = 0x23;
  static constexpr uint8_t CS43L22_REG_SPEAKER_A_VOL = 0x24;
  static constexpr uint8_t CS43L22_REG_SPEAKER_B_VOL = 0x25;
  static constexpr uint8_t CS43L22_REG_CH_MIXER_SWAP = 0x26;
  static constexpr uint8_t CS43L22_REG_LIMIT_CTL1 = 0x27;
  static constexpr uint8_t CS43L22_REG_LIMIT_CTL2 = 0x28;
  static constexpr uint8_t CS43L22_REG_LIMIT_ATTACK_RATE = 0x29;
  static constexpr uint8_t CS43L22_REG_OVF_CLK_STATUS = 0x2E;
  static constexpr uint8_t CS43L22_REG_BATT_COMPENSATION = 0x2F;
  static constexpr uint8_t CS43L22_REG_VP_BATTERY_LEVEL = 0x30;
  static constexpr uint8_t CS43L22_REG_SPEAKER_STATUS = 0x31;
  static constexpr uint8_t CS43L22_REG_TEMPMONITOR_CTL = 0x32;
  static constexpr uint8_t CS43L22_REG_THERMAL_FOLDBACK = 0x33;
  static constexpr uint8_t CS43L22_REG_CHARGE_PUMP_FREQ = 0x34;
  static constexpr uint8_t CODEC_STANDARD = 0x04;
  static constexpr uint8_t CS43L22_ID = 0xE0;
  static constexpr uint8_t CS43L22_ID_MASK = 0xF8;
  static constexpr uint8_t CS43L22_CHIPID_ADDR = 0x01;
  static constexpr uint8_t cs43l22VolumeConvert(uint8_t volume) {
    return volume > 100 ? 255 : (uint8_t)((volume * 255) / 100);
  }
  CS43L22() = default;
 
  void setWire(i2c_bus_handle_t handle) { i2c_handle = handle; }
 
  void setAddress(uint16_t addr) { device_addr = addr; }
 
  uint32_t init(uint16_t outputDevice, uint8_t volume, uint32_t audioFreq) {
    uint32_t counter = 0;
 
    /* Keep Codec powered OFF */
    counter += writeReg(CS43L22_REG_POWER_CTL1, 0x01);
 
    /*Save Output device for mute ON/OFF procedure*/
    switch (outputDevice) {
      case OUTPUT_DEVICE_SPEAKER:
        output_dev = 0xFA;
        break;
 
      case OUTPUT_DEVICE_HEADPHONE:
        output_dev = 0xAF;
        break;
 
      case OUTPUT_DEVICE_BOTH:
        output_dev = 0xAA;
        break;
 
      case OUTPUT_DEVICE_AUTO:
        output_dev = 0x05;
        break;
 
      default:
        output_dev = 0x05;
        break;
    }
 
    counter += writeReg(CS43L22_REG_POWER_CTL2, output_dev);
 
    /* Clock configuration: Auto detection */
    counter += writeReg(CS43L22_REG_CLOCKING_CTL, 0x81);
 
    /* Set the Slave Mode and the audio Standard */
    counter += writeReg(CS43L22_REG_INTERFACE_CTL1, CODEC_STANDARD);
 
    /* Set the Master volume */
    counter += setVolume(volume);
 
    /* If the Speaker is enabled, set the Mono mode and volume attenuation level
     */
    if (outputDevice != OUTPUT_DEVICE_HEADPHONE) {
      /* Set the Speaker Mono mode */
      counter += writeReg(CS43L22_REG_PLAYBACK_CTL2, 0x06);
 
      /* Set the Speaker attenuation level */
      counter += writeReg(CS43L22_REG_SPEAKER_A_VOL, 0x00);
      counter += writeReg(CS43L22_REG_SPEAKER_B_VOL, 0x00);
    }
 
    /* Additional configuration for the CODEC. These configurations are done to
    reduce the time needed for the Codec to power off. If these configurations are
    removed, then a long delay should be added between powering off the Codec and
    switching off the I2S peripheral MCLK clock (which is the operating clock for
    Codec). If this delay is not inserted, then the codec will not shut down
    properly and it results in high noise after shut down. */
 
    /* Disable the analog soft ramp */
    counter += writeReg(CS43L22_REG_ANALOG_ZC_SR_SETT, 0x00);
    /* Disable the digital soft ramp */
    counter += writeReg(CS43L22_REG_MISC_CTL, 0x04);
    /* Disable the limiter attack level */
    counter += writeReg(CS43L22_REG_LIMIT_CTL1, 0x00);
    /* Adjust Bass and Treble levels */
    counter += writeReg(CS43L22_REG_TONE_CTL, 0x0F);
    /* Adjust PCM volume level */
    counter += writeReg(CS43L22_REG_PCMA_VOL, 0x0A);
    counter += writeReg(CS43L22_REG_PCMB_VOL, 0x0A);
 
    /* Return communication control value */
    return counter;
  }
 
  void deinit() {}
 
  uint32_t readID() {
    uint8_t reg = CS43L22_CHIPID_ADDR;
    uint8_t value = 0;
    i2c_bus_read_bytes(i2c_handle, device_addr, &reg, 1, &value, 1);
    return (uint32_t)(value & CS43L22_ID_MASK);
  }
 
  uint32_t play(uint16_t* pBuffer, uint16_t size) {
    uint32_t counter = 0;
 
    if (is_stop == 1) {
      /* Enable the digital soft ramp */
      counter += writeReg(CS43L22_REG_MISC_CTL, 0x06);
 
      /* Enable Output device */
      counter += setMute(AUDIO_MUTE_OFF);
 
      /* Power on the Codec */
      counter += writeReg(CS43L22_REG_POWER_CTL1, 0x9E);
      is_stop = 0;
    }
 
    /* Return communication control value */
    return counter;
  }
 
  uint32_t pause() {
    uint32_t counter = 0;
 
    /* Pause the audio file playing */
    /* Mute the output first */
    counter += setMute(AUDIO_MUTE_ON);
 
    /* Put the Codec in Power save mode */
    counter += writeReg(CS43L22_REG_POWER_CTL1, 0x01);
 
    return counter;
  }
 
  uint32_t resume() {
    uint32_t counter = 0;
    /* Resumes the audio file playing */
    /* Unmute the output first */
    counter += setMute(AUDIO_MUTE_OFF);
 
    delayMs(10);
 
    counter += writeReg(CS43L22_REG_POWER_CTL2, output_dev);
 
    /* Exit the Power save mode */
    counter += writeReg(CS43L22_REG_POWER_CTL1, 0x9E);
 
    return counter;
  }
 
  uint32_t stop(uint32_t cmd) {
    uint32_t counter = 0;
 
    /* Mute the output first */
    counter += setMute(AUDIO_MUTE_ON);
 
    /* Disable the digital soft ramp */
    counter += writeReg(CS43L22_REG_MISC_CTL, 0x04);
 
    /* Power down the DAC and the speaker (PMDAC and PMSPK bits)*/
    counter += writeReg(CS43L22_REG_POWER_CTL1, 0x9F);
 
    is_stop = 1;
    return counter;
  }
 
  uint32_t setVolume(uint8_t volume) {
    uint32_t counter = 0;
    uint8_t convertedvol = cs43l22VolumeConvert(volume);
 
    if (convertedvol > 0xE6) {
      /* Set the Master volume */
      counter += writeReg(CS43L22_REG_MASTER_A_VOL, convertedvol - 0xE7);
      counter += writeReg(CS43L22_REG_MASTER_B_VOL, convertedvol - 0xE7);
    } else {
      /* Set the Master volume */
      counter += writeReg(CS43L22_REG_MASTER_A_VOL, convertedvol + 0x19);
      counter += writeReg(CS43L22_REG_MASTER_B_VOL, convertedvol + 0x19);
    }
 
    return counter;
  }
 
  uint32_t setFrequency(uint32_t audioFreq) { return 0; }
 
  uint32_t setMute(uint32_t cmd) {
    uint32_t counter = 0;
 
    /* Set the Mute mode */
    if (cmd == AUDIO_MUTE_ON) {
      counter += writeReg(CS43L22_REG_POWER_CTL2, 0xFF);
      counter += writeReg(CS43L22_REG_HEADPHONE_A_VOL, 0x01);
      counter += writeReg(CS43L22_REG_HEADPHONE_B_VOL, 0x01);
    } else /* AUDIO_MUTE_OFF Disable the Mute */
    {
      counter += writeReg(CS43L22_REG_HEADPHONE_A_VOL, 0x00);
      counter += writeReg(CS43L22_REG_HEADPHONE_B_VOL, 0x00);
      counter += writeReg(CS43L22_REG_POWER_CTL2, output_dev);
    }
    return counter;
  }
 
  uint32_t setOutputMode(uint8_t output) {
    uint32_t counter = 0;
 
    switch (output) {
      case OUTPUT_DEVICE_SPEAKER:
        counter += writeReg(CS43L22_REG_POWER_CTL2,
                             0xFA); /* SPK always ON & HP always OFF */
        output_dev = 0xFA;
        break;
 
      case OUTPUT_DEVICE_HEADPHONE:
        counter += writeReg(CS43L22_REG_POWER_CTL2,
                             0xAF); /* SPK always OFF & HP always ON */
        output_dev = 0xAF;
        break;
 
      case OUTPUT_DEVICE_BOTH:
        counter += writeReg(CS43L22_REG_POWER_CTL2,
                             0xAA); /* SPK always ON & HP always ON */
        output_dev = 0xAA;
        break;
 
      case OUTPUT_DEVICE_AUTO:
        counter += writeReg(CS43L22_REG_POWER_CTL2,
                             0x05); /* Detect the HP or the SPK automatically */
        output_dev = 0x05;
        break;
 
      default:
        counter += writeReg(CS43L22_REG_POWER_CTL2,
                             0x05); /* Detect the HP or the SPK automatically */
        output_dev = 0x05;
        break;
    }
    return counter;
  }
 
  uint32_t reset() { return 0; }
  uint8_t writeReg(uint8_t reg, uint8_t value) {
    error_t rc = i2c_bus_write_bytes(i2c_handle, device_addr, &reg, 1, &value, 1);
    return rc == RESULT_OK ? 0 : 1;
  }
 
 protected:
  i2c_bus_handle_t i2c_handle = nullptr;
  uint16_t device_addr = 0;
  uint8_t is_stop = 1;
  volatile uint8_t output_dev = 0;
};
 
} // namespace audio_driver