/*

  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_aess.h"
#include "abe_gain.h"
#include "abe_mem.h"
#include "abe_port.h"
#include "abe_seq.h"

#include "abe_taskid.h"


#define ABE_TASK_ID(ID) (OMAP_ABE_D_TASKSLIST_ADDR + sizeof(ABE_STask)*(ID))
void omap_abe_build_scheduler_table(struct omap_abe *abe);
void omap_abe_reset_all_ports(struct omap_abe *abe);

const u32 abe_firmware_array[ABE_FIRMWARE_MAX_SIZE] = {
#include "abe_firmware.c"
};


/*
 * initialize the default values for call-backs to subroutines
 * - FIFO IRQ call-backs for sequenced tasks
 * - FIFO IRQ call-backs for audio player/recorders (ping-pong protocols)
 * - Remote debugger interface
 * - Error monitoring
 * - Activity Tracing
 */

/**
 * abe_init_mem - Allocate Kernel space memory map for ABE
 *
 * Memory map of ABE memory space for PMEM/DMEM/SMEM/DMEM
 */
void abe_init_mem(void __iomem **_io_base)
{
	int i;

	abe = kzalloc(sizeof(struct omap_abe), GFP_KERNEL);
	if (abe == NULL)
		printk(KERN_ERR "ABE Allocation ERROR ");

	for (i = 0; i < 5; i++)
		abe->io_base[i] = _io_base[i];

	mutex_init(&abe->mutex);

}
EXPORT_SYMBOL(abe_init_mem);

/**
 * abe_load_fw_param - Load ABE Firmware memories
 * @PMEM: Pointer of Program memory data
 * @PMEM_SIZE: Size of PMEM data
 * @CMEM: Pointer of Coeffients memory data
 * @CMEM_SIZE: Size of CMEM data
 * @SMEM: Pointer of Sample memory data
 * @SMEM_SIZE: Size of SMEM data
 * @DMEM: Pointer of Data memory data
 * @DMEM_SIZE: Size of DMEM data
 *
 */
int abe_load_fw_param(u32 *ABE_FW)
{
	u32 pmem_size, dmem_size, smem_size, cmem_size;
	u32 *pmem_ptr, *dmem_ptr, *smem_ptr, *cmem_ptr, *fw_ptr;
	/* fast counter timer set at 4096 * 250us = 1,024s */
	u32 data = 0x10001000;

	_log(ABE_ID_LOAD_FW_param, 0, 0, 0);
#define ABE_FW_OFFSET 5
	fw_ptr = ABE_FW;
	abe->firmware_version_number = *fw_ptr++;
	pmem_size = *fw_ptr++;
	cmem_size = *fw_ptr++;
	dmem_size = *fw_ptr++;
	smem_size = *fw_ptr++;
	pmem_ptr = fw_ptr;
	cmem_ptr = pmem_ptr + (pmem_size >> 2);
	dmem_ptr = cmem_ptr + (cmem_size >> 2);
	smem_ptr = dmem_ptr + (dmem_size >> 2);
	/* do not load PMEM */
	if (abe->warm_boot) {
		/* Stop the event Generator */
		omap_abe_stop_event_generator(abe);

		/* Now we are sure the firmware is stalled */
		omap_abe_mem_write(abe, OMAP_ABE_CMEM, 0, cmem_ptr,
			       cmem_size);
		omap_abe_mem_write(abe, OMAP_ABE_SMEM, 0, smem_ptr,
			       smem_size);
		omap_abe_mem_write(abe, OMAP_ABE_DMEM, 0, dmem_ptr,
			       dmem_size);

		/* Restore the event Generator status */
		omap_abe_start_event_generator(abe);
	} else {
		omap_abe_mem_write(abe, OMAP_ABE_PMEM, 0, pmem_ptr,
			       pmem_size);
		omap_abe_mem_write(abe, OMAP_ABE_CMEM, 0, cmem_ptr,
			       cmem_size);
		omap_abe_mem_write(abe, OMAP_ABE_SMEM, 0, smem_ptr,
			       smem_size);
		omap_abe_mem_write(abe, OMAP_ABE_DMEM, 0, dmem_ptr,
			       dmem_size);
	}
	omap_abe_mem_write(abe, OMAP_ABE_DMEM,
		       OMAP_ABE_D_FASTCOUNTER_ADDR,
		       &data,
		       OMAP_ABE_D_FASTCOUNTER_SIZE);

	/* Update Saturation threshold */
	data = 0x00700000;
	omap_abe_mem_write(abe, OMAP_ABE_SMEM,
		       OMAP_ABE_S_SATURATION_EQ_ADDR,
		       &data, 4);
	data = 0x00900000;
	omap_abe_mem_write(abe, OMAP_ABE_SMEM,
		       OMAP_ABE_S_SATURATION_EQ_ADDR + 4,
		       &data, 4);

	abe->warm_boot = 1;
	return 0;
}
EXPORT_SYMBOL(abe_load_fw_param);

