diff --git a/include/dt-bindings/sound/pistachio-audio.h b/include/dt-bindings/sound/pistachio-audio.h
new file mode 100644
index 0000000..ac34261
--- /dev/null
+++ b/include/dt-bindings/sound/pistachio-audio.h
@@ -0,0 +1,7 @@
+#ifndef __PISTACHIO_AUDIO_H
+#define __PISTACHIO_AUDIO_H
+
+#define PISTACHIO_MCLK_I2S		0
+#define PISTACHIO_MCLK_DAC		1
+
+#endif
diff --git a/sound/soc/img/Kconfig b/sound/soc/img/Kconfig
index 857a951..dd010cb 100644
--- a/sound/soc/img/Kconfig
+++ b/sound/soc/img/Kconfig
@@ -50,3 +50,14 @@ config SND_SOC_IMG_PISTACHIO_INTERNAL_DAC
 	help
 	  Say Y or M if you want to add support for Pistachio internal DAC
 	  driver for Imagination Technologies Pistachio internal DAC device.
+
+config SND_SOC_IMG_PISTACHIO
+	tristate "Audio support for Pistachio SoC"
+	depends on SND_SOC_IMG
+	depends on COMMON_CLK
+	select SND_SOC_IMG_I2S_IN
+	select SND_SOC_IMG_I2S_OUT
+	select SND_SOC_IMG_PARALLEL_OUT
+	select SND_SOC_IMG_SPDIF_IN
+	select SND_SOC_IMG_SPDIF_OUT
+	select SND_SOC_IMG_PISTACHIO_INTERNAL_DAC
\ No newline at end of file
diff --git a/sound/soc/img/Makefile b/sound/soc/img/Makefile
index 0508c1c..e72024f 100644
--- a/sound/soc/img/Makefile
+++ b/sound/soc/img/Makefile
@@ -5,3 +5,4 @@ obj-$(CONFIG_SND_SOC_IMG_SPDIF_IN) += img-spdif-in.o
 obj-$(CONFIG_SND_SOC_IMG_SPDIF_OUT) += img-spdif-out.o
 
 obj-$(CONFIG_SND_SOC_IMG_PISTACHIO_INTERNAL_DAC) += pistachio-internal-dac.o
