Add support for Allo Boss DAC add-on board for Raspberry Pi. (#1924)

Signed-off-by: Baswaraj K <jaikumar@cem-solutions.net>
Reviewed-by: Deepak <deepak@zilogic.com>
Reviewed-by: BabuSubashChandar <babusubashchandar@zilogic.com>
Signed-off-by: Tim Gardner <tim.gardner@canonical.com>

diff --git a/arch/arm/boot/dts/overlays/Makefile b/arch/arm/boot/dts/overlays/Makefile
index 73826c74d2cfb58cac1a72e523ce00b021411d16..b64dd7ac0630b2b525809a9f5221420f34a58ac9 100644 (file)
--- a/arch/arm/boot/dts/overlays/Makefile
+++ b/arch/arm/boot/dts/overlays/Makefile
@@ -7,6 +7,7 @@ dtbo-$(CONFIG_ARCH_BCM2835) += \
        ads1115.dtbo \
        ads7846.dtbo \
        akkordion-iqdacplus.dtbo \
+       allo-boss-dac-pcm512x-audio.dtbo \
        allo-piano-dac-pcm512x-audio.dtbo \
        allo-piano-dac-plus-pcm512x-audio.dtbo \
        at86rf233.dtbo \

diff --git a/arch/arm/boot/dts/overlays/README b/arch/arm/boot/dts/overlays/README
index 1e3420e80d620f3c376ffb7c905e7aba7f63d709..c9e954253a6318dbd2605b93026c04974b3271bd 100644 (file)
--- a/arch/arm/boot/dts/overlays/README
+++ b/arch/arm/boot/dts/overlays/README
@@ -263,6 +263,30 @@ Params: 24db_digital_gain       Allow gain to be applied via the PCM512x codec
                                 that does not result in clipping/distortion!)
 
 
