path: root/sound/soc/omap/abe/abe_gain.c

/*

  This file is provided under a dual BSD/GPLv2 license.  When using or
  redistributing this file, you may do so under either license.

  GPL LICENSE SUMMARY

  Copyright(c) 2010-2011 Texas Instruments Incorporated,
  All rights reserved.

  This program is free software; you can redistribute it and/or modify
  it under the terms of version 2 of the GNU General Public License as
  published by the Free Software Foundation.

  This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  The full GNU General Public License is included in this distribution
  in the file called LICENSE.GPL.

  BSD LICENSE

  Copyright(c) 2010-2011 Texas Instruments Incorporated,
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions
  are met:

    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in
      the documentation and/or other materials provided with the
      distribution.
    * Neither the name of Texas Instruments Incorporated nor the names of
      its contributors may be used to endorse or promote products derived
      from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/err.h>
#include <linux/slab.h>

#include "abe_dbg.h"
#include "abe.h"
#include "abe_gain.h"
#include "abe_mem.h"

/*
 * ABE CONST AREA FOR PARAMETERS TRANSLATION
 */
#define min_mdb (-12000)
#define max_mdb (3000)
#define sizeof_db2lin_table (1 + ((max_mdb - min_mdb)/100))

const u32 abe_db2lin_table[sizeof_db2lin_table] = {
	0x00000000,		/* SMEM coding of -120 dB */
	0x00000000,		/* SMEM coding of -119 dB */
	0x00000000,		/* SMEM coding of -118 dB */
	0x00000000,		/* SMEM coding of -117 dB */
	0x00000000,		/* SMEM coding of -116 dB */
	0x00000000,		/* SMEM coding of -115 dB */
	0x00000000,		/* SMEM coding of -114 dB */
	0x00000000,		/* SMEM coding of -113 dB */
	0x00000000,		/* SMEM coding of -112 dB */
	0x00000000,		/* SMEM coding of -111 dB */
	0x00000000,		/* SMEM coding of -110 dB */
	0x00000000,		/* SMEM coding of -109 dB */
	0x00000001,		/* SMEM coding of -108 dB */
	0x00000001,		/* SMEM coding of -107 dB */
	0x00000001,		/* SMEM coding of -106 dB */
	0x00000001,		/* SMEM coding of -105 dB */
	0x00000001,		/* SMEM coding of -104 dB */
	0x00000001,		/* SMEM coding of -103 dB */
	0x00000002,		/* SMEM coding of -102 dB */
	0x00000002,		/* SMEM coding of -101 dB */
	0x00000002,		/* SMEM coding of -100 dB */
	0x00000002,		/* SMEM coding of -99 dB */
	0x00000003,		/* SMEM coding of -98 dB */
	0x00000003,		/* SMEM coding of -97 dB */
	0x00000004,		/* SMEM coding of -96 dB */
	0x00000004,		/* SMEM coding of -95 dB */
	0x00000005,		/* SMEM coding of -94 dB */
	0x00000005,		/* SMEM coding of -93 dB */
	0x00000006,		/* SMEM coding of -92 dB */
	0x00000007,		/* SMEM coding of -91 dB */
	0x00000008,		/* SMEM coding of -90 dB */
	0x00000009,		/* SMEM coding of -89 dB */
	0x0000000A,		/* SMEM coding of -88 dB */
	0x0000000B,		/* SMEM coding of -87 dB */
	0x0000000D,		/* SMEM coding of -86 dB */
	0x0000000E,		/* SMEM coding of -85 dB */
	0x00000010,		/* SMEM coding of -84 dB */
	0x00000012,		/* SMEM coding of -83 dB */
	0x00000014,		/* SMEM coding of -82 dB */
	0x00000017,		/* SMEM coding of -81 dB */
	0x0000001A,		/* SMEM coding of -80 dB */
	0x0000001D,		/* SMEM coding of -79 dB */
	0x00000021,		/* SMEM coding of -78 dB */
	0x00000025,		/* SMEM coding of -77 dB */
	0x00000029,		/* SMEM coding of -76 dB */
	0x0000002E,		/* SMEM coding of -75 dB */
	0x00000034,		/* SMEM coding of -74 dB */
	0x0000003A,		/* SMEM coding of -73 dB */
	0x00000041,		/* SMEM coding of -72 dB */
	0x00000049,		/* SMEM coding of -71 dB */
	0x00000052,		/* SMEM coding of -70 dB */
	0x0000005D,		/* SMEM coding of -69 dB */
	0x00000068,		/* SMEM coding of -68 dB */
	0x00000075,		/* SMEM coding of -67 dB */
	0x00000083,		/* SMEM coding of -66 dB */
	0x00000093,		/* SMEM coding of -65 dB */
	0x000000A5,		/* SMEM coding of -64 dB */
	0x000000B9,		/* SMEM coding of -63 dB */
	0x000000D0,		/* SMEM coding of -62 dB */
	0x000000E9,		/* SMEM coding of -61 dB */
	0x00000106,		/* SMEM coding of -60 dB */
	0x00000126,		/* SMEM coding of -59 dB */
	0x0000014A,		/* SMEM coding of -58 dB */
	0x00000172,		/* SMEM coding of -57 dB */
	0x0000019F,		/* SMEM coding of -56 dB */
	0x000001D2,		/* SMEM coding of -55 dB */
	0x0000020B,		/* SMEM coding of -54 dB */
	0x0000024A,		/* SMEM coding of -53 dB */
	0x00000292,		/* SMEM coding of -52 dB */
	0x000002E2,		/* SMEM coding of -51 dB */
	0x0000033C,		/* SMEM coding of -50 dB */
	0x000003A2,		/* SMEM coding of -49 dB */
	0x00000413,		/* SMEM coding of -48 dB */
	0x00000492,		/* SMEM coding of -47 dB */
	0x00000521,		/* SMEM coding of -46 dB */
	0x000005C2,		/* SMEM coding of -45 dB */
	0x00000676,		/* SMEM coding of -44 dB */
	0x0000073F,		/* SMEM coding of -43 dB */
	0x00000822,		/* SMEM coding of -42 dB */
	0x00000920,		/* SMEM coding of -41 dB */
	0x00000A3D,		/* SMEM coding of -40 dB */
	0x00000B7D,		/* SMEM coding of -39 dB */
	0x00000CE4,		/* SMEM coding of -38 dB */
	0x00000E76,		/* SMEM coding of -37 dB */
	0x0000103A,		/* SMEM coding of -36 dB */
	0x00001235,		/* SMEM coding of -35 dB */
	0x0000146E,		/* SMEM coding of -34 dB */
	0x000016EC,		/* SMEM coding of -33 dB */
	0x000019B8,		/* SMEM coding of -32 dB */
	0x00001CDC,		/* SMEM coding of -31 dB */
	0x00002061,		/* SMEM coding of -30 dB */
	0x00002455,		/* SMEM coding of -29 dB */
	0x000028C4,		/* SMEM coding of -28 dB */
	0x00002DBD,		/* SMEM coding of -27 dB */
	0x00003352,		/* SMEM coding of -26 dB */
	0x00003995,		/* SMEM coding of -25 dB */
	0x0000409C,		/* SMEM coding of -24 dB */
	0x0000487E,		/* SMEM coding of -23 dB */
	0x00005156,		/* SMEM coding of -22 dB */
	0x00005B43,		/* SMEM coding of -21 dB */
	0x00006666,		/* SMEM coding of -20 dB */
	0x000072E5,		/* SMEM coding of -19 dB */
	0x000080E9,		/* SMEM coding of -18 dB */
	0x000090A4,		/* SMEM coding of -17 dB */
	0x0000A24B,		/* SMEM coding of -16 dB */
	0x0000B618,		/* SMEM coding of -15 dB */
	0x0000CC50,		/* SMEM coding of -14 dB */
	0x0000E53E,		/* SMEM coding of -13 dB */
	0x00010137,		/* SMEM coding of -12 dB */
	0x0001209A,		/* SMEM coding of -11 dB */
	0x000143D1,		/* SMEM coding of -10 dB */
	0x00016B54,		/* SMEM coding of -9 dB */
	0x000197A9,		/* SMEM coding of -8 dB */
	0x0001C967,		/* SMEM coding of -7 dB */
	0x00020137,		/* SMEM coding of -6 dB */
	0x00023FD6,		/* SMEM coding of -5 dB */
	0x00028619,		/* SMEM coding of -4 dB */
	0x0002D4EF,		/* SMEM coding of -3 dB */
	0x00032D64,		/* SMEM coding of -2 dB */
	0x000390A4,		/* SMEM coding of -1 dB */
	0x00040000,		/* SMEM coding of 0 dB */
	0x00047CF2,		/* SMEM coding of 1 dB */
	0x00050923,		/* SMEM coding of 2 dB */
	0x0005A670,		/* SMEM coding of 3 dB */
	0x000656EE,		/* SMEM coding of 4 dB */
	0x00071CF5,		/* SMEM coding of 5 dB */
	0x0007FB26,		/* SMEM coding of 6 dB */
	0x0008F473,		/* SMEM coding of 7 dB */
	0x000A0C2B,		/* SMEM coding of 8 dB */
	0x000B4606,		/* SMEM coding of 9 dB */
	0x000CA62C,		/* SMEM coding of 10 dB */
	0x000E314A,		/* SMEM coding of 11 dB */
	0x000FEC9E,		/* SMEM coding of 12 dB */
	0x0011DE0A,		/* SMEM coding of 13 dB */
	0x00140C28,		/* SMEM coding of 14 dB */
	0x00167E60,		/* SMEM coding of 15 dB */
	0x00193D00,		/* SMEM coding of 16 dB */
	0x001C515D,		/* SMEM coding of 17 dB */
	0x001FC5EB,		/* SMEM coding of 18 dB */
	0x0023A668,		/* SMEM coding of 19 dB */
	0x00280000,		/* SMEM coding of 20 dB */
	0x002CE178,		/* SMEM coding of 21 dB */
	0x00325B65,		/* SMEM coding of 22 dB */
	0x00388062,		/* SMEM coding of 23 dB */
	0x003F654E,		/* SMEM coding of 24 dB */
	0x00472194,		/* SMEM coding of 25 dB */
	0x004FCF7C,		/* SMEM coding of 26 dB */
	0x00598C81,		/* SMEM coding of 27 dB */
	0x006479B7,		/* SMEM coding of 28 dB */
	0x0070BC3D,		/* SMEM coding of 29 dB */
	0x007E7DB9,		/* SMEM coding of 30 dB */
};

