bkgpl/cyb4_linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
cyb4_linux/sound/soc/codecs/rt5627.c

1377 lines
35 KiB
C
Raw Permalink Blame History

/*
* rt5627.c -- RT5627/RT5628 ALSA Soc Audio driver
*
* Copyright 2008 Realtek Microelectronics
*
* Author: flove <flove@realtek.com>
*
* 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 <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/version.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/pm.h>
#include <linux/i2c.h>
#include <linux/platform_device.h>
#include <sound/driver.h>
#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/soc.h>
#include <sound/soc-dapm.h>
#include <sound/initval.h>
#include <asm/div64.h>
#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 <asm/hardware.h>
//#include <asm-arm/arch-s3c2410/regs-gpio.h>
/* 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;i<SET_CODEC_REG_INIT_NUM;i++)
{
rt5627_write(codec,Set_Codec_Reg_Init[i][0],Set_Codec_Reg_Init[i][1]);
}
rt5627_add_controls(codec);
// rt5627_add_widgets(codec);
ret = snd_soc_register_card(socdev);
if (ret < 0) {
printk(KERN_ERR "rt5627: failed to register card\n");
goto card_err;
}
//HIKO DEBUG: for REALTEK 5627 on ebook proj
// s3c2410_gpio_cfgpin(S3C2410_GPB10, S3C2410_GPB10_OUTP);
// s3c2410_gpio_setpin(S3C2410_GPB10, 1);
// printk(KERN_NOTICE "[HIKO AUDIO]Enable GPB10 output");
return ret;
card_err:
snd_soc_free_pcms(socdev);
snd_soc_dapm_free(socdev);
pcm_err:
kfree(codec->reg_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");
Reference in New Issue View Git Blame Copy Permalink