+Name:   allo-boss-dac-pcm512x-audio
+Info:   Configures the Allo Boss DAC audio cards.
+Load:   dtoverlay=allo-boss-dac-pcm512x-audio,<param>
+Params: 24db_digital_gain       Allow gain to be applied via the PCM512x codec
+                                Digital volume control. Enable with
+                                "dtoverlay=allo-boss-dac-pcm512x-audio,
+                                24db_digital_gain"
+                                (The default behaviour is that the Digital
+                                volume control is limited to a maximum of
+                                0dB. ie. it can attenuate but not provide
+                                gain. For most users, this will be desired
+                                as it will prevent clipping. By appending
+                                the 24db_digital_gain parameter, the Digital
+                                volume control will allow up to 24dB of
+                                gain. If this parameter is enabled, it is the
+                                responsibility of the user to ensure that
+                                the Digital volume control is set to a value
+                                that does not result in clipping/distortion!)
+        slave                   Force Boss DAC into slave mode, using Pi a
+                                master for bit clock and frame clock. Enable
+                                with "dtoverlay=allo-boss-dac-pcm512x-audio,
+                                slave"
+
+
 Name:   allo-piano-dac-pcm512x-audio
 Info:   Configures the Allo Piano DAC (2.0/2.1) audio cards.
         (NB. This initial support is for 2.0 channel audio ONLY! ie. stereo.

diff --git a/arch/arm/boot/dts/overlays/allo-boss-dac-pcm512x-audio-overlay.dts b/arch/arm/boot/dts/overlays/allo-boss-dac-pcm512x-audio-overlay.dts
new file mode 100644 (file)
index 0000000..7df335a
--- /dev/null
+++ b/arch/arm/boot/dts/overlays/allo-boss-dac-pcm512x-audio-overlay.dts
@@ -0,0 +1,58 @@
+/*
+ * Definitions for Allo Boss DAC board
+ */
+
+/dts-v1/;
+/plugin/;
+
+/ {
+       compatible = "brcm,bcm2708";
+
+       fragment@0 {
+               target-path = "/clocks";
+               __overlay__ {
+                       boss_osc: boss_osc {
+                               compatible = "allo,dac-clk";
+                               #clock-cells = <0>;
+                       };
+               };
+       };
+
+       fragment@1 {
+               target = <&i2s>;
+               __overlay__ {
+                       status = "okay";
+               };
+       };
+
+       fragment@2 {
+               target = <&i2c1>;
+               __overlay__ {
+                       #address-cells = <1>;
+                       #size-cells = <0>;
+                       status = "okay";
+
+                       pcm5122@4d {
+                               #sound-dai-cells = <0>;
+                               compatible = "ti,pcm5122";
+                               clocks = <&boss_osc>;
+                               reg = <0x4d>;
+                               status = "okay";
+                       };
+               };
+       };
+
+       fragment@3 {
+               target = <&sound>;
+               boss_dac: __overlay__ {
+                       compatible = "allo,boss-dac";
+                       i2s-controller = <&i2s>;
+                       status = "okay";
+               };
+       };
+
+       __overrides__ {
+               24db_digital_gain = <&boss_dac>,"allo,24db_digital_gain?";
+               slave = <&boss_dac>,"allo,slave?";
+       };
+};

diff --git a/drivers/clk/Makefile b/drivers/clk/Makefile
index 5ae5237accf2ebd80b38065d37984554e3f0f939..a9ad66c714f14de828d164d0d55f2ca63644b750 100644 (file)
--- a/drivers/clk/Makefile
+++ b/drivers/clk/Makefile
@@ -17,6 +17,7 @@ endif
 
 # hardware specific clock types
 # please keep this section sorted lexicographically by file path name
+obj-$(CONFIG_SND_BCM2708_SOC_ALLO_BOSS_DAC)    += clk-allo-dac-45Mhz.o
 obj-$(CONFIG_MACH_ASM9260)             += clk-asm9260.o
 obj-$(CONFIG_COMMON_CLK_AXI_CLKGEN)    += clk-axi-clkgen.o
 obj-$(CONFIG_ARCH_AXXIA)               += clk-axm5516.o

diff --git a/drivers/clk/clk-allo-dac-45Mhz.c b/drivers/clk/clk-allo-dac-45Mhz.c
new file mode 100644 (file)
index 0000000..d5e9e5b
--- /dev/null
+++ b/drivers/clk/clk-allo-dac-45Mhz.c
@@ -0,0 +1,161 @@
+/*
+ * Clock Driver for Allo DAC
+ *
+ * Author:     Baswaraj K <jaikumar@cem-solutions.net>
+ *             Copyright 2016
+ *             based on code by Stuart MacLean
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ */
+
+#include <linux/clk-provider.h>
+#include <linux/clkdev.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/slab.h>
+#include <linux/platform_device.h>
+
+/* Clock rate of CLK44EN attached to GPIO6 pin */
+#define CLK_44EN_RATE 45158400UL
+/* Clock rate of CLK48EN attached to GPIO3 pin */
+#define CLK_48EN_RATE 49152000UL
+
+/**
+ * struct allo_dac_clk - Common struct to the Allo DAC
+ * @hw: clk_hw for the common clk framework
+ * @mode: 0 => CLK44EN, 1 => CLK48EN
+ */
+struct clk_allo_hw {
+       struct clk_hw hw;
+       uint8_t mode;
+};
+
+#define to_allo_clk(_hw) container_of(_hw, struct clk_allo_hw, hw)
+
+static const struct of_device_id clk_allo_dac_dt_ids[] = {
+       { .compatible = "allo,dac-clk",},
+       { }
+};
+MODULE_DEVICE_TABLE(of, clk_allo_dac_dt_ids);
+
+static unsigned long clk_allo_dac_recalc_rate(struct clk_hw *hw,
+       unsigned long parent_rate)
+{
+       return (to_allo_clk(hw)->mode == 0) ? CLK_44EN_RATE :
+               CLK_48EN_RATE;
+}
+
+static long clk_allo_dac_round_rate(struct clk_hw *hw,
+       unsigned long rate, unsigned long *parent_rate)
+{
+       long actual_rate;
+
+       if (rate <= CLK_44EN_RATE) {
+               actual_rate = (long)CLK_44EN_RATE;
+       } else if (rate >= CLK_48EN_RATE) {
+               actual_rate = (long)CLK_48EN_RATE;
+       } else {
+               long diff44Rate = (long)(rate - CLK_44EN_RATE);
+               long diff48Rate = (long)(CLK_48EN_RATE - rate);
+
+               if (diff44Rate < diff48Rate)
+                       actual_rate = (long)CLK_44EN_RATE;
+               else
+                       actual_rate = (long)CLK_48EN_RATE;
+       }
+       return actual_rate;
+}
+
+
+static int clk_allo_dac_set_rate(struct clk_hw *hw,
+       unsigned long rate, unsigned long parent_rate)
+{
+       unsigned long actual_rate;
+       struct clk_allo_hw *clk = to_allo_clk(hw);
+
+       actual_rate = (unsigned long)clk_allo_dac_round_rate(hw, rate,
+               &parent_rate);
+       clk->mode = (actual_rate == CLK_44EN_RATE) ? 0 : 1;
+       return 0;
+}
+
+
+const struct clk_ops clk_allo_dac_rate_ops = {
+       .recalc_rate = clk_allo_dac_recalc_rate,
+       .round_rate = clk_allo_dac_round_rate,
+       .set_rate = clk_allo_dac_set_rate,
+};
+
+static int clk_allo_dac_probe(struct platform_device *pdev)
+{
+       int ret;
+       struct clk_allo_hw *proclk;
+       struct clk *clk;
+       struct device *dev;
+       struct clk_init_data init;
+
+       dev = &pdev->dev;
+
+       proclk = kzalloc(sizeof(struct clk_allo_hw), GFP_KERNEL);
+       if (!proclk)
+               return -ENOMEM;
+
+       init.name = "clk-allo-dac";
+       init.ops = &clk_allo_dac_rate_ops;
+       init.flags = CLK_IS_ROOT | CLK_IS_BASIC;
+       init.parent_names = NULL;
+       init.num_parents = 0;
+
+       proclk->mode = 0;
+       proclk->hw.init = &init;
+
+       clk = devm_clk_register(dev, &proclk->hw);
+       if (!IS_ERR(clk)) {
+               ret = of_clk_add_provider(dev->of_node, of_clk_src_simple_get,
+                       clk);
+       } else {
+               dev_err(dev, "Fail to register clock driver\n");
+               kfree(proclk);
+               ret = PTR_ERR(clk);
+       }
+       return ret;
+}
+
+static int clk_allo_dac_remove(struct platform_device *pdev)
+{
+       of_clk_del_provider(pdev->dev.of_node);
+       return 0;
+}
+
+static struct platform_driver clk_allo_dac_driver = {
+       .probe = clk_allo_dac_probe,
+       .remove = clk_allo_dac_remove,
+       .driver = {
+               .name = "clk-allo-dac",
+               .of_match_table = clk_allo_dac_dt_ids,
+       },
+};
+
+static int __init clk_allo_dac_init(void)
+{
+       return platform_driver_register(&clk_allo_dac_driver);
+}
+core_initcall(clk_allo_dac_init);
+
+static void __exit clk_allo_dac_exit(void)
+{
+       platform_driver_unregister(&clk_allo_dac_driver);
+}
+module_exit(clk_allo_dac_exit);
+
+MODULE_DESCRIPTION("Allo DAC clock driver");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:clk-allo-dac");

diff --git a/sound/soc/bcm/Kconfig b/sound/soc/bcm/Kconfig
index ee59713344b3d0385c4d659d6dab3da8c2a60633..be474a58151889f145ca5aeb789ea6c116c4fd44 100644 (file)
--- a/sound/soc/bcm/Kconfig
+++ b/sound/soc/bcm/Kconfig
@@ -176,6 +176,14 @@ config SND_BCM2708_SOC_FE_PI_AUDIO
        help
          Say Y or M if you want to add support for Fe-Pi-Audio.
 
+config SND_BCM2708_SOC_ALLO_BOSS_DAC
+       tristate "Support for allo Boss DAC"
+       depends on SND_BCM2708_SOC_I2S || SND_BCM2835_SOC_I2S
+       select SND_SOC_PCM512x_I2C
+       help
+         Say Y or M if you want to add support for allo Boss DAC.
+
+
 config SND_PISOUND
        tristate "Support for Blokas Labs pisound"
        depends on SND_BCM2708_SOC_I2S || SND_BCM2835_SOC_I2S

diff --git a/sound/soc/bcm/Makefile b/sound/soc/bcm/Makefile
index 54b4111ad820b3f8086867ca2ce86d5339fca93e..72e1620fa4038035804cf3b2a09c6b12e7ae0fe1 100644 (file)
--- a/sound/soc/bcm/Makefile
+++ b/sound/soc/bcm/Makefile
@@ -31,6 +31,7 @@ snd-soc-audioinjector-octo-soundcard-objs := audioinjector-octo-soundcard.o
 snd-soc-digidac1-soundcard-objs := digidac1-soundcard.o
 snd-soc-dionaudio-loco-objs := dionaudio_loco.o
 snd-soc-dionaudio-loco-v2-objs := dionaudio_loco-v2.o
+snd-soc-allo-boss-dac-objs := allo-boss-dac.o
 snd-soc-allo-piano-dac-objs := allo-piano-dac.o
 snd-soc-allo-piano-dac-plus-objs := allo-piano-dac-plus.o
 snd-soc-pisound-objs := pisound.o
@@ -56,6 +57,7 @@ obj-$(CONFIG_SND_AUDIOINJECTOR_OCTO_SOUNDCARD) += snd-soc-audioinjector-octo-sou
 obj-$(CONFIG_SND_DIGIDAC1_SOUNDCARD) += snd-soc-digidac1-soundcard.o
 obj-$(CONFIG_SND_BCM2708_SOC_DIONAUDIO_LOCO) += snd-soc-dionaudio-loco.o
 obj-$(CONFIG_SND_BCM2708_SOC_DIONAUDIO_LOCO_V2) += snd-soc-dionaudio-loco-v2.o
+obj-$(CONFIG_SND_BCM2708_SOC_ALLO_BOSS_DAC) += snd-soc-allo-boss-dac.o
 obj-$(CONFIG_SND_BCM2708_SOC_ALLO_PIANO_DAC) += snd-soc-allo-piano-dac.o
 obj-$(CONFIG_SND_BCM2708_SOC_ALLO_PIANO_DAC_PLUS) += snd-soc-allo-piano-dac-plus.o
 obj-$(CONFIG_SND_PISOUND) += snd-soc-pisound.o

diff --git a/sound/soc/bcm/allo-boss-dac.c b/sound/soc/bcm/allo-boss-dac.c
new file mode 100644 (file)
index 0000000..c080e31
--- /dev/null
+++ b/sound/soc/bcm/allo-boss-dac.c
@@ -0,0 +1,374 @@
+/*
+ * ALSA ASoC Machine Driver for Allo Boss DAC
+ *
+ * Author:     Baswaraj K <jaikumar@cem-solutions.net>
+ *             Copyright 2016
+ *             based on code by Daniel Matuschek, Stuart MacLean <stuart@hifiberry.com>
+ *             based on code by Florian Meier <florian.meier@koalo.de>
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ */
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/delay.h>
+
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+#include "../codecs/pcm512x.h"
+
+#define ALLO_BOSS_NOCLOCK 0
+#define ALLO_BOSS_CLK44EN 1
+#define ALLO_BOSS_CLK48EN 2
+
+struct pcm512x_priv {
+       struct regmap *regmap;
+       struct clk *sclk;
+};
+
+/* Clock rate of CLK44EN attached to GPIO6 pin */
+#define CLK_44EN_RATE 45158400UL
+/* Clock rate of CLK48EN attached to GPIO3 pin */
+#define CLK_48EN_RATE 49152000UL
+
+static bool slave;
+static bool snd_soc_allo_boss_master;
+static bool digital_gain_0db_limit = true;
+
+static void snd_allo_boss_select_clk(struct snd_soc_codec *codec,
+       int clk_id)
+{
+       switch (clk_id) {
+       case ALLO_BOSS_NOCLOCK:
+               snd_soc_update_bits(codec, PCM512x_GPIO_CONTROL_1, 0x24, 0x00);
+               break;
+       case ALLO_BOSS_CLK44EN:
+               snd_soc_update_bits(codec, PCM512x_GPIO_CONTROL_1, 0x24, 0x20);
+               break;
+       case ALLO_BOSS_CLK48EN:
+               snd_soc_update_bits(codec, PCM512x_GPIO_CONTROL_1, 0x24, 0x04);
+               break;
+       }
+}
+
+static void snd_allo_boss_clk_gpio(struct snd_soc_codec *codec)
+{
+       snd_soc_update_bits(codec, PCM512x_GPIO_EN, 0x24, 0x24);
+       snd_soc_update_bits(codec, PCM512x_GPIO_OUTPUT_3, 0x0f, 0x02);
+       snd_soc_update_bits(codec, PCM512x_GPIO_OUTPUT_6, 0x0f, 0x02);
+}
+
+static bool snd_allo_boss_is_sclk(struct snd_soc_codec *codec)
+{
+       int sck;
+
+       sck = snd_soc_read(codec, PCM512x_RATE_DET_4);
+       return (!(sck & 0x40));
+}
+
+static bool snd_allo_boss_is_sclk_sleep(
+       struct snd_soc_codec *codec)
+{
+       msleep(2);
+       return snd_allo_boss_is_sclk(codec);
+}
+
+static bool snd_allo_boss_is_master_card(struct snd_soc_codec *codec)
+{
+       bool isClk44EN, isClk48En, isNoClk;
+
+       snd_allo_boss_clk_gpio(codec);
+
+       snd_allo_boss_select_clk(codec, ALLO_BOSS_CLK44EN);
+       isClk44EN = snd_allo_boss_is_sclk_sleep(codec);
+
+       snd_allo_boss_select_clk(codec, ALLO_BOSS_NOCLOCK);
+       isNoClk = snd_allo_boss_is_sclk_sleep(codec);
+
+       snd_allo_boss_select_clk(codec, ALLO_BOSS_CLK48EN);
+       isClk48En = snd_allo_boss_is_sclk_sleep(codec);
+
+       return (isClk44EN && isClk48En && !isNoClk);
+}
+
+static int snd_allo_boss_clk_for_rate(int sample_rate)
+{
+       int type;
+
+       switch (sample_rate) {
+       case 11025:
+       case 22050:
+       case 44100:
+       case 88200:
+       case 176400:
+               type = ALLO_BOSS_CLK44EN;
+               break;
+       default:
+               type = ALLO_BOSS_CLK48EN;
+               break;
+       }
+       return type;
+}
+
+static void snd_allo_boss_set_sclk(struct snd_soc_codec *codec,
+       int sample_rate)
+{
+       struct pcm512x_priv *pcm512x = snd_soc_codec_get_drvdata(codec);
+
+       if (!IS_ERR(pcm512x->sclk)) {
+               int ctype;
+
+               ctype = snd_allo_boss_clk_for_rate(sample_rate);
+               clk_set_rate(pcm512x->sclk, (ctype == ALLO_BOSS_CLK44EN)
+                               ? CLK_44EN_RATE : CLK_48EN_RATE);
+               snd_allo_boss_select_clk(codec, ctype);
+       }
+}
+
+static int snd_allo_boss_init(struct snd_soc_pcm_runtime *rtd)
+{
+       struct snd_soc_codec *codec = rtd->codec;
+       struct pcm512x_priv *priv;
+
+       if (slave)
+               snd_soc_allo_boss_master = false;
+       else
+               snd_soc_allo_boss_master =
+                       snd_allo_boss_is_master_card(codec);
+
+       if (snd_soc_allo_boss_master) {
+               struct snd_soc_dai_link *dai = rtd->dai_link;
+
+               dai->name = "BossDAC";
+               dai->stream_name = "BossDAC";
+               dai->dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF
+                       | SND_SOC_DAIFMT_CBM_CFM;
+
+               snd_soc_update_bits(codec, PCM512x_BCLK_LRCLK_CFG, 0x31, 0x11);
+               snd_soc_update_bits(codec, PCM512x_MASTER_MODE, 0x03, 0x03);
+               snd_soc_update_bits(codec, PCM512x_MASTER_CLKDIV_2, 0x7f, 63);
+       } else {
+               priv = snd_soc_codec_get_drvdata(codec);
+               priv->sclk = ERR_PTR(-ENOENT);
+       }
+
+       snd_soc_update_bits(codec, PCM512x_GPIO_EN, 0x08, 0x08);
+       snd_soc_update_bits(codec, PCM512x_GPIO_OUTPUT_4, 0x0f, 0x02);
+       snd_soc_update_bits(codec, PCM512x_GPIO_CONTROL_1, 0x08, 0x08);
+
+       if (digital_gain_0db_limit) {
+               int ret;
+               struct snd_soc_card *card = rtd->card;
+
+               ret = snd_soc_limit_volume(card, "Digital Playback Volume",
+                               207);
+               if (ret < 0)
+                       dev_warn(card->dev, "Failed to set volume limit: %d\n",
+                                       ret);
+       }
+
+       return 0;
+}
+
+static int snd_allo_boss_update_rate_den(
+       struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params)
+{
+       struct snd_soc_pcm_runtime *rtd = substream->private_data;
+       struct snd_soc_codec *codec = rtd->codec;
+       struct pcm512x_priv *pcm512x = snd_soc_codec_get_drvdata(codec);
+       struct snd_ratnum *rats_no_pll;
+       unsigned int num = 0, den = 0;
+       int err;
+
+       rats_no_pll = devm_kzalloc(rtd->dev, sizeof(*rats_no_pll), GFP_KERNEL);
+       if (!rats_no_pll)
+               return -ENOMEM;
+
+       rats_no_pll->num = clk_get_rate(pcm512x->sclk) / 64;
+       rats_no_pll->den_min = 1;
+       rats_no_pll->den_max = 128;
+       rats_no_pll->den_step = 1;
+
+       err = snd_interval_ratnum(hw_param_interval(params,
+               SNDRV_PCM_HW_PARAM_RATE), 1, rats_no_pll, &num, &den);
+       if (err >= 0 && den) {
+               params->rate_num = num;
+               params->rate_den = den;
+       }
+
+       devm_kfree(rtd->dev, rats_no_pll);
+       return 0;
+}
+
+static int snd_allo_boss_set_bclk_ratio_pro(
+       struct snd_soc_dai *cpu_dai, struct snd_pcm_hw_params *params)
+{
+       int bratio = snd_pcm_format_physical_width(params_format(params))
+               * params_channels(params);
+       return snd_soc_dai_set_bclk_ratio(cpu_dai, bratio);
+}
+
+static int snd_allo_boss_hw_params(
+       struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params)
+{
+       int ret = 0;
+       struct snd_soc_pcm_runtime *rtd = substream->private_data;
+       struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
+       unsigned int sample_bits =
+               snd_pcm_format_physical_width(params_format(params));
+
+       if (snd_soc_allo_boss_master) {
+               struct snd_soc_codec *codec = rtd->codec;
+
+               snd_allo_boss_set_sclk(codec,
+                       params_rate(params));
+
+               ret = snd_allo_boss_set_bclk_ratio_pro(cpu_dai,
+                       params);
+               if (!ret)
+                       ret = snd_allo_boss_update_rate_den(
+                               substream, params);
+       } else {
+               if (snd_allo_boss_is_sclk(rtd->codec)) {
+                       snd_soc_update_bits(rtd->codec, PCM512x_PLL_EN,
+                                       PCM512x_PLLE, 0x01);
+                       snd_soc_update_bits(rtd->codec, PCM512x_PLL_REF,
+                                       PCM512x_SREF, PCM512x_SREF_BCK);
+                       dev_dbg(rtd->codec->dev,
+                               "Setting BCLK as input clock and Enable PLL\n");
+               } else {
+                       snd_soc_update_bits(rtd->codec, PCM512x_PLL_EN,
+                                       PCM512x_PLLE, 0x00);
+                       snd_soc_update_bits(rtd->codec, PCM512x_PLL_REF,
+                                       PCM512x_SREF, PCM512x_SREF_SCK);
+
+                       dev_dbg(rtd->codec->dev,
+                               "Setting SCLK as input clock and disabled PLL\n");
+               }
+
+               ret = snd_soc_dai_set_bclk_ratio(cpu_dai, sample_bits * 2);
+       }
+       return ret;
+}
+
+static int snd_allo_boss_startup(
+       struct snd_pcm_substream *substream)
+{
+       struct snd_soc_pcm_runtime *rtd = substream->private_data;
+       struct snd_soc_codec *codec = rtd->codec;
+
+       snd_soc_update_bits(codec, PCM512x_GPIO_CONTROL_1, 0x08, 0x08);
+       return 0;
+}
+
+static void snd_allo_boss_shutdown(
+       struct snd_pcm_substream *substream)
+{
+       struct snd_soc_pcm_runtime *rtd = substream->private_data;
+       struct snd_soc_codec *codec = rtd->codec;
+
+       snd_soc_update_bits(codec, PCM512x_GPIO_CONTROL_1, 0x08, 0x00);
+}
+
+/* machine stream operations */
+static struct snd_soc_ops snd_allo_boss_ops = {
+       .hw_params = snd_allo_boss_hw_params,
+       .startup = snd_allo_boss_startup,
+       .shutdown = snd_allo_boss_shutdown,
+};
+
+static struct snd_soc_dai_link snd_allo_boss_dai[] = {
+{
+       .name           = "Boss DAC",
+       .stream_name    = "Boss DAC HiFi",
+       .cpu_dai_name   = "bcm2708-i2s.0",
+       .codec_dai_name = "pcm512x-hifi",
+       .platform_name  = "bcm2708-i2s.0",
+       .codec_name     = "pcm512x.1-004d",
+       .dai_fmt        = SND_SOC_DAIFMT_I2S |
+                         SND_SOC_DAIFMT_NB_NF |
+                         SND_SOC_DAIFMT_CBS_CFS,
+       .ops            = &snd_allo_boss_ops,
+       .init           = snd_allo_boss_init,
+},
+};
+
+/* audio machine driver */
+static struct snd_soc_card snd_allo_boss = {
+       .name         = "BossDAC",
+       .owner        = THIS_MODULE,
+       .dai_link     = snd_allo_boss_dai,
+       .num_links    = ARRAY_SIZE(snd_allo_boss_dai),
+};
+
+static int snd_allo_boss_probe(struct platform_device *pdev)
+{
+       int ret = 0;
+
+       snd_allo_boss.dev = &pdev->dev;
+
+       if (pdev->dev.of_node) {
+               struct device_node *i2s_node;
+               struct snd_soc_dai_link *dai;
+
+               dai = &snd_allo_boss_dai[0];
+               i2s_node = of_parse_phandle(pdev->dev.of_node,
+                                           "i2s-controller", 0);
+
+               if (i2s_node) {
+                       dai->cpu_dai_name = NULL;
+                       dai->cpu_of_node = i2s_node;
+                       dai->platform_name = NULL;
+                       dai->platform_of_node = i2s_node;
+               }
+
+               digital_gain_0db_limit = !of_property_read_bool(
+                       pdev->dev.of_node, "allo,24db_digital_gain");
+               slave = of_property_read_bool(pdev->dev.of_node,
+                                       "allo,slave");
+       }
+
+       ret = snd_soc_register_card(&snd_allo_boss);
+       if (ret)
+               dev_err(&pdev->dev,
+                       "snd_soc_register_card() failed: %d\n", ret);
+
+       return ret;
+}
+
+static int snd_allo_boss_remove(struct platform_device *pdev)
+{
+       return snd_soc_unregister_card(&snd_allo_boss);
+}
+
+static const struct of_device_id snd_allo_boss_of_match[] = {
+       { .compatible = "allo,boss-dac", },
+       { /* sentinel */ },
+};
+MODULE_DEVICE_TABLE(of, snd_allo_boss_of_match);
+
+static struct platform_driver snd_allo_boss_driver = {
+       .driver = {
+               .name   = "snd-allo-boss-dac",
+               .owner  = THIS_MODULE,
+               .of_match_table = snd_allo_boss_of_match,
+       },
+       .probe          = snd_allo_boss_probe,
+       .remove         = snd_allo_boss_remove,
+};
+
+module_platform_driver(snd_allo_boss_driver);
+
+MODULE_AUTHOR("Baswaraj K <jaikumar@cem-solutions.net>");
+MODULE_DESCRIPTION("ALSA ASoC Machine Driver for Allo Boss DAC");
+MODULE_LICENSE("GPL v2");