This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

TLV320AIC32 LINE2 (R/L) to ADC route problem

Other Parts Discussed in Thread: TLV320AIC32

Hello,

I have some problem with routing LINE2 R/L to output amplifier.

My application is to use codec as audio mixing matrix (without I2S at all).

According to datasheet, LINE2 can be routed to output drivers bypassing PGA and this I have done working very well.

Also LINE/MIC3RL works just fine using ADC&PGA.

Unfortunatelly, I can't configure LINE2RL to go through ADC and PGA and then go to output driver...

Attaching schematic.

  • Hi, Cezary,

    Welcome to E2E and thank you for your interest in our products!

    In order to route the PGA output to the output drivers, it is necessary to configure the registers PGA_L/R to (output). For example, Page 0 / Register 46 routes the PGA_L output to the HPLOUT.

    Could you provide your register configuration to have a better approach to this issue?

    Thank you.

    Best regards,
    Luis Fernando Rodríguez S.
  • Hello,

    This is my register config to basic Audio init (dbg function is something like printf):

    void AUDIO_Reset (void)
    {
        CODEC_RESET_L;
        delay_ms(10);
        CODEC_RESET_H;
        delay_ms(30);
    }

    void AUDIO_Init (void)
    {
        AUDIO_Reset();
        //delay_ms(50);
        dbg ("Writing Headset_Configuration_Register %d \n", I2C_WRITE8B_REG(I2C_Audio_Channel, Audio_Chip_Address, Headset_Configuration_Register, 0x00));
        dbg ("Writing Left_ADC_PGA_Gain_Control_Register %d \n", I2C_WRITE8B_REG(I2C_Audio_Channel, Audio_Chip_Address, Left_ADC_PGA_Gain_Control_Register, 0x09));
        dbg ("Writing Right_ADC_PGA_Gain_Control_Register %d \n", I2C_WRITE8B_REG(I2C_Audio_Channel, Audio_Chip_Address, Right_ADC_PGA_Gain_Control_Register, 0x09));
        dbg ("Writing High_Power_Output_Driver_Control_Register %d \n", I2C_WRITE8B_REG(I2C_Audio_Channel, Audio_Chip_Address,High_Power_Output_Driver_Control_Register , 0x04));
        dbg ("Writing HPLCOM_Output_Level_Control_Register %d \n", I2C_WRITE8B_REG(I2C_Audio_Channel, Audio_Chip_Address, HPLCOM_Output_Level_Control_Register, 0x2F));
        dbg ("Writing HPRCOM_Output_Level_Control_Register %d \n", I2C_WRITE8B_REG(I2C_Audio_Channel, Audio_Chip_Address, HPRCOM_Output_Level_Control_Register, 0x0F));
        dbg ("Writing HPLOUT_Output_Level_Control_Register %d \n", I2C_WRITE8B_REG(I2C_Audio_Channel, Audio_Chip_Address, HPLOUT_Output_Level_Control_Register, 0x0F));
        dbg ("Writing HPROUT_Output_Level_Control_Register %d \n", I2C_WRITE8B_REG(I2C_Audio_Channel, Audio_Chip_Address, HPROUT_Output_Level_Control_Register, 0x0F));

    }

    And for enabling Line2RL:

            AUDIO_Set_Path(LINE2L_to_HPLOUT, Enabled, 0x00);
            AUDIO_Set_Path(LINE2R_to_HPROUT, Enabled, 0x00);

    //This routes LINE2 directly to output driver passing PGA
        //    AUDIO_Set_Path(LINE2L_to_HPLCOM, Enabled, 0x00);
        //    AUDIO_Set_Path(LINE2R_to_HPRCOM, Enabled, 0x00);

          
            AUDIO_Set_Path(PGA_R_to_HPROUT, Enabled, 0x00);
            AUDIO_Set_Path(PGA_L_to_HPLOUT, Enabled, 0x00);

     AUDIO_Set_Path  routine is like this (inside switch at first argument):

        case LINE2L_to_Left_ADC:
            dbg ("LINE2L_to_Left_ADC, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable == Enabled )
                AUDIO_REG_W(LINE2L_to_Left_ADC_Control_Register,((Value)<<3));
            else
                AUDIO_REG_W(LINE2L_to_Left_ADC_Control_Register, 0x78);
            break;

        case LINE2R_to_Right_ADC:
            dbg ("LINE2R_to_Right_ADC, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable == Enabled)
                AUDIO_REG_W(LINE2R_to_Right_ADC_Control_Register,((Value)<<3));

            else
                AUDIO_REG_W(LINE2R_to_Right_ADC_Control_Register, 0x78);
            break;

    Hope that will put some light on it.

  • For enabling radio I have this and it works fine:

    void AUDIO_Set_FMRADIO (uint8_t Enable)
    {
    if (Enable == Enabled)
    {
    //Włączanie sygnału z radia FM
    AUDIO_Set_Path(MIC3LR_to_Left_ADC, Enabled, 0x88);
    AUDIO_Set_Path(MIC3LR_to_Right_ADC, Enabled, 0x88);

    AUDIO_Set_Path(PGA_R_to_HPLOUT, Enabled, 0x00);
    AUDIO_Set_Path(PGA_R_to_HPROUT, Enabled, 0x00);
    AUDIO_Set_Path(PGA_L_to_HPLOUT, Enabled, 0x00);
    AUDIO_Set_Path(PGA_L_to_HPROUT, Enabled, 0x00);
    }
    else
    {
    AUDIO_Set_Path(MIC3LR_to_Left_ADC, Disabled, 0xFF);
    AUDIO_Set_Path(MIC3LR_to_Right_ADC, Disabled, 0xFF);
    }
    }
  • Of course I posted wrong code.
    For enabling LINE2RL I have tried this:


    AUDIO_Set_Path(LINE2L_to_Left_ADC, Enabled, 0x00);
    AUDIO_Set_Path(LINE2R_to_Right_ADC, Enabled, 0x00);

    //AUDIO_Set_Path(LINE2L_to_HPLOUT, Enabled, 0x00);
    //AUDIO_Set_Path(LINE2R_to_HPROUT, Enabled, 0x00);

    //AUDIO_Set_Path(LINE2L_to_HPLCOM, Enabled, 0x00);
    //AUDIO_Set_Path(LINE2R_to_HPRCOM, Enabled, 0x00);

    AUDIO_Set_Path(PGA_R_to_HPLOUT, Enabled, 0x00);
    AUDIO_Set_Path(PGA_R_to_HPROUT, Enabled, 0x00);
    AUDIO_Set_Path(PGA_L_to_HPLOUT, Enabled, 0x00);
    AUDIO_Set_Path(PGA_L_to_HPROUT, Enabled, 0x00);

    Init function is the same.
  • Hi, Cezary,

    The analog inputs and outputs should be enabled in order to use these functions. Please ensure that the HPROUT (page 0 / register 65) and HPLOUT (page 0 / register 51) are fully powered up. Also, ensure that the ADC is powered on. This will provide the necessary DC bias to enable the analog inputs.

    Best regards,
    Luis Fernando Rodríguez S.
  • As you could see in AUDIO_Init function, there is:

        dbg ("Writing HPLOUT_Output_Level_Control_Register %d \n", I2C_WRITE8B_REG(I2C_Audio_Channel, Audio_Chip_Address, HPLOUT_Output_Level_Control_Register, 0x0F));
        dbg ("Writing HPROUT_Output_Level_Control_Register %d \n", I2C_WRITE8B_REG(I2C_Audio_Channel, Audio_Chip_Address, HPROUT_Output_Level_Control_Register, 0x0F));

    So these registers are set.

    Just to be clear. When I channel LINE3 (RADIO) through ADC->PGA->HPROUT/HPRCOM then it works just fine.

    Problem happens when I try to configure:

    Register 23:LINE2R to Right ADC Control Register
    Register 20: LINE2L to Left ADC Control Register

    For example I write to them 0x00 to be sure about gain.

    And this is I'm trying to do in:
    AUDIO_Set_Path(LINE2L_to_Left_ADC, Enabled, 0x00);
    AUDIO_Set_Path(LINE2R_to_Right_ADC, Enabled, 0x00);

  • Hello,

    I have found problem in my code. Problem was located in passing arguments through I2C envelope function...

    Sorry to bother you.

    Bellow is my source code for others :)

    audio.c


    #include "stm32f10x_exti.h"
    #include "stm32f10x_adc.h"
    #include "stm32f10x_gpio.h"
    #include "stm32f10x_rcc.h"
    #include "stm32f10x_spi.h"
    #include "stm32f10x_usart.h"
    #include "stm32f10x_i2c.h"
    #include "stm32f10x.h"
    #include "stm32f10x_flash.h"
    #include "stm32f10x_tim.h"
    #include "stm32f10x_dma.h"
    #include "stm32f10x_can.h"
    #include "misc.h"
    #include <stdio.h>
    #include <stdarg.h>
    #include <stdlib.h>
    #include "HAL.h"
    #include "audio.h"
    #include "I2C.h"


    void AUDIO_Reset (void)
    {
        CODEC_RESET_L;
        delay_ms(10);
        CODEC_RESET_H;
        delay_ms(30);
    }

    void AUDIO_Init (void)
    {
        AUDIO_Reset();
        dbg ("Writing Headset_Configuration_Register %d \n", I2C_WRITE8B_REG(I2C_Audio_Channel, Audio_Chip_Address, Headset_Configuration_Register, 0x00));
        dbg ("Writing Left_ADC_PGA_Gain_Control_Register %d \n", I2C_WRITE8B_REG(I2C_Audio_Channel, Audio_Chip_Address, Left_ADC_PGA_Gain_Control_Register, 0x09));
        dbg ("Writing Right_ADC_PGA_Gain_Control_Register %d \n", I2C_WRITE8B_REG(I2C_Audio_Channel, Audio_Chip_Address, Right_ADC_PGA_Gain_Control_Register, 0x09));
        dbg ("Writing High_Power_Output_Driver_Control_Register %d \n", I2C_WRITE8B_REG(I2C_Audio_Channel, Audio_Chip_Address,High_Power_Output_Driver_Control_Register , 0x04));
        dbg ("Writing HPLCOM_Output_Level_Control_Register %d \n", I2C_WRITE8B_REG(I2C_Audio_Channel, Audio_Chip_Address, HPLCOM_Output_Level_Control_Register, 0x2F));
        dbg ("Writing HPRCOM_Output_Level_Control_Register %d \n", I2C_WRITE8B_REG(I2C_Audio_Channel, Audio_Chip_Address, HPRCOM_Output_Level_Control_Register, 0x0F));
        dbg ("Writing HPLOUT_Output_Level_Control_Register %d \n", I2C_WRITE8B_REG(I2C_Audio_Channel, Audio_Chip_Address, HPLOUT_Output_Level_Control_Register, 0x0F));
        dbg ("Writing HPROUT_Output_Level_Control_Register %d \n", I2C_WRITE8B_REG(I2C_Audio_Channel, Audio_Chip_Address, HPROUT_Output_Level_Control_Register, 0x0F));
    }

    //Radio FM jest wysterowywane na sluchawki.
    void AUDIO_Set_FMRADIO (uint8_t Enable)
    {
        if (Enable == Enabled)
        {
        //Włączanie sygnału z radia FM
            AUDIO_Set_Path(MIC3LR_to_Left_ADC, Enabled, 0x88);
            AUDIO_Set_Path(MIC3LR_to_Right_ADC, Enabled, 0x88);

            AUDIO_Set_Path(PGA_R_to_HPLOUT, Enabled, 0x00);
            AUDIO_Set_Path(PGA_R_to_HPROUT, Enabled, 0x00);
            AUDIO_Set_Path(PGA_L_to_HPLOUT, Enabled, 0x00);
            AUDIO_Set_Path(PGA_L_to_HPROUT, Enabled, 0x00);
        }
        else
        {
            AUDIO_Set_Path(MIC3LR_to_Left_ADC, Disabled, 0xFF);
            AUDIO_Set_Path(MIC3LR_to_Right_ADC, Disabled, 0xFF);
        }
    }

    //GSM jest wysterowywany na głosniczek
    void AUDIO_Set_GSM (uint8_t Enable)
    {
        if (Enable == Enabled)
        {
        //Włączanie sygnału z modułu GSM
            AUDIO_Set_Path(LINE2L_to_Left_ADC, Enabled, 0x00);
            AUDIO_Set_Path(LINE2R_to_Right_ADC, Enabled, 0x00);
            AUDIO_Set_Path(PGA_R_to_HPROUT, Enabled, 0x00);
            AUDIO_Set_Path(PGA_L_to_HPLOUT, Enabled, 0x00);
        }
        else
        {
            AUDIO_Set_Path(LINE2L_to_Left_ADC, Disabled, 0x00);
            AUDIO_Set_Path(LINE2R_to_Right_ADC, Disabled, 0x00);
        }

    }
    void AUDIO_Set_Path(uint8_t AudioPath,uint8_t Enable, uint8_t Value)
    {
        dbg ("Setting ");
        switch (AudioPath)
        {
        case LINE1L_to_Left_ADC:
            dbg ("LINE1L_to_Left_ADC, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable==Enabled)
                AUDIO_REG_W(LINE1L_to_Left_ADC_Control_Register,0x04|((Value&&0x07)<<3));//Włączenie kanału i ustawienie głosnosci
            else
                AUDIO_REG_W(LINE1L_to_Left_ADC_Control_Register, 0x7B);//Wyłączenie kanału
            break;

        case LINE1L_to_Right_ADC:
            dbg ("LINE1L_to_Right_ADC, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if ((Enable==Enabled) && (Value<0x08))
                AUDIO_REG_W(LINE1L_to_Right_ADC_Control_Register,((Value&&0x07)<<3));//Włączenie kanału i ustawienie głosnosci
            else
                AUDIO_REG_W(LINE1L_to_Right_ADC_Control_Register, 0x78);//Wyłączenie kanału
            break;

        case LINE1R_to_Left_ADC:
            dbg ("LINE1R_to_Left_ADC, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if ((Enable==Enabled) && (Value<0x08))
                AUDIO_REG_W(LINE1R_to_Left_ADC_Control_Register,((Value&&0x07)<<3));//Włączenie kanału i ustawienie głosnosci
            else
                AUDIO_REG_W(LINE1R_to_Left_ADC_Control_Register, 0x78);//Wyłączenie kanału
            break;
            break;

        case LINE1R_to_Right_ADC:
            dbg ("LINE1R_to_Right_ADC, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if ((Enable==Enabled) && (Value<0x08))
                AUDIO_REG_W(LINE1R_to_Right_ADC_Control_Register,0x04|((Value&&0x07)<<3));//Włączenie kanału i ustawienie głosnosci
            else
                AUDIO_REG_W(LINE1R_to_Right_ADC_Control_Register, 0x7B);//Wyłączenie kanału
            break;

        case LINE2L_to_Left_ADC:
            dbg ("LINE2L_to_Left_ADC, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable == Enabled )
                AUDIO_REG_W(LINE2L_to_Left_ADC_Control_Register,((Value)<<3));//Włączenie kanału i ustawienie głosnosci
            else
                AUDIO_REG_W(LINE2L_to_Left_ADC_Control_Register, 0x78);//Wyłączenie kanału
            break;

        case LINE2R_to_Right_ADC:
            dbg ("LINE2R_to_Right_ADC, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable == Enabled)
                AUDIO_REG_W(LINE2R_to_Right_ADC_Control_Register,((Value)<<3));//Włączenie kanału i ustawienie głosnosci
            else
                AUDIO_REG_W(LINE2R_to_Right_ADC_Control_Register, 0x78);//Wyłączenie kanału
            break;

        case MIC3LR_to_Left_ADC:
            dbg ("MIC3LR_to_Left_ADC, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable==Enabled)
                AUDIO_REG_W(MIC3LR_to_Left_ADC_Control_Register,Value);//Włączenie kanału i ustawienie głosnosci
            else
                AUDIO_REG_W(MIC3LR_to_Left_ADC_Control_Register, 0xFF);//Wyłączenie kanału
            break;


        case MIC3LR_to_Right_ADC:
            dbg ("MIC3LR_to_Right_ADC, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable==Enabled)
                AUDIO_REG_W(MIC3LR_to_Right_ADC_Control_Register, Value);//Włączenie kanału i ustawienie głosnosci
            else
                AUDIO_REG_W(MIC3LR_to_Right_ADC_Control_Register, 0xFF);//Wyłączenie kanału
            break;

        case PGA_L_to_HPLOUT:
            dbg ("PGA_L_to_HPLOUT, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable == Enabled)
                    AUDIO_REG_W(PGA_L_to_HPLOUT_Volume_Control_Register, Value | 0x80);
                else
                    AUDIO_REG_W(PGA_L_to_HPLOUT_Volume_Control_Register, 0x00);
            break;

        case PGA_R_to_HPLOUT:
            dbg ("PGA_R_to_HPLOUT, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable == Enabled)
                    AUDIO_REG_W(PGA_R_to_HPLOUT_Volume_Control_Register, Value | 0x80);
                else
                    AUDIO_REG_W(PGA_R_to_HPLOUT_Volume_Control_Register, 0x00);
            break;

        case PGA_L_to_HPROUT:
            dbg ("PGA_L_to_HPROUT, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable == Enabled)
                    AUDIO_REG_W(PGA_L_to_HPROUT_Volume_Control_Register, Value | 0x80);
                else
                    AUDIO_REG_W(PGA_L_to_HPROUT_Volume_Control_Register, 0x00);
            break;

        case PGA_R_to_HPROUT:
            dbg ("PGA_R_to_HPROUT, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable == Enabled)
                    AUDIO_REG_W(PGA_R_to_HPROUT_Volume_Control_Register, Value | 0x80);
                else
                    AUDIO_REG_W(PGA_R_to_HPROUT_Volume_Control_Register, 0x00);
            break;

        case PGA_L_to_HPLCOM:
            dbg ("PGA_L_to_HPLCOM, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable == Enabled)
                    AUDIO_REG_W(PGA_L_to_HPLCOM_Volume_Control_Register, Value | 0x80);
                else
                    AUDIO_REG_W(PGA_L_to_HPLCOM_Volume_Control_Register, 0x00);
            break;

        case PGA_R_to_HPLCOM:
            dbg ("PGA_R_to_HPLCOM, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable == Enabled)
                    AUDIO_REG_W(PGA_R_to_HPLCOM_Volume_Control_Register, Value | 0x80);
                else
                    AUDIO_REG_W(PGA_R_to_HPLCOM_Volume_Control_Register, 0x00);
            break;

        case PGA_L_to_HPRCOM:
            dbg ("PGA_L_to_HPRCOM, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable == Enabled)
                    AUDIO_REG_W(PGA_L_to_HPRCOM_Volume_Control_Register, Value | 0x80);
                else
                    AUDIO_REG_W(PGA_L_to_HPRCOM_Volume_Control_Register, 0x00);
            break;

        case PGA_R_to_HPRCOM:
            dbg ("PGA_R_to_HPRCOM, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable == Enabled)
                    AUDIO_REG_W(PGA_R_to_HPRCOM_Volume_Control_Register, Value | 0x80);
                else
                    AUDIO_REG_W(PGA_R_to_HPRCOM_Volume_Control_Register, 0x00);
            break;

        case LINE2L_to_HPLOUT:
            dbg ("LINE2L_to_HPLOUT, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable == Enabled)
                    AUDIO_REG_W(LINE2L_to_HPLOUT_Volume_Control_Register, Value | 0x80);
                else
                    AUDIO_REG_W(LINE2L_to_HPLOUT_Volume_Control_Register, 0x00);
            break;

        case LINE2R_to_HPLOUT:
            dbg ("LINE2R_to_HPLOUT, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable == Enabled)
                    AUDIO_REG_W(LINE2R_to_HPLOUT_Volume_Control_Register, Value | 0x80);
                else
                    AUDIO_REG_W(LINE2R_to_HPLOUT_Volume_Control_Register, 0x00);
            break;

        case LINE2L_to_HPROUT:
            dbg ("LINE2L_to_HPROUT, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable == Enabled)
                    AUDIO_REG_W(LINE2L_to_HPROUT_Volume_Control_Register, Value | 0x80);
                else
                    AUDIO_REG_W(LINE2L_to_HPROUT_Volume_Control_Register, 0x00);
            break;

        case LINE2R_to_HPROUT:
            dbg ("LINE2R_to_HPROUT, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable == Enabled)
                    AUDIO_REG_W(LINE2R_to_HPROUT_Volume_Control_Register, Value | 0x80);
                else
                    AUDIO_REG_W(LINE2R_to_HPROUT_Volume_Control_Register, 0x00);
            break;

        case LINE2L_to_HPRCOM:
            dbg ("LINE2L_to_HPRCOM, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable == Enabled)
                    AUDIO_REG_W(LINE2L_to_HPRCOM_Volume_Control_Register, Value | 0x80);
                else
                    AUDIO_REG_W(LINE2L_to_HPRCOM_Volume_Control_Register, 0x00);
            break;

        case LINE2R_to_HPRCOM:
            dbg ("LINE2R_to_HPRCOM, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable == Enabled)
                    AUDIO_REG_W(LINE2R_to_HPRCOM_Volume_Control_Register, Value | 0x80);
                else
                    AUDIO_REG_W(LINE2R_to_HPRCOM_Volume_Control_Register, 0x00);
            break;

        case LINE2L_to_HPLCOM:
            dbg ("LINE2L_to_HPLCOM, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable == Enabled)
                    AUDIO_REG_W(LINE2L_to_HPLCOM_Volume_Control_Register, Value | 0x80);
                else
                    AUDIO_REG_W(LINE2L_to_HPLCOM_Volume_Control_Register, 0x00);
            break;

        case LINE2R_to_HPLCOM:
            dbg ("LINE2R_to_HPLCOM, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable == Enabled)
                    AUDIO_REG_W(LINE2R_to_HPLCOM_Volume_Control_Register, Value | 0x80);
                else
                    AUDIO_REG_W(LINE2R_to_HPLCOM_Volume_Control_Register, 0x00);
            break;

        case LINE2L_to_LEFT_LOPM:
            dbg ("LINE2L_to_LEFT_LOPM, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable)
                    AUDIO_REG_W(LINE2L_to_LEFT_LOPM_Volume_Control_Register, Value | 0x80);
                else
                    AUDIO_REG_W(LINE2L_to_LEFT_LOPM_Volume_Control_Register, 0x00);
            break;

        case LINE2R_to_LEFT_LOPM:
            dbg ("LINE2R_to_LEFT_LOPM, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable == Enabled)
                    AUDIO_REG_W(LINE2R_to_LEFT_LOPM_Volume_Control_Register, Value | 0x80);
                else
                    AUDIO_REG_W(LINE2R_to_LEFT_LOPM_Volume_Control_Register, 0x00);
            break;

        case LINE2L_to_RIGHT_LOPM:
            dbg ("LINE2L_to_RIGHT_LOPM, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable == Enabled)
                    AUDIO_REG_W(LINE2L_to_RIGHT_LOPM_Volume_Control_Register, Value | 0x80);
                else
                    AUDIO_REG_W(LINE2L_to_RIGHT_LOPM_Volume_Control_Register, 0x00);
            break;

        case LINE2R_to_RIGHT_LOPM:
            dbg ("LINE2R_to_RIGHT_LOPM, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable == Enabled)
                    AUDIO_REG_W(LINE2R_to_RIGHT_LOPM_Volume_Control_Register, Value | 0x80);
                else
                    AUDIO_REG_W(LINE2R_to_RIGHT_LOPM_Volume_Control_Register, 0x00);
            break;

        case PGA_L_to_LEFT_LOPM:
            dbg ("PGA_L_to_LEFT_LOPM, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable == Enabled)
                    AUDIO_REG_W(PGA_L_to_LEFT_LOPM_Volume_Control_Register, Value | 0x80);
                else
                    AUDIO_REG_W(PGA_L_to_LEFT_LOPM_Volume_Control_Register, 0x00);
            break;

        case PGA_R_to_LEFT_LOPM:
            dbg ("PGA_R_to_LEFT_LOPM, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable == Enabled)
                    AUDIO_REG_W(PGA_R_to_LEFT_LOPM_Volume_Control_Register, Value | 0x80);
                else
                    AUDIO_REG_W(PGA_R_to_LEFT_LOPM_Volume_Control_Register, 0x00);
            break;

        case PGA_L_to_RIGHT_LOPM:
            dbg ("PGA_L_to_RIGHT_LOPM, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable == Enabled)
                    AUDIO_REG_W(PGA_L_to_RIGHT_LOPM_Volume_Control_Register, Value | 0x80);
                else
                    AUDIO_REG_W(PGA_L_to_RIGHT_LOPM_Volume_Control_Register, 0x00);
            break;

        case PGA_R_to_RIGHT_LOPM:
            dbg ("PGA_R_to_RIGHT_LOPM, Val %d, EN=%d\n", Value,!(Enable%Enabled));
            if (Enable == Enabled)
                    AUDIO_REG_W(PGA_R_to_RIGHT_LOPM_Volume_Control_Register, Value | 0x80);
                else
                    AUDIO_REG_W(PGA_R_to_RIGHT_LOPM_Volume_Control_Register, 0x00);
            break;
        }
    }

    uint16_t AUDIO_REG_W (uint8_t RegAddr, uint8_t RegVal)
    {
        return I2C_WRITE8B_REG(I2C_Audio_Channel,Audio_Chip_Address,RegAddr,RegVal);
    }



    audio.h

    #include "stm32f10x.h"

    void AUDIO_Reset (void);
    void AUDIO_Init (void);


    void AUDIO_Set_Path(uint8_t AudioPath,uint8_t Enable, uint8_t Value);
    uint16_t AUDIO_REG_W (uint8_t RegAddr, uint8_t RegVal);
    void AUDIO_Set_FMRADIO (uint8_t Enable);
    void AUDIO_Set_GSM (uint8_t Enable);

    #define I2C_Audio_Channel                                        I2C1
    //Control registers for TLV320aic32
    #define Audio_Chip_Address                                        0x30
    #define Page_Select_Register                                    0
    #define Software_Reset_Register                                    1
    #define Codec_Sample_Rate_Select_Register                        2
    #define PLL_Programming_Register_A                                3
    #define PLL_Programming_Register_B                                4
    #define PLL_Programming_Register_C                                5
    #define PLL_Programming_Register_D                                6
    #define Codec_Datapath_Setup_Register                            7
    #define Audio_Serial_Data_Interface_Control_Register_A            8
    #define Audio_Serial_Data_Interface_Control_Register_B            9
    #define Audio_Serial_Data_Interface_Control_Register_C            10
    #define Audio_Codec_Overflow_Flag_Register                        11
    #define Audio_Codec_Digital_Filter_Control_Register                12
    #define Headset_Configuration_Register                            14
    #define Left_ADC_PGA_Gain_Control_Register                        15
    #define Right_ADC_PGA_Gain_Control_Register                        16
    #define MIC3LR_to_Left_ADC_Control_Register                        17
    #define MIC3LR_to_Right_ADC_Control_Register                     18
    #define LINE1L_to_Left_ADC_Control_Register                        19
    #define LINE2L_to_Left_ADC_Control_Register                        20
    #define LINE1R_to_Left_ADC_Control_Register                        21
    #define LINE1R_to_Right_ADC_Control_Register                    22
    #define LINE2R_to_Right_ADC_Control_Register                    23
    #define LINE1L_to_Right_ADC_Control_Register                    24
    #define MICBIAS_Control_Register                                25
    #define Left_AGC_Control_Register_A                                26
    #define Left_AGC_Control_Register_B                                27
    #define Left_AGC_Control_Register_C                                28
    #define Right_AGC_Control_Register_A                            29
    #define Right_AGC_Control_Register_B                            30
    #define Right_AGC_Control_Register_C                            31
    #define Left_AGC_Gain_Register                                    32
    #define Right_AGC_Gain_Register                                    33
    #define Left_AGC_Noise_Gate_Debounce_Register                    34
    #define Right_AGC_Noise_Gate_Debounce_Register                    35
    #define ADC_Flag_Register                                        36
    #define DAC_Power_and_Output_Driver_Control_Register            37
    #define High_Power_Output_Driver_Control_Register                38
    #define High_Power_Output_Stage_Control_Register                40
    #define DAC_Output_Switching_Control_Register                    41
    #define Output_Driver_Pop_Reduction_Register                    42
    #define Left_DAC_Digital_Volume_Control_Register                43
    #define Right_DAC_Digital_Volume_Control_Register                44
    #define LINE2L_to_HPLOUT_Volume_Control_Register                45
    #define PGA_L_to_HPLOUT_Volume_Control_Register                    46
    #define DAC_L1_to_HPLOUT_Volume_Control_Register                47
    #define LINE2R_to_HPLOUT_Volume_Control_Register                48
    #define PGA_R_to_HPLOUT_Volume_Control_Register                    49
    #define DAC_R1_to_HPLOUT_Volume_Control_Register                50
    #define HPLOUT_Output_Level_Control_Register                    51
    #define LINE2L_to_HPLCOM_Volume_Control_Register                52
    #define PGA_L_to_HPLCOM_Volume_Control_Register                    53
    #define DAC_L1_to_HPLCOM_Volume_Control_Register                54
    #define LINE2R_to_HPLCOM_Volume_Control_Register                55
    #define PGA_R_to_HPLCOM_Volume_Control_Register                    56
    #define DAC_R1_to_HPLCOM_Volume_Control_Register                57
    #define HPLCOM_Output_Level_Control_Register                    58
    #define LINE2L_to_HPROUT_Volume_Control_Register                59
    #define PGA_L_to_HPROUT_Volume_Control_Register                    60
    #define DAC_L1_to_HPROUT_Volume_Control_Register                61
    #define LINE2R_to_HPROUT_Volume_Control_Register                62
    #define PGA_R_to_HPROUT_Volume_Control_Register                    63
    #define DAC_R1_to_HPROUT_Volume_Control_Register                64
    #define HPROUT_Output_Level_Control_Register                    65
    #define LINE2L_to_HPRCOM_Volume_Control_Register                66
    #define PGA_L_to_HPRCOM_Volume_Control_Register                    67
    #define DAC_L1_to_HPRCOM_Volume_Control_Register                68
    #define LINE2R_to_HPRCOM_Volume_Control_Register                69
    #define PGA_R_to_HPRCOM_Volume_Control_Register                    70
    #define DAC_R1_to_HPRCOM_Volume_Control_Register                71
    #define HPRCOM_Output_Level_Control_Register                    72
    #define LINE2L_to_LEFT_LOPM_Volume_Control_Register                80
    #define PGA_L_to_LEFT_LOPM_Volume_Control_Register                81
    #define DAC_L1_to_LEFT_LOPM_Volume_Control_Register                82
    #define LINE2R_to_LEFT_LOPM_Volume_Control_Register                83
    #define PGA_R_to_LEFT_LOPM_Volume_Control_Register                84
    #define DAC_R1_to_LEFT_LOPM_Volume_Control_Register                85
    #define LEFT_LOPM_Output_Level_Control_Register                    86
    #define LINE2L_to_RIGHT_LOPM_Volume_Control_Register            87
    #define PGA_L_to_RIGHT_LOPM_Volume_Control_Register                88
    #define DAC_L1_to_RIGHT_LOPM_Volume_Control_Register            89
    #define LINE2R_to_RIGHT_LOPM_Volume_Control_Register            90
    #define PGA_R_to_RIGHT_LOPM_Volume_Control_Register                91
    #define DAC_R1_to_RIGHT_LOPM_Volume_Control_Register            92
    #define RIGHT_LOPM_Output_Level_Control_Register                93
    #define Module_Power_Status_Register                            94
    #define Output_Driver_Short_Circuit_Detection_Status_Register    95
    #define Sticky_Interrupt_Flags_Register                            96
    #define Real_time_Interrupt_Flags_Register                         97
    #define Additional_Clock_Control_Register                          101
    #define Clock_Generation_Control_Register                        102




    //Definicje Opcji kanałowania sygnałów w kodeku

    #define Disabled                    0x00
    #define Enabled                        0xFF


    #define    LINE1L_to_Left_ADC            0x01
    #define    LINE1L_to_Right_ADC            0x02
    #define    LINE1R_to_Left_ADC            0x03
    #define    LINE1R_to_Right_ADC            0x04

    #define    LINE2L_to_Left_ADC            0x05
    #define    LINE2R_to_Right_ADC            0x06

    #define    MIC3LR_to_Left_ADC            0x07
    #define    MIC3LR_to_Right_ADC            0x08

    #define    PGA_L_to_HPLOUT                0x09
    #define    PGA_R_to_HPLOUT                0x0A
    #define    PGA_L_to_HPROUT                0x0B
    #define    PGA_R_to_HPROUT                0x0C

    #define    PGA_L_to_HPLCOM                0x0D
    #define    PGA_R_to_HPLCOM                0x0E
    #define    PGA_L_to_HPRCOM                0x0F
    #define    PGA_R_to_HPRCOM                0x10

    #define    LINE2L_to_HPLOUT            0x11
    #define    LINE2R_to_HPLOUT            0x12
    #define    LINE2L_to_HPROUT            0x13
    #define    LINE2R_to_HPROUT            0x14

    #define    LINE2L_to_HPRCOM            0x15
    #define    LINE2R_to_HPRCOM            0x16
    #define    LINE2L_to_HPLCOM            0x17
    #define    LINE2R_to_HPLCOM            0x18

    #define    LINE2L_to_LEFT_LOPM            0x19
    #define    LINE2R_to_LEFT_LOPM            0x1A
    #define    LINE2L_to_RIGHT_LOPM        0x1B
    #define    LINE2R_to_RIGHT_LOPM        0x1C

    #define    PGA_L_to_LEFT_LOPM            0x1D
    #define    PGA_R_to_LEFT_LOPM            0x1E
    #define    PGA_L_to_RIGHT_LOPM            0x1F
    #define    PGA_R_to_RIGHT_LOPM            0x20