Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/sound/soc/omap/omap-hdmi.c

  1 /*
  2  * omap-hdmi.c
  3  *
  4  * OMAP ALSA SoC DAI driver for HDMI audio on OMAP4 processors.
  5  * Copyright (C) 2010-2011 Texas Instruments Incorporated - http://www.ti.com/
  6  * Authors: Jorge Candelaria <jorge.candelaria@ti.com>
  7  *          Ricardo Neri <ricardo.neri@ti.com>
  8  *
  9  * This program is free software; you can redistribute it and/or
 10  * modify it under the terms of the GNU General Public License
 11  * version 2 as published by the Free Software Foundation.
 12  *
 13  * This program is distributed in the hope that it will be useful, but
 14  * WITHOUT ANY WARRANTY; without even the implied warranty of
 15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 16  * General Public License for more details.
 17  *
 18  * You should have received a copy of the GNU General Public License
 19  * along with this program; if not, write to the Free Software
 20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 21  * 02110-1301 USA
 22  *
 23  */
 24 
 25 #include <linux/init.h>
 26 #include <linux/module.h>
 27 #include <linux/device.h>
 28 #include <sound/core.h>
 29 #include <sound/pcm.h>
 30 #include <sound/pcm_params.h>
 31 #include <sound/initval.h>
 32 #include <sound/soc.h>
 33 #include <sound/asound.h>
 34 #include <sound/asoundef.h>
 35 #include <sound/dmaengine_pcm.h>
 36 #include <video/omapdss.h>
 37 
 38 #include "omap-hdmi.h"
 39 
 40 #define DRV_NAME "omap-hdmi-audio-dai"
 41 
 42 struct hdmi_priv {
 43         struct snd_dmaengine_dai_dma_data dma_data;
 44         unsigned int dma_req;
 45         struct omap_dss_audio dss_audio;
 46         struct snd_aes_iec958 iec;
 47         struct snd_cea_861_aud_if cea;
 48         struct omap_dss_device *dssdev;
 49 };
 50 
 51 static int omap_hdmi_dai_startup(struct snd_pcm_substream *substream,
 52                                   struct snd_soc_dai *dai)
 53 {
 54         struct hdmi_priv *priv = snd_soc_dai_get_drvdata(dai);
 55         int err;
 56         /*
 57          * Make sure that the period bytes are multiple of the DMA packet size.
 58          * Largest packet size we use is 32 32-bit words = 128 bytes
 59          */
 60         err = snd_pcm_hw_constraint_step(substream->runtime, 0,
 61                                  SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 128);
 62         if (err < 0) {
 63                 dev_err(dai->dev, "could not apply constraint\n");
 64                 return err;
 65         }
 66 
 67         if (!priv->dssdev->driver->audio_supported(priv->dssdev)) {
 68                 dev_err(dai->dev, "audio not supported\n");
 69                 return -ENODEV;
 70         }
 71 
 72         snd_soc_dai_set_dma_data(dai, substream, &priv->dma_data);
 73 
 74         return 0;
 75 }
 76 
 77 static int omap_hdmi_dai_prepare(struct snd_pcm_substream *substream,
 78                                 struct snd_soc_dai *dai)
 79 {
 80         struct hdmi_priv *priv = snd_soc_dai_get_drvdata(dai);
 81 
 82         return priv->dssdev->driver->audio_enable(priv->dssdev);
 83 }
 84 
 85 static int omap_hdmi_dai_hw_params(struct snd_pcm_substream *substream,
 86                                     struct snd_pcm_hw_params *params,
 87                                     struct snd_soc_dai *dai)
 88 {
 89         struct hdmi_priv *priv = snd_soc_dai_get_drvdata(dai);
 90         struct snd_aes_iec958 *iec = &priv->iec;
 91         struct snd_cea_861_aud_if *cea = &priv->cea;
 92         int err = 0;
 93 
 94         switch (params_format(params)) {
 95         case SNDRV_PCM_FORMAT_S16_LE:
 96                 priv->dma_data.maxburst = 16;
 97                 break;
 98         case SNDRV_PCM_FORMAT_S24_LE:
 99                 priv->dma_data.maxburst = 32;
100                 break;
101         default:
102                 dev_err(dai->dev, "format not supported!\n");
103                 return -EINVAL;
104         }
105 
106         /*
107          * fill the IEC-60958 channel status word
108          */
109         /* initialize the word bytes */
110         memset(iec->status, 0, sizeof(iec->status));
111 
112         /* specify IEC-60958-3 (commercial use) */
113         iec->status[0] &= ~IEC958_AES0_PROFESSIONAL;
114 
115         /* specify that the audio is LPCM*/
116         iec->status[0] &= ~IEC958_AES0_NONAUDIO;
117 
118         iec->status[0] |= IEC958_AES0_CON_NOT_COPYRIGHT;
119 
120         iec->status[0] |= IEC958_AES0_CON_EMPHASIS_NONE;
121 
122         iec->status[0] |= IEC958_AES1_PRO_MODE_NOTID;
123 
124         iec->status[1] = IEC958_AES1_CON_GENERAL;
125 
126         iec->status[2] |= IEC958_AES2_CON_SOURCE_UNSPEC;
127 
128         iec->status[2] |= IEC958_AES2_CON_CHANNEL_UNSPEC;
129 
130         switch (params_rate(params)) {
131         case 32000:
132                 iec->status[3] |= IEC958_AES3_CON_FS_32000;
133                 break;
134         case 44100:
135                 iec->status[3] |= IEC958_AES3_CON_FS_44100;
136                 break;
137         case 48000:
138                 iec->status[3] |= IEC958_AES3_CON_FS_48000;
139                 break;
140         case 88200:
141                 iec->status[3] |= IEC958_AES3_CON_FS_88200;
142                 break;
143         case 96000:
144                 iec->status[3] |= IEC958_AES3_CON_FS_96000;
145                 break;
146         case 176400:
147                 iec->status[3] |= IEC958_AES3_CON_FS_176400;
148                 break;
149         case 192000:
150                 iec->status[3] |= IEC958_AES3_CON_FS_192000;
151                 break;
152         default:
153                 dev_err(dai->dev, "rate not supported!\n");
154                 return -EINVAL;
155         }
156 
157         /* specify the clock accuracy */
158         iec->status[3] |= IEC958_AES3_CON_CLOCK_1000PPM;
159 
160         /*
161          * specify the word length. The same word length value can mean
162          * two different lengths. Hence, we need to specify the maximum
163          * word length as well.
164          */
165         switch (params_format(params)) {
166         case SNDRV_PCM_FORMAT_S16_LE:
167                 iec->status[4] |= IEC958_AES4_CON_WORDLEN_20_16;
168                 iec->status[4] &= ~IEC958_AES4_CON_MAX_WORDLEN_24;
169                 break;
170         case SNDRV_PCM_FORMAT_S24_LE:
171                 iec->status[4] |= IEC958_AES4_CON_WORDLEN_24_20;
172                 iec->status[4] |= IEC958_AES4_CON_MAX_WORDLEN_24;
173                 break;
174         default:
175                 dev_err(dai->dev, "format not supported!\n");
176                 return -EINVAL;
177         }
178 
179         /*
180          * Fill the CEA-861 audio infoframe (see spec for details)
181          */
182 
183         cea->db1_ct_cc = (params_channels(params) - 1)
184                 & CEA861_AUDIO_INFOFRAME_DB1CC;
185         cea->db1_ct_cc |= CEA861_AUDIO_INFOFRAME_DB1CT_FROM_STREAM;
186 
187         cea->db2_sf_ss = CEA861_AUDIO_INFOFRAME_DB2SF_FROM_STREAM;
188         cea->db2_sf_ss |= CEA861_AUDIO_INFOFRAME_DB2SS_FROM_STREAM;
189 
190         cea->db3 = 0; /* not used, all zeros */
191 
192         /*
193          * The OMAP HDMI IP requires to use the 8-channel channel code when
194          * transmitting more than two channels.
195          */
196         if (params_channels(params) == 2)
197                 cea->db4_ca = 0x0;
198         else
199                 cea->db4_ca = 0x13;
200 
201         cea->db5_dminh_lsv = CEA861_AUDIO_INFOFRAME_DB5_DM_INH_PROHIBITED;
202         /* the expression is trivial but makes clear what we are doing */
203         cea->db5_dminh_lsv |= (0 & CEA861_AUDIO_INFOFRAME_DB5_LSV);
204 
205         priv->dss_audio.iec = iec;
206         priv->dss_audio.cea = cea;
207 
208         err = priv->dssdev->driver->audio_config(priv->dssdev,
209                                                  &priv->dss_audio);
210 
211         return err;
212 }
213 
214 static int omap_hdmi_dai_trigger(struct snd_pcm_substream *substream, int cmd,
215                                 struct snd_soc_dai *dai)
216 {
217         struct hdmi_priv *priv = snd_soc_dai_get_drvdata(dai);
218         int err = 0;
219 
220         switch (cmd) {
221         case SNDRV_PCM_TRIGGER_START:
222         case SNDRV_PCM_TRIGGER_RESUME:
223         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
224                 err = priv->dssdev->driver->audio_start(priv->dssdev);
225                 break;
226         case SNDRV_PCM_TRIGGER_STOP:
227         case SNDRV_PCM_TRIGGER_SUSPEND:
228         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
229                 priv->dssdev->driver->audio_stop(priv->dssdev);
230                 break;
231         default:
232                 err = -EINVAL;
233         }
234         return err;
235 }
236 
237 static void omap_hdmi_dai_shutdown(struct snd_pcm_substream *substream,
238                                 struct snd_soc_dai *dai)
239 {
240         struct hdmi_priv *priv = snd_soc_dai_get_drvdata(dai);
241 
242         priv->dssdev->driver->audio_disable(priv->dssdev);
243 }
244 
245 static const struct snd_soc_dai_ops omap_hdmi_dai_ops = {
246         .startup        = omap_hdmi_dai_startup,
247         .hw_params      = omap_hdmi_dai_hw_params,
248         .prepare        = omap_hdmi_dai_prepare,
249         .trigger        = omap_hdmi_dai_trigger,
250         .shutdown       = omap_hdmi_dai_shutdown,
251 };
252 
253 static struct snd_soc_dai_driver omap_hdmi_dai = {
254         .playback = {
255                 .channels_min = 2,
256                 .channels_max = 8,
257                 .rates = OMAP_HDMI_RATES,
258                 .formats = OMAP_HDMI_FORMATS,
259         },
260         .ops = &omap_hdmi_dai_ops,
261 };
262 
263 static const struct snd_soc_component_driver omap_hdmi_component = {
264         .name           = DRV_NAME,
265 };
266 
267 static int omap_hdmi_probe(struct platform_device *pdev)
268 {
269         int ret;
270         struct resource *hdmi_rsrc;
271         struct hdmi_priv *hdmi_data;
272         bool hdmi_dev_found = false;
273 
274         hdmi_data = devm_kzalloc(&pdev->dev, sizeof(*hdmi_data), GFP_KERNEL);
275         if (hdmi_data == NULL) {
276                 dev_err(&pdev->dev, "Cannot allocate memory for HDMI data\n");
277                 return -ENOMEM;
278         }
279 
280         hdmi_rsrc = platform_get_resource(pdev, IORESOURCE_MEM, 0);
281         if (!hdmi_rsrc) {
282                 dev_err(&pdev->dev, "Cannot obtain IORESOURCE_MEM HDMI\n");
283                 return -ENODEV;
284         }
285 
286         hdmi_data->dma_data.addr = hdmi_rsrc->start + OMAP_HDMI_AUDIO_DMA_PORT;
287 
288         hdmi_rsrc = platform_get_resource(pdev, IORESOURCE_DMA, 0);
289         if (!hdmi_rsrc) {
290                 dev_err(&pdev->dev, "Cannot obtain IORESOURCE_DMA HDMI\n");
291                 return -ENODEV;
292         }
293 
294         hdmi_data->dma_req = hdmi_rsrc->start;
295         hdmi_data->dma_data.filter_data = &hdmi_data->dma_req;
296         hdmi_data->dma_data.addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
297 
298         /*
299          * TODO: We assume that there is only one DSS HDMI device. Future
300          * OMAP implementations may support more than one HDMI devices and
301          * we should provided separate audio support for all of them.
302          */
303         /* Find an HDMI device. */
304         for_each_dss_dev(hdmi_data->dssdev) {
305                 omap_dss_get_device(hdmi_data->dssdev);
306 
307                 if (!hdmi_data->dssdev->driver) {
308                         omap_dss_put_device(hdmi_data->dssdev);
309                         continue;
310                 }
311 
312                 if (hdmi_data->dssdev->type == OMAP_DISPLAY_TYPE_HDMI) {
313                         hdmi_dev_found = true;
314                         break;
315                 }
316         }
317 
318         if (!hdmi_dev_found) {
319                 dev_err(&pdev->dev, "no driver for HDMI display found\n");
320                 return -ENODEV;
321         }
322 
323         dev_set_drvdata(&pdev->dev, hdmi_data);
324         ret = snd_soc_register_component(&pdev->dev, &omap_hdmi_component,
325                                          &omap_hdmi_dai, 1);
326 
327         return ret;
328 }
329 
330 static int omap_hdmi_remove(struct platform_device *pdev)
331 {
332         struct hdmi_priv *hdmi_data = dev_get_drvdata(&pdev->dev);
333 
334         snd_soc_unregister_component(&pdev->dev);
335 
336         if (hdmi_data == NULL) {
337                 dev_err(&pdev->dev, "cannot obtain HDMi data\n");
338                 return -ENODEV;
339         }
340 
341         omap_dss_put_device(hdmi_data->dssdev);
342         return 0;
343 }
344 
345 static struct platform_driver hdmi_dai_driver = {
346         .driver = {
347                 .name = DRV_NAME,
348                 .owner = THIS_MODULE,
349         },
350         .probe = omap_hdmi_probe,
351         .remove = omap_hdmi_remove,
352 };
353 
354 module_platform_driver(hdmi_dai_driver);
355 
356 MODULE_AUTHOR("Jorge Candelaria <jorge.candelaria@ti.com>");
357 MODULE_AUTHOR("Ricardo Neri <ricardo.neri@ti.com>");
358 MODULE_DESCRIPTION("OMAP HDMI SoC Interface");
359 MODULE_LICENSE("GPL");
360 MODULE_ALIAS("platform:" DRV_NAME);
361 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us