drivers/staging/intel_sst/intelmid_msic_control.c

/*
 *  intelmid_vm_control.c - Intel Sound card driver for MID
 *
 *  Copyright (C) 2010 Intel Corp
 *  Authors:	Vinod Koul <vinod.koul@intel.com>
 *
 *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; version 2 of the License.
 *
 *  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.,
 *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 * This file contains the control operations of msic vendors
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/pci.h>
#include <linux/file.h>
#include <linux/delay.h>
#include <sound/control.h>
#include "intel_sst.h"
#include <linux/input.h>
#include "intelmid_snd_control.h"
#include "intelmid.h"

#define AUDIOMUX12  0x24c
#define AUDIOMUX34  0x24d

static int msic_init_card(void)
{
	struct sc_reg_access sc_access[] = {
		/* dmic configuration */
		{0x241, 0x85, 0},
		{0x242, 0x02, 0},
		/* audio paths config */
		{0x24C, 0x10, 0},
		{0x24D, 0x32, 0},
		/* PCM2 interface slots */
		/* preconfigured slots for 0-5 both tx, rx */
		{0x272, 0x10, 0},
		{0x273, 0x32, 0},
		{0x274, 0xFF, 0},
		{0x275, 0x10, 0},
		{0x276, 0x32, 0},
		{0x277, 0x54, 0},
		/*Sinc5 decimator*/
		{0x24E, 0x28, 0},
		/*TI vibra w/a settings*/
		{0x384, 0x80, 0},
		{0x385, 0x80, 0},
		{0x267, 0x00, 0},
		{0x261, 0x00, 0},
		/* pcm port setting */
		{0x278, 0x00, 0},
		{0x27B, 0x01, 0},
		{0x27C, 0x0a, 0},
		/* Set vol HSLRVOLCTRL, IHFVOL */
		{0x259, 0x08, 0},
		{0x25A, 0x08, 0},
		{0x25B, 0x08, 0},
		{0x25C, 0x08, 0},
		/* HSEPRXCTRL  Enable the headset left and right FIR filters  */
		{0x250, 0x30, 0},
		/* HSMIXER */
		{0x256, 0x11, 0},
		/* amic configuration */
		{0x249, 0x01, 0x0},
		{0x24A, 0x01, 0x0},
		/* unmask ocaudio/accdet interrupts */
		{0x1d, 0x00, 0x00},
		{0x1e, 0x00, 0x00},
	};
	snd_msic_ops.card_status = SND_CARD_INIT_DONE;
	sst_sc_reg_access(sc_access, PMIC_WRITE, 28);
	snd_msic_ops.pb_on = 0;
	snd_msic_ops.pbhs_on = 0;
	snd_msic_ops.cap_on = 0;
	snd_msic_ops.input_dev_id = DMIC; /*def dev*/
	snd_msic_ops.output_dev_id = STEREO_HEADPHONE;
	snd_msic_ops.jack_interrupt_status = false;
	pr_debug("msic init complete!!\n");
	return 0;
}
static int msic_line_out_restore(u8 value)
{
	struct sc_reg_access hs_drv_en[] = {
		{0x25d, 0x03, 0x03},
	};
	struct sc_reg_access ep_drv_en[] = {
		{0x25d, 0x40, 0x40},
	};
	struct sc_reg_access ihf_drv_en[] = {
		{0x25d, 0x0c, 0x0c},
	};
	struct sc_reg_access vib1_drv_en[] = {
		{0x25d, 0x10, 0x10},
	};
	struct sc_reg_access vib2_drv_en[] = {
		{0x25d, 0x20, 0x20},
	};
	struct sc_reg_access pmode_enable[] = {
		{0x381, 0x10, 0x10},
	};
	int retval = 0;

	pr_debug("msic_lineout_restore_lineout_dev:%d\n", value);

	switch (value) {
	case HEADSET:
		pr_debug("Selecting Lineout-HEADSET-restore\n");
		if (snd_msic_ops.output_dev_id == STEREO_HEADPHONE)
			retval = sst_sc_reg_access(hs_drv_en,
							PMIC_READ_MODIFY, 1);
		else
			retval = sst_sc_reg_access(ep_drv_en,
							PMIC_READ_MODIFY, 1);
		break;
	case IHF:
		pr_debug("Selecting Lineout-IHF-restore\n");
		retval = sst_sc_reg_access(ihf_drv_en, PMIC_READ_MODIFY, 1);
		if (retval)
			return retval;
		retval = sst_sc_reg_access(pmode_enable, PMIC_READ_MODIFY, 1);
		break;
	case VIBRA1:
		pr_debug("Selecting Lineout-Vibra1-restore\n");
		retval = sst_sc_reg_access(vib1_drv_en, PMIC_READ_MODIFY, 1);
		break;
	case VIBRA2:
		pr_debug("Selecting Lineout-VIBRA2-restore\n");
		retval = sst_sc_reg_access(vib2_drv_en, PMIC_READ_MODIFY, 1);
		break;
	case NONE:
		pr_debug("Selecting Lineout-NONE-restore\n");
		break;
	default:
		return -EINVAL;
	}
	return retval;
}
static int msic_get_lineout_prvstate(void)
{
	struct sc_reg_access hs_ihf_drv[2] = {
		{0x257, 0x0, 0x0},
		{0x25d, 0x0, 0x0},
	};
	struct sc_reg_access vib1drv[2] = {
		{0x264, 0x0, 0x0},
		{0x25D, 0x0, 0x0},
	};
	struct sc_reg_access vib2drv[2] = {
		{0x26A, 0x0, 0x0},
		{0x25D, 0x0, 0x0},
	};
	int retval = 0, drv_en, dac_en, dev_id, mask;
	for (dev_id = 0; dev_id < snd_msic_ops.line_out_names_cnt; dev_id++) {
		switch (dev_id) {
		case HEADSET:
			pr_debug("msic_get_lineout_prvs_state: HEADSET\n");
			sst_sc_reg_access(hs_ihf_drv, PMIC_READ, 2);

			mask = (MASK0|MASK1);
			dac_en = (hs_ihf_drv[0].value) & mask;

			mask = ((MASK0|MASK1)|MASK6);
			drv_en = (hs_ihf_drv[1].value) & mask;

			if (dac_en && (!drv_en)) {
				snd_msic_ops.prev_lineout_dev_id = HEADSET;
				return retval;
			}
			break;
		case IHF:
			pr_debug("msic_get_lineout_prvstate: IHF\n");
			sst_sc_reg_access(hs_ihf_drv, PMIC_READ, 2);

			mask = (MASK2 | MASK3);
			dac_en = (hs_ihf_drv[0].value) & mask;

			mask = (MASK2 | MASK3);
			drv_en = (hs_ihf_drv[1].value) & mask;

			if (dac_en && (!drv_en)) {
				snd_msic_ops.prev_lineout_dev_id = IHF;
				return retval;
			}
			break;
		case VIBRA1:
			pr_debug("msic_get_lineout_prvstate: vibra1\n");
			sst_sc_reg_access(vib1drv, PMIC_READ, 2);

			mask = MASK1;
			dac_en = (vib1drv[0].value) & mask;

			mask = MASK4;
			drv_en = (vib1drv[1].value) & mask;

			if (dac_en && (!drv_en)) {
				snd_msic_ops.prev_lineout_dev_id = VIBRA1;
				return retval;
			}
			break;
		case VIBRA2:
			pr_debug("msic_get_lineout_prvstate: vibra2\n");
			sst_sc_reg_access(vib2drv, PMIC_READ, 2);

			mask = MASK1;
			dac_en = (vib2drv[0].value) & mask;

			mask = MASK5;
			drv_en = ((vib2drv[1].value) & mask);

			if (dac_en && (!drv_en)) {
				snd_msic_ops.prev_lineout_dev_id = VIBRA2;
				return retval;
			}
			break;
		case NONE:
			pr_debug("msic_get_lineout_prvstate: NONE\n");
			snd_msic_ops.prev_lineout_dev_id = NONE;
			return retval;
		default:
			pr_debug("Invalid device id\n");
			snd_msic_ops.prev_lineout_dev_id = NONE;
			return -EINVAL;
		}
	}
	return retval;
}
static int msic_set_selected_lineout_dev(u8 value)
{
	struct sc_reg_access lout_hs[] = {
		{0x25e, 0x33, 0xFF},
		{0x25d, 0x0, 0x43},
	};
	struct sc_reg_access lout_ihf[] = {
		{0x25e, 0x55, 0xff},
		{0x25d, 0x0, 0x0c},
	};
	struct sc_reg_access lout_vibra1[] = {

		{0x25e, 0x61, 0xff},
		{0x25d, 0x0, 0x10},
	};
	struct sc_reg_access lout_vibra2[] = {

		{0x25e, 0x16, 0xff},
		{0x25d, 0x0, 0x20},
	};
	struct sc_reg_access lout_def[] = {
		{0x25e, 0x66, 0x0},
	};
	struct sc_reg_access pmode_disable[] = {
		{0x381, 0x00, 0x10},
	};
	struct sc_reg_access pmode_enable[] = {
		{0x381, 0x10, 0x10},
	};
	int retval = 0;

	pr_debug("msic_set_selected_lineout_dev:%d\n", value);
	msic_get_lineout_prvstate();
	msic_line_out_restore(snd_msic_ops.prev_lineout_dev_id);
	snd_msic_ops.lineout_dev_id = value;

	switch (value) {
	case HEADSET:
		pr_debug("Selecting Lineout-HEADSET\n");
		if (snd_msic_ops.pb_on)
			retval = sst_sc_reg_access(lout_hs,
					PMIC_READ_MODIFY, 2);
			if (retval)
				return retval;
			retval = sst_sc_reg_access(pmode_disable,
					PMIC_READ_MODIFY, 1);
		break;
	case IHF:
		pr_debug("Selecting Lineout-IHF\n");
		if (snd_msic_ops.pb_on)
			retval = sst_sc_reg_access(lout_ihf,
							PMIC_READ_MODIFY, 2);
			if (retval)
				return retval;
			retval = sst_sc_reg_access(pmode_enable,
					PMIC_READ_MODIFY, 1);
		break;
	case VIBRA1:
		pr_debug("Selecting Lineout-Vibra1\n");
		if (snd_msic_ops.pb_on)
			retval = sst_sc_reg_access(lout_vibra1,
							PMIC_READ_MODIFY, 2);
			if (retval)
				return retval;
			retval = sst_sc_reg_access(pmode_disable,
					PMIC_READ_MODIFY, 1);
		break;
	case VIBRA2:
		pr_debug("Selecting Lineout-VIBRA2\n");
		if (snd_msic_ops.pb_on)
			retval = sst_sc_reg_access(lout_vibra2,
							PMIC_READ_MODIFY, 2);
			if (retval)
				return retval;
			retval = sst_sc_reg_access(pmode_disable,
					PMIC_READ_MODIFY, 1);
		break;
	case NONE:
		pr_debug("Selecting Lineout-NONE\n");
			retval = sst_sc_reg_access(lout_def,
							PMIC_WRITE, 1);
			if (retval)
				return retval;
			retval = sst_sc_reg_access(pmode_disable,
					PMIC_READ_MODIFY, 1);
		break;
	default:
		return -EINVAL;
	}
	return retval;
}