const u32 abe_1_alpha_iir[64] = {
	0x040002, 0x040002, 0x040002, 0x040002,	/* 0 */
	0x50E955, 0x48CA65, 0x40E321, 0x72BE78,	/* 1 [ms] */
	0x64BA68, 0x57DF14, 0x4C3D60, 0x41D690,	/* 2 */
	0x38A084, 0x308974, 0x297B00, 0x235C7C,	/* 4 */
	0x1E14B0, 0x198AF0, 0x15A800, 0x125660,	/* 8 */
	0x0F82A0, 0x0D1B5C, 0x0B113C, 0x0956CC,	/* 16 */
	0x07E054, 0x06A3B8, 0x059844, 0x04B680,	/* 32 */
	0x03F80C, 0x035774, 0x02D018, 0x025E0C,	/* 64 */
	0x7F8057, 0x6B482F, 0x5A4297, 0x4BEECB,	/* 128 */
	0x3FE00B, 0x35BAA7, 0x2D3143, 0x2602AF,	/* 256 */
	0x1FF803, 0x1AE2FB, 0x169C9F, 0x13042B,	/* 512 */
	0x0FFE03, 0x0D72E7, 0x0B4F4F, 0x0982CB,	/* 1.024 [s] */
	0x07FF83, 0x06B9CF, 0x05A7E7, 0x04C193,	/* 2.048 */
	0x03FFE3, 0x035CFF, 0x02D403, 0x0260D7,	/* 4.096 */
	0x01FFFB, 0x01AE87, 0x016A07, 0x01306F,	/* 8.192 */
	0x00FFFF, 0x00D743, 0x00B503, 0x009837,
};

