/* * rt5627.c -- RT5627/RT5628 ALSA Soc Audio driver * * Copyright 2008 Realtek Microelectronics * * Author: flove * * Based on WM8753.c * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "rt5627.h" #define AUDIO_NAME "rt5627" #define RT5627_VERSION "0.01" /* * Debug */ #ifdef CONFIG_SND_DEBUG #define s3cdbg(x...) printk(x) #else #define s3cdbg(x...) #endif #define RT5627_DEBUG 0 #ifdef RT5627_DEBUG #define dbg(format, arg...) \ printk(KERN_DEBUG AUDIO_NAME ": " format "\n" , ## arg) #else #define dbg(format, arg...) do {} while (0) #endif #define err(format, arg...) \ printk(KERN_ERR AUDIO_NAME ": " format "\n" , ## arg) #define info(format, arg...) \ printk(KERN_INFO AUDIO_NAME ": " format "\n" , ## arg) #define warn(format, arg...) \ printk(KERN_WARNING AUDIO_NAME ": " format "\n" , ## arg) static int caps_charge = 2000; module_param(caps_charge, int, 0); MODULE_PARM_DESC(caps_charge, "RT5627 cap charge time (msecs)"); //HIKO DEBUG: for REALTEK 5627 on ebook proj //#include //#include /* codec private data */ struct rt5627_priv { unsigned int sysclk; }; static struct snd_soc_device *rt5627_socdev; /* * rt5627 register cache * We can't read the RT5627 register space when we * are using 2 wire for device control, so we cache them instead. */ static const u16 rt5627_reg[0x7E/2]; /* virtual HP mixers regs */ #define HPL_MIXER 0x80 #define HPR_MIXER 0x82 static u16 reg80=0,reg82=0; u16 Set_Codec_Reg_Init[][2]={ {RT5627_STEREO_DAC_VOL ,0x1010},//default stereo DAC volume to 0db {RT5627_OUTPUT_MIXER_CTRL,0x0704},//default output mixer control {RT5627_GEN_CTRL ,0x0b00},//set Class D Vmid ratio is 1VDD and DAC have high pass filter {RT5627_AUDIO_DATA_CTRL ,0x8000},//set I2S codec to slave mode {RT5627_SPK_OUT_VOL ,0x8080},//default speaker volume to 0db {RT5627_HP_OUT_VOL ,0x8888},//default HP volume to -12db }; #define SET_CODEC_REG_INIT_NUM ARRAY_SIZE(Set_Codec_Reg_Init) /* * read rt5627 register cache */ static inline unsigned int rt5627_read_reg_cache(struct snd_soc_codec *codec, unsigned int reg) { u16 *cache = codec->reg_cache; if (reg < 1 || reg > (ARRAY_SIZE(rt5627_reg) + 1)) return -1; return cache[reg/2]; } /* * write rt5627 register cache */ static inline void rt5627_write_reg_cache(struct snd_soc_codec *codec, unsigned int reg, unsigned int value) { u16 *cache = codec->reg_cache; if (reg < 0 || reg > 0x7e) return; cache[reg/2] = value; } static int rt5627_write(struct snd_soc_codec *codec, unsigned int reg, unsigned int value) { u8 data[3]; if(reg>0x7E) { if(reg==HPL_MIXER) reg80=value; else if(reg==HPR_MIXER) reg82=value; else return -EIO; return 0; } printk("rt5627 write reg=%x,value=%x\n",reg,value); data[0] = reg; data[1] = (0xFF00 & value) >> 8; data[2] = 0x00FF & value; if (codec->hw_write(codec->control_data, data, 3) == 3) { rt5627_write_reg_cache (codec, reg, value); // printk("rt5627 write OK\n"); return 0; } else { printk("rt5627 write faile\n"); return -EIO; } } static unsigned int rt5627_read(struct snd_soc_codec *codec, unsigned int reg) { u8 data[2]={0}; unsigned int value=0x0; if(reg>0x7E) { if(reg==HPL_MIXER) return reg80; else if(reg==HPR_MIXER) return reg82; else return -EIO; return -EIO; } data[0] = reg; if(codec->hw_write(codec->control_data, data, 1) ==1) { codec->hw_read(codec->control_data, data, 2); value = (data[0]<<8) | data[1]; printk("rt5627 read reg%x=%x\n",reg,value); return value; } else { printk("rt5627 read faile\n"); return -EIO; } } static int rt5627_write_mask(struct snd_soc_codec *codec, unsigned int reg,unsigned int value,unsigned int mask) { unsigned char RetVal=0; unsigned int CodecData; if(!mask) return 0; if(mask!=0xffff) { CodecData=rt5627_read(codec,reg); CodecData&=~mask; CodecData|=(value&mask); RetVal=rt5627_write(codec,reg,CodecData); } else { RetVal=rt5627_write(codec,reg,value); } return RetVal; } static int rt5627_ChangeCodecPowerStatus(struct snd_soc_codec *codec,int power_state) { unsigned short int PowerDownState=0; switch(power_state) { case POWER_STATE_D0: //FULL ON-----power on all power rt5627_write(codec,RT5627_PWR_MANAG_ADD1,~PowerDownState); rt5627_write(codec,RT5627_PWR_MANAG_ADD2,~PowerDownState); rt5627_write(codec,RT5627_PWR_MANAG_ADD3,~PowerDownState); break; case POWER_STATE_D1: //LOW ON----- rt5627_write_mask(codec,RT5627_PWR_MANAG_ADD2,PWR_VREF |PWR_DAC_REF_CIR |PWR_L_DAC_CLK |PWR_R_DAC_CLK|PWR_L_DAC_L_D_S|PWR_R_DAC_R_D_S |PWR_L_HP_MIXER |PWR_R_HP_MIXER|PWR_SPK_MIXER|PWR_CLASS_D ,PWR_VREF |PWR_DAC_REF_CIR |PWR_L_DAC_CLK |PWR_R_DAC_CLK|PWR_L_DAC_L_D_S|PWR_R_DAC_R_D_S |PWR_L_HP_MIXER |PWR_R_HP_MIXER|PWR_SPK_MIXER|PWR_CLASS_D); rt5627_write_mask(codec,RT5627_PWR_MANAG_ADD1,PWR_MAIN_I2S_EN|PWR_HP_AMP|PWR_HP_ENH_AMP ,PWR_MAIN_I2S_EN|PWR_HP_AMP|PWR_HP_ENH_AMP); rt5627_write_mask(codec,RT5627_PWR_MANAG_ADD3,PWR_MAIN_BIAS|PWR_HP_R_OUT_VOL_AMP|PWR_HP_L_OUT_VOL_AMP|PWR_SPK_OUT ,PWR_MAIN_BIAS|PWR_HP_R_OUT_VOL_AMP|PWR_HP_L_OUT_VOL_AMP|PWR_SPK_OUT); break; case POWER_STATE_D1_PLAYBACK: //Low on of Playback rt5627_write_mask(codec,RT5627_PWR_MANAG_ADD1,PWR_MAIN_I2S_EN|PWR_HP_AMP|PWR_HP_ENH_AMP ,PWR_MAIN_I2S_EN|PWR_HP_AMP|PWR_HP_ENH_AMP); rt5627_write_mask(codec,RT5627_PWR_MANAG_ADD2,PWR_VREF|PWR_DAC_REF_CIR|PWR_L_DAC_CLK|PWR_R_DAC_CLK|PWR_L_DAC_L_D_S|PWR_R_DAC_R_D_S|PWR_L_HP_MIXER|PWR_R_HP_MIXER|PWR_SPK_MIXER|PWR_CLASS_D ,PWR_VREF|PWR_DAC_REF_CIR|PWR_L_DAC_CLK|PWR_R_DAC_CLK|PWR_L_DAC_L_D_S|PWR_R_DAC_R_D_S|PWR_L_HP_MIXER|PWR_R_HP_MIXER|PWR_SPK_MIXER|PWR_CLASS_D); rt5627_write_mask(codec,RT5627_PWR_MANAG_ADD3,PWR_MAIN_BIAS|PWR_HP_R_OUT_VOL_AMP|PWR_HP_L_OUT_VOL_AMP|PWR_SPK_OUT ,PWR_MAIN_BIAS|PWR_HP_R_OUT_VOL_AMP|PWR_HP_L_OUT_VOL_AMP|PWR_SPK_OUT); break; case POWER_STATE_D1_RECORD: //Low on of Record //ALC5627 don't support record function break; case POWER_STATE_D2: //STANDBY---- // rt5627_write_mask(codec,RT5627_PWR_MANAG_ADD1,0,PWR_MAIN_I2S_EN|PWR_HP_AMP|PWR_HP_ENH_AMP); // rt5627_write_mask(codec,RT5627_PWR_MANAG_ADD2,0,PWR_DAC_REF_CIR |PWR_L_DAC_CLK |PWR_R_DAC_CLK |PWR_L_DAC_L_D_S|PWR_R_DAC_R_D_S|PWR_L_HP_MIXER |PWR_R_HP_MIXER|PWR_SPK_MIXER|PWR_CLASS_D); rt5627_write_mask(codec,RT5627_PWR_MANAG_ADD3,0,PWR_HP_R_OUT_VOL_AMP|PWR_HP_L_OUT_VOL_AMP|PWR_SPK_OUT); break; case POWER_STATE_D2_PLAYBACK: //STANDBY of playback rt5627_write_mask(codec,RT5627_PWR_MANAG_ADD3,0,/*PWR_HP_R_OUT_VOL_AMP|PWR_HP_L_OUT_VOL_AMP|*/PWR_SPK_OUT); rt5627_write_mask(codec,RT5627_PWR_MANAG_ADD1,0,PWR_HP_AMP|PWR_HP_ENH_AMP); // rt5627_write_mask(codec,RT5627_PWR_MANAG_ADD2,0,PWR_DAC_REF_CIR|PWR_L_DAC_CLK|PWR_R_DAC_CLK|PWR_L_DAC_L_D_S|PWR_R_DAC_R_D_S|PWR_L_HP_MIXER|PWR_R_HP_MIXER|PWR_SPK_MIXER|PWR_CLASS_D ); break; case POWER_STATE_D3: //SLEEP case POWER_STATE_D4: //OFF----power off all power rt5627_write_mask(codec,RT5627_PWR_MANAG_ADD1,0,PWR_HP_AMP|PWR_HP_ENH_AMP); rt5627_write(codec,RT5627_PWR_MANAG_ADD3,PowerDownState); rt5627_write(codec,RT5627_PWR_MANAG_ADD1,PowerDownState); rt5627_write(codec,RT5627_PWR_MANAG_ADD2,PowerDownState); break; default: break; } return 0; } static int rt5627_AudioOutEnable(struct snd_soc_codec *codec,unsigned short int WavOutPath,int Mute) { int RetVal=0; if(Mute) { switch(WavOutPath) { case RT_WAVOUT_ALL_ON: RetVal=rt5627_write_mask(codec,RT5627_SPK_OUT_VOL,RT_L_MUTE|RT_R_MUTE,RT_L_MUTE|RT_R_MUTE); //Mute Speaker right/left channel RetVal=rt5627_write_mask(codec,RT5627_HP_OUT_VOL,RT_L_MUTE|RT_R_MUTE,RT_L_MUTE|RT_R_MUTE); //Mute headphone right/left channel RetVal=rt5627_write_mask(codec,RT5627_STEREO_DAC_VOL,RT_M_HP_MIXER|RT_M_SPK_MIXER ,RT_M_HP_MIXER|RT_M_SPK_MIXER); //Mute DAC to HP,Speaker break; case RT_WAVOUT_HP: RetVal=rt5627_write_mask(codec,RT5627_HP_OUT_VOL,RT_L_MUTE|RT_R_MUTE,RT_L_MUTE|RT_R_MUTE); //Mute headphone right/left channel break; case RT_WAVOUT_SPK: RetVal=rt5627_write_mask(codec,RT5627_SPK_OUT_VOL,RT_L_MUTE|RT_R_MUTE,RT_L_MUTE|RT_R_MUTE); //Mute Speaker right/left channel break; case RT_WAVOUT_DAC: RetVal=rt5627_write_mask(codec,RT5627_STEREO_DAC_VOL,RT_M_HP_MIXER|RT_M_SPK_MIXER ,RT_M_HP_MIXER|RT_M_SPK_MIXER); //Mute DAC to HP,Speaker break; default: return 0; } } else { switch(WavOutPath) { case RT_WAVOUT_ALL_ON: RetVal=rt5627_write_mask(codec,RT5627_SPK_OUT_VOL ,0,RT_L_MUTE|RT_R_MUTE); //Mute Speaker right/left channel RetVal=rt5627_write_mask(codec,RT5627_HP_OUT_VOL ,0,RT_L_MUTE|RT_R_MUTE); //Mute headphone right/left channel RetVal=rt5627_write_mask(codec,RT5627_STEREO_DAC_VOL,0,RT_M_HP_MIXER|RT_M_SPK_MIXER); //Mute DAC to HP,Speaker break; case RT_WAVOUT_HP: RetVal=rt5627_write_mask(codec,RT5627_HP_OUT_VOL,0,RT_L_MUTE|RT_R_MUTE); //unMute headphone right/left channel break; case RT_WAVOUT_SPK: RetVal=rt5627_write_mask(codec,RT5627_SPK_OUT_VOL,0,RT_L_MUTE|RT_R_MUTE); //unMute Speaker right/left channel break; case RT_WAVOUT_DAC: RetVal=rt5627_write_mask(codec,RT5627_STEREO_DAC_VOL,0,RT_M_HP_MIXER|RT_M_SPK_MIXER); //unMute DAC to HP,Speaker break; default: return 0; } } return RetVal; } #define rt5627_reset(c) rt5627_write(c, 0x0, 0) /* * RT5627 Controls */ static const char *rt5627_spk_n_sour_sel[] = {"RN","RP","LN","MUTE"}; static const char *rt5627_spkout_input_sel[] = {"Vmid","HP mixer","Speaker Mixer"}; static const char *rt5627_hpl_out_input_sel[] = {"Vmid","HP Left mixer"}; static const char *rt5627_hpr_out_input_sel[] = {"Vmid","HP Right mixer"}; static const char *rt5627_class_d_ratio_sel[] = {"2.25vdd","2.00vdd","1.75vdd","1.5vdd","1.25vdd","1.0vdd"}; static const struct soc_enum rt5627_enum[] = { SOC_ENUM_SINGLE(RT5627_OUTPUT_MIXER_CTRL, 14, 4, rt5627_spk_n_sour_sel),// 0 SOC_ENUM_SINGLE(RT5627_OUTPUT_MIXER_CTRL, 10, 3, rt5627_spkout_input_sel),// 1 SOC_ENUM_SINGLE(RT5627_OUTPUT_MIXER_CTRL, 9, 2, rt5627_hpl_out_input_sel),// 2 SOC_ENUM_SINGLE(RT5627_OUTPUT_MIXER_CTRL, 8, 2, rt5627_hpr_out_input_sel),// 3 SOC_ENUM_SINGLE(RT5627_GEN_CTRL, 9, 6, rt5627_class_d_ratio_sel),// 4 }; static const struct snd_kcontrol_new rt5627_snd_controls[] = { SOC_DOUBLE("Speaker Playback Volume", RT5627_SPK_OUT_VOL, 8, 0, 31, 1), SOC_DOUBLE("Speaker Playback Switch", RT5627_SPK_OUT_VOL, 15, 7, 1, 1), SOC_DOUBLE("Headphone Playback Volume", RT5627_HP_OUT_VOL, 8, 0, 31, 1), SOC_DOUBLE("Headphone Playback Switch", RT5627_HP_OUT_VOL,15, 7, 1, 1), SOC_DOUBLE("PCM Playback Volume", RT5627_STEREO_DAC_VOL, 8, 0, 31, 1), SOC_DOUBLE("PCM Playback Switch", RT5627_STEREO_DAC_VOL,15, 7, 1, 1), SOC_DOUBLE("LineIn Capture Volume", RT5627_LINE_IN_VOL, 8, 0, 31, 1), SOC_DOUBLE("AuxIn Capture Volume", RT5627_AUXIN_VOL, 8, 0, 31, 1), SOC_ENUM("Class D AMP ratio", rt5627_enum[4]), }; /* add non dapm controls */ static int rt5627_add_controls(struct snd_soc_codec *codec) { int err, i; for (i = 0; i < ARRAY_SIZE(rt5627_snd_controls); i++) { err = snd_ctl_add(codec->card, snd_soc_cnew(&rt5627_snd_controls[i],codec, NULL)); if (err < 0) return err; } return 0; } /* * _DAPM_ Controls */ /* We have to create a fake left and right HP mixers because * the codec only has a single control that is shared by both channels. * This makes it impossible to determine the audio path using the current * register map, thus we add a new (virtual) register to help determine the * audio route within the device. */ static int mixer_event (struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol, int event) { u16 l=0, r=0, lineIn,auxin,pcm; struct snd_soc_device *socdev = rt5627_socdev; struct snd_soc_codec *codec = socdev->codec; l = rt5627_read(codec, HPL_MIXER); r = rt5627_read(codec, HPR_MIXER); lineIn = rt5627_read(codec, RT5627_LINE_IN_VOL); auxin = rt5627_read(codec,RT5627_AUXIN_VOL); pcm = rt5627_read(codec, RT5627_STEREO_DAC_VOL); if (event & SND_SOC_DAPM_PRE_REG) return 0; if (l & 0x1 || r & 0x1) rt5627_write(codec, RT5627_STEREO_DAC_VOL, pcm & 0x7fff); else rt5627_write(codec, RT5627_STEREO_DAC_VOL, pcm | 0x8000); if (l & 0x2 || r & 0x2) rt5627_write(codec, RT5627_AUXIN_VOL, auxin & 0x7fff); else rt5627_write(codec, RT5627_AUXIN_VOL, auxin | 0x8000); if (l & 0x4 || r & 0x4) rt5627_write(codec, RT5627_LINE_IN_VOL, lineIn & 0x7fff); else rt5627_write(codec, RT5627_LINE_IN_VOL, lineIn | 0x8000); return 0; } /* Left Headphone Mixers */ static const struct snd_kcontrol_new rt5627_hpl_mixer_controls[] = { SOC_DAPM_SINGLE("LineIn Playback Switch", HPL_MIXER, 2, 1, 0), SOC_DAPM_SINGLE("AUXIN Playback Switch", HPL_MIXER, 1, 1, 0), SOC_DAPM_SINGLE("PCM Playback Switch", HPL_MIXER, 0, 1, 0), }; /* Right Headphone Mixers */ static const struct snd_kcontrol_new rt5627_hpr_mixer_controls[] = { SOC_DAPM_SINGLE("LineIn Playback Switch", HPR_MIXER, 2, 1, 0), SOC_DAPM_SINGLE("AUXIN Playback Switch", HPR_MIXER, 1, 1, 0), SOC_DAPM_SINGLE("PCM Playback Switch", HPR_MIXER, 0, 1, 0), }; /* Speaker Mixer */ static const struct snd_kcontrol_new rt5627_speaker_mixer_controls[] = { SOC_DAPM_SINGLE("LineIn Playback Switch", RT5627_LINE_IN_VOL, 14, 1, 1), SOC_DAPM_SINGLE("AuxIn Playback Switch", RT5627_AUXIN_VOL, 14, 1, 1), SOC_DAPM_SINGLE("PCM Playback Switch", RT5627_STEREO_DAC_VOL, 14, 1, 1), }; /* speaker output mux */ static const struct snd_kcontrol_new rt5627_spkout_mux_controls = SOC_DAPM_ENUM("Route", rt5627_enum[2]); /* headphone left output mux */ static const struct snd_kcontrol_new rt5627_hpl_out_mux_controls = SOC_DAPM_ENUM("Route", rt5627_enum[3]); /* headphone right output mux */ static const struct snd_kcontrol_new rt5627_hpr_out_mux_controls = SOC_DAPM_ENUM("Route", rt5627_enum[4]); static const struct snd_soc_dapm_widget rt5627_dapm_widgets[] = { SND_SOC_DAPM_MUX("Speaker Out Mux", SND_SOC_NOPM, 0, 0, &rt5627_spkout_mux_controls), SND_SOC_DAPM_MUX("Left Headphone Out Mux", SND_SOC_NOPM, 0, 0, &rt5627_hpl_out_mux_controls), SND_SOC_DAPM_MUX("Right Headphone Out Mux", SND_SOC_NOPM, 0, 0, &rt5627_hpr_out_mux_controls), SND_SOC_DAPM_MIXER_E("Left HP Mixer",RT5627_PWR_MANAG_ADD2, 5, 0, &rt5627_hpl_mixer_controls[0], ARRAY_SIZE(rt5627_hpl_mixer_controls), mixer_event, SND_SOC_DAPM_POST_REG), SND_SOC_DAPM_MIXER_E("Right HP Mixer",RT5627_PWR_MANAG_ADD2, 4, 0, &rt5627_hpr_mixer_controls[0], ARRAY_SIZE(rt5627_hpr_mixer_controls), mixer_event, SND_SOC_DAPM_POST_REG), SND_SOC_DAPM_MIXER("Speaker Mixer", RT5627_PWR_MANAG_ADD2,3,0, &rt5627_speaker_mixer_controls[0], ARRAY_SIZE(rt5627_speaker_mixer_controls)), SND_SOC_DAPM_DAC("Left DAC", "Left HiFi Playback", RT5627_PWR_MANAG_ADD2,9, 0), SND_SOC_DAPM_DAC("Right DAC", "Right HiFi Playback", RT5627_PWR_MANAG_ADD2, 8, 0), SND_SOC_DAPM_MIXER("IIS Mixer", SND_SOC_NOPM, 0, 0, NULL, 0), SND_SOC_DAPM_MIXER("HP Mixer", SND_SOC_NOPM, 0, 0, NULL, 0), SND_SOC_DAPM_MIXER("AuxIn Mixer", SND_SOC_NOPM, 0, 0, NULL, 0), SND_SOC_DAPM_MIXER("Line Mixer", SND_SOC_NOPM, 0, 0, NULL, 0), SND_SOC_DAPM_PGA("Left Headphone", RT5627_PWR_MANAG_ADD3, 10, 0, NULL, 0), SND_SOC_DAPM_PGA("Right Headphone", RT5627_PWR_MANAG_ADD3, 9, 0, NULL, 0), SND_SOC_DAPM_PGA("Speaker Out", RT5627_PWR_MANAG_ADD3, 12, 0, NULL, 0), SND_SOC_DAPM_PGA("Left Aux Out", RT5627_PWR_MANAG_ADD3, 14, 0, NULL, 0), SND_SOC_DAPM_PGA("Right Aux Out", RT5627_PWR_MANAG_ADD3, 13, 0, NULL, 0), SND_SOC_DAPM_PGA("Left Line In", RT5627_PWR_MANAG_ADD3, 7, 0, NULL, 0), SND_SOC_DAPM_PGA("Right Line In", RT5627_PWR_MANAG_ADD3, 6, 0, NULL, 0), SND_SOC_DAPM_PGA("Left Aux In",RT5627_PWR_MANAG_ADD3, 5, 0, NULL, 0), SND_SOC_DAPM_PGA("Right Aux In",RT5627_PWR_MANAG_ADD3, 4, 0, NULL, 0), SND_SOC_DAPM_OUTPUT("HPL"), SND_SOC_DAPM_OUTPUT("HPR"), SND_SOC_DAPM_OUTPUT("SPKOUT"), SND_SOC_DAPM_INPUT("LINEL"), SND_SOC_DAPM_INPUT("LINER"), SND_SOC_DAPM_INPUT("AUXINL"), SND_SOC_DAPM_INPUT("AUXINR"), SND_SOC_DAPM_VMID("VMID"), }; static const char *audio_map[][3] = { /* left HP mixer */ {"Left HP Mixer", "LineIn Playback Switch", "LINEL"}, {"Left HP Mixer", "AuxIn Playback Switch","AUXIN"}, {"Left HP Mixer", "PCM Playback Switch","Left DAC"}, /* right HP mixer */ {"Right HP Mixer", "LineIn Playback Switch", "LINER"}, {"Right HP Mixer", "AuxIn Playback Switch","AUXIN"}, {"Right HP Mixer", "PCM Playback Switch","Right DAC"}, /* virtual mixer - mixes left & right channels for spk and mono */ {"IIS Mixer", NULL, "Left DAC"}, {"IIS Mixer", NULL, "Right DAC"}, {"Line Mixer", NULL, "Right Line In"}, {"Line Mixer", NULL, "Left Line In"}, {"HP Mixer", NULL, "Left HP Mixer"}, {"HP Mixer", NULL, "Right HP Mixer"}, {"AuxIn Mixer",NULL,"Left Aux In"}, {"AuxIn Mixer",NULL,"Right Aux In"}, /* speaker mixer */ {"Speaker Mixer", "LineIn Playback Switch","Line Mixer"}, {"Speaker Mixer", "AuxIn Playback Switch","AuxIn Mixer"}, {"Speaker Mixer", "PCM Playback Switch","IIS Mixer"}, /* headphone left mux */ {"Left Headphone Out Mux", "HP Left mixer", "Left HP Mixer"}, /* headphone right mux */ {"Right Headphone Out Mux", "HP Right mixer", "Right HP Mixer"}, /* speaker out mux */ {"Speaker Out Mux", "HP mixer", "HP Mixer"}, {"Speaker Out Mux", "Speaker Mixer", "Speaker Mixer"}, /* output pga */ {"HPL", NULL, "Left Headphone"}, {"Left Headphone", NULL, "Left Headphone Out Mux"}, {"HPR", NULL, "Right Headphone"}, {"Right Headphone", NULL, "Right Headphone Out Mux"}, {"SPKOUT", NULL, "Speaker Out"}, {"Speaker Out", NULL, "Speaker Out Mux"}, /* input pga */ {"Left Line In", NULL, "LINEL"}, {"Right Line In", NULL, "LINER"}, {"Left Aux In", NULL, "AUXINL"}, {"Right Aux In", NULL, "AUXINR"}, /* terminator */ {NULL, NULL, NULL}, }; static int rt5627_add_widgets(struct snd_soc_codec *codec) { int i; for (i = 0; i < ARRAY_SIZE(rt5627_dapm_widgets); i++) snd_soc_dapm_new_control(codec, &rt5627_dapm_widgets[i]); /* set up the RT5627 audio map */ for (i = 0; audio_map[i][0] != NULL; i++) { snd_soc_dapm_connect_input(codec, audio_map[i][0], audio_map[i][1], audio_map[i][2]); } snd_soc_dapm_new_widgets(codec); return 0; } /* PLL divisors */ struct _pll_div { u32 pll_in; u32 pll_out; u16 regvalue; }; static const struct _pll_div codec_master_pll_div[] = { { 2048000, 8192000, 0x0ea0}, { 3686400, 8192000, 0x4e27}, { 12000000, 8192000, 0x456b}, { 13000000, 8192000, 0x495f}, { 13100000, 8192000, 0x0320}, { 2048000, 11289600, 0xf637}, { 3686400, 11289600, 0x2f22}, { 12000000, 11289600, 0x3e2f}, { 13000000, 11289600, 0x4d5b}, { 13100000, 11289600, 0x363b}, { 2048000, 16384000, 0x1ea0}, { 3686400, 16384000, 0x9e27}, { 12000000, 16384000, 0x452b}, { 13000000, 16384000, 0x542f}, { 13100000, 16384000, 0x03a0}, { 2048000, 16934400, 0xe625}, { 3686400, 16934400, 0x9126}, { 12000000, 16934400, 0x4d2c}, { 13000000, 16934400, 0x742f}, { 13100000, 16934400, 0x3c27}, { 2048000, 22579200, 0x2aa0}, { 3686400, 22579200, 0x2f20}, { 12000000, 22579200, 0x7e2f}, { 13000000, 22579200, 0x742f}, { 13100000, 22579200, 0x3c27}, { 2048000, 24576000, 0x2ea0}, { 3686400, 24576000, 0xee27}, { 12000000, 24576000, 0x2915}, { 13000000, 24576000, 0x772e}, { 13100000, 24576000, 0x0d20}, }; static const struct _pll_div codec_slave_pll_div[] = { { 1024000, 16384000, 0x3ea0}, { 1411200, 22579200, 0x3ea0}, { 1536000, 24576000, 0x3ea0}, { 2048000, 16384000, 0x1ea0}, { 2822400, 22579200, 0x1ea0}, { 3072000, 24576000, 0x1ea0}, }; static int rt5627_set_dai_pll(struct snd_soc_codec_dai *codec_dai, int pll_id, unsigned int freq_in, unsigned int freq_out) { int i; struct snd_soc_codec *codec = codec_dai->codec; if (pll_id < RT5627_PLL_FR_MCLK || pll_id > RT5627_PLL_FR_BCK) return -ENODEV; rt5627_write_mask(codec,RT5627_PWR_MANAG_ADD2, 0x0000,0x1000); //disable PLL power if (!freq_in || !freq_out) { return 0; } if (pll_id == RT5627_PLL_FR_MCLK) { //codec is master mode //HIKO DEBUG: printk("[HIKO AUDIO]pll_id == RT5627_PLL_FR_MCLK"); for (i = 0; i < ARRAY_SIZE(codec_master_pll_div); i++) { if (codec_master_pll_div[i].pll_in == freq_in && codec_master_pll_div[i].pll_out == freq_out) { //HIKO DEBUG: printk("[HIKO AUDIO]i==0x%X", i); rt5627_write(codec,RT5627_GLOBAL_CLK_CTRL,0x8000);//PLL source from MCLK,Clock source from PLL rt5627_write(codec,RT5627_PLL_CTRL,codec_master_pll_div[i].regvalue);//set PLL parameter rt5627_write_mask(codec,RT5627_PWR_MANAG_ADD2, 0x1000,0x1000); //enable PLL power break; } } } else { //codec is slave mode //HIKO DEBUG: printk("[HIKO AUDIO]pll_id != RT5627_PLL_FR_MCLK"); for (i = 0; i < ARRAY_SIZE(codec_slave_pll_div); i++) { if (codec_slave_pll_div[i].pll_in == freq_in && codec_slave_pll_div[i].pll_out == freq_out) { //HIKO DEBUG: printk("[HIKO AUDIO]i==0x%X", i); rt5627_write(codec,RT5627_GLOBAL_CLK_CTRL,0xC000);//PLL source from Bitclk rt5627_write(codec,RT5627_PLL_CTRL,codec_master_pll_div[i].regvalue);//set PLL parameter rt5627_write_mask(codec,RT5627_PWR_MANAG_ADD2, 0x1000,0x1000); //enable PLL power break; } } } return 0; } struct _coeff_div { u32 mclk; u32 rate; u16 fs; u16 regvalue; }; /* codec hifi mclk (after PLL) clock divider coefficients */ static const struct _coeff_div coeff_div[] = { /* 8k */ { 8192000, 8000, 256*4, 0x2a69}, {12288000, 8000, 384*4, 0x2c6b}, /* 11.025k */ {11289600, 11025, 256*4, 0x2a69}, {16934400, 11025, 384*4, 0x2c6b}, /* 16k */ {16384000, 16000, 256*4, 0x2a69}, {24576000, 16000, 384*4, 0x2c6b}, /* 22.05k */ {11289600, 22050, 256*2, 0x1a69}, {16934400, 22050, 384*2, 0x1c6b}, /* 32k */ {16384000, 32000, 256*2, 0x1a69}, {24576000, 32000, 384*2, 0x1c6b}, /* 44.1k */ {22579200, 44100, 256*2, 0x1a69}, /* 48k */ {24576000, 48000, 256*2, 0x1a69}, }; static int get_coeff(int mclk, int rate) { int i; printk("get_coeff mclk=%d,rate=%d\n",mclk,rate); for (i = 0; i < ARRAY_SIZE(coeff_div); i++) { if (coeff_div[i].rate == rate && coeff_div[i].mclk == mclk) return i; } return -EINVAL; } /* * Clock after PLL and dividers */ static int rt5627_set_dai_sysclk(struct snd_soc_codec_dai *codec_dai, int clk_id, unsigned int freq, int dir) { struct snd_soc_codec *codec = codec_dai->codec; struct rt5627_priv *rt5627 = codec->private_data; switch (freq) { case 8192000: case 11289600: case 12288000: case 16384000: case 16934400: case 18432000: case 22579200: case 24576000: rt5627->sysclk = freq; return 0; } return -EINVAL; } static int rt5627_set_dai_fmt(struct snd_soc_codec_dai *codec_dai, unsigned int fmt) { struct snd_soc_codec *codec = codec_dai->codec; u16 iface = 0; /* set master/slave audio interface */ switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { case SND_SOC_DAIFMT_CBM_CFM: iface = 0x0000; break; case SND_SOC_DAIFMT_CBS_CFS: iface = 0x8000; break; default: return -EINVAL; } /* interface format */ switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { case SND_SOC_DAIFMT_I2S: iface |= 0x0000; break; case SND_SOC_DAIFMT_RIGHT_J: iface |= 0x0001; break; case SND_SOC_DAIFMT_LEFT_J: iface |= 0x0002; break; case SND_SOC_DAIFMT_DSP_A: iface |= 0x0003; break; case SND_SOC_DAIFMT_DSP_B: iface |= 0x4003; break; default: return -EINVAL; } /* clock inversion */ switch (fmt & SND_SOC_DAIFMT_INV_MASK) { case SND_SOC_DAIFMT_NB_NF: break; case SND_SOC_DAIFMT_IB_IF: iface |= 0x0080; break; case SND_SOC_DAIFMT_IB_NF: iface |= 0x0080; break; case SND_SOC_DAIFMT_NB_IF: break; default: return -EINVAL; } rt5627_write_mask(codec,RT5627_AUDIO_DATA_CTRL, iface,0x4803); return 0; } static int rt5627_pcm_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params) { struct snd_soc_pcm_runtime *rtd = substream->private_data; struct snd_soc_device *socdev = rtd->socdev; struct snd_soc_codec *codec = socdev->codec; struct rt5627_priv *rt5627 = codec->private_data; u16 iface=rt5627_read(codec,RT5627_AUDIO_DATA_CTRL)&0xfff3; int coeff = get_coeff(rt5627->sysclk, params_rate(params)); printk("rt5627_pcm_hw_params %d\n",params_rate(params)); /* bit size */ switch (params_format(params)) { case SNDRV_PCM_FORMAT_S16_LE: break; case SNDRV_PCM_FORMAT_S20_3LE: iface |= 0x0004; break; case SNDRV_PCM_FORMAT_S24_LE: iface |= 0x0008; break; case SNDRV_PCM_FORMAT_S32_LE: iface |= 0x000c; break; } /* set iface & srate */ rt5627_write(codec,RT5627_AUDIO_DATA_CTRL, iface); if (coeff >= 0) rt5627_write(codec,RT5627_DAC_CLK_CTRL,coeff_div[coeff].regvalue); return 0; } static int rt5627_pcm_hw_trigger(struct snd_pcm_substream *substream,int cmd) { // struct snd_pcm_runtime *runtime = substream->runtime; struct snd_soc_pcm_runtime *rtd = substream->private_data; struct snd_soc_device *socdev = rtd->socdev; struct snd_soc_codec *codec = socdev->codec; int ret = 0; switch (cmd) { case SNDRV_PCM_TRIGGER_START: if(substream->stream==SNDRV_PCM_STREAM_PLAYBACK) { rt5627_ChangeCodecPowerStatus(codec,POWER_STATE_D1_PLAYBACK); rt5627_AudioOutEnable(codec,RT_WAVOUT_SPK,0); rt5627_AudioOutEnable(codec,RT_WAVOUT_HP,0); //HIKO DEBIG: printk(KERN_NOTICE "[HIKO AUDIO]rt5627_AudioOutEnable"); } break; case SNDRV_PCM_TRIGGER_STOP: case SNDRV_PCM_TRIGGER_SUSPEND: case SNDRV_PCM_TRIGGER_PAUSE_PUSH: break; case SNDRV_PCM_TRIGGER_RESUME: break; case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: break; default: ret = -EINVAL; } return ret; } static int rt5627_mute(struct snd_soc_codec_dai *dai, int mute) { struct snd_soc_codec *codec = dai->codec; u16 mute_reg = rt5627_read(codec, RT5627_MISC2_CTRL) & 0xfff3; if (mute) { rt5627_write(codec, RT5627_MISC2_CTRL, mute_reg | 0xc); } else { rt5627_write(codec, RT5627_MISC2_CTRL, mute_reg); } return 0; } static int rt5627_dapm_event(struct snd_soc_codec *codec, int event) { switch (event) { case SNDRV_CTL_POWER_D0: /* full On */ printk("rt5627_dapm_event_POWER_D0\n"); break; case SNDRV_CTL_POWER_D1: /* partial On */ printk("rt5627_dapm_event_POWER_D1\n"); case SNDRV_CTL_POWER_D2: /* partial On */ printk("rt5627_dapm_event_POWER_D2\n"); break; case SNDRV_CTL_POWER_D3hot: /* Off, with power */ printk("rt5627_dapm_event_POWER_D3\n"); break; case SNDRV_CTL_POWER_D3cold: /* Off, without power */ printk("rt5627_dapm_event_POWER_D4\n"); break; } codec->dapm_state = event; return 0; } #define RT5627_RATES SNDRV_PCM_RATE_48000 #define RT5627_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\ SNDRV_PCM_FMTBIT_S24_LE) struct snd_soc_codec_dai rt5627_dai = { .name = "RT5627", .playback = { .stream_name = "Playback", .channels_min = 1, .channels_max = 2, .rates = RT5627_RATES, .formats = RT5627_FORMATS,}, .ops = { .hw_params = rt5627_pcm_hw_params, .trigger = rt5627_pcm_hw_trigger, }, .dai_ops = { .digital_mute = rt5627_mute, .set_fmt = rt5627_set_dai_fmt, .set_sysclk = rt5627_set_dai_sysclk, .set_pll = rt5627_set_dai_pll, }, }; EXPORT_SYMBOL_GPL(rt5627_dai); static void rt5627_work(struct work_struct *work) { struct snd_soc_codec *codec = container_of(work, struct snd_soc_codec, delayed_work.work); rt5627_dapm_event(codec, codec->dapm_state); } static int rt5627_suspend(struct platform_device *pdev, pm_message_t state) { struct snd_soc_device *socdev = platform_get_drvdata(pdev); struct snd_soc_codec *codec = socdev->codec; /* we only need to suspend if we are a valid card */ if(!codec->card) return 0; rt5627_dapm_event(codec, SNDRV_CTL_POWER_D3cold); return 0; } static int rt5627_resume(struct platform_device *pdev) { struct snd_soc_device *socdev = platform_get_drvdata(pdev); struct snd_soc_codec *codec = socdev->codec; int i; u8 data[3]; u16 *cache = codec->reg_cache; /* we only need to resume if we are a valid card */ if(!codec->card) return 0; /* Sync reg_cache with the hardware */ for (i = 0; i < ARRAY_SIZE(rt5627_reg); i++) { if (i == RT5627_RESET) continue; data[0] =i*2; data[1] = (0xFF00 & cache[i]) >> 8; data[2] = 0x00FF & cache[i]; codec->hw_write(codec->control_data, data, 3); } rt5627_dapm_event(codec, SNDRV_CTL_POWER_D3hot); /* charge rt5627 caps */ if (codec->suspend_dapm_state == SNDRV_CTL_POWER_D0) { rt5627_dapm_event(codec, SNDRV_CTL_POWER_D2); codec->dapm_state = SNDRV_CTL_POWER_D0; schedule_delayed_work(&codec->delayed_work, msecs_to_jiffies(caps_charge)); } return 0; } /* * initialise the RT5627 driver * register the mixer and dsp interfaces with the kernel */ static int rt5627_init(struct snd_soc_device *socdev) { struct snd_soc_codec *codec = socdev->codec; int ret = 0,i=0; codec->name = "RT5627"; codec->owner = THIS_MODULE; codec->read = rt5627_read; codec->write = rt5627_write; codec->dapm_event = rt5627_dapm_event; codec->dai = &rt5627_dai; codec->num_dai = 1; codec->reg_cache_size = sizeof(rt5627_reg); codec->reg_cache = kmemdup(rt5627_reg, sizeof(rt5627_reg), GFP_KERNEL); printk(KERN_NOTICE "[HIKO] rt5627_init()\n"); if (codec->reg_cache == NULL) return -ENOMEM; rt5627_reset(codec); /* register pcms */ ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1); if (ret < 0) { printk(KERN_ERR "rt5627: failed to create pcms\n"); goto pcm_err; } rt5627_write(codec, RT5627_PWR_MANAG_ADD3, 0x8000);//enable Main bias rt5627_write(codec, RT5627_PWR_MANAG_ADD2, 0x2000);//enable Vref /* charge output caps */ rt5627_dapm_event(codec, SNDRV_CTL_POWER_D2); codec->dapm_state = SNDRV_CTL_POWER_D3hot; schedule_delayed_work(&codec->delayed_work, msecs_to_jiffies(caps_charge)); for(i=0;ireg_cache); return ret; } /* If the i2c layer weren't so broken, we could pass this kind of data around */ #if defined (CONFIG_I2C) || defined (CONFIG_I2C_MODULE) /* * RT5627 2 wire address is determined by A1 pin * state during powerup. * low = 0x1a * high = 0x1b */ static unsigned short normal_i2c[] = { 0, I2C_CLIENT_END }; /* Magic definition of all other variables and things */ I2C_CLIENT_INSMOD; static struct i2c_driver rt5627_i2c_driver; static struct i2c_client client_template; static int rt5627_codec_probe(struct i2c_adapter *adap, int addr, int kind) { struct snd_soc_device *socdev = rt5627_socdev; struct rt5627_setup_data *setup = socdev->codec_data; struct snd_soc_codec *codec = socdev->codec; struct i2c_client *i2c; int ret; printk(KERN_NOTICE "[HIKO] rt5627_codec_probe()\n"); if (addr != setup->i2c_address) return -ENODEV; client_template.adapter = adap; client_template.addr = addr; i2c = kmemdup(&client_template, sizeof(client_template), GFP_KERNEL); if (i2c == NULL){ kfree(codec); return -ENOMEM; } i2c_set_clientdata(i2c, codec); codec->control_data = i2c; ret = i2c_attach_client(i2c); if (ret < 0) { err("failed to attach codec at addr %x\n", addr); goto err; } ret = rt5627_init(socdev); if (ret < 0) { err("failed to initialise RT5627\n"); goto err; } return ret; err: kfree(codec); kfree(i2c); return ret; } static int rt5627_i2c_detach(struct i2c_client *client) { struct snd_soc_codec *codec = i2c_get_clientdata(client); i2c_detach_client(client); kfree(codec->reg_cache); kfree(client); return 0; } static int rt5627_i2c_attach(struct i2c_adapter *adap) { return i2c_probe(adap, &addr_data, rt5627_codec_probe); } /* corgi i2c codec control layer */ static struct i2c_driver rt5627_i2c_driver = { .driver = { .name = "RT5627 I2C Codec", .owner = THIS_MODULE, }, .id = I2C_DRIVERID_I2CDEV, // .id = I2C_DRIVERID_RT5627, .attach_adapter = rt5627_i2c_attach, .detach_client = rt5627_i2c_detach, .command = NULL, }; static struct i2c_client client_template = { .name = "RT5627", .driver = &rt5627_i2c_driver, }; #endif static int rt5627_probe(struct platform_device *pdev) { struct snd_soc_device *socdev = platform_get_drvdata(pdev); struct rt5627_setup_data *setup; struct snd_soc_codec *codec; struct rt5627_priv *rt5627; int ret = 0; info("RT5627 Audio Codec %s",RT5627_VERSION); setup = socdev->codec_data; codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL); if (codec == NULL) return -ENOMEM; rt5627 = kzalloc(sizeof(struct rt5627_priv), GFP_KERNEL); if (rt5627 == NULL) { kfree(codec); return -ENOMEM; } codec->private_data = rt5627; socdev->codec = codec; mutex_init(&codec->mutex); INIT_LIST_HEAD(&codec->dapm_widgets); INIT_LIST_HEAD(&codec->dapm_paths); rt5627_socdev = socdev; INIT_DELAYED_WORK(&codec->delayed_work, rt5627_work); #if defined (CONFIG_I2C) || defined (CONFIG_I2C_MODULE) if (setup->i2c_address) { normal_i2c[0] = setup->i2c_address; codec->hw_write = (hw_write_t)i2c_master_send; codec->hw_read = (hw_read_t)i2c_master_recv; ret = i2c_add_driver(&rt5627_i2c_driver); if (ret != 0) printk(KERN_ERR "can't add i2c driver"); } #else /* Add other interfaces here */ #endif return ret; } /* * This function forces any delayed work to be queued and run. */ static int run_delayed_work(struct delayed_work *dwork) { int ret; /* cancel any work waiting to be queued. */ ret = cancel_delayed_work(dwork); /* if there was any work waiting then we run it now and * wait for it's completion */ if (ret) { schedule_delayed_work(dwork, 0); flush_scheduled_work(); } return ret; } /* power down chip */ static int rt5627_remove(struct platform_device *pdev) { struct snd_soc_device *socdev = platform_get_drvdata(pdev); struct snd_soc_codec *codec = socdev->codec; if (codec->control_data) rt5627_dapm_event(codec, SNDRV_CTL_POWER_D3cold); run_delayed_work(&codec->delayed_work); snd_soc_free_pcms(socdev); snd_soc_dapm_free(socdev); #if defined (CONFIG_I2C) || defined (CONFIG_I2C_MODULE) i2c_del_driver(&rt5627_i2c_driver); #endif kfree(codec->private_data); kfree(codec); return 0; } struct snd_soc_codec_device soc_codec_dev_rt5627 = { .probe = rt5627_probe, .remove = rt5627_remove, .suspend = rt5627_suspend, .resume = rt5627_resume, }; EXPORT_SYMBOL_GPL(soc_codec_dev_rt5627); MODULE_DESCRIPTION("ASoC RT5627/5628 driver"); MODULE_AUTHOR("flove"); MODULE_LICENSE("GPL");