static int msic_power_up_pb(unsigned int device)
{
	struct sc_reg_access vaud[] = {
		/* turn on the audio power supplies */
		{0x0DB, 0x07, 0},
	};
	struct sc_reg_access pll[] = {
		/* turn on PLL */
		{0x240, 0x20, 0},
	};
	struct sc_reg_access vhs[] = {
		/*  VHSP */
		{0x0DC, 0x3D, 0},
		/*  VHSN */
		{0x0DD, 0x3F, 0},
	};
	struct sc_reg_access hsdac[] = {
		{0x382, 0x40, 0x40},
		/*  disable driver */
		{0x25D, 0x0, 0x43},
		/* DAC CONFIG ; both HP, LP on */
		{0x257, 0x03, 0x03},
	};
	struct sc_reg_access hs_filter[] = {
		/* HSEPRXCTRL  Enable the headset left and right FIR filters  */
		{0x250, 0x30, 0},
		/* HSMIXER */
		{0x256, 0x11, 0},
	};
	struct sc_reg_access hs_enable[] = {
		/* enable driver */
		{0x25D, 0x3, 0x3},
		{0x26C, 0x0, 0x2},
		/* unmute the headset */
		{ 0x259, 0x80, 0x80},
		{ 0x25A, 0x80, 0x80},
	};
	struct sc_reg_access vihf[] = {
		/*  VIHF ON */
		{0x0C9, 0x27, 0x00},
	};
	struct sc_reg_access ihf_filter[] = {
		/*  disable driver */
		{0x25D, 0x00, 0x0C},
		/*Filer DAC enable*/
		{0x251, 0x03, 0x03},
		{0x257, 0x0C, 0x0C},
	};
	struct sc_reg_access ihf_en[] = {
		/*enable drv*/
		{0x25D, 0x0C, 0x0c},
	};
	struct sc_reg_access ihf_unmute[] = {
		/*unmute headset*/
		{0x25B, 0x80, 0x80},
		{0x25C, 0x80, 0x80},
	};
	struct sc_reg_access epdac[] = {
		/*  disable driver */
		{0x25D, 0x0, 0x43},
		/* DAC CONFIG ; both HP, LP on */
		{0x257, 0x03, 0x03},
	};
	struct sc_reg_access ep_enable[] = {
		/* enable driver */
		{0x25D, 0x40, 0x40},
		/* unmute the headset */
		{ 0x259, 0x80, 0x80},
		{ 0x25A, 0x80, 0x80},
	};
	struct sc_reg_access vib1_en[] = {
		/* enable driver, ADC */
		{0x25D, 0x10, 0x10},
		{0x264, 0x02, 0x82},
	};
	struct sc_reg_access vib2_en[] = {
		/* enable driver, ADC */
		{0x25D, 0x20, 0x20},
		{0x26A, 0x02, 0x82},
	};
	struct sc_reg_access pcm2_en[] = {
		/* enable pcm 2 */
		{0x27C, 0x1, 0x1},
	};
	int retval = 0;

	if (snd_msic_ops.card_status == SND_CARD_UN_INIT) {
		retval = msic_init_card();
		if (retval)
			return retval;
	}

	pr_debug("powering up pb.... Device %d\n", device);
	sst_sc_reg_access(vaud, PMIC_WRITE, 1);
	msleep(1);
	sst_sc_reg_access(pll, PMIC_WRITE, 1);
	msleep(1);
	switch (device) {
	case SND_SST_DEVICE_HEADSET:
		snd_msic_ops.pb_on = 1;
		snd_msic_ops.pbhs_on = 1;
		if (snd_msic_ops.output_dev_id == STEREO_HEADPHONE) {
			sst_sc_reg_access(vhs, PMIC_WRITE, 2);
			sst_sc_reg_access(hsdac, PMIC_READ_MODIFY, 3);
			sst_sc_reg_access(hs_filter, PMIC_WRITE, 2);
			sst_sc_reg_access(hs_enable, PMIC_READ_MODIFY, 4);
		} else {
			sst_sc_reg_access(epdac, PMIC_READ_MODIFY, 2);
			sst_sc_reg_access(hs_filter, PMIC_WRITE, 2);
			sst_sc_reg_access(ep_enable, PMIC_READ_MODIFY, 3);
		}
		if (snd_msic_ops.lineout_dev_id == HEADSET)
			msic_set_selected_lineout_dev(HEADSET);
		break;
	case SND_SST_DEVICE_IHF:
		snd_msic_ops.pb_on = 1;
		sst_sc_reg_access(vihf, PMIC_WRITE, 1);
		sst_sc_reg_access(ihf_filter, PMIC_READ_MODIFY, 3);
		sst_sc_reg_access(ihf_en, PMIC_READ_MODIFY, 1);
		sst_sc_reg_access(ihf_unmute, PMIC_READ_MODIFY, 2);
		if (snd_msic_ops.lineout_dev_id == IHF)
			msic_set_selected_lineout_dev(IHF);
		break;

	case SND_SST_DEVICE_VIBRA:
		snd_msic_ops.pb_on = 1;
		sst_sc_reg_access(vib1_en, PMIC_READ_MODIFY, 2);
		if (snd_msic_ops.lineout_dev_id == VIBRA1)
			msic_set_selected_lineout_dev(VIBRA1);
		break;

	case SND_SST_DEVICE_HAPTIC:
		snd_msic_ops.pb_on = 1;
		sst_sc_reg_access(vib2_en, PMIC_READ_MODIFY, 2);
		if (snd_msic_ops.lineout_dev_id == VIBRA2)
			msic_set_selected_lineout_dev(VIBRA2);
		break;

	default:
		pr_warn("Wrong Device %d, selected %d\n",
			       device, snd_msic_ops.output_dev_id);
	}
	return sst_sc_reg_access(pcm2_en, PMIC_READ_MODIFY, 1);
}