const u32 abe_alpha_iir[64] = {
	0x000000, 0x000000, 0x000000, 0x000000,	/* 0 */
	0x5E2D58, 0x6E6B3C, 0x7E39C0, 0x46A0C5,	/* 1 [ms] */
	0x4DA2CD, 0x541079, 0x59E151, 0x5F14B9,	/* 2 */
	0x63AFC1, 0x67BB45, 0x6B4281, 0x6E51C1,	/* 4 */
	0x70F5A9, 0x733A89, 0x752C01, 0x76D4D1,	/* 8 */
	0x783EB1, 0x797251, 0x7A7761, 0x7B549D,	/* 16 */
	0x7C0FD5, 0x7CAE25, 0x7D33DD, 0x7DA4C1,	/* 32 */
	0x7E03FD, 0x7E5449, 0x7E97F5, 0x7ED0F9,	/* 64 */
	0x7F0101, 0x7F2971, 0x7F4B7D, 0x7F6825,	/* 128 */
	0x7F8041, 0x7F948D, 0x7FA59D, 0x7FB3FD,	/* 256 */
	0x7FC011, 0x7FCA3D, 0x7FD2C9, 0x7FD9F9,	/* 512 */
	0x7FE005, 0x7FE51D, 0x7FE961, 0x7FECFD,	/* 1.024 [s] */
	0x7FF001, 0x7FF28D, 0x7FF4B1, 0x7FF67D,	/* 2.048 */
	0x7FF801, 0x7FF949, 0x7FFA59, 0x7FFB41,	/* 4.096 */
	0x7FFC01, 0x7FFCA5, 0x7FFD2D, 0x7FFDA1,	/* 8.192 */
	0x7FFE01, 0x7FFE51, 0x7FFE95, 0x7FFED1,
};

