Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound-2.6

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound-2.6: (214 commits)
  ALSA: hda - Add pin-fix for HP dc5750
  ALSA: als4000: Fix potentially invalid DMA mode setup
  ALSA: als4000: enable burst mode
  ALSA: hda - Fix initial capsrc selection in patch_alc269()
  ASoC: TWL4030: Capture route runtime DAPM ordering fix
  ALSA: hda - Add PC-beep whitelist for an Intel board
  ALSA: hda - More relax for pending period handling
  ALSA: hda - Define AC_FMT_* constants
  ALSA: hda - Fix beep frequency on IDT 92HD73xx and 92HD71Bxx codecs
  ALSA: hda - Add support for HDMI HBR passthrough
  ALSA: hda - Set Stream Type in Stream Format according to AES0
  ALSA: hda - Fix Thinkpad X300 so SPDIF is not exposed
  ALSA: hda - FIX to not expose SPDIF on Thinkpad X301, since it does not have the ability to use SPDIF
  ASoC: wm9081: fix resource reclaim in wm9081_register error path
  ASoC: wm8978: fix a memory leak if a wm8978_register fail
  ASoC: wm8974: fix a memory leak if another WM8974 is registered
  ASoC: wm8961: fix resource reclaim in wm8961_register error path
  ASoC: wm8955: fix resource reclaim in wm8955_register error path
  ASoC: wm8940: fix a memory leak if wm8940_register return error
  ASoC: wm8904: fix resource reclaim in wm8904_register error path
  ...

6 files changed, 165 insertions, 21 deletions

diff --git a/sound/soc/davinci/davinci-i2s.c b/sound/soc/davinci/davinci-i2s.c
index adadcd3aa1b1..9e8932abf158 100644
--- a/sound/soc/davinci/davinci-i2s.c
+++ b/sound/soc/davinci/davinci-i2s.c
@@ -26,6 +26,7 @@
 #include <mach/asp.h>
 
 #include "davinci-pcm.h"
+#include "davinci-i2s.h"
 
 
 /*
@@ -68,16 +69,21 @@
 #define DAVINCI_MCBSP_RCR_RDATDLY(v)    ((v) << 16)
 #define DAVINCI_MCBSP_RCR_RFIG          (1 << 18)
 #define DAVINCI_MCBSP_RCR_RWDLEN2(v)    ((v) << 21)
+#define DAVINCI_MCBSP_RCR_RFRLEN2(v)    ((v) << 24)
+#define DAVINCI_MCBSP_RCR_RPHASE        BIT(31)
 
 #define DAVINCI_MCBSP_XCR_XWDLEN1(v)    ((v) << 5)
 #define DAVINCI_MCBSP_XCR_XFRLEN1(v)    ((v) << 8)
 #define DAVINCI_MCBSP_XCR_XDATDLY(v)    ((v) << 16)
 #define DAVINCI_MCBSP_XCR_XFIG          (1 << 18)
 #define DAVINCI_MCBSP_XCR_XWDLEN2(v)    ((v) << 21)
+#define DAVINCI_MCBSP_XCR_XFRLEN2(v)    ((v) << 24)
+#define DAVINCI_MCBSP_XCR_XPHASE        BIT(31)
 
 #define DAVINCI_MCBSP_SRGR_FWID(v)      ((v) << 8)
 #define DAVINCI_MCBSP_SRGR_FPER(v)      ((v) << 16)
 #define DAVINCI_MCBSP_SRGR_FSGM         (1 << 28)
+#define DAVINCI_MCBSP_SRGR_CLKSM        BIT(29)
 
 #define DAVINCI_MCBSP_PCR_CLKRP         (1 << 0)
 #define DAVINCI_MCBSP_PCR_CLKXP         (1 << 1)
@@ -116,6 +122,7 @@ static const unsigned char double_fmt[SNDRV_PCM_FORMAT_S32_LE + 1] = {
 };
 
 struct davinci_mcbsp_dev {
+        struct device *dev;
         struct davinci_pcm_dma_params   dma_params[2];
         void __iomem                    *base;
 #define MOD_DSP_A       0
@@ -144,6 +151,11 @@ struct davinci_mcbsp_dev {
          * won't end up being swapped because of the underrun.
          */
         unsigned enable_channel_combine:1;