static int msic_power_up_cp(unsigned int device)
{
	struct sc_reg_access vaud[] = {
		/* turn on the audio power supplies */
		{0x0DB, 0x07, 0},
	};
	struct sc_reg_access pll[] = {
		/* turn on PLL */
		{0x240, 0x20, 0},
	};
	struct sc_reg_access dmic_bias[] = {
		/*  Turn on AMIC supply  */
		{0x247, 0xA0, 0xA0},
	};
	struct sc_reg_access dmic[] = {
		/* mic demux enable */
		{0x245, 0x3F, 0x3F},
		{0x246, 0x07, 0x07},

	};
	struct sc_reg_access amic_bias[] = {
		/*  Turn on AMIC supply  */
		{0x247, 0xFC, 0xFC},
	};
	struct sc_reg_access amic[] = {
		/*MIC EN*/
		{0x249, 0x01, 0x01},
		{0x24A, 0x01, 0x01},
		/*ADC EN*/
		{0x248, 0x05, 0x0F},

	};
	struct sc_reg_access pcm2[] = {
		/* enable pcm 2 */
		{0x27C, 0x1, 0x1},
	};
	struct sc_reg_access tx_on[] = {
		/*wait for mic to stabalize before turning on audio channels*/
		{0x24F, 0x3C, 0x0},
	};
	int retval = 0;

	if (snd_msic_ops.card_status == SND_CARD_UN_INIT) {
		retval = msic_init_card();
		if (retval)
			return retval;
	}

	pr_debug("powering up cp....%d\n", snd_msic_ops.input_dev_id);
	sst_sc_reg_access(vaud, PMIC_WRITE, 1);
	msleep(500);/*FIXME need optimzed value here*/
	sst_sc_reg_access(pll, PMIC_WRITE, 1);
	msleep(1);
	snd_msic_ops.cap_on = 1;
	if (snd_msic_ops.input_dev_id == AMIC) {
		sst_sc_reg_access(amic_bias, PMIC_READ_MODIFY, 1);
		msleep(1);
		sst_sc_reg_access(amic, PMIC_READ_MODIFY, 3);
	} else {
		sst_sc_reg_access(dmic_bias, PMIC_READ_MODIFY, 1);
		msleep(1);
		sst_sc_reg_access(dmic, PMIC_READ_MODIFY, 2);
	}
	msleep(1);
	sst_sc_reg_access(tx_on, PMIC_WRITE, 1);
	return sst_sc_reg_access(pcm2, PMIC_READ_MODIFY, 1);
}

