1 // SPDX-License-Identifier: GPL-2.0-only
2 /* sound/soc/rockchip/rockchip_i2s.c
4 * ALSA SoC Audio Layer - Rockchip I2S Controller driver
6 * Copyright (c) 2014 Rockchip Electronics Co. Ltd.
7 * Author: Jianqun <jay.xu@rock-chips.com>
10 #include <linux/module.h>
11 #include <linux/mfd/syscon.h>
12 #include <linux/delay.h>
13 #include <linux/of_gpio.h>
14 #include <linux/of_device.h>
15 #include <linux/clk.h>
16 #include <linux/pinctrl/consumer.h>
17 #include <linux/pm_runtime.h>
18 #include <linux/regmap.h>
19 #include <linux/spinlock.h>
20 #include <sound/pcm_params.h>
21 #include <sound/dmaengine_pcm.h>
23 #include "rockchip_i2s.h"
25 #define DRV_NAME "rockchip-i2s"
38 struct snd_dmaengine_dai_dma_data capture_dma_data;
39 struct snd_dmaengine_dai_dma_data playback_dma_data;
41 struct regmap *regmap;
48 * Used to indicate the tx/rx status.
49 * I2S controller hopes to start the tx and rx together,
50 * also to stop them when they are both try to stop.
55 const struct rk_i2s_pins *pins;
56 unsigned int bclk_ratio;
57 spinlock_t lock; /* tx/rx lock */
58 struct pinctrl *pinctrl;
59 struct pinctrl_state *bclk_on;
60 struct pinctrl_state *bclk_off;
63 static int i2s_pinctrl_select_bclk_on(struct rk_i2s_dev *i2s)
67 if (!IS_ERR(i2s->pinctrl) && !IS_ERR_OR_NULL(i2s->bclk_on))
68 ret = pinctrl_select_state(i2s->pinctrl,
72 dev_err(i2s->dev, "bclk enable failed %d\n", ret);
77 static int i2s_pinctrl_select_bclk_off(struct rk_i2s_dev *i2s)
82 if (!IS_ERR(i2s->pinctrl) && !IS_ERR_OR_NULL(i2s->bclk_off))
83 ret = pinctrl_select_state(i2s->pinctrl,
87 dev_err(i2s->dev, "bclk disable failed %d\n", ret);
92 static int i2s_runtime_suspend(struct device *dev)
94 struct rk_i2s_dev *i2s = dev_get_drvdata(dev);
96 regcache_cache_only(i2s->regmap, true);
97 clk_disable_unprepare(i2s->mclk);
102 static int i2s_runtime_resume(struct device *dev)
104 struct rk_i2s_dev *i2s = dev_get_drvdata(dev);
107 ret = clk_prepare_enable(i2s->mclk);
109 dev_err(i2s->dev, "clock enable failed %d\n", ret);
113 regcache_cache_only(i2s->regmap, false);
114 regcache_mark_dirty(i2s->regmap);
116 ret = regcache_sync(i2s->regmap);
118 clk_disable_unprepare(i2s->mclk);
123 static inline struct rk_i2s_dev *to_info(struct snd_soc_dai *dai)
125 return snd_soc_dai_get_drvdata(dai);
128 static int rockchip_snd_txctrl(struct rk_i2s_dev *i2s, int on)
130 unsigned int val = 0;
134 spin_lock(&i2s->lock);
136 ret = regmap_update_bits(i2s->regmap, I2S_DMACR,
137 I2S_DMACR_TDE_ENABLE, I2S_DMACR_TDE_ENABLE);
141 ret = regmap_update_bits(i2s->regmap, I2S_XFER,
142 I2S_XFER_TXS_START | I2S_XFER_RXS_START,
143 I2S_XFER_TXS_START | I2S_XFER_RXS_START);
147 i2s->tx_start = true;
149 i2s->tx_start = false;
151 ret = regmap_update_bits(i2s->regmap, I2S_DMACR,
152 I2S_DMACR_TDE_ENABLE, I2S_DMACR_TDE_DISABLE);
156 if (!i2s->rx_start) {
157 ret = regmap_update_bits(i2s->regmap, I2S_XFER,
166 ret = regmap_update_bits(i2s->regmap, I2S_CLR,
167 I2S_CLR_TXC | I2S_CLR_RXC,
168 I2S_CLR_TXC | I2S_CLR_RXC);
172 regmap_read(i2s->regmap, I2S_CLR, &val);
174 /* Should wait for clear operation to finish */
176 regmap_read(i2s->regmap, I2S_CLR, &val);
179 dev_warn(i2s->dev, "fail to clear\n");
186 spin_unlock(&i2s->lock);
188 dev_err(i2s->dev, "lrclk update failed\n");
193 static int rockchip_snd_rxctrl(struct rk_i2s_dev *i2s, int on)
195 unsigned int val = 0;
199 spin_lock(&i2s->lock);
201 ret = regmap_update_bits(i2s->regmap, I2S_DMACR,
202 I2S_DMACR_RDE_ENABLE, I2S_DMACR_RDE_ENABLE);
206 ret = regmap_update_bits(i2s->regmap, I2S_XFER,
207 I2S_XFER_TXS_START | I2S_XFER_RXS_START,
208 I2S_XFER_TXS_START | I2S_XFER_RXS_START);
212 i2s->rx_start = true;
214 i2s->rx_start = false;
216 ret = regmap_update_bits(i2s->regmap, I2S_DMACR,
217 I2S_DMACR_RDE_ENABLE, I2S_DMACR_RDE_DISABLE);
221 if (!i2s->tx_start) {
222 ret = regmap_update_bits(i2s->regmap, I2S_XFER,
230 ret = regmap_update_bits(i2s->regmap, I2S_CLR,
231 I2S_CLR_TXC | I2S_CLR_RXC,
232 I2S_CLR_TXC | I2S_CLR_RXC);
235 regmap_read(i2s->regmap, I2S_CLR, &val);
236 /* Should wait for clear operation to finish */
238 regmap_read(i2s->regmap, I2S_CLR, &val);
241 dev_warn(i2s->dev, "fail to clear\n");
248 spin_unlock(&i2s->lock);
250 dev_err(i2s->dev, "lrclk update failed\n");
255 static int rockchip_i2s_set_fmt(struct snd_soc_dai *cpu_dai,
258 struct rk_i2s_dev *i2s = to_info(cpu_dai);
259 unsigned int mask = 0, val = 0;
262 pm_runtime_get_sync(cpu_dai->dev);
263 mask = I2S_CKR_MSS_MASK;
264 switch (fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) {
265 case SND_SOC_DAIFMT_BP_FP:
266 /* Set source clock in Master mode */
267 val = I2S_CKR_MSS_MASTER;
268 i2s->is_master_mode = true;
270 case SND_SOC_DAIFMT_BC_FC:
271 val = I2S_CKR_MSS_SLAVE;
272 i2s->is_master_mode = false;
279 regmap_update_bits(i2s->regmap, I2S_CKR, mask, val);
281 mask = I2S_CKR_CKP_MASK | I2S_CKR_TLP_MASK | I2S_CKR_RLP_MASK;
282 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
283 case SND_SOC_DAIFMT_NB_NF:
284 val = I2S_CKR_CKP_NORMAL |
288 case SND_SOC_DAIFMT_NB_IF:
289 val = I2S_CKR_CKP_NORMAL |
290 I2S_CKR_TLP_INVERTED |
291 I2S_CKR_RLP_INVERTED;
293 case SND_SOC_DAIFMT_IB_NF:
294 val = I2S_CKR_CKP_INVERTED |
298 case SND_SOC_DAIFMT_IB_IF:
299 val = I2S_CKR_CKP_INVERTED |
300 I2S_CKR_TLP_INVERTED |
301 I2S_CKR_RLP_INVERTED;
308 regmap_update_bits(i2s->regmap, I2S_CKR, mask, val);
310 mask = I2S_TXCR_IBM_MASK | I2S_TXCR_TFS_MASK | I2S_TXCR_PBM_MASK;
311 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
312 case SND_SOC_DAIFMT_RIGHT_J:
313 val = I2S_TXCR_IBM_RSJM;
315 case SND_SOC_DAIFMT_LEFT_J:
316 val = I2S_TXCR_IBM_LSJM;
318 case SND_SOC_DAIFMT_I2S:
319 val = I2S_TXCR_IBM_NORMAL;
321 case SND_SOC_DAIFMT_DSP_A: /* PCM delay 1 bit mode */
322 val = I2S_TXCR_TFS_PCM | I2S_TXCR_PBM_MODE(1);
324 case SND_SOC_DAIFMT_DSP_B: /* PCM no delay mode */
325 val = I2S_TXCR_TFS_PCM;
332 regmap_update_bits(i2s->regmap, I2S_TXCR, mask, val);
334 mask = I2S_RXCR_IBM_MASK | I2S_RXCR_TFS_MASK | I2S_RXCR_PBM_MASK;
335 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
336 case SND_SOC_DAIFMT_RIGHT_J:
337 val = I2S_RXCR_IBM_RSJM;
339 case SND_SOC_DAIFMT_LEFT_J:
340 val = I2S_RXCR_IBM_LSJM;
342 case SND_SOC_DAIFMT_I2S:
343 val = I2S_RXCR_IBM_NORMAL;
345 case SND_SOC_DAIFMT_DSP_A: /* PCM delay 1 bit mode */
346 val = I2S_RXCR_TFS_PCM | I2S_RXCR_PBM_MODE(1);
348 case SND_SOC_DAIFMT_DSP_B: /* PCM no delay mode */
349 val = I2S_RXCR_TFS_PCM;
356 regmap_update_bits(i2s->regmap, I2S_RXCR, mask, val);
359 pm_runtime_put(cpu_dai->dev);
364 static int rockchip_i2s_hw_params(struct snd_pcm_substream *substream,
365 struct snd_pcm_hw_params *params,
366 struct snd_soc_dai *dai)
368 struct rk_i2s_dev *i2s = to_info(dai);
369 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
370 unsigned int val = 0;
371 unsigned int mclk_rate, bclk_rate, div_bclk, div_lrck;
373 if (i2s->is_master_mode) {
374 mclk_rate = clk_get_rate(i2s->mclk);
375 bclk_rate = i2s->bclk_ratio * params_rate(params);
379 div_bclk = DIV_ROUND_CLOSEST(mclk_rate, bclk_rate);
380 div_lrck = bclk_rate / params_rate(params);
381 regmap_update_bits(i2s->regmap, I2S_CKR,
383 I2S_CKR_MDIV(div_bclk));
385 regmap_update_bits(i2s->regmap, I2S_CKR,
388 I2S_CKR_TSD(div_lrck) |
389 I2S_CKR_RSD(div_lrck));
392 switch (params_format(params)) {
393 case SNDRV_PCM_FORMAT_S8:
394 val |= I2S_TXCR_VDW(8);
396 case SNDRV_PCM_FORMAT_S16_LE:
397 val |= I2S_TXCR_VDW(16);
399 case SNDRV_PCM_FORMAT_S20_3LE:
400 val |= I2S_TXCR_VDW(20);
402 case SNDRV_PCM_FORMAT_S24_LE:
403 val |= I2S_TXCR_VDW(24);
405 case SNDRV_PCM_FORMAT_S32_LE:
406 val |= I2S_TXCR_VDW(32);
412 switch (params_channels(params)) {
426 dev_err(i2s->dev, "invalid channel: %d\n",
427 params_channels(params));
431 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
432 regmap_update_bits(i2s->regmap, I2S_RXCR,
433 I2S_RXCR_VDW_MASK | I2S_RXCR_CSR_MASK,
436 regmap_update_bits(i2s->regmap, I2S_TXCR,
437 I2S_TXCR_VDW_MASK | I2S_TXCR_CSR_MASK,
440 if (!IS_ERR(i2s->grf) && i2s->pins) {
441 regmap_read(i2s->regmap, I2S_TXCR, &val);
442 val &= I2S_TXCR_CSR_MASK;
446 val = I2S_IO_4CH_OUT_6CH_IN;
449 val = I2S_IO_6CH_OUT_4CH_IN;
452 val = I2S_IO_8CH_OUT_2CH_IN;
455 val = I2S_IO_2CH_OUT_8CH_IN;
459 val <<= i2s->pins->shift;
460 val |= (I2S_IO_DIRECTION_MASK << i2s->pins->shift) << 16;
461 regmap_write(i2s->grf, i2s->pins->reg_offset, val);
464 regmap_update_bits(i2s->regmap, I2S_DMACR, I2S_DMACR_TDL_MASK,
466 regmap_update_bits(i2s->regmap, I2S_DMACR, I2S_DMACR_RDL_MASK,
469 val = I2S_CKR_TRCM_TXRX;
470 if (dai->driver->symmetric_rate && rtd->dai_link->symmetric_rate)
471 val = I2S_CKR_TRCM_TXONLY;
473 regmap_update_bits(i2s->regmap, I2S_CKR,
479 static int rockchip_i2s_trigger(struct snd_pcm_substream *substream,
480 int cmd, struct snd_soc_dai *dai)
482 struct rk_i2s_dev *i2s = to_info(dai);
486 case SNDRV_PCM_TRIGGER_START:
487 case SNDRV_PCM_TRIGGER_RESUME:
488 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
489 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
490 ret = rockchip_snd_rxctrl(i2s, 1);
492 ret = rockchip_snd_txctrl(i2s, 1);
493 /* Do not turn on bclk if lrclk open fails. */
496 i2s_pinctrl_select_bclk_on(i2s);
498 case SNDRV_PCM_TRIGGER_SUSPEND:
499 case SNDRV_PCM_TRIGGER_STOP:
500 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
501 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
503 i2s_pinctrl_select_bclk_off(i2s);
504 ret = rockchip_snd_rxctrl(i2s, 0);
507 i2s_pinctrl_select_bclk_off(i2s);
508 ret = rockchip_snd_txctrl(i2s, 0);
519 static int rockchip_i2s_set_bclk_ratio(struct snd_soc_dai *dai,
522 struct rk_i2s_dev *i2s = to_info(dai);
524 i2s->bclk_ratio = ratio;
529 static int rockchip_i2s_set_sysclk(struct snd_soc_dai *cpu_dai, int clk_id,
530 unsigned int freq, int dir)
532 struct rk_i2s_dev *i2s = to_info(cpu_dai);
538 ret = clk_set_rate(i2s->mclk, freq);
540 dev_err(i2s->dev, "Fail to set mclk %d\n", ret);
545 static int rockchip_i2s_dai_probe(struct snd_soc_dai *dai)
547 struct rk_i2s_dev *i2s = snd_soc_dai_get_drvdata(dai);
549 snd_soc_dai_init_dma_data(dai,
550 i2s->has_playback ? &i2s->playback_dma_data : NULL,
551 i2s->has_capture ? &i2s->capture_dma_data : NULL);
556 static const struct snd_soc_dai_ops rockchip_i2s_dai_ops = {
557 .hw_params = rockchip_i2s_hw_params,
558 .set_bclk_ratio = rockchip_i2s_set_bclk_ratio,
559 .set_sysclk = rockchip_i2s_set_sysclk,
560 .set_fmt = rockchip_i2s_set_fmt,
561 .trigger = rockchip_i2s_trigger,
564 static struct snd_soc_dai_driver rockchip_i2s_dai = {
565 .probe = rockchip_i2s_dai_probe,
566 .ops = &rockchip_i2s_dai_ops,
570 static const struct snd_soc_component_driver rockchip_i2s_component = {
574 static bool rockchip_i2s_wr_reg(struct device *dev, unsigned int reg)
591 static bool rockchip_i2s_rd_reg(struct device *dev, unsigned int reg)
611 static bool rockchip_i2s_volatile_reg(struct device *dev, unsigned int reg)
625 static bool rockchip_i2s_precious_reg(struct device *dev, unsigned int reg)
635 static const struct reg_default rockchip_i2s_reg_defaults[] = {
643 static const struct regmap_config rockchip_i2s_regmap_config = {
647 .max_register = I2S_RXDR,
648 .reg_defaults = rockchip_i2s_reg_defaults,
649 .num_reg_defaults = ARRAY_SIZE(rockchip_i2s_reg_defaults),
650 .writeable_reg = rockchip_i2s_wr_reg,
651 .readable_reg = rockchip_i2s_rd_reg,
652 .volatile_reg = rockchip_i2s_volatile_reg,
653 .precious_reg = rockchip_i2s_precious_reg,
654 .cache_type = REGCACHE_FLAT,
657 static const struct rk_i2s_pins rk3399_i2s_pins = {
658 .reg_offset = 0xe220,
662 static const struct of_device_id rockchip_i2s_match[] __maybe_unused = {
663 { .compatible = "rockchip,px30-i2s", },
664 { .compatible = "rockchip,rk1808-i2s", },
665 { .compatible = "rockchip,rk3036-i2s", },
666 { .compatible = "rockchip,rk3066-i2s", },
667 { .compatible = "rockchip,rk3128-i2s", },
668 { .compatible = "rockchip,rk3188-i2s", },
669 { .compatible = "rockchip,rk3228-i2s", },
670 { .compatible = "rockchip,rk3288-i2s", },
671 { .compatible = "rockchip,rk3308-i2s", },
672 { .compatible = "rockchip,rk3328-i2s", },
673 { .compatible = "rockchip,rk3366-i2s", },
674 { .compatible = "rockchip,rk3368-i2s", },
675 { .compatible = "rockchip,rk3399-i2s", .data = &rk3399_i2s_pins },
676 { .compatible = "rockchip,rv1126-i2s", },
680 static int rockchip_i2s_init_dai(struct rk_i2s_dev *i2s, struct resource *res,
681 struct snd_soc_dai_driver **dp)
683 struct device_node *node = i2s->dev->of_node;
684 struct snd_soc_dai_driver *dai;
685 struct property *dma_names;
686 const char *dma_name;
689 of_property_for_each_string(node, "dma-names", dma_names, dma_name) {
690 if (!strcmp(dma_name, "tx"))
691 i2s->has_playback = true;
692 if (!strcmp(dma_name, "rx"))
693 i2s->has_capture = true;
696 dai = devm_kmemdup(i2s->dev, &rockchip_i2s_dai,
697 sizeof(*dai), GFP_KERNEL);
701 if (i2s->has_playback) {
702 dai->playback.stream_name = "Playback";
703 dai->playback.channels_min = 2;
704 dai->playback.channels_max = 8;
705 dai->playback.rates = SNDRV_PCM_RATE_8000_192000;
706 dai->playback.formats = SNDRV_PCM_FMTBIT_S8 |
707 SNDRV_PCM_FMTBIT_S16_LE |
708 SNDRV_PCM_FMTBIT_S20_3LE |
709 SNDRV_PCM_FMTBIT_S24_LE |
710 SNDRV_PCM_FMTBIT_S32_LE;
712 i2s->playback_dma_data.addr = res->start + I2S_TXDR;
713 i2s->playback_dma_data.addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
714 i2s->playback_dma_data.maxburst = 8;
716 if (!of_property_read_u32(node, "rockchip,playback-channels", &val)) {
717 if (val >= 2 && val <= 8)
718 dai->playback.channels_max = val;
722 if (i2s->has_capture) {
723 dai->capture.stream_name = "Capture";
724 dai->capture.channels_min = 2;
725 dai->capture.channels_max = 8;
726 dai->capture.rates = SNDRV_PCM_RATE_8000_192000;
727 dai->capture.formats = SNDRV_PCM_FMTBIT_S8 |
728 SNDRV_PCM_FMTBIT_S16_LE |
729 SNDRV_PCM_FMTBIT_S20_3LE |
730 SNDRV_PCM_FMTBIT_S24_LE |
731 SNDRV_PCM_FMTBIT_S32_LE;
733 i2s->capture_dma_data.addr = res->start + I2S_RXDR;
734 i2s->capture_dma_data.addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
735 i2s->capture_dma_data.maxburst = 8;
737 if (!of_property_read_u32(node, "rockchip,capture-channels", &val)) {
738 if (val >= 2 && val <= 8)
739 dai->capture.channels_max = val;
749 static int rockchip_i2s_probe(struct platform_device *pdev)
751 struct device_node *node = pdev->dev.of_node;
752 const struct of_device_id *of_id;
753 struct rk_i2s_dev *i2s;
754 struct snd_soc_dai_driver *dai;
755 struct resource *res;
759 i2s = devm_kzalloc(&pdev->dev, sizeof(*i2s), GFP_KERNEL);
763 spin_lock_init(&i2s->lock);
764 i2s->dev = &pdev->dev;
766 i2s->grf = syscon_regmap_lookup_by_phandle(node, "rockchip,grf");
767 if (!IS_ERR(i2s->grf)) {
768 of_id = of_match_device(rockchip_i2s_match, &pdev->dev);
769 if (!of_id || !of_id->data)
772 i2s->pins = of_id->data;
775 /* try to prepare related clocks */
776 i2s->hclk = devm_clk_get(&pdev->dev, "i2s_hclk");
777 if (IS_ERR(i2s->hclk)) {
778 dev_err(&pdev->dev, "Can't retrieve i2s bus clock\n");
779 return PTR_ERR(i2s->hclk);
781 ret = clk_prepare_enable(i2s->hclk);
783 dev_err(i2s->dev, "hclock enable failed %d\n", ret);
787 i2s->mclk = devm_clk_get(&pdev->dev, "i2s_clk");
788 if (IS_ERR(i2s->mclk)) {
789 dev_err(&pdev->dev, "Can't retrieve i2s master clock\n");
790 ret = PTR_ERR(i2s->mclk);
794 regs = devm_platform_get_and_ioremap_resource(pdev, 0, &res);
800 i2s->regmap = devm_regmap_init_mmio(&pdev->dev, regs,
801 &rockchip_i2s_regmap_config);
802 if (IS_ERR(i2s->regmap)) {
804 "Failed to initialise managed register map\n");
805 ret = PTR_ERR(i2s->regmap);
809 i2s->bclk_ratio = 64;
810 i2s->pinctrl = devm_pinctrl_get(&pdev->dev);
811 if (IS_ERR(i2s->pinctrl))
812 dev_err(&pdev->dev, "failed to find i2s pinctrl\n");
814 i2s->bclk_on = pinctrl_lookup_state(i2s->pinctrl,
816 if (IS_ERR_OR_NULL(i2s->bclk_on))
817 dev_err(&pdev->dev, "failed to find i2s default state\n");
819 dev_dbg(&pdev->dev, "find i2s bclk state\n");
821 i2s->bclk_off = pinctrl_lookup_state(i2s->pinctrl,
823 if (IS_ERR_OR_NULL(i2s->bclk_off))
824 dev_err(&pdev->dev, "failed to find i2s gpio state\n");
826 dev_dbg(&pdev->dev, "find i2s bclk_off state\n");
828 i2s_pinctrl_select_bclk_off(i2s);
830 i2s->playback_dma_data.addr = res->start + I2S_TXDR;
831 i2s->playback_dma_data.addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
832 i2s->playback_dma_data.maxburst = 4;
834 i2s->capture_dma_data.addr = res->start + I2S_RXDR;
835 i2s->capture_dma_data.addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
836 i2s->capture_dma_data.maxburst = 4;
838 dev_set_drvdata(&pdev->dev, i2s);
840 pm_runtime_enable(&pdev->dev);
841 if (!pm_runtime_enabled(&pdev->dev)) {
842 ret = i2s_runtime_resume(&pdev->dev);
847 ret = rockchip_i2s_init_dai(i2s, res, &dai);
851 ret = devm_snd_soc_register_component(&pdev->dev,
852 &rockchip_i2s_component,
856 dev_err(&pdev->dev, "Could not register DAI\n");
860 ret = devm_snd_dmaengine_pcm_register(&pdev->dev, NULL, 0);
862 dev_err(&pdev->dev, "Could not register PCM\n");
869 if (!pm_runtime_status_suspended(&pdev->dev))
870 i2s_runtime_suspend(&pdev->dev);
872 pm_runtime_disable(&pdev->dev);
874 clk_disable_unprepare(i2s->hclk);
878 static int rockchip_i2s_remove(struct platform_device *pdev)
880 struct rk_i2s_dev *i2s = dev_get_drvdata(&pdev->dev);
882 pm_runtime_disable(&pdev->dev);
883 if (!pm_runtime_status_suspended(&pdev->dev))
884 i2s_runtime_suspend(&pdev->dev);
886 clk_disable_unprepare(i2s->hclk);
891 static const struct dev_pm_ops rockchip_i2s_pm_ops = {
892 SET_RUNTIME_PM_OPS(i2s_runtime_suspend, i2s_runtime_resume,
896 static struct platform_driver rockchip_i2s_driver = {
897 .probe = rockchip_i2s_probe,
898 .remove = rockchip_i2s_remove,
901 .of_match_table = of_match_ptr(rockchip_i2s_match),
902 .pm = &rockchip_i2s_pm_ops,
905 module_platform_driver(rockchip_i2s_driver);
907 MODULE_DESCRIPTION("ROCKCHIP IIS ASoC Interface");
908 MODULE_AUTHOR("jianqun <jay.xu@rock-chips.com>");
909 MODULE_LICENSE("GPL v2");
910 MODULE_ALIAS("platform:" DRV_NAME);
911 MODULE_DEVICE_TABLE(of, rockchip_i2s_match);