+
+        unsigned int fmt;
+        int clk_div;
+        int clk_input_pin;
+        bool i2s_accurate_sck;
 };
 
 static inline void davinci_mcbsp_write_reg(struct davinci_mcbsp_dev *dev,
@@ -254,10 +266,12 @@ static int davinci_i2s_set_dai_fmt(struct snd_soc_dai *cpu_dai,
         struct davinci_mcbsp_dev *dev = cpu_dai->private_data;
         unsigned int pcr;
         unsigned int srgr;
+        /* Attention srgr is updated by hw_params! */
         srgr = DAVINCI_MCBSP_SRGR_FSGM |
                 DAVINCI_MCBSP_SRGR_FPER(DEFAULT_BITPERSAMPLE * 2 - 1) |
                 DAVINCI_MCBSP_SRGR_FWID(DEFAULT_BITPERSAMPLE - 1);
 
+        dev->fmt = fmt;
         /* set master/slave audio interface */
         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
         case SND_SOC_DAIFMT_CBS_CFS:
@@ -268,11 +282,26 @@ static int davinci_i2s_set_dai_fmt(struct snd_soc_dai *cpu_dai,
                         DAVINCI_MCBSP_PCR_CLKRM;
                 break;
         case SND_SOC_DAIFMT_CBM_CFS:
-                /* McBSP CLKR pin is the input for the Sample Rate Generator.
-                 * McBSP FSR and FSX are driven by the Sample Rate Generator. */
-                pcr = DAVINCI_MCBSP_PCR_SCLKME |
-                        DAVINCI_MCBSP_PCR_FSXM |
-                        DAVINCI_MCBSP_PCR_FSRM;
+                pcr = DAVINCI_MCBSP_PCR_FSRM | DAVINCI_MCBSP_PCR_FSXM;
+                /*
+                 * Selection of the clock input pin that is the
+                 * input for the Sample Rate Generator.
+                 * McBSP FSR and FSX are driven by the Sample Rate
+                 * Generator.
+                 */
+                switch (dev->clk_input_pin) {
+                case MCBSP_CLKS:
+                        pcr |= DAVINCI_MCBSP_PCR_CLKXM |
+                                DAVINCI_MCBSP_PCR_CLKRM;
+                        break;
+                case MCBSP_CLKR:
+                        pcr |= DAVINCI_MCBSP_PCR_SCLKME;
+                        break;
+                default:
+                        dev_err(dev->dev, "bad clk_input_pin\n");
+                        return -EINVAL;
+                }
+
                 break;
         case SND_SOC_DAIFMT_CBM_CFM:
                 /* codec is master */
@@ -372,6 +401,18 @@ static int davinci_i2s_set_dai_fmt(struct snd_soc_dai *cpu_dai,
         return 0;
 }
 
+static int davinci_i2s_dai_set_clkdiv(struct snd_soc_dai *cpu_dai,
+                                int div_id, int div)
+{
+        struct davinci_mcbsp_dev *dev = cpu_dai->private_data;
+
+        if (div_id != DAVINCI_MCBSP_CLKGDV)
+                return -ENODEV;
+
+        dev->clk_div = div;
+        return 0;
+}
+
 static int davinci_i2s_hw_params(struct snd_pcm_substream *substream,
                                  struct snd_pcm_hw_params *params,
                                  struct snd_soc_dai *dai)
@@ -380,8 +421,8 @@ static int davinci_i2s_hw_params(struct snd_pcm_substream *substream,
         struct davinci_pcm_dma_params *dma_params =
                                         &dev->dma_params[substream->stream];
         struct snd_interval *i = NULL;
-        int mcbsp_word_length;
-        unsigned int rcr, xcr, srgr;
+        int mcbsp_word_length, master;
+        unsigned int rcr, xcr, srgr, clk_div, freq, framesize;
         u32 spcr;
         snd_pcm_format_t fmt;
         unsigned element_cnt = 1;
@@ -396,12 +437,59 @@ static int davinci_i2s_hw_params(struct snd_pcm_substream *substream,
                 davinci_mcbsp_write_reg(dev, DAVINCI_MCBSP_SPCR_REG, spcr);
         }
 
-        i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS);
-        srgr = DAVINCI_MCBSP_SRGR_FSGM;
-        srgr |= DAVINCI_MCBSP_SRGR_FWID(snd_interval_value(i) - 1);
+        master = dev->fmt & SND_SOC_DAIFMT_MASTER_MASK;
+        fmt = params_format(params);
+        mcbsp_word_length = asp_word_length[fmt];
 
-        i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_FRAME_BITS);
-        srgr |= DAVINCI_MCBSP_SRGR_FPER(snd_interval_value(i) - 1);
+        switch (master) {
+        case SND_SOC_DAIFMT_CBS_CFS:
+                freq = clk_get_rate(dev->clk);
+                srgr = DAVINCI_MCBSP_SRGR_FSGM |
+                       DAVINCI_MCBSP_SRGR_CLKSM;
+                srgr |= DAVINCI_MCBSP_SRGR_FWID(mcbsp_word_length *
+                                                8 - 1);
+                if (dev->i2s_accurate_sck) {
+                        clk_div = 256;
+                        do {
+                                framesize = (freq / (--clk_div)) /
+                                params->rate_num *
+                                        params->rate_den;
+                        } while (((framesize < 33) || (framesize > 4095)) &&
+                                 (clk_div));
+                        clk_div--;
+                        srgr |= DAVINCI_MCBSP_SRGR_FPER(framesize - 1);
+                } else {
+                        /* symmetric waveforms */
+                        clk_div = freq / (mcbsp_word_length * 16) /
+                                  params->rate_num * params->rate_den;
+                        srgr |= DAVINCI_MCBSP_SRGR_FPER(mcbsp_word_length *
+                                                        16 - 1);
+                }
+                clk_div &= 0xFF;
+                srgr |= clk_div;
+                break;
+        case SND_SOC_DAIFMT_CBM_CFS:
+                srgr = DAVINCI_MCBSP_SRGR_FSGM;
+                clk_div = dev->clk_div - 1;
+                srgr |= DAVINCI_MCBSP_SRGR_FWID(mcbsp_word_length * 8 - 1);
+                srgr |= DAVINCI_MCBSP_SRGR_FPER(mcbsp_word_length * 16 - 1);
+                clk_div &= 0xFF;
+                srgr |= clk_div;
+                break;
+        case SND_SOC_DAIFMT_CBM_CFM:
+                /* Clock and frame sync given from external sources */
+                i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS);
+                srgr = DAVINCI_MCBSP_SRGR_FSGM;
+                srgr |= DAVINCI_MCBSP_SRGR_FWID(snd_interval_value(i) - 1);
+                pr_debug("%s - %d  FWID set: re-read srgr = %X\n",
+                        __func__, __LINE__, snd_interval_value(i) - 1);
+
+                i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_FRAME_BITS);
+                srgr |= DAVINCI_MCBSP_SRGR_FPER(snd_interval_value(i) - 1);
+                break;
+        default:
+                return -EINVAL;
+        }
         davinci_mcbsp_write_reg(dev, DAVINCI_MCBSP_SRGR_REG, srgr);
 
         rcr = DAVINCI_MCBSP_RCR_RFIG;