static int msic_power_down(void)
{
	struct sc_reg_access power_dn[] = {
		/*  VHSP */
		{0x0DC, 0xC4, 0},
		/*  VHSN */
		{0x0DD, 0x04, 0},
		/*  VIHF */
		{0x0C9, 0x24, 0},
	};
	struct sc_reg_access pll[] = {
		/* turn off PLL*/
		{0x240, 0x00, 0x0},
	};
	struct sc_reg_access vaud[] = {
		/* turn off VAUD*/
		{0x0DB, 0x04, 0},
	};

	pr_debug("powering dn msic\n");
	snd_msic_ops.pbhs_on = 0;
	snd_msic_ops.pb_on = 0;
	snd_msic_ops.cap_on = 0;
	sst_sc_reg_access(power_dn, PMIC_WRITE, 3);
	msleep(1);
	sst_sc_reg_access(pll, PMIC_WRITE, 1);
	msleep(1);
	sst_sc_reg_access(vaud, PMIC_WRITE, 1);
	return 0;
}

static int msic_power_down_pb(unsigned int device)
{
	struct sc_reg_access drv_enable[] = {
		{0x25D, 0x00, 0x00},
	};
	struct sc_reg_access hs_mute[] = {
		{0x259, 0x80, 0x80},
		{0x25A, 0x80, 0x80},
		{0x26C, 0x02, 0x02},
	};
	struct sc_reg_access hs_off[] = {
		{0x257, 0x00, 0x03},
		{0x250, 0x00, 0x30},
		{0x382, 0x00, 0x40},
	};
	struct sc_reg_access ihf_mute[] = {
		{0x25B, 0x80, 0x80},
		{0x25C, 0x80, 0x80},
	};
	struct sc_reg_access ihf_off[] = {
		{0x257, 0x00, 0x0C},
		{0x251, 0x00, 0x03},
	};
	struct sc_reg_access vib1_off[] = {
		{0x264, 0x00, 0x82},
	};
	struct sc_reg_access vib2_off[] = {
		{0x26A, 0x00, 0x82},
	};
	struct sc_reg_access lout_off[] = {
		{0x25e, 0x66, 0x00},
	};
	struct sc_reg_access pmode_disable[] = {
		{0x381, 0x00, 0x10},
	};



	pr_debug("powering dn pb for device %d\n", device);
	switch (device) {
	case SND_SST_DEVICE_HEADSET:
		snd_msic_ops.pbhs_on = 0;
		sst_sc_reg_access(hs_mute, PMIC_READ_MODIFY, 3);
		drv_enable[0].mask = 0x43;
		sst_sc_reg_access(drv_enable, PMIC_READ_MODIFY, 1);
		sst_sc_reg_access(hs_off, PMIC_READ_MODIFY, 3);
		if (snd_msic_ops.lineout_dev_id == HEADSET)
			sst_sc_reg_access(lout_off, PMIC_WRITE, 1);
		break;

	case SND_SST_DEVICE_IHF:
		sst_sc_reg_access(ihf_mute, PMIC_READ_MODIFY, 2);
		drv_enable[0].mask = 0x0C;
		sst_sc_reg_access(drv_enable, PMIC_READ_MODIFY, 1);
		sst_sc_reg_access(ihf_off, PMIC_READ_MODIFY, 2);
		if (snd_msic_ops.lineout_dev_id == IHF) {
			sst_sc_reg_access(lout_off, PMIC_WRITE, 1);
			sst_sc_reg_access(pmode_disable, PMIC_READ_MODIFY, 1);
		}
		break;

	case SND_SST_DEVICE_VIBRA:
		sst_sc_reg_access(vib1_off, PMIC_READ_MODIFY, 1);
		drv_enable[0].mask = 0x10;
		sst_sc_reg_access(drv_enable, PMIC_READ_MODIFY, 1);
		if (snd_msic_ops.lineout_dev_id == VIBRA1)
			sst_sc_reg_access(lout_off, PMIC_WRITE, 1);
		break;

	case SND_SST_DEVICE_HAPTIC:
		sst_sc_reg_access(vib2_off, PMIC_READ_MODIFY, 1);
		drv_enable[0].mask = 0x20;
		sst_sc_reg_access(drv_enable, PMIC_READ_MODIFY, 1);
		if (snd_msic_ops.lineout_dev_id == VIBRA2)
			sst_sc_reg_access(lout_off, PMIC_WRITE, 1);
		break;
	}
	return 0;
}