/**
 * omap_abe_load_fw - Load ABE Firmware and initialize memories
 * @abe: Pointer on abe handle
 *
 */
int omap_abe_load_fw(struct omap_abe *abe, u32 *firmware)
{
	_log(ABE_ID_LOAD_FW, 0, 0, 0);
	abe_load_fw_param(firmware);
	omap_abe_reset_all_ports(abe);
	omap_abe_build_scheduler_table(abe);
	omap_abe_reset_all_sequence(abe);
	omap_abe_select_main_port(OMAP_ABE_PDM_DL_PORT);
	return 0;
}
EXPORT_SYMBOL(omap_abe_load_fw);

/**
 * abe_reload_fw - Reload ABE Firmware after OFF mode
 */
int omap_abe_reload_fw(struct omap_abe *abe, u32 *firmware)
{
	abe->warm_boot = 0;
	abe_load_fw_param(firmware);
	omap_abe_build_scheduler_table(abe);
	omap_abe_dbg_reset(&abe->dbg);
	/* IRQ circular read pointer in DMEM */
	abe->irq_dbg_read_ptr = 0;
	/* Restore Gains not managed by the drivers */
	omap_abe_write_gain(abe, GAINS_SPLIT, GAIN_0dB,
			    RAMP_2MS, GAIN_LEFT_OFFSET);
	omap_abe_write_gain(abe, GAINS_SPLIT, GAIN_0dB,
			    RAMP_2MS, GAIN_RIGHT_OFFSET);

	return 0;
}
EXPORT_SYMBOL(omap_abe_reload_fw);

/**
 * omap_abe_get_default_fw
 *
 * Get default ABE firmware
 */
u32 *omap_abe_get_default_fw(struct omap_abe *abe)
{
	return (u32 *)abe_firmware_array;
}

/**
 * abe_build_scheduler_table
 *
 */