@@ -426,12 +514,41 @@ static int davinci_i2s_hw_params(struct snd_pcm_substream *substream,
                         element_cnt = 1;
                         fmt = double_fmt[fmt];
                 }
+                switch (master) {
+                case SND_SOC_DAIFMT_CBS_CFS:
+                case SND_SOC_DAIFMT_CBS_CFM:
+                        rcr |= DAVINCI_MCBSP_RCR_RFRLEN2(0);
+                        xcr |= DAVINCI_MCBSP_XCR_XFRLEN2(0);
+                        rcr |= DAVINCI_MCBSP_RCR_RPHASE;
+                        xcr |= DAVINCI_MCBSP_XCR_XPHASE;
+                        break;
+                case SND_SOC_DAIFMT_CBM_CFM:
+                case SND_SOC_DAIFMT_CBM_CFS:
+                        rcr |= DAVINCI_MCBSP_RCR_RFRLEN2(element_cnt - 1);
+                        xcr |= DAVINCI_MCBSP_XCR_XFRLEN2(element_cnt - 1);
+                        break;
+                default:
+                        return -EINVAL;
+                }
         }
         dma_params->acnt = dma_params->data_type = data_type[fmt];
         dma_params->fifo_level = 0;
         mcbsp_word_length = asp_word_length[fmt];
-        rcr |= DAVINCI_MCBSP_RCR_RFRLEN1(element_cnt - 1);
-        xcr |= DAVINCI_MCBSP_XCR_XFRLEN1(element_cnt - 1);
+
+        switch (master) {
+        case SND_SOC_DAIFMT_CBS_CFS:
+        case SND_SOC_DAIFMT_CBS_CFM:
+                rcr |= DAVINCI_MCBSP_RCR_RFRLEN1(0);
+                xcr |= DAVINCI_MCBSP_XCR_XFRLEN1(0);
+                break;
+        case SND_SOC_DAIFMT_CBM_CFM:
+        case SND_SOC_DAIFMT_CBM_CFS:
+                rcr |= DAVINCI_MCBSP_RCR_RFRLEN1(element_cnt - 1);
+                xcr |= DAVINCI_MCBSP_XCR_XFRLEN1(element_cnt - 1);
+                break;
+        default:
+                return -EINVAL;
+        }
 
         rcr |= DAVINCI_MCBSP_RCR_RWDLEN1(mcbsp_word_length) |
                 DAVINCI_MCBSP_RCR_RWDLEN2(mcbsp_word_length);