static int msic_power_down_cp(unsigned int device)
{
	struct sc_reg_access dmic[] = {
		{0x247, 0x00, 0xA0},
		{0x245, 0x00, 0x38},
		{0x246, 0x00, 0x07},
	};
	struct sc_reg_access amic[] = {
		{0x248, 0x00, 0x05},
		{0x249, 0x00, 0x01},
		{0x24A, 0x00, 0x01},
		{0x247, 0x00, 0xA3},
	};
	struct sc_reg_access tx_off[] = {
		{0x24F, 0x00, 0x3C},
	};

	pr_debug("powering dn cp....\n");
	snd_msic_ops.cap_on = 0;
	sst_sc_reg_access(tx_off, PMIC_READ_MODIFY, 1);
	if (snd_msic_ops.input_dev_id == DMIC)
		sst_sc_reg_access(dmic, PMIC_READ_MODIFY, 3);
	else
		sst_sc_reg_access(amic, PMIC_READ_MODIFY, 4);
	return 0;
}

static int msic_set_selected_output_dev(u8 value)
{
	int retval = 0;

	pr_debug("msic set selected output:%d\n", value);
	snd_msic_ops.output_dev_id = value;
	if (snd_msic_ops.pbhs_on)
		msic_power_up_pb(SND_SST_DEVICE_HEADSET);
	return retval;
}