/**
 * abe_int_2_float
 * returns a mantissa on 16 bits and the exponent
 * 0x4000.0000 leads to M=0x4000 X=15
 * 0x0004.0000 leads to M=0x4000 X=4
 * 0x0000.0001 leads to M=0x4000 X=-14
 *
 */
void abe_int_2_float16(u32 data, u32 *mantissa, u32 *exp)
{
	u32 i;
	*exp = 0;
	*mantissa = 0;
	for (i = 0; i < 32; i++) {
		if ((1 << i) > data)
			break;
	}
	*exp = i - 15;
	*mantissa = (*exp > 0) ? data >> (*exp) : data << (*exp);
}

/**
 * abe_use_compensated_gain
 * @on_off:
 *
 * Selects the automatic Mixer's gain management
 * on_off = 1 allows the "abe_write_gain" to adjust the overall
 * gains of the mixer to be tuned not to create saturation
 */
int omap_abe_use_compensated_gain(struct omap_abe *abe, int on_off)
{
	abe->compensated_mixer_gain = on_off;
	return 0;
}
EXPORT_SYMBOL(omap_abe_use_compensated_gain);

/**
 * omap_abe_gain_offset
 * returns the offset to firmware data structures
 *
 */
void omap_abe_gain_offset(struct omap_abe *abe, u32 id, u32 *mixer_offset)
{
	switch (id) {
	default:
	case GAINS_DMIC1:
		*mixer_offset = dmic1_gains_offset;
		break;
	case GAINS_DMIC2:
		*mixer_offset = dmic2_gains_offset;
		break;
	case GAINS_DMIC3:
		*mixer_offset = dmic3_gains_offset;
		break;
	case GAINS_AMIC:
		*mixer_offset = amic_gains_offset;
		break;
	case GAINS_DL1:
		*mixer_offset = dl1_gains_offset;
		break;
	case GAINS_DL2:
		*mixer_offset = dl2_gains_offset;
		break;
	case GAINS_SPLIT:
		*mixer_offset = splitters_gains_offset;
		break;
	case MIXDL1:
		*mixer_offset = mixer_dl1_offset;
		break;
	case MIXDL2:
		*mixer_offset = mixer_dl2_offset;
		break;
	case MIXECHO:
		*mixer_offset = mixer_echo_offset;
		break;
	case MIXSDT:
		*mixer_offset = mixer_sdt_offset;
		break;
	case MIXVXREC:
		*mixer_offset = mixer_vxrec_offset;
		break;
	case MIXAUDUL:
		*mixer_offset = mixer_audul_offset;
		break;
	case GAINS_BTUL:
		*mixer_offset = btul_gains_offset;
		break;
	}
}

/**
 * oamp_abe_write_equalizer
 * @abe: Pointer on abe handle
 * @id: name of the equalizer
 * @param : equalizer coefficients
 *
 * Load the coefficients in CMEM.
 */
