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