static int msic_set_selected_input_dev(u8 value)
{

	struct sc_reg_access sc_access_dmic[] = {
		{0x24C, 0x10, 0x0},
	};
	struct sc_reg_access sc_access_amic[] = {
		{0x24C, 0x76, 0x0},

	};
	int retval = 0;

	pr_debug("msic_set_selected_input_dev:%d\n", value);
	snd_msic_ops.input_dev_id = value;
	switch (value) {
	case AMIC:
		pr_debug("Selecting AMIC1\n");
		retval = sst_sc_reg_access(sc_access_amic, PMIC_WRITE, 1);
		break;
	case DMIC:
		pr_debug("Selecting DMIC1\n");
		retval = sst_sc_reg_access(sc_access_dmic, PMIC_WRITE, 1);
		break;
	default:
		return -EINVAL;

	}
	if (snd_msic_ops.cap_on)
		retval = msic_power_up_cp(SND_SST_DEVICE_CAPTURE);
	return retval;
}

static int msic_set_hw_dmic_route(u8 hw_ch_index)
{
	struct sc_reg_access sc_access_router;
	int    retval = -EINVAL;

	switch (hw_ch_index) {
	case HW_CH0:
		sc_access_router.reg_addr = AUDIOMUX12;
		sc_access_router.value    = snd_msic_ops.hw_dmic_map[0];
		sc_access_router.mask     = (MASK2 | MASK1 | MASK0);
		pr_debug("hw_ch0.  value = 0x%x\n",
				sc_access_router.value);
		retval = sst_sc_reg_access(&sc_access_router,
				PMIC_READ_MODIFY, 1);
		break;

	case HW_CH1:
		sc_access_router.reg_addr = AUDIOMUX12;
		sc_access_router.value    = (snd_msic_ops.hw_dmic_map[1]) << 4;
		sc_access_router.mask     = (MASK6 | MASK5 | MASK4);
		pr_debug("### hw_ch1.  value = 0x%x\n",
				sc_access_router.value);
		retval = sst_sc_reg_access(&sc_access_router,
				PMIC_READ_MODIFY, 1);
		break;

	case HW_CH2:
		sc_access_router.reg_addr = AUDIOMUX34;
		sc_access_router.value    = snd_msic_ops.hw_dmic_map[2];
		sc_access_router.mask     = (MASK2 | MASK1 | MASK0);
		pr_debug("hw_ch2.  value = 0x%x\n",
				sc_access_router.value);
		retval = sst_sc_reg_access(&sc_access_router,
				PMIC_READ_MODIFY, 1);
		break;

	case HW_CH3:
		sc_access_router.reg_addr = AUDIOMUX34;
		sc_access_router.value    = (snd_msic_ops.hw_dmic_map[3]) << 4;
		sc_access_router.mask     = (MASK6 | MASK5 | MASK4);
		pr_debug("hw_ch3.  value = 0x%x\n",
				sc_access_router.value);
		retval = sst_sc_reg_access(&sc_access_router,
				PMIC_READ_MODIFY, 1);
		break;
	}

	return retval;
}


