From: Alexander Sverdlin subaparts@yandex.ru

Added support for Cirrus CS4271 codec to ALSA SoC subsystem.

Applies on: 2.6.36-rc6

Signed-off-by: Alexander Sverdlin subaparts@yandex.ru

---

sound/soc/codecs/Kconfig | 3 + sound/soc/codecs/Makefile | 2 + sound/soc/codecs/cs4271.c | 840 +++++++++++++++++++++++++++++++++++++++++++++ sound/soc/codecs/cs4271.h | 27 ++ 4 files changed, 872 insertions(+), 0 deletions(-)

diff --git a/sound/soc/codecs/Kconfig b/sound/soc/codecs/Kconfig index 83f5c67..608cf88 100644 --- a/sound/soc/codecs/Kconfig +++ b/sound/soc/codecs/Kconfig @@ -138,6 +138,9 @@ config SND_SOC_CS4270_VD33_ERRATA bool depends on SND_SOC_CS4270

+config SND_SOC_CS4271 + tristate + config SND_SOC_CX20442 tristate

diff --git a/sound/soc/codecs/Makefile b/sound/soc/codecs/Makefile index 5352409..d7dd676 100644 --- a/sound/soc/codecs/Makefile +++ b/sound/soc/codecs/Makefile @@ -11,6 +11,7 @@ snd-soc-ak4671-objs := ak4671.o snd-soc-cq93vc-objs := cq93vc.o snd-soc-cs42l51-objs := cs42l51.o snd-soc-cs4270-objs := cs4270.o +snd-soc-cs4271-objs := cs4271.o snd-soc-cx20442-objs := cx20442.o snd-soc-da7210-objs := da7210.o snd-soc-l3-objs := l3.o @@ -79,6 +80,7 @@ obj-$(CONFIG_SND_SOC_AK4671) += snd-soc-ak4671.o obj-$(CONFIG_SND_SOC_CQ0093VC) += snd-soc-cq93vc.o obj-$(CONFIG_SND_SOC_CS42L51) += snd-soc-cs42l51.o obj-$(CONFIG_SND_SOC_CS4270) += snd-soc-cs4270.o +obj-$(CONFIG_SND_SOC_CS4271) += snd-soc-cs4271.o obj-$(CONFIG_SND_SOC_CX20442) += snd-soc-cx20442.o obj-$(CONFIG_SND_SOC_DA7210) += snd-soc-da7210.o obj-$(CONFIG_SND_SOC_L3) += snd-soc-l3.o diff --git a/sound/soc/codecs/cs4271.c b/sound/soc/codecs/cs4271.c new file mode 100644 index 0000000..305281a --- /dev/null +++ b/sound/soc/codecs/cs4271.c @@ -0,0 +1,840 @@ +/* + * CS4271 ALSA SoC (ASoC) codec driver + * + * Copyright (c) 2010 Alexander Sverdlin subaparts@yandex.ru + * + * This file is licensed under the terms of the GNU General Public License + * version 2. This program is licensed "as is" without any warranty of any + * kind, whether express or implied. + * + * This is an ASoC device driver for the Cirrus Logic CS4271 codec. + * + * Current features/limitations: + * + * - I2C and SPI are supported + * - Software mode is supported. Stand-alone mode is not supported + * - Support for master and slave mode + * - The machine driver's 'startup' function must call + * cs4271_set_dai_sysclk() with the value of MCLK + * - Only I2S and left-justified modes are supported + */ + +#include <linux/module.h> +#include <linux/platform_device.h> +#include <linux/slab.h> +#include <sound/core.h> +#include <sound/soc.h> +#include <sound/initval.h> +#include <linux/i2c.h> +#include <linux/spi/spi.h> + +#include "cs4271.h" + +#define CS4271_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | \ + SNDRV_PCM_FMTBIT_S24_LE | \ + SNDRV_PCM_FMTBIT_S32_LE) + +/* + * CS4271 registers addresses + * High byte represents SPI address (0x10) + write command (0) + */ +#define CS4271_MODE1 0x2001 /* Mode Control 1 */ +#define CS4271_DACCTL 0x2002 /* DAC Control */ +#define CS4271_DACVOL 0x2003 /* DAC Volume & Mixing Control */ +#define CS4271_VOLA 0x2004 /* DAC Channel A Volume Control */ +#define CS4271_VOLB 0x2005 /* DAC Channel B Volume Control */ +#define CS4271_ADCCTL 0x2006 /* ADC Control */ +#define CS4271_MODE2 0x2007 /* Mode Control 2 */ +#define CS4271_CHIPID 0x2008 /* Chip ID */ + +#define CS4271_FIRSTREG CS4271_MODE1 +#define CS4271_LASTREG CS4271_MODE2 +#define CS4271_NR_REGS ((CS4271_LASTREG & 0xFF) + 1) + +/* Bit masks for the CS4271 registers */ +#define CS4271_MODE1_FUNCMODE_MASK 0xC0 +#define CS4271_MODE1_FUNCMODE_1X 0x00 +#define CS4271_MODE1_FUNCMODE_2X 0x80 +#define CS4271_MODE1_FUNCMODE_4X 0xC0 + +#define CS4271_MODE1_DIV_MASK 0x30 +#define CS4271_MODE1_DIV_1 0x00 +#define CS4271_MODE1_DIV_15 0x10 +#define CS4271_MODE1_DIV_2 0x20 +#define CS4271_MODE1_DIV_3 0x30 + +#define CS4271_MODE1_MASTER 0x08 + +#define CS4271_MODE1_DAC_DIF_MASK 0x07 +#define CS4271_MODE1_DAC_DIF_LJ 0x00 +#define CS4271_MODE1_DAC_DIF_I2S 0x01 +#define CS4271_MODE1_DAC_DIF_RJ16 0x02 +#define CS4271_MODE1_DAC_DIF_RJ24 0x03 +#define CS4271_MODE1_DAC_DIF_RJ20 0x04 +#define CS4271_MODE1_DAC_DIF_RJ18 0x05 + +#define CS4271_DACCTL_AMUTE 0x80 +#define CS4271_DACCTL_IF_SLOW 0x40 + +#define CS4271_DACCTL_DEM_MASK 0x30 +#define CS4271_DACCTL_DEM_DIS 0x00 +#define CS4271_DACCTL_DEM_441 0x10 +#define CS4271_DACCTL_DEM_48 0x20 +#define CS4271_DACCTL_DEM_32 0x30 + +#define CS4271_DACCTL_SVRU 0x08 +#define CS4271_DACCTL_SRD 0x04 +#define CS4271_DACCTL_INVA 0x02 +#define CS4271_DACCTL_INVB 0x01 + +#define CS4271_DACVOL_BEQUA 0x40 +#define CS4271_DACVOL_SOFT 0x20 +#define CS4271_DACVOL_ZEROC 0x10 + +#define CS4271_DACVOL_ATAPI_MASK 0x0F +#define CS4271_DACVOL_ATAPI_M_M 0x00 +#define CS4271_DACVOL_ATAPI_M_BR 0x01 +#define CS4271_DACVOL_ATAPI_M_BL 0x02 +#define CS4271_DACVOL_ATAPI_M_BLR2 0x03 +#define CS4271_DACVOL_ATAPI_AR_M 0x04 +#define CS4271_DACVOL_ATAPI_AR_BR 0x05 +#define CS4271_DACVOL_ATAPI_AR_BL 0x06 +#define CS4271_DACVOL_ATAPI_AR_BLR2 0x07 +#define CS4271_DACVOL_ATAPI_AL_M 0x08 +#define CS4271_DACVOL_ATAPI_AL_BR 0x09 +#define CS4271_DACVOL_ATAPI_AL_BL 0x0A +#define CS4271_DACVOL_ATAPI_AL_BLR2 0x0B +#define CS4271_DACVOL_ATAPI_ALR2_M 0x0C +#define CS4271_DACVOL_ATAPI_ALR2_BR 0x0D +#define CS4271_DACVOL_ATAPI_ALR2_BL 0x0E +#define CS4271_DACVOL_ATAPI_ALR2_BLR2 0x0F + +#define CS4271_VOLA_MUTE 0x80 +#define CS4271_VOLA_VOL_MASK 0x7F +#define CS4271_VOLB_MUTE 0x80 +#define CS4271_VOLB_VOL_MASK 0x7F + +#define CS4271_ADCCTL_DITHER16 0x20 + +#define CS4271_ADCCTL_ADC_DIF_MASK 0x10 +#define CS4271_ADCCTL_ADC_DIF_LJ 0x00 +#define CS4271_ADCCTL_ADC_DIF_I2S 0x10 + +#define CS4271_ADCCTL_MUTEA 0x08 +#define CS4271_ADCCTL_MUTEB 0x04 +#define CS4271_ADCCTL_HPFDA 0x02 +#define CS4271_ADCCTL_HPFDB 0x01 + +#define CS4271_MODE2_LOOP 0x10 +#define CS4271_MODE2_MUTECAEQUB 0x08 +#define CS4271_MODE2_FREEZE 0x04 +#define CS4271_MODE2_CPEN 0x02 +#define CS4271_MODE2_PDN 0x01 + +#define CS4271_CHIPID_PART_MASK 0xF0 +#define CS4271_CHIPID_REV_MASK 0x0F + +/* Private data for the CS4271 */ +struct cs4271_private { + struct snd_soc_codec codec; + u8 reg_cache[CS4271_NR_REGS]; + unsigned int mclk; /* Input frequency of the MCLK pin */ + unsigned int mode; /* The mode (I2S or left-justified) */ + unsigned int slave_mode; +}; + +/* + * struct cs4271_mode_ratios - clock ratio tables + * @ratio: the ratio of MCLK to the sample rate + * @speed_mode: the Speed Mode bits to set in the Mode Control register for + * this ratio + * @mclk_master: the Ratio Select bits to set in the Mode Control register + * for this ratio while in Master mode + * @mclk_slave: the Ratio Select bits to set in the Mode Control register + * for this ratio while in Slave mode + * + * This table is used to determine how to program the Mode Control register + * It is also used by cs4271_set_dai_sysclk() to tell ALSA which sampling + * rates the CS4271 currently supports. + */ +struct cs4271_mode_ratios { + unsigned int ratio; + u8 speed_mode; + u8 mclk_master; + u8 mclk_slave; +}; + +static struct cs4271_mode_ratios cs4271_mode_ratios[] = { + {64, CS4271_MODE1_FUNCMODE_4X, CS4271_MODE1_DIV_1, CS4271_MODE1_DIV_1}, + {96, CS4271_MODE1_FUNCMODE_4X, CS4271_MODE1_DIV_15, CS4271_MODE1_DIV_1}, + {128, CS4271_MODE1_FUNCMODE_2X, CS4271_MODE1_DIV_1, CS4271_MODE1_DIV_1}, + {192, CS4271_MODE1_FUNCMODE_2X, CS4271_MODE1_DIV_15, CS4271_MODE1_DIV_1}, + {256, CS4271_MODE1_FUNCMODE_1X, CS4271_MODE1_DIV_1, CS4271_MODE1_DIV_1}, + {384, CS4271_MODE1_FUNCMODE_1X, CS4271_MODE1_DIV_15, CS4271_MODE1_DIV_1}, + {512, CS4271_MODE1_FUNCMODE_1X, CS4271_MODE1_DIV_2, CS4271_MODE1_DIV_1}, + {768, CS4271_MODE1_FUNCMODE_1X, CS4271_MODE1_DIV_3, CS4271_MODE1_DIV_3}, + {1024, CS4271_MODE1_FUNCMODE_1X, CS4271_MODE1_DIV_3, CS4271_MODE1_DIV_3} +}; + +/* The number of MCLK/LRCK ratios supported by the CS4271 */ +#define NUM_MCLK_RATIOS ARRAY_SIZE(cs4271_mode_ratios) + +/* + * cs4271_set_dai_sysclk - determine the CS4271 MCLK rate. + * @codec_dai: the codec DAI + * @clk_id: the clock ID (ignored) + * @freq: the MCLK input frequency + * @dir: the clock direction (ignored) + * + * This function is used to tell the codec driver what the input MCLK + * frequency is. + * + * The value of MCLK is used to determine which sample rates are supported + * by the CS4271. The ratio of MCLK / Fs must be equal to one of + * supported values - 64, 96, 128, 192, 256, 384, 512, 768 and + * for Slave mode 1024. 256 is the best value and widely recommended. + * + * This function must be called by the machine driver's 'startup' function, + * otherwise the list of supported sample rates will not be available in + * time for ALSA. + * + * For setups with variable MCLKs, pass 0 as 'freq' argument. This will cause + * theoretically possible sample rates to be enabled. Call it again with a + * proper value set one the external clock is set (most probably you would do + * that from a machine's driver 'hw_param' hook. + */ +static int cs4271_set_dai_sysclk(struct snd_soc_dai *codec_dai, + int clk_id, unsigned int freq, int dir) +{ + struct snd_soc_codec *codec = codec_dai->codec; + struct cs4271_private *cs4271 = snd_soc_codec_get_drvdata(codec); + unsigned int rates = 0; + unsigned int rate_min = -1; + unsigned int rate_max = 0; + unsigned int i; + + cs4271->mclk = freq; + + if (cs4271->mclk) { + for (i = 0; i < NUM_MCLK_RATIOS; i++) { + unsigned int rate = freq / cs4271_mode_ratios[i].ratio; + rates |= snd_pcm_rate_to_rate_bit(rate); + if (rate < rate_min) + rate_min = rate; + if (rate > rate_max) + rate_max = rate; + } + + rates &= ~SNDRV_PCM_RATE_KNOT; + + if (!rates) { + dev_err(codec->dev, "could not find a valid sample rate\n"); + return -EINVAL; + } + } else { + /* enable all possible rates */ + rates = SNDRV_PCM_RATE_8000_96000; + rate_min = 8000; + rate_max = 96000; + } + + codec_dai->playback.rates = rates; + codec_dai->playback.rate_min = rate_min; + codec_dai->playback.rate_max = rate_max; + + codec_dai->capture.rates = rates; + codec_dai->capture.rate_min = rate_min; + codec_dai->capture.rate_max = rate_max; + + return 0; +} + +/* + * cs4271_set_dai_fmt - configure the codec for the selected audio format + * @codec_dai: the codec DAI + * @format: a SND_SOC_DAIFMT_x value indicating the data format + * + * Currently, this function only supports SND_SOC_DAIFMT_I2S and + * SND_SOC_DAIFMT_LEFT_J. + */ +static int cs4271_set_dai_fmt(struct snd_soc_dai *codec_dai, + unsigned int format) +{ + struct snd_soc_codec *codec = codec_dai->codec; + struct cs4271_private *cs4271 = snd_soc_codec_get_drvdata(codec); + int ret = 0; + + /* set DAI format */ + switch (format & SND_SOC_DAIFMT_FORMAT_MASK) { + case SND_SOC_DAIFMT_I2S: + case SND_SOC_DAIFMT_LEFT_J: + cs4271->mode = format & SND_SOC_DAIFMT_FORMAT_MASK; + break; + default: + dev_err(codec->dev, "invalid dai format\n"); + ret = -EINVAL; + } + + /* set master/slave audio interface */ + switch (format & SND_SOC_DAIFMT_MASTER_MASK) { + case SND_SOC_DAIFMT_CBS_CFS: + cs4271->slave_mode = 1; + break; + case SND_SOC_DAIFMT_CBM_CFM: + cs4271->slave_mode = 0; + break; + default: + /* all other modes are unsupported by the hardware */ + ret = -EINVAL; + } + + return ret; +} + +/* + * cs4271_hw_params - program the CS4271 with the given hardware parameters. + * @substream: the audio stream + * @params: the hardware parameters to set + * @dai: the SOC DAI (ignored) + */ +static int cs4271_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params, + struct snd_soc_dai *dai) +{ + struct snd_soc_pcm_runtime *rtd = substream->private_data; + struct snd_soc_device *socdev = rtd->socdev; + struct snd_soc_codec *codec = socdev->card->codec; + struct cs4271_private *cs4271 = snd_soc_codec_get_drvdata(codec); + int ret; + unsigned int i, ratio; + + /* Figure out which MCLK/LRCK ratio to use */ + ratio = cs4271->mclk / params_rate(params); + + for (i = 0; i < NUM_MCLK_RATIOS; i++) + if (cs4271_mode_ratios[i].ratio == ratio) + break; + + if ((i == NUM_MCLK_RATIOS) || ((ratio == 1024) && (!cs4271->slave_mode))) { + dev_err(codec->dev, "could not find matching ratio\n"); + return -EINVAL; + } + + /* Set the sample rate */ + ret = snd_soc_read(codec, CS4271_MODE1); + ret &= ~(CS4271_MODE1_FUNCMODE_MASK | CS4271_MODE1_DIV_MASK | CS4271_MODE1_DAC_DIF_MASK); + ret |= cs4271_mode_ratios[i].speed_mode; + + if (cs4271->slave_mode) { + ret &= ~CS4271_MODE1_MASTER; + ret |= cs4271_mode_ratios[i].mclk_slave; + } + else { + ret |= CS4271_MODE1_MASTER; + ret |= cs4271_mode_ratios[i].mclk_master; + } + + switch (cs4271->mode) { + case SND_SOC_DAIFMT_I2S: + ret |= CS4271_MODE1_DAC_DIF_I2S; + break; + case SND_SOC_DAIFMT_LEFT_J: + ret |= CS4271_MODE1_DAC_DIF_LJ; + break; + default: + dev_err(codec->dev, "unknown dai format\n"); + return -EINVAL; + } + + ret = snd_soc_write(codec, CS4271_MODE1, ret); + if (ret < 0) { + dev_err(codec->dev, "Codec write failed\n"); + return ret; + } + + /* Set the DAI format */ + ret = snd_soc_read(codec, CS4271_ADCCTL); + ret &= ~CS4271_ADCCTL_ADC_DIF_MASK; + ret |= (cs4271->mode == SND_SOC_DAIFMT_I2S) ? CS4271_ADCCTL_ADC_DIF_I2S : CS4271_ADCCTL_ADC_DIF_LJ; + ret = snd_soc_write(codec, CS4271_ADCCTL, ret); + if (ret < 0) + dev_err(codec->dev, "Codec write failed\n"); + + return ret; +} + +/* + * cs4271_dai_mute - enable/disable the CS4271 external mute + * @dai: the SOC DAI + * @mute: 0 = disable mute, 1 = enable mute + */ +static int cs4271_dai_mute(struct snd_soc_dai *dai, int mute) +{ + struct snd_soc_codec *codec = dai->codec; + int ret1, ret2; + + ret1 = snd_soc_read(codec, CS4271_VOLA); + ret2 = snd_soc_read(codec, CS4271_VOLB); + + if (mute) { + ret1 |= CS4271_VOLA_MUTE; + ret2 |= CS4271_VOLB_MUTE; + } + else { + ret1 &= ~(CS4271_VOLA_MUTE); + ret2 &= ~(CS4271_VOLB_MUTE); + } + + ret1 = snd_soc_write(codec, CS4271_VOLA, ret1); + if (ret1) + return ret1; + return snd_soc_write(codec, CS4271_VOLB, ret2); +} + +/* + * A list of non-DAPM controls that the CS4271 supports + */ +static const char *cs4271_de_texts[] = {"None", "44.1KHz", "48KHz", "32KHz"}; +static const struct soc_enum cs4271_de_enum = + SOC_ENUM_SINGLE(CS4271_DACCTL, 4, 4, cs4271_de_texts); + +static const struct snd_kcontrol_new cs4271_snd_controls[] = { + SOC_DOUBLE_R("Master Playback Volume", CS4271_VOLA, CS4271_VOLB, 0, 0x7F, 1), + SOC_SINGLE("Digital Loopback Switch", CS4271_MODE2, 4, 1, 0), + SOC_SINGLE("Soft Ramp Switch", CS4271_DACVOL, 5, 1, 0), + SOC_SINGLE("Zero Cross Switch", CS4271_DACVOL, 4, 1, 0), + SOC_ENUM("De-emphasis filter", cs4271_de_enum), + SOC_SINGLE("Auto-Mute Switch", CS4271_DACCTL, 7, 1, 0), + SOC_SINGLE("Slow Roll Off Filter Switch", CS4271_DACCTL, 6, 1, 0), + SOC_SINGLE("Soft Volume Ramp-Up Switch", CS4271_DACCTL, 3, 1, 0), + SOC_SINGLE("Soft Ramp-Down Switch", CS4271_DACCTL, 2, 1, 0), + SOC_SINGLE("Left Channel Inversion Switch", CS4271_DACCTL, 1, 1, 0), + SOC_SINGLE("Right Channel Inversion Switch", CS4271_DACCTL, 0, 1, 0), + SOC_DOUBLE("Master Capture Switch", CS4271_ADCCTL, 3, 2, 1, 1), + SOC_SINGLE("Dither 16-Bit Data Switch", CS4271_ADCCTL, 5, 1, 0), + SOC_DOUBLE("High Pass Filter Switch", CS4271_ADCCTL, 1, 0, 1, 1), + SOC_DOUBLE_R("Master Playback Switch", CS4271_VOLA, CS4271_VOLB, 7, 1, 1), +}; + +/* + * cs4271_codec - global variable to store codec for the ASoC probe function + * + * For now, we also only allow cs4271_i2c_probe() to be run once. That means + * that we do not support more than one cs4271 device in the system, at least + * for now. + */ +static struct snd_soc_codec *cs4271_codec; + +static struct snd_soc_dai_ops cs4271_dai_ops = { + .hw_params = cs4271_hw_params, + .set_sysclk = cs4271_set_dai_sysclk, + .set_fmt = cs4271_set_dai_fmt, + .digital_mute = cs4271_dai_mute, +}; + +struct snd_soc_dai cs4271_dai = { + .name = "cs4271", + .playback = { + .stream_name = "Playback", + .channels_min = 2, + .channels_max = 2, + .rates = 0, + .formats = CS4271_FORMATS, + }, + .capture = { + .stream_name = "Capture", + .channels_min = 2, + .channels_max = 2, + .rates = 0, + .formats = CS4271_FORMATS, + }, + .ops = &cs4271_dai_ops, +}; +EXPORT_SYMBOL_GPL(cs4271_dai); + +/* + * This function writes all writeble registers from cache to codec. + * It's used te setup initial config and restore after suspend. + */ +static int cs4271_write_cache(struct snd_soc_codec *codec) +{ + int i, ret; + + for (i = CS4271_FIRSTREG; i <= CS4271_LASTREG; i++) { + ret = snd_soc_write(codec, i, snd_soc_read(codec, i)); + if (ret) + return ret; + } + + return 0; +} + +/* + * cs4271_probe - ASoC probe function + * @pdev: platform device + * + * This function is called when ASoC has all the pieces it needs to + * instantiate a sound driver. + * This function actually configure the codec, so MCLK must be enabled + * already and reset must be inactive. This is probably done by + * machine drivers. + */ +static int cs4271_probe(struct platform_device *pdev) +{ + struct snd_soc_device *socdev = platform_get_drvdata(pdev); + struct snd_soc_codec *codec = cs4271_codec; + int ret; + u8 *cache; + + /* Turn control port on and set power down mode for a while */ + ret = snd_soc_write(codec, CS4271_MODE2, CS4271_MODE2_CPEN | CS4271_MODE2_PDN); + if (ret < 0) { + dev_err(codec->dev, "Codec write failed\n"); + return ret; + } + + cache = codec->reg_cache; + /* + * Almost default power up configuration of codec, except auto + * mute feature which is turned off. + * We need to mask register address, because it contains + * SPI address also. + */ + cache[CS4271_MODE1 & 0xFF] = 0x00; + cache[CS4271_DACCTL & 0xFF] = 0x00; + cache[CS4271_DACVOL & 0xFF] = CS4271_DACVOL_ATAPI_AL_BR; + cache[CS4271_VOLA & 0xFF] = 0x00; + cache[CS4271_VOLB & 0xFF] = 0x00; + cache[CS4271_ADCCTL & 0xFF] = 0x00; + cache[CS4271_MODE2 & 0xFF] = CS4271_MODE2_CPEN; + + ret = cs4271_write_cache(codec); + if (ret < 0) { + dev_err(codec->dev, "Cache write failed\n"); + return ret; + } + + /* Connect the codec to the socdev. snd_soc_new_pcms() needs this. */ + socdev->card->codec = codec; + + /* Register PCMs */ + ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1); + if (ret < 0) { + dev_err(codec->dev, "failed to create pcms\n"); + return ret; + } + + /* Add the non-DAPM controls */ + ret = snd_soc_add_controls(codec, cs4271_snd_controls, + ARRAY_SIZE(cs4271_snd_controls)); + if (ret < 0) { + dev_err(codec->dev, "failed to add controls\n"); + goto error_free_pcms; + } + + return 0; + +error_free_pcms: + snd_soc_free_pcms(socdev); + + return ret; +} + +/* + * cs4271_remove - ASoC remove function + * @pdev: platform device + * + * This function is the counterpart to cs4271_probe(). + */ +static int cs4271_remove(struct platform_device *pdev) +{ + struct snd_soc_device *socdev = platform_get_drvdata(pdev); + + snd_soc_free_pcms(socdev); + + return 0; +}; + +#ifdef CONFIG_PM + +/* + * The codec's own power saving features are enabled in the suspend callback, + * and all registers are written back to the hardware when resuming. + */ +static int cs4271_soc_suspend(struct platform_device *pdev, pm_message_t mesg) +{ + struct snd_soc_codec *codec = cs4271_codec; + struct cs4271_private *cs4271 = snd_soc_codec_get_drvdata(codec); + int ret; + + ret = snd_soc_read(codec, CS4271_MODE2); + ret |= CS4271_MODE2_PDN; + + return snd_soc_write(codec, CS4271_MODE2, ret); +} + +static int cs4271_soc_resume(struct platform_device *pdev) +{ + struct snd_soc_codec *codec = cs4271_codec; + struct cs4271_private *cs4271 = snd_soc_codec_get_drvdata(codec); + int ret; + + ret = cs4271_write_cache(codec); + if (ret < 0) { + dev_err(pdev, "Cache write failed\n"); + return ret; + } + + /* ... then disable the power-down bits */ + ret = snd_soc_read(codec, CS4271_MODE2); + ret &= ~CS4271_MODE2_PDN; + + return snd_soc_write(codec, CS4271_MODE2, ret); +} +#else +#define cs4271_soc_suspend NULL +#define cs4271_soc_resume NULL +#endif /* CONFIG_PM */ + +/* + * ASoC codec device structure + * + * Assign this variable to the codec_dev field of the machine driver's + * snd_soc_device structure. + */ +struct snd_soc_codec_device soc_codec_device_cs4271 = { + .probe = cs4271_probe, + .remove = cs4271_remove, + .suspend = cs4271_soc_suspend, + .resume = cs4271_soc_resume, +}; +EXPORT_SYMBOL_GPL(soc_codec_device_cs4271); + +/* + * Serial bus independent probe function. It's called both for + * I2C and SPI -connected codecs. + */ +static int cs4271_bus_probe(struct device *dev, void *ctrl_data, int bus_type) +{ + struct cs4271_private *cs4271; + struct snd_soc_codec *codec; + int ret; + + /* + * For now, we only support one cs4271 device in the system. See the + * comment for cs4271_codec. + */ + if (cs4271_codec) { + dev_err(dev, "Only one CS4271 per board allowed\n"); + return -ENODEV; + } + + /* + * Allocate enough space for the snd_soc_codec structure + * and our private data together. + */ + cs4271 = kzalloc(sizeof(struct cs4271_private), GFP_KERNEL); + if (!cs4271) { + dev_err(dev, "Could not allocate codec\n"); + return -ENOMEM; + } + + dev_set_drvdata(dev, cs4271); + + codec = &cs4271->codec; + mutex_init(&codec->mutex); + INIT_LIST_HEAD(&codec->dapm_widgets); + INIT_LIST_HEAD(&codec->dapm_paths); + + codec->dev = dev; + codec->name = "CS4271"; + codec->owner = THIS_MODULE; + codec->dai = &cs4271_dai; + codec->num_dai = 1; + snd_soc_codec_set_drvdata(codec, cs4271); + codec->control_data = ctrl_data; + codec->reg_cache = cs4271->reg_cache; + codec->reg_cache_size = ARRAY_SIZE(cs4271->reg_cache); + + /* + * In case of I2C, chip address specified in board data. + * So cache IO operations use 8 bit codec register address. + * In case of SPI, chip address and register address + * passed together as 16 bit value. + * Anyway, register address is masked with 0xFF inside + * soc_cache code. + */ + ret = snd_soc_codec_set_cache_io(codec, + (bus_type == SND_SOC_SPI) ? 16 : 8, 8, bus_type); + if (ret) { + dev_err(dev, "Failed to set cache I/O: %d\n", ret); + goto error_free_codec; + } + + /* + * Initialize the DAI. Normally, we'd prefer to have a kmalloc'd DAI + * structure for each CS4271 device, but the machine driver needs to + * have a pointer to the DAI structure, so for now it must be a global + * variable. + */ + cs4271_dai.dev = dev; + + /* + * Register the DAI. If all the other ASoC driver have already + * registered, then this will call our probe function, so + * cs4271_codec needs to be ready. + */ + cs4271_codec = codec; + + ret = snd_soc_register_codec(codec); + if (ret) { + dev_err(dev, "Failed to register codec: %d\n", ret); + goto error_free_codec; + } + + ret = snd_soc_register_dai(&cs4271_dai); + if (ret) { + dev_err(dev, "failed to register DAI\n"); + goto error_reg; + } + + return 0; + +error_reg: + snd_soc_unregister_codec(codec); +error_free_codec: + kfree(cs4271); + cs4271_codec = NULL; + cs4271_dai.dev = NULL; + + return ret; +} + +static int cs4271_bus_remove(struct device *dev) +{ + struct cs4271_private *cs4271 = dev_get_drvdata(dev); + + snd_soc_unregister_dai(&cs4271_dai); + kfree(cs4271); + cs4271_codec = NULL; + cs4271_dai.dev = NULL; + + return 0; +} + + +#if defined(CONFIG_SPI_MASTER) + +static struct spi_device_id cs4271_spi_id[] = { + {"cs4271", 0}, + {} +}; +MODULE_DEVICE_TABLE(spi, cs4271_spi_id); + +static int __devinit cs4271_spi_probe(struct spi_device *spi) +{ + return cs4271_bus_probe(&spi->dev, spi, SND_SOC_SPI); +} + +static int __devexit cs4271_spi_remove(struct spi_device *spi) +{ + return cs4271_bus_remove(&spi->dev); +} + +static struct spi_driver cs4271_spi_driver = { + .driver = { + .name = "cs4271", + .owner = THIS_MODULE, + }, + .id_table = cs4271_spi_id, + .probe = cs4271_spi_probe, + .remove = __devexit_p(cs4271_spi_remove), +}; + +#endif + +#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE) +/* + * cs4271_id - I2C device IDs supported by this driver + */ +static struct i2c_device_id cs4271_i2c_id[] = { + {"cs4271", 0}, + {} +}; +MODULE_DEVICE_TABLE(i2c, cs4271_i2c_id); + +static int __devinit cs4271_i2c_probe(struct i2c_client *client, + const struct i2c_device_id *id) +{ + return cs4271_bus_probe(&client->dev, client, SND_SOC_I2C); +} + +static int __devexit cs4271_i2c_remove(struct i2c_client *client) +{ + return cs4271_bus_remove(&client->dev); +} + +/* + * cs4271_i2c_driver - I2C device identification + * + * This structure tells the I2C subsystem how to identify and support a + * given I2C device type. + */ +static struct i2c_driver cs4271_i2c_driver = { + .driver = { + .name = "cs4271", + .owner = THIS_MODULE, + }, + .id_table = cs4271_i2c_id, + .probe = cs4271_i2c_probe, + .remove = __devexit_p(cs4271_i2c_remove), +}; + +#endif + +/* + * We only register our serial bus driver here without + * assignment to particular chip. So if any of the below + * fails, there is some problem with I2C or SPI subsystem. + * In most cases this module will be compiled with support + * of only one serial bus. + */ +static int __init cs4271_modinit(void) +{ + int ret; + +#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE) + ret = i2c_add_driver(&cs4271_i2c_driver); + if (ret) { + pr_err("Failed to register CS4271 I2C driver: %d\n", ret); + return ret; + } +#endif + +#if defined(CONFIG_SPI_MASTER) + ret = spi_register_driver(&cs4271_spi_driver); + if (ret) { + pr_err("Failed to register CS4271 SPI driver: %d\n", ret); + return ret; + } +#endif + + return 0; +} +module_init(cs4271_modinit); + +static void __exit cs4271_modexit(void) +{ +#if defined(CONFIG_SPI_MASTER) + spi_unregister_driver(&cs4271_spi_driver); +#endif + +#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE) + i2c_del_driver(&cs4271_i2c_driver); +#endif +} +module_exit(cs4271_modexit); + +MODULE_AUTHOR("Alexander Sverdlin subaparts@yandex.ru"); +MODULE_DESCRIPTION("Cirrus Logic CS4271 ALSA SoC Codec Driver"); +MODULE_LICENSE("GPL"); diff --git a/sound/soc/codecs/cs4271.h b/sound/soc/codecs/cs4271.h new file mode 100644 index 0000000..7cf6af2 --- /dev/null +++ b/sound/soc/codecs/cs4271.h @@ -0,0 +1,27 @@ +/* + * Cirrus Logic CS4271 ALSA SoC Codec Driver + * + * Copyright (c) 2010 Alexander Sverdlin subaparts@yandex.ru + * + * This file is licensed under the terms of the GNU General Public License + * version 2. This program is licensed "as is" without any warranty of any + * kind, whether express or implied. + */ + +#ifndef _CS4271_H +#define _CS4271_H + +/* + * The ASoC codec DAI structure for the CS4271. Assign this structure to + * the .codec_dai field of your machine driver's snd_soc_dai_link structure. + */ +extern struct snd_soc_dai cs4271_dai; + +/* + * The ASoC codec device structure for the CS4271. Assign this structure + * to the .codec_dev field of your machine driver's snd_soc_device + * structure. + */ +extern struct snd_soc_codec_device soc_codec_device_cs4271; + +#endif