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,
00032     uint8_t int_level, int32_t max_write_num, int32_t max_read_num) 
00033        : audio_cs_(cs), mI2c_(sda, scl), mI2s_(sck, ws, tx, rx) {
00034     audio_cs_ = 0;
00035     mAddr     = 0x34;
00036     audio_path_control = 0;
00037 
00038     // I2S Mode
00039     ssif_cfg.enabled                = true;
00040     ssif_cfg.int_level              = int_level;
00041     ssif_cfg.slave_mode             = true;
00042     ssif_cfg.sample_freq            = 44100u;
00043     ssif_cfg.clk_select             = SSIF_CFG_CKS_AUDIO_X1;
00044     ssif_cfg.multi_ch               = SSIF_CFG_MULTI_CH_1;
00045     ssif_cfg.data_word              = SSIF_CFG_DATA_WORD_16;
00046     ssif_cfg.system_word            = SSIF_CFG_SYSTEM_WORD_32;
00047     ssif_cfg.bclk_pol               = SSIF_CFG_FALLING;
00048     ssif_cfg.ws_pol                 = SSIF_CFG_WS_LOW;
00049     ssif_cfg.padding_pol            = SSIF_CFG_PADDING_LOW;
00050     ssif_cfg.serial_alignment       = SSIF_CFG_DATA_FIRST;
00051     ssif_cfg.parallel_alignment     = SSIF_CFG_LEFT;
00052     ssif_cfg.ws_delay               = SSIF_CFG_DELAY;
00053     ssif_cfg.noise_cancel           = SSIF_CFG_ENABLE_NOISE_CANCEL;
00054     ssif_cfg.tdm_mode               = SSIF_CFG_DISABLE_TDM;
00055     ssif_cfg.romdec_direct.mode     = SSIF_CFG_DISABLE_ROMDEC_DIRECT;
00056     ssif_cfg.romdec_direct.p_cbfunc = NULL;
00057     mI2s_.init(&ssif_cfg, max_write_num, max_read_num);
00058 
00059     mI2c_.frequency(150000);
00060     reset();                       // TLV resets
00061     power(0x80);                   // Power off
00062     format(16);                    // 16Bit I2S protocol format
00063     frequency(44100);              // Default sample frequency is 44.1kHz
00064     bypass(false);                 // Do not bypass device
00065     mic(false);                    // Input select for ADC is line
00066     mute(false);                   // Not muted
00067     activateDigitalInterface_();   // The digital part of the chip is active
00068 }
00069 
00070 // Public Functions
00071 bool TLV320_RBSP::inputVolume(float leftVolumeIn, float rightVolumeIn) {
00072     // check values are in range
00073     if ((leftVolumeIn  < 0.0) || (leftVolumeIn  > 1.0)
00074      || (rightVolumeIn < 0.0) || (rightVolumeIn > 1.0)) {
00075         return false;
00076     }
00077 
00078     // convert float to encoded char
00079     char left  = (char)(31 * leftVolumeIn);
00080     char right = (char)(31 * rightVolumeIn);
00081 
00082     // Left Channel
00083     cmd[0] = LEFT_LINE_INPUT_CHANNEL_VOLUME_CONTROL;
00084     cmd[1] = left | (0 << 7);    // set volume, mute off
00085     mI2c_.write(mAddr, cmd, 2);
00086 
00087     // Right Channel
00088     cmd[0] = RIGHT_LINE_INPUT_CHANNEL_VOLUME_CONTROL;
00089     cmd[1] = right | (0 << 7);   // set volume, mute off
00090     mI2c_.write(mAddr, cmd, 2);
00091 
00092     return true;
00093 }
00094 
00095 bool TLV320_RBSP::outputVolume(float leftVolumeOut, float rightVolumeOut) {
00096     // check values are in range
00097     if ((leftVolumeOut  < 0.0) || (leftVolumeOut  > 1.0)
00098      || (rightVolumeOut < 0.0) || (rightVolumeOut > 1.0)) {
00099         return false;
00100     }
00101 
00102     // convert float to encoded char
00103     char left  = (char)((79 * leftVolumeOut) + 0x30);
00104     char right = (char)((79 * rightVolumeOut) + 0x30);
00105 
00106     // Left Channel
00107     cmd[0] = LEFT_CHANNEL_HEADPHONE_VOLUME_CONTROL;
00108     cmd[1] = left | (1 << 7);    // set volume, Zero-cross detect
00109     mI2c_.write(mAddr, cmd, 2);
00110 
00111     // Right Channel
00112     cmd[0] = RIGHT_CHANNEL_HEADPHONE_VOLUME_CONTROL;
00113     cmd[1] = right | (1 << 7);   // set volume, Zero-cross detect
00114     mI2c_.write(mAddr, cmd, 2);
00115 
00116     return true;
00117 }
00118 
00119 void TLV320_RBSP::bypass(bool bypassVar) {
00120     cmd[0] = ANALOG_AUDIO_PATH_CONTROL;
00121     if (bypassVar != false) {
00122         audio_path_control |= (1 << 3);       // bypass enabled
00123         audio_path_control &= ~(1 << 4);      // DAC disable
00124     } else {
00125         audio_path_control &= ~(1 << 3);      // bypass disable
00126         audio_path_control |= (1 << 4);       // DAC enabled
00127     }
00128     cmd[1] = audio_path_control;
00129     mI2c_.write(mAddr, cmd, 2);
00130 }
00131 
00132 void TLV320_RBSP::mic(bool micVar) {
00133     cmd[0] = ANALOG_AUDIO_PATH_CONTROL;
00134     if (micVar != false) {
00135         audio_path_control |= (1 << 2);        // INSEL Microphone
00136     } else {
00137         audio_path_control &= ~(1 << 2);       // INSEL Line
00138     }
00139     cmd[1] = audio_path_control;
00140     mI2c_.write(mAddr, cmd, 2);
00141 }
00142 
00143 void TLV320_RBSP::micVolume(bool mute, bool boost) {
00144     cmd[0] = ANALOG_AUDIO_PATH_CONTROL;
00145     if (mute != false) {
00146         audio_path_control |= (1 << 1);        // MICM Muted
00147     } else {
00148         audio_path_control &= ~(1 << 1);       // MICM Normal
00149     }
00150     if (boost != false) {
00151         audio_path_control |= (1 << 0);        // MICB 20dB
00152     } else {
00153         audio_path_control &= ~(1 << 0);       // MICB 0dB
00154     }
00155     cmd[1] = audio_path_control;
00156     mI2c_.write(mAddr, cmd, 2);
00157 }
00158 
00159 void TLV320_RBSP::mute(bool softMute) {
00160     cmd[0] = DIGITAL_AUDIO_PATH_CONTROL;
00161     if (softMute != false) {
00162         cmd[1] = 0x08;           // set instruction to mute
00163     } else {
00164         cmd[1] = 0x00;           // set instruction to NOT mute
00165     }
00166     mI2c_.write(mAddr, cmd, 2);
00167 }
00168 
00169 void TLV320_RBSP::power(int device) {
00170     cmd[0] = POWER_DOWN_CONTROL;
00171     cmd[1] = (char)device;       // set user defined commands
00172     mI2c_.write(mAddr, cmd, 2);
00173 }
00174 
00175 bool TLV320_RBSP::format(char length) {
00176     cmd[0] = DIGITAL_AUDIO_INTERFACE_FORMAT;
00177     cmd[1] = (1 << 6);           // Master
00178     switch (length) {            // input data into instruction byte
00179         case 16:
00180             ssif_cfg.data_word = SSIF_CFG_DATA_WORD_16;
00181             cmd[1] |= 0x02;
00182             break;
00183         case 20:
00184             ssif_cfg.data_word = SSIF_CFG_DATA_WORD_20;
00185             cmd[1] |= 0x06;
00186             break;
00187         case 24:
00188             ssif_cfg.data_word = SSIF_CFG_DATA_WORD_24;
00189             cmd[1] |= 0x0A;
00190             break;
00191         case 32:
00192             ssif_cfg.data_word = SSIF_CFG_DATA_WORD_32;
00193             cmd[1] |= 0x0E;
00194             break;
00195         default:
00196             return false;
00197     }
00198     mI2s_.ConfigChannel(&ssif_cfg);
00199     mI2c_.write(mAddr, cmd, 2);
00200 
00201     return true;
00202 }
00203 
00204 bool TLV320_RBSP::frequency(int hz) {
00205     char control_setting;
00206 
00207 #if defined(MCLK_12MHZ)
00208     switch (hz) {
00209         case 96000:
00210             control_setting = 0x1D;
00211             break;
00212         case 88200:
00213             control_setting = 0x3F;
00214             break;
00215         case 48000:
00216             control_setting = 0x01;
00217             break;
00218         case 44100:
00219             control_setting = 0x23;
00220             break;
00221         case 32000:
00222             control_setting = 0x19;
00223             break;
00224         case 8021:
00225             control_setting = 0x2F;
00226             break;
00227         case 8000:
00228             control_setting = 0x0D;
00229             break;
00230         default:
00231             return false;
00232     }
00233 #elif defined(MCLK_11_2896MHZ)
00234     switch (hz) {
00235         case 88200:
00236             control_setting = 0x3C;
00237             break;
00238         case 44100:
00239             control_setting = 0x20;
00240             break;
00241         case 8021:
00242             control_setting = 0x2C;
00243             break;
00244         default:
00245             return false;
00246     }
00247 #else
00248     #error MCLK error
00249 #endif
00250     cmd[0] = SAMPLE_RATE_CONTROL;
00251     cmd[1] = control_setting;
00252     mI2c_.write(mAddr, cmd, 2);
00253 
00254     return true;
00255 }
00256 
00257 void TLV320_RBSP::reset(void) {
00258     cmd[0] = RESET_REGISTER;
00259     cmd[1] = 0x00;               // Write 000000000 to this register triggers reset
00260     mI2c_.write(mAddr, cmd, 2);
00261 }
00262 
00263 // Private Functions
00264 void TLV320_RBSP::activateDigitalInterface_(void) {
00265     cmd[0] = DIGITAL_INTERFACE_ACTIVATION;
00266     cmd[1] = 0x01;               // Activate
00267     mI2c_.write(mAddr, cmd, 2);
00268 }