static int msic_set_pcm_voice_params(void)
{
	return 0;
}

static int msic_set_pcm_audio_params(int sfreq, int word_size, int num_channel)
{
	return 0;
}

static int msic_set_audio_port(int status)
{
	return 0;
}

static int msic_set_voice_port(int status)
{
	return 0;
}

static int msic_set_mute(int dev_id, u8 value)
{
	return 0;
}

static int msic_set_vol(int dev_id, int value)
{
	return 0;
}

static int msic_get_mute(int dev_id, u8 *value)
{
	return 0;
}

static int msic_get_vol(int dev_id, int *value)
{
	return 0;
}

static int msic_set_headset_state(int state)
{
	struct sc_reg_access hs_enable[] = {
		{0x25D, 0x03, 0x03},
	};

	if (state)
		/*enable*/
		sst_sc_reg_access(hs_enable, PMIC_READ_MODIFY, 1);
	else {
		hs_enable[0].value = 0;
		sst_sc_reg_access(hs_enable, PMIC_READ_MODIFY, 1);
	}
	return 0;
}

static int msic_enable_mic_bias(void)
{
	struct sc_reg_access jack_interrupt_reg[] = {
		{0x0DB, 0x07, 0x00},

	};
	struct sc_reg_access jack_bias_reg[] = {
		{0x247, 0x0C, 0x0C},
	};

	sst_sc_reg_access(jack_interrupt_reg, PMIC_WRITE, 1);
	sst_sc_reg_access(jack_bias_reg, PMIC_READ_MODIFY, 1);
	return 0;
}

static int msic_disable_mic_bias(void)
{
	if (snd_msic_ops.jack_interrupt_status == true)
		return 0;
	if (!(snd_msic_ops.pb_on || snd_msic_ops.cap_on))
		msic_power_down();
	return 0;
}

static int msic_disable_jack_btn(void)
{
	struct sc_reg_access btn_disable[] = {
		{0x26C, 0x00, 0x01}
	};

	if (!(snd_msic_ops.pb_on || snd_msic_ops.cap_on))
		msic_power_down();
	snd_msic_ops.jack_interrupt_status = false;
	return sst_sc_reg_access(btn_disable, PMIC_READ_MODIFY, 1);
}

static int msic_enable_jack_btn(void)
{
	struct sc_reg_access btn_enable[] = {
			{0x26b, 0x77, 0x00},
			{0x26C, 0x01, 0x00},
	};
	return sst_sc_reg_access(btn_enable, PMIC_WRITE, 2);
}
static int msic_convert_adc_to_mvolt(unsigned int mic_bias)
{
	return (ADC_ONE_LSB_MULTIPLIER * mic_bias) / 1000;
}
int msic_get_headset_state(int mic_bias)
{
	struct sc_reg_access msic_hs_toggle[] = {
		{0x070, 0x00, 0x01},
	};
	if (mic_bias >= 0 && mic_bias < 400) {

		pr_debug("Detected Headphone!!!\n");
		sst_sc_reg_access(msic_hs_toggle, PMIC_READ_MODIFY, 1);

	} else if (mic_bias > 400 && mic_bias < 650) {

		pr_debug("Detected American headset\n");
		msic_hs_toggle[0].value = 0x01;
		sst_sc_reg_access(msic_hs_toggle, PMIC_READ_MODIFY, 1);

	} else if (mic_bias >= 650 && mic_bias < 2000) {

		pr_debug("Detected Headset!!!\n");
		sst_sc_reg_access(msic_hs_toggle, PMIC_READ_MODIFY, 1);
		/*power on jack and btn*/
		snd_msic_ops.jack_interrupt_status = true;
		msic_enable_jack_btn();
		msic_enable_mic_bias();
		return SND_JACK_HEADSET;

	} else
		pr_debug("Detected Open Cable!!!\n");

	return SND_JACK_HEADPHONE;
}

