sound/soc/samsung/smdk_spdif.c

   1 /*
   2  * smdk_spdif.c  --  S/PDIF audio for SMDK
   3  *
   4  * Copyright 2010 Samsung Electronics Co. Ltd.
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation; either version 2 of the
   9  * License, or (at your option) any later version.
  10  *
  11  */
  12
  13 #include <linux/module.h>
  14 #include <linux/device.h>
  15 #include <linux/clk.h>
  16
  17 #include <plat/devs.h>
  18
  19 #include <sound/soc.h>
  20
  21 #include "dma.h"
  22 #include "spdif.h"
  23
  24 /* Audio clock settings are belonged to board specific part. Every
  25  * board can set audio source clock setting which is matched with H/W
  26  * like this function-'set_audio_clock_heirachy'.
  27  */
  28 static int set_audio_clock_heirachy(struct platform_device *pdev)
  29 {
  30         struct clk *fout_epll, *mout_epll, *sclk_audio0, *sclk_spdif;
  31         int ret;
  32
  33         fout_epll = clk_get(NULL, "fout_epll");
  34         if (IS_ERR(fout_epll)) {
  35                 printk(KERN_WARNING "%s: Cannot find fout_epll.\n",
  36                                 __func__);
  37                 return -EINVAL;
  38         }
  39
  40         mout_epll = clk_get(NULL, "mout_epll");
  41         if (IS_ERR(mout_epll)) {
  42                 printk(KERN_WARNING "%s: Cannot find mout_epll.\n",
  43                                 __func__);
  44                 ret = -EINVAL;
  45                 goto out1;
  46         }
  47
  48         sclk_audio0 = clk_get(&pdev->dev, "sclk_audio");
  49         if (IS_ERR(sclk_audio0)) {
  50                 printk(KERN_WARNING "%s: Cannot find sclk_audio.\n",
  51                                 __func__);
  52                 ret = -EINVAL;
  53                 goto out2;
  54         }
  55
  56         sclk_spdif = clk_get(NULL, "sclk_spdif");
  57         if (IS_ERR(sclk_spdif)) {
  58                 printk(KERN_WARNING "%s: Cannot find sclk_spdif.\n",
  59                                 __func__);
  60                 ret = -EINVAL;
  61                 goto out3;
  62         }
  63
  64         /* Set audio clock heirachy for S/PDIF */
  65         clk_set_parent(mout_epll, fout_epll);
  66         clk_set_parent(sclk_audio0, mout_epll);
  67         clk_set_parent(sclk_spdif, sclk_audio0);
  68
  69         clk_put(sclk_spdif);
  70 out3:
  71         clk_put(sclk_audio0);
  72 out2:
  73         clk_put(mout_epll);
  74 out1:
  75         clk_put(fout_epll);
  76
  77         return ret;
  78 }
  79
  80 /* We should haved to set clock directly on this part because of clock
  81  * scheme of Samsudng SoCs did not support to set rates from abstrct
  82  * clock of it's heirachy.
  83  */
  84 static int set_audio_clock_rate(unsigned long epll_rate,
  85                                 unsigned long audio_rate)
  86 {
  87         struct clk *fout_epll, *sclk_spdif;
  88
  89         fout_epll = clk_get(NULL, "fout_epll");
  90         if (IS_ERR(fout_epll)) {
  91                 printk(KERN_ERR "%s: failed to get fout_epll\n", __func__);
  92                 return -ENOENT;
  93         }
  94
  95         clk_set_rate(fout_epll, epll_rate);
  96         clk_put(fout_epll);
  97
  98         sclk_spdif = clk_get(NULL, "sclk_spdif");
  99         if (IS_ERR(sclk_spdif)) {
 100                 printk(KERN_ERR "%s: failed to get sclk_spdif\n", __func__);
 101                 return -ENOENT;
 102         }
 103
 104         clk_set_rate(sclk_spdif, audio_rate);
 105         clk_put(sclk_spdif);
 106
 107         return 0;
 108 }
 109
 110 static int smdk_hw_params(struct snd_pcm_substream *substream,
 111                 struct snd_pcm_hw_params *params)
 112 {
 113         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 114         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 115         unsigned long pll_out, rclk_rate;
 116         int ret, ratio;
 117
 118         switch (params_rate(params)) {
 119         case 44100:
 120                 pll_out = 45158400;
 121                 break;
 122         case 32000:
 123         case 48000:
 124         case 96000:
 125                 pll_out = 49152000;
 126                 break;
 127         default:
 128                 return -EINVAL;
 129         }
 130
 131         /* Setting ratio to 512fs helps to use S/PDIF with HDMI without
 132          * modify S/PDIF ASoC machine driver.
 133          */
 134         ratio = 512;
 135         rclk_rate = params_rate(params) * ratio;
 136
 137         /* Set audio source clock rates */
 138         ret = set_audio_clock_rate(pll_out, rclk_rate);
 139         if (ret < 0)
 140                 return ret;
 141
 142         /* Set S/PDIF uses internal source clock */
 143         ret = snd_soc_dai_set_sysclk(cpu_dai, SND_SOC_SPDIF_INT_MCLK,
 144                                         rclk_rate, SND_SOC_CLOCK_IN);
 145         if (ret < 0)
 146                 return ret;
 147
 148         return ret;
 149 }
 150
 151 static struct snd_soc_ops smdk_spdif_ops = {
 152         .hw_params = smdk_hw_params,
 153 };
 154
 155 static struct snd_soc_card smdk;
 156
 157 static struct snd_soc_dai_link smdk_dai = {
 158         .name = "S/PDIF",
 159         .stream_name = "S/PDIF PCM Playback",
 160         .platform_name = "samsung-audio",
 161         .cpu_dai_name = "samsung-spdif",
 162         .codec_dai_name = "dit-hifi",
 163         .codec_name = "spdif-dit",
 164         .ops = &smdk_spdif_ops,
 165 };
 166
 167 static struct snd_soc_card smdk = {
 168         .name = "SMDK-S/PDIF",
 169         .dai_link = &smdk_dai,
 170         .num_links = 1,
 171 };
 172
 173 static struct platform_device *smdk_snd_spdif_dit_device;
 174 static struct platform_device *smdk_snd_spdif_device;
 175
 176 static int __init smdk_init(void)
 177 {
 178         int ret;
 179
 180         smdk_snd_spdif_dit_device = platform_device_alloc("spdif-dit", -1);
 181         if (!smdk_snd_spdif_dit_device)
 182                 return -ENOMEM;
 183
 184         ret = platform_device_add(smdk_snd_spdif_dit_device);
 185         if (ret)
 186                 goto err1;
 187
 188         smdk_snd_spdif_device = platform_device_alloc("soc-audio", -1);
 189         if (!smdk_snd_spdif_device) {
 190                 ret = -ENOMEM;
 191                 goto err2;
 192         }
 193
 194         platform_set_drvdata(smdk_snd_spdif_device, &smdk);
 195
 196         ret = platform_device_add(smdk_snd_spdif_device);
 197         if (ret)
 198                 goto err3;
 199
 200         /* Set audio clock heirachy manually */
 201         ret = set_audio_clock_heirachy(smdk_snd_spdif_device);
 202         if (ret)
 203                 goto err4;
 204
 205         return 0;
 206 err4:
 207         platform_device_del(smdk_snd_spdif_device);
 208 err3:
 209         platform_device_put(smdk_snd_spdif_device);
 210 err2:
 211         platform_device_del(smdk_snd_spdif_dit_device);
 212 err1:
 213         platform_device_put(smdk_snd_spdif_dit_device);
 214         return ret;
 215 }
 216
 217 static void __exit smdk_exit(void)
 218 {
 219         platform_device_unregister(smdk_snd_spdif_device);
 220         platform_device_unregister(smdk_snd_spdif_dit_device);
 221 }
 222
 223 module_init(smdk_init);
 224 module_exit(smdk_exit);
 225
 226 MODULE_AUTHOR("Seungwhan Youn, <sw.youn@samsung.com>");
 227 MODULE_DESCRIPTION("ALSA SoC SMDK+S/PDIF");
 228 MODULE_LICENSE("GPL");