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);
}
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_up_pb(unsigned int device)
{
struct sc_reg_access sc_access1[] = {
/* turn on the audio power supplies */
{0x0DB, 0x05, 0},
/* VHSP */
{0x0DC, 0xFF, 0},
/* VHSN */
{0x0DD, 0x3F, 0},
/* turn on PLL */
{0x240, 0x21, 0},
};
struct sc_reg_access sc_access2[] = {
/* disable driver */
{0x25D, 0x0, 0x43},
/* DAC CONFIG ; both HP, LP on */
{0x257, 0x03, 0x03},
};
struct sc_reg_access sc_access3[] = {
/* HSEPRXCTRL Enable the headset left and right FIR filters */
{0x250, 0x30, 0},
/* HSMIXER */
{0x256, 0x11, 0},
};
struct sc_reg_access sc_access4[] = {
/* enable driver */
{0x25D, 0x3, 0x3},
/* unmute the headset */
{ 0x259, 0x80, 0x80},
{ 0x25A, 0x80, 0x80},
};
struct sc_reg_access sc_access_vihf[] = {
/* VIHF ON */
{0x0C9, 0x2D, 0x00},
};
struct sc_reg_access sc_access22[] = {
/* disable driver */
{0x25D, 0x00, 0x0C},
/*Filer DAC enable*/
{0x251, 0x03, 0x03},
{0x257, 0x0C, 0x0C},
};
struct sc_reg_access sc_access32[] = {
/*enable drv*/
{0x25D, 0x0C, 0x0c},
};
struct sc_reg_access sc_access42[] = {
/*unmute headset*/
{0x25B, 0x80, 0x80},
{0x25C, 0x80, 0x80},
};
struct sc_reg_access sc_access23[] = {
/* disable driver */
{0x25D, 0x0, 0x43},
/* DAC CONFIG ; both HP, LP on */
{0x257, 0x03, 0x03},
};
struct sc_reg_access sc_access43[] = {
/* enable driver */
{0x25D, 0x40, 0x40},
/* unmute the headset */
{ 0x259, 0x80, 0x80},
{ 0x25A, 0x80, 0x80},
};
struct sc_reg_access sc_access_vib[] = {
/* enable driver, ADC */
{0x25D, 0x10, 0x10},
{0x264, 0x02, 0x02},
};
struct sc_reg_access sc_access_hap[] = {
/* enable driver, ADC */
{0x25D, 0x20, 0x20},
{0x26A, 0x02, 0x02},
};
struct sc_reg_access sc_access_pcm2[] = {
/* 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(sc_access1, PMIC_WRITE, 4);
switch (device) {
case SND_SST_DEVICE_HEADSET:
if (snd_msic_ops.output_dev_id == STEREO_HEADPHONE) {
sst_sc_reg_access(sc_access2, PMIC_READ_MODIFY, 2);
sst_sc_reg_access(sc_access3, PMIC_WRITE, 2);
sst_sc_reg_access(sc_access4, PMIC_READ_MODIFY, 3);
} else {
sst_sc_reg_access(sc_access23, PMIC_READ_MODIFY, 2);
sst_sc_reg_access(sc_access3, PMIC_WRITE, 2);
sst_sc_reg_access(sc_access43, PMIC_READ_MODIFY, 3);
}
snd_msic_ops.pb_on = 1;
break;
case SND_SST_DEVICE_IHF:
sst_sc_reg_access(sc_access_vihf, PMIC_WRITE, 1);
sst_sc_reg_access(sc_access22, PMIC_READ_MODIFY, 3);
sst_sc_reg_access(sc_access32, PMIC_READ_MODIFY, 1);
sst_sc_reg_access(sc_access42, PMIC_READ_MODIFY, 2);
break;
case SND_SST_DEVICE_VIBRA:
sst_sc_reg_access(sc_access_vib, PMIC_READ_MODIFY, 2);
break;
case SND_SST_DEVICE_HAPTIC:
sst_sc_reg_access(sc_access_hap, PMIC_READ_MODIFY, 2);
break;
default:
pr_warn("Wrong Device %d, selected %d\n",
device, snd_msic_ops.output_dev_id);
}
return sst_sc_reg_access(sc_access_pcm2, PMIC_READ_MODIFY, 1);
}
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 sc_access[] = {
/* turn on the audio power supplies */
{0x0DB, 0x05, 0},
/* VHSP */
{0x0DC, 0xFF, 0},
/* VHSN */
{0x0DD, 0x3F, 0},
/* turn on PLL */
{0x240, 0x21, 0},
/* Turn on DMIC supply */
{0x247, 0xA0, 0x0},
{0x240, 0x21, 0x0},
{0x24C, 0x10, 0x0},
/* mic demux enable */
{0x245, 0x3F, 0x0},
{0x246, 0x7, 0x0},
};
struct sc_reg_access sc_access_amic[] = {
/* turn on the audio power supplies */
{0x0DB, 0x05, 0},
/* VHSP */
{0x0DC, 0xFF, 0},
/* VHSN */
{0x0DD, 0x3F, 0},
/* turn on PLL */
{0x240, 0x21, 0},
/*ADC EN*/
{0x248, 0x05, 0x0},
{0x24C, 0x76, 0x0},
/*MIC EN*/
{0x249, 0x09, 0x0},
{0x24A, 0x09, 0x0},
/* Turn on AMIC supply */
{0x247, 0xFC, 0x0},
};
struct sc_reg_access sc_access2[] = {
/* enable pcm 2 */
{0x27C, 0x1, 0x1},
};
struct sc_reg_access sc_access3[] = {
/*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(sc_access2, PMIC_READ_MODIFY, 1);
snd_msic_ops.cap_on = 1;
if (snd_msic_ops.input_dev_id == AMIC)
sst_sc_reg_access(sc_access_amic, PMIC_WRITE, 9);
else
sst_sc_reg_access(sc_access, PMIC_WRITE, 9);
return sst_sc_reg_access(sc_access3, PMIC_WRITE, 1);
}