static int msic_get_mic_bias(void *arg)
{
	struct snd_intelmad *intelmad_drv = (struct snd_intelmad *)arg;
	u16 adc_adr = intelmad_drv->adc_address;
	u16 adc_val;
	int ret;
	struct sc_reg_access adc_ctrl3[2] = {
			{0x1C2, 0x05, 0x0},
	};

	struct sc_reg_access audio_adc_reg1 = {0,};
	struct sc_reg_access audio_adc_reg2 = {0,};

	msic_enable_mic_bias();
	/* Enable the msic for conversion before reading */
	ret = sst_sc_reg_access(adc_ctrl3, PMIC_WRITE, 1);
	if (ret)
		return ret;
	adc_ctrl3[0].value = 0x04;
	/* Re-toggle the RRDATARD bit */
	ret = sst_sc_reg_access(adc_ctrl3, PMIC_WRITE, 1);
	if (ret)
		return ret;

	audio_adc_reg1.reg_addr = adc_adr;
	/* Read the higher bits of data */
	msleep(1000);
	ret = sst_sc_reg_access(&audio_adc_reg1, PMIC_READ, 1);
	if (ret)
		return ret;
	pr_debug("adc read value %x", audio_adc_reg1.value);

	/* Shift bits to accomodate the lower two data bits */
	adc_val = (audio_adc_reg1.value << 2);
	adc_adr++;
	audio_adc_reg2. reg_addr = adc_adr;
	ret = sst_sc_reg_access(&audio_adc_reg2, PMIC_READ, 1);
	if (ret)
		return ret;
	pr_debug("adc read value %x", audio_adc_reg2.value);

	/* Adding lower two bits to the higher bits */
	audio_adc_reg2.value &= 03;
	adc_val += audio_adc_reg2.value;

	pr_debug("ADC value 0x%x", adc_val);
	msic_disable_mic_bias();
	return adc_val;
}

static void msic_pmic_irq_cb(void *cb_data, u8 intsts)
{
	struct mad_jack *mjack = NULL;
	unsigned int present = 0, jack_event_flag = 0, buttonpressflag = 0;
	struct snd_intelmad *intelmaddata = cb_data;
	int retval = 0;

	pr_debug("value returned = 0x%x\n", intsts);

	if (snd_msic_ops.card_status == SND_CARD_UN_INIT) {
		retval = msic_init_card();
		if (retval)
			return;
	  }

	mjack = &intelmaddata->jack[0];
	if (intsts & 0x1) {
		pr_debug("MAD short_push detected\n");
		present = SND_JACK_BTN_0;
		jack_event_flag = buttonpressflag = 1;
		mjack->jack.type = SND_JACK_BTN_0;
		mjack->jack.key[0] = BTN_0 ;
	}

	if (intsts & 0x2) {
		pr_debug(":MAD long_push detected\n");
		jack_event_flag = buttonpressflag = 1;
		mjack->jack.type = present = SND_JACK_BTN_1;
		mjack->jack.key[1] = BTN_1;
	}

	if (intsts & 0x4) {
		unsigned int mic_bias;
		jack_event_flag = 1;
		buttonpressflag = 0;
		mic_bias = msic_get_mic_bias(intelmaddata);
		pr_debug("mic_bias = %d\n", mic_bias);
		mic_bias = msic_convert_adc_to_mvolt(mic_bias);
		pr_debug("mic_bias after conversion = %d mV\n", mic_bias);
		mjack->jack_dev_state = msic_get_headset_state(mic_bias);
		mjack->jack.type = present = mjack->jack_dev_state;
	}

	if (intsts & 0x8) {
		mjack->jack.type = mjack->jack_dev_state;
		present = 0;
		jack_event_flag = 1;
		buttonpressflag = 0;
		msic_disable_jack_btn();
		msic_disable_mic_bias();
	}
	if (jack_event_flag)
		sst_mad_send_jack_report(&mjack->jack,
					buttonpressflag, present);
}



struct snd_pmic_ops snd_msic_ops = {
	.set_input_dev	=	msic_set_selected_input_dev,
	.set_output_dev =	msic_set_selected_output_dev,
	.set_lineout_dev =	msic_set_selected_lineout_dev,
	.set_hw_dmic_route =    msic_set_hw_dmic_route,
	.set_mute	=	msic_set_mute,
	.get_mute	=	msic_get_mute,
	.set_vol	=	msic_set_vol,
	.get_vol	=	msic_get_vol,
	.init_card	=	msic_init_card,
	.set_pcm_audio_params	= msic_set_pcm_audio_params,
	.set_pcm_voice_params	= msic_set_pcm_voice_params,
	.set_voice_port = msic_set_voice_port,
	.set_audio_port = msic_set_audio_port,
	.power_up_pmic_pb =	msic_power_up_pb,
	.power_up_pmic_cp =	msic_power_up_cp,
	.power_down_pmic_pb =	msic_power_down_pb,
	.power_down_pmic_cp =	msic_power_down_cp,
	.power_down_pmic	=	msic_power_down,
	.pmic_irq_cb	=	msic_pmic_irq_cb,
	.pmic_jack_enable = msic_enable_mic_bias,
	.pmic_get_mic_bias	= msic_get_mic_bias,
	.pmic_set_headset_state = msic_set_headset_state,
};