H2201_Audio_Mixer/ESP32/main/H2201_i2c.c

#include "esp_system.h"
#include "esp_log.h"
#include "driver/i2c.h"

#include "H2201_i2c.h"
#include "H2201_V1_IC1.h"
#include "H2201_V1_IC1_PARAM.h"
#include "SigmaStudioFW.h"

SemaphoreHandle_t i2c_block_mutex = NULL;

void H2201_i2c_beep_task(void *arg)
{
    printf("start beep task \n");
    if (xSemaphoreTake(i2c_block_mutex, (TickType_t)portMAX_DELAY) == pdTRUE)
    {
        ADI_REG_TYPE beep_on[4] = {0x00, 0x80, 0x00, 0x00};
        SIGMA_WRITE_REGISTER_BLOCK(DEVICE_ADDR_IC1, MOD_BEEPSWITCH_ISON_ADDR, 4, beep_on);
        vTaskDelay(400 / portTICK_PERIOD_MS);
        ADI_REG_TYPE beep_off[4] = {0x00, 0x00, 0x00, 0x00};
        SIGMA_WRITE_REGISTER_BLOCK(DEVICE_ADDR_IC1, MOD_BEEPSWITCH_ISON_ADDR, 4, beep_off);

        xSemaphoreGive(i2c_block_mutex);
    }
    else
    {
        printf("cannot get mutex \n");
    }
    vTaskDelete(NULL);
}
void H2201_i2c_beep(void)
{
    xTaskCreate(H2201_i2c_beep_task, "beep", 2048, NULL, configMAX_PRIORITIES - 3, NULL);
}

void H2201_i2c_mastervolume_task(void *arg)
{
    uint8_t volume = *((uint8_t *)arg);
    if (xSemaphoreTake(i2c_block_mutex, (TickType_t)portMAX_DELAY) == pdTRUE)
    {
        uint8_t vol = volume << R30_PB_HEADPHONE_LEFT_VOL_IC1_SHIFT;
        vol |= (1 << R30_PB_HEADPHONE_LEFT_PWRUP_IC1_SHIFT); // Headphone volume control enable.
        vol |= (1 << R30_PB_HEADPHONE_LEFT_MUTE_IC1_SHIFT);  // unmute
        SIGMA_WRITE_REGISTER(DEVICE_ADDR_IC1, REG_PLAYBACK_HEADPHONE_LEFT_IC1_ADDR, vol);

        vol &= ~(1 << R31_PB_HEADPHONE_RIGHT_PWRUP_IC1_SHIFT); // enable line output
        SIGMA_WRITE_REGISTER(DEVICE_ADDR_IC1, REG_PLAYBACK_HEADPHONE_RIGHT_IC1_ADDR, vol);

        xSemaphoreGive(i2c_block_mutex);
    }
    else
    {
        printf("cannot get mutex \n");
    }
    vTaskDelete(NULL);
}
void H2201_i2c_mastervolume(uint8_t volume)
{
    xTaskCreate(H2201_i2c_mastervolume_task, "mastervolume", 2048, (void *)&volume, configMAX_PRIORITIES - 3, NULL);
}

void H2201_i2c_telephonevolume_task(void *arg)
{
    uint8_t volume = *((uint8_t *)arg);
    if (xSemaphoreTake(i2c_block_mutex, (TickType_t)portMAX_DELAY) == pdTRUE)
    {
        uint8_t vol = volume << R23_PBC0_AUX_OUT_GAIN_IC1_SHIFT;
        vol |= (1 << R23_PBC0_LEFT_DAC_MUTE_IC1_SHIFT); // unmute left
        vol |= (1 << R23_PBC0_MIX_ENABLE_IC1_SHIFT);    // enable mixer
        SIGMA_WRITE_REGISTER(DEVICE_ADDR_IC1, REG_PLAYBACK_MIXER_LEFT_CONTROL_0_IC1_ADDR, vol);

        vol &= ~(1 << R25_PBMRC0_L_DAC_MUTE_IC1_SHIFT); // mute left
        vol |= (1 << R25_PBMRC0_R_DAC_MUTE_IC1_SHIFT);  // unmute right
        SIGMA_WRITE_REGISTER(DEVICE_ADDR_IC1, REG_PLABACK_MIXER_RIGHT_CONTROL_0_IC1_ADDR, vol);

        xSemaphoreGive(i2c_block_mutex);
    }
    else
    {
        printf("cannot get mutex \n");
    }
    vTaskDelete(NULL);
}
void H2201_i2c_telephonevolume(uint8_t volume)
{
    xTaskCreate(H2201_i2c_telephonevolume_task, "telvolume", 2048, (void *)&volume, configMAX_PRIORITIES - 3, NULL);
}

