1 // SPDX-License-Identifier: GPL-2.0
3 // Freescale S/PDIF ALSA SoC Digital Audio Interface (DAI) driver
5 // Copyright (C) 2013 Freescale Semiconductor, Inc.
7 // Based on stmp3xxx_spdif_dai.c
8 // Vladimir Barinov <vbarinov@embeddedalley.com>
9 // Copyright 2008 SigmaTel, Inc
10 // Copyright 2008 Embedded Alley Solutions, Inc
12 #include <linux/bitrev.h>
13 #include <linux/clk.h>
14 #include <linux/module.h>
15 #include <linux/of_address.h>
16 #include <linux/of_device.h>
17 #include <linux/of_irq.h>
18 #include <linux/regmap.h>
19 #include <linux/pm_runtime.h>
21 #include <sound/asoundef.h>
22 #include <sound/dmaengine_pcm.h>
23 #include <sound/soc.h>
25 #include "fsl_spdif.h"
28 #define FSL_SPDIF_TXFIFO_WML 0x8
29 #define FSL_SPDIF_RXFIFO_WML 0x8
31 #define INTR_FOR_PLAYBACK (INT_TXFIFO_RESYNC)
32 #define INTR_FOR_CAPTURE (INT_SYM_ERR | INT_BIT_ERR | INT_URX_FUL |\
33 INT_URX_OV | INT_QRX_FUL | INT_QRX_OV |\
34 INT_UQ_SYNC | INT_UQ_ERR | INT_RXFIFO_RESYNC |\
35 INT_LOSS_LOCK | INT_DPLL_LOCKED)
37 #define SIE_INTR_FOR(tx) (tx ? INTR_FOR_PLAYBACK : INTR_FOR_CAPTURE)
39 /* Index list for the values that has if (DPLL Locked) condition */
40 static u8 srpc_dpll_locked[] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0xa, 0xb };
41 #define SRPC_NODPLL_START1 0x5
42 #define SRPC_NODPLL_START2 0xc
44 #define DEFAULT_RXCLK_SRC 1
47 * struct fsl_spdif_soc_data: soc specific data
49 * @imx: for imx platform
50 * @shared_root_clock: flag of sharing a clock source with others;
51 * so the driver shouldn't set root clock rate
52 * @raw_capture_mode: if raw capture mode support
53 * @interrupts: interrupt number
54 * @tx_burst: tx maxburst size
55 * @rx_burst: rx maxburst size
56 * @tx_formats: tx supported data format
58 struct fsl_spdif_soc_data {
60 bool shared_root_clock;
61 bool raw_capture_mode;
69 * SPDIF control structure
70 * Defines channel status, subcode and Q sub
72 struct spdif_mixer_control {
73 /* spinlock to access control data */
76 /* IEC958 channel tx status bit */
77 unsigned char ch_status[4];
80 unsigned char subcode[2 * SPDIF_UBITS_SIZE];
82 /* Q subcode part of user bits */
83 unsigned char qsub[2 * SPDIF_QSUB_SIZE];
85 /* Buffer offset for U/Q */
89 /* Ready buffer index of the two buffers */
94 * struct fsl_spdif_priv - Freescale SPDIF private data
95 * @soc: SPDIF soc data
96 * @fsl_spdif_control: SPDIF control data
97 * @cpu_dai_drv: cpu dai driver
98 * @pdev: platform device pointer
99 * @regmap: regmap handler
100 * @dpll_locked: dpll lock flag
101 * @txrate: the best rates for playback
102 * @txclk_df: STC_TXCLK_DF dividers value for playback
103 * @sysclk_df: STC_SYSCLK_DF dividers value for playback
104 * @txclk_src: STC_TXCLK_SRC values for playback
105 * @rxclk_src: SRPC_CLKSRC_SEL values for capture
106 * @txclk: tx clock sources for playback
107 * @rxclk: rx clock sources for capture
108 * @coreclk: core clock for register access via DMA
109 * @sysclk: system clock for rx clock rate measurement
110 * @spbaclk: SPBA clock (optional, depending on SoC design)
111 * @dma_params_tx: DMA parameters for transmit channel
112 * @dma_params_rx: DMA parameters for receive channel
113 * @regcache_srpc: regcache for SRPC
115 struct fsl_spdif_priv {
116 const struct fsl_spdif_soc_data *soc;
117 struct spdif_mixer_control fsl_spdif_control;
118 struct snd_soc_dai_driver cpu_dai_drv;
119 struct platform_device *pdev;
120 struct regmap *regmap;
122 u32 txrate[SPDIF_TXRATE_MAX];
123 u8 txclk_df[SPDIF_TXRATE_MAX];
124 u16 sysclk_df[SPDIF_TXRATE_MAX];
125 u8 txclk_src[SPDIF_TXRATE_MAX];
127 struct clk *txclk[SPDIF_TXRATE_MAX];
132 struct snd_dmaengine_dai_dma_data dma_params_tx;
133 struct snd_dmaengine_dai_dma_data dma_params_rx;
134 /* regcache for SRPC */
138 static struct fsl_spdif_soc_data fsl_spdif_vf610 = {
140 .shared_root_clock = false,
141 .raw_capture_mode = false,
143 .tx_burst = FSL_SPDIF_TXFIFO_WML,
144 .rx_burst = FSL_SPDIF_RXFIFO_WML,
145 .tx_formats = FSL_SPDIF_FORMATS_PLAYBACK,
148 static struct fsl_spdif_soc_data fsl_spdif_imx35 = {
150 .shared_root_clock = false,
151 .raw_capture_mode = false,
153 .tx_burst = FSL_SPDIF_TXFIFO_WML,
154 .rx_burst = FSL_SPDIF_RXFIFO_WML,
155 .tx_formats = FSL_SPDIF_FORMATS_PLAYBACK,
158 static struct fsl_spdif_soc_data fsl_spdif_imx6sx = {
160 .shared_root_clock = true,
161 .raw_capture_mode = false,
163 .tx_burst = FSL_SPDIF_TXFIFO_WML,
164 .rx_burst = FSL_SPDIF_RXFIFO_WML,
165 .tx_formats = FSL_SPDIF_FORMATS_PLAYBACK,
169 static struct fsl_spdif_soc_data fsl_spdif_imx8qm = {
171 .shared_root_clock = true,
172 .raw_capture_mode = false,
174 .tx_burst = 2, /* Applied for EDMA */
175 .rx_burst = 2, /* Applied for EDMA */
176 .tx_formats = SNDRV_PCM_FMTBIT_S24_LE, /* Applied for EDMA */
179 static struct fsl_spdif_soc_data fsl_spdif_imx8mm = {
181 .shared_root_clock = false,
182 .raw_capture_mode = true,
184 .tx_burst = FSL_SPDIF_TXFIFO_WML,
185 .rx_burst = FSL_SPDIF_RXFIFO_WML,
186 .tx_formats = FSL_SPDIF_FORMATS_PLAYBACK,
189 /* Check if clk is a root clock that does not share clock source with others */
190 static inline bool fsl_spdif_can_set_clk_rate(struct fsl_spdif_priv *spdif, int clk)
192 return (clk == STC_TXCLK_SPDIF_ROOT) && !spdif->soc->shared_root_clock;
195 /* DPLL locked and lock loss interrupt handler */
196 static void spdif_irq_dpll_lock(struct fsl_spdif_priv *spdif_priv)
198 struct regmap *regmap = spdif_priv->regmap;
199 struct platform_device *pdev = spdif_priv->pdev;
202 regmap_read(regmap, REG_SPDIF_SRPC, &locked);
203 locked &= SRPC_DPLL_LOCKED;
205 dev_dbg(&pdev->dev, "isr: Rx dpll %s \n",
206 locked ? "locked" : "loss lock");
208 spdif_priv->dpll_locked = locked ? true : false;
211 /* Receiver found illegal symbol interrupt handler */
212 static void spdif_irq_sym_error(struct fsl_spdif_priv *spdif_priv)
214 struct regmap *regmap = spdif_priv->regmap;
215 struct platform_device *pdev = spdif_priv->pdev;
217 dev_dbg(&pdev->dev, "isr: receiver found illegal symbol\n");
219 /* Clear illegal symbol if DPLL unlocked since no audio stream */
220 if (!spdif_priv->dpll_locked)
221 regmap_update_bits(regmap, REG_SPDIF_SIE, INT_SYM_ERR, 0);
224 /* U/Q Channel receive register full */
225 static void spdif_irq_uqrx_full(struct fsl_spdif_priv *spdif_priv, char name)
227 struct spdif_mixer_control *ctrl = &spdif_priv->fsl_spdif_control;
228 struct regmap *regmap = spdif_priv->regmap;
229 struct platform_device *pdev = spdif_priv->pdev;
230 u32 *pos, size, val, reg;
235 size = SPDIF_UBITS_SIZE;
240 size = SPDIF_QSUB_SIZE;
244 dev_err(&pdev->dev, "unsupported channel name\n");
248 dev_dbg(&pdev->dev, "isr: %c Channel receive register full\n", name);
250 if (*pos >= size * 2) {
252 } else if (unlikely((*pos % size) + 3 > size)) {
253 dev_err(&pdev->dev, "User bit receive buffer overflow\n");
257 regmap_read(regmap, reg, &val);
258 ctrl->subcode[*pos++] = val >> 16;
259 ctrl->subcode[*pos++] = val >> 8;
260 ctrl->subcode[*pos++] = val;
263 /* U/Q Channel sync found */
264 static void spdif_irq_uq_sync(struct fsl_spdif_priv *spdif_priv)
266 struct spdif_mixer_control *ctrl = &spdif_priv->fsl_spdif_control;
267 struct platform_device *pdev = spdif_priv->pdev;
269 dev_dbg(&pdev->dev, "isr: U/Q Channel sync found\n");
271 /* U/Q buffer reset */
275 /* Set ready to this buffer */
276 ctrl->ready_buf = (ctrl->qpos - 1) / SPDIF_QSUB_SIZE + 1;
279 /* U/Q Channel framing error */
280 static void spdif_irq_uq_err(struct fsl_spdif_priv *spdif_priv)
282 struct spdif_mixer_control *ctrl = &spdif_priv->fsl_spdif_control;
283 struct regmap *regmap = spdif_priv->regmap;
284 struct platform_device *pdev = spdif_priv->pdev;
287 dev_dbg(&pdev->dev, "isr: U/Q Channel framing error\n");
289 /* Read U/Q data to clear the irq and do buffer reset */
290 regmap_read(regmap, REG_SPDIF_SRU, &val);
291 regmap_read(regmap, REG_SPDIF_SRQ, &val);
293 /* Drop this U/Q buffer */
299 /* Get spdif interrupt status and clear the interrupt */
300 static u32 spdif_intr_status_clear(struct fsl_spdif_priv *spdif_priv)
302 struct regmap *regmap = spdif_priv->regmap;
305 regmap_read(regmap, REG_SPDIF_SIS, &val);
306 regmap_read(regmap, REG_SPDIF_SIE, &val2);
308 regmap_write(regmap, REG_SPDIF_SIC, val & val2);
313 static irqreturn_t spdif_isr(int irq, void *devid)
315 struct fsl_spdif_priv *spdif_priv = (struct fsl_spdif_priv *)devid;
316 struct platform_device *pdev = spdif_priv->pdev;
319 sis = spdif_intr_status_clear(spdif_priv);
321 if (sis & INT_DPLL_LOCKED)
322 spdif_irq_dpll_lock(spdif_priv);
324 if (sis & INT_TXFIFO_UNOV)
325 dev_dbg(&pdev->dev, "isr: Tx FIFO under/overrun\n");
327 if (sis & INT_TXFIFO_RESYNC)
328 dev_dbg(&pdev->dev, "isr: Tx FIFO resync\n");
331 dev_dbg(&pdev->dev, "isr: cstatus new\n");
333 if (sis & INT_VAL_NOGOOD)
334 dev_dbg(&pdev->dev, "isr: validity flag no good\n");
336 if (sis & INT_SYM_ERR)
337 spdif_irq_sym_error(spdif_priv);
339 if (sis & INT_BIT_ERR)
340 dev_dbg(&pdev->dev, "isr: receiver found parity bit error\n");
342 if (sis & INT_URX_FUL)
343 spdif_irq_uqrx_full(spdif_priv, 'U');
345 if (sis & INT_URX_OV)
346 dev_dbg(&pdev->dev, "isr: U Channel receive register overrun\n");
348 if (sis & INT_QRX_FUL)
349 spdif_irq_uqrx_full(spdif_priv, 'Q');
351 if (sis & INT_QRX_OV)
352 dev_dbg(&pdev->dev, "isr: Q Channel receive register overrun\n");
354 if (sis & INT_UQ_SYNC)
355 spdif_irq_uq_sync(spdif_priv);
357 if (sis & INT_UQ_ERR)
358 spdif_irq_uq_err(spdif_priv);
360 if (sis & INT_RXFIFO_UNOV)
361 dev_dbg(&pdev->dev, "isr: Rx FIFO under/overrun\n");
363 if (sis & INT_RXFIFO_RESYNC)
364 dev_dbg(&pdev->dev, "isr: Rx FIFO resync\n");
366 if (sis & INT_LOSS_LOCK)
367 spdif_irq_dpll_lock(spdif_priv);
369 /* FIXME: Write Tx FIFO to clear TxEm */
371 dev_dbg(&pdev->dev, "isr: Tx FIFO empty\n");
373 /* FIXME: Read Rx FIFO to clear RxFIFOFul */
374 if (sis & INT_RXFIFO_FUL)
375 dev_dbg(&pdev->dev, "isr: Rx FIFO full\n");
380 static int spdif_softreset(struct fsl_spdif_priv *spdif_priv)
382 struct regmap *regmap = spdif_priv->regmap;
383 u32 val, cycle = 1000;
385 regcache_cache_bypass(regmap, true);
387 regmap_write(regmap, REG_SPDIF_SCR, SCR_SOFT_RESET);
390 * RESET bit would be cleared after finishing its reset procedure,
391 * which typically lasts 8 cycles. 1000 cycles will keep it safe.
394 regmap_read(regmap, REG_SPDIF_SCR, &val);
395 } while ((val & SCR_SOFT_RESET) && cycle--);
397 regcache_cache_bypass(regmap, false);
398 regcache_mark_dirty(regmap);
399 regcache_sync(regmap);
407 static void spdif_set_cstatus(struct spdif_mixer_control *ctrl,
410 ctrl->ch_status[3] &= ~mask;
411 ctrl->ch_status[3] |= cstatus & mask;
414 static void spdif_write_channel_status(struct fsl_spdif_priv *spdif_priv)
416 struct spdif_mixer_control *ctrl = &spdif_priv->fsl_spdif_control;
417 struct regmap *regmap = spdif_priv->regmap;
418 struct platform_device *pdev = spdif_priv->pdev;
421 ch_status = (bitrev8(ctrl->ch_status[0]) << 16) |
422 (bitrev8(ctrl->ch_status[1]) << 8) |
423 bitrev8(ctrl->ch_status[2]);
424 regmap_write(regmap, REG_SPDIF_STCSCH, ch_status);
426 dev_dbg(&pdev->dev, "STCSCH: 0x%06x\n", ch_status);
428 ch_status = bitrev8(ctrl->ch_status[3]) << 16;
429 regmap_write(regmap, REG_SPDIF_STCSCL, ch_status);
431 dev_dbg(&pdev->dev, "STCSCL: 0x%06x\n", ch_status);
434 /* Set SPDIF PhaseConfig register for rx clock */
435 static int spdif_set_rx_clksrc(struct fsl_spdif_priv *spdif_priv,
436 enum spdif_gainsel gainsel, int dpll_locked)
438 struct regmap *regmap = spdif_priv->regmap;
439 u8 clksrc = spdif_priv->rxclk_src;
441 if (clksrc >= SRPC_CLKSRC_MAX || gainsel >= GAINSEL_MULTI_MAX)
444 regmap_update_bits(regmap, REG_SPDIF_SRPC,
445 SRPC_CLKSRC_SEL_MASK | SRPC_GAINSEL_MASK,
446 SRPC_CLKSRC_SEL_SET(clksrc) | SRPC_GAINSEL_SET(gainsel));
451 static int spdif_set_sample_rate(struct snd_pcm_substream *substream,
454 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
455 struct fsl_spdif_priv *spdif_priv = snd_soc_dai_get_drvdata(asoc_rtd_to_cpu(rtd, 0));
456 struct spdif_mixer_control *ctrl = &spdif_priv->fsl_spdif_control;
457 struct regmap *regmap = spdif_priv->regmap;
458 struct platform_device *pdev = spdif_priv->pdev;
459 unsigned long csfs = 0;
465 switch (sample_rate) {
467 rate = SPDIF_TXRATE_32000;
468 csfs = IEC958_AES3_CON_FS_32000;
471 rate = SPDIF_TXRATE_44100;
472 csfs = IEC958_AES3_CON_FS_44100;
475 rate = SPDIF_TXRATE_48000;
476 csfs = IEC958_AES3_CON_FS_48000;
479 rate = SPDIF_TXRATE_88200;
480 csfs = IEC958_AES3_CON_FS_88200;
483 rate = SPDIF_TXRATE_96000;
484 csfs = IEC958_AES3_CON_FS_96000;
487 rate = SPDIF_TXRATE_176400;
488 csfs = IEC958_AES3_CON_FS_176400;
491 rate = SPDIF_TXRATE_192000;
492 csfs = IEC958_AES3_CON_FS_192000;
495 dev_err(&pdev->dev, "unsupported sample rate %d\n", sample_rate);
499 clk = spdif_priv->txclk_src[rate];
500 if (clk >= STC_TXCLK_SRC_MAX) {
501 dev_err(&pdev->dev, "tx clock source is out of range\n");
505 txclk_df = spdif_priv->txclk_df[rate];
507 dev_err(&pdev->dev, "the txclk_df can't be zero\n");
511 sysclk_df = spdif_priv->sysclk_df[rate];
513 if (!fsl_spdif_can_set_clk_rate(spdif_priv, clk))
516 /* The S/PDIF block needs a clock of 64 * fs * txclk_df */
517 ret = clk_set_rate(spdif_priv->txclk[rate],
518 64 * sample_rate * txclk_df);
520 dev_err(&pdev->dev, "failed to set tx clock rate\n");
525 dev_dbg(&pdev->dev, "expected clock rate = %d\n",
526 (64 * sample_rate * txclk_df * sysclk_df));
527 dev_dbg(&pdev->dev, "actual clock rate = %ld\n",
528 clk_get_rate(spdif_priv->txclk[rate]));
530 /* set fs field in consumer channel status */
531 spdif_set_cstatus(ctrl, IEC958_AES3_CON_FS, csfs);
533 /* select clock source and divisor */
534 stc = STC_TXCLK_ALL_EN | STC_TXCLK_SRC_SET(clk) |
535 STC_TXCLK_DF(txclk_df) | STC_SYSCLK_DF(sysclk_df);
536 mask = STC_TXCLK_ALL_EN_MASK | STC_TXCLK_SRC_MASK |
537 STC_TXCLK_DF_MASK | STC_SYSCLK_DF_MASK;
538 regmap_update_bits(regmap, REG_SPDIF_STC, mask, stc);
540 dev_dbg(&pdev->dev, "set sample rate to %dHz for %dHz playback\n",
541 spdif_priv->txrate[rate], sample_rate);
546 static int fsl_spdif_startup(struct snd_pcm_substream *substream,
547 struct snd_soc_dai *cpu_dai)
549 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
550 struct fsl_spdif_priv *spdif_priv = snd_soc_dai_get_drvdata(asoc_rtd_to_cpu(rtd, 0));
551 struct platform_device *pdev = spdif_priv->pdev;
552 struct regmap *regmap = spdif_priv->regmap;
556 /* Reset module and interrupts only for first initialization */
557 if (!snd_soc_dai_active(cpu_dai)) {
558 ret = spdif_softreset(spdif_priv);
560 dev_err(&pdev->dev, "failed to soft reset\n");
564 /* Disable all the interrupts */
565 regmap_update_bits(regmap, REG_SPDIF_SIE, 0xffffff, 0);
568 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
569 scr = SCR_TXFIFO_AUTOSYNC | SCR_TXFIFO_CTRL_NORMAL |
570 SCR_TXSEL_NORMAL | SCR_USRC_SEL_CHIP |
572 mask = SCR_TXFIFO_AUTOSYNC_MASK | SCR_TXFIFO_CTRL_MASK |
573 SCR_TXSEL_MASK | SCR_USRC_SEL_MASK |
574 SCR_TXFIFO_FSEL_MASK;
576 scr = SCR_RXFIFO_FSEL_IF8 | SCR_RXFIFO_AUTOSYNC;
577 mask = SCR_RXFIFO_FSEL_MASK | SCR_RXFIFO_AUTOSYNC_MASK|
578 SCR_RXFIFO_CTL_MASK | SCR_RXFIFO_OFF_MASK;
580 regmap_update_bits(regmap, REG_SPDIF_SCR, mask, scr);
582 /* Power up SPDIF module */
583 regmap_update_bits(regmap, REG_SPDIF_SCR, SCR_LOW_POWER, 0);
588 static void fsl_spdif_shutdown(struct snd_pcm_substream *substream,
589 struct snd_soc_dai *cpu_dai)
591 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
592 struct fsl_spdif_priv *spdif_priv = snd_soc_dai_get_drvdata(asoc_rtd_to_cpu(rtd, 0));
593 struct regmap *regmap = spdif_priv->regmap;
596 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
598 mask = SCR_TXFIFO_AUTOSYNC_MASK | SCR_TXFIFO_CTRL_MASK |
599 SCR_TXSEL_MASK | SCR_USRC_SEL_MASK |
600 SCR_TXFIFO_FSEL_MASK;
601 /* Disable TX clock */
602 regmap_update_bits(regmap, REG_SPDIF_STC, STC_TXCLK_ALL_EN_MASK, 0);
604 scr = SCR_RXFIFO_OFF | SCR_RXFIFO_CTL_ZERO;
605 mask = SCR_RXFIFO_FSEL_MASK | SCR_RXFIFO_AUTOSYNC_MASK|
606 SCR_RXFIFO_CTL_MASK | SCR_RXFIFO_OFF_MASK;
608 regmap_update_bits(regmap, REG_SPDIF_SCR, mask, scr);
610 /* Power down SPDIF module only if tx&rx are both inactive */
611 if (!snd_soc_dai_active(cpu_dai)) {
612 spdif_intr_status_clear(spdif_priv);
613 regmap_update_bits(regmap, REG_SPDIF_SCR,
614 SCR_LOW_POWER, SCR_LOW_POWER);
618 static int fsl_spdif_hw_params(struct snd_pcm_substream *substream,
619 struct snd_pcm_hw_params *params,
620 struct snd_soc_dai *dai)
622 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
623 struct fsl_spdif_priv *spdif_priv = snd_soc_dai_get_drvdata(asoc_rtd_to_cpu(rtd, 0));
624 struct spdif_mixer_control *ctrl = &spdif_priv->fsl_spdif_control;
625 struct platform_device *pdev = spdif_priv->pdev;
626 u32 sample_rate = params_rate(params);
629 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
630 ret = spdif_set_sample_rate(substream, sample_rate);
632 dev_err(&pdev->dev, "%s: set sample rate failed: %d\n",
633 __func__, sample_rate);
636 spdif_set_cstatus(ctrl, IEC958_AES3_CON_CLOCK,
637 IEC958_AES3_CON_CLOCK_1000PPM);
638 spdif_write_channel_status(spdif_priv);
640 /* Setup rx clock source */
641 ret = spdif_set_rx_clksrc(spdif_priv, SPDIF_DEFAULT_GAINSEL, 1);
647 static int fsl_spdif_trigger(struct snd_pcm_substream *substream,
648 int cmd, struct snd_soc_dai *dai)
650 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
651 struct fsl_spdif_priv *spdif_priv = snd_soc_dai_get_drvdata(asoc_rtd_to_cpu(rtd, 0));
652 struct regmap *regmap = spdif_priv->regmap;
653 bool tx = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
654 u32 intr = SIE_INTR_FOR(tx);
655 u32 dmaen = SCR_DMA_xX_EN(tx);
658 case SNDRV_PCM_TRIGGER_START:
659 case SNDRV_PCM_TRIGGER_RESUME:
660 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
661 regmap_update_bits(regmap, REG_SPDIF_SIE, intr, intr);
662 regmap_update_bits(regmap, REG_SPDIF_SCR, dmaen, dmaen);
664 case SNDRV_PCM_TRIGGER_STOP:
665 case SNDRV_PCM_TRIGGER_SUSPEND:
666 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
667 regmap_update_bits(regmap, REG_SPDIF_SCR, dmaen, 0);
668 regmap_update_bits(regmap, REG_SPDIF_SIE, intr, 0);
677 static const struct snd_soc_dai_ops fsl_spdif_dai_ops = {
678 .startup = fsl_spdif_startup,
679 .hw_params = fsl_spdif_hw_params,
680 .trigger = fsl_spdif_trigger,
681 .shutdown = fsl_spdif_shutdown,
686 * FSL SPDIF IEC958 controller(mixer) functions
688 * Channel status get/put control
689 * User bit value get/put control
690 * Valid bit value get control
691 * DPLL lock status get control
692 * User bit sync mode selection control
695 static int fsl_spdif_info(struct snd_kcontrol *kcontrol,
696 struct snd_ctl_elem_info *uinfo)
698 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
704 static int fsl_spdif_pb_get(struct snd_kcontrol *kcontrol,
705 struct snd_ctl_elem_value *uvalue)
707 struct snd_soc_dai *cpu_dai = snd_kcontrol_chip(kcontrol);
708 struct fsl_spdif_priv *spdif_priv = snd_soc_dai_get_drvdata(cpu_dai);
709 struct spdif_mixer_control *ctrl = &spdif_priv->fsl_spdif_control;
711 uvalue->value.iec958.status[0] = ctrl->ch_status[0];
712 uvalue->value.iec958.status[1] = ctrl->ch_status[1];
713 uvalue->value.iec958.status[2] = ctrl->ch_status[2];
714 uvalue->value.iec958.status[3] = ctrl->ch_status[3];
719 static int fsl_spdif_pb_put(struct snd_kcontrol *kcontrol,
720 struct snd_ctl_elem_value *uvalue)
722 struct snd_soc_dai *cpu_dai = snd_kcontrol_chip(kcontrol);
723 struct fsl_spdif_priv *spdif_priv = snd_soc_dai_get_drvdata(cpu_dai);
724 struct spdif_mixer_control *ctrl = &spdif_priv->fsl_spdif_control;
726 ctrl->ch_status[0] = uvalue->value.iec958.status[0];
727 ctrl->ch_status[1] = uvalue->value.iec958.status[1];
728 ctrl->ch_status[2] = uvalue->value.iec958.status[2];
729 ctrl->ch_status[3] = uvalue->value.iec958.status[3];
731 spdif_write_channel_status(spdif_priv);
736 /* Get channel status from SPDIF_RX_CCHAN register */
737 static int fsl_spdif_capture_get(struct snd_kcontrol *kcontrol,
738 struct snd_ctl_elem_value *ucontrol)
740 struct snd_soc_dai *cpu_dai = snd_kcontrol_chip(kcontrol);
741 struct fsl_spdif_priv *spdif_priv = snd_soc_dai_get_drvdata(cpu_dai);
742 struct regmap *regmap = spdif_priv->regmap;
745 regmap_read(regmap, REG_SPDIF_SIS, &val);
746 if (!(val & INT_CNEW))
749 regmap_read(regmap, REG_SPDIF_SRCSH, &cstatus);
750 ucontrol->value.iec958.status[0] = (cstatus >> 16) & 0xFF;
751 ucontrol->value.iec958.status[1] = (cstatus >> 8) & 0xFF;
752 ucontrol->value.iec958.status[2] = cstatus & 0xFF;
754 regmap_read(regmap, REG_SPDIF_SRCSL, &cstatus);
755 ucontrol->value.iec958.status[3] = (cstatus >> 16) & 0xFF;
756 ucontrol->value.iec958.status[4] = (cstatus >> 8) & 0xFF;
757 ucontrol->value.iec958.status[5] = cstatus & 0xFF;
760 regmap_write(regmap, REG_SPDIF_SIC, INT_CNEW);
766 * Get User bits (subcode) from chip value which readed out
767 * in UChannel register.
769 static int fsl_spdif_subcode_get(struct snd_kcontrol *kcontrol,
770 struct snd_ctl_elem_value *ucontrol)
772 struct snd_soc_dai *cpu_dai = snd_kcontrol_chip(kcontrol);
773 struct fsl_spdif_priv *spdif_priv = snd_soc_dai_get_drvdata(cpu_dai);
774 struct spdif_mixer_control *ctrl = &spdif_priv->fsl_spdif_control;
778 spin_lock_irqsave(&ctrl->ctl_lock, flags);
779 if (ctrl->ready_buf) {
780 int idx = (ctrl->ready_buf - 1) * SPDIF_UBITS_SIZE;
781 memcpy(&ucontrol->value.iec958.subcode[0],
782 &ctrl->subcode[idx], SPDIF_UBITS_SIZE);
785 spin_unlock_irqrestore(&ctrl->ctl_lock, flags);
790 /* Q-subcode information. The byte size is SPDIF_UBITS_SIZE/8 */
791 static int fsl_spdif_qinfo(struct snd_kcontrol *kcontrol,
792 struct snd_ctl_elem_info *uinfo)
794 uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES;
795 uinfo->count = SPDIF_QSUB_SIZE;
800 /* Get Q subcode from chip value which readed out in QChannel register */
801 static int fsl_spdif_qget(struct snd_kcontrol *kcontrol,
802 struct snd_ctl_elem_value *ucontrol)
804 struct snd_soc_dai *cpu_dai = snd_kcontrol_chip(kcontrol);
805 struct fsl_spdif_priv *spdif_priv = snd_soc_dai_get_drvdata(cpu_dai);
806 struct spdif_mixer_control *ctrl = &spdif_priv->fsl_spdif_control;
810 spin_lock_irqsave(&ctrl->ctl_lock, flags);
811 if (ctrl->ready_buf) {
812 int idx = (ctrl->ready_buf - 1) * SPDIF_QSUB_SIZE;
813 memcpy(&ucontrol->value.bytes.data[0],
814 &ctrl->qsub[idx], SPDIF_QSUB_SIZE);
817 spin_unlock_irqrestore(&ctrl->ctl_lock, flags);
822 /* Get valid good bit from interrupt status register */
823 static int fsl_spdif_rx_vbit_get(struct snd_kcontrol *kcontrol,
824 struct snd_ctl_elem_value *ucontrol)
826 struct snd_soc_dai *cpu_dai = snd_kcontrol_chip(kcontrol);
827 struct fsl_spdif_priv *spdif_priv = snd_soc_dai_get_drvdata(cpu_dai);
828 struct regmap *regmap = spdif_priv->regmap;
831 regmap_read(regmap, REG_SPDIF_SIS, &val);
832 ucontrol->value.integer.value[0] = (val & INT_VAL_NOGOOD) != 0;
833 regmap_write(regmap, REG_SPDIF_SIC, INT_VAL_NOGOOD);
838 static int fsl_spdif_tx_vbit_get(struct snd_kcontrol *kcontrol,
839 struct snd_ctl_elem_value *ucontrol)
841 struct snd_soc_dai *cpu_dai = snd_kcontrol_chip(kcontrol);
842 struct fsl_spdif_priv *spdif_priv = snd_soc_dai_get_drvdata(cpu_dai);
843 struct regmap *regmap = spdif_priv->regmap;
846 regmap_read(regmap, REG_SPDIF_SCR, &val);
847 val = (val & SCR_VAL_MASK) >> SCR_VAL_OFFSET;
849 ucontrol->value.integer.value[0] = val;
854 static int fsl_spdif_tx_vbit_put(struct snd_kcontrol *kcontrol,
855 struct snd_ctl_elem_value *ucontrol)
857 struct snd_soc_dai *cpu_dai = snd_kcontrol_chip(kcontrol);
858 struct fsl_spdif_priv *spdif_priv = snd_soc_dai_get_drvdata(cpu_dai);
859 struct regmap *regmap = spdif_priv->regmap;
860 u32 val = (1 - ucontrol->value.integer.value[0]) << SCR_VAL_OFFSET;
862 regmap_update_bits(regmap, REG_SPDIF_SCR, SCR_VAL_MASK, val);
867 static int fsl_spdif_rx_rcm_get(struct snd_kcontrol *kcontrol,
868 struct snd_ctl_elem_value *ucontrol)
870 struct snd_soc_dai *cpu_dai = snd_kcontrol_chip(kcontrol);
871 struct fsl_spdif_priv *spdif_priv = snd_soc_dai_get_drvdata(cpu_dai);
872 struct regmap *regmap = spdif_priv->regmap;
875 regmap_read(regmap, REG_SPDIF_SCR, &val);
876 val = (val & SCR_RAW_CAPTURE_MODE) ? 1 : 0;
877 ucontrol->value.integer.value[0] = val;
882 static int fsl_spdif_rx_rcm_put(struct snd_kcontrol *kcontrol,
883 struct snd_ctl_elem_value *ucontrol)
885 struct snd_soc_dai *cpu_dai = snd_kcontrol_chip(kcontrol);
886 struct fsl_spdif_priv *spdif_priv = snd_soc_dai_get_drvdata(cpu_dai);
887 struct regmap *regmap = spdif_priv->regmap;
888 u32 val = (ucontrol->value.integer.value[0] ? SCR_RAW_CAPTURE_MODE : 0);
891 cpu_dai->driver->capture.formats |= SNDRV_PCM_FMTBIT_S32_LE;
893 cpu_dai->driver->capture.formats &= ~SNDRV_PCM_FMTBIT_S32_LE;
895 regmap_update_bits(regmap, REG_SPDIF_SCR, SCR_RAW_CAPTURE_MODE, val);
900 /* DPLL lock information */
901 static int fsl_spdif_rxrate_info(struct snd_kcontrol *kcontrol,
902 struct snd_ctl_elem_info *uinfo)
904 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
906 uinfo->value.integer.min = 16000;
907 uinfo->value.integer.max = 192000;
912 static u32 gainsel_multi[GAINSEL_MULTI_MAX] = {
913 24, 16, 12, 8, 6, 4, 3,
916 /* Get RX data clock rate given the SPDIF bus_clk */
917 static int spdif_get_rxclk_rate(struct fsl_spdif_priv *spdif_priv,
918 enum spdif_gainsel gainsel)
920 struct regmap *regmap = spdif_priv->regmap;
921 struct platform_device *pdev = spdif_priv->pdev;
922 u64 tmpval64, busclk_freq = 0;
923 u32 freqmeas, phaseconf;
926 regmap_read(regmap, REG_SPDIF_SRFM, &freqmeas);
927 regmap_read(regmap, REG_SPDIF_SRPC, &phaseconf);
929 clksrc = (phaseconf >> SRPC_CLKSRC_SEL_OFFSET) & 0xf;
931 /* Get bus clock from system */
932 if (srpc_dpll_locked[clksrc] && (phaseconf & SRPC_DPLL_LOCKED))
933 busclk_freq = clk_get_rate(spdif_priv->sysclk);
935 /* FreqMeas_CLK = (BUS_CLK * FreqMeas) / 2 ^ 10 / GAINSEL / 128 */
936 tmpval64 = (u64) busclk_freq * freqmeas;
937 do_div(tmpval64, gainsel_multi[gainsel] * 1024);
938 do_div(tmpval64, 128 * 1024);
940 dev_dbg(&pdev->dev, "FreqMeas: %d\n", freqmeas);
941 dev_dbg(&pdev->dev, "BusclkFreq: %lld\n", busclk_freq);
942 dev_dbg(&pdev->dev, "RxRate: %lld\n", tmpval64);
944 return (int)tmpval64;
948 * Get DPLL lock or not info from stable interrupt status register.
949 * User application must use this control to get locked,
950 * then can do next PCM operation
952 static int fsl_spdif_rxrate_get(struct snd_kcontrol *kcontrol,
953 struct snd_ctl_elem_value *ucontrol)
955 struct snd_soc_dai *cpu_dai = snd_kcontrol_chip(kcontrol);
956 struct fsl_spdif_priv *spdif_priv = snd_soc_dai_get_drvdata(cpu_dai);
959 if (spdif_priv->dpll_locked)
960 rate = spdif_get_rxclk_rate(spdif_priv, SPDIF_DEFAULT_GAINSEL);
962 ucontrol->value.integer.value[0] = rate;
968 * User bit sync mode:
969 * 1 CD User channel subcode
972 static int fsl_spdif_usync_get(struct snd_kcontrol *kcontrol,
973 struct snd_ctl_elem_value *ucontrol)
975 struct snd_soc_dai *cpu_dai = snd_kcontrol_chip(kcontrol);
976 struct fsl_spdif_priv *spdif_priv = snd_soc_dai_get_drvdata(cpu_dai);
977 struct regmap *regmap = spdif_priv->regmap;
980 regmap_read(regmap, REG_SPDIF_SRCD, &val);
981 ucontrol->value.integer.value[0] = (val & SRCD_CD_USER) != 0;
987 * User bit sync mode:
988 * 1 CD User channel subcode
991 static int fsl_spdif_usync_put(struct snd_kcontrol *kcontrol,
992 struct snd_ctl_elem_value *ucontrol)
994 struct snd_soc_dai *cpu_dai = snd_kcontrol_chip(kcontrol);
995 struct fsl_spdif_priv *spdif_priv = snd_soc_dai_get_drvdata(cpu_dai);
996 struct regmap *regmap = spdif_priv->regmap;
997 u32 val = ucontrol->value.integer.value[0] << SRCD_CD_USER_OFFSET;
999 regmap_update_bits(regmap, REG_SPDIF_SRCD, SRCD_CD_USER, val);
1004 /* FSL SPDIF IEC958 controller defines */
1005 static struct snd_kcontrol_new fsl_spdif_ctrls[] = {
1006 /* Status cchanel controller */
1008 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1009 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
1010 .access = SNDRV_CTL_ELEM_ACCESS_READ |
1011 SNDRV_CTL_ELEM_ACCESS_WRITE |
1012 SNDRV_CTL_ELEM_ACCESS_VOLATILE,
1013 .info = fsl_spdif_info,
1014 .get = fsl_spdif_pb_get,
1015 .put = fsl_spdif_pb_put,
1018 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1019 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
1020 .access = SNDRV_CTL_ELEM_ACCESS_READ |
1021 SNDRV_CTL_ELEM_ACCESS_VOLATILE,
1022 .info = fsl_spdif_info,
1023 .get = fsl_spdif_capture_get,
1025 /* User bits controller */
1027 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1028 .name = "IEC958 Subcode Capture Default",
1029 .access = SNDRV_CTL_ELEM_ACCESS_READ |
1030 SNDRV_CTL_ELEM_ACCESS_VOLATILE,
1031 .info = fsl_spdif_info,
1032 .get = fsl_spdif_subcode_get,
1035 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1036 .name = "IEC958 Q-subcode Capture Default",
1037 .access = SNDRV_CTL_ELEM_ACCESS_READ |
1038 SNDRV_CTL_ELEM_ACCESS_VOLATILE,
1039 .info = fsl_spdif_qinfo,
1040 .get = fsl_spdif_qget,
1042 /* Valid bit error controller */
1044 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1045 .name = "IEC958 RX V-Bit Errors",
1046 .access = SNDRV_CTL_ELEM_ACCESS_READ |
1047 SNDRV_CTL_ELEM_ACCESS_VOLATILE,
1048 .info = snd_ctl_boolean_mono_info,
1049 .get = fsl_spdif_rx_vbit_get,
1052 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1053 .name = "IEC958 TX V-Bit",
1054 .access = SNDRV_CTL_ELEM_ACCESS_READ |
1055 SNDRV_CTL_ELEM_ACCESS_WRITE |
1056 SNDRV_CTL_ELEM_ACCESS_VOLATILE,
1057 .info = snd_ctl_boolean_mono_info,
1058 .get = fsl_spdif_tx_vbit_get,
1059 .put = fsl_spdif_tx_vbit_put,
1061 /* DPLL lock info get controller */
1063 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1064 .name = "RX Sample Rate",
1065 .access = SNDRV_CTL_ELEM_ACCESS_READ |
1066 SNDRV_CTL_ELEM_ACCESS_VOLATILE,
1067 .info = fsl_spdif_rxrate_info,
1068 .get = fsl_spdif_rxrate_get,
1070 /* User bit sync mode set/get controller */
1072 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1073 .name = "IEC958 USyncMode CDText",
1074 .access = SNDRV_CTL_ELEM_ACCESS_READ |
1075 SNDRV_CTL_ELEM_ACCESS_WRITE |
1076 SNDRV_CTL_ELEM_ACCESS_VOLATILE,
1077 .info = snd_ctl_boolean_mono_info,
1078 .get = fsl_spdif_usync_get,
1079 .put = fsl_spdif_usync_put,
1083 static struct snd_kcontrol_new fsl_spdif_ctrls_rcm[] = {
1085 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1086 .name = "IEC958 Raw Capture Mode",
1087 .access = SNDRV_CTL_ELEM_ACCESS_READ |
1088 SNDRV_CTL_ELEM_ACCESS_WRITE |
1089 SNDRV_CTL_ELEM_ACCESS_VOLATILE,
1090 .info = snd_ctl_boolean_mono_info,
1091 .get = fsl_spdif_rx_rcm_get,
1092 .put = fsl_spdif_rx_rcm_put,
1096 static int fsl_spdif_dai_probe(struct snd_soc_dai *dai)
1098 struct fsl_spdif_priv *spdif_private = snd_soc_dai_get_drvdata(dai);
1100 snd_soc_dai_init_dma_data(dai, &spdif_private->dma_params_tx,
1101 &spdif_private->dma_params_rx);
1103 snd_soc_add_dai_controls(dai, fsl_spdif_ctrls, ARRAY_SIZE(fsl_spdif_ctrls));
1105 if (spdif_private->soc->raw_capture_mode)
1106 snd_soc_add_dai_controls(dai, fsl_spdif_ctrls_rcm,
1107 ARRAY_SIZE(fsl_spdif_ctrls_rcm));
1109 /*Clear the val bit for Tx*/
1110 regmap_update_bits(spdif_private->regmap, REG_SPDIF_SCR,
1111 SCR_VAL_MASK, SCR_VAL_CLEAR);
1116 static struct snd_soc_dai_driver fsl_spdif_dai = {
1117 .probe = &fsl_spdif_dai_probe,
1119 .stream_name = "CPU-Playback",
1122 .rates = FSL_SPDIF_RATES_PLAYBACK,
1123 .formats = FSL_SPDIF_FORMATS_PLAYBACK,
1126 .stream_name = "CPU-Capture",
1129 .rates = FSL_SPDIF_RATES_CAPTURE,
1130 .formats = FSL_SPDIF_FORMATS_CAPTURE,
1132 .ops = &fsl_spdif_dai_ops,
1135 static const struct snd_soc_component_driver fsl_spdif_component = {
1136 .name = "fsl-spdif",
1139 /* FSL SPDIF REGMAP */
1140 static const struct reg_default fsl_spdif_reg_defaults[] = {
1141 {REG_SPDIF_SCR, 0x00000400},
1142 {REG_SPDIF_SRCD, 0x00000000},
1143 {REG_SPDIF_SIE, 0x00000000},
1144 {REG_SPDIF_STL, 0x00000000},
1145 {REG_SPDIF_STR, 0x00000000},
1146 {REG_SPDIF_STCSCH, 0x00000000},
1147 {REG_SPDIF_STCSCL, 0x00000000},
1148 {REG_SPDIF_STC, 0x00020f00},
1151 static bool fsl_spdif_readable_reg(struct device *dev, unsigned int reg)
1155 case REG_SPDIF_SRCD:
1156 case REG_SPDIF_SRPC:
1161 case REG_SPDIF_SRCSH:
1162 case REG_SPDIF_SRCSL:
1165 case REG_SPDIF_STCSCH:
1166 case REG_SPDIF_STCSCL:
1167 case REG_SPDIF_SRFM:
1175 static bool fsl_spdif_volatile_reg(struct device *dev, unsigned int reg)
1178 case REG_SPDIF_SRPC:
1182 case REG_SPDIF_SRCSH:
1183 case REG_SPDIF_SRCSL:
1186 case REG_SPDIF_SRFM:
1193 static bool fsl_spdif_writeable_reg(struct device *dev, unsigned int reg)
1197 case REG_SPDIF_SRCD:
1198 case REG_SPDIF_SRPC:
1203 case REG_SPDIF_STCSCH:
1204 case REG_SPDIF_STCSCL:
1212 static const struct regmap_config fsl_spdif_regmap_config = {
1217 .max_register = REG_SPDIF_STC,
1218 .reg_defaults = fsl_spdif_reg_defaults,
1219 .num_reg_defaults = ARRAY_SIZE(fsl_spdif_reg_defaults),
1220 .readable_reg = fsl_spdif_readable_reg,
1221 .volatile_reg = fsl_spdif_volatile_reg,
1222 .writeable_reg = fsl_spdif_writeable_reg,
1223 .cache_type = REGCACHE_FLAT,
1226 static u32 fsl_spdif_txclk_caldiv(struct fsl_spdif_priv *spdif_priv,
1227 struct clk *clk, u64 savesub,
1228 enum spdif_txrate index, bool round)
1230 static const u32 rate[] = { 32000, 44100, 48000, 88200, 96000, 176400,
1232 bool is_sysclk = clk_is_match(clk, spdif_priv->sysclk);
1233 u64 rate_ideal, rate_actual, sub;
1235 u16 sysclk_dfmin, sysclk_dfmax, sysclk_df;
1238 /* The sysclk has an extra divisor [2, 512] */
1239 sysclk_dfmin = is_sysclk ? 2 : 1;
1240 sysclk_dfmax = is_sysclk ? 512 : 1;
1242 for (sysclk_df = sysclk_dfmin; sysclk_df <= sysclk_dfmax; sysclk_df++) {
1243 for (txclk_df = 1; txclk_df <= 128; txclk_df++) {
1244 rate_ideal = rate[index] * txclk_df * 64ULL;
1246 rate_actual = clk_round_rate(clk, rate_ideal);
1248 rate_actual = clk_get_rate(clk);
1250 arate = rate_actual / 64;
1251 arate /= txclk_df * sysclk_df;
1253 if (arate == rate[index]) {
1256 spdif_priv->txclk_df[index] = txclk_df;
1257 spdif_priv->sysclk_df[index] = sysclk_df;
1258 spdif_priv->txrate[index] = arate;
1260 } else if (arate / rate[index] == 1) {
1261 /* A little bigger than expect */
1262 sub = (u64)(arate - rate[index]) * 100000;
1263 do_div(sub, rate[index]);
1267 spdif_priv->txclk_df[index] = txclk_df;
1268 spdif_priv->sysclk_df[index] = sysclk_df;
1269 spdif_priv->txrate[index] = arate;
1270 } else if (rate[index] / arate == 1) {
1271 /* A little smaller than expect */
1272 sub = (u64)(rate[index] - arate) * 100000;
1273 do_div(sub, rate[index]);
1277 spdif_priv->txclk_df[index] = txclk_df;
1278 spdif_priv->sysclk_df[index] = sysclk_df;
1279 spdif_priv->txrate[index] = arate;
1288 static int fsl_spdif_probe_txclk(struct fsl_spdif_priv *spdif_priv,
1289 enum spdif_txrate index)
1291 static const u32 rate[] = { 32000, 44100, 48000, 88200, 96000, 176400,
1293 struct platform_device *pdev = spdif_priv->pdev;
1294 struct device *dev = &pdev->dev;
1295 u64 savesub = 100000, ret;
1300 for (i = 0; i < STC_TXCLK_SRC_MAX; i++) {
1301 sprintf(tmp, "rxtx%d", i);
1302 clk = devm_clk_get(dev, tmp);
1304 dev_err(dev, "no rxtx%d clock in devicetree\n", i);
1305 return PTR_ERR(clk);
1307 if (!clk_get_rate(clk))
1310 ret = fsl_spdif_txclk_caldiv(spdif_priv, clk, savesub, index,
1311 fsl_spdif_can_set_clk_rate(spdif_priv, i));
1316 spdif_priv->txclk[index] = clk;
1317 spdif_priv->txclk_src[index] = i;
1319 /* To quick catch a divisor, we allow a 0.1% deviation */
1324 dev_dbg(dev, "use rxtx%d as tx clock source for %dHz sample rate\n",
1325 spdif_priv->txclk_src[index], rate[index]);
1326 dev_dbg(dev, "use txclk df %d for %dHz sample rate\n",
1327 spdif_priv->txclk_df[index], rate[index]);
1328 if (clk_is_match(spdif_priv->txclk[index], spdif_priv->sysclk))
1329 dev_dbg(dev, "use sysclk df %d for %dHz sample rate\n",
1330 spdif_priv->sysclk_df[index], rate[index]);
1331 dev_dbg(dev, "the best rate for %dHz sample rate is %dHz\n",
1332 rate[index], spdif_priv->txrate[index]);
1337 static int fsl_spdif_probe(struct platform_device *pdev)
1339 struct fsl_spdif_priv *spdif_priv;
1340 struct spdif_mixer_control *ctrl;
1341 struct resource *res;
1345 spdif_priv = devm_kzalloc(&pdev->dev, sizeof(*spdif_priv), GFP_KERNEL);
1349 spdif_priv->pdev = pdev;
1351 spdif_priv->soc = of_device_get_match_data(&pdev->dev);
1353 /* Initialize this copy of the CPU DAI driver structure */
1354 memcpy(&spdif_priv->cpu_dai_drv, &fsl_spdif_dai, sizeof(fsl_spdif_dai));
1355 spdif_priv->cpu_dai_drv.name = dev_name(&pdev->dev);
1356 spdif_priv->cpu_dai_drv.playback.formats =
1357 spdif_priv->soc->tx_formats;
1359 /* Get the addresses and IRQ */
1360 regs = devm_platform_get_and_ioremap_resource(pdev, 0, &res);
1362 return PTR_ERR(regs);
1364 spdif_priv->regmap = devm_regmap_init_mmio(&pdev->dev, regs, &fsl_spdif_regmap_config);
1365 if (IS_ERR(spdif_priv->regmap)) {
1366 dev_err(&pdev->dev, "regmap init failed\n");
1367 return PTR_ERR(spdif_priv->regmap);
1370 for (i = 0; i < spdif_priv->soc->interrupts; i++) {
1371 irq = platform_get_irq(pdev, i);
1375 ret = devm_request_irq(&pdev->dev, irq, spdif_isr, 0,
1376 dev_name(&pdev->dev), spdif_priv);
1378 dev_err(&pdev->dev, "could not claim irq %u\n", irq);
1383 /* Get system clock for rx clock rate calculation */
1384 spdif_priv->sysclk = devm_clk_get(&pdev->dev, "rxtx5");
1385 if (IS_ERR(spdif_priv->sysclk)) {
1386 dev_err(&pdev->dev, "no sys clock (rxtx5) in devicetree\n");
1387 return PTR_ERR(spdif_priv->sysclk);
1390 /* Get core clock for data register access via DMA */
1391 spdif_priv->coreclk = devm_clk_get(&pdev->dev, "core");
1392 if (IS_ERR(spdif_priv->coreclk)) {
1393 dev_err(&pdev->dev, "no core clock in devicetree\n");
1394 return PTR_ERR(spdif_priv->coreclk);
1397 spdif_priv->spbaclk = devm_clk_get(&pdev->dev, "spba");
1398 if (IS_ERR(spdif_priv->spbaclk))
1399 dev_warn(&pdev->dev, "no spba clock in devicetree\n");
1401 /* Select clock source for rx/tx clock */
1402 spdif_priv->rxclk = devm_clk_get(&pdev->dev, "rxtx1");
1403 if (IS_ERR(spdif_priv->rxclk)) {
1404 dev_err(&pdev->dev, "no rxtx1 clock in devicetree\n");
1405 return PTR_ERR(spdif_priv->rxclk);
1407 spdif_priv->rxclk_src = DEFAULT_RXCLK_SRC;
1409 for (i = 0; i < SPDIF_TXRATE_MAX; i++) {
1410 ret = fsl_spdif_probe_txclk(spdif_priv, i);
1415 /* Initial spinlock for control data */
1416 ctrl = &spdif_priv->fsl_spdif_control;
1417 spin_lock_init(&ctrl->ctl_lock);
1419 /* Init tx channel status default value */
1420 ctrl->ch_status[0] = IEC958_AES0_CON_NOT_COPYRIGHT |
1421 IEC958_AES0_CON_EMPHASIS_5015;
1422 ctrl->ch_status[1] = IEC958_AES1_CON_DIGDIGCONV_ID;
1423 ctrl->ch_status[2] = 0x00;
1424 ctrl->ch_status[3] = IEC958_AES3_CON_FS_44100 |
1425 IEC958_AES3_CON_CLOCK_1000PPM;
1427 spdif_priv->dpll_locked = false;
1429 spdif_priv->dma_params_tx.maxburst = spdif_priv->soc->tx_burst;
1430 spdif_priv->dma_params_rx.maxburst = spdif_priv->soc->rx_burst;
1431 spdif_priv->dma_params_tx.addr = res->start + REG_SPDIF_STL;
1432 spdif_priv->dma_params_rx.addr = res->start + REG_SPDIF_SRL;
1434 /* Register with ASoC */
1435 dev_set_drvdata(&pdev->dev, spdif_priv);
1436 pm_runtime_enable(&pdev->dev);
1437 regcache_cache_only(spdif_priv->regmap, true);
1440 * Register platform component before registering cpu dai for there
1441 * is not defer probe for platform component in snd_soc_add_pcm_runtime().
1443 ret = imx_pcm_dma_init(pdev, IMX_SPDIF_DMABUF_SIZE);
1445 dev_err_probe(&pdev->dev, ret, "imx_pcm_dma_init failed\n");
1446 goto err_pm_disable;
1449 ret = devm_snd_soc_register_component(&pdev->dev, &fsl_spdif_component,
1450 &spdif_priv->cpu_dai_drv, 1);
1452 dev_err(&pdev->dev, "failed to register DAI: %d\n", ret);
1453 goto err_pm_disable;
1459 pm_runtime_disable(&pdev->dev);
1463 static int fsl_spdif_remove(struct platform_device *pdev)
1465 pm_runtime_disable(&pdev->dev);
1471 static int fsl_spdif_runtime_suspend(struct device *dev)
1473 struct fsl_spdif_priv *spdif_priv = dev_get_drvdata(dev);
1476 /* Disable all the interrupts */
1477 regmap_update_bits(spdif_priv->regmap, REG_SPDIF_SIE, 0xffffff, 0);
1479 regmap_read(spdif_priv->regmap, REG_SPDIF_SRPC,
1480 &spdif_priv->regcache_srpc);
1481 regcache_cache_only(spdif_priv->regmap, true);
1483 clk_disable_unprepare(spdif_priv->rxclk);
1485 for (i = 0; i < SPDIF_TXRATE_MAX; i++)
1486 clk_disable_unprepare(spdif_priv->txclk[i]);
1488 if (!IS_ERR(spdif_priv->spbaclk))
1489 clk_disable_unprepare(spdif_priv->spbaclk);
1490 clk_disable_unprepare(spdif_priv->coreclk);
1495 static int fsl_spdif_runtime_resume(struct device *dev)
1497 struct fsl_spdif_priv *spdif_priv = dev_get_drvdata(dev);
1501 ret = clk_prepare_enable(spdif_priv->coreclk);
1503 dev_err(dev, "failed to enable core clock\n");
1507 if (!IS_ERR(spdif_priv->spbaclk)) {
1508 ret = clk_prepare_enable(spdif_priv->spbaclk);
1510 dev_err(dev, "failed to enable spba clock\n");
1511 goto disable_core_clk;
1515 for (i = 0; i < SPDIF_TXRATE_MAX; i++) {
1516 ret = clk_prepare_enable(spdif_priv->txclk[i]);
1518 goto disable_tx_clk;
1521 ret = clk_prepare_enable(spdif_priv->rxclk);
1523 goto disable_tx_clk;
1525 regcache_cache_only(spdif_priv->regmap, false);
1526 regcache_mark_dirty(spdif_priv->regmap);
1528 regmap_update_bits(spdif_priv->regmap, REG_SPDIF_SRPC,
1529 SRPC_CLKSRC_SEL_MASK | SRPC_GAINSEL_MASK,
1530 spdif_priv->regcache_srpc);
1532 ret = regcache_sync(spdif_priv->regmap);
1534 goto disable_rx_clk;
1539 clk_disable_unprepare(spdif_priv->rxclk);
1541 for (i--; i >= 0; i--)
1542 clk_disable_unprepare(spdif_priv->txclk[i]);
1543 if (!IS_ERR(spdif_priv->spbaclk))
1544 clk_disable_unprepare(spdif_priv->spbaclk);
1546 clk_disable_unprepare(spdif_priv->coreclk);
1550 #endif /* CONFIG_PM */
1552 static const struct dev_pm_ops fsl_spdif_pm = {
1553 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
1554 pm_runtime_force_resume)
1555 SET_RUNTIME_PM_OPS(fsl_spdif_runtime_suspend, fsl_spdif_runtime_resume,
1559 static const struct of_device_id fsl_spdif_dt_ids[] = {
1560 { .compatible = "fsl,imx35-spdif", .data = &fsl_spdif_imx35, },
1561 { .compatible = "fsl,vf610-spdif", .data = &fsl_spdif_vf610, },
1562 { .compatible = "fsl,imx6sx-spdif", .data = &fsl_spdif_imx6sx, },
1563 { .compatible = "fsl,imx8qm-spdif", .data = &fsl_spdif_imx8qm, },
1564 { .compatible = "fsl,imx8mm-spdif", .data = &fsl_spdif_imx8mm, },
1567 MODULE_DEVICE_TABLE(of, fsl_spdif_dt_ids);
1569 static struct platform_driver fsl_spdif_driver = {
1571 .name = "fsl-spdif-dai",
1572 .of_match_table = fsl_spdif_dt_ids,
1573 .pm = &fsl_spdif_pm,
1575 .probe = fsl_spdif_probe,
1576 .remove = fsl_spdif_remove,
1579 module_platform_driver(fsl_spdif_driver);
1581 MODULE_AUTHOR("Freescale Semiconductor, Inc.");
1582 MODULE_DESCRIPTION("Freescale S/PDIF CPU DAI Driver");
1583 MODULE_LICENSE("GPL v2");
1584 MODULE_ALIAS("platform:fsl-spdif-dai");