int omap_abe_write_equalizer(struct omap_abe *abe,
			     u32 id, struct omap_abe_equ *param)
{
	u32 eq_offset, length, *src, eq_mem, eq_mem_len;
	_log(ABE_ID_WRITE_EQUALIZER, id, 0, 0);
	switch (id) {
	default:
	case EQ1:
		eq_offset = OMAP_ABE_C_DL1_COEFS_ADDR;
		eq_mem = OMAP_ABE_S_DL1_M_EQ_DATA_ADDR;
		eq_mem_len = OMAP_ABE_S_DL1_M_EQ_DATA_SIZE;
		break;
	case EQ2L:
		eq_offset = OMAP_ABE_C_DL2_L_COEFS_ADDR;
		eq_mem = OMAP_ABE_S_DL2_M_LR_EQ_DATA_ADDR;
		eq_mem_len = OMAP_ABE_S_DL2_M_LR_EQ_DATA_SIZE;
		break;
	case EQ2R:
		eq_offset = OMAP_ABE_C_DL2_R_COEFS_ADDR;
		eq_mem = OMAP_ABE_S_DL2_M_LR_EQ_DATA_ADDR;
		eq_mem_len = OMAP_ABE_S_DL2_M_LR_EQ_DATA_SIZE;
		break;
	case EQSDT:
		eq_offset = OMAP_ABE_C_SDT_COEFS_ADDR;
		eq_mem = OMAP_ABE_S_SDT_F_DATA_ADDR;
		eq_mem_len = OMAP_ABE_S_SDT_F_DATA_SIZE;
		break;
	case EQAMIC:
		eq_offset = OMAP_ABE_C_96_48_AMIC_COEFS_ADDR;
		eq_mem = OMAP_ABE_S_AMIC_96_48_DATA_ADDR;
		eq_mem_len = OMAP_ABE_S_AMIC_96_48_DATA_SIZE;
		break;
	case EQDMIC:
		eq_offset = OMAP_ABE_C_96_48_DMIC_COEFS_ADDR;
		eq_mem = OMAP_ABE_S_DMIC0_96_48_DATA_ADDR;
		eq_mem_len = OMAP_ABE_S_DMIC0_96_48_DATA_SIZE;
		/* three DMIC are clear at the same time DMIC0 DMIC1 DMIC2 */
		eq_mem_len *= 3;
		break;
	}
	/* reset SMEM buffers before the coefficients are loaded */
	omap_abe_reset_mem(abe, OMAP_ABE_SMEM, eq_mem, eq_mem_len);

	length = param->equ_length;
	src = (u32 *) ((param->coef).type1);
	/* translate in bytes */
	length <<= 2;
	omap_abe_mem_write(abe,	OMAP_ABE_CMEM, eq_offset, src, length);

	/* reset SMEM buffers after the coefficients are loaded */
	omap_abe_reset_mem(abe, OMAP_ABE_SMEM, eq_mem, eq_mem_len);
	return 0;
}
EXPORT_SYMBOL(omap_abe_write_equalizer);

/**
 * omap_abe_disable_gain
 * @abe: Pointer on abe handle
 * Parameters:
 *	mixer id
 *	sub-port id
 *
 */
int omap_abe_disable_gain(struct omap_abe *abe, u32 id, u32 p)
{
	u32 mixer_offset, f_g, ramp;
	omap_abe_gain_offset(abe, id, &mixer_offset);
	/* save the input parameters for mute/unmute */
	ramp = abe->desired_ramp_delay_ms[mixer_offset + p];
	f_g = GAIN_MUTE;
	if (!(abe->muted_gains_indicator[mixer_offset + p] &
	      OMAP_ABE_GAIN_DISABLED)) {
		/* Check if we are in mute */
		if (!(abe->muted_gains_indicator[mixer_offset + p] &
		      OMAP_ABE_GAIN_MUTED)) {
			abe->muted_gains_decibel[mixer_offset + p] =
				abe->desired_gains_decibel[mixer_offset + p];
			/* mute the gain */
			omap_abe_write_gain(abe, id, f_g, ramp, p);
		}
		abe->muted_gains_indicator[mixer_offset + p] |=
			OMAP_ABE_GAIN_DISABLED;
	}
	return 0;
}
EXPORT_SYMBOL(omap_abe_disable_gain);

/**
 * omap_abe_enable_gain
 * Parameters:
 *	mixer id
 *	sub-port id
 *
 */
