gmane.linux.alsa.devel

Dynamic PCM and Tegra AHUB

Stephen Warren — 2012-05-26T00:23:48

Mark, Liam,

Tegra30's AHUB is structured as follows:


Notes on the diagram:

Each FIFO above is a separate TX and RX FIFO. I merged them in the
drawing for simplicity, but they operate completely independently;
different memory packing formats, data flow rates, ...

The CIF can convert the audio format, e.g. mono<->stereo conversion and
change the # of bits in the data in pretty arbitrary combinations. This
is true for all CIFs; those that join the AHUB core to either the DMA
FIFOs or the I2S/SPDIF/DAM controllers.

The AHUB core is a complete cross-bar; each output selects 1 of the n
inputs.

The I2S and SPDIF controllers take audio from the AHUB, format it to the
appropriate protocol, and send to external IO (or the other way around).
The I2S and SPDIF modules don't perform any additional data
rate/width/channel conversion; the CIF must do whatever conversions are
needed.

The DAMs take 2 input channels from the AHUB, optionally perform some
sample rate conversion and/or bit size conversion beyond what the CIF
does, mix them together, and send them back into the AHUB cross-bar.

Questions:

It seems like the whole point of ASoC dynamic PCM is to represent the
AHUB core, and at least some of the surrounding boxes above, as an ASoC
CODEC.

Initially, I would assume the AHUB CODEC's DAIs would be the DMA FIFOs
and the I2S* controllers themselves, i.e. include everything in the
above diagram.

If I do that, then the dai_links that the ASoC machine driver registers
for I2S->WM8903 would represent a codec DAI <-> codec DAI link rather
than a regular CPU DAI <-> codec DAI link. The difference here is the
lack of symmetry in struct snd_soc_dai_link: The CPU-side of each DAI
link only has a "cpu_dai_name" to identify it, whereas the codec side
has both a codec_name (or of node) /plus/ a DAI name. This is important
at least in the context of device tree, where to avoid hard-coding
specific device names into the dai_link structure's .codec_name field in
the machine driver, an of_node is looked up at run-time instead, and
then the codec_dai_name interpreted relative to that. Without a CPU-side
separation between name/node and dai_name, that's not possible. So, I
sent a patch for that in case this is the right approach.

An alternative to expanding struct snd_soc_dai_link might be to add an
API so the machine driver could ask the AHUB driver for the
globally-unique name of each DAI it exposes, and write that into
dai_link.cpu_dai_name. But if we have that API, we could use it for the
codec-side of the link to, and just have .codec_dai_name and remove the
.codec_name and .codec_of_node fields.

Alternatively, perhaps the DMA FIFOs should be registered as CPU DAIs
completely separately from the AHUB CODEC. The AHUB CIFs would then be
the DAIs registered by the AHUB CODEC. But then, the machine driver
would need to include dai_links for all the DMA FIFO <-> CIF
connections, which would end up duplicating that list of links into all
Tegra machine drives (or perhaps sharing it in common code).

Very curious for your thoughts...

Help requested: new HSS1394 MIDI back-end

Sean M. Pappalardo - D.J. Pegasus — 2012-05-25T19:43:17

Hello everyone.

I am a developer for Mixxx, GPL cross-platform digital DJ software: 
http://www.mixxx.org. My focus is the controller subsystem. I am ready 
to finally add Linux support for HSS1394 DJ controllers such as 
Stanton's SCS.1m and SCS.1d.

HSS1394 is just MIDI over IEEE1394 (Firewire) at wire speed. The Windows 
and OSX library source code is LGPL and available on LaunchPad here: 
https://launchpad.net/hss1394

The Stanton SCS.1m is a sound interface integrated with a two-way 
control surface that speaks HSS1394. (The sound card uses an Oxford chip 
set and works fine with FFADO 2.0.1 today up to 96kHz. I use it with 
Mixxx via JACK.)

The Stanton SCS.1d is a two-way control surface (no sound card) that 
speaks HSS1394 and is capable of sending ALOT of latency-sensitive data: 
about 4000 messages per platter rotation. (Now imagine if you had four 
or even two of them on the same network running at +50% speed. This 
would quickly overwhelm USB, at least at the time these devices were 
designed.)

Read about them here:
http://www.stantondj.com/stanton-controllers-systems/system1.html

After a lengthy discussion on the FFADO mailing list, we determined that 
the best (cleanest and most flexible) way to get Linux support for these 
devices is to write an ALSA kernel driver that speaks HSS1394 with the 
devices and presents an ALSA MIDI device (with no data rate limits) for 
each to Linux applications.

The advantage of doing this is that the devices will appear to all MIDI 
applications without them having to have specific support for HSS1394. 
This means they could be used in DAW applications as well.

(FWIW, FFADO trunk has a program called test-scs that does exactly this, 
but using that is impractical because it depends on various internal 
parts of the FFADO source so would require bundling all of FFADO with 
the application, and it's unable to see non-audio devices due to FFADO's 
intended use (so it sees the SCS.1m but not the .1d.))

So my questions are: where can I find documentation on writing a new 
MIDI driver for ALSA? And is anyone else interested in helping me do this?

Thank you very much for your time and work. Help me take the last step 
to my dream DJ setup! (Linux, FLAC and SCS.1 controllers.)

Sincerely,
Sean M. Pappalardo
"D.J. Pegasus"
Mixxx Developer - Controller Specialist

[PATCH] ASoC: fsi: use PIO handler if DMA handler wasinvalid

Kuninori Morimoto — 2012-05-25T06:56:19

PIO handler is not good performance, but works on all platform.
So, switch to PIO handler if DMA handler was invalid case.

Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx< at >renesas.com>
---
 sound/soc/sh/fsi.c |   29 ++++++++++++++++++++---------
 1 files changed, 20 insertions(+), 9 deletions(-)