void H2201_i2c_bluetoothvolume_task(void *arg)
{
    uint8_t volume = *((uint8_t *)arg);
    if (xSemaphoreTake(i2c_block_mutex, (TickType_t)portMAX_DELAY) == pdTRUE)
    {
        printf("bluetooth vol %d\n", volume);

        // SIGMA_WRITE_REGISTER(DEVICE_ADDR_IC1, REG_PLAYBACK_MIXER_LEFT_CONTROL_0_IC1_ADDR, volume);
        //  vTaskDelay(10 / portTICK_PERIOD_MS);
        // SIGMA_WRITE_REGISTER(DEVICE_ADDR_IC1, REG_PLABACK_MIXER_RIGHT_CONTROL_0_IC1_ADDR, volume);

        xSemaphoreGive(i2c_block_mutex);
    }
    else
    {
        printf("cannot get mutex \n");
    }
    vTaskDelete(NULL);
}
void H2201_i2c_bluetoothvolume(uint8_t volume)
{
    xTaskCreate(H2201_i2c_bluetoothvolume_task, "blvolume", 2048, (void *)&volume, configMAX_PRIORITIES - 3, NULL);
}

void H2201_i2c_pcvolume_task(void *arg)
{
    uint8_t volume = *((uint8_t *)arg);
    if (xSemaphoreTake(i2c_block_mutex, (TickType_t)portMAX_DELAY) == pdTRUE)
    {
        uint8_t vol = volume << 3;
        vol |= volume;
        vol = vol << 1;
        vol |= (1 << R5_ENABLE_MIXER_IC1_SHIFT); // mixer enable

        SIGMA_WRITE_REGISTER(DEVICE_ADDR_IC1, REG_RECORD_MIXER_LEFT_CTRL_0_IC1_ADDR, vol);
        SIGMA_WRITE_REGISTER(DEVICE_ADDR_IC1, REG_RECORD_MIXER_RIGHT_CTRL_0_IC1_ADDR, vol);

        xSemaphoreGive(i2c_block_mutex);
    }
    else
    {
        printf("cannot get mutex \n");
    }
    vTaskDelete(NULL);
}
void H2201_i2c_pcvolume(uint8_t volume)
{
    xTaskCreate(H2201_i2c_pcvolume_task, "pcvolume", 2048, (void *)&volume, configMAX_PRIORITIES - 3, NULL);
}

void H2201_i2c_master_init(void)
{
    i2c_config_t i2c_config = {
        .mode = I2C_MODE_MASTER,
        .sda_io_num = I2C_MASTER_SDA_IO,
        .sda_pullup_en = GPIO_PULLUP_DISABLE,
        .scl_io_num = I2C_MASTER_SCL_IO,
        .scl_pullup_en = GPIO_PULLUP_DISABLE,
        .master.clk_speed = I2C_MASTER_FREQ_HZ,
        // .clk_flags = 0,          /*!< Optional, you can use I2C_SCLK_SRC_FLAG_* flags to choose i2c source clock here. */
    };
    esp_err_t err;
    if ((err = i2c_param_config(I2C_MASTER_NUM, &i2c_config)) != ESP_OK)
    {
        ESP_LOGE(H2201_I2C_TAG, "%s i2c param config failed: %s\n", __func__, esp_err_to_name(err));
        return;
    }
    if ((err = i2c_driver_install(I2C_MASTER_NUM, I2C_MODE_MASTER, I2C_MASTER_RX_BUF_DISABLE, I2C_MASTER_TX_BUF_DISABLE, 0)) != ESP_OK)
    {
        ESP_LOGE(H2201_I2C_TAG, "%s i2c driver config failed: %s\n", __func__, esp_err_to_name(err));
        return;
    }

    i2c_block_mutex = xSemaphoreCreateBinary();
    xSemaphoreGive(i2c_block_mutex);
}

void H2201_i2c_adau1761_init(void)
{
    default_download_IC1();
}