TLV320_RBSP.cpp

00001 /*******************************************************************************
00002 * DISCLAIMER
00003 * This software is supplied by Renesas Electronics Corporation and is only
00004 * intended for use with Renesas products. No other uses are authorized. This
00005 * software is owned by Renesas Electronics Corporation and is protected under
00006 * all applicable laws, including copyright laws.
00007 * THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
00008 * THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
00009 * LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
00010 * AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
00011 * TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
00012 * ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
00013 * FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
00014 * ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
00015 * BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
00016 * Renesas reserves the right, without notice, to make changes to this software
00017 * and to discontinue the availability of this software. By using this software,
00018 * you agree to the additional terms and conditions found by accessing the
00019 * following link:
00020 * http://www.renesas.com/disclaimer*
00021 * Copyright (C) 2015 Renesas Electronics Corporation. All rights reserved.
00022 *******************************************************************************/
00023 
00024 #include "mbed.h"
00025 #include "TLV320_RBSP.h"
00026 #include "pinmap.h"
00027 
00028 #define MCLK_12MHZ
00029 #undef  MCLK_11_2896MHZ
00030 
00031 TLV320_RBSP::TLV320_RBSP(PinName cs, PinName sda, PinName scl, PinName sck, PinName ws, PinName tx, PinName rx, uint8_t int_level, int32_t max_write_num, int32_t max_read_num) 
00032        : audio_cs_(cs), mI2c_(sda, scl), mI2s_(sck, ws, tx, rx, int_level, max_write_num, max_read_num) {
00033     audio_cs_ = 0;
00034     mAddr     = 0x34;
00035     audio_path_control = 0;
00036 
00037     // I2S Mode
00038     ssif_cfg.enabled                = true;
00039     ssif_cfg.int_level              = 0x78;
00040     ssif_cfg.slave_mode             = true;
00041     ssif_cfg.sample_freq            = 44100u;
00042     ssif_cfg.clk_select             = SSIF_CFG_CKS_AUDIO_X1;
00043     ssif_cfg.multi_ch               = SSIF_CFG_MULTI_CH_1;
00044     ssif_cfg.data_word              = SSIF_CFG_DATA_WORD_16;
00045     ssif_cfg.system_word            = SSIF_CFG_SYSTEM_WORD_32;
00046     ssif_cfg.bclk_pol               = SSIF_CFG_FALLING;
00047     ssif_cfg.ws_pol                 = SSIF_CFG_WS_LOW;
00048     ssif_cfg.padding_pol            = SSIF_CFG_PADDING_LOW;
00049     ssif_cfg.serial_alignment       = SSIF_CFG_DATA_FIRST;
00050     ssif_cfg.parallel_alignment     = SSIF_CFG_LEFT;
00051     ssif_cfg.ws_delay               = SSIF_CFG_DELAY;
00052     ssif_cfg.noise_cancel           = SSIF_CFG_ENABLE_NOISE_CANCEL;
00053     ssif_cfg.tdm_mode               = SSIF_CFG_DISABLE_TDM;
00054     ssif_cfg.romdec_direct.mode     = SSIF_CFG_DISABLE_ROMDEC_DIRECT;
00055     ssif_cfg.romdec_direct.p_cbfunc = NULL;
00056     mI2s_.ConfigChannel(&ssif_cfg);
00057 
00058     mI2c_.frequency(150000);
00059     reset();                       // TLV resets
00060     power(0x80);                   // Power off
00061     format(16);                    // 16Bit I2S protocol format
00062     frequency(44100);              // Default sample frequency is 44.1kHz
00063     bypass(false);                 // Do not bypass device
00064     mic(false);                    // Input select for ADC is line
00065     mute(false);                   // Not muted
00066     activateDigitalInterface_();   // The digital part of the chip is active
00067 }
00068 
00069 // Public Functions
00070 bool TLV320_RBSP::inputVolume(float leftVolumeIn, float rightVolumeIn) {
00071     // check values are in range
00072     if ((leftVolumeIn  < 0.0) || (leftVolumeIn  > 1.0)
00073      || (rightVolumeIn < 0.0) || (rightVolumeIn > 1.0)) {
00074         return false;
00075     }
00076 
00077     // convert float to encoded char
00078     char left  = (char)(31 * leftVolumeIn);
00079     char right = (char)(31 * rightVolumeIn);
00080 
00081     // Left Channel
00082     cmd[0] = LEFT_LINE_INPUT_CHANNEL_VOLUME_CONTROL;
00083     cmd[1] = left | (0 << 7);    // set volume, mute off
00084     mI2c_.write(mAddr, cmd, 2);
00085 
00086     // Right Channel
00087     cmd[0] = RIGHT_LINE_INPUT_CHANNEL_VOLUME_CONTROL;
00088     cmd[1] = right | (0 << 7);   // set volume, mute off
00089     mI2c_.write(mAddr, cmd, 2);
00090 
00091     return true;
00092 }
00093 
00094 bool TLV320_RBSP::outputVolume(float leftVolumeOut, float rightVolumeOut) {
00095     // check values are in range
00096     if ((leftVolumeOut  < 0.0) || (leftVolumeOut  > 1.0)
00097      || (rightVolumeOut < 0.0) || (rightVolumeOut > 1.0)) {
00098         return false;
00099     }
00100 
00101     // convert float to encoded char
00102     char left  = (char)((79 * leftVolumeOut) + 0x30);
00103     char right = (char)((79 * rightVolumeOut) + 0x30);
00104 
00105     // Left Channel
00106     cmd[0] = LEFT_CHANNEL_HEADPHONE_VOLUME_CONTROL;
00107     cmd[1] = left | (1 << 7);    // set volume, Zero-cross detect
00108     mI2c_.write(mAddr, cmd, 2);
00109 
00110     // Right Channel
00111     cmd[0] = RIGHT_CHANNEL_HEADPHONE_VOLUME_CONTROL;
00112     cmd[1] = right | (1 << 7);   // set volume, Zero-cross detect
00113     mI2c_.write(mAddr, cmd, 2);
00114 
00115     return true;
00116 }
00117 
00118 void TLV320_RBSP::bypass(bool bypassVar) {
00119     cmd[0] = ANALOG_AUDIO_PATH_CONTROL;
00120     if (bypassVar != false) {
00121         audio_path_control |= (1 << 3);       // bypass enabled
00122         audio_path_control &= ~(1 << 4);      // DAC disable
00123     } else {
00124         audio_path_control &= ~(1 << 3);      // bypass disable
00125         audio_path_control |= (1 << 4);       // DAC enabled
00126     }
00127     cmd[1] = audio_path_control;
00128     mI2c_.write(mAddr, cmd, 2);
00129 }
00130 
00131 void TLV320_RBSP::mic(bool micVar) {
00132     cmd[0] = ANALOG_AUDIO_PATH_CONTROL;
00133     if (micVar != false) {
00134         audio_path_control |= (1 << 2);        // INSEL Microphone
00135     } else {
00136         audio_path_control &= ~(1 << 2);       // INSEL Line
00137     }
00138     cmd[1] = audio_path_control;
00139     mI2c_.write(mAddr, cmd, 2);
00140 }
00141 
00142 void TLV320_RBSP::micVolume(bool mute, bool boost) {
00143     cmd[0] = ANALOG_AUDIO_PATH_CONTROL;
00144     if (mute != false) {
00145         audio_path_control |= (1 << 1);        // MICM Muted
00146     } else {
00147         audio_path_control &= ~(1 << 1);       // MICM Normal
00148     }
00149     if (boost != false) {
00150         audio_path_control |= (1 << 0);        // MICB 20dB
00151     } else {
00152         audio_path_control &= ~(1 << 0);       // MICB 0dB
00153     }
00154     cmd[1] = audio_path_control;
00155     mI2c_.write(mAddr, cmd, 2);
00156 }
00157 
00158 void TLV320_RBSP::mute(bool softMute) {
00159     cmd[0] = DIGITAL_AUDIO_PATH_CONTROL;
00160     if (softMute != false) {
00161         cmd[1] = 0x08;           // set instruction to mute
00162     } else {
00163         cmd[1] = 0x00;           // set instruction to NOT mute
00164     }
00165     mI2c_.write(mAddr, cmd, 2);
00166 }
00167 
00168 void TLV320_RBSP::power(int device) {
00169     cmd[0] = POWER_DOWN_CONTROL;
00170     cmd[1] = (char)device;       // set user defined commands
00171     mI2c_.write(mAddr, cmd, 2);
00172 }
00173 
00174 bool TLV320_RBSP::format(char length) {
00175     cmd[0] = DIGITAL_AUDIO_INTERFACE_FORMAT;
00176     cmd[1] = (1 << 6);           // Master
00177     switch (length) {            // input data into instruction byte
00178         case 16:
00179             ssif_cfg.data_word = SSIF_CFG_DATA_WORD_16;
00180             cmd[1] |= 0x02;
00181             break;
00182         case 20:
00183             ssif_cfg.data_word = SSIF_CFG_DATA_WORD_20;
00184             cmd[1] |= 0x06;
00185             break;
00186         case 24:
00187             ssif_cfg.data_word = SSIF_CFG_DATA_WORD_24;
00188             cmd[1] |= 0x0A;
00189             break;
00190         case 32:
00191             ssif_cfg.data_word = SSIF_CFG_DATA_WORD_32;
00192             cmd[1] |= 0x0E;
00193             break;
00194         default:
00195             return false;
00196     }
00197     mI2s_.ConfigChannel(&ssif_cfg);
00198     mI2c_.write(mAddr, cmd, 2);
00199 
00200     return true;
00201 }
00202 
00203 bool TLV320_RBSP::frequency(int hz) {
00204     char control_setting;
00205 
00206 #if defined(MCLK_12MHZ)
00207     switch (hz) {
00208         case 96000:
00209             control_setting = 0x1D;
00210             break;
00211         case 88200:
00212             control_setting = 0x3F;
00213             break;
00214         case 48000:
00215             control_setting = 0x01;
00216             break;
00217         case 44100:
00218             control_setting = 0x23;
00219             break;
00220         case 32000:
00221             control_setting = 0x19;
00222             break;
00223         case 8021:
00224             control_setting = 0x2F;
00225             break;
00226         case 8000:
00227             control_setting = 0x0D;
00228             break;
00229         default:
00230             return false;
00231     }
00232 #elif defined(MCLK_11_2896MHZ)
00233     switch (hz) {
00234         case 88200:
00235             control_setting = 0x3C;
00236             break;
00237         case 44100:
00238             control_setting = 0x20;
00239             break;
00240         case 8021:
00241             control_setting = 0x2C;
00242             break;
00243         default:
00244             return false;
00245     }
00246 #else
00247     #error MCLK error
00248 #endif
00249     cmd[0] = SAMPLE_RATE_CONTROL;
00250     cmd[1] = control_setting;
00251     mI2c_.write(mAddr, cmd, 2);
00252 
00253     return true;
00254 }
00255 
00256 void TLV320_RBSP::reset(void) {
00257     cmd[0] = RESET_REGISTER;
00258     cmd[1] = 0x00;               // Write 000000000 to this register triggers reset
00259     mI2c_.write(mAddr, cmd, 2);
00260 }
00261 
00262 // Private Functions
00263 void TLV320_RBSP::activateDigitalInterface_(void) {
00264     cmd[0] = DIGITAL_INTERFACE_ACTIVATION;
00265     cmd[1] = 0x01;               // Activate
00266     mI2c_.write(mAddr, cmd, 2);
00267 }