diff --git a/sound/soc/sh/fsi.c b/sound/soc/sh/fsi.c
index 05582c1..0da021a 100644
--- a/sound/soc/sh/fsi.c
+++ b/sound/soc/sh/fsi.c
< at >< at > -247,7 +247,7 < at >< at > struct fsi_priv {
 struct fsi_stream_handler {
 int (*init)(struct fsi_priv *fsi, struct fsi_stream *io);
 int (*quit)(struct fsi_priv *fsi, struct fsi_stream *io);
-int (*probe)(struct fsi_priv *fsi, struct fsi_stream *io);
+int (*probe)(struct fsi_priv *fsi, struct fsi_stream *io, struct device *dev);
 int (*transfer)(struct fsi_priv *fsi, struct fsi_stream *io);
 int (*remove)(struct fsi_priv *fsi, struct fsi_stream *io);
 void (*start_stop)(struct fsi_priv *fsi, struct fsi_stream *io,
< at >< at > -571,16 +571,16 < at >< at > static int fsi_stream_transfer(struct fsi_stream *io)
 #define fsi_stream_stop(fsi, io)\
 fsi_stream_handler_call(io, start_stop, fsi, io, 0)
 
-static int fsi_stream_probe(struct fsi_priv *fsi)
+static int fsi_stream_probe(struct fsi_priv *fsi, struct device *dev)
 {
 struct fsi_stream *io;
 int ret1, ret2;
 
 io = &fsi->playback;
-ret1 = fsi_stream_handler_call(io, probe, fsi, io);
+ret1 = fsi_stream_handler_call(io, probe, fsi, io, dev);
 
 io = &fsi->capture;
-ret2 = fsi_stream_handler_call(io, probe, fsi, io);
+ret2 = fsi_stream_handler_call(io, probe, fsi, io, dev);
 
 if (ret1 < 0)
 return ret1;
< at >< at > -1182,7 +1182,7 < at >< at > static void fsi_dma_push_start_stop(struct fsi_priv *fsi, struct fsi_stream *io,
 fsi_master_mask_set(master, CLK_RST, clk, (enable) ? clk : 0);
 }
 
-static int fsi_dma_probe(struct fsi_priv *fsi, struct fsi_stream *io)
+static int fsi_dma_probe(struct fsi_priv *fsi, struct fsi_stream *io, struct device *dev)
 {
 dma_cap_mask_t mask;
 
< at >< at > -1190,8 +1190,19 < at >< at > static int fsi_dma_probe(struct fsi_priv *fsi, struct fsi_stream *io)
 dma_cap_set(DMA_SLAVE, mask);
 
 io->chan = dma_request_channel(mask, fsi_dma_filter, &io->slave);
-if (!io->chan)
-return -EIO;
+if (!io->chan) {
+
+/* switch to PIO handler */
+if (fsi_stream_is_play(fsi, io))
+fsi->playback.handler= &fsi_pio_push_handler;
+else
+fsi->capture.handler= &fsi_pio_pop_handler;
+
+dev_info(dev, "switch handler (dma => pio)\n");
+
+/* probe again */
+return fsi_stream_probe(fsi, dev);
+}
 
 tasklet_init(&io->tasklet, fsi_dma_do_tasklet, (unsigned long)io);
 
< at >< at > -1681,7 +1692,7 < at >< at > static int fsi_probe(struct platform_device *pdev)
 master->fsia.master= master;
 master->fsia.info= &info->port_a;
 fsi_handler_init(&master->fsia);
-ret = fsi_stream_probe(&master->fsia);
+ret = fsi_stream_probe(&master->fsia, &pdev->dev);
 if (ret < 0) {
 dev_err(&pdev->dev, "FSIA stream probe failed\n");
 goto exit_iounmap;
< at >< at > -1692,7 +1703,7 < at >< at > static int fsi_probe(struct platform_device *pdev)
 master->fsib.master= master;
 master->fsib.info= &info->port_b;
 fsi_handler_init(&master->fsib);
-ret = fsi_stream_probe(&master->fsib);
+ret = fsi_stream_probe(&master->fsib, &pdev->dev);
 if (ret < 0) {
 dev_err(&pdev->dev, "FSIB stream probe failed\n");
 goto exit_fsia;

[PATCH] ASoC: fsi: bugfix: enable master clock controlon DMA stream

Kuninori Morimoto — 2012-05-25T06:55:11

DMA stream handler didn't care about master clock.
This patch fixes it up.

Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx< at >renesas.com>
---
 sound/soc/sh/fsi.c |    5 +++++
 1 files changed, 5 insertions(+), 0 deletions(-)

diff --git a/sound/soc/sh/fsi.c b/sound/soc/sh/fsi.c
index 7cee225..05582c1 100644
--- a/sound/soc/sh/fsi.c
+++ b/sound/soc/sh/fsi.c
< at >< at > -1172,9 +1172,14 < at >< at > static int fsi_dma_transfer(struct fsi_priv *fsi, struct fsi_stream *io)
 static void fsi_dma_push_start_stop(struct fsi_priv *fsi, struct fsi_stream *io,
  int start)
 {
+struct fsi_master *master = fsi_get_master(fsi);
+u32 clk  = fsi_is_port_a(fsi) ? CRA  : CRB;
 u32 enable = start ? DMA_ON : 0;
 
 fsi_reg_mask_set(fsi, OUT_DMAC, DMA_ON, enable);
+
+if (fsi_is_clk_master(fsi))
+fsi_master_mask_set(master, CLK_RST, clk, (enable) ? clk : 0);
 }
 
 static int fsi_dma_probe(struct fsi_priv *fsi, struct fsi_stream *io)

emu10k1 (Audigy) FXBus routing query

Dan Swain — 2012-05-25T01:12:05

Dear all,

I am writing to ask how to route certain DSP 'outputs' from my Audigy 2 ZS
back into the equivalent 'ASIO inputs' for recording purposes.

Specifically, I'd like to route outputs from the Wavetable Synths on my
card to inputs that would go straight into a DAW (such as Ardour), so that
I can apply effects, record and mix-down as if they were external synth
signals.

I know that with the kX project drivers in Windows this is possible, by
routing the Synth outputs to FXBus outputs 16-63, leaving the ASIO inputs
as 0-15 for the audio input, and then patching which channels I require
from the Synth to those inputs (e.g. Synth Channel 1 -> FXBus out 16&17 ->
FXBus in 0&1).

After reading a thread that contained responses from Jaroslav, I believe
the answer is in emufx.c, but I'm unsure as to where to start as I need to
assign the outputs from the Synths correctly first.

Thanks in advance! Any help would be greatly appreciated!

Kind Regards,

Dan

runtime change in plugin behaviour

Massimiliano Cialdi — 2012-05-24T14:58:36

Hi,

I have developed a plugin that implements a bi-quad filter. filter's 
parameters are given into asoundrc file.

Now I need to change those parameters during playback.
How can I do?
what help can gives alsalib to achieve this?

best regards

Max

[PATCH 5/5] ASoC: Ux500: Add machine-driver

Ola Lilja — 2012-05-24T13:26:45

Add machine-driver for ST-Ericsson U8500 platform, including
support for the AB8500-codec.

Signed-off-by: Ola Lilja <ola.o.lilja< at >stericsson.com>
---
 sound/soc/ux500/Kconfig         |   11 +
 sound/soc/ux500/Makefile        |    3 +
 sound/soc/ux500/mop500.c        |  117 +++++++++++
 sound/soc/ux500/mop500_ab8500.c |  441 +++++++++++++++++++++++++++++++++++++++
 sound/soc/ux500/mop500_ab8500.h |   22 ++
 5 files changed, 594 insertions(+), 0 deletions(-)
 create mode 100644 sound/soc/ux500/mop500.c
 create mode 100644 sound/soc/ux500/mop500_ab8500.c
 create mode 100644 sound/soc/ux500/mop500_ab8500.h

diff --git a/sound/soc/ux500/Kconfig b/sound/soc/ux500/Kconfig
index 1d38515..069330d 100644
--- a/sound/soc/ux500/Kconfig
+++ b/sound/soc/ux500/Kconfig
< at >< at > -19,3 +19,14 < at >< at > config SND_SOC_UX500_PLAT_DMA
 select SND_SOC_DMAENGINE_PCM
 help
 Say Y if you want to enable the Ux500 platform-driver.
+
++config SND_SOC_UX500_MACH_MOP500
++tristate "Machine - MOP500 (Ux500 + AB8500)"
+depends on AB8500_CORE && AB8500_GPADC && SND_SOC_UX500
+select SND_SOC_AB8500_CODEC
+select SND_SOC_UX500_PLAT_MSP_I2S
+select SND_SOC_UX500_PLAT_DMA
+help
+Select this to enable the MOP500 machine-driver.
+This will enable platform-drivers for: Ux500
+This will enable codec-drivers for: AB8500
diff --git a/sound/soc/ux500/Makefile b/sound/soc/ux500/Makefile
index 4634bf0..cce0c11 100644
--- a/sound/soc/ux500/Makefile
+++ b/sound/soc/ux500/Makefile
< at >< at > -5,3 +5,6 < at >< at > obj-$(CONFIG_SND_SOC_UX500_PLAT_MSP_I2S) += snd-soc-ux500-plat-msp-i2s.o
 
 snd-soc-ux500-plat-dma-objs := ux500_pcm.o
 obj-$(CONFIG_SND_SOC_UX500_PLAT_DMA) += snd-soc-ux500-plat-dma.o
+
+snd-soc-ux500-mach-mop500-objs := mop500.o mop500_ab8500.o
+obj-$(CONFIG_SND_SOC_UX500_MACH_MOP500) += snd-soc-ux500-mach-mop500.o
diff --git a/sound/soc/ux500/mop500.c b/sound/soc/ux500/mop500.c
new file mode 100644
index 0000000..d9f4a6b
--- /dev/null
+++ b/sound/soc/ux500/mop500.c
< at >< at > -0,0 +1,117 < at >< at >
+/*
+ * Copyright (C) ST-Ericsson SA 2012
+ *
+ * Author: Ola Lilja (ola.o.lilja< at >stericsson.com)
+ *         for ST-Ericsson.
+ *
+ * License terms:
+ *
+ * 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 <asm/mach-types.h>
+
+#include <linux/module.h>
+#include <linux/io.h>
+#include <linux/spi/spi.h>
+
+#include <mach/board-mop500-audio.h>
+
+#include <sound/soc.h>
+#include <sound/initval.h>
+
+#include "ux500_pcm.h"
+#include "ux500_msp_dai.h"
+
+#include <mop500_ab8500.h>
+
+/* Define the whole MOP500 soundcard, linking platform to the codec-drivers  */
+struct snd_soc_dai_link mop500_dai_links[] = {
+{
+.name = "ab8500_0",
+.stream_name = "ab8500_0",
+.cpu_dai_name = "ux500-msp-i2s.1",
+.codec_dai_name = "ab8500-codec-dai.0",
+.platform_name = "ux500-pcm.0",
+.codec_name = "ab8500-codec.0",
+.init = mop500_ab8500_machine_init,
+.ops = mop500_ab8500_ops,
+},
+{
+.name = "ab8500_1",
+.stream_name = "ab8500_1",
+.cpu_dai_name = "ux500-msp-i2s.3",
+.codec_dai_name = "ab8500-codec-dai.1",
+.platform_name = "ux500-pcm.0",
+.codec_name = "ab8500-codec.0",
+.init = NULL,
+.ops = mop500_ab8500_ops,
+},
+};
+
+static struct snd_soc_card mop500_card = {
+.name = "MOP500-card",
+.probe = NULL,
+.dai_link = mop500_dai_links,
+.num_links = ARRAY_SIZE(mop500_dai_links),
+};
+
+static int __devinit mop500_probe(struct platform_device *pdev)
+{
+int ret;
+
+pr_debug("%s: Enter.\n", __func__);
+
+dev_dbg(&pdev->dev, "%s: Enter.\n", __func__);
+
+mop500_card.dev = &pdev->dev;
+
+dev_dbg(&pdev->dev, "%s: Card %s: Set platform drvdata.\n",
+__func__, mop500_card.name);
+platform_set_drvdata(pdev, &mop500_card);
+
+snd_soc_card_set_drvdata(&mop500_card, NULL);
+
+dev_dbg(&pdev->dev, "%s: Card %s: num_links = %d\n",
+__func__, mop500_card.name, mop500_card.num_links);
+dev_dbg(&pdev->dev, "%s: Card %s: DAI-link 0: name = %s\n",
+__func__, mop500_card.name, mop500_card.dai_link[0].name);
+dev_dbg(&pdev->dev, "%s: Card %s: DAI-link 0: stream_name = %s\n",
+__func__, mop500_card.name,
+mop500_card.dai_link[0].stream_name);
+
+ret = snd_soc_register_card(&mop500_card);
+if (ret)
+dev_err(&pdev->dev,
+"Error: snd_soc_register_card failed (%d)!\n",
+ret);
+
+return ret;
+}
+
+static int __devexit mop500_remove(struct platform_device *pdev)
+{
+struct snd_soc_card *mop500_card = platform_get_drvdata(pdev);
+
+pr_debug("%s: Enter.\n", __func__);
+
+mop500_ab8500_remove(mop500_card);
+
+snd_soc_unregister_card(mop500_card);
+platform_set_drvdata(pdev, NULL);
+
+return 0;
+}
+
+static struct platform_driver snd_soc_mop500_driver = {
+.driver = {
+.owner = THIS_MODULE,
+.name = "snd-soc-mop500",
+},
+.probe = mop500_probe,
+.remove = __devexit_p(mop500_remove),
+};
+
+module_platform_driver(snd_soc_mop500_driver);
diff --git a/sound/soc/ux500/mop500_ab8500.c b/sound/soc/ux500/mop500_ab8500.c
new file mode 100644
index 0000000..32e0e34
--- /dev/null
+++ b/sound/soc/ux500/mop500_ab8500.c
< at >< at > -0,0 +1,441 < at >< at >
+/*
+ * Copyright (C) ST-Ericsson SA 2012
+ *
+ * Author: Ola Lilja <ola.o.lilja< at >stericsson.com>,
+ *         Kristoffer Karlsson <kristoffer.karlsson< at >stericsson.com>
+ *         for ST-Ericsson.
+ *
+ * License terms:
+ *
+ * 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/device.h>
+#include <linux/io.h>
+#include <linux/clk.h>
+
+#include <mach/hardware.h>
+#include <mach/board-mop500-audio.h>
+
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+
+#include "ux500_pcm.h"
+#include "ux500_msp_dai.h"
+#include "../codecs/ab8500-codec.h"
+
+#define TX_SLOT_MONO0x0008
+#define TX_SLOT_STEREO0x000a
+#define RX_SLOT_MONO0x0001
+#define RX_SLOT_STEREO0x0003
+#define TX_SLOT_8CH0x00FF
+#define RX_SLOT_8CH0x00FF
+
+#define DEF_TX_SLOTSTX_SLOT_STEREO
+#define DEF_RX_SLOTSRX_SLOT_MONO
+
+#define DRIVERMODE_NORMAL0
+#define DRIVERMODE_CODEC_ONLY1
+
+/* Slot configuration */
+static unsigned int tx_slots = DEF_TX_SLOTS;
+static unsigned int rx_slots = DEF_RX_SLOTS;
+
+/* Clocks */
+static const char * const enum_mclk[] = {
+"SYSCLK",
+"ULPCLK"
+};
+enum mclk {
+MCLK_SYSCLK,
+MCLK_ULPCLK,
+};
+
+static SOC_ENUM_SINGLE_EXT_DECL(soc_enum_mclk, enum_mclk);
+
+/* Private data for machine-part MOP500<->AB8500 */
+struct mop500_ab8500_drvdata {
+/* Clocks */
+enum mclk mclk_sel;
+struct clk *clk_ptr_intclk;
+struct clk *clk_ptr_sysclk;
+struct clk *clk_ptr_ulpclk;
+};
+
+static inline const char *get_mclk_str(enum mclk mclk_sel)
+{
+switch (mclk_sel) {
+case MCLK_SYSCLK:
+return "MCLK_SYSCLK";
+case MCLK_ULPCLK:
+return "MCLK_ULPCLK";
+default:
+return "Unknown";
+}
+}
+
+static int mop500_ab8500_set_mclk(struct device *dev,
+struct mop500_ab8500_drvdata *drvdata)
+{
+int status;
+struct clk *clk_ptr;
+
+if (IS_ERR(drvdata->clk_ptr_intclk)) {
+dev_err(dev,
+"%s: ERROR: intclk not initialized!\n", __func__);
+return -EIO;
+}
+
+switch (drvdata->mclk_sel) {
+case MCLK_SYSCLK:
+clk_ptr = drvdata->clk_ptr_sysclk;
+break;
+case MCLK_ULPCLK:
+clk_ptr = drvdata->clk_ptr_ulpclk;
+break;
+default:
+return -EINVAL;
+}
+
+if (IS_ERR(clk_ptr)) {
+dev_err(dev, "%s: ERROR: %s not initialized!\n", __func__,
+get_mclk_str(drvdata->mclk_sel));
+return -EIO;
+}
+
+status = clk_set_parent(drvdata->clk_ptr_intclk, clk_ptr);
+if (status)
+dev_err(dev,
+"%s: ERROR: Setting intclk parent to %s failed (ret = %d)!",
+__func__, get_mclk_str(drvdata->mclk_sel), status);
+else
+dev_dbg(dev,
+"%s: intclk parent changed to %s.\n",
+__func__, get_mclk_str(drvdata->mclk_sel));
+
+return status;
+}
+
+/*
+ * Control-events
+ */
+
+static int mclk_input_control_get(struct snd_kcontrol *kcontrol,
+struct snd_ctl_elem_value *ucontrol)
+{
+struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+struct mop500_ab8500_drvdata *drvdata =
+snd_soc_card_get_drvdata(codec->card);
+
+ucontrol->value.enumerated.item[0] = drvdata->mclk_sel;
+
+return 0;
+}
+
+static int mclk_input_control_put(struct snd_kcontrol *kcontrol,
+struct snd_ctl_elem_value *ucontrol)
+{
+struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+struct mop500_ab8500_drvdata *drvdata =
+snd_soc_card_get_drvdata(codec->card);
+unsigned int val;
+
+val = (ucontrol->value.enumerated.item[0] != 0);
+if (drvdata->mclk_sel == val)
+return 0;
+
+drvdata->mclk_sel = val;
+
+return 1;
+}
+
+/*
+ * Controls
+ */
+
+static struct snd_kcontrol_new mop500_ab8500_ctrls[] = {
+SOC_ENUM_EXT("Master Clock Select",
+soc_enum_mclk,
+mclk_input_control_get, mclk_input_control_put),
+/* Digital interface - Clocks */
+SOC_SINGLE("Digital Interface Master Generator Switch",
+AB8500_DIGIFCONF1, AB8500_DIGIFCONF1_ENMASTGEN,
+1, 0),
+SOC_SINGLE("Digital Interface 0 Bit-clock Switch",
+AB8500_DIGIFCONF1, AB8500_DIGIFCONF1_ENFSBITCLK0,
+1, 0),
+SOC_SINGLE("Digital Interface 1 Bit-clock Switch",
+AB8500_DIGIFCONF1, AB8500_DIGIFCONF1_ENFSBITCLK1,
+1, 0),
+SOC_DAPM_PIN_SWITCH("Headset Left"),
+SOC_DAPM_PIN_SWITCH("Headset Right"),
+SOC_DAPM_PIN_SWITCH("Earpiece"),
+SOC_DAPM_PIN_SWITCH("Speaker Left"),
+SOC_DAPM_PIN_SWITCH("Speaker Right"),
+SOC_DAPM_PIN_SWITCH("LineOut Left"),
+SOC_DAPM_PIN_SWITCH("LineOut Right"),
+SOC_DAPM_PIN_SWITCH("Vibra 1"),
+SOC_DAPM_PIN_SWITCH("Vibra 2"),
+SOC_DAPM_PIN_SWITCH("Mic 1"),
+SOC_DAPM_PIN_SWITCH("Mic 2"),
+SOC_DAPM_PIN_SWITCH("LineIn Left"),
+SOC_DAPM_PIN_SWITCH("LineIn Right"),
+SOC_DAPM_PIN_SWITCH("DMic 1"),
+SOC_DAPM_PIN_SWITCH("DMic 2"),
+SOC_DAPM_PIN_SWITCH("DMic 3"),
+SOC_DAPM_PIN_SWITCH("DMic 4"),
+SOC_DAPM_PIN_SWITCH("DMic 5"),
+SOC_DAPM_PIN_SWITCH("DMic 6"),
+};
+
+/* ASoC */
+
+int mop500_ab8500_startup(struct snd_pcm_substream *substream)
+{
+struct snd_soc_pcm_runtime *rtd = substream->private_data;
+
+/* Set audio-clock source */
+return mop500_ab8500_set_mclk(rtd->card->dev,
+snd_soc_card_get_drvdata(rtd->card));
+}
+
+void mop500_ab8500_shutdown(struct snd_pcm_substream *substream)
+{
+struct snd_soc_pcm_runtime *rtd = substream->private_data;
+struct device *dev = rtd->card->dev;
+
+dev_dbg(dev, "%s: Enter\n", __func__);
+
+/* Reset slots configuration to default(s) */
+if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+tx_slots = DEF_TX_SLOTS;
+else
+rx_slots = DEF_RX_SLOTS;
+}
+
+int mop500_ab8500_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_dai *codec_dai = rtd->codec_dai;
+struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
+struct device *dev = rtd->card->dev;
+unsigned int fmt;
+int channels, ret = 0, driver_mode, slots;
+unsigned int sw_codec, sw_cpu;
+bool is_playback;
+
+dev_dbg(dev, "%s: Enter\n", __func__);
+
+dev_dbg(dev, "%s: substream->pcm->name = %s\n"
+"substream->pcm->id = %s.\n"
+"substream->name = %s.\n"
+"substream->number = %d.\n",
+__func__,
+substream->pcm->name,
+substream->pcm->id,
+substream->name,
+substream->number);
+
+channels = params_channels(params);
+
+switch (params_format(params)) {
+case SNDRV_PCM_FORMAT_S32_LE:
+sw_cpu = 32;
+break;
+
+case SNDRV_PCM_FORMAT_S16_LE:
+sw_cpu = 16;
+break;
+
+default:
+return -EINVAL;
+}
+
+/* Setup codec depending on driver-mode */
+driver_mode = (channels == 8) ?
+DRIVERMODE_CODEC_ONLY : DRIVERMODE_NORMAL;
+dev_dbg(dev, "%s: Driver-mode: %s.\n", __func__,
+(driver_mode == DRIVERMODE_NORMAL) ? "NORMAL" : "CODEC_ONLY");
+
+/* Setup format */
+
+if (driver_mode == DRIVERMODE_NORMAL) {
+fmt = SND_SOC_DAIFMT_DSP_A |
+SND_SOC_DAIFMT_CBM_CFM |
+SND_SOC_DAIFMT_NB_NF |
+SND_SOC_DAIFMT_CONT;
+} else {
+fmt = SND_SOC_DAIFMT_DSP_A |
+SND_SOC_DAIFMT_CBM_CFM |
+SND_SOC_DAIFMT_NB_NF |
+SND_SOC_DAIFMT_GATED;
+}
+
+ret = snd_soc_dai_set_fmt(codec_dai, fmt);
+if (ret < 0) {
+dev_err(dev,
+"%s: ERROR: snd_soc_dai_set_fmt failed for codec_dai (ret = %d)!\n",
+__func__, ret);
+return ret;
+}
+
+ret = snd_soc_dai_set_fmt(cpu_dai, fmt);
+if (ret < 0) {
+dev_err(dev,
+"%s: ERROR: snd_soc_dai_set_fmt failed for cpu_dai (ret = %d)!\n",
+__func__, ret);
+return ret;
+}
+
+/* Setup TDM-slots */
+
+is_playback = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK);
+switch (channels) {
+case 1:
+slots = 16;
+tx_slots = (is_playback) ? TX_SLOT_MONO : 0;
+rx_slots = (is_playback) ? 0 : RX_SLOT_MONO;
+break;
+case 2:
+slots = 16;
+tx_slots = (is_playback) ? TX_SLOT_STEREO : 0;
+rx_slots = (is_playback) ? 0 : RX_SLOT_STEREO;
+break;
+case 8:
+slots = 16;
+tx_slots = (is_playback) ? TX_SLOT_8CH : 0;
+rx_slots = (is_playback) ? 0 : RX_SLOT_8CH;
+break;
+default:
+return -EINVAL;
+}
+
+sw_codec = (driver_mode == DRIVERMODE_NORMAL) ? sw_cpu : 20;
+
+dev_dbg(dev, "%s: CPU-DAI TDM: TX=0x%04X RX=0x%04x\n", __func__,
+tx_slots, rx_slots);
+ret = snd_soc_dai_set_tdm_slot(cpu_dai, tx_slots, rx_slots, slots,
+sw_cpu);
+if (ret)
+return ret;
+
+dev_dbg(dev, "%s: CODEC-DAI TDM: TX=0x%04X RX=0x%04x\n", __func__,
+tx_slots, rx_slots);
+ret = snd_soc_dai_set_tdm_slot(codec_dai, tx_slots, rx_slots, slots,
+sw_codec);
+if (ret)
+return ret;
+
+return 0;
+}
+
+struct snd_soc_ops mop500_ab8500_ops[] = {
+{
+.hw_params = mop500_ab8500_hw_params,
+.startup = mop500_ab8500_startup,
+.shutdown = mop500_ab8500_shutdown,
+}
+};
+
+int mop500_ab8500_machine_init(struct snd_soc_pcm_runtime *rtd)
+{
+struct snd_soc_codec *codec = rtd->codec;
+struct device *dev = rtd->card->dev;
+struct mop500_audio_platform_data *pdata;
+struct mop500_ab8500_drvdata *drvdata;
+int ret;
+
+dev_dbg(dev, "%s Enter.\n", __func__);
+
+/* Create driver private-data struct */
+drvdata = devm_kzalloc(dev, sizeof(struct mop500_ab8500_drvdata),
+GFP_KERNEL);
+snd_soc_card_set_drvdata(rtd->card, drvdata);
+
+/* Setup clocks */
+
+drvdata->clk_ptr_sysclk = clk_get(dev, "sysclk");
+if (IS_ERR(drvdata->clk_ptr_sysclk))
+dev_warn(dev, "%s: WARNING: clk_get failed for 'sysclk'!\n",
+__func__);
+drvdata->clk_ptr_ulpclk = clk_get(dev, "ulpclk");
+if (IS_ERR(drvdata->clk_ptr_ulpclk))
+dev_warn(dev, "%s: WARNING: clk_get failed for 'ulpclk'!\n",
+__func__);
+drvdata->clk_ptr_intclk = clk_get(dev, "intclk");
+if (IS_ERR(drvdata->clk_ptr_intclk))
+dev_warn(dev, "%s: WARNING: clk_get failed for 'intclk'!\n",
+__func__);
+
+/* Set intclk default parent to ulpclk */
+drvdata->mclk_sel = MCLK_ULPCLK;
+ret = mop500_ab8500_set_mclk(dev, drvdata);
+if (ret < 0)
+dev_warn(dev, "%s: WARNING: mop500_ab8500_set_mclk!\n",
+__func__);
+
+drvdata->mclk_sel = MCLK_ULPCLK;
+
+/* Add controls */
+ret = snd_soc_add_codec_controls(codec, mop500_ab8500_ctrls,
+ARRAY_SIZE(mop500_ab8500_ctrls));
+if (ret < 0) {
+pr_err("%s: Failed to add machine-controls (%d)!\n",
+__func__, ret);
+return ret;
+}
+
+/* Setup AB8500 according to board-settings */
+pdata = (struct mop500_audio_platform_data *)dev_get_platdata(dev);
+ret = ab8500_audio_setup_mics(codec, &pdata->amics);
+if (ret < 0) {
+pr_err("%s: Failed to setup mics (%d)!\n", __func__, ret);
+return ret;
+}
+ret = ab8500_audio_set_ear_cmv(codec, pdata->ear_cmv);
+if (ret < 0) {
+pr_err("%s: Failed to set earpiece CM-voltage (%d)!\n",
+__func__, ret);
+return ret;
+}
+
+ret = snd_soc_dapm_disable_pin(&codec->dapm, "Earpiece");
+ret |= snd_soc_dapm_disable_pin(&codec->dapm, "Speaker Left");
+ret |= snd_soc_dapm_disable_pin(&codec->dapm, "Speaker Right");
+ret |= snd_soc_dapm_disable_pin(&codec->dapm, "LineOut Left");
+ret |= snd_soc_dapm_disable_pin(&codec->dapm, "LineOut Right");
+ret |= snd_soc_dapm_disable_pin(&codec->dapm, "Vibra 1");
+ret |= snd_soc_dapm_disable_pin(&codec->dapm, "Vibra 2");
+ret |= snd_soc_dapm_disable_pin(&codec->dapm, "Mic 1");
+ret |= snd_soc_dapm_disable_pin(&codec->dapm, "Mic 2");
+ret |= snd_soc_dapm_disable_pin(&codec->dapm, "LineIn Left");
+ret |= snd_soc_dapm_disable_pin(&codec->dapm, "LineIn Right");
+ret |= snd_soc_dapm_disable_pin(&codec->dapm, "DMic 1");
+ret |= snd_soc_dapm_disable_pin(&codec->dapm, "DMic 2");
+ret |= snd_soc_dapm_disable_pin(&codec->dapm, "DMic 3");
+ret |= snd_soc_dapm_disable_pin(&codec->dapm, "DMic 4");
+ret |= snd_soc_dapm_disable_pin(&codec->dapm, "DMic 5");
+ret |= snd_soc_dapm_disable_pin(&codec->dapm, "DMic 6");
+
+return ret;
+}
+
+void mop500_ab8500_remove(struct snd_soc_card *card)
+{
+struct mop500_ab8500_drvdata *drvdata = snd_soc_card_get_drvdata(card);
+
+if (drvdata->clk_ptr_sysclk != NULL)
+clk_put(drvdata->clk_ptr_sysclk);
+if (drvdata->clk_ptr_ulpclk != NULL)
+clk_put(drvdata->clk_ptr_ulpclk);
+if (drvdata->clk_ptr_intclk != NULL)
+clk_put(drvdata->clk_ptr_intclk);
+
+snd_soc_card_set_drvdata(card, drvdata);
+}
diff --git a/sound/soc/ux500/mop500_ab8500.h b/sound/soc/ux500/mop500_ab8500.h
new file mode 100644
index 0000000..cca5b33
--- /dev/null
+++ b/sound/soc/ux500/mop500_ab8500.h
< at >< at > -0,0 +1,22 < at >< at >
+/*
+ * Copyright (C) ST-Ericsson SA 2012
+ *
+ * Author: Ola Lilja <ola.o.lilja< at >stericsson.com>
+ *         for ST-Ericsson.
+ *
+ * License terms:
+ *
+ * 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.
+ */
+
+#ifndef MOP500_AB8500_H
+#define MOP500_AB8500_H
+
+extern struct snd_soc_ops mop500_ab8500_ops[];
+
+int mop500_ab8500_machine_init(struct snd_soc_pcm_runtime *runtime);
+void mop500_ab8500_remove(struct snd_soc_card *card);
+
+#endif

[PATCH 3/5] ASoC: Ux500: Add platform-driver

Ola Lilja — 2012-05-24T13:26:32

Add platform-driver handling all DMA-activities.

Signed-off-by: Ola Lilja <ola.o.lilja< at >stericsson.com>
---
 sound/soc/ux500/Kconfig     |    7 +
 sound/soc/ux500/Makefile    |    3 +
 sound/soc/ux500/ux500_pcm.c |  318 +++++++++++++++++++++++++++++++++++++++++++
 sound/soc/ux500/ux500_pcm.h |   35 +++++
 4 files changed, 363 insertions(+), 0 deletions(-)
 create mode 100644 sound/soc/ux500/ux500_pcm.c
 create mode 100644 sound/soc/ux500/ux500_pcm.h

diff --git a/sound/soc/ux500/Kconfig b/sound/soc/ux500/Kconfig
index 44cf434..1d38515 100644
--- a/sound/soc/ux500/Kconfig
+++ b/sound/soc/ux500/Kconfig
< at >< at > -12,3 +12,10 < at >< at > menuconfig SND_SOC_UX500
 config SND_SOC_UX500_PLAT_MSP_I2S
 tristate
 depends on SND_SOC_UX500
+
+config SND_SOC_UX500_PLAT_DMA
+tristate "Platform - DB8500 (DMA)"
+depends on SND_SOC_UX500
+select SND_SOC_DMAENGINE_PCM
+help
+Say Y if you want to enable the Ux500 platform-driver.
diff --git a/sound/soc/ux500/Makefile b/sound/soc/ux500/Makefile
index 19974c5..4634bf0 100644
--- a/sound/soc/ux500/Makefile
+++ b/sound/soc/ux500/Makefile
< at >< at > -2,3 +2,6 < at >< at >
 
 snd-soc-ux500-plat-msp-i2s-objs := ux500_msp_dai.o ux500_msp_i2s.o
 obj-$(CONFIG_SND_SOC_UX500_PLAT_MSP_I2S) += snd-soc-ux500-plat-msp-i2s.o
+
+snd-soc-ux500-plat-dma-objs := ux500_pcm.o
+obj-$(CONFIG_SND_SOC_UX500_PLAT_DMA) += snd-soc-ux500-plat-dma.o
diff --git a/sound/soc/ux500/ux500_pcm.c b/sound/soc/ux500/ux500_pcm.c
new file mode 100644
index 0000000..66b080e
--- /dev/null
+++ b/sound/soc/ux500/ux500_pcm.c
< at >< at > -0,0 +1,318 < at >< at >
+/*
+ * Copyright (C) ST-Ericsson SA 2012
+ *
+ * Author: Ola Lilja <ola.o.lilja< at >stericsson.com>,
+ *         Roger Nilsson <roger.xr.nilsson< at >stericsson.com>
+ *         for ST-Ericsson.
+ *
+ * License terms:
+ *
+ * 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 <asm/page.h>
+
+#include <linux/module.h>
+#include <linux/dma-mapping.h>
+#include <linux/dmaengine.h>
+#include <linux/slab.h>
+
+#include <plat/ste_dma40.h>
+
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+#include <sound/dmaengine_pcm.h>
+
+#include "ux500_msp_i2s.h"
+#include "ux500_pcm.h"
+
+static struct snd_pcm_hardware ux500_pcm_hw_playback = {
+.info = SNDRV_PCM_INFO_INTERLEAVED |
+SNDRV_PCM_INFO_MMAP |
+SNDRV_PCM_INFO_RESUME |
+SNDRV_PCM_INFO_PAUSE,
+.formats = SNDRV_PCM_FMTBIT_S16_LE |
+SNDRV_PCM_FMTBIT_U16_LE |
+SNDRV_PCM_FMTBIT_S16_BE |
+SNDRV_PCM_FMTBIT_U16_BE,
+.rates = SNDRV_PCM_RATE_KNOT,
+.rate_min = UX500_PLATFORM_MIN_RATE_PLAYBACK,
+.rate_max = UX500_PLATFORM_MAX_RATE_PLAYBACK,
+.channels_min = UX500_PLATFORM_MIN_CHANNELS,
+.channels_max = UX500_PLATFORM_MAX_CHANNELS,
+.buffer_bytes_max = UX500_PLATFORM_BUFFER_BYTES_MAX,
+.period_bytes_min = UX500_PLATFORM_PERIODS_BYTES_MIN,
+.period_bytes_max = UX500_PLATFORM_PERIODS_BYTES_MAX,
+.periods_min = UX500_PLATFORM_PERIODS_MIN,
+.periods_max = UX500_PLATFORM_PERIODS_MAX,
+};
+
+static struct snd_pcm_hardware ux500_pcm_hw_capture = {
+.info = SNDRV_PCM_INFO_INTERLEAVED |
+SNDRV_PCM_INFO_MMAP |
+SNDRV_PCM_INFO_RESUME |
+SNDRV_PCM_INFO_PAUSE,
+.formats = SNDRV_PCM_FMTBIT_S16_LE |
+SNDRV_PCM_FMTBIT_U16_LE |
+SNDRV_PCM_FMTBIT_S16_BE |
+SNDRV_PCM_FMTBIT_U16_BE,
+.rates = SNDRV_PCM_RATE_KNOT,
+.rate_min = UX500_PLATFORM_MIN_RATE_CAPTURE,
+.rate_max = UX500_PLATFORM_MAX_RATE_CAPTURE,
+.channels_min = UX500_PLATFORM_MIN_CHANNELS,
+.channels_max = UX500_PLATFORM_MAX_CHANNELS,
+.buffer_bytes_max = UX500_PLATFORM_BUFFER_BYTES_MAX,
+.period_bytes_min = UX500_PLATFORM_PERIODS_BYTES_MIN,
+.period_bytes_max = UX500_PLATFORM_PERIODS_BYTES_MAX,
+.periods_min = UX500_PLATFORM_PERIODS_MIN,
+.periods_max = UX500_PLATFORM_PERIODS_MAX,
+};
+
+static void ux500_pcm_dma_hw_free(struct device *dev,
+struct snd_pcm_substream *substream)
+{
+struct snd_pcm_runtime *runtime = substream->runtime;
+struct snd_dma_buffer *buf = runtime->dma_buffer_p;
+
+if (runtime->dma_area == NULL)
+return;
+
+if (buf != &substream->dma_buffer) {
+dma_free_coherent(buf->dev.dev, buf->bytes, buf->area,
+buf->addr);
+kfree(runtime->dma_buffer_p);
+}
+
+snd_pcm_set_runtime_buffer(substream, NULL);
+}
+
+static int ux500_pcm_open(struct snd_pcm_substream *substream)
+{
+int stream_id = substream->pstr->stream;
+struct snd_pcm_runtime *runtime = substream->runtime;
+struct snd_soc_pcm_runtime *rtd = substream->private_data;
+struct snd_soc_dai *dai = rtd->cpu_dai;
+struct device *dev = dai->dev;
+int ret;
+struct ux500_msp_dma_params *dma_params;
+u16 per_data_width, mem_data_width;
+struct stedma40_chan_cfg *dma_cfg;
+
+dev_dbg(dev, "%s: MSP %d (%s): Enter.\n", __func__, dai->id,
+snd_pcm_stream_str(substream));
+
+dev_dbg(dev, "%s: Set runtime hwparams.\n", __func__);
+if (stream_id == SNDRV_PCM_STREAM_PLAYBACK)
+snd_soc_set_runtime_hwparams(substream,
+&ux500_pcm_hw_playback);
+else
+snd_soc_set_runtime_hwparams(substream,
+&ux500_pcm_hw_capture);
+
+/* ensure that buffer size is a multiple of period size */
+ret = snd_pcm_hw_constraint_integer(runtime,
+SNDRV_PCM_HW_PARAM_PERIODS);
+if (ret < 0) {
+dev_err(dev, "%s: Error: snd_pcm_hw_constraints failed (%d)\n",
+__func__, ret);
+return ret;
+}
+
+dev_dbg(dev, "%s: Set hw-struct for %s.\n", __func__,
+snd_pcm_stream_str(substream));
+runtime->hw = (stream_id == SNDRV_PCM_STREAM_PLAYBACK) ?
+ux500_pcm_hw_playback : ux500_pcm_hw_capture;
+
+mem_data_width = STEDMA40_HALFWORD_WIDTH;
+
+dma_params = snd_soc_dai_get_dma_data(dai, substream);
+switch (dma_params->data_size) {
+case 32:
+per_data_width = STEDMA40_WORD_WIDTH;
+break;
+case 16:
+per_data_width = STEDMA40_HALFWORD_WIDTH;
+break;
+case 8:
+per_data_width = STEDMA40_BYTE_WIDTH;
+break;
+default:
+per_data_width = STEDMA40_WORD_WIDTH;
+dev_warn(rtd->platform->dev,
+"%s: Unknown data-size (%d)! Assuming 32 bits.\n",
+__func__, dma_params->data_size);
+}
+
+dma_cfg = dma_params->dma_cfg;
+
+if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+dma_cfg->src_info.data_width = mem_data_width;
+dma_cfg->dst_info.data_width = per_data_width;
+} else {
+dma_cfg->src_info.data_width = per_data_width;
+dma_cfg->dst_info.data_width = mem_data_width;
+}
+
+
+ret = snd_dmaengine_pcm_open(substream, stedma40_filter, dma_cfg);
+if (ret) {
+dev_dbg(dai->dev,
+"%s: ERROR: snd_dmaengine_pcm_open failed (%d)!\n",
+__func__, ret);
+return ret;
+}
+
+snd_dmaengine_pcm_set_data(substream, dma_cfg);
+
+return 0;
+}
+
+static int ux500_pcm_close(struct snd_pcm_substream *substream)
+{
+struct snd_soc_pcm_runtime *rtd = substream->private_data;
+struct snd_soc_dai *dai = rtd->cpu_dai;
+
+dev_dbg(dai->dev, "%s: Enter\n", __func__);
+
+snd_dmaengine_pcm_close(substream);
+
+return 0;
+}
+
+static int ux500_pcm_hw_params(struct snd_pcm_substream *substream,
+struct snd_pcm_hw_params *hw_params)
+{
+struct snd_pcm_runtime *runtime = substream->runtime;
+struct snd_dma_buffer *buf = runtime->dma_buffer_p;
+struct snd_soc_pcm_runtime *rtd = substream->private_data;
+int ret = 0;
+int size;
+
+dev_dbg(rtd->platform->dev, "%s: Enter\n", __func__);
+
+size = params_buffer_bytes(hw_params);
+
+if (buf) {
+if (buf->bytes >= size)
+goto out;
+ux500_pcm_dma_hw_free(NULL, substream);
+}
+
+if (substream->dma_buffer.area != NULL &&
+substream->dma_buffer.bytes >= size) {
+buf = &substream->dma_buffer;
+} else {
+buf = kmalloc(sizeof(struct snd_dma_buffer), GFP_KERNEL);
+if (!buf)
+goto nomem;
+
+buf->dev.type = SNDRV_DMA_TYPE_DEV;
+buf->dev.dev = NULL;
+buf->area = dma_alloc_coherent(NULL, size, &buf->addr,
+GFP_KERNEL);
+buf->bytes = size;
+buf->private_data = NULL;
+
+if (!buf->area)
+goto free;
+}
+snd_pcm_set_runtime_buffer(substream, buf);
+ret = 1;
+ out:
+runtime->dma_bytes = size;
+return ret;
+
+ free:
+kfree(buf);
+ nomem:
+return -ENOMEM;
+}
+
+static int ux500_pcm_hw_free(struct snd_pcm_substream *substream)
+{
+struct snd_soc_pcm_runtime *rtd = substream->private_data;
+
+dev_dbg(rtd->platform->dev, "%s: Enter\n", __func__);
+
+ux500_pcm_dma_hw_free(NULL, substream);
+
+return 0;
+}
+
+static int ux500_pcm_mmap(struct snd_pcm_substream *substream,
+struct vm_area_struct *vma)
+{
+struct snd_pcm_runtime *runtime = substream->runtime;
+struct snd_soc_pcm_runtime *rtd = substream->private_data;
+
+dev_dbg(rtd->platform->dev, "%s: Enter.\n", __func__);
+
+return dma_mmap_coherent(NULL, vma, runtime->dma_area,
+runtime->dma_addr, runtime->dma_bytes);
+}
+
+static struct snd_pcm_ops ux500_pcm_ops = {
+.open= ux500_pcm_open,
+.close= ux500_pcm_close,
+.ioctl= snd_pcm_lib_ioctl,
+.hw_params= ux500_pcm_hw_params,
+.hw_free= ux500_pcm_hw_free,
+.trigger= snd_dmaengine_pcm_trigger,
+.pointer= snd_dmaengine_pcm_pointer,
+.mmap= ux500_pcm_mmap
+};
+
+int ux500_pcm_new(struct snd_soc_pcm_runtime *rtd)
+{
+struct snd_pcm *pcm = rtd->pcm;
+
+dev_dbg(rtd->platform->dev, "%s: Enter (id = '%s').\n", __func__,
+pcm->id);
+
+pcm->info_flags = 0;
+
+return 0;
+}
+
+static struct snd_soc_platform_driver ux500_pcm_soc_drv = {
+.ops= &ux500_pcm_ops,
+.pcm_new        = ux500_pcm_new,
+};
+
+static int __devexit ux500_pcm_drv_probe(struct platform_device *pdev)
+{
+int ret;
+
+ret = snd_soc_register_platform(&pdev->dev, &ux500_pcm_soc_drv);
+if (ret < 0) {
+dev_err(&pdev->dev,
+"%s: ERROR: Failed to register platform '%s' (%d)!\n",
+__func__, pdev->name, ret);
+return ret;
+}
+
+return 0;
+}
+
+static int __devinit ux500_pcm_drv_remove(struct platform_device *pdev)
+{
+snd_soc_unregister_platform(&pdev->dev);
+
+return 0;
+}
+
+static struct platform_driver ux500_pcm_driver = {
+.driver = {
+.name = "ux500-pcm",
+.owner = THIS_MODULE,
+},
+
+.probe = ux500_pcm_drv_probe,
+.remove = __devexit_p(ux500_pcm_drv_remove),
+};
+module_platform_driver(ux500_pcm_driver);
+
+MODULE_LICENSE("GPLv2");
diff --git a/sound/soc/ux500/ux500_pcm.h b/sound/soc/ux500/ux500_pcm.h
new file mode 100644
index 0000000..77ed44d
--- /dev/null
+++ b/sound/soc/ux500/ux500_pcm.h
< at >< at > -0,0 +1,35 < at >< at >
+/*
+ * Copyright (C) ST-Ericsson SA 2012
+ *
+ * Author: Ola Lilja <ola.o.lilja< at >stericsson.com>,
+ *         Roger Nilsson <roger.xr.nilsson< at >stericsson.com>
+ *         for ST-Ericsson.
+ *
+ * License terms:
+ *
+ * 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.
+ */
+#ifndef UX500_PCM_H
+#define UX500_PCM_H
+
+#include <asm/page.h>
+
+#include <linux/workqueue.h>
+
+#define UX500_PLATFORM_MIN_RATE_PLAYBACK 8000
+#define UX500_PLATFORM_MAX_RATE_PLAYBACK 48000
+#define UX500_PLATFORM_MIN_RATE_CAPTURE8000
+#define UX500_PLATFORM_MAX_RATE_CAPTURE48000
+
+#define UX500_PLATFORM_MIN_CHANNELS 1
+#define UX500_PLATFORM_MAX_CHANNELS 8
+
+#define UX500_PLATFORM_PERIODS_BYTES_MIN128
+#define UX500_PLATFORM_PERIODS_BYTES_MAX(64 * PAGE_SIZE)
+#define UX500_PLATFORM_PERIODS_MIN2
+#define UX500_PLATFORM_PERIODS_MAX48
+#define UX500_PLATFORM_BUFFER_BYTES_MAX(2048 * PAGE_SIZE)
+
+#endif

[PATCH 2/5] ASoC: core: Add widgetSND_SOC_DAPM_CLOCK_SUPPLY

Ola Lilja — 2012-05-24T13:26:25

Adds a supply-widget variant for connection to the clock-framework.
This widget-type corresponds to the variant for regulators.

Signed-off-by: Ola Lilja <ola.o.lilja< at >stericsson.com>
---
 include/sound/soc-dapm.h |   10 ++++++++++
 sound/soc/soc-dapm.c     |   38 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 48 insertions(+), 0 deletions(-)

diff --git a/include/sound/soc-dapm.h b/include/sound/soc-dapm.h
index e3833d9..05559e5 100644
--- a/include/sound/soc-dapm.h
+++ b/include/sound/soc-dapm.h
< at >< at > -229,6 +229,10 < at >< at > struct device;
 {.id = snd_soc_dapm_adc, .name = wname, .sname = stname, .reg = wreg, \
 .shift = wshift, .invert = winvert, \
 .event = wevent, .event_flags = wflags}
+#define SND_SOC_DAPM_CLOCK_SUPPLY(wname) \
+{.id = snd_soc_dapm_clock_supply, .name = wname, \
+.reg = SND_SOC_NOPM, .event = dapm_clock_event, \
+.event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD }
 
 /* generic widgets */
 #define SND_SOC_DAPM_REG(wid, wname, wreg, wshift, wmask, won_val, woff_val) \
< at >< at > -245,6 +249,7 < at >< at > struct device;
 .reg = SND_SOC_NOPM, .shift = wdelay, .event = dapm_regulator_event, \
 .event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD }
 
+
 /* dapm kcontrol types */
 #define SOC_DAPM_SINGLE(xname, reg, shift, max, invert) \
 {.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
< at >< at > -327,6 +332,8 < at >< at > int dapm_reg_event(struct snd_soc_dapm_widget *w,
    struct snd_kcontrol *kcontrol, int event);
 int dapm_regulator_event(struct snd_soc_dapm_widget *w,
  struct snd_kcontrol *kcontrol, int event);
+int dapm_clock_event(struct snd_soc_dapm_widget *w,
+ struct snd_kcontrol *kcontrol, int event);
 
 /* dapm controls */
 int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
< at >< at > -432,6 +439,7 < at >< at > enum snd_soc_dapm_type {
 snd_soc_dapm_post,/* machine specific post widget - exec last */
 snd_soc_dapm_supply,/* power/clock supply */
 snd_soc_dapm_regulator_supply,/* external regulator */
+snd_soc_dapm_clock_supply,/* external clock */
 snd_soc_dapm_aif_in,/* audio interface input */
 snd_soc_dapm_aif_out,/* audio interface output */
 snd_soc_dapm_siggen,/* signal generator */
< at >< at > -537,6 +545,8 < at >< at > struct snd_soc_dapm_widget {
 struct list_head dirty;
 int inputs;
 int outputs;
+
+struct clk *clk;
 };
 
 struct snd_soc_dapm_update {
diff --git a/sound/soc/soc-dapm.c b/sound/soc/soc-dapm.c
index 90ee77d..3bb7a6f 100644
--- a/sound/soc/soc-dapm.c
+++ b/sound/soc/soc-dapm.c
< at >< at > -35,6 +35,7 < at >< at >
 #include <linux/debugfs.h>
 #include <linux/pm_runtime.h>
 #include <linux/regulator/consumer.h>
+#include <linux/clk.h>
 #include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
< at >< at > -51,6 +52,7 < at >< at > static int dapm_up_seq[] = {
 [snd_soc_dapm_pre] = 0,
 [snd_soc_dapm_supply] = 1,
 [snd_soc_dapm_regulator_supply] = 1,
+[snd_soc_dapm_clock_supply] = 1,
 [snd_soc_dapm_micbias] = 2,
 [snd_soc_dapm_dai_link] = 2,
 [snd_soc_dapm_dai] = 3,
< at >< at > -92,6 +94,7 < at >< at > static int dapm_down_seq[] = {
 [snd_soc_dapm_aif_out] = 10,
 [snd_soc_dapm_dai] = 10,
 [snd_soc_dapm_dai_link] = 11,
+[snd_soc_dapm_clock_supply] = 12,
 [snd_soc_dapm_regulator_supply] = 12,
 [snd_soc_dapm_supply] = 12,
 [snd_soc_dapm_post] = 13,
< at >< at > -391,6 +394,7 < at >< at > static void dapm_set_path_status(struct snd_soc_dapm_widget *w,
 case snd_soc_dapm_vmid:
 case snd_soc_dapm_supply:
 case snd_soc_dapm_regulator_supply:
+case snd_soc_dapm_clock_supply:
 case snd_soc_dapm_aif_in:
 case snd_soc_dapm_aif_out:
 case snd_soc_dapm_dai:
< at >< at > -764,6 +768,7 < at >< at > static int is_connected_output_ep(struct snd_soc_dapm_widget *widget,
 switch (widget->id) {
 case snd_soc_dapm_supply:
 case snd_soc_dapm_regulator_supply:
+case snd_soc_dapm_clock_supply:
 return 0;
 default:
 break;
< at >< at > -850,6 +855,7 < at >< at > static int is_connected_input_ep(struct snd_soc_dapm_widget *widget,
 switch (widget->id) {
 case snd_soc_dapm_supply:
 case snd_soc_dapm_regulator_supply:
+case snd_soc_dapm_clock_supply:
 return 0;
 default:
 break;
< at >< at > -996,6 +1002,24 < at >< at > int dapm_regulator_event(struct snd_soc_dapm_widget *w,
 }
 EXPORT_SYMBOL_GPL(dapm_regulator_event);
 
+/*
+ * Handler for clock supply widget.
+ */
+int dapm_clock_event(struct snd_soc_dapm_widget *w,
+   struct snd_kcontrol *kcontrol, int event)
+{
+if (!w->clk)
+return -EIO;
+
+if (SND_SOC_DAPM_EVENT_ON(event)) {
+return clk_enable(w->clk);
+} else {
+clk_disable(w->clk);
+return 0;
+}
+}
+EXPORT_SYMBOL_GPL(dapm_clock_event);
+
 static int dapm_widget_power_check(struct snd_soc_dapm_widget *w)
 {
 if (w->power_checked)
< at >< at > -1487,6 +1511,7 < at >< at > static void dapm_widget_set_power(struct snd_soc_dapm_widget *w, bool power,
 switch (w->id) {
 case snd_soc_dapm_supply:
 case snd_soc_dapm_regulator_supply:
+case snd_soc_dapm_clock_supply:
 /* Supplies can't affect their outputs, only their inputs */
 break;
 default:
< at >< at > -1587,6 +1612,7 < at >< at > static int dapm_power_widgets(struct snd_soc_dapm_context *dapm, int event)
 break;
 case snd_soc_dapm_supply:
 case snd_soc_dapm_regulator_supply:
+case snd_soc_dapm_clock_supply:
 case snd_soc_dapm_micbias:
 if (d->target_bias_level < SND_SOC_BIAS_STANDBY)
 d->target_bias_level = SND_SOC_BIAS_STANDBY;
< at >< at > -1941,6 +1967,7 < at >< at > static ssize_t dapm_widget_show(struct device *dev,
 case snd_soc_dapm_mixer_named_ctl:
 case snd_soc_dapm_supply:
 case snd_soc_dapm_regulator_supply:
+case snd_soc_dapm_clock_supply:
 if (w->name)
 count += sprintf(buf + count, "%s: %s\n",
 w->name, w->power ? "On":"Off");
< at >< at > -2187,6 +2214,7 < at >< at > static int snd_soc_dapm_add_route(struct snd_soc_dapm_context *dapm,
 case snd_soc_dapm_post:
 case snd_soc_dapm_supply:
 case snd_soc_dapm_regulator_supply:
+case snd_soc_dapm_clock_supply:
 case snd_soc_dapm_aif_in:
 case snd_soc_dapm_aif_out:
 case snd_soc_dapm_dai:
< at >< at > -2873,6 +2901,15 < at >< at > snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
 return NULL;
 }
 break;
+case snd_soc_dapm_clock_supply:
+w->clk = clk_get(dapm->dev, w->name);
+if (IS_ERR(w->clk)) {
+ret = PTR_ERR(w->clk);
+dev_err(dapm->dev, "Failed to request %s: %d\n",
+w->name, ret);
+return NULL;
+}
+break;
 default:
 break;
 }
< at >< at > -2924,6 +2961,7 < at >< at > snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
 break;
 case snd_soc_dapm_supply:
 case snd_soc_dapm_regulator_supply:
+case snd_soc_dapm_clock_supply:
 w->power_check = dapm_supply_check_power;
 break;
 case snd_soc_dapm_dai:

[PATCH 1/5] ALSA: pcm: Add debug-print helper function

Ola Lilja — 2012-05-24T13:26:03

Adds a function getting the stream-name as a string for
a specific stream.

Signed-off-by: Ola Lilja <ola.o.lilja< at >stericsson.com>
---
 include/sound/pcm.h |   11 +++++++++++
 1 files changed, 11 insertions(+), 0 deletions(-)

diff --git a/include/sound/pcm.h b/include/sound/pcm.h
index 0d11128..a55d5db 100644
--- a/include/sound/pcm.h
+++ b/include/sound/pcm.h
< at >< at > -1073,4 +1073,15 < at >< at > static inline void snd_pcm_limit_isa_dma_size(int dma, size_t *max)
 
 const char *snd_pcm_format_name(snd_pcm_format_t format);
 
+/**
+ * Get a string naming the direction of a stream
+ */
+static inline const char *snd_pcm_stream_str(struct snd_pcm_substream *substream)
+{
+if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+return "Playback";
+else
+return "Capture";
+}
+
 #endif /* __SOUND_PCM_H */

[PATCH 1/5] ALSA: pcm: Add debug-print helper function

Ola Lilja — 2012-05-24T13:24:57

Adds a function getting the stream-name as a string for
a specific stream.

Signed-off-by: Ola Lilja <ola.o.lilja< at >stericsson.com>
---
 include/sound/pcm.h |   11 +++++++++++
 1 files changed, 11 insertions(+), 0 deletions(-)

diff --git a/include/sound/pcm.h b/include/sound/pcm.h
index 0d11128..a55d5db 100644
--- a/include/sound/pcm.h
+++ b/include/sound/pcm.h
< at >< at > -1073,4 +1073,15 < at >< at > static inline void snd_pcm_limit_isa_dma_size(int dma, size_t *max)
 
 const char *snd_pcm_format_name(snd_pcm_format_t format);
 
+/**
+ * Get a string naming the direction of a stream
+ */
+static inline const char *snd_pcm_stream_str(struct snd_pcm_substream *substream)
+{
+if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+return "Playback";
+else
+return "Capture";
+}
+
 #endif /* __SOUND_PCM_H */

[PATCH 0/5] Version 5

Ola Lilja — 2012-05-24T13:24:45

*) ALSA-core helper function made static inline
*) Removed debug-functions from the core-patch
*) Bug-fixes in codec-file
*) Controversial controls (clock-stuff) moved to machine-file
*) Removed custom functions for second codec-interface
*) Streams moved to separete DAPM-widgets

Ola Lilja (5):
  ALSA: pcm: Add debug-print helper function
  ASoC: core: Add widget SND_SOC_DAPM_CLOCK_SUPPLY
  ASoC: Ux500: Add platform-driver
  ASoC: codecs: Add AB8500 codec-driver
  ASoC: Ux500: Add machine-driver

 include/sound/pcm.h             |   11 +
 include/sound/soc-dapm.h        |   10 +
 sound/soc/codecs/Kconfig        |    4 +
 sound/soc/codecs/Makefile       |    2 +
 sound/soc/codecs/ab8500-codec.c | 2569 +++++++++++++++++++++++++++++++++++++++
 sound/soc/codecs/ab8500-codec.h |  606 +++++++++
 sound/soc/soc-dapm.c            |   38 +
 sound/soc/ux500/Kconfig         |   18 +
 sound/soc/ux500/Makefile        |    6 +
 sound/soc/ux500/mop500.c        |  117 ++
 sound/soc/ux500/mop500_ab8500.c |  441 +++++++
 sound/soc/ux500/mop500_ab8500.h |   22 +
 sound/soc/ux500/ux500_pcm.c     |  318 +++++
 sound/soc/ux500/ux500_pcm.h     |   35 +
 14 files changed, 4197 insertions(+), 0 deletions(-)
 create mode 100644 sound/soc/codecs/ab8500-codec.c
 create mode 100644 sound/soc/codecs/ab8500-codec.h
 create mode 100644 sound/soc/ux500/mop500.c
 create mode 100644 sound/soc/ux500/mop500_ab8500.c
 create mode 100644 sound/soc/ux500/mop500_ab8500.h
 create mode 100644 sound/soc/ux500/ux500_pcm.c
 create mode 100644 sound/soc/ux500/ux500_pcm.h

UAC2 defaults to max sampling rate

adelias — 2012-05-23T07:59:56

Hi,

I'm running ALSA 1.0.23 and kernel 2.6.37 on ARM. The UAC2 audio device 
is the XMOS reference board.

This is what I'm observing. As soon as the XMOS board is plugged in to 
the USB port, the display on my DAC indicates that is has locked at 
192kHz which is the maximum sampling rate supported by the XMOS.

Is this the expected behavior or can I specify the defualt sampling rate 
at start up?

Thanks

[PATCH] alsa-lib conf: Add more USB devices to S/PDIFblacklist

David Henningsson — 2012-05-23T07:59:50

These devices don't have digital in/out, so prevent them from being
opened.

Signed-off-by: David Henningsson <david.henningsson< at >canonical.com>
---
 src/conf/cards/USB-Audio.conf |    4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/conf/cards/USB-Audio.conf b/src/conf/cards/USB-Audio.conf
index 0a0e374..177a7af 100644
--- a/src/conf/cards/USB-Audio.conf
+++ b/src/conf/cards/USB-Audio.conf
< at >< at > -42,6 +42,10 < at >< at > USB-Audio.pcm.iec958_device {
 "Logitech Speaker Lapdesk N700" 999
 "Logitech USB Headset" 999
 "Logitech Wireless Headset" 999
+"Plantronics GameCom 780" 999
+"Plantronics USB Headset" 999
+"Plantronics Wireless Audio" 999
+"SB WoW Headset" 999
 "Sennheiser USB headset" 999
 "USB Device 0x46d:0x992" 999
 }

[PATCH] ASoC: tegra+wm8903: remove non-DT support forSeaboard

Stephen Warren — 2012-05-22T22:11:19

From: Stephen Warren <swarren< at >nvidia.com>

In kernel 3.6, Seaboard will only be supported when booting using device
tree; the board files are being removed. Hence, remove the non-DT support
for Seaboard and derivatives Kaen and Aebl from the audio driver.

Harmony is the only remaining board supported by this driver when not
using DT. This support is currently scheduled for removal in 3.7.

Signed-off-by: Stephen Warren <swarren< at >nvidia.com>
---
This is pretty independent from anything else, but is based on the previous
5-long series I posted in terms of context.

 sound/soc/tegra/tegra_wm8903.c |   48 +--------------------------------------
 1 files changed, 2 insertions(+), 46 deletions(-)

diff --git a/sound/soc/tegra/tegra_wm8903.c b/sound/soc/tegra/tegra_wm8903.c
index 1fd6a41..b75e0e8 100644
--- a/sound/soc/tegra/tegra_wm8903.c
+++ b/sound/soc/tegra/tegra_wm8903.c
< at >< at > -28,8 +28,6 < at >< at >
  *
  */
 
-#include <asm/mach-types.h>
-
 #include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
< at >< at > -196,37 +194,6 < at >< at > static const struct snd_soc_dapm_route harmony_audio_map[] = {
 {"IN1L", NULL, "Mic Jack"},
 };
 
-static const struct snd_soc_dapm_route seaboard_audio_map[] = {
-{"Headphone Jack", NULL, "HPOUTR"},
-{"Headphone Jack", NULL, "HPOUTL"},
-{"Int Spk", NULL, "ROP"},
-{"Int Spk", NULL, "RON"},
-{"Int Spk", NULL, "LOP"},
-{"Int Spk", NULL, "LON"},
-{"Mic Jack", NULL, "MICBIAS"},
-{"IN1R", NULL, "Mic Jack"},
-};
-
-static const struct snd_soc_dapm_route kaen_audio_map[] = {
-{"Headphone Jack", NULL, "HPOUTR"},
-{"Headphone Jack", NULL, "HPOUTL"},
-{"Int Spk", NULL, "ROP"},
-{"Int Spk", NULL, "RON"},
-{"Int Spk", NULL, "LOP"},
-{"Int Spk", NULL, "LON"},
-{"Mic Jack", NULL, "MICBIAS"},
-{"IN2R", NULL, "Mic Jack"},
-};
-
-static const struct snd_soc_dapm_route aebl_audio_map[] = {
-{"Headphone Jack", NULL, "HPOUTR"},
-{"Headphone Jack", NULL, "HPOUTL"},
-{"Int Spk", NULL, "LINEOUTR"},
-{"Int Spk", NULL, "LINEOUTL"},
-{"Mic Jack", NULL, "MICBIAS"},
-{"IN1R", NULL, "Mic Jack"},
-};
-
 static const struct snd_kcontrol_new tegra_wm8903_controls[] = {
 SOC_DAPM_PIN_SWITCH("Int Spk"),
 };
< at >< at > -377,19 +344,8 < at >< at > static __devinit int tegra_wm8903_driver_probe(struct platform_device *pdev)
 tegra_wm8903_dai.platform_of_node =
 tegra_wm8903_dai.cpu_dai_of_node;
 } else {
-if (machine_is_harmony()) {
-card->dapm_routes = harmony_audio_map;
-card->num_dapm_routes = ARRAY_SIZE(harmony_audio_map);
-} else if (machine_is_seaboard()) {
-card->dapm_routes = seaboard_audio_map;
-card->num_dapm_routes = ARRAY_SIZE(seaboard_audio_map);
-} else if (machine_is_kaen()) {
-card->dapm_routes = kaen_audio_map;
-card->num_dapm_routes = ARRAY_SIZE(kaen_audio_map);
-} else {
-card->dapm_routes = aebl_audio_map;
-card->num_dapm_routes = ARRAY_SIZE(aebl_audio_map);
-}
+card->dapm_routes = harmony_audio_map;
+card->num_dapm_routes = ARRAY_SIZE(harmony_audio_map);
 }
 
 if (gpio_is_valid(pdata->gpio_spkr_en)) {

[PATCH 1/2] ALSA: update sync header when streams arelinked/unlinked

Pierre-Louis Bossart — 2012-05-22T19:54:01

Previous code only reported card number and was not updated
when devices were linked/unlinked. This makes alsa-lib
snd_pcm_info_get_sync totally useless.
Add hooks to force update of sync header when devices are
linked/unlinked, and provide more information such as
number of devices and indices of capture/playback devices
linked to

Signed-off-by: Pierre-Louis Bossart <pierre-louis.bossart< at >linux.intel.com>
---
 sound/core/pcm_lib.c    |   37 ++++++++++++++++++++++++++++++++-----
 sound/core/pcm_native.c |    6 ++++++
 2 files changed, 38 insertions(+), 5 deletions(-)

diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c
index faedb14..ae46d75 100644
--- a/sound/core/pcm_lib.c
+++ b/sound/core/pcm_lib.c
< at >< at > -533,11 +533,38 < at >< at > EXPORT_SYMBOL(snd_pcm_set_ops);
 void snd_pcm_set_sync(struct snd_pcm_substream *substream)
 {
 struct snd_pcm_runtime *runtime = substream->runtime;
-
-runtime->sync.id32[0] = substream->pcm->card->number;
-runtime->sync.id32[1] = -1;
-runtime->sync.id32[2] = -1;
-runtime->sync.id32[3] = -1;
+struct snd_pcm_substream *s;
+int dev_c, dev_p;
+
+if (snd_pcm_stream_linked(substream)) {
+runtime->sync.id32[0] = substream->pcm->card->number;
+/* save number of devices linked */
+runtime->sync.id32[1] = substream->group->count-1;
+dev_c = dev_p = 0;
+
+snd_pcm_group_for_each_entry(s, substream) {
+if (s == substream)
+continue;
+if (s->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+dev_p++;
+if (dev_p == 1)
+runtime->sync.id32[2] = 0;
+/* save mask of linked playback devices */
+runtime->sync.id32[2] |= (1<<s->number);
+} else {
+dev_c++;
+if (dev_c == 1)
+runtime->sync.id32[3] = 0;
+/* save mask of linked capture devices */
+runtime->sync.id32[3] |= (1<<s->number);
+}
+}
+} else {
+runtime->sync.id32[0] = -1;
+runtime->sync.id32[1] = -1;
+runtime->sync.id32[2] = -1;
+runtime->sync.id32[3] = -1;
+}
 }
 
 EXPORT_SYMBOL(snd_pcm_set_sync);
diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c
index 3fe99e6..e92bc62 100644
--- a/sound/core/pcm_native.c
+++ b/sound/core/pcm_native.c
< at >< at > -1619,6 +1619,9 < at >< at > static int snd_pcm_link(struct snd_pcm_substream *substream, int fd)
 list_add_tail(&substream1->link_list, &substream->group->substreams);
 substream->group->count++;
 substream1->group = substream->group;
+snd_pcm_set_sync(substream);
+snd_pcm_set_sync(substream1);
+
  _end:
 write_unlock_irq(&snd_pcm_link_rwlock);
 up_write(&snd_pcm_link_rwsem);
< at >< at > -1652,11 +1655,14 < at >< at > static int snd_pcm_unlink(struct snd_pcm_substream *substream)
 if (substream->group->count == 1) {/* detach the last stream, too */
 snd_pcm_group_for_each_entry(s, substream) {
 relink_to_local(s);
+snd_pcm_set_sync(s);
 break;
 }
 kfree(substream->group);
 }
 relink_to_local(substream);
+snd_pcm_set_sync(substream);
+
        _end:
 write_unlock_irq(&snd_pcm_link_rwlock);
 up_write(&snd_pcm_link_rwsem);

[PATCH 3/3] sb_mixer: Add extended SB16 mixer controlsfor newer chips

Ondrej Zary — 2012-05-22T19:45:04

Newer SB16 chips (Vibra 16C and later) have extended mixer controls.
This detects them and enables automatically if present.

Supported extended controls:
Synth Playback Switch
PCM Playback Switch
Beep Playback Switch
Master Playback Switch
PCM Capture Switch
Master Capture Volume
Master Capture Switch

Vibra 16XV has an additional Aux input which is used on
SF16-FMD and SF16-FMD2 cards to connect the onboard FM tuner:
Aux Playback Switch
Aux Volume
Aux Capture Switch

Signed-off-by: Ondrej Zary <linux< at >rainbow-software.org>

--- a/include/sound/sb.h
+++ b/include/sound/sb.h
< at >< at > -214,6 +214,12 < at >< at > struct snd_sb {
 #define SB_DSP4_IGAIN_DEV0x3f
 #define SB_DSP4_OGAIN_DEV0x41
 #define SB_DSP4_MIC_AGC0x43
+/* extended registers for newer SB16 */
+#define SB_DSP4_OUTPUT2_SW0x48
+#define SB_DSP4_MASTER_SW0x49
+#define SB_DSP4_INPUT2_SW0x4a
+#define SB_DSP4_MASTER_REC_DEV0x50
+#define SB_DSP4_AUX_DEV0x52
 
 /* additional registers for SB 16 mixer */
 #define SB_DSP4_IRQSETUP0x80
--- a/sound/isa/sb/sb_mixer.c
+++ b/sound/isa/sb/sb_mixer.c
< at >< at > -615,6 +615,38 < at >< at > static struct sbmix_elem snd_sb16_gain_ctls[] = {
   SB_DSP4_OGAIN_DEV, (SB_DSP4_OGAIN_DEV + 1), 6, 6, 3),
 };
 
+static struct sbmix_elem snd_sb16_output2_ctls[] = {
+SB_DOUBLE("Synth Playback Switch",
+  SB_DSP4_OUTPUT2_SW, SB_DSP4_OUTPUT2_SW, 4, 3, 1),
+SB_DOUBLE("PCM Playback Switch",
+  SB_DSP4_OUTPUT2_SW, SB_DSP4_OUTPUT2_SW, 2, 1, 1),
+SB_SINGLE("Beep Playback Switch", SB_DSP4_OUTPUT2_SW, 0, 1),
+};
+
+static struct sbmix_elem snd_sb16_master_sw_ctl =
+SB_DOUBLE("Master Playback Switch",
+  SB_DSP4_MASTER_SW, SB_DSP4_MASTER_SW, 3, 2, 1);
+
+static struct sbmix_elem snd_sb16_pcm_capture_sw_ctl =
+SB_DOUBLE("PCM Capture Switch",
+  SB_DSP4_INPUT2_SW, SB_DSP4_INPUT2_SW, 1, 0, 1);
+
+static struct sbmix_elem snd_sb16_master_rec_ctls[] = {
+SB_DOUBLE("Master Capture Volume",
+  SB_DSP4_MASTER_REC_DEV, (SB_DSP4_MASTER_REC_DEV + 1), 3, 3, 31),
+SB_DOUBLE("Master Capture Switch",
+  SB_DSP4_MASTER_SW, SB_DSP4_MASTER_SW, 1, 0, 1),
+};
+
+static struct sbmix_elem snd_sb16_aux_ctls[] = {
+SB_DOUBLE("Aux Playback Switch",
+  SB_DSP4_OUTPUT2_SW, SB_DSP4_OUTPUT2_SW, 6, 5, 1),
+SB_DOUBLE("Aux Volume",
+  SB_DSP4_AUX_DEV, (SB_DSP4_AUX_DEV + 1), 3, 3, 31),
+SB_DOUBLE("Aux Capture Switch",
+  SB_DSP4_INPUT2_SW, SB_DSP4_INPUT2_SW, 3, 2, 1),
+};
+
 static struct sbmix_elem snd_sb16_3d_ctl =
 SB_SINGLE("3D Control - Switch", SB_DSP4_3DSE, 0, 1);
 
< at >< at > -789,6 +821,43 < at >< at > static int snd_sbmixer_sb16_opt_init(struct snd_sb *chip)
 if (err < 0)
 return err;
 }
+/* CT8903 has the following registers but they don't do anything */
+if (sb16_type == CT8903)
+return 0;
+/* additional playback switches */
+if ((snd_sbmixer_read(chip, SB_DSP4_OUTPUT2_SW) & 0x9f) == 0x1f)
+for (idx = 0; idx < ARRAY_SIZE(snd_sb16_output2_ctls); idx++) {
+err = snd_sbmixer_add_ctl_elem(chip, &snd_sb16_output2_ctls[idx]);
+if (err < 0)
+return err;
+}
+/* master playback switch */
+if ((snd_sbmixer_read(chip, SB_DSP4_MASTER_SW) & 0xfc) == 0x0c) {
+err = snd_sbmixer_add_ctl_elem(chip, &snd_sb16_master_sw_ctl);
+if (err < 0)
+return err;
+}
+/* PCM capture switch */
+snd_sbmixer_write(chip, SB_DSP4_INPUT2_SW, 0xff);
+if ((snd_sbmixer_read(chip, SB_DSP4_INPUT2_SW) & 0xf3) == 0x03) {
+err = snd_sbmixer_add_ctl_elem(chip, &snd_sb16_pcm_capture_sw_ctl);
+if (err < 0)
+return err;
+}
+/* master capture volume + switch (CT2511) */
+if (snd_sbmixer_read(chip, SB_DSP4_MASTER_REC_DEV) == 0xe0)
+for (idx = 0; idx < ARRAY_SIZE(snd_sb16_master_rec_ctls); idx++) {
+err = snd_sbmixer_add_ctl_elem(chip, &snd_sb16_master_rec_ctls[idx]);
+if (err < 0)
+return err;
+}
+/* Aux input + switches (CT2511) */
+if (snd_sbmixer_read(chip, SB_DSP4_AUX_DEV) == 0xc0)
+for (idx = 0; idx < ARRAY_SIZE(snd_sb16_aux_ctls); idx++) {
+err = snd_sbmixer_add_ctl_elem(chip, &snd_sb16_aux_ctls[idx]);
+if (err < 0)
+return err;
+}
 
 return 0;
 }

[PATCH 2/3] sb_mixer: Autodetect optional SB16 mixercontrols

Ondrej Zary — 2012-05-22T19:44:55

Tone (bass/treble), gain and 3D mixer controls are not present on all SB16 cards.

This attempts to detect chip type and enable them only if they're really present.

Signed-off-by: Ondrej Zary <linux< at >rainbow-software.org>

--- a/sound/isa/sb/sb_mixer.c
+++ b/sound/isa/sb/sb_mixer.c
< at >< at > -592,10 +592,6 < at >< at > static struct sbmix_elem snd_sb16_controls[] = {
 SB_SINGLE("Mic Playback Switch", SB_DSP4_OUTPUT_SW, 0, 1),
 SB_SINGLE("Mic Volume", SB_DSP4_MIC_DEV, 3, 31),
 SB_SINGLE("Beep Volume", SB_DSP4_SPEAKER_DEV, 6, 3),
-SB_DOUBLE("Gain Capture Volume",
-  SB_DSP4_IGAIN_DEV, (SB_DSP4_IGAIN_DEV + 1), 6, 6, 3),
-SB_DOUBLE("Gain Playback Volume",
-  SB_DSP4_OGAIN_DEV, (SB_DSP4_OGAIN_DEV + 1), 6, 6, 3),
 SB16_INPUT_SW("Line Capture Route",
       SB_DSP4_INPUT_LEFT, SB_DSP4_INPUT_RIGHT, 4, 3),
 SB_DOUBLE("Line Playback Switch",
< at >< at > -603,13 +599,25 < at >< at > static struct sbmix_elem snd_sb16_controls[] = {
 SB_DOUBLE("Line Volume",
   SB_DSP4_LINE_DEV, (SB_DSP4_LINE_DEV + 1), 3, 3, 31),
 SB_SINGLE("Mic Auto Gain", SB_DSP4_MIC_AGC, 0, 1),
-SB_SINGLE("3D Control - Switch", SB_DSP4_3DSE, 0, 1),
+};
+
+static struct sbmix_elem snd_sb16_tone_ctls[] = {
 SB_DOUBLE("Tone Control - Bass",
   SB_DSP4_BASS_DEV, (SB_DSP4_BASS_DEV + 1), 4, 4, 15),
 SB_DOUBLE("Tone Control - Treble",
-  SB_DSP4_TREBLE_DEV, (SB_DSP4_TREBLE_DEV + 1), 4, 4, 15)
+  SB_DSP4_TREBLE_DEV, (SB_DSP4_TREBLE_DEV + 1), 4, 4, 15),
+};
+
+static struct sbmix_elem snd_sb16_gain_ctls[] = {
+SB_DOUBLE("Gain Capture Volume",
+  SB_DSP4_IGAIN_DEV, (SB_DSP4_IGAIN_DEV + 1), 6, 6, 3),
+SB_DOUBLE("Gain Playback Volume",
+  SB_DSP4_OGAIN_DEV, (SB_DSP4_OGAIN_DEV + 1), 6, 6, 3),
 };
 
+static struct sbmix_elem snd_sb16_3d_ctl =
+SB_SINGLE("3D Control - Switch", SB_DSP4_3DSE, 0, 1);
+
 static unsigned char snd_sb16_init_values[][2] = {
 { SB_DSP4_MASTER_DEV + 0, 0 },
 { SB_DSP4_MASTER_DEV + 1, 0 },
< at >< at > -720,6 +728,71 < at >< at > static unsigned char snd_als4000_init_values[][2] = {
 { SB_ALS4000_MIC_IN_GAIN, 0 },
 };
 
+static int snd_sbmixer_sb16_opt_init(struct snd_sb *chip)
+{
+int idx, err;
+enum { CLASSIC, CT2504, CT2505, CT2511, CT8903, CT8920 } sb16_type;
+/*
+   The detection is a mess because some chips have registers that
+   appear to work (read/write) but don't do anything. This applies
+   mainly to tone controls which are present on all SB16 cards but
+   do nothing on all Vibra chips except CT2502. Also CT8903 appears to
+   have additional switch registers but they have no effect too.
+   CT8920 has non-working gain.
+
+   This tries to detect chip type. CLASSIC means older non-integrated
+   cards (CT1746/CT1747/CT1749 + CT1745 mixer).
+   No detection code for CT2501 Vibra 16, CT2502 Vibra 16Pro,
+   CT2508 Vibra 16CL and CT2510 Vibra 16X (lack of HW for testing).
+*/
+sb16_type = CLASSIC;
+if (snd_sbmixer_read(chip, SB_DSP4_IRQSTATUS) & 0x40) {
+/* read chip ID (only present on newer (PnP?) chips) */
+u16 id = snd_sbmixer_read(chip, 0xfd) |
+ snd_sbmixer_read(chip, 0xfe) << 8;
+printk("sb16 id=0x%04x\n", id);
+switch (id) {
+case 0xffff:/* No ID? Assume CT2504 Vibra 16S */
+sb16_type = CT2504;
+break;
+case 0x0721:/* CT2505 Vibra 16C */
+sb16_type = CT2505;
+break;
+case 0x0810:/* CT2511 Vibra 16XV */
+sb16_type = CT2511;
+break;
+case 0x1190:/* CT8903 AWE64 */
+sb16_type = CT8903;
+break;
+case 0x1241:/* CT8920 AWE64 */
+sb16_type = CT8920;
+break;
+}
+}
+/* tone controls */
+if (sb16_type == CLASSIC || sb16_type == CT8903 || sb16_type == CT8920)
+for (idx = 0; idx < ARRAY_SIZE(snd_sb16_tone_ctls); idx++) {
+err = snd_sbmixer_add_ctl_elem(chip, &snd_sb16_tone_ctls[idx]);
+if (err < 0)
+return err;
+}
+/* gain */
+if (sb16_type == CLASSIC || sb16_type == CT8903)
+for (idx = 0; idx < ARRAY_SIZE(snd_sb16_gain_ctls); idx++) {
+err = snd_sbmixer_add_ctl_elem(chip, &snd_sb16_gain_ctls[idx]);
+if (err < 0)
+return err;
+}
+/* 3D Stereo Enhancement */
+if (snd_sbmixer_read(chip, SB_DSP4_3DSE) != 0xff) {
+err = snd_sbmixer_add_ctl_elem(chip, &snd_sb16_3d_ctl);
+if (err < 0)
+return err;
+}
+
+return 0;
+}
+
 /*
  */
 static int snd_sbmixer_init(struct snd_sb *chip,
< at >< at > -750,6 +823,14 < at >< at > static int snd_sbmixer_init(struct snd_sb *chip,
 if (err < 0)
 return err;
 }
+
+/* detect optional SB16 controls */
+if (controls == snd_sb16_controls) {
+err = snd_sbmixer_sb16_opt_init(chip);
+if (err < 0)
+return err;
+}
+
 snd_component_add(card, name);
 strcpy(card->mixername, name);
 return 0;

[PATCH 1/3] sb_mixer: Correct SB16 mixer control names

Ondrej Zary — 2012-05-22T19:44:47

SB16 volume controls affect both playback and recording. Correct the volume controls to match that.
(Beep volume was already correct).

Correct misleading "Capture Volume" and "Playback Volume" names - they're in fact gain controls.

Also change "3D Enhancement Switch" to standard name "3D Control - Switch".

Signed-off-by: Ondrej Zary <linux< at >rainbow-software.org>

--- a/sound/isa/sb/sb_mixer.c
+++ b/sound/isa/sb/sb_mixer.c
< at >< at > -579,31 +579,31 < at >< at > static struct sbmix_elem snd_sb16_controls[] = {
   SB_DSP4_PCM_DEV, (SB_DSP4_PCM_DEV + 1), 3, 3, 31),
 SB16_INPUT_SW("Synth Capture Route",
       SB_DSP4_INPUT_LEFT, SB_DSP4_INPUT_RIGHT, 6, 5),
-SB_DOUBLE("Synth Playback Volume",
+SB_DOUBLE("Synth Volume",
   SB_DSP4_SYNTH_DEV, (SB_DSP4_SYNTH_DEV + 1), 3, 3, 31),
 SB16_INPUT_SW("CD Capture Route",
       SB_DSP4_INPUT_LEFT, SB_DSP4_INPUT_RIGHT, 2, 1),
 SB_DOUBLE("CD Playback Switch",
   SB_DSP4_OUTPUT_SW, SB_DSP4_OUTPUT_SW, 2, 1, 1),
-SB_DOUBLE("CD Playback Volume",
+SB_DOUBLE("CD Volume",
   SB_DSP4_CD_DEV, (SB_DSP4_CD_DEV + 1), 3, 3, 31),
 SB16_INPUT_SW("Mic Capture Route",
       SB_DSP4_INPUT_LEFT, SB_DSP4_INPUT_RIGHT, 0, 0),
 SB_SINGLE("Mic Playback Switch", SB_DSP4_OUTPUT_SW, 0, 1),
-SB_SINGLE("Mic Playback Volume", SB_DSP4_MIC_DEV, 3, 31),
+SB_SINGLE("Mic Volume", SB_DSP4_MIC_DEV, 3, 31),
 SB_SINGLE("Beep Volume", SB_DSP4_SPEAKER_DEV, 6, 3),
-SB_DOUBLE("Capture Volume",
+SB_DOUBLE("Gain Capture Volume",
   SB_DSP4_IGAIN_DEV, (SB_DSP4_IGAIN_DEV + 1), 6, 6, 3),
-SB_DOUBLE("Playback Volume",
+SB_DOUBLE("Gain Playback Volume",
   SB_DSP4_OGAIN_DEV, (SB_DSP4_OGAIN_DEV + 1), 6, 6, 3),
 SB16_INPUT_SW("Line Capture Route",
       SB_DSP4_INPUT_LEFT, SB_DSP4_INPUT_RIGHT, 4, 3),
 SB_DOUBLE("Line Playback Switch",
   SB_DSP4_OUTPUT_SW, SB_DSP4_OUTPUT_SW, 4, 3, 1),
-SB_DOUBLE("Line Playback Volume",
+SB_DOUBLE("Line Volume",
   SB_DSP4_LINE_DEV, (SB_DSP4_LINE_DEV + 1), 3, 3, 31),
 SB_SINGLE("Mic Auto Gain", SB_DSP4_MIC_AGC, 0, 1),
-SB_SINGLE("3D Enhancement Switch", SB_DSP4_3DSE, 0, 1),
+SB_SINGLE("3D Control - Switch", SB_DSP4_3DSE, 0, 1),
 SB_DOUBLE("Tone Control - Bass",
   SB_DSP4_BASS_DEV, (SB_DSP4_BASS_DEV + 1), 4, 4, 15),
 SB_DOUBLE("Tone Control - Treble",

[GIT PULL] ASoC updates for 3.5

Liam Girdwood — 2012-05-22T17:19:25

Hi Takashi,

It's mainly OMAP4 HDMI updates from Ricardo using the new DSS audio
interface and Device Tree updates from Peter for OMAP.

Thanks

Liam 

---

The following changes since commit 766812e6d5e2e23be1e212cf84902d5e834dd865:

  ASoC: sh: fsi: enable chip specific data transfer mode (2012-05-19 19:41:45 +0100)

are available in the git repository at:

  git://git.kernel.org/pub/scm/linux/kernel/git/lrg/asoc.git for-3.5

for you to fetch changes up to ced47a3117ba084b404f3fc28de3ef6eaba1b911:

  ASoC: OMAP: HDMI: Rename sound card source file (2012-05-22 17:33:24 +0100)

----------------------------------------------------------------
Peter Ujfalusi (9):
      ASoC: omap-mcbsp: Use DMA packet mode for non mono streams on OMAP3+
      ASoC: omap-mcbsp: Remove unused FRAME dma_op_mode
      ASoC: omap-mcbsp: Use the common interrupt line if supported by the SoC
      ASoC: omap-mcbsp: buffer size constraint only applies to playback stream
      ASoC: omap-mcpdm: Add device tree bindings
      ASoC: omap-dmic: Add device tree bindings
      ASoC: omap-abe-twl6040: Keep only one snd_soc_dai_link structure
      ASoC: omap-abe-twl6040: Move Digital Mic widget into dapm table
      ASoC: omap-abe-twl6040: Introduce driver data for runtime parameters

Ricardo Neri (10):
      ASoC: OMAP: HDMI: Update the platform device names
      ASoC: OMAP: HDMI: Change error values in HDMI CPU DAI
      ASoC: OMAP: HDMI: Create a structure for private data of the CPU DAI
      ASoC: OMAP: HDMI: Use the DSS audio interface
      ASoC: OMAP: HDMI: Expand configuration of hw_params
      ASoC: OMAP: HDMI: Improve how the display state is verified
      ASoC: OMAP: HDMI: Expand capabilities of the HDMI DAI
      ASoC: OMAP: HDMI: Make build config options more generic
      ASoC: OMAP: HDMI: Make sound card naming more generic
      ASoC: OMAP: HDMI: Rename sound card source file

 .../devicetree/bindings/sound/omap-dmic.txt        |   21 ++
 .../devicetree/bindings/sound/omap-mcpdm.txt       |   21 ++
 sound/soc/omap/Kconfig                             |    7 +-
 sound/soc/omap/Makefile                            |    4 +-
 sound/soc/omap/mcbsp.c                             |  115 ++++++++--
 sound/soc/omap/mcbsp.h                             |    8 +-
 sound/soc/omap/omap-abe-twl6040.c                  |   68 +++---
 sound/soc/omap/omap-dmic.c                         |    8 +
 sound/soc/omap/omap-hdmi-card.c                    |   87 +++++++
 sound/soc/omap/omap-hdmi.c                         |  238 ++++++++++++++++++--
 sound/soc/omap/omap-hdmi.h                         |    4 +-
 sound/soc/omap/omap-mcbsp.c                        |   45 ++--
 sound/soc/omap/omap-mcpdm.c                        |    8 +
 sound/soc/omap/omap4-hdmi-card.c                   |  121 ----------
 14 files changed, 531 insertions(+), 224 deletions(-)
 create mode 100644 Documentation/devicetree/bindings/sound/omap-dmic.txt
 create mode 100644 Documentation/devicetree/bindings/sound/omap-mcpdm.txt
 create mode 100644 sound/soc/omap/omap-hdmi-card.c
 delete mode 100644 sound/soc/omap/omap4-hdmi-card.c

ASoC updates for 3.5

Mark Brown — 2012-05-21T14:57:41

The following changes since commit 5fb86e5d4a951ddb0474cdfd809380c8e2a8d101:

  ARM: mx31_3ds: Add sound support (2012-05-18 16:42:44 +0100)

are available in the git repository at:

  git://git.kernel.org/pub/scm/linux/kernel/git/broonie/sound.git tags/asoc-3.5

for you to fetch changes up to 766812e6d5e2e23be1e212cf84902d5e834dd865:

  ASoC: sh: fsi: enable chip specific data transfer mode (2012-05-19 19:41:45 +0100)

----------------------------------------------------------------
ASoC: Last minute updates

These are all new code, they've been in -next already so should be OK
for merge this time round.  I'd been planning to send a pull request
today after they'd had a bit of exposure there to make sure breakage
didn't propagate into your tree.

----------------------------------------------------------------
Kuninori Morimoto (5):
      ASoC: sh: fsi: use register field macro name on IN/OUT_DMAC
      ASoC: sh: fsi: add fsi_version() and removed meaningless version check
      ASoC: sh: fsi: use same format for IN/OUT
      ASoC: sh: fsi: call fsi_hw_startup/shutdown from fsi_dai_trigger()
      ASoC: sh: fsi: enable chip specific data transfer mode

Ricardo Neri (1):
      ASoC: OMAP: HDMI: Introduce codec

Stephen Warren (1):
      ASoC: tegra: Add machine driver for WM8753 codec

 .../bindings/sound/tegra-audio-wm8753.txt          |   54 +++++
 include/sound/sh_fsi.h                             |    6 +-
 sound/soc/codecs/Kconfig                           |    4 +
 sound/soc/codecs/Makefile                          |    2 +
 sound/soc/codecs/omap-hdmi.c                       |   69 ++++++
 sound/soc/omap/Kconfig                             |    1 +
 sound/soc/sh/fsi.c                                 |  224 ++++++++++++++------
 sound/soc/tegra/Kconfig                            |   10 +
 sound/soc/tegra/Makefile                           |    2 +
 sound/soc/tegra/tegra_wm8753.c                     |  224 ++++++++++++++++++++
 10 files changed, 529 insertions(+), 67 deletions(-)
 create mode 100644 Documentation/devicetree/bindings/sound/tegra-audio-wm8753.txt
 create mode 100644 sound/soc/codecs/omap-hdmi.c
 create mode 100644 sound/soc/tegra/tegra_wm8753.c