int omap_abe_enable_gain(struct omap_abe *abe, u32 id, u32 p)
{
	u32 mixer_offset, f_g, ramp;
	omap_abe_gain_offset(abe, id, &mixer_offset);
	if ((abe->muted_gains_indicator[mixer_offset + p] &
	     OMAP_ABE_GAIN_DISABLED)) {
		/* restore the input parameters for mute/unmute */
		f_g = abe->muted_gains_decibel[mixer_offset + p];
		ramp = abe->desired_ramp_delay_ms[mixer_offset + p];
		abe->muted_gains_indicator[mixer_offset + p] &=
			~OMAP_ABE_GAIN_DISABLED;
		/* unmute the gain */
		omap_abe_write_gain(abe, id, f_g, ramp, p);
	}
	return 0;
}
EXPORT_SYMBOL(omap_abe_enable_gain);
/**
 * omap_abe_mute_gain
 * Parameters:
 *	mixer id
 *	sub-port id
 *
 */
int omap_abe_mute_gain(struct omap_abe *abe, u32 id, u32 p)
{
	u32 mixer_offset, f_g, ramp;
	omap_abe_gain_offset(abe, id, &mixer_offset);
	/* save the input parameters for mute/unmute */
	ramp = abe->desired_ramp_delay_ms[mixer_offset + p];
	f_g = GAIN_MUTE;
	if (!abe->muted_gains_indicator[mixer_offset + p]) {
		abe->muted_gains_decibel[mixer_offset + p] =
			abe->desired_gains_decibel[mixer_offset + p];
		/* mute the gain */
		omap_abe_write_gain(abe, id, f_g, ramp, p);
	}
	abe->muted_gains_indicator[mixer_offset + p] |= OMAP_ABE_GAIN_MUTED;
	return 0;
}
EXPORT_SYMBOL(omap_abe_mute_gain);
/**
 * omap_abe_unmute_gain
 * Parameters:
 *	mixer id
 *	sub-port id
 *
 */
int omap_abe_unmute_gain(struct omap_abe *abe, u32 id, u32 p)
{
	u32 mixer_offset, f_g, ramp;
	omap_abe_gain_offset(abe, id, &mixer_offset);
	if ((abe->muted_gains_indicator[mixer_offset + p] &
	    OMAP_ABE_GAIN_MUTED)) {
		/* restore the input parameters for mute/unmute */
		f_g = abe->muted_gains_decibel[mixer_offset + p];
		ramp = abe->desired_ramp_delay_ms[mixer_offset + p];
		abe->muted_gains_indicator[mixer_offset + p] &=
			~OMAP_ABE_GAIN_MUTED;
		/* unmute the gain */
		omap_abe_write_gain(abe, id, f_g, ramp, p);
	}
	return 0;
}
EXPORT_SYMBOL(omap_abe_unmute_gain);

/**
 * omap_abe_write_gain
 * @id: gain name or mixer name
 * @f_g: list of input gains of the mixer
 * @ramp: gain ramp speed factor
 * @p: list of ports corresponding to the above gains
 *
 * Loads the gain coefficients to FW memory. This API can be called when
 * the corresponding MIXER is not activated. After reloading the firmware
 * the default coefficients corresponds to "all input and output mixer's gain
 * in mute state". A mixer is disabled with a network reconfiguration
 * corresponding to an OPP value.
 */