@@ -442,6 +559,10 @@ static int davinci_i2s_hw_params(struct snd_pcm_substream *substream,
                 davinci_mcbsp_write_reg(dev, DAVINCI_MCBSP_XCR_REG, xcr);
         else
                 davinci_mcbsp_write_reg(dev, DAVINCI_MCBSP_RCR_REG, rcr);
+
+        pr_debug("%s - %d  srgr=%X\n", __func__, __LINE__, srgr);
+        pr_debug("%s - %d  xcr=%X\n", __func__, __LINE__, xcr);
+        pr_debug("%s - %d  rcr=%X\n", __func__, __LINE__, rcr);
         return 0;
 }
 
@@ -500,6 +621,7 @@ static struct snd_soc_dai_ops davinci_i2s_dai_ops = {
         .trigger        = davinci_i2s_trigger,
         .hw_params      = davinci_i2s_hw_params,
         .set_fmt        = davinci_i2s_set_dai_fmt,
+        .set_clkdiv     = davinci_i2s_dai_set_clkdiv,
 
 };
 
@@ -526,6 +648,8 @@ static int davinci_i2s_probe(struct platform_device *pdev)
         struct snd_platform_data *pdata = pdev->dev.platform_data;
         struct davinci_mcbsp_dev *dev;
         struct resource *mem, *ioarea, *res;
+        enum dma_event_q asp_chan_q = EVENTQ_0;
+        enum dma_event_q ram_chan_q = EVENTQ_1;
         int ret;
 
         mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -552,7 +676,17 @@ static int davinci_i2s_probe(struct platform_device *pdev)
                         pdata->sram_size_playback;
                 dev->dma_params[SNDRV_PCM_STREAM_CAPTURE].sram_size =
                         pdata->sram_size_capture;
+                dev->clk_input_pin = pdata->clk_input_pin;
+                dev->i2s_accurate_sck = pdata->i2s_accurate_sck;
+                asp_chan_q = pdata->asp_chan_q;
+                ram_chan_q = pdata->ram_chan_q;
         }
+
+        dev->dma_params[SNDRV_PCM_STREAM_PLAYBACK].asp_chan_q   = asp_chan_q;
+        dev->dma_params[SNDRV_PCM_STREAM_PLAYBACK].ram_chan_q   = ram_chan_q;
+        dev->dma_params[SNDRV_PCM_STREAM_CAPTURE].asp_chan_q    = asp_chan_q;
+        dev->dma_params[SNDRV_PCM_STREAM_CAPTURE].ram_chan_q    = ram_chan_q;
+
         dev->clk = clk_get(&pdev->dev, NULL);
         if (IS_ERR(dev->clk)) {
                 ret = -ENODEV;
@@ -584,6 +718,7 @@ static int davinci_i2s_probe(struct platform_device *pdev)
                 goto err_free_mem;
         }
         dev->dma_params[SNDRV_PCM_STREAM_CAPTURE].channel = res->start;
+        dev->dev = &pdev->dev;
 
         davinci_i2s_dai.private_data = dev;
         davinci_i2s_dai.capture.dma_data = dev->dma_params;
diff --git a/sound/soc/davinci/davinci-i2s.h b/sound/soc/davinci/davinci-i2s.h
index 241648ce8873..0b1e77b8c279 100644
--- a/sound/soc/davinci/davinci-i2s.h
+++ b/sound/soc/davinci/davinci-i2s.h
@@ -12,6 +12,11 @@
 #ifndef _DAVINCI_I2S_H
 #define _DAVINCI_I2S_H
 
+/* McBSP dividers */
+enum davinci_mcbsp_div {
+        DAVINCI_MCBSP_CLKGDV,              /* Sample rate generator divider */
+};
+
 extern struct snd_soc_dai davinci_i2s_dai;
 
 #endif