void omap_abe_build_scheduler_table(struct omap_abe *abe)
{
	u16 i, n;
	u8 *ptr;
	u16 aUplinkMuxing[NBROUTE_UL];

	/* LOAD OF THE TASKS' MULTIFRAME */
	/* WARNING ON THE LOCATION OF IO_MM_DL WHICH IS PATCHED
	   IN "abe_init_io_tasks" */
	for (ptr = (u8 *) &(abe->MultiFrame[0][0]), i = 0;
	     i < sizeof(abe->MultiFrame); i++)
		*ptr++ = 0;

	abe->MultiFrame[0][0] = 0/*ABE_TASK_ID(C_ABE_FW_TASK_IO_PDM_UL)*/;
	abe->MultiFrame[0][3] = ABE_TASK_ID(C_ABE_FW_TASK_ASRC_VX_DL_8);

	abe->MultiFrame[1][3] = ABE_TASK_ID(C_ABE_FW_TASK_VX_DL_8_48_FIR);
	abe->MultiFrame[1][6] = ABE_TASK_ID(C_ABE_FW_TASK_DL2Mixer);
	abe->MultiFrame[1][7] = 0; /*ABE_TASK_ID(C_ABE_FW_TASK_IO_VIB_DL)*/

	abe->MultiFrame[2][0] = ABE_TASK_ID(C_ABE_FW_TASK_DL1Mixer);
	abe->MultiFrame[2][1] = ABE_TASK_ID(C_ABE_FW_TASK_SDTMixer);
	abe->MultiFrame[2][5] = 0; /*ABE_TASK_ID(C_ABE_FW_TASK_IO_DMIC)*/

	abe->MultiFrame[3][0] = ABE_TASK_ID(C_ABE_FW_TASK_DL1_GAIN);
	abe->MultiFrame[3][6] = ABE_TASK_ID(C_ABE_FW_TASK_DL2_GAIN);
	abe->MultiFrame[3][7] = ABE_TASK_ID(C_ABE_FW_TASK_DL2_EQ);

	abe->MultiFrame[4][0] = ABE_TASK_ID(C_ABE_FW_TASK_DL1_EQ);
	abe->MultiFrame[4][2] = ABE_TASK_ID(C_ABE_FW_TASK_VXRECMixer);
	abe->MultiFrame[4][3] = ABE_TASK_ID(C_ABE_FW_TASK_VXREC_SPLIT);
	abe->MultiFrame[4][6] = ABE_TASK_ID(C_ABE_FW_TASK_VIBRA1);
	abe->MultiFrame[4][7] = ABE_TASK_ID(C_ABE_FW_TASK_VIBRA2);

	abe->MultiFrame[5][0] = 0;
	abe->MultiFrame[5][1] = ABE_TASK_ID(C_ABE_FW_TASK_EARP_48_96_LP);
	abe->MultiFrame[5][2] = 0; /*ABE_TASK_ID(C_ABE_FW_TASK_IO_PDM_UL)*/
	abe->MultiFrame[5][7] = ABE_TASK_ID(C_ABE_FW_TASK_VIBRA_SPLIT);

	abe->MultiFrame[6][0] = ABE_TASK_ID(C_ABE_FW_TASK_EARP_48_96_LP);
	abe->MultiFrame[6][4] = ABE_TASK_ID(C_ABE_FW_TASK_EchoMixer);
	abe->MultiFrame[6][5] = ABE_TASK_ID(C_ABE_FW_TASK_BT_UL_SPLIT);

	abe->MultiFrame[7][0] = 0; /*ABE_TASK_ID(C_ABE_FW_TASK_IO_PDM_DL)*/
	abe->MultiFrame[7][3] = ABE_TASK_ID(C_ABE_FW_TASK_DBG_SYNC);
	abe->MultiFrame[7][5] = ABE_TASK_ID(C_ABE_FW_TASK_ECHO_REF_SPLIT);

	abe->MultiFrame[8][2] = ABE_TASK_ID(C_ABE_FW_TASK_DMIC1_96_48_LP);
	abe->MultiFrame[8][4] = ABE_TASK_ID(C_ABE_FW_TASK_DMIC1_SPLIT);

	abe->MultiFrame[9][2] = ABE_TASK_ID(C_ABE_FW_TASK_DMIC2_96_48_LP);
	abe->MultiFrame[9][4] = ABE_TASK_ID(C_ABE_FW_TASK_DMIC2_SPLIT);
	abe->MultiFrame[9][6] = 0;
	abe->MultiFrame[9][7] = ABE_TASK_ID(C_ABE_FW_TASK_IHF_48_96_LP);

	abe->MultiFrame[10][2] = ABE_TASK_ID(C_ABE_FW_TASK_DMIC3_96_48_LP);
	abe->MultiFrame[10][4] = ABE_TASK_ID(C_ABE_FW_TASK_DMIC3_SPLIT);
	abe->MultiFrame[10][7] = ABE_TASK_ID(C_ABE_FW_TASK_IHF_48_96_LP);

	abe->MultiFrame[11][2] = ABE_TASK_ID(C_ABE_FW_TASK_AMIC_96_48_LP);
	abe->MultiFrame[11][4] = ABE_TASK_ID(C_ABE_FW_TASK_AMIC_SPLIT);
	abe->MultiFrame[11][7] = ABE_TASK_ID(C_ABE_FW_TASK_VIBRA_PACK);

	abe->MultiFrame[12][3] = ABE_TASK_ID(C_ABE_FW_TASK_VX_UL_ROUTING);
	abe->MultiFrame[12][4] = ABE_TASK_ID(C_ABE_FW_TASK_ULMixer);
	abe->MultiFrame[12][5] = ABE_TASK_ID(C_ABE_FW_TASK_VX_UL_48_8);

	abe->MultiFrame[13][2] = ABE_TASK_ID(C_ABE_FW_TASK_MM_UL2_ROUTING);
	abe->MultiFrame[13][3] = ABE_TASK_ID(C_ABE_FW_TASK_SideTone);
	abe->MultiFrame[13][5] = 0; /*ABE_TASK_ID(C_ABE_FW_TASK_IO_BT_VX_DL)*/

	abe->MultiFrame[14][3] = 0; /*ABE_TASK_ID(C_ABE_FW_TASK_IO_DMIC)*/
	abe->MultiFrame[14][4] = ABE_TASK_ID(C_ABE_FW_TASK_BT_DL_48_8_FIR_FW_COMPAT);

	abe->MultiFrame[15][0] = 0; /*ABE_TASK_ID(C_ABE_FW_TASK_IO_MM_EXT_OUT)*/
	abe->MultiFrame[15][3] = 0; /*ABE_TASK_ID(C_ABE_FW_TASK_IO_BT_VX_UL)*/
	abe->MultiFrame[15][6] = 0; /*ABE_TASK_ID(C_ABE_FW_TASK_ASRC_BT_UL_8)*/

	abe->MultiFrame[16][2] = ABE_TASK_ID(C_ABE_FW_TASK_ASRC_VX_UL_8);
	abe->MultiFrame[16][3] = 0; /*ABE_TASK_ID(C_ABE_FW_TASK_IO_VX_UL)*/

	abe->MultiFrame[17][2] = ABE_TASK_ID(C_ABE_FW_TASK_BT_UL_8_48);
	abe->MultiFrame[17][3] = 0; /*ABE_TASK_ID(C_ABE_FW_TASK_IO_MM_UL2)*/

	abe->MultiFrame[18][0] = 0; /*ABE_TASK_ID(C_ABE_FW_TASK_IO_MM_DL)*/
	abe->MultiFrame[18][6] = 0; /*ABE_TASK_ID(C_ABE_FW_TASK_ASRC_BT_DL_8)*/

	abe->MultiFrame[19][0] = 0; /*ABE_TASK_ID(C_ABE_FW_TASK_IO_PDM_DL)*/

	/*         MM_UL is moved to OPP 100% */
	abe->MultiFrame[19][6] = 0; /*ABE_TASK_ID(C_ABE_FW_TASK_IO_MM_UL)*/

	abe->MultiFrame[20][0] = 0; /*ABE_TASK_ID(C_ABE_FW_TASK_IO_TONES_DL)*/
	abe->MultiFrame[20][6] = 0; /*ABE_TASK_ID(C_ABE_FW_TASK_ASRC_MM_EXT_IN)*/

	abe->MultiFrame[21][1] = ABE_TASK_ID(C_ABE_FW_TASK_DEBUGTRACE_VX_ASRCs);
	abe->MultiFrame[21][2] = ABE_TASK_ID(C_ABE_FW_TASK_CHECK_IIR_RIGHT_8K);
	abe->MultiFrame[21][3] = 0/*ABE_TASK_ID(C_ABE_FW_TASK_IO_MM_EXT_IN)*/;
	/* MUST STAY ON SLOT 22 */
	abe->MultiFrame[22][0] = ABE_TASK_ID(C_ABE_FW_TASK_DEBUG_IRQFIFO);
	abe->MultiFrame[22][1] = ABE_TASK_ID(C_ABE_FW_TASK_INIT_FW_MEMORY);
	abe->MultiFrame[22][2] = ABE_TASK_ID(C_ABE_FW_TASK_IO_VX_DL);
	/* MM_EXT_IN_SPLIT task must be after IO_MM_EXT_IN and before
	   ASRC_MM_EXT_IN in order to manage OPP50 <-> transitions */
	abe->MultiFrame[22][4] = ABE_TASK_ID(C_ABE_FW_TASK_MM_EXT_IN_SPLIT);

	abe->MultiFrame[23][0] = ABE_TASK_ID(C_ABE_FW_TASK_GAIN_UPDATE);
	abe->MultiFrame[23][2] = ABE_TASK_ID(C_ABE_FW_TASK_CHECK_IIR_LEFT_8K);

	omap_abe_mem_write(abe, OMAP_ABE_DMEM, OMAP_ABE_D_MULTIFRAME_ADDR,
		       (u32 *) abe->MultiFrame, sizeof(abe->MultiFrame));
	/* reset the uplink router */
	n = (OMAP_ABE_D_AUPLINKROUTING_SIZE) >> 1;
	for (i = 0; i < n; i++)
		aUplinkMuxing[i] = ZERO_labelID;

	omap_abe_mem_write(abe, OMAP_ABE_DMEM, OMAP_ABE_D_AUPLINKROUTING_ADDR,
		       (u32 *) aUplinkMuxing, sizeof(aUplinkMuxing));
}