int omap_abe_write_gain(struct omap_abe *abe,
			u32 id, s32 f_g, u32 ramp, u32 p)
{
	u32 lin_g, sum_g, mixer_target, mixer_offset, i, mean_gain, mean_exp;
	u32 new_gain_linear[4];
	s32 gain_index;
	u32 alpha, beta;
	u32 ramp_index;

	_log(ABE_ID_WRITE_GAIN, id, f_g, p);
	gain_index = ((f_g - min_mdb) / 100);
	gain_index = maximum(gain_index, 0);
	gain_index = minimum(gain_index, sizeof_db2lin_table);
	lin_g = abe_db2lin_table[gain_index];
	omap_abe_gain_offset(abe, id, &mixer_offset);
	/* save the input parameters for mute/unmute */
	abe->desired_gains_linear[mixer_offset + p] = lin_g;
	abe->desired_gains_decibel[mixer_offset + p] = f_g;
	abe->desired_ramp_delay_ms[mixer_offset + p] = ramp;
	/* SMEM address in bytes */
	mixer_target = OMAP_ABE_S_GTARGET1_ADDR;
	mixer_target += (mixer_offset<<2);
	mixer_target += (p<<2);

	if (abe->compensated_mixer_gain) {
		switch (id) {
		case MIXDL1:
		case MIXDL2:
		case MIXVXREC:
		case MIXAUDUL:
			/* compute the sum of the gain of the mixer */
			for (sum_g = i = 0; i < 4; i++)
				sum_g += abe->desired_gains_linear[mixer_offset +
								  i];
			/* lets avoid a division by 0 */
			if (sum_g == 0)
				break;
			/* if the sum is OK with less than 1, then
			   do not weight the gains */
			if (sum_g < 0x00040000) {	/* REMOVE HARD CONST */
				/* recompute all gains from original
				   desired values */
				sum_g = 0x00040000;
			}
			/* translate it in Q16 format for the later division */
			abe_int_2_float16(sum_g, &mean_gain, &mean_exp);
			mean_exp = 10 - mean_exp;
			for (i = 0; i < 4; i++) {
				/* new gain = desired gain divided by sum of gains */
				new_gain_linear[i] =
					(abe->desired_gains_linear
					 [mixer_offset + i]
					 << 8) / mean_gain;
				new_gain_linear[i] = (mean_exp > 0) ?
					new_gain_linear[i] << mean_exp :
					new_gain_linear[i] >> mean_exp;
			}
			/* load the whole adpated S_G_Target SMEM MIXER table */
			omap_abe_mem_write(abe, OMAP_ABE_SMEM,
				       mixer_target - (p << 2),
				       new_gain_linear, (4 * sizeof(lin_g)));
			break;
		default:
			/* load the S_G_Target SMEM table */
			omap_abe_mem_write(abe, OMAP_ABE_SMEM,
				       mixer_target,
				       (u32 *) &lin_g, sizeof(lin_g));
			break;
		}
	} else {
		if (!abe->muted_gains_indicator[mixer_offset + p])
			/* load the S_G_Target SMEM table */
			omap_abe_mem_write(abe, OMAP_ABE_SMEM,
				       mixer_target, (u32 *) &lin_g,
				       sizeof(lin_g));
		else
			/* update muted gain with new value */
			abe->muted_gains_decibel[mixer_offset + p] = f_g;
	}
	ramp = maximum(minimum(RAMP_MAXLENGTH, ramp), RAMP_MINLENGTH);
	/* ramp data should be interpolated in the table instead */
	ramp_index = 3;
	if ((RAMP_2MS <= ramp) && (ramp < RAMP_5MS))
		ramp_index = 8;
	if ((RAMP_5MS <= ramp) && (ramp < RAMP_50MS))
		ramp_index = 24;
	if ((RAMP_50MS <= ramp) && (ramp < RAMP_500MS))
		ramp_index = 36;
	if (ramp > RAMP_500MS)
		ramp_index = 48;
	beta = abe_alpha_iir[ramp_index];
	alpha = abe_1_alpha_iir[ramp_index];
	/* CMEM bytes address */
	mixer_target = OMAP_ABE_C_1_ALPHA_ADDR;
	/* a pair of gains is updated once in the firmware */
	mixer_target += ((p + mixer_offset) >> 1) << 2;
	/* load the ramp delay data */
	omap_abe_mem_write(abe, OMAP_ABE_CMEM, mixer_target,
		       (u32 *) &alpha, sizeof(alpha));
	/* CMEM bytes address */
	mixer_target = OMAP_ABE_C_ALPHA_ADDR;
	/* a pair of gains is updated once in the firmware */
	mixer_target += ((p + mixer_offset) >> 1) << 2;
	omap_abe_mem_write(abe, OMAP_ABE_CMEM, mixer_target,
		       (u32 *) &beta, sizeof(beta));
	return 0;
}
EXPORT_SYMBOL(omap_abe_write_gain);
/**
 * omap_abe_write_mixer
 * @id: name of the mixer
 * @param: input gains and delay ramp of the mixer
 * @p: port corresponding to the above gains
 *
 * Load the gain coefficients in FW memory. This API can be called when
 * the corresponding MIXER is not activated. After reloading the firmware
 * the default coefficients corresponds to "all input and output mixer's
 * gain in mute state". A mixer is disabled with a network reconfiguration
 * corresponding to an OPP value.
 */
int omap_abe_write_mixer(struct omap_abe *abe,
				u32 id, s32 f_g, u32 f_ramp, u32 p)
{
	_log(ABE_ID_WRITE_MIXER, id, f_ramp, p);
	omap_abe_write_gain(abe, id, f_g, f_ramp, p);
	return 0;
}
EXPORT_SYMBOL(omap_abe_write_mixer);

