/* * intelmid_vm_control.c - Intel Sound card driver for MID * * Copyright (C) 2010 Intel Corp * Authors: Vinod Koul * * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * * 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 #include #include #include #include "intel_sst.h" #include #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, };