+obj-$(CONFIG_SND_SOC_IMG_PISTACHIO) += pistachio.o
\ No newline at end of file
diff --git a/sound/soc/img/pistachio.c b/sound/soc/img/pistachio.c
new file mode 100644
index 0000000..b8d387a
--- /dev/null
+++ b/sound/soc/img/pistachio.c
@@ -0,0 +1,2249 @@
+/*
+ * Pistachio audio card driver
+ *
+ * Copyright (C) 2015 Imagination Technologies Ltd.
+ *
+ * Author: Damien Horsley <Damien.Horsley@imgtec.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ */
+
+
+#include <linux/clk.h>
+#include <linux/device.h>
+#include <linux/module.h>
+#include <linux/notifier.h>
+#include <linux/of_gpio.h>
+#include <linux/of_platform.h>
+#include <linux/platform_device.h>
+#include <linux/regmap.h>
+#include <linux/mfd/syscon.h>
+#include <sound/jack.h>
+#include <sound/soc.h>
+#include <dt-bindings/sound/pistachio-audio.h>
+
+#define PISTACHIO_PLL_RATE_A		147456000
+#define PISTACHIO_PLL_RATE_B		135475200
+#define PISTACHIO_MAX_DIV		256
+#define PISTACHIO_MIN_MCLK_FREQ		(135475200 / 256)
+
+#define PISTACHIO_CLOCK_MASTER_EXT	-1
+#define PISTACHIO_CLOCK_MASTER_LOOPBACK	-2
+
+#define PISTACHIO_MAX_I2S_CODECS	12
+
+#define PISTACHIO_MAX_FS_RATES		20
+
+#define PISTACHIO_I2S_MCLK_MAX_FREQ	200000000
+#define PISTACHIO_DAC_MCLK_MAX_FREQ	200000000
+
+#define PISTACHIO_INTERNAL_DAC_PREFIX	"internal-dac"
+#define PISTACHIO_I2S_OUT_PREFIX	"i2s-out"
+#define PISTACHIO_I2S_IN_PREFIX		"i2s-in"
+
+#define PISTACHIO_I2S_MCLK_NAME		"i2s_mclk"
+#define PISTACHIO_DAC_MCLK_NAME		"dac_mclk"
+
+#define PISTACHIO_I2S_OUTPUT_NAME	"I2S OUTPUT"
+#define PISTACHIO_I2S_INPUT_NAME	"I2S INPUT"
+
+#define PISTACHIO_I2S_LOOPBACK_REG		0x88
+#define PISTACHIO_I2S_LOOPBACK_CLK_MASK		0x3
+
+#define PISTACHIO_I2S_LOOPBACK_CLK_NONE		0
+#define PISTACHIO_I2S_LOOPBACK_CLK_LOCAL	2
+
+#define PISTACHIO_MAX_DAPM_ROUTES		6
+
+struct pistachio_audio_output {
+	unsigned int active_rate;
+};
+
+struct pistachio_parallel_out {
+	struct pistachio_audio_output output;
+	struct snd_soc_dai_link_component component;
+};
+
+struct pistachio_mclk {
+	char *name;
+	struct clk *mclk;
+	unsigned int cur_rate;
+	unsigned int max_rate;
+};
+
+struct pistachio_i2s_mclk {
+	struct pistachio_mclk *mclk;
+	unsigned int *fs_rates;
+	unsigned int num_fs_rates;
+	unsigned int min_rate;
+	unsigned int max_rate;
+};
+
+struct pistachio_codec_i2s {
+	struct pistachio_mclk *mclk;
+	struct snd_soc_dai *dai;
+	unsigned int mclk_index;
+};
+
+struct pistachio_i2s {
+	struct pistachio_i2s_mclk mclk_a;
+	struct pistachio_i2s_mclk mclk_b;
+	struct pistachio_codec_i2s *codecs;
+	struct snd_soc_dai_link_component *components;
+	unsigned int num_codecs;
+};
+
+struct pistachio_i2s_out {
+	struct pistachio_i2s i2s;
+	struct pistachio_audio_output output;
+};
+
+struct pistachio_i2s_in {
+	struct pistachio_i2s i2s;
+	unsigned int active_rate;
+	unsigned int fmt;
+	int frame_master;
+	int bitclock_master;
+};
+
+struct pistachio_i2s_codec_info_s {
+	const char *prefix;
+	const char *dai_name;
+	struct device_node *np;
+	struct pistachio_mclk *mclk;
+	unsigned int mclk_index;
+};
+
+struct pistachio_i2s_codec_info {
+	unsigned int total_codecs;
+	unsigned int unique_codecs;
+	int bitclock_master_idx;
+	int frame_master_idx;
+	struct pistachio_i2s_codec_info_s codecs[PISTACHIO_MAX_I2S_CODECS];
+};
+
+struct pistachio_i2s_mclk_info {
+	unsigned int fs_rates[PISTACHIO_MAX_FS_RATES];
+	unsigned int num_fs_rates;
+	unsigned int min_rate;
+	unsigned int max_rate;
+};
+
+struct pistachio_card {
+	struct pistachio_audio_output *spdif_out;
+	struct pistachio_parallel_out *parallel_out;
+	struct pistachio_i2s_out *i2s_out;
+	struct pistachio_i2s_in *i2s_in;
+	bool spdif_in;
+	struct snd_soc_card card;
+	struct snd_soc_jack hp_jack;
+	struct snd_soc_jack_pin hp_jack_pin;
+	struct snd_soc_jack_gpio hp_jack_gpio;
+	unsigned int mute_gpio;
+	bool mute_gpio_inverted;
+	struct mutex rate_mutex;
+	struct clk *audio_pll;
+	unsigned int audio_pll_rate;
+	struct pistachio_mclk i2s_mclk;
+	struct pistachio_mclk dac_mclk;
+	struct regmap *periph_regs;
+	struct notifier_block i2s_clk_notifier;
+	struct snd_soc_dapm_route routes[PISTACHIO_MAX_DAPM_ROUTES];
+};
+
+static const struct snd_soc_dapm_widget pistachio_card_widgets[] = {
+	SND_SOC_DAPM_CLOCK_SUPPLY(PISTACHIO_I2S_MCLK_NAME),
+	SND_SOC_DAPM_CLOCK_SUPPLY(PISTACHIO_DAC_MCLK_NAME),
+	SND_SOC_DAPM_OUTPUT(PISTACHIO_I2S_OUTPUT_NAME),
+	SND_SOC_DAPM_INPUT(PISTACHIO_I2S_INPUT_NAME)
+};
+
+static int pistachio_card_set_sysclk_s(struct pistachio_codec_i2s *codec,
+				       unsigned int rate, struct device *dev)
+{
+	int ret;
+
+	ret = snd_soc_dai_set_sysclk(codec->dai, codec->mclk_index,
+				     rate, SND_SOC_CLOCK_IN);
+	if (ret)
+		dev_err(dev, "snd_soc_dai_set_sysclk failed: %d", ret);
+
+	return ret;
+}
+
+static int pistachio_card_set_sysclk(struct pistachio_i2s *i2s,
+				     struct pistachio_mclk *mclk,
+				     struct device *dev)
+{
+	int i, ret;
+	struct pistachio_codec_i2s *codec;
+	unsigned int rate = mclk->cur_rate;
+
+	for (i = 0; i < i2s->num_codecs; i++) {
+		codec = &i2s->codecs[i];
+		if (codec->mclk == mclk) {
+			ret = pistachio_card_set_sysclk_s(codec, rate, dev);
+			if (ret)
+				return ret;
+		}
+	}
+
+	return 0;
+}
+
+static int pistachio_card_set_mclk_codecs(struct pistachio_card *pbc,
+					  struct pistachio_mclk *mclk)
+{
+	int ret;
+	struct device *dev = pbc->card.dev;
+
+	if (pbc->i2s_out) {
+		ret = pistachio_card_set_sysclk(&pbc->i2s_out->i2s, mclk, dev);
+		if (ret)
+			return ret;
+	}
+
+	if (pbc->i2s_in) {
+		ret = pistachio_card_set_sysclk(&pbc->i2s_in->i2s, mclk, dev);
+		if (ret)
+			return ret;
+	}
+
+	return 0;
+}
+
+static bool pistachio_card_mclk_active(struct pistachio_card *pbc,
+				       struct pistachio_mclk *mclk)
+{
+	if (pbc->i2s_out && pbc->i2s_out->output.active_rate) {
+		if (pbc->i2s_out->i2s.mclk_a.mclk == mclk)
+			return true;
+		if (pbc->i2s_out->i2s.mclk_b.mclk == mclk)
+			return true;
+	}
+
+	if (pbc->i2s_in && pbc->i2s_in->active_rate) {
+		if (pbc->i2s_in->i2s.mclk_a.mclk == mclk)
+			return true;
+		if (pbc->i2s_in->i2s.mclk_b.mclk == mclk)
+			return true;
+	}
+
+	return false;
+}
+
+static int pistachio_card_set_mclk(struct pistachio_card *pbc,
+				   struct pistachio_mclk *mclk,
+				   unsigned int rate)
+{
+	int ret;
+	unsigned int old_rate = mclk->cur_rate;
+	struct device *dev = pbc->card.dev;
+
+	if (pistachio_card_mclk_active(pbc, mclk)) {
+		dev_err(dev, "%s in use, cannot change rate\n", mclk->name);
+		return -EBUSY;
+	}
+
+	/*
+	 * Set cur_rate before the clk_set_rate call to stop the i2s
+	 * mclk rate change callback rejecting the change
+	 */
+	mclk->cur_rate = rate;
+	ret = clk_set_rate(mclk->mclk, rate);
+	if (ret) {
+		dev_err(dev, "clk_set_rate(%s, %u) failed: %d\n",
+			mclk->name, rate, ret);
+		mclk->cur_rate = old_rate;
+		return ret;
+	}
+
+	return pistachio_card_set_mclk_codecs(pbc, mclk);
+}
+
+static int pistachio_card_set_pll_rate(struct pistachio_card *pbc,
+				       unsigned int rate)
+{
+	int ret;
+	unsigned int old_i2s_rate;
+	struct device *dev = pbc->card.dev;
+
+	/*
+	 * If any configured streams are currently using a clock derived
+	 * from the audio pll, a pll rate change cannot take place
+	 */
+	if ((pbc->spdif_out && pbc->spdif_out->active_rate) ||
+	    (pbc->parallel_out && pbc->parallel_out->output.active_rate) ||
+	    (pbc->i2s_out && pbc->i2s_out->output.active_rate) ||
+	    (pbc->i2s_in && pbc->i2s_in->active_rate &&
+	    pbc->i2s_in->i2s.mclk_a.mclk)) {
+		dev_err(dev, "audio pll in use, cannot change rate\n");
+		return -EBUSY;
+	}
+
+	/*
+	 * Set cur_rate before the clk_set_rate call to stop the i2s
+	 * mclk rate change callback rejecting the change
+	 */
+	old_i2s_rate = pbc->i2s_mclk.cur_rate;
+	pbc->i2s_mclk.cur_rate = rate / (pbc->audio_pll_rate / old_i2s_rate);
+
+	ret = clk_set_rate(pbc->audio_pll, rate);
+	if (ret) {
+		dev_err(dev, "clk_set_rate(audio_pll, %u) failed: %d\n",
+			rate, ret);
+		pbc->i2s_mclk.cur_rate = old_i2s_rate;
+		return ret;
+	}
+
+	pbc->audio_pll_rate = rate;
+
+	pbc->dac_mclk.cur_rate = rate / (pbc->audio_pll_rate /
+					 pbc->dac_mclk.cur_rate);
+
+	ret = pistachio_card_set_mclk_codecs(pbc, &pbc->i2s_mclk);
+	if (ret)
+		return ret;
+
+	return pistachio_card_set_mclk_codecs(pbc, &pbc->dac_mclk);
+}
+
+static void pistachio_card_rate_err(struct pistachio_card *pbc,
+			struct pistachio_i2s_mclk *mclk_a,
+			struct pistachio_i2s_mclk *mclk_b,
+			unsigned int rate_a, unsigned int rate_b)
+{
+	char *dir_a, *dir_b;
+	struct device *dev = pbc->card.dev;
+
+	if (pbc->i2s_out && ((mclk_a == &pbc->i2s_out->i2s.mclk_a) ||
+			     (mclk_a == &pbc->i2s_out->i2s.mclk_b))) {
+		dir_a = "I2S out";
+	} else {
+		dir_a = "I2S in";
+	}
+
+	if (pbc->i2s_out && ((mclk_b == &pbc->i2s_out->i2s.mclk_a) ||
+			     (mclk_b == &pbc->i2s_out->i2s.mclk_b))) {
+		dir_b = "I2S out";
+	} else {
+		dir_b = "I2S in";
+	}
+
+	if (!mclk_b) {
+		dev_err(dev, "No valid rate for %s (%s sample rate %u)\n",
+			mclk_a->mclk->name, dir_a, rate_a);
+	} else {
+		dev_err(dev,
+			"No valid rate for %s (%s sample rate %u, %s sample rate %u)\n",
+			mclk_a->mclk->name, dir_a, rate_a, dir_b, rate_b);
+	}
+}
+
+static bool pistachio_card_mclk_ok(struct pistachio_i2s_mclk *mclk,
+				   unsigned int rate)
+{
+	int i;
+	unsigned int mclk_rate;
+
+	if (!mclk)
+		return true;
+
+	mclk_rate = mclk->mclk->cur_rate;
+
+	if ((mclk_rate < mclk->min_rate) || (mclk_rate > mclk->max_rate))
+		return false;
+
+	for (i = 0; i < mclk->num_fs_rates; i++)
+		if ((rate * mclk->fs_rates[i]) == mclk_rate)
+			return true;
+
+	return false;
+}
+
+static int pistachio_card_get_mclk_rate(struct pistachio_card *pbc,
+	struct pistachio_i2s_mclk *mclk_a, struct pistachio_i2s_mclk *mclk_b,
+	unsigned int rate_a, unsigned int rate_b, unsigned int *p_mclk_rate)
+{
+	int i, j;
+	unsigned int div, total_div, mclk_rate;
+
+	/*
+	 * If the current system clock rate is sufficient for the given
+	 * sample rates, do not change the rate.
+	 */
+	if (pistachio_card_mclk_ok(mclk_a, rate_a) &&
+	    pistachio_card_mclk_ok(mclk_b, rate_b)) {
+		*p_mclk_rate = mclk_a->mclk->cur_rate;
+		return 0;
+	}
+
+	/* Calculate total divide (internal divide and Nfs combined) */
+	total_div = pbc->audio_pll_rate / rate_a;
+
+	/* Attempt to find an mclk rate that satisfies the constraints */
+	for (i = 0; i < mclk_a->num_fs_rates; i++) {
+
+		div = total_div / mclk_a->fs_rates[i];
+
+		if (div > PISTACHIO_MAX_DIV)
+			continue;
+
+		mclk_rate = pbc->audio_pll_rate / div;
+
+		if ((mclk_rate < mclk_a->min_rate) ||
+		    (mclk_rate > mclk_a->max_rate) ||
+		    (mclk_rate > mclk_a->mclk->max_rate))
+			continue;
+
+		if ((rate_a * mclk_a->fs_rates[i] * div) !=
+		     pbc->audio_pll_rate)
+			continue;
+
+		if (!mclk_b)
+			break;
+
+		if ((mclk_rate < mclk_b->min_rate) ||
+		    (mclk_rate > mclk_b->max_rate))
+			continue;
+
+		for (j = 0; j < mclk_b->num_fs_rates; j++)
+			if ((rate_b * mclk_b->fs_rates[j] * div) ==
+			     pbc->audio_pll_rate)
+				break;
+
+		if (j != mclk_b->num_fs_rates)
+			break;
+	}
+
+	if (i == mclk_a->num_fs_rates) {
+		pistachio_card_rate_err(pbc, mclk_a, mclk_b, rate_a, rate_b);
+		return -EINVAL;
+	}
+
+	*p_mclk_rate = mclk_rate;
+
+	return 0;
+}
+
+static int pistachio_card_update_mclk(struct pistachio_card *pbc,
+	struct pistachio_i2s_mclk *mclk_a, struct pistachio_i2s_mclk *mclk_b,
+	unsigned int rate_a, unsigned int rate_b)
+{
+	struct pistachio_mclk *mclk = mclk_a->mclk;
+	unsigned int mclk_rate;
+	int ret;
+
+	ret = pistachio_card_get_mclk_rate(pbc, mclk_a, mclk_b, rate_a,
+					   rate_b, &mclk_rate);
+	if (ret)
+		return ret;
+
+	if (mclk->cur_rate != mclk_rate)
+		return pistachio_card_set_mclk(pbc, mclk, mclk_rate);
+
+	return 0;
+}
+
+static int pistachio_card_update_mclk_single(struct pistachio_card *pbc,
+		      struct pistachio_i2s_mclk *mclk, unsigned int rate)
+{
+	return pistachio_card_update_mclk(pbc, mclk, NULL, rate, 0);
+}
+
+static int pistachio_card_get_pll_rate(unsigned int rate, struct device *dev)
+{
+	switch (rate) {
+	case 8000:
+	case 16000:
+	case 32000:
+	case 48000:
+	case 64000:
+	case 96000:
+	case 192000:
+		return PISTACHIO_PLL_RATE_A;
+	case 11025:
+	case 22050:
+	case 44100:
+	case 88200:
+	case 176400:
+		return PISTACHIO_PLL_RATE_B;
+	default:
+		dev_err(dev, "No suitable pll rate for sample rate %u\n", rate);
+		return -EINVAL;
+	}
+}
+
+static int _pistachio_card_change_rate(struct pistachio_card *pbc,
+				       unsigned int rate,
+				       struct pistachio_i2s *i2s)
+{
+	int ret;
+	unsigned int pll_rate;
+
+	ret = pistachio_card_get_pll_rate(rate, pbc->card.dev);
+	if (ret < 0)
+		return ret;
+
+	pll_rate = ret;
+
+	if (pbc->audio_pll_rate != pll_rate) {
+		ret = pistachio_card_set_pll_rate(pbc, pll_rate);
+		if (ret)
+			return ret;
+	}
+
+	/*
+	 * Nothing more to do if an mclk is not used. The individual
+	 * cpu-dai drivers will make the required clock changes
+	 */
+	if (!i2s)
+		return 0;
+
+	ret = pistachio_card_update_mclk_single(pbc, &i2s->mclk_a, rate);
+	if (ret)
+		return ret;
+
+	if (!i2s->mclk_b.mclk)
+		return 0;
+
+	return pistachio_card_update_mclk_single(pbc, &i2s->mclk_b, rate);
+}
+
+static int pistachio_card_change_rate(struct pistachio_card *pbc,
+			unsigned int rate, struct pistachio_i2s *i2s,
+			unsigned int *active_rate)
+{
+	int ret;
+
+	mutex_lock(&pbc->rate_mutex);
+	*active_rate = 0;
+	ret = _pistachio_card_change_rate(pbc, rate, i2s);
+	if (!ret)
+		*active_rate = rate;
+	mutex_unlock(&pbc->rate_mutex);
+
+	return ret;
+}
+
+static int pistachio_card_i2s_link_init(struct pistachio_i2s *i2s,
+					struct snd_soc_pcm_runtime *rtd,
+					struct device *dev)
+{
+	int ret, i;
+	unsigned long rate;
+	struct pistachio_codec_i2s *codec;
+
+	for (i = 0; i < i2s->num_codecs; i++) {
+		codec = &i2s->codecs[i];
+		codec->dai = rtd->codec_dais[i];
+		if (codec->mclk) {
+			rate = codec->mclk->cur_rate;
+			ret = pistachio_card_set_sysclk_s(codec, rate, dev);
+			if (ret)
+				return ret;
+		}
+	}
+
+	return 0;
+}
+
+static int pistachio_card_i2s_out_link_init(struct snd_soc_pcm_runtime *rtd)
+{
+	struct pistachio_card *pbc = snd_soc_card_get_drvdata(rtd->card);
+	struct device *dev = pbc->card.dev;
+
+	return pistachio_card_i2s_link_init(&pbc->i2s_out->i2s, rtd, dev);
+}
+
+static int pistachio_card_i2s_in_link_init(struct snd_soc_pcm_runtime *rtd)
+{
+	struct pistachio_card *pbc = snd_soc_card_get_drvdata(rtd->card);
+	int ret, i;
+	unsigned int fmt;
+	struct device *dev = pbc->card.dev;
+	u32 val;
+
+	ret = pistachio_card_i2s_link_init(&pbc->i2s_in->i2s, rtd, dev);
+	if (ret)
+		return ret;
+
+	if (pbc->i2s_in->frame_master == PISTACHIO_CLOCK_MASTER_LOOPBACK)
+		val = PISTACHIO_I2S_LOOPBACK_CLK_LOCAL;
+	else
+		val = PISTACHIO_I2S_LOOPBACK_CLK_NONE;
+
+	ret = regmap_update_bits(pbc->periph_regs, PISTACHIO_I2S_LOOPBACK_REG,
+				 PISTACHIO_I2S_LOOPBACK_CLK_MASK, val);
+	if (ret) {
+		dev_err(pbc->card.dev, "regmap_update_bits failed: %d\n", ret);
+		return ret;
+	}
+
+	fmt = pbc->i2s_in->fmt | SND_SOC_DAIFMT_CBM_CFM;
+	ret = snd_soc_dai_set_fmt(rtd->cpu_dai, fmt);
+	if (ret) {
+		dev_err(dev, "snd_soc_dai_set_fmt (cpu) failed: %d\n", ret);
+		return ret;
+	}
+
+	for (i = 0; i < pbc->i2s_in->i2s.num_codecs; i++) {
+		fmt = pbc->i2s_in->fmt;
+
+		if (i == pbc->i2s_in->frame_master)
+			if (i == pbc->i2s_in->bitclock_master)
+				fmt |= SND_SOC_DAIFMT_CBM_CFM;
+			else
+				fmt |= SND_SOC_DAIFMT_CBS_CFM;
+		else
+			if (i == pbc->i2s_in->bitclock_master)
+				fmt |= SND_SOC_DAIFMT_CBM_CFS;
+			else
+				fmt |= SND_SOC_DAIFMT_CBS_CFS;
+
+		ret = snd_soc_dai_set_fmt(rtd->codec_dais[i], fmt);
+		if (ret) {
+			dev_err(dev, "snd_soc_dai_set_fmt failed: %d\n", ret);
+			return ret;
+		}
+	}
+
+	return 0;
+}
+
+static void pistachio_card_parallel_out_shutdown(struct snd_pcm_substream *st)
+{
+	struct snd_soc_pcm_runtime *rtd = st->private_data;
+	struct pistachio_card *pbc = snd_soc_card_get_drvdata(rtd->card);
+
+	pbc->parallel_out->output.active_rate = 0;
+}
+
+static int pistachio_card_parallel_out_hw_params(struct snd_pcm_substream *st,
+					      struct snd_pcm_hw_params *params)
+{
+	struct snd_soc_pcm_runtime *rtd = st->private_data;
+	struct pistachio_card *pbc = snd_soc_card_get_drvdata(rtd->card);
+
+	return pistachio_card_change_rate(pbc, params_rate(params), NULL,
+				   &pbc->parallel_out->output.active_rate);
+}
+
+static struct snd_soc_ops pistachio_card_parallel_out_ops = {
+	.shutdown = pistachio_card_parallel_out_shutdown,
+	.hw_params = pistachio_card_parallel_out_hw_params
+};
+
+static void pistachio_card_spdif_out_shutdown(struct snd_pcm_substream *st)
+{
+	struct snd_soc_pcm_runtime *rtd = st->private_data;
+	struct pistachio_card *pbc = snd_soc_card_get_drvdata(rtd->card);
+
+	pbc->spdif_out->active_rate = 0;
+}
+
+static int pistachio_card_spdif_out_hw_params(struct snd_pcm_substream *st,
+					      struct snd_pcm_hw_params *params)
+{
+	struct snd_soc_pcm_runtime *rtd = st->private_data;
+	struct pistachio_card *pbc = snd_soc_card_get_drvdata(rtd->card);
+
+	return pistachio_card_change_rate(pbc, params_rate(params), NULL,
+					  &pbc->spdif_out->active_rate);
+}
+
+static struct snd_soc_ops pistachio_card_spdif_out_ops = {
+	.shutdown = pistachio_card_spdif_out_shutdown,
+	.hw_params = pistachio_card_spdif_out_hw_params
+};
+
+static void pistachio_card_i2s_out_shutdown(struct snd_pcm_substream *st)
+{
+	struct snd_soc_pcm_runtime *rtd = st->private_data;
+	struct pistachio_card *pbc = snd_soc_card_get_drvdata(rtd->card);
+
+	pbc->i2s_out->output.active_rate = 0;
+}
+
+static int pistachio_card_i2s_out_hw_params(struct snd_pcm_substream *st,
+					    struct snd_pcm_hw_params *params)
+{
+	struct snd_soc_pcm_runtime *rtd = st->private_data;
+	struct pistachio_card *pbc = snd_soc_card_get_drvdata(rtd->card);
+
+	return pistachio_card_change_rate(pbc, params_rate(params),
+					  &pbc->i2s_out->i2s,
+					  &pbc->i2s_out->output.active_rate);
+}
+
+static struct snd_soc_ops pistachio_card_i2s_out_ops = {
+	.shutdown = pistachio_card_i2s_out_shutdown,
+	.hw_params = pistachio_card_i2s_out_hw_params
+};
+
+static void pistachio_card_i2s_in_shutdown(struct snd_pcm_substream *st)
+{
+	struct snd_soc_pcm_runtime *rtd = st->private_data;
+	struct pistachio_card *pbc = snd_soc_card_get_drvdata(rtd->card);
+
+	pbc->i2s_in->active_rate = 0;
+}
+
+static int pistachio_card_i2s_in_hw_params(struct snd_pcm_substream *st,
+					   struct snd_pcm_hw_params *params)
+{
+	struct snd_soc_pcm_runtime *rtd = st->private_data;
+	struct pistachio_card *pbc = snd_soc_card_get_drvdata(rtd->card);
+
+	return pistachio_card_change_rate(pbc, params_rate(params),
+					  &pbc->i2s_in->i2s,
+					  &pbc->i2s_in->active_rate);
+}
+
+static struct snd_soc_ops pistachio_card_i2s_in_ops = {
+	.shutdown = pistachio_card_i2s_in_shutdown,
+	.hw_params = pistachio_card_i2s_in_hw_params
+};
+
+static int pistachio_card_parse_spdif_out(struct device_node *node,
+					  struct pistachio_card *pbc,
+					  struct snd_soc_dai_link *link)
+{
+	struct device_node *np;
+	struct device *dev = pbc->card.dev;
+
+	pbc->spdif_out = devm_kzalloc(pbc->card.dev, sizeof(*pbc->spdif_out),
+				      GFP_KERNEL);
+	if (!pbc->spdif_out)
+		return -ENOMEM;
+
+	link->name = link->stream_name = "pistachio-spdif-out";
+
+	np = of_parse_phandle(node, "cpu-dai", 0);
+	if (!np) {
+		dev_err(dev, "Failed to parse cpu-dai (%s)\n", node->name);
+		return -EINVAL;
+	}
+
+	link->cpu_of_node = np;
+	link->platform_of_node = np;
+	link->codec_dai_name = "snd-soc-dummy-dai";
+	link->codec_name = "snd-soc-dummy";
+	link->ops = &pistachio_card_spdif_out_ops;
+
+	return 0;
+}
+
+static int pistachio_card_parse_spdif_in(struct device_node *node,
+					 struct pistachio_card *pbc,
+					 struct snd_soc_dai_link *link)
+{
+	struct device_node *np;
+	struct device *dev = pbc->card.dev;
+
+	pbc->spdif_in = true;
+
+	link->name = link->stream_name = "pistachio-spdif-in";
+
+	np = of_parse_phandle(node, "cpu-dai", 0);
+	if (!np) {
+		dev_err(dev, "Failed to parse cpu-dai (%s)\n", node->name);
+		return -EINVAL;
+	}
+
+	link->cpu_of_node = np;
+	link->platform_of_node = np;
+	link->codec_dai_name = "snd-soc-dummy-dai";
+	link->codec_name = "snd-soc-dummy";
+
+	return 0;
+}
+
+static int pistachio_card_parse_parallel_out(struct device_node *node,
+					     struct pistachio_card *pbc,
+					     struct snd_soc_dai_link *link)
+{
+	struct device_node *np;
+	int ret;
+	struct device *dev = pbc->card.dev;
+
+	pbc->parallel_out = devm_kzalloc(pbc->card.dev,
+					 sizeof(*pbc->parallel_out),
+					 GFP_KERNEL);
+	if (!pbc->parallel_out)
+		return -ENOMEM;
+
+	link->name = link->stream_name = "pistachio-parallel-out";
+
+	np = of_parse_phandle(node, "cpu-dai", 0);
+	if (!np) {
+		dev_err(dev, "Failed to parse cpu-dai (%s)\n", node->name);
+		return -EINVAL;
+	}
+
+	link->cpu_of_node = np;
+	link->platform_of_node = np;
+	link->codecs = &pbc->parallel_out->component;
+
+	np = of_parse_phandle(node, "sound-dai", 0);
+	if (!np) {
+		dev_err(dev, "Failed to parse sound-dai (%s)\n", node->name);
+		return -EINVAL;
+	}
+	link->codecs[0].of_node = np;
+	link->num_codecs = 1;
+	ret = snd_soc_of_get_dai_name(node, &link->codecs[0].dai_name);
+	if (ret) {
+		dev_err(dev, "snd_soc_of_get_dai_name failed (%s): %d\n",
+			node->name, ret);
+		return ret;
+	}
+
+	link->ops = &pistachio_card_parallel_out_ops;
+
+	return 0;
+}
+
+static int pistachio_card_parse_i2s_mclk(struct pistachio_card *pbc,
+		struct device_node *np, struct pistachio_mclk *mclk,
+		struct pistachio_i2s_mclk_info *fs)
+{
+	int ret, i, j, k, num_fs_rates;
+	u32 min_fs_rate, max_fs_rate, max_rate;
+	u32 fs_rates[PISTACHIO_MAX_FS_RATES];
+	struct device *dev = pbc->card.dev;
+
+	ret = of_property_read_u32(np, "mclk-min-fs-freq", &min_fs_rate);
+	if (ret) {
+		dev_err(dev, "Failed to read mclk-min-fs-freq (%s): %d\n",
+			np->name, ret);
+		return ret;
+	}
+
+	ret = of_property_read_u32(np, "mclk-max-fs-freq", &max_fs_rate);
+	if (ret) {
+		dev_err(dev, "Failed to read mclk-max-fs-freq (%s): %d\n",
+			np->name, ret);
+		return ret;
+	}
+
+	ret = of_property_read_u32(np, "mclk-max-freq", &max_rate);
+	if (ret) {
+		dev_err(dev, "Failed to read mclk-max-freq (%s): %d\n",
+			np->name, ret);
+		return ret;
+	}
+
+	if ((max_fs_rate < PISTACHIO_MIN_MCLK_FREQ) ||
+	    (max_fs_rate > max_rate) ||
+	    (max_fs_rate < min_fs_rate)) {
+		dev_err(dev, "Invalid min/max rate (%s)\n", np->name);
+		return -EINVAL;
+	}
+
+	if (min_fs_rate > fs->min_rate)
+		fs->min_rate = min_fs_rate;
+
+	if (max_fs_rate < fs->max_rate)
+		fs->max_rate = max_fs_rate;
+
+	if (max_rate < mclk->max_rate)
+		mclk->max_rate = max_rate;
+
+	if (fs->min_rate > fs->max_rate) {
+		dev_err(dev, "No valid frequency range remaining for %s\n",
+			mclk->name);
+		return -EINVAL;
+	}
+
+	num_fs_rates = of_property_count_u32_elems(np, "mclk-fs");
+	if (num_fs_rates < 0) {
+		dev_err(dev, "of_property_count_u32_elems failed: %d (%s)\n",
+			num_fs_rates, np->name);
+		return num_fs_rates;
+	}
+
+	if (!num_fs_rates || (num_fs_rates > PISTACHIO_MAX_FS_RATES)) {
+		dev_err(dev, "Invalid fs-rates count: %d (%s)\n",
+			num_fs_rates, np->name);
+		return -EINVAL;
+	}
+
+	ret = of_property_read_u32_array(np, "mclk-fs", fs_rates,
+					 num_fs_rates);
+	if (ret) {
+		dev_err(dev, "of_property_read_u32_array failed: %d (%s)\n",
+			ret, np->name);
+		return ret;
+	}
+
+	/*
+	 * If this is the first fs-rates list for this combination
+	 * of {i2s direction, mclk}, this list defines the
+	 * current fs-rate list for this combination. Else, this list
+	 * subtracts any fs-rates that are not present in both lists
+	 */
+	if (!fs->num_fs_rates) {
+		/* Remove any duplicates while copying */
+		for (i = 0, k = 0; i < num_fs_rates; i++) {
+			for (j = 0; j < k; j++)
+				if (fs->fs_rates[j] == fs_rates[i])
+					break;
+			if (j == k)
+				fs->fs_rates[k++] = fs_rates[i];
+		}
+		fs->num_fs_rates = k;
+	} else {
+		for (j = 0; j < fs->num_fs_rates; j++) {
+			for (i = 0; i < num_fs_rates; i++)
+				if (fs->fs_rates[j] == fs_rates[i])
+					break;
+
+			if (i == num_fs_rates) {
+				for (k = j; k < (fs->num_fs_rates - 1); k++)
+					fs->fs_rates[k] = fs->fs_rates[k + 1];
+				fs->num_fs_rates--;
+
+				if (!fs->num_fs_rates) {
+					dev_err(dev, "No fs rates remaining for %s\n",
+						mclk->name);
+					return -EINVAL;
+				}
+
+				j--;
+			}
+		}
+	}
+
+	return 0;
+}
+
+static int pistachio_card_parse_i2s_codec(struct device_node *np,
+	struct device_node *subnode, int index, struct pistachio_card *pbc,
+	struct device_node *codec, struct pistachio_i2s_codec_info *codec_info,
+	struct pistachio_mclk *mclk)
+{
+	int i, ret;
+	struct pistachio_i2s_codec_info_s *info;
+	struct device *dev = pbc->card.dev;
+
+	if (codec_info->total_codecs == PISTACHIO_MAX_I2S_CODECS) {
+		dev_err(dev, "Too many codecs\n");
+		of_node_put(codec);
+		return -EINVAL;
+	}
+
+	for (i = 0; i < codec_info->total_codecs; i++)
+		if (codec_info->codecs[i].np == codec)
+			break;
+
+	if (i == codec_info->total_codecs)
+		codec_info->unique_codecs++;
+
+	info = &codec_info->codecs[codec_info->total_codecs++];
+	info->np = codec;
+	info->prefix = subnode->name;
+	info->mclk = mclk;
+
+	ret = of_property_read_u32(subnode, "mclk-index", &info->mclk_index);
+	if (ret)
+		info->mclk_index = 0;
+
+	ret = snd_soc_of_get_dai_name(subnode, &info->dai_name);
+	if (ret) {
+		dev_err(dev, "snd_soc_of_get_dai_name failed: %d (%s)\n",
+			ret, subnode->name);
+		return ret;
+	}
+
+	if (of_property_read_bool(subnode, "frame-master")) {
+		if (codec_info->frame_master_idx != -1) {
+			dev_err(dev, "Multiple frame clock masters (%s)\n",
+				np->name);
+			return -EINVAL;
+		}
+		codec_info->frame_master_idx = index;
+	}
+
+	if (of_property_read_bool(subnode, "bitclock-master")) {
+		if (codec_info->bitclock_master_idx != -1) {
+			dev_err(dev, "Multiple bit clock masters (%s)\n",
+				np->name);
+			return -EINVAL;
+		}
+		codec_info->bitclock_master_idx = index;
+	}
+
+	return 0;
+}
+
+static int pistachio_card_parse_i2s_codecs(struct device_node *np,
+			struct pistachio_card *pbc,
+			struct pistachio_i2s_codec_info *codec_info,
+			struct pistachio_i2s_mclk_info *i2s_fs_info,
+			struct pistachio_i2s_mclk_info *dac_fs_info)
+{
+	int i, ret;
+	struct device_node *subnode, *codec;
+	u32 mclk_id;
+	struct pistachio_mclk *mclk;
+	struct pistachio_i2s_mclk_info *fs_info;
+	struct device *dev = pbc->card.dev;
+
+	i = 0;
+	for_each_child_of_node(np, subnode) {
+
+		ret = of_property_read_u32(subnode, "mclk", &mclk_id);
+		if (ret) {
+			mclk = NULL;
+		} else {
+			switch (mclk_id) {
+			case PISTACHIO_MCLK_I2S:
+				mclk = &pbc->i2s_mclk;
+				fs_info = i2s_fs_info;
+				break;
+			case PISTACHIO_MCLK_DAC:
+				mclk = &pbc->dac_mclk;
+				fs_info = dac_fs_info;
+				break;
+			default:
+				dev_err(dev, "Invalid mclk id: %u (%s)\n",
+					mclk_id, subnode->name);
+				ret = -EINVAL;
+				goto err_subnode;
+			}
+			ret = pistachio_card_parse_i2s_mclk(pbc, subnode, mclk,
+							    fs_info);
+			if (ret)
+				goto err_subnode;
+		}
+
+		codec = of_parse_phandle(subnode, "sound-dai", 0);
+		if (!codec)
+			continue;
+
+		ret = pistachio_card_parse_i2s_codec(np, subnode, i, pbc,
+						     codec, codec_info, mclk);
+		if (ret)
+			goto err_subnode;
+
+		i++;
+	}
+
+	return 0;
+
+err_subnode:
+	of_node_put(subnode);
+
+	return ret;
+}
+
+static int pistachio_card_mclk_copy(struct pistachio_mclk *mclk,
+	struct pistachio_i2s_mclk *mclk_i2s, struct pistachio_card *pbc,
+	struct pistachio_i2s_mclk_info *mclk_info)
+{
+	unsigned int size;
+
+	mclk_i2s->mclk = mclk;
+	mclk_i2s->num_fs_rates = mclk_info->num_fs_rates;
+
+	size = sizeof(*mclk_i2s->fs_rates) * mclk_i2s->num_fs_rates;
+	mclk_i2s->fs_rates = devm_kzalloc(pbc->card.dev, size, GFP_KERNEL);
+	if (!mclk_i2s->fs_rates)
+		return -ENOMEM;
+
+	memcpy(mclk_i2s->fs_rates, mclk_info->fs_rates, size);
+
+	mclk_i2s->min_rate = mclk_info->min_rate;
+	mclk_i2s->max_rate = mclk_info->max_rate;
+
+	return 0;
+}
+
+static int pistachio_card_parse_i2s_common(struct device_node *node,
+		struct pistachio_card *pbc, struct pistachio_i2s *i2s,
+		struct snd_soc_dai_link *link,
+		struct pistachio_i2s_codec_info *codec_info,
+		struct pistachio_i2s_mclk_info *i2s_mclk_info,
+		struct pistachio_i2s_mclk_info *dac_mclk_info)
+{
+	int ret, i;
+	unsigned int initial_codecs = codec_info->total_codecs, size;
+	struct pistachio_i2s_codec_info_s *codecs;
+	struct pistachio_i2s_mclk *mclk;
+
+	codecs = &codec_info->codecs[initial_codecs];
+
+	ret = pistachio_card_parse_i2s_codecs(node, pbc, codec_info,
+					      i2s_mclk_info, dac_mclk_info);
+	i2s->num_codecs = codec_info->total_codecs - initial_codecs;
+	if (ret)
+		goto err_codec_info;
+
+	mclk = &i2s->mclk_a;
+
+	if (i2s_mclk_info->num_fs_rates) {
+		ret = pistachio_card_mclk_copy(&pbc->i2s_mclk, mclk,
+					       pbc, i2s_mclk_info);
+		if (ret)
+			goto err_codec_info;
+
+		mclk = &i2s->mclk_b;
+	}
+
+	if (dac_mclk_info->num_fs_rates) {
+		ret = pistachio_card_mclk_copy(&pbc->dac_mclk, mclk,
+					       pbc, dac_mclk_info);
+		if (ret)
+			goto err_codec_info;
+	}
+
+	/* Use the dummy codec if there are no codec drivers in this link */
+	if (!i2s->num_codecs) {
+		link->codec_dai_name = "snd-soc-dummy-dai";
+		link->codec_name = "snd-soc-dummy";
+		return 0;
+	}
+
+	size = sizeof(*i2s->codecs) * i2s->num_codecs;
+	i2s->codecs = devm_kzalloc(pbc->card.dev, size, GFP_KERNEL);
+	if (!i2s->codecs) {
+		ret = -ENOMEM;
+		goto err_codec_info;
+	}
+
+	for (i = 0; i < i2s->num_codecs; i++) {
+		i2s->codecs[i].mclk = codecs[i].mclk;
+		i2s->codecs[i].mclk_index = codecs[i].mclk_index;
+	}
+
+	size = sizeof(*i2s->components) * i2s->num_codecs;
+	i2s->components = devm_kzalloc(pbc->card.dev, size, GFP_KERNEL);
+	if (!i2s->components) {
+		ret = -ENOMEM;
+		goto err_codec_info;
+	}
+
+	for (i = 0; i < i2s->num_codecs; i++) {
+		i2s->components[i].dai_name = codecs[i].dai_name;
+		i2s->components[i].of_node = codecs[i].np;
+	}
+
+	link->codecs = i2s->components;
+	link->num_codecs = i2s->num_codecs;
+
+	return 0;
+
+err_codec_info:
+	for (i = 0; i < i2s->num_codecs; i++)
+		of_node_put(codecs[i].np);
+
+	return ret;
+}
+
+static void pistachio_card_add_i2s_clk_route(struct pistachio_card *pbc,
+					     struct pistachio_i2s_mclk *mclk,
+					     char *cpu_dai_wname)
+{
+	struct snd_soc_dapm_route *route;
+
+	/*
+	 * Add a route connecting the clock supply widget to the i2s
+	 * Playback/Capture widget if the mclk is used in this path
+	 */
+	if (!mclk->mclk)
+		return;
+
+	route = &pbc->routes[pbc->card.num_dapm_routes++];
+	route->source = mclk->mclk->name;
+	route->sink = cpu_dai_wname;
+}
+
+static void pistachio_card_add_i2s_routes(struct pistachio_card *pbc,
+					  struct pistachio_i2s *i2s)
+{
+	char *cpu_dai_wname;
+	struct snd_soc_dapm_route *route;
+
+	route = &pbc->routes[pbc->card.num_dapm_routes++];
+
+	/*
+	 * dapm requires a full path (source to sink) for the clock supply
+	 * widgets to turn on/off as expected. Create routes linking the
+	 * i2s Playback/Capture widgets to Inputs/Outputs as required to
+	 * create these paths
+	 */
+	if (i2s == &pbc->i2s_out->i2s) {
+		cpu_dai_wname = PISTACHIO_I2S_OUT_PREFIX " Playback";
+		route->source = cpu_dai_wname;
+		route->sink = PISTACHIO_I2S_OUTPUT_NAME;
+	} else {
+		cpu_dai_wname = PISTACHIO_I2S_IN_PREFIX " Capture";
+		route->source = PISTACHIO_I2S_INPUT_NAME;
+		route->sink = cpu_dai_wname;
+	}
+
+	pistachio_card_add_i2s_clk_route(pbc, &i2s->mclk_a, cpu_dai_wname);
+
+	pistachio_card_add_i2s_clk_route(pbc, &i2s->mclk_b, cpu_dai_wname);
+}
+
+static int pistachio_card_parse_i2s_out(struct device_node *i2s_out_np,
+		struct pistachio_card *pbc, struct snd_soc_dai_link *link,
+		struct pistachio_i2s_codec_info *codec_info)
+{
+	struct device *dev = pbc->card.dev;
+	struct device_node *np;
+	unsigned int fmt;
+	int ret;
+	struct pistachio_i2s_mclk_info i2s_mclk_info;
+	struct pistachio_i2s_mclk_info dac_mclk_info;
+
+	pbc->i2s_out = devm_kzalloc(dev, sizeof(*pbc->i2s_out), GFP_KERNEL);
+	if (!pbc->i2s_out)
+		return -ENOMEM;
+
+	link->name = link->stream_name = "pistachio-i2s-out";
+
+	np = of_parse_phandle(i2s_out_np, "cpu-dai", 0);
+	if (!np) {
+		dev_err(dev, "Failed to parse cpu-dai (%s)", i2s_out_np->name);
+		return -EINVAL;
+	}
+
+	link->cpu_of_node = np;
+	link->platform_of_node = np;
+
+	fmt = snd_soc_of_parse_daifmt(i2s_out_np, NULL, NULL, NULL);
+	fmt &= ~SND_SOC_DAIFMT_MASTER_MASK;
+	fmt |= SND_SOC_DAIFMT_CBS_CFS;
+	link->dai_fmt = fmt;
+
+	/*
+	 * Internal i2s out controller uses i2s_mclk and
+	 * accepts 256fs,384fs
+	 */
+	i2s_mclk_info.fs_rates[0] = 256;
+	i2s_mclk_info.fs_rates[1] = 384;
+	i2s_mclk_info.num_fs_rates = 2;
+	i2s_mclk_info.min_rate = 0;
+	i2s_mclk_info.max_rate = PISTACHIO_I2S_MCLK_MAX_FREQ;
+	dac_mclk_info.num_fs_rates = 0;
+	dac_mclk_info.min_rate = 0;
+	dac_mclk_info.max_rate = PISTACHIO_DAC_MCLK_MAX_FREQ;
+
+	codec_info->bitclock_master_idx = 0;
+	codec_info->frame_master_idx = 0;
+
+	ret = pistachio_card_parse_i2s_common(i2s_out_np, pbc,
+			&pbc->i2s_out->i2s, link, codec_info,
+			&i2s_mclk_info, &dac_mclk_info);
+	if (ret)
+		return ret;
+
+	pistachio_card_add_i2s_routes(pbc, &pbc->i2s_out->i2s);
+
+	link->init = pistachio_card_i2s_out_link_init;
+	link->ops = &pistachio_card_i2s_out_ops;
+
+	return 0;
+}
+
+static int pistachio_card_parse_i2s_in(struct device_node *i2s_in_np,
+		struct pistachio_card *pbc, struct snd_soc_dai_link *link,
+		bool i2s_loopback, struct pistachio_i2s_codec_info *codec_info)
+{
+	int ret;
+	struct device *dev = pbc->card.dev;
+	unsigned int fmt;
+	struct device_node *np;
+	struct pistachio_i2s_mclk_info i2s_mclk_info;
+	struct pistachio_i2s_mclk_info dac_mclk_info;
+
+	pbc->i2s_in = devm_kzalloc(dev, sizeof(*pbc->i2s_in), GFP_KERNEL);
+	if (!pbc->i2s_in)
+		return -ENOMEM;
+
+	link->name = link->stream_name = "pistachio-i2s-in";
+
+	np = of_parse_phandle(i2s_in_np, "cpu-dai", 0);
+	if (!np) {
+		dev_err(dev, "Failed to parse cpu-dai (%s)", i2s_in_np->name);
+		return -EINVAL;
+	}
+
+	link->cpu_of_node = np;
+	link->platform_of_node = np;
+
+	fmt = snd_soc_of_parse_daifmt(i2s_in_np, NULL, NULL, NULL);
+	fmt &= ~SND_SOC_DAIFMT_MASTER_MASK;
+	pbc->i2s_in->fmt = fmt;
+
+	i2s_mclk_info.num_fs_rates = 0;
+	i2s_mclk_info.min_rate = 0;
+	i2s_mclk_info.max_rate = PISTACHIO_I2S_MCLK_MAX_FREQ;
+	dac_mclk_info.num_fs_rates = 0;
+	dac_mclk_info.min_rate = 0;
+	dac_mclk_info.max_rate = PISTACHIO_DAC_MCLK_MAX_FREQ;
+
+	codec_info->bitclock_master_idx = -1;
+	codec_info->frame_master_idx = -1;
+
+	ret = pistachio_card_parse_i2s_common(i2s_in_np, pbc,
+			&pbc->i2s_in->i2s, link, codec_info,
+			&i2s_mclk_info, &dac_mclk_info);
+	if (ret)
+		return ret;
+
+	if (i2s_loopback) {
+		pbc->i2s_in->frame_master = PISTACHIO_CLOCK_MASTER_LOOPBACK;
+		pbc->i2s_in->bitclock_master = PISTACHIO_CLOCK_MASTER_LOOPBACK;
+	} else if ((codec_info->bitclock_master_idx == -1) ||
+		   (codec_info->frame_master_idx == -1)) {
+		pbc->i2s_in->frame_master = PISTACHIO_CLOCK_MASTER_EXT;
+		pbc->i2s_in->bitclock_master = PISTACHIO_CLOCK_MASTER_EXT;
+	} else {
+		pbc->i2s_in->frame_master = codec_info->frame_master_idx;
+		pbc->i2s_in->bitclock_master = codec_info->bitclock_master_idx;
+	}
+
+	pistachio_card_add_i2s_routes(pbc, &pbc->i2s_in->i2s);
+
+	link->init = pistachio_card_i2s_in_link_init;
+
+	/*
+	 * If no mclks are used by i2s in, there is nothing for
+	 * the ops callbacks to do, so leave this as NULL
+	 */
+	if (pbc->i2s_in->i2s.mclk_a.mclk)
+		link->ops = &pistachio_card_i2s_in_ops;
+
+	return 0;
+}
+
+static int pistachio_card_prefixes(struct pistachio_card *pbc,
+	struct pistachio_i2s_codec_info *codec_info,
+	struct snd_soc_dai_link *i2s_out, struct snd_soc_dai_link *i2s_in,
+	struct snd_soc_dai_link *parallel_out)
+{
+	int i, j, n;
+	unsigned int size;
+	struct pistachio_i2s_codec_info_s *codecs;
+	struct snd_soc_codec_conf *conf, *c;
+
+	n = codec_info->unique_codecs;
+
+	if (parallel_out)
+		n++;
+
+	if (i2s_out)
+		n++;
+
+	if (i2s_in)
+		n++;
+
+	codecs = codec_info->codecs;
+
+	size = sizeof(*pbc->card.codec_conf) * n;
+	pbc->card.codec_conf = devm_kzalloc(pbc->card.dev, size, GFP_KERNEL);
+	if (!pbc->card.codec_conf)
+		return -ENOMEM;
+
+	conf = pbc->card.codec_conf;
+
+	/* Create prefixes for unique codecs only */
+	for (i = 0; i < codec_info->total_codecs; i++) {
+		for (j = 0; j < i; j++)
+			if (codecs[j].np == codecs[i].np)
+				break;
+		if (j == i) {
+			conf->of_node = codecs[i].np;
+			conf->name_prefix = codecs[i].prefix;
+			conf++;
+		}
+	}
+
+	if (i2s_out) {
+		conf->of_node = i2s_out->cpu_of_node;
+		conf->name_prefix = PISTACHIO_I2S_OUT_PREFIX;
+		conf++;
+	}
+
+	if (i2s_in) {
+		conf->of_node = i2s_in->cpu_of_node;
+		conf->name_prefix = PISTACHIO_I2S_IN_PREFIX;
+		conf++;
+	}
+
+	if (parallel_out) {
+		conf->of_node = parallel_out->codecs[0].of_node;
+		conf->name_prefix = PISTACHIO_INTERNAL_DAC_PREFIX;
+		conf++;
+	}
+
+	pbc->card.num_configs = n;
+
+	/* Check for prefix clashes */
+	for (i = 0; i < n; i++) {
+		conf = &pbc->card.codec_conf[i];
+		for (j = i + 1; j < n; j++) {
+			c = &pbc->card.codec_conf[j];
+			if (!strcasecmp(conf->name_prefix, c->name_prefix)) {
+				dev_err(pbc->card.dev, "Prefix clash: %s\n",
+					conf->name_prefix);
+				return -EINVAL;
+			}
+		}
+	}
+
+	return 0;
+}
+
+static int pistachio_card_parse_of(struct device_node *node,
+				   struct pistachio_card *pbc)
+{
+	int ret = 0;
+	unsigned int size, gpio;
+	struct device_node *spdif_out_np, *spdif_in_np, *parallel_out_np;
+	struct device_node *i2s_out_np, *i2s_in_np;
+	struct snd_soc_dai_link *link, *prl_out, *i2s_out, *i2s_in;
+	enum of_gpio_flags flags;
+	struct pistachio_i2s_codec_info codec_info;
+	bool i2s_loopback;
+	struct device *dev = pbc->card.dev;
+
+	pbc->periph_regs = syscon_regmap_lookup_by_phandle(node, "img,cr-periph");
+	if (IS_ERR(pbc->periph_regs)) {
+		dev_err(dev, "syscon_regmap_lookup_by_phandle failed: %ld\n",
+			PTR_ERR(pbc->periph_regs));
+		return PTR_ERR(pbc->periph_regs);
+	}
+
+	if (of_property_read_bool(node, "img,widgets")) {
+		ret = snd_soc_of_parse_audio_simple_widgets(&pbc->card, "img,widgets");
+		if (ret) {
+			dev_err(dev, "img,widgets parse failed: %d\n", ret);
+			return ret;
+		}
+	}
+
+	if (of_property_read_bool(node, "img,routing")) {
+		ret = snd_soc_of_parse_audio_routing(&pbc->card, "img,routing");
+		if (ret) {
+			dev_err(dev, "img,routing parse failed: %d\n", ret);
+			return ret;
+		}
+	}
+
+	spdif_out_np = of_get_child_by_name(node, "spdif-out");
+	if (spdif_out_np)
+		pbc->card.num_links++;
+
+	spdif_in_np = of_get_child_by_name(node, "spdif-in");
+	if (spdif_in_np)
+		pbc->card.num_links++;
+
+	parallel_out_np = of_get_child_by_name(node, "parallel-out");
+	if (parallel_out_np)
+		pbc->card.num_links++;
+
+	i2s_out_np = of_get_child_by_name(node, "i2s-out");
+	if (i2s_out_np)
+		pbc->card.num_links++;
+
+	i2s_in_np = of_get_child_by_name(node, "i2s-in");
+	if (i2s_in_np)
+		pbc->card.num_links++;
+
+	i2s_loopback = of_property_read_bool(node, "img,i2s-clk-loopback");
+	if (i2s_loopback && (!i2s_out_np || !i2s_in_np)) {
+		dev_err(dev, "img,i2s-clk-loopback specified when i2s-out/i2s-in are not present\n");
+		ret = -EINVAL;
+		goto end;
+	}
+
+	if (!pbc->card.num_links) {
+		dev_err(dev, "No dai links on card\n");
+		ret = -EINVAL;
+		goto end;
+	}
+
+	size = sizeof(*pbc->card.dai_link) * pbc->card.num_links;
+	pbc->card.dai_link = devm_kzalloc(pbc->card.dev, size, GFP_KERNEL);
+	if (!pbc->card.dai_link) {
+		ret = -ENOMEM;
+		goto end;
+	}
+
+	codec_info.total_codecs = 0;
+	codec_info.unique_codecs = 0;
+
+	link = pbc->card.dai_link;
+
+	if (spdif_out_np) {
+		ret = pistachio_card_parse_spdif_out(spdif_out_np, pbc, link);
+		if (ret)
+			goto end;
+		link++;
+	}
+
+	if (spdif_in_np) {
+		ret = pistachio_card_parse_spdif_in(spdif_in_np, pbc, link);
+		if (ret)
+			goto end;
+		link++;
+	}
+
+	if (parallel_out_np) {
+		ret = pistachio_card_parse_parallel_out(parallel_out_np, pbc,
+							link);
+		if (ret)
+			goto end;
+
+		prl_out = link++;
+	} else {
+		prl_out = NULL;
+	}
+
+	if (i2s_out_np) {
+		ret = pistachio_card_parse_i2s_out(i2s_out_np, pbc, link,
+						   &codec_info);
+		if (ret)
+			goto end;
+
+		i2s_out = link++;
+	} else {
+		i2s_out = NULL;
+	}
+
+	if (i2s_in_np) {
+		ret = pistachio_card_parse_i2s_in(i2s_in_np, pbc, link,
+						  i2s_loopback, &codec_info);
+		if (ret)
+			goto end;
+
+		i2s_in = link;
+	} else {
+		i2s_in = NULL;
+	}
+
+	ret = pistachio_card_prefixes(pbc, &codec_info, i2s_out,
+				      i2s_in, prl_out);
+	if (ret)
+		goto end;
+
+	gpio = of_get_named_gpio_flags(node, "img,hp-det-gpio", 0, &flags);
+	pbc->hp_jack_gpio.gpio = gpio;
+	pbc->hp_jack_gpio.invert = !!(flags & OF_GPIO_ACTIVE_LOW);
+	if (pbc->hp_jack_gpio.gpio == -EPROBE_DEFER) {
+		ret = -EPROBE_DEFER;
+		goto end;
+	}
+
+	gpio = of_get_named_gpio_flags(node, "img,mute-gpio", 0, &flags);
+	pbc->mute_gpio = gpio;
+	pbc->mute_gpio_inverted = !!(flags & OF_GPIO_ACTIVE_LOW);
+	if (pbc->mute_gpio == -EPROBE_DEFER)
+		ret = -EPROBE_DEFER;
+
+end:
+	if (spdif_out_np)
+		of_node_put(spdif_out_np);
+	if (spdif_in_np)
+		of_node_put(spdif_in_np);
+	if (parallel_out_np)
+		of_node_put(parallel_out_np);
+	if (i2s_out_np)
+		of_node_put(i2s_out_np);
+	if (i2s_in_np)
+		of_node_put(i2s_in_np);
+
+	return ret;
+}
+
+static void pistachio_card_unref(struct pistachio_card *pbc)
+{
+	int i, j;
+	struct snd_soc_dai_link *link;
+
+	link = pbc->card.dai_link;
+	if (!link)
+		return;
+
+	for (i = 0; i < pbc->card.num_links; i++, link++) {
+		if (link->cpu_of_node)
+			of_node_put(link->cpu_of_node);
+		for (j = 0; j < link->num_codecs; j++)
+			of_node_put(link->codecs[j].of_node);
+	}
+}
+
+static int pistachio_card_init_clk(struct device *dev, char *name,
+				   struct clk **pclk, unsigned int rate)
+{
+	struct clk *clk;
+	int ret;
+
+	clk = devm_clk_get(dev, name);
+	if (IS_ERR(clk)) {
+		ret = PTR_ERR(clk);
+		if (ret != -EPROBE_DEFER)
+			dev_err(dev, "devm_clk_get failed for %s: %d",
+				name, ret);
+		return ret;
+	}
+
+	ret = clk_set_rate(clk, rate);
+	if (ret) {
+		dev_err(dev, "clk_set_rate(%s, %u) failed: %d",
+			name, rate, ret);
+		return ret;
+	}
+
+	*pclk = clk;
+
+	return 0;
+}
+
+static int pistachio_card_get_mute(struct snd_kcontrol *kcontrol,
+				   struct snd_ctl_elem_value *ucontrol)
+{
+	struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
+	struct pistachio_card *pbc = snd_soc_card_get_drvdata(card);
+	int ret;
+
+	ret = gpio_get_value_cansleep(pbc->mute_gpio);
+	if (ret < 0)
+		return ret;
+
+	if (pbc->mute_gpio_inverted)
+		ucontrol->value.integer.value[0] = !ret;
+	else
+		ucontrol->value.integer.value[0] = !!ret;
+
+	return 0;
+}
+
+static int pistachio_card_set_mute(struct snd_kcontrol *kcontrol,
+				   struct snd_ctl_elem_value *ucontrol)
+{
+	struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
+	struct pistachio_card *pbc = snd_soc_card_get_drvdata(card);
+	int val;
+
+	if (pbc->mute_gpio_inverted)
+		val = !ucontrol->value.integer.value[0];
+	else
+		val = ucontrol->value.integer.value[0];
+
+	gpio_set_value_cansleep(pbc->mute_gpio, val);
+
+	return 0;
+}
+
+static int pistachio_card_info_sample_rates(struct snd_kcontrol *kcontrol,
+					    struct snd_ctl_elem_info *uinfo)
+{
+	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+	uinfo->count = 2;
+	uinfo->value.integer.min = 0;
+	uinfo->value.integer.max = 192000;
+
+	return 0;
+}
+
+static int pistachio_card_set_sample_rates_mclk(struct pistachio_card *pbc,
+		    struct pistachio_mclk *mclk, unsigned int i2s_out_rate,
+		    unsigned int i2s_in_rate)
+{
+	struct pistachio_i2s_mclk *mclk_a, *mclk_b;
+	unsigned int rate_a, rate_b;
+
+	mclk_a = NULL;
+	mclk_b = NULL;
+	rate_a = i2s_out_rate;
+	rate_b = i2s_in_rate;
+
+	if (i2s_out_rate) {
+		if (pbc->i2s_out->i2s.mclk_a.mclk == mclk)
+			mclk_a = &pbc->i2s_out->i2s.mclk_a;
+		else if (pbc->i2s_out->i2s.mclk_b.mclk == mclk)
+			mclk_a = &pbc->i2s_out->i2s.mclk_b;
+	}
+	if (i2s_in_rate) {
+		if (pbc->i2s_in->i2s.mclk_a.mclk == mclk)
+			mclk_b = &pbc->i2s_in->i2s.mclk_a;
+		else if (pbc->i2s_in->i2s.mclk_b.mclk == mclk)
+			mclk_b = &pbc->i2s_in->i2s.mclk_b;
+	}
+
+	if (!mclk_a) {
+		mclk_a = mclk_b;
+		rate_a = rate_b;
+		mclk_b = NULL;
+	}
+
+	if (mclk_a)
+		return pistachio_card_update_mclk(pbc, mclk_a, mclk_b,
+						  rate_a, rate_b);
+
+	return 0;
+}
+
+static int pistachio_card_set_sample_rates(struct snd_kcontrol *kcontrol,
+					   struct snd_ctl_elem_value *ucontrol)
+{
+	struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
+	struct pistachio_card *pbc = snd_soc_card_get_drvdata(card);
+	int ret;
+	unsigned int pll_rate, i2s_out_rate, i2s_in_rate;
+	struct device *dev = pbc->card.dev;
+
+	i2s_out_rate = 0;
+	i2s_in_rate = 0;
+
+	if (pbc->i2s_out)
+		i2s_out_rate = ucontrol->value.integer.value[0];
+
+	if (pbc->i2s_in && pbc->i2s_in->i2s.mclk_a.mclk)
+		i2s_in_rate = ucontrol->value.integer.value[1];
+
+	if (!i2s_out_rate && !i2s_in_rate)
+		return 0;
+
+	pll_rate = 0;
+
+	if (i2s_out_rate) {
+		ret = pistachio_card_get_pll_rate(i2s_out_rate, dev);
+		if (ret < 0)
+			return ret;
+
+		pll_rate = ret;
+	}
+
+	if (i2s_in_rate) {
+		ret = pistachio_card_get_pll_rate(i2s_in_rate, dev);
+		if (ret < 0)
+			return ret;
+
+		if (pll_rate && (ret != pll_rate)) {
+			dev_err(dev, "Conflicting pll rate requirements\n");
+			return -EINVAL;
+		}
+
+		pll_rate = ret;
+	}
+
+	mutex_lock(&pbc->rate_mutex);
+
+	if (pbc->audio_pll_rate != pll_rate) {
+		ret = pistachio_card_set_pll_rate(pbc, pll_rate);
+		if (ret) {
+			mutex_unlock(&pbc->rate_mutex);
+			return ret;
+		}
+	}
+
+	ret = pistachio_card_set_sample_rates_mclk(pbc, &pbc->i2s_mclk,
+						   i2s_out_rate, i2s_in_rate);
+	if (ret) {
+		mutex_unlock(&pbc->rate_mutex);
+		return ret;
+	}
+
+	ret = pistachio_card_set_sample_rates_mclk(pbc, &pbc->dac_mclk,
+						   i2s_out_rate, i2s_in_rate);
+
+	mutex_unlock(&pbc->rate_mutex);
+
+	return ret;
+}
+
+static struct snd_kcontrol_new pistachio_controls[] = {
+	{
+		.access = SNDRV_CTL_ELEM_ACCESS_WRITE,
+		.iface = SNDRV_CTL_ELEM_IFACE_CARD,
+		.name = "I2S Rates",
+		.info = pistachio_card_info_sample_rates,
+		.put = pistachio_card_set_sample_rates
+	},
+};
+
+static int pistachio_card_i2s_clk_cb(struct notifier_block *nb,
+				     unsigned long event, void *data)
+{
+	struct clk_notifier_data *ndata = data;
+	struct pistachio_card *pbc;
+
+	pbc = container_of(nb, struct pistachio_card, i2s_clk_notifier);
+
+	switch (event) {
+	case PRE_RATE_CHANGE:
+		/* Allow changes made by the card driver only */
+		if (ndata->new_rate == pbc->i2s_mclk.cur_rate)
+			return NOTIFY_OK;
+		else
+			return NOTIFY_STOP;
+	case POST_RATE_CHANGE:
+	case ABORT_RATE_CHANGE:
+		return NOTIFY_OK;
+	default:
+		return NOTIFY_DONE;
+	}
+}
+
+#ifdef DEBUG
+
+static void pistachio_card_info_fmt(struct pistachio_card *pbc,
+				    unsigned int fmt)
+{
+	struct device *dev = pbc->card.dev;
+	char *text_a, *text_b;
+
+	if ((fmt & SND_SOC_DAIFMT_FORMAT_MASK) == SND_SOC_DAIFMT_I2S)
+		text_a = "I2S";
+	else
+		text_a = "Left Justified";
+	dev_dbg(dev, "    Format: %s\n", text_a);
+
+	switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
+	case SND_SOC_DAIFMT_NB_NF:
+		text_a = "No";
+		text_b = "No";
+		break;
+	case SND_SOC_DAIFMT_NB_IF:
+		text_a = "Yes";
+		text_b = "No";
+		break;
+	case SND_SOC_DAIFMT_IB_NF:
+		text_a = "No";
+		text_b = "Yes";
+		break;
+	default:
+		text_a = "Yes";
+		text_b = "Yes";
+		break;
+	}
+	dev_dbg(dev, "    Frame Clock Inverted: %s\n", text_a);
+	dev_dbg(dev, "    Bit Clock Inverted: %s\n", text_b);
+
+	if ((fmt & SND_SOC_DAIFMT_CLOCK_MASK) == SND_SOC_DAIFMT_CONT)
+		text_a = "Yes";
+	else
+		text_a = "No";
+	dev_dbg(dev, "    Continuous Clock: %s\n", text_a);
+}
+
+static void pistachio_card_info_mclk(struct pistachio_card *pbc,
+				     struct pistachio_i2s_mclk *mclk)
+{
+	struct device *dev = pbc->card.dev;
+	int i;
+
+	dev_dbg(dev, "        Min FS Freq: %u\n", mclk->min_rate);
+	dev_dbg(dev, "        Max FS Freq: %u\n", mclk->max_rate);
+	dev_dbg(dev, "        FS Rates:\n");
+
+	for (i = 0; i < mclk->num_fs_rates; i++)
+		dev_dbg(dev, "            %u\n", mclk->fs_rates[i]);
+}
+
+static void pistachio_card_info_mclks(struct pistachio_card *pbc,
+				      struct pistachio_i2s *i2s)
+{
+	struct pistachio_i2s_mclk *i2s_mclk;
+	struct pistachio_i2s_mclk *dac_mclk;
+	struct device *dev = pbc->card.dev;
+
+	if (i2s->mclk_a.mclk == &pbc->i2s_mclk)
+		i2s_mclk = &i2s->mclk_a;
+	else if (pbc->i2s_in->i2s.mclk_b.mclk == &pbc->i2s_mclk)
+		i2s_mclk = &i2s->mclk_b;
+	else
+		i2s_mclk = NULL;
+
+	if (i2s_mclk) {
+		dev_dbg(dev, "    I2S MCLK\n");
+		pistachio_card_info_mclk(pbc, i2s_mclk);
+	} else {
+		dev_dbg(dev, "    I2S MCLK NOT USED\n");
+	}
+
+	dev_dbg(dev, "\n");
+
+	if (i2s->mclk_a.mclk == &pbc->dac_mclk)
+		dac_mclk = &i2s->mclk_a;
+	else if (i2s->mclk_b.mclk == &pbc->dac_mclk)
+		dac_mclk = &i2s->mclk_b;
+	else
+		dac_mclk = NULL;
+
+	if (dac_mclk) {
+		dev_dbg(dev, "    DAC MCLK\n");
+		pistachio_card_info_mclk(pbc, dac_mclk);
+	} else {
+		dev_dbg(dev, "    DAC MCLK NOT USED\n");
+	}
+}
+
+static void pistachio_card_info_i2s_out(struct pistachio_card *pbc,
+					struct snd_soc_dai_link *link)
+{
+	int i, j;
+	struct snd_soc_dai_link_component *components;
+	struct snd_soc_codec_conf *confs;
+	struct device *dev = pbc->card.dev;
+	char *text;
+
+	components = pbc->i2s_out->i2s.components;
+	confs = pbc->card.codec_conf;
+
+	dev_dbg(dev, "I2S OUT\n");
+	dev_dbg(dev, "\n");
+	if (pbc->i2s_in && (pbc->i2s_in->frame_master ==
+			    PISTACHIO_CLOCK_MASTER_LOOPBACK))
+		text = "(Dual Frame + Bit Clock Master)";
+	else
+		text = "(Frame + Bit Clock Master)";
+	dev_dbg(dev, "    CPU DAI\n");
+	dev_dbg(dev, "        i2s-out (%s) %s\n",
+		link->cpu_of_node->name, text);
+	dev_dbg(dev, "\n");
+	dev_dbg(dev, "    CODECS\n");
+
+	for (i = 0; i < pbc->i2s_out->i2s.num_codecs; i++) {
+		for (j = 0; j < pbc->card.num_configs; j++)
+			if (confs[j].of_node == components[i].of_node)
+				break;
+
+		dev_dbg(dev, "        %s (%s) (%s)\n", confs[j].name_prefix,
+			confs[j].of_node->name, components[i].dai_name);
+	}
+	dev_dbg(dev, "\n");
+
+	pistachio_card_info_mclks(pbc, &pbc->i2s_out->i2s);
+
+	dev_dbg(dev, "\n");
+
+	pistachio_card_info_fmt(pbc, link->dai_fmt);
+
+	dev_dbg(dev, "\n");
+}
+
+static void pistachio_card_info_i2s_in(struct pistachio_card *pbc,
+				       struct snd_soc_dai_link *link)
+{
+	int i, j;
+	struct snd_soc_dai_link_component *components;
+	struct snd_soc_codec_conf *confs;
+	char *text;
+	struct device *dev = pbc->card.dev;
+
+	components = pbc->i2s_in->i2s.components;
+	confs = pbc->card.codec_conf;
+
+	dev_dbg(dev, "I2S IN\n");
+	dev_dbg(dev, "\n");
+	dev_dbg(dev, "    CPU DAI\n");
+	dev_dbg(dev, "        i2s-in (%s)\n", link->cpu_of_node->name);
+	dev_dbg(dev, "\n");
+	dev_dbg(dev, "    CODECS\n");
+
+	for (i = 0; i < pbc->i2s_in->i2s.num_codecs; i++) {
+		for (j = 0; j < pbc->card.num_configs; j++)
+			if (confs[j].of_node == components[i].of_node)
+				break;
+
+		if (i == pbc->i2s_in->frame_master)
+			if (i == pbc->i2s_in->bitclock_master)
+				text = "(Frame + Bit Clock Master)";
+			else
+				text = "(Frame Master)";
+		else
+			if (i == pbc->i2s_in->bitclock_master)
+				text = "(Bitclock Master)";
+			else
+				text = "";
+
+		dev_dbg(dev, "        %s (%s) (%s) %s\n", confs[j].name_prefix,
+			confs[j].of_node->name, components[i].dai_name, text);
+	}
+	dev_dbg(dev, "\n");
+
+	pistachio_card_info_mclks(pbc, &pbc->i2s_in->i2s);
+
+	dev_dbg(dev, "\n");
+
+	pistachio_card_info_fmt(pbc, pbc->i2s_in->fmt);
+
+	dev_dbg(dev, "\n");
+}
+
+static void pistachio_card_info(struct pistachio_card *pbc)
+{
+	struct device *dev = pbc->card.dev;
+	struct snd_soc_codec_conf *conf;
+	struct snd_soc_dai_link *link;
+	char *text;
+
+	link = pbc->card.dai_link;
+
+	dev_dbg(dev, "\n");
+	dev_dbg(dev, "####################################################\n");
+	dev_dbg(dev, "\n");
+	dev_dbg(dev, "Pistachio Audio Card\n");
+	dev_dbg(dev, "\n");
+
+	if (pbc->spdif_out) {
+		dev_dbg(dev, "SPDIF OUT\n");
+		dev_dbg(dev, "\n");
+		dev_dbg(dev, "    CPU DAI\n");
+		dev_dbg(dev, "        spdif-out (%s)\n",
+			link->cpu_of_node->name);
+		dev_dbg(dev, "\n");
+		link++;
+	}
+	if (pbc->spdif_in) {
+		dev_dbg(dev, "SPDIF IN\n");
+		dev_dbg(dev, "\n");
+		dev_dbg(dev, "    CPU DAI\n");
+		dev_dbg(dev, "        spdif-in (%s)\n",
+			link->cpu_of_node->name);
+		dev_dbg(dev, "\n");
+		link++;
+	}
+	if (pbc->parallel_out) {
+		dev_dbg(dev, "PARALLEL OUT\n");
+		dev_dbg(dev, "\n");
+		dev_dbg(dev, "    CPU DAI\n");
+		dev_dbg(dev, "        parallel-out (%s)\n",
+			link->cpu_of_node->name);
+		dev_dbg(dev, "\n");
+		dev_dbg(dev, "    CODEC\n");
+		conf = &pbc->card.codec_conf[pbc->card.num_configs - 1];
+		dev_dbg(dev, "        %s (%s) (%s)\n", conf->name_prefix,
+			conf->of_node->name,
+			pbc->parallel_out->component.dai_name);
+		dev_dbg(dev, "\n");
+		link++;
+	}
+	if (pbc->i2s_out) {
+		pistachio_card_info_i2s_out(pbc, link);
+		link++;
+	}
+	if (pbc->i2s_in)
+		pistachio_card_info_i2s_in(pbc, link);
+
+	dev_dbg(dev, "I2S MCLK Max Freq: %u\n", pbc->i2s_mclk.max_rate);
+	dev_dbg(dev, "DAC MCLK Max Freq: %u\n", pbc->dac_mclk.max_rate);
+	dev_dbg(dev, "\n");
+
+	if (gpio_is_valid(pbc->mute_gpio)) {
+		if (pbc->mute_gpio_inverted)
+			text = "(Active Low)";
+		else
+			text = "(Active High)";
+		dev_dbg(dev, "Mute: GPIO %u %s\n", pbc->mute_gpio, text);
+	}
+	if (gpio_is_valid(pbc->hp_jack_gpio.gpio)) {
+		if (pbc->hp_jack_gpio.invert)
+			text = "(Active Low)";
+		else
+			text = "(Active High)";
+		dev_dbg(dev, "Headphone-Detect: GPIO %u %s\n",
+				pbc->hp_jack_gpio.gpio, text);
+	}
+	dev_dbg(dev, "\n");
+	dev_dbg(dev, "####################################################\n");
+	dev_dbg(dev, "\n");
+}
+
+#endif
+
+static int pistachio_card_probe(struct platform_device *pdev)
+{
+	struct pistachio_card *pbc;
+	struct device_node *np = pdev->dev.of_node;
+	struct device *dev = &pdev->dev;
+	int ret;
+	unsigned long gpio_flags;
+	struct snd_kcontrol_new *control;
+
+	if (!np || !of_device_is_available(np))
+		return -EINVAL;
+
+	pbc = devm_kzalloc(dev, sizeof(*pbc), GFP_KERNEL);
+	if (!pbc)
+		return -ENOMEM;
+
+	snd_soc_card_set_drvdata(&pbc->card, pbc);
+
+	pbc->card.owner = THIS_MODULE;
+	pbc->card.dev = dev;
+	pbc->card.name = "pistachio-card";
+
+	pbc->i2s_mclk.name = PISTACHIO_I2S_MCLK_NAME;
+	pbc->i2s_mclk.max_rate = PISTACHIO_I2S_MCLK_MAX_FREQ;
+	pbc->dac_mclk.name = PISTACHIO_DAC_MCLK_NAME;
+	pbc->dac_mclk.max_rate = PISTACHIO_DAC_MCLK_MAX_FREQ;
+
+	mutex_init(&pbc->rate_mutex);
+
+	pbc->hp_jack_gpio.gpio = -ENOENT;
+	pbc->mute_gpio = -ENOENT;
+
+	pbc->card.dapm_widgets = pistachio_card_widgets;
+	pbc->card.num_dapm_widgets = ARRAY_SIZE(pistachio_card_widgets);
+
+	pbc->card.dapm_routes = pbc->routes;
+
+	ret = pistachio_card_parse_of(np, pbc);
+	if (ret)
+		goto err;
+
+	pbc->audio_pll_rate = PISTACHIO_PLL_RATE_B;
+	ret = pistachio_card_init_clk(dev, "audio_pll", &pbc->audio_pll,
+				      pbc->audio_pll_rate);
+	if (ret)
+		goto err;
+
+	pbc->i2s_mclk.cur_rate = PISTACHIO_MIN_MCLK_FREQ;
+	ret = pistachio_card_init_clk(dev, PISTACHIO_I2S_MCLK_NAME,
+				      &pbc->i2s_mclk.mclk,
+				      pbc->i2s_mclk.cur_rate);
+	if (ret)
+		goto err;
+
+	pbc->dac_mclk.cur_rate = PISTACHIO_MIN_MCLK_FREQ;
+	ret = pistachio_card_init_clk(dev, PISTACHIO_DAC_MCLK_NAME,
+				      &pbc->dac_mclk.mclk,
+				      pbc->dac_mclk.cur_rate);
+	if (ret)
+		goto err;
+
+	pbc->i2s_clk_notifier.notifier_call = pistachio_card_i2s_clk_cb;
+	ret = clk_notifier_register(pbc->i2s_mclk.mclk,
+				    &pbc->i2s_clk_notifier);
+	if (ret) {
+		dev_err(dev, "clk_notifier_register failed: %d", ret);
+		goto err;
+	}
+
+	ret = devm_snd_soc_register_card(dev, &pbc->card);
+	if (ret) {
+		dev_err(dev, "devm_snd_soc_register_card failed: %d", ret);
+		goto err_notifier;
+	}
+
+	ret = snd_soc_add_card_controls(&pbc->card, pistachio_controls,
+					ARRAY_SIZE(pistachio_controls));
+	if (ret) {
+		dev_err(dev, "snd_soc_add_card_controls failed: %d", ret);
+		goto err_notifier;
+	}
+
+	if (gpio_is_valid(pbc->hp_jack_gpio.gpio)) {
+		pbc->hp_jack_pin.pin = "Headphones";
+		pbc->hp_jack_pin.mask = SND_JACK_HEADPHONE;
+		pbc->hp_jack_gpio.name = "Headphone detection";
+		pbc->hp_jack_gpio.report = SND_JACK_HEADPHONE;
+		pbc->hp_jack_gpio.debounce_time = 150;
+		ret = snd_soc_card_jack_new(&pbc->card, "Headphones",
+					    SND_JACK_HEADPHONE, &pbc->hp_jack,
+					    &pbc->hp_jack_pin, 1);
+		if (ret) {
+			dev_err(dev, "snd_soc_card_jack_new failed: %d", ret);
+			goto err_notifier;
+		}
+		ret = snd_soc_jack_add_gpios(&pbc->hp_jack, 1,
+					     &pbc->hp_jack_gpio);
+		if (ret) {
+			dev_err(dev, "snd_soc_jack_add_gpios failed: %d", ret);
+			goto err_notifier;
+		}
+	}
+
+	if (gpio_is_valid(pbc->mute_gpio)) {
+		if (pbc->mute_gpio_inverted)
+			gpio_flags = GPIOF_OUT_INIT_HIGH;
+		else
+			gpio_flags = GPIOF_OUT_INIT_LOW;
+		ret = gpio_request_one(pbc->mute_gpio, gpio_flags, "Mute");
+		if (ret) {
+			dev_err(dev, "gpio_request_one failed: %d", ret);
+			goto err_jack;
+		}
+		control = devm_kzalloc(dev, sizeof(*control), GFP_KERNEL);
+		if (!control) {
+			ret = -ENOMEM;
+			goto err_mute;
+		}
+		control->access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
+		control->iface = SNDRV_CTL_ELEM_IFACE_CARD;
+		control->name = "Mute Switch";
+		control->info = snd_ctl_boolean_mono_info;
+		control->get = pistachio_card_get_mute;
+		control->put = pistachio_card_set_mute;
+		ret = snd_soc_add_card_controls(&pbc->card, control, 1);
+		if (ret) {
+			dev_err(dev, "mute control add failed: %d", ret);
+			goto err_mute;
+		}
+	}
+
+#ifdef	DEBUG
+	pistachio_card_info(pbc);
+#endif
+
+	return 0;
+
+err_mute:
+	if (gpio_is_valid(pbc->mute_gpio))
+		gpio_free(pbc->mute_gpio);
+err_jack:
+	if (gpio_is_valid(pbc->hp_jack_gpio.gpio))
+		snd_soc_jack_free_gpios(&pbc->hp_jack, 1, &pbc->hp_jack_gpio);
+err_notifier:
+	clk_notifier_unregister(pbc->i2s_mclk.mclk, &pbc->i2s_clk_notifier);
+err:
+	pistachio_card_unref(pbc);
+
+	return ret;
+}
+
+static int pistachio_card_remove(struct platform_device *pdev)
+{
+	struct snd_soc_card *card = platform_get_drvdata(pdev);
+	struct pistachio_card *pbc = snd_soc_card_get_drvdata(card);
+
+	if (gpio_is_valid(pbc->mute_gpio))
+		gpio_free(pbc->mute_gpio);
+	if (gpio_is_valid(pbc->hp_jack_gpio.gpio))
+		snd_soc_jack_free_gpios(&pbc->hp_jack, 1, &pbc->hp_jack_gpio);
+	clk_notifier_unregister(pbc->i2s_mclk.mclk, &pbc->i2s_clk_notifier);
+	pistachio_card_unref(pbc);
+
+	return 0;
+}
+
+static const struct of_device_id pistachio_card_of_match[] = {
+	{ .compatible = "img,pistachio-audio" },
+	{},
+};
+MODULE_DEVICE_TABLE(of, pistachio_card_of_match);
+
+static struct platform_driver pistachio_card = {
+	.driver = {
+		.name = "pistachio-card",
+		.of_match_table = pistachio_card_of_match,
+	},
+	.probe = pistachio_card_probe,
+	.remove = pistachio_card_remove,
+};
+module_platform_driver(pistachio_card);
+
+MODULE_DESCRIPTION("Pistachio audio card driver");
+MODULE_AUTHOR("Damien Horsley <Damien.Horsley@imgtec.com>");
+MODULE_LICENSE("GPL v2");