diff --git a/sound/soc/davinci/davinci-mcasp.c b/sound/soc/davinci/davinci-mcasp.c
index d3955096d872..b24720894af6 100644
--- a/sound/soc/davinci/davinci-mcasp.c
+++ b/sound/soc/davinci/davinci-mcasp.c
@@ -890,7 +890,8 @@ static int davinci_mcasp_probe(struct platform_device *pdev)
         dev->rxnumevt = pdata->rxnumevt;
 
         dma_data = &dev->dma_params[SNDRV_PCM_STREAM_PLAYBACK];
-        dma_data->eventq_no = pdata->eventq_no;
+        dma_data->asp_chan_q = pdata->asp_chan_q;
+        dma_data->ram_chan_q = pdata->ram_chan_q;
         dma_data->dma_addr = (dma_addr_t) (pdata->tx_dma_offset +
                                                         io_v2p(dev->base));
 
@@ -904,7 +905,8 @@ static int davinci_mcasp_probe(struct platform_device *pdev)
         dma_data->channel = res->start;
 
         dma_data = &dev->dma_params[SNDRV_PCM_STREAM_CAPTURE];
-        dma_data->eventq_no = pdata->eventq_no;
+        dma_data->asp_chan_q = pdata->asp_chan_q;
+        dma_data->ram_chan_q = pdata->ram_chan_q;
         dma_data->dma_addr = (dma_addr_t)(pdata->rx_dma_offset +
                                                         io_v2p(dev->base));
 
diff --git a/sound/soc/davinci/davinci-pcm.c b/sound/soc/davinci/davinci-pcm.c
index 2dc406f42fe7..a7124116d2e0 100644
--- a/sound/soc/davinci/davinci-pcm.c
+++ b/sound/soc/davinci/davinci-pcm.c
@@ -381,7 +381,7 @@ static int request_ping_pong(struct snd_pcm_substream *substream,
         /* Request ram master channel */
         link = prtd->ram_channel = edma_alloc_channel(EDMA_CHANNEL_ANY,
                                   davinci_pcm_dma_irq, substream,
-                                  EVENTQ_1);
+                                  prtd->params->ram_chan_q);
         if (link < 0)
                 goto exit1;
 
@@ -477,7 +477,8 @@ static int davinci_pcm_dma_request(struct snd_pcm_substream *substream)
 
         /* Request asp master DMA channel */
         link = prtd->asp_channel = edma_alloc_channel(params->channel,
-                        davinci_pcm_dma_irq, substream, EVENTQ_0);
+                        davinci_pcm_dma_irq, substream,
+                        prtd->params->asp_chan_q);
         if (link < 0)
                 goto exit1;
 
@@ -800,7 +801,7 @@ static void davinci_pcm_free(struct snd_pcm *pcm)
                 dma_free_writecombine(pcm->card->dev, buf->bytes,
                                       buf->area, buf->addr);
                 buf->area = NULL;
-                iram_dma = (struct snd_dma_buffer *)buf->private_data;
+                iram_dma = buf->private_data;
                 if (iram_dma) {
                         sram_free(iram_dma->area, iram_dma->bytes);
                         kfree(iram_dma);
diff --git a/sound/soc/davinci/davinci-pcm.h b/sound/soc/davinci/davinci-pcm.h
index 0764944cf10f..b799a02333d8 100644
--- a/sound/soc/davinci/davinci-pcm.h
+++ b/sound/soc/davinci/davinci-pcm.h
@@ -21,7 +21,8 @@ struct davinci_pcm_dma_params {
         unsigned short acnt;
         dma_addr_t dma_addr;            /* device physical address for DMA */
         unsigned sram_size;
-        enum dma_event_q eventq_no;     /* event queue number */
+        enum dma_event_q asp_chan_q;    /* event queue number for ASP channel */
+        enum dma_event_q ram_chan_q;    /* event queue number for RAM channel */
         unsigned char data_type;        /* xfer data type */
         unsigned char convert_mono_stereo;
         unsigned int fifo_level;
diff --git a/sound/soc/davinci/davinci-vcif.c b/sound/soc/davinci/davinci-vcif.c
index 9aa980d38231..48678533da7a 100644
--- a/sound/soc/davinci/davinci-vcif.c
+++ b/sound/soc/davinci/davinci-vcif.c
@@ -203,7 +203,7 @@ static int davinci_vcif_probe(struct platform_device *pdev)
         int ret;
 
         davinci_vcif_dev = kzalloc(sizeof(struct davinci_vcif_dev), GFP_KERNEL);
-        if (!davinci_vc) {
+        if (!davinci_vcif_dev) {
                 dev_dbg(&pdev->dev,
                         "could not allocate memory for private data\n");
                 return -ENOMEM;