/**
 * omap_abe_reset_port
 * @id: ABE port ID
 *
 * stop the port activity and reload default parameters on the associated
 * processing features.
 * Clears the internal AE buffers.
 */
int omap_abe_reset_port(u32 id)
{
	_log(ABE_ID_RESET_PORT, id, 0, 0);
	abe_port[id] = ((abe_port_t *) abe_port_init)[id];
	return 0;
}

/**
 * abe_reset_all_ports
 *
 * load default configuration for all features
 */
void omap_abe_reset_all_ports(struct omap_abe *abe)
{
	u16 i;
	for (i = 0; i < LAST_PORT_ID; i++)
		omap_abe_reset_port(i);
	/* mixers' configuration */
	omap_abe_write_mixer(abe, MIXDL1, MUTE_GAIN,
			     RAMP_2MS, MIX_DL1_INPUT_MM_DL);
	omap_abe_write_mixer(abe, MIXDL1, MUTE_GAIN,
			     RAMP_2MS, MIX_DL1_INPUT_MM_UL2);
	omap_abe_write_mixer(abe, MIXDL1, MUTE_GAIN,
			     RAMP_2MS, MIX_DL1_INPUT_VX_DL);
	omap_abe_write_mixer(abe, MIXDL1, MUTE_GAIN,
			     RAMP_2MS, MIX_DL1_INPUT_TONES);
	omap_abe_write_mixer(abe, MIXDL2, MUTE_GAIN,
			     RAMP_2MS, MIX_DL2_INPUT_TONES);
	omap_abe_write_mixer(abe, MIXDL2, MUTE_GAIN,
			     RAMP_2MS, MIX_DL2_INPUT_VX_DL);
	omap_abe_write_mixer(abe, MIXDL2, MUTE_GAIN,
			     RAMP_2MS, MIX_DL2_INPUT_MM_DL);
	omap_abe_write_mixer(abe, MIXDL2, MUTE_GAIN,
			     RAMP_2MS, MIX_DL2_INPUT_MM_UL2);
	omap_abe_write_mixer(abe, MIXSDT, MUTE_GAIN,
			     RAMP_2MS, MIX_SDT_INPUT_UP_MIXER);
	omap_abe_write_mixer(abe, MIXSDT, GAIN_0dB,
			     RAMP_2MS, MIX_SDT_INPUT_DL1_MIXER);
	omap_abe_write_mixer(abe, MIXECHO, MUTE_GAIN,
			     RAMP_2MS, MIX_ECHO_DL1);
	omap_abe_write_mixer(abe, MIXECHO, MUTE_GAIN,
			     RAMP_2MS, MIX_ECHO_DL2);
	omap_abe_write_mixer(abe, MIXAUDUL, MUTE_GAIN,
			     RAMP_2MS, MIX_AUDUL_INPUT_MM_DL);
	omap_abe_write_mixer(abe, MIXAUDUL, MUTE_GAIN,
			     RAMP_2MS, MIX_AUDUL_INPUT_TONES);
	omap_abe_write_mixer(abe, MIXAUDUL, GAIN_0dB,
			     RAMP_2MS, MIX_AUDUL_INPUT_UPLINK);
	omap_abe_write_mixer(abe, MIXAUDUL, MUTE_GAIN,
			     RAMP_2MS, MIX_AUDUL_INPUT_VX_DL);
	omap_abe_write_mixer(abe, MIXVXREC, MUTE_GAIN,
			     RAMP_2MS, MIX_VXREC_INPUT_TONES);
	omap_abe_write_mixer(abe, MIXVXREC, MUTE_GAIN,
			     RAMP_2MS, MIX_VXREC_INPUT_VX_DL);
	omap_abe_write_mixer(abe, MIXVXREC, MUTE_GAIN,
			     RAMP_2MS, MIX_VXREC_INPUT_MM_DL);
	omap_abe_write_mixer(abe, MIXVXREC, MUTE_GAIN,
			     RAMP_2MS, MIX_VXREC_INPUT_VX_UL);
	omap_abe_write_gain(abe, GAINS_DMIC1, GAIN_0dB,
			    RAMP_2MS, GAIN_LEFT_OFFSET);
	omap_abe_write_gain(abe, GAINS_DMIC1, GAIN_0dB,
			    RAMP_2MS, GAIN_RIGHT_OFFSET);
	omap_abe_write_gain(abe, GAINS_DMIC2, GAIN_0dB,
			    RAMP_2MS, GAIN_LEFT_OFFSET);
	omap_abe_write_gain(abe, GAINS_DMIC2, GAIN_0dB,
			    RAMP_2MS, GAIN_RIGHT_OFFSET);
	omap_abe_write_gain(abe, GAINS_DMIC3, GAIN_0dB,
			    RAMP_2MS, GAIN_LEFT_OFFSET);
	omap_abe_write_gain(abe, GAINS_DMIC3, GAIN_0dB,
			    RAMP_2MS, GAIN_RIGHT_OFFSET);
	omap_abe_write_gain(abe, GAINS_AMIC, GAIN_0dB,
			    RAMP_2MS, GAIN_LEFT_OFFSET);
	omap_abe_write_gain(abe, GAINS_AMIC, GAIN_0dB,
			    RAMP_2MS, GAIN_RIGHT_OFFSET);
	omap_abe_write_gain(abe, GAINS_SPLIT, GAIN_0dB,
			    RAMP_2MS, GAIN_LEFT_OFFSET);
	omap_abe_write_gain(abe, GAINS_SPLIT, GAIN_0dB,
			    RAMP_2MS, GAIN_RIGHT_OFFSET);
	omap_abe_write_gain(abe, GAINS_DL1, GAIN_0dB,
			    RAMP_2MS, GAIN_LEFT_OFFSET);
	omap_abe_write_gain(abe, GAINS_DL1, GAIN_0dB,
			    RAMP_2MS, GAIN_RIGHT_OFFSET);
	omap_abe_write_gain(abe, GAINS_DL2, GAIN_0dB,
			    RAMP_2MS, GAIN_LEFT_OFFSET);
	omap_abe_write_gain(abe, GAINS_DL2, GAIN_0dB,
			    RAMP_2MS, GAIN_RIGHT_OFFSET);
	omap_abe_write_gain(abe, GAINS_BTUL, GAIN_0dB,
			    RAMP_2MS, GAIN_LEFT_OFFSET);
	omap_abe_write_gain(abe, GAINS_BTUL, GAIN_0dB,
			    RAMP_2MS, GAIN_RIGHT_OFFSET);
}