1 From bb4781b1dac98688a3cf64cf728a64d811ca6add Mon Sep 17 00:00:00 2001
2 From: =?UTF-8?q?J=C3=B6rg=20Schambacher?=
3 <j-schambacher@users.noreply.github.com>
4 Date: Tue, 21 Jan 2020 15:58:39 +0100
5 Subject: [PATCH] sound: Add the HiFiBerry DAC+HD version
7 This adds the driver for the DAC+HD version supporting HiFiBerry's
8 PCM179x based DACs. It also adds PLL control for clock generation.
10 Signed-off-by: Joerg Schambacher <joerg@i2audio.com>
12 arch/arm/boot/dts/overlays/Makefile | 1 +
13 arch/arm/boot/dts/overlays/README | 6 +
14 .../overlays/hifiberry-dacplushd-overlay.dts | 106 ++++++
15 drivers/clk/Makefile | 1 +
16 drivers/clk/clk-hifiberry-dachd.c | 333 ++++++++++++++++++
17 sound/soc/bcm/Kconfig | 7 +
18 sound/soc/bcm/Makefile | 2 +
19 sound/soc/bcm/hifiberry_dacplushd.c | 235 ++++++++++++
20 13 files changed, 696 insertions(+)
21 create mode 100644 arch/arm/boot/dts/overlays/hifiberry-dacplushd-overlay.dts
22 create mode 100644 drivers/clk/clk-hifiberry-dachd.c
23 create mode 100644 sound/soc/bcm/hifiberry_dacplushd.c
25 --- a/arch/arm/boot/dts/overlays/Makefile
26 +++ b/arch/arm/boot/dts/overlays/Makefile
27 @@ -57,6 +57,7 @@ dtbo-$(CONFIG_ARCH_BCM2835) += \
28 hifiberry-dacplusadc.dtbo \
29 hifiberry-dacplusadcpro.dtbo \
30 hifiberry-dacplusdsp.dtbo \
31 + hifiberry-dacplushd.dtbo \
33 hifiberry-digi-pro.dtbo \
35 --- a/arch/arm/boot/dts/overlays/README
36 +++ b/arch/arm/boot/dts/overlays/README
37 @@ -956,6 +956,12 @@ Load: dtoverlay=hifiberry-dacplusdsp
41 +Name: hifiberry-dacplushd
42 +Info: Configures the HifiBerry DAC+ HD audio card
43 +Load: dtoverlay=hifiberry-dacplushd
48 Info: Configures the HifiBerry Digi and Digi+ audio card
49 Load: dtoverlay=hifiberry-digi
51 +++ b/arch/arm/boot/dts/overlays/hifiberry-dacplushd-overlay.dts
53 +// Definitions for HiFiBerry DAC+ HD
57 +#include <dt-bindings/gpio/gpio.h>
60 + compatible = "brcm,bcm2835";
63 + target-path = "/clocks";
65 + dachd_osc: pll_dachd_osc {
66 + compatible = "hifiberry,dachd-clk";
82 + #address-cells = <1>;
87 + compatible = "ti,pcm1792a";
88 + #sound-dai-cells = <0>;
90 + clocks = <&dachd_osc>;
95 + compatible = "hifiberry,dachd-clk";
98 + clocks = <&dachd_osc>;
100 + common_pll_regs = [
101 + 02 53 03 00 07 20 0F 00
102 + 10 0D 11 1D 12 0D 13 8C
103 + 14 8C 15 8C 16 8C 17 8C
104 + 18 2A 1C 00 1D 0F 1F 00
105 + 2A 00 2C 00 2F 00 30 00
106 + 31 00 32 00 34 00 37 00
107 + 38 00 39 00 3A 00 3B 01
108 + 3E 00 3F 00 40 00 41 00
109 + 5A 00 5B 00 95 00 96 00
110 + 97 00 98 00 99 00 9A 00
111 + 9B 00 A2 00 A3 00 A4 00
114 + 1A 0C 1B 35 1E F0 20 09
115 + 21 50 2B 02 2D 10 2E 40
116 + 33 01 35 22 36 80 3C 22
119 + 1A 0C 1B 35 1E F0 20 09
120 + 21 50 2B 02 2D 10 2E 40
121 + 33 01 35 47 36 00 3C 32
124 + 1A 0C 1B 35 1E F0 20 09
125 + 21 50 2B 02 2D 10 2E 40
126 + 33 01 35 90 36 00 3C 42
129 + 1A 3D 1B 09 1E F3 20 13
130 + 21 75 2B 04 2D 11 2E E0
131 + 33 02 35 25 36 C0 3C 22
134 + 1A 3D 1B 09 1E F3 20 13
135 + 21 75 2B 04 2D 11 2E E0
136 + 33 01 35 4D 36 80 3C 32
139 + 1A 3D 1B 09 1E F3 20 13
140 + 21 75 2B 04 2D 11 2E E0
141 + 33 01 35 9D 36 00 3C 42
150 + compatible = "hifiberry,hifiberry-dacplushd";
151 + i2s-controller = <&i2s>;
153 + reset-gpio = <&gpio 16 GPIO_ACTIVE_LOW>;
159 --- a/drivers/clk/Makefile
160 +++ b/drivers/clk/Makefile
161 @@ -32,6 +32,7 @@ obj-$(CONFIG_COMMON_CLK_ASPEED) += clk-
162 obj-$(CONFIG_ARCH_HIGHBANK) += clk-highbank.o
163 obj-$(CONFIG_CLK_HSDK) += clk-hsdk-pll.o
164 obj-$(CONFIG_SND_BCM2708_SOC_HIFIBERRY_DACPLUS) += clk-hifiberry-dacpro.o
165 +obj-$(CONFIG_SND_BCM2708_SOC_HIFIBERRY_DACPLUSHD) += clk-hifiberry-dachd.o
166 obj-$(CONFIG_COMMON_CLK_MAX77686) += clk-max77686.o
167 obj-$(CONFIG_COMMON_CLK_MAX9485) += clk-max9485.o
168 obj-$(CONFIG_ARCH_MOXART) += clk-moxart.o
170 +++ b/drivers/clk/clk-hifiberry-dachd.c
172 +// SPDX-License-Identifier: GPL-2.0
174 + * Clock Driver for HiFiBerry DAC+ HD
176 + * Author: Joerg Schambacher, i2Audio GmbH for HiFiBerry
179 + * This program is free software; you can redistribute it and/or
180 + * modify it under the terms of the GNU General Public License
181 + * version 2 as published by the Free Software Foundation.
183 + * This program is distributed in the hope that it will be useful, but
184 + * WITHOUT ANY WARRANTY; without even the implied warranty of
185 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
186 + * General Public License for more details.
189 +#include <linux/clk-provider.h>
190 +#include <linux/clk.h>
191 +#include <linux/kernel.h>
192 +#include <linux/module.h>
193 +#include <linux/of.h>
194 +#include <linux/slab.h>
195 +#include <linux/platform_device.h>
196 +#include <linux/i2c.h>
197 +#include <linux/regmap.h>
199 +#define NO_PLL_RESET 0
201 +#define HIFIBERRY_PLL_MAX_REGISTER 256
202 +#define DEFAULT_RATE 44100
204 +static struct reg_default hifiberry_pll_reg_defaults[] = {
205 + {0x02, 0x53}, {0x03, 0x00}, {0x07, 0x20}, {0x0F, 0x00},
206 + {0x10, 0x0D}, {0x11, 0x1D}, {0x12, 0x0D}, {0x13, 0x8C},
207 + {0x14, 0x8C}, {0x15, 0x8C}, {0x16, 0x8C}, {0x17, 0x8C},
208 + {0x18, 0x2A}, {0x1C, 0x00}, {0x1D, 0x0F}, {0x1F, 0x00},
209 + {0x2A, 0x00}, {0x2C, 0x00}, {0x2F, 0x00}, {0x30, 0x00},
210 + {0x31, 0x00}, {0x32, 0x00}, {0x34, 0x00}, {0x37, 0x00},
211 + {0x38, 0x00}, {0x39, 0x00}, {0x3A, 0x00}, {0x3B, 0x01},
212 + {0x3E, 0x00}, {0x3F, 0x00}, {0x40, 0x00}, {0x41, 0x00},
213 + {0x5A, 0x00}, {0x5B, 0x00}, {0x95, 0x00}, {0x96, 0x00},
214 + {0x97, 0x00}, {0x98, 0x00}, {0x99, 0x00}, {0x9A, 0x00},
215 + {0x9B, 0x00}, {0xA2, 0x00}, {0xA3, 0x00}, {0xA4, 0x00},
217 + {0x1A, 0x3D}, {0x1B, 0x09}, {0x1E, 0xF3}, {0x20, 0x13},
218 + {0x21, 0x75}, {0x2B, 0x04}, {0x2D, 0x11}, {0x2E, 0xE0},
220 + {0x35, 0x9D}, {0x36, 0x00}, {0x3C, 0x42},
223 +static struct reg_default common_pll_regs[HIFIBERRY_PLL_MAX_REGISTER];
224 +static int num_common_pll_regs;
225 +static struct reg_default dedicated_192k_pll_regs[HIFIBERRY_PLL_MAX_REGISTER];
226 +static int num_dedicated_192k_pll_regs;
227 +static struct reg_default dedicated_96k_pll_regs[HIFIBERRY_PLL_MAX_REGISTER];
228 +static int num_dedicated_96k_pll_regs;
229 +static struct reg_default dedicated_48k_pll_regs[HIFIBERRY_PLL_MAX_REGISTER];
230 +static int num_dedicated_48k_pll_regs;
231 +static struct reg_default dedicated_176k4_pll_regs[HIFIBERRY_PLL_MAX_REGISTER];
232 +static int num_dedicated_176k4_pll_regs;
233 +static struct reg_default dedicated_88k2_pll_regs[HIFIBERRY_PLL_MAX_REGISTER];
234 +static int num_dedicated_88k2_pll_regs;
235 +static struct reg_default dedicated_44k1_pll_regs[HIFIBERRY_PLL_MAX_REGISTER];
236 +static int num_dedicated_44k1_pll_regs;
239 + * struct clk_hifiberry_drvdata - Common struct to the HiFiBerry DAC HD Clk
240 + * @hw: clk_hw for the common clk framework
242 +struct clk_hifiberry_drvdata {
243 + struct regmap *regmap;
246 + unsigned long rate;
249 +#define to_hifiberry_clk(_hw) \
250 + container_of(_hw, struct clk_hifiberry_drvdata, hw)
252 +static int clk_hifiberry_dachd_write_pll_regs(struct regmap *regmap,
253 + struct reg_default *regs,
254 + int num, int do_pll_reset)
258 + char pll_soft_reset[] = { 177, 0xAC, };
260 + for (i = 0; i < num; i++) {
261 + ret |= regmap_write(regmap, regs[i].reg, regs[i].def);
265 + if (do_pll_reset) {
266 + ret |= regmap_write(regmap, pll_soft_reset[0],
267 + pll_soft_reset[1]);
273 +static unsigned long clk_hifiberry_dachd_recalc_rate(struct clk_hw *hw,
274 + unsigned long parent_rate)
276 + return to_hifiberry_clk(hw)->rate;
279 +static long clk_hifiberry_dachd_round_rate(struct clk_hw *hw,
280 + unsigned long rate, unsigned long *parent_rate)
285 +static int clk_hifiberry_dachd_set_rate(struct clk_hw *hw,
286 + unsigned long rate, unsigned long parent_rate)
289 + struct clk_hifiberry_drvdata *drvdata = to_hifiberry_clk(hw);
293 + ret = clk_hifiberry_dachd_write_pll_regs(drvdata->regmap,
294 + dedicated_44k1_pll_regs, num_dedicated_44k1_pll_regs,
298 + ret = clk_hifiberry_dachd_write_pll_regs(drvdata->regmap,
299 + dedicated_88k2_pll_regs, num_dedicated_88k2_pll_regs,
303 + ret = clk_hifiberry_dachd_write_pll_regs(drvdata->regmap,
304 + dedicated_176k4_pll_regs, num_dedicated_176k4_pll_regs,
308 + ret = clk_hifiberry_dachd_write_pll_regs(drvdata->regmap,
309 + dedicated_48k_pll_regs, num_dedicated_48k_pll_regs,
313 + ret = clk_hifiberry_dachd_write_pll_regs(drvdata->regmap,
314 + dedicated_96k_pll_regs, num_dedicated_96k_pll_regs,
318 + ret = clk_hifiberry_dachd_write_pll_regs(drvdata->regmap,
319 + dedicated_192k_pll_regs, num_dedicated_192k_pll_regs,
326 + to_hifiberry_clk(hw)->rate = rate;
331 +const struct clk_ops clk_hifiberry_dachd_rate_ops = {
332 + .recalc_rate = clk_hifiberry_dachd_recalc_rate,
333 + .round_rate = clk_hifiberry_dachd_round_rate,
334 + .set_rate = clk_hifiberry_dachd_set_rate,
337 +static int clk_hifiberry_get_prop_values(struct device *dev,
339 + struct reg_default *regs)
343 + u8 tmp[2 * HIFIBERRY_PLL_MAX_REGISTER];
345 + ret = of_property_read_variable_u8_array(dev->of_node, prop_name,
346 + tmp, 0, 2 * HIFIBERRY_PLL_MAX_REGISTER);
351 + "%s <%s> -> #%i odd number of bytes for reg/val pairs!",
358 + for (i = 0; i < ret; i++) {
359 + regs[i].reg = (u32)tmp[2 * i];
360 + regs[i].def = (u32)tmp[2 * i + 1];
366 +static int clk_hifiberry_dachd_dt_parse(struct device *dev)
368 + num_common_pll_regs = clk_hifiberry_get_prop_values(dev,
369 + "common_pll_regs", common_pll_regs);
370 + num_dedicated_44k1_pll_regs = clk_hifiberry_get_prop_values(dev,
371 + "44k1_pll_regs", dedicated_44k1_pll_regs);
372 + num_dedicated_88k2_pll_regs = clk_hifiberry_get_prop_values(dev,
373 + "88k2_pll_regs", dedicated_88k2_pll_regs);
374 + num_dedicated_176k4_pll_regs = clk_hifiberry_get_prop_values(dev,
375 + "176k4_pll_regs", dedicated_176k4_pll_regs);
376 + num_dedicated_48k_pll_regs = clk_hifiberry_get_prop_values(dev,
377 + "48k_pll_regs", dedicated_48k_pll_regs);
378 + num_dedicated_96k_pll_regs = clk_hifiberry_get_prop_values(dev,
379 + "96k_pll_regs", dedicated_96k_pll_regs);
380 + num_dedicated_192k_pll_regs = clk_hifiberry_get_prop_values(dev,
381 + "192k_pll_regs", dedicated_192k_pll_regs);
386 +static int clk_hifiberry_dachd_remove(struct device *dev)
388 + of_clk_del_provider(dev->of_node);
392 +const struct regmap_config hifiberry_pll_regmap = {
395 + .max_register = HIFIBERRY_PLL_MAX_REGISTER,
396 + .reg_defaults = hifiberry_pll_reg_defaults,
397 + .num_reg_defaults = ARRAY_SIZE(hifiberry_pll_reg_defaults),
398 + .cache_type = REGCACHE_RBTREE,
400 +EXPORT_SYMBOL_GPL(hifiberry_pll_regmap);
403 +static int clk_hifiberry_dachd_i2c_probe(struct i2c_client *i2c,
404 + const struct i2c_device_id *id)
406 + struct clk_hifiberry_drvdata *hdclk;
408 + struct clk_init_data init;
409 + struct device *dev = &i2c->dev;
410 + struct device_node *dev_node = dev->of_node;
411 + struct regmap_config config = hifiberry_pll_regmap;
413 + hdclk = devm_kzalloc(&i2c->dev,
414 + sizeof(struct clk_hifiberry_drvdata), GFP_KERNEL);
418 + i2c_set_clientdata(i2c, hdclk);
420 + hdclk->regmap = devm_regmap_init_i2c(i2c, &config);
422 + if (IS_ERR(hdclk->regmap))
423 + return PTR_ERR(hdclk->regmap);
425 + /* start PLL to allow detection of DAC */
426 + ret = clk_hifiberry_dachd_write_pll_regs(hdclk->regmap,
427 + hifiberry_pll_reg_defaults,
428 + ARRAY_SIZE(hifiberry_pll_reg_defaults),
433 + clk_hifiberry_dachd_dt_parse(dev);
435 + /* restart PLL with configs from DTB */
436 + ret = clk_hifiberry_dachd_write_pll_regs(hdclk->regmap, common_pll_regs,
437 + num_common_pll_regs, PLL_RESET);
441 + init.name = "clk-hifiberry-dachd";
442 + init.ops = &clk_hifiberry_dachd_rate_ops;
443 + init.flags = CLK_IS_BASIC;
444 + init.parent_names = NULL;
445 + init.num_parents = 0;
447 + hdclk->hw.init = &init;
449 + hdclk->clk = devm_clk_register(dev, &hdclk->hw);
450 + if (IS_ERR(hdclk->clk)) {
451 + dev_err(dev, "unable to register %s\n", init.name);
452 + return PTR_ERR(hdclk->clk);
455 + ret = of_clk_add_provider(dev_node, of_clk_src_simple_get, hdclk->clk);
457 + dev_err(dev, "Cannot of_clk_add_provider");
461 + ret = clk_set_rate(hdclk->hw.clk, DEFAULT_RATE);
463 + dev_err(dev, "Cannot set rate : %d\n", ret);
470 +static int clk_hifiberry_dachd_i2c_remove(struct i2c_client *i2c)
472 + clk_hifiberry_dachd_remove(&i2c->dev);
476 +static const struct i2c_device_id clk_hifiberry_dachd_i2c_id[] = {
480 +MODULE_DEVICE_TABLE(i2c, clk_hifiberry_dachd_i2c_id);
482 +static const struct of_device_id clk_hifiberry_dachd_of_match[] = {
483 + { .compatible = "hifiberry,dachd-clk", },
486 +MODULE_DEVICE_TABLE(of, clk_hifiberry_dachd_of_match);
488 +static struct i2c_driver clk_hifiberry_dachd_i2c_driver = {
489 + .probe = clk_hifiberry_dachd_i2c_probe,
490 + .remove = clk_hifiberry_dachd_i2c_remove,
491 + .id_table = clk_hifiberry_dachd_i2c_id,
493 + .name = "dachd-clk",
494 + .of_match_table = of_match_ptr(clk_hifiberry_dachd_of_match),
498 +module_i2c_driver(clk_hifiberry_dachd_i2c_driver);
501 +MODULE_DESCRIPTION("HiFiBerry DAC+ HD clock driver");
502 +MODULE_AUTHOR("Joerg Schambacher <joerg@i2audio.com>");
503 +MODULE_LICENSE("GPL v2");
504 +MODULE_ALIAS("platform:clk-hifiberry-dachd");
505 --- a/sound/soc/bcm/Kconfig
506 +++ b/sound/soc/bcm/Kconfig
507 @@ -40,6 +40,13 @@ config SND_BCM2708_SOC_HIFIBERRY_DACPLUS
509 Say Y or M if you want to add support for HifiBerry DAC+.
511 +config SND_BCM2708_SOC_HIFIBERRY_DACPLUSHD
512 + tristate "Support for HifiBerry DAC+ HD"
513 + depends on SND_BCM2708_SOC_I2S || SND_BCM2835_SOC_I2S
514 + select SND_SOC_PCM179X_I2C
516 + Say Y or M if you want to add support for HifiBerry DAC+ HD.
518 config SND_BCM2708_SOC_HIFIBERRY_DACPLUSADC
519 tristate "Support for HifiBerry DAC+ADC"
520 depends on SND_BCM2708_SOC_I2S || SND_BCM2835_SOC_I2S
521 --- a/sound/soc/bcm/Makefile
522 +++ b/sound/soc/bcm/Makefile
523 @@ -13,6 +13,7 @@ snd-soc-googlevoicehat-codec-objs := goo
525 # BCM2708 Machine Support
526 snd-soc-hifiberry-dacplus-objs := hifiberry_dacplus.o
527 +snd-soc-hifiberry-dacplushd-objs := hifiberry_dacplushd.o
528 snd-soc-hifiberry-dacplusadc-objs := hifiberry_dacplusadc.o
529 snd-soc-hifiberry-dacplusadcpro-objs := hifiberry_dacplusadcpro.o
530 snd-soc-hifiberry-dacplusdsp-objs := hifiberry_dacplusdsp.o
531 @@ -40,6 +41,7 @@ snd-soc-rpi-wm8804-soundcard-objs := rpi
533 obj-$(CONFIG_SND_BCM2708_SOC_GOOGLEVOICEHAT_SOUNDCARD) += snd-soc-googlevoicehat-codec.o
534 obj-$(CONFIG_SND_BCM2708_SOC_HIFIBERRY_DACPLUS) += snd-soc-hifiberry-dacplus.o
535 +obj-$(CONFIG_SND_BCM2708_SOC_HIFIBERRY_DACPLUSHD) += snd-soc-hifiberry-dacplushd.o
536 obj-$(CONFIG_SND_BCM2708_SOC_HIFIBERRY_DACPLUSADC) += snd-soc-hifiberry-dacplusadc.o
537 obj-$(CONFIG_SND_BCM2708_SOC_HIFIBERRY_DACPLUSADCPRO) += snd-soc-hifiberry-dacplusadcpro.o
538 obj-$(CONFIG_SND_BCM2708_SOC_HIFIBERRY_DACPLUSDSP) += snd-soc-hifiberry-dacplusdsp.o
540 +++ b/sound/soc/bcm/hifiberry_dacplushd.c
542 +// SPDX-License-Identifier: GPL-2.0
544 + * ASoC Driver for HiFiBerry DAC+ HD
546 + * Author: Joerg Schambacher, i2Audio GmbH for HiFiBerry
549 + * This program is free software; you can redistribute it and/or
550 + * modify it under the terms of the GNU General Public License
551 + * version 2 as published by the Free Software Foundation.
553 + * This program is distributed in the hope that it will be useful, but
554 + * WITHOUT ANY WARRANTY; without even the implied warranty of
555 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
556 + * General Public License for more details.
559 +#include <linux/module.h>
560 +#include <linux/platform_device.h>
561 +#include <linux/kernel.h>
562 +#include <linux/delay.h>
563 +#include <linux/module.h>
564 +#include <linux/of.h>
565 +#include <linux/delay.h>
566 +#include <linux/gpio.h>
567 +#include <linux/gpio/consumer.h>
568 +#include <sound/core.h>
569 +#include <sound/pcm.h>
570 +#include <sound/pcm_params.h>
571 +#include <sound/soc.h>
572 +#include <linux/i2c.h>
573 +#include <linux/clk.h>
575 +#include "../codecs/pcm179x.h"
577 +#define DEFAULT_RATE 44100
579 +struct brd_drv_data {
580 + struct regmap *regmap;
584 +static struct brd_drv_data drvdata;
585 +static struct gpio_desc *reset_gpio;
586 +static const unsigned int hb_dacplushd_rates[] = {
587 + 192000, 96000, 48000, 176400, 88200, 44100,
590 +static struct snd_pcm_hw_constraint_list hb_dacplushd_constraints = {
591 + .list = hb_dacplushd_rates,
592 + .count = ARRAY_SIZE(hb_dacplushd_rates),
595 +static int snd_rpi_hb_dacplushd_startup(struct snd_pcm_substream *substream)
597 + /* constraints for standard sample rates */
598 + snd_pcm_hw_constraint_list(substream->runtime, 0,
599 + SNDRV_PCM_HW_PARAM_RATE,
600 + &hb_dacplushd_constraints);
604 +static void snd_rpi_hifiberry_dacplushd_set_sclk(
605 + struct snd_soc_component *component,
608 + if (!IS_ERR(drvdata.sclk))
609 + clk_set_rate(drvdata.sclk, sample_rate);
612 +static int snd_rpi_hifiberry_dacplushd_init(struct snd_soc_pcm_runtime *rtd)
614 + struct snd_soc_dai_link *dai = rtd->dai_link;
615 + struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
617 + dai->name = "HiFiBerry DAC+ HD";
618 + dai->stream_name = "HiFiBerry DAC+ HD HiFi";
619 + dai->dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF
620 + | SND_SOC_DAIFMT_CBM_CFM;
622 + /* allow only fixed 32 clock counts per channel */
623 + snd_soc_dai_set_bclk_ratio(cpu_dai, 32*2);
628 +static int snd_rpi_hifiberry_dacplushd_hw_params(
629 + struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params)
632 + struct snd_soc_pcm_runtime *rtd = substream->private_data;
634 + struct snd_soc_component *component = rtd->codec_dai->component;
636 + snd_rpi_hifiberry_dacplushd_set_sclk(component, params_rate(params));
640 +/* machine stream operations */
641 +static struct snd_soc_ops snd_rpi_hifiberry_dacplushd_ops = {
642 + .startup = snd_rpi_hb_dacplushd_startup,
643 + .hw_params = snd_rpi_hifiberry_dacplushd_hw_params,
646 +static struct snd_soc_dai_link snd_rpi_hifiberry_dacplushd_dai[] = {
648 + .name = "HiFiBerry DAC+ HD",
649 + .stream_name = "HiFiBerry DAC+ HD HiFi",
650 + .cpu_dai_name = "bcm2708-i2s.0",
651 + .codec_dai_name = "pcm179x-hifi",
652 + .platform_name = "bcm2708-i2s.0",
653 + .codec_name = "pcm179x.1-004c",
654 + .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
655 + SND_SOC_DAIFMT_CBS_CFS,
656 + .ops = &snd_rpi_hifiberry_dacplushd_ops,
657 + .init = snd_rpi_hifiberry_dacplushd_init,
661 +/* audio machine driver */
662 +static struct snd_soc_card snd_rpi_hifiberry_dacplushd = {
663 + .name = "snd_rpi_hifiberry_dacplushd",
664 + .driver_name = "HifiberryDacplusHD",
665 + .owner = THIS_MODULE,
666 + .dai_link = snd_rpi_hifiberry_dacplushd_dai,
667 + .num_links = ARRAY_SIZE(snd_rpi_hifiberry_dacplushd_dai),
670 +static int snd_rpi_hifiberry_dacplushd_probe(struct platform_device *pdev)
673 + static int dac_reset_done;
674 + struct device *dev = &pdev->dev;
675 + struct device_node *dev_node = dev->of_node;
677 + snd_rpi_hifiberry_dacplushd.dev = &pdev->dev;
679 + /* get GPIO and release DAC from RESET */
680 + if (!dac_reset_done) {
681 + reset_gpio = gpiod_get(&pdev->dev, "reset", GPIOD_OUT_LOW);
682 + if (IS_ERR(reset_gpio)) {
683 + dev_err(&pdev->dev, "gpiod_get() failed\n");
686 + dac_reset_done = 1;
688 + if (!IS_ERR(reset_gpio))
689 + gpiod_set_value(reset_gpio, 0);
691 + if (!IS_ERR(reset_gpio))
692 + gpiod_set_value(reset_gpio, 1);
694 + if (!IS_ERR(reset_gpio))
695 + gpiod_set_value(reset_gpio, 0);
697 + if (pdev->dev.of_node) {
698 + struct device_node *i2s_node;
699 + struct snd_soc_dai_link *dai;
701 + dai = &snd_rpi_hifiberry_dacplushd_dai[0];
702 + i2s_node = of_parse_phandle(pdev->dev.of_node,
703 + "i2s-controller", 0);
706 + dai->cpu_dai_name = NULL;
707 + dai->cpu_of_node = i2s_node;
708 + dai->platform_name = NULL;
709 + dai->platform_of_node = i2s_node;
711 + return -EPROBE_DEFER;
716 + ret = devm_snd_soc_register_card(&pdev->dev,
717 + &snd_rpi_hifiberry_dacplushd);
718 + if (ret && ret != -EPROBE_DEFER) {
719 + dev_err(&pdev->dev,
720 + "snd_soc_register_card() failed: %d\n", ret);
723 + if (ret == -EPROBE_DEFER)
726 + dev_set_drvdata(dev, &drvdata);
727 + if (dev_node == NULL) {
728 + dev_err(&pdev->dev, "Device tree node not found\n");
732 + drvdata.sclk = devm_clk_get(dev, NULL);
733 + if (IS_ERR(drvdata.sclk)) {
734 + drvdata.sclk = ERR_PTR(-ENOENT);
738 + clk_set_rate(drvdata.sclk, DEFAULT_RATE);
743 +static int snd_rpi_hifiberry_dacplushd_remove(struct platform_device *pdev)
745 + if (IS_ERR(reset_gpio))
748 + /* put DAC into RESET and release GPIO */
749 + gpiod_set_value(reset_gpio, 0);
750 + gpiod_put(reset_gpio);
755 +static const struct of_device_id snd_rpi_hifiberry_dacplushd_of_match[] = {
756 + { .compatible = "hifiberry,hifiberry-dacplushd", },
760 +MODULE_DEVICE_TABLE(of, snd_rpi_hifiberry_dacplushd_of_match);
762 +static struct platform_driver snd_rpi_hifiberry_dacplushd_driver = {
764 + .name = "snd-rpi-hifiberry-dacplushd",
765 + .owner = THIS_MODULE,
766 + .of_match_table = snd_rpi_hifiberry_dacplushd_of_match,
768 + .probe = snd_rpi_hifiberry_dacplushd_probe,
769 + .remove = snd_rpi_hifiberry_dacplushd_remove,
772 +module_platform_driver(snd_rpi_hifiberry_dacplushd_driver);
774 +MODULE_AUTHOR("Joerg Schambacher <joerg@i2audio.com>");
775 +MODULE_DESCRIPTION("ASoC Driver for HiFiBerry DAC+ HD");
776 +MODULE_LICENSE("GPL v2");