/**
 * omap_abe_read_gain
 * @id: name of the mixer
 * @param: list of input gains of the mixer
 * @p: list of port corresponding to the above gains
 *
 */
int omap_abe_read_gain(struct omap_abe *abe,
				u32 id, u32 *f_g, u32 p)
{
	u32 mixer_target, mixer_offset, i;
	_log(ABE_ID_READ_GAIN, id, (u32) f_g, p);
	omap_abe_gain_offset(abe, id, &mixer_offset);
	/* SMEM bytes address */
	mixer_target = OMAP_ABE_S_GTARGET1_ADDR;
	mixer_target += (mixer_offset<<2);
	mixer_target += (p<<2);
	if (!abe->muted_gains_indicator[mixer_offset + p]) {
		/* load the S_G_Target SMEM table */
		omap_abe_mem_read(abe, OMAP_ABE_SMEM, mixer_target,
			       (u32 *) f_g, sizeof(*f_g));
		for (i = 0; i < sizeof_db2lin_table; i++) {
				if (abe_db2lin_table[i] == *f_g)
				goto found;
		}
		*f_g = 0;
		return -1;
	      found:
		*f_g = (i * 100) + min_mdb;
	} else {
		/* update muted gain with new value */
		*f_g = abe->muted_gains_decibel[mixer_offset + p];
	}
	return 0;
}
EXPORT_SYMBOL(omap_abe_read_gain);

/**
 * abe_read_mixer
 * @id: name of the mixer
 * @param: gains of the mixer
 * @p: port corresponding to the above gains
 *
 * Load the gain coefficients in FW memory. This API can be called when
 * the corresponding MIXER is not activated. After reloading the firmware
 * the default coefficients corresponds to "all input and output mixer's
 * gain in mute state". A mixer is disabled with a network reconfiguration
 * corresponding to an OPP value.
 */
int omap_abe_read_mixer(struct omap_abe *abe,
				u32 id, u32 *f_g, u32 p)
{
	_log(ABE_ID_READ_MIXER, id, 0, p);
	omap_abe_read_gain(abe, id, f_g, p);
	return 0;
}
EXPORT_SYMBOL(omap_abe_read_mixer);

/**
 * abe_reset_gain_mixer
 * @id: name of the mixer
 * @p: list of port corresponding to the above gains
 *
 * restart the working gain value of the mixers when a port is enabled
 */
void omap_abe_reset_gain_mixer(struct omap_abe *abe, u32 id, u32 p)
{
	u32 lin_g, mixer_target, mixer_offset;
	switch (id) {
	default:
	case GAINS_DMIC1:
		mixer_offset = dmic1_gains_offset;
		break;
	case GAINS_DMIC2:
		mixer_offset = dmic2_gains_offset;
		break;
	case GAINS_DMIC3:
		mixer_offset = dmic3_gains_offset;
		break;
	case GAINS_AMIC:
		mixer_offset = amic_gains_offset;
		break;
	case GAINS_DL1:
		mixer_offset = dl1_gains_offset;
		break;
	case GAINS_DL2:
		mixer_offset = dl2_gains_offset;
		break;
	case GAINS_SPLIT:
		mixer_offset = splitters_gains_offset;
		break;
	case MIXDL1:
		mixer_offset = mixer_dl1_offset;
		break;
	case MIXDL2:
		mixer_offset = mixer_dl2_offset;
		break;
	case MIXECHO:
		mixer_offset = mixer_echo_offset;
		break;
	case MIXSDT:
		mixer_offset = mixer_sdt_offset;
		break;
	case MIXVXREC:
		mixer_offset = mixer_vxrec_offset;
		break;
	case MIXAUDUL:
		mixer_offset = mixer_audul_offset;
		break;
	case GAINS_BTUL:
		mixer_offset = btul_gains_offset;
		break;
	}
	/* SMEM bytes address for the CURRENT gain values */
	mixer_target = OMAP_ABE_S_GCURRENT_ADDR;
	mixer_target += (mixer_offset<<2);
	mixer_target += (p<<2);
	lin_g = 0;
	/* load the S_G_Target SMEM table */
	omap_abe_mem_write(abe, OMAP_ABE_SMEM, mixer_target,
		       (u32 *) &lin_g, sizeof(lin_g));
}