f588545698f3687f75941977b8e597791c964e9e
[linux-2.6.git] / sound / soc / fsl / fsl_ssi.c
1 /*
2  * Freescale SSI ALSA SoC Digital Audio Interface (DAI) driver
3  *
4  * Author: Timur Tabi <timur@freescale.com>
5  *
6  * Copyright 2007-2008 Freescale Semiconductor, Inc.  This file is licensed
7  * under the terms of the GNU General Public License version 2.  This
8  * program is licensed "as is" without any warranty of any kind, whether
9  * express or implied.
10  */
11
12 #include <linux/init.h>
13 #include <linux/module.h>
14 #include <linux/interrupt.h>
15 #include <linux/device.h>
16 #include <linux/delay.h>
17
18 #include <sound/core.h>
19 #include <sound/pcm.h>
20 #include <sound/pcm_params.h>
21 #include <sound/initval.h>
22 #include <sound/soc.h>
23
24 #include <asm/immap_86xx.h>
25
26 #include "fsl_ssi.h"
27
28 /**
29  * FSLSSI_I2S_RATES: sample rates supported by the I2S
30  *
31  * This driver currently only supports the SSI running in I2S slave mode,
32  * which means the codec determines the sample rate.  Therefore, we tell
33  * ALSA that we support all rates and let the codec driver decide what rates
34  * are really supported.
35  */
36 #define FSLSSI_I2S_RATES (SNDRV_PCM_RATE_5512 | SNDRV_PCM_RATE_8000_192000 | \
37                           SNDRV_PCM_RATE_CONTINUOUS)
38
39 /**
40  * FSLSSI_I2S_FORMATS: audio formats supported by the SSI
41  *
42  * This driver currently only supports the SSI running in I2S slave mode.
43  *
44  * The SSI has a limitation in that the samples must be in the same byte
45  * order as the host CPU.  This is because when multiple bytes are written
46  * to the STX register, the bytes and bits must be written in the same
47  * order.  The STX is a shift register, so all the bits need to be aligned
48  * (bit-endianness must match byte-endianness).  Processors typically write
49  * the bits within a byte in the same order that the bytes of a word are
50  * written in.  So if the host CPU is big-endian, then only big-endian
51  * samples will be written to STX properly.
52  */
53 #ifdef __BIG_ENDIAN
54 #define FSLSSI_I2S_FORMATS (SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_S16_BE | \
55          SNDRV_PCM_FMTBIT_S18_3BE | SNDRV_PCM_FMTBIT_S20_3BE | \
56          SNDRV_PCM_FMTBIT_S24_3BE | SNDRV_PCM_FMTBIT_S24_BE)
57 #else
58 #define FSLSSI_I2S_FORMATS (SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_S16_LE | \
59          SNDRV_PCM_FMTBIT_S18_3LE | SNDRV_PCM_FMTBIT_S20_3LE | \
60          SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_S24_LE)
61 #endif
62
63 /**
64  * fsl_ssi_private: per-SSI private data
65  *
66  * @name: short name for this device ("SSI0", "SSI1", etc)
67  * @ssi: pointer to the SSI's registers
68  * @ssi_phys: physical address of the SSI registers
69  * @irq: IRQ of this SSI
70  * @dev: struct device pointer
71  * @playback: the number of playback streams opened
72  * @capture: the number of capture streams opened
73  * @cpu_dai: the CPU DAI for this device
74  * @dev_attr: the sysfs device attribute structure
75  * @stats: SSI statistics
76  */
77 struct fsl_ssi_private {
78         char name[8];
79         struct ccsr_ssi __iomem *ssi;
80         dma_addr_t ssi_phys;
81         unsigned int irq;
82         struct device *dev;
83         unsigned int playback;
84         unsigned int capture;
85         struct snd_soc_cpu_dai cpu_dai;
86         struct device_attribute dev_attr;
87
88         struct {
89                 unsigned int rfrc;
90                 unsigned int tfrc;
91                 unsigned int cmdau;
92                 unsigned int cmddu;
93                 unsigned int rxt;
94                 unsigned int rdr1;
95                 unsigned int rdr0;
96                 unsigned int tde1;
97                 unsigned int tde0;
98                 unsigned int roe1;
99                 unsigned int roe0;
100                 unsigned int tue1;
101                 unsigned int tue0;
102                 unsigned int tfs;
103                 unsigned int rfs;
104                 unsigned int tls;
105                 unsigned int rls;
106                 unsigned int rff1;
107                 unsigned int rff0;
108                 unsigned int tfe1;
109                 unsigned int tfe0;
110         } stats;
111 };
112
113 /**
114  * fsl_ssi_isr: SSI interrupt handler
115  *
116  * Although it's possible to use the interrupt handler to send and receive
117  * data to/from the SSI, we use the DMA instead.  Programming is more
118  * complicated, but the performance is much better.
119  *
120  * This interrupt handler is used only to gather statistics.
121  *
122  * @irq: IRQ of the SSI device
123  * @dev_id: pointer to the ssi_private structure for this SSI device
124  */
125 static irqreturn_t fsl_ssi_isr(int irq, void *dev_id)
126 {
127         struct fsl_ssi_private *ssi_private = dev_id;
128         struct ccsr_ssi __iomem *ssi = ssi_private->ssi;
129         irqreturn_t ret = IRQ_NONE;
130         __be32 sisr;
131         __be32 sisr2 = 0;
132
133         /* We got an interrupt, so read the status register to see what we
134            were interrupted for.  We mask it with the Interrupt Enable register
135            so that we only check for events that we're interested in.
136          */
137         sisr = in_be32(&ssi->sisr) & in_be32(&ssi->sier);
138
139         if (sisr & CCSR_SSI_SISR_RFRC) {
140                 ssi_private->stats.rfrc++;
141                 sisr2 |= CCSR_SSI_SISR_RFRC;
142                 ret = IRQ_HANDLED;
143         }
144
145         if (sisr & CCSR_SSI_SISR_TFRC) {
146                 ssi_private->stats.tfrc++;
147                 sisr2 |= CCSR_SSI_SISR_TFRC;
148                 ret = IRQ_HANDLED;
149         }
150
151         if (sisr & CCSR_SSI_SISR_CMDAU) {
152                 ssi_private->stats.cmdau++;
153                 ret = IRQ_HANDLED;
154         }
155
156         if (sisr & CCSR_SSI_SISR_CMDDU) {
157                 ssi_private->stats.cmddu++;
158                 ret = IRQ_HANDLED;
159         }
160
161         if (sisr & CCSR_SSI_SISR_RXT) {
162                 ssi_private->stats.rxt++;
163                 ret = IRQ_HANDLED;
164         }
165
166         if (sisr & CCSR_SSI_SISR_RDR1) {
167                 ssi_private->stats.rdr1++;
168                 ret = IRQ_HANDLED;
169         }
170
171         if (sisr & CCSR_SSI_SISR_RDR0) {
172                 ssi_private->stats.rdr0++;
173                 ret = IRQ_HANDLED;
174         }
175
176         if (sisr & CCSR_SSI_SISR_TDE1) {
177                 ssi_private->stats.tde1++;
178                 ret = IRQ_HANDLED;
179         }
180
181         if (sisr & CCSR_SSI_SISR_TDE0) {
182                 ssi_private->stats.tde0++;
183                 ret = IRQ_HANDLED;
184         }
185
186         if (sisr & CCSR_SSI_SISR_ROE1) {
187                 ssi_private->stats.roe1++;
188                 sisr2 |= CCSR_SSI_SISR_ROE1;
189                 ret = IRQ_HANDLED;
190         }
191
192         if (sisr & CCSR_SSI_SISR_ROE0) {
193                 ssi_private->stats.roe0++;
194                 sisr2 |= CCSR_SSI_SISR_ROE0;
195                 ret = IRQ_HANDLED;
196         }
197
198         if (sisr & CCSR_SSI_SISR_TUE1) {
199                 ssi_private->stats.tue1++;
200                 sisr2 |= CCSR_SSI_SISR_TUE1;
201                 ret = IRQ_HANDLED;
202         }
203
204         if (sisr & CCSR_SSI_SISR_TUE0) {
205                 ssi_private->stats.tue0++;
206                 sisr2 |= CCSR_SSI_SISR_TUE0;
207                 ret = IRQ_HANDLED;
208         }
209
210         if (sisr & CCSR_SSI_SISR_TFS) {
211                 ssi_private->stats.tfs++;
212                 ret = IRQ_HANDLED;
213         }
214
215         if (sisr & CCSR_SSI_SISR_RFS) {
216                 ssi_private->stats.rfs++;
217                 ret = IRQ_HANDLED;
218         }
219
220         if (sisr & CCSR_SSI_SISR_TLS) {
221                 ssi_private->stats.tls++;
222                 ret = IRQ_HANDLED;
223         }
224
225         if (sisr & CCSR_SSI_SISR_RLS) {
226                 ssi_private->stats.rls++;
227                 ret = IRQ_HANDLED;
228         }
229
230         if (sisr & CCSR_SSI_SISR_RFF1) {
231                 ssi_private->stats.rff1++;
232                 ret = IRQ_HANDLED;
233         }
234
235         if (sisr & CCSR_SSI_SISR_RFF0) {
236                 ssi_private->stats.rff0++;
237                 ret = IRQ_HANDLED;
238         }
239
240         if (sisr & CCSR_SSI_SISR_TFE1) {
241                 ssi_private->stats.tfe1++;
242                 ret = IRQ_HANDLED;
243         }
244
245         if (sisr & CCSR_SSI_SISR_TFE0) {
246                 ssi_private->stats.tfe0++;
247                 ret = IRQ_HANDLED;
248         }
249
250         /* Clear the bits that we set */
251         if (sisr2)
252                 out_be32(&ssi->sisr, sisr2);
253
254         return ret;
255 }
256
257 /**
258  * fsl_ssi_startup: create a new substream
259  *
260  * This is the first function called when a stream is opened.
261  *
262  * If this is the first stream open, then grab the IRQ and program most of
263  * the SSI registers.
264  */
265 static int fsl_ssi_startup(struct snd_pcm_substream *substream)
266 {
267         struct snd_soc_pcm_runtime *rtd = substream->private_data;
268         struct fsl_ssi_private *ssi_private = rtd->dai->cpu_dai->private_data;
269
270         /*
271          * If this is the first stream opened, then request the IRQ
272          * and initialize the SSI registers.
273          */
274         if (!ssi_private->playback && !ssi_private->capture) {
275                 struct ccsr_ssi __iomem *ssi = ssi_private->ssi;
276                 int ret;
277
278                 ret = request_irq(ssi_private->irq, fsl_ssi_isr, 0,
279                                   ssi_private->name, ssi_private);
280                 if (ret < 0) {
281                         dev_err(substream->pcm->card->dev,
282                                 "could not claim irq %u\n", ssi_private->irq);
283                         return ret;
284                 }
285
286                 /*
287                  * Section 16.5 of the MPC8610 reference manual says that the
288                  * SSI needs to be disabled before updating the registers we set
289                  * here.
290                  */
291                 clrbits32(&ssi->scr, CCSR_SSI_SCR_SSIEN);
292
293                 /*
294                  * Program the SSI into I2S Slave Non-Network Synchronous mode.
295                  * Also enable the transmit and receive FIFO.
296                  *
297                  * FIXME: Little-endian samples require a different shift dir
298                  */
299                 clrsetbits_be32(&ssi->scr, CCSR_SSI_SCR_I2S_MODE_MASK,
300                         CCSR_SSI_SCR_TFR_CLK_DIS |
301                         CCSR_SSI_SCR_I2S_MODE_SLAVE | CCSR_SSI_SCR_SYN);
302
303                 out_be32(&ssi->stcr,
304                          CCSR_SSI_STCR_TXBIT0 | CCSR_SSI_STCR_TFEN0 |
305                          CCSR_SSI_STCR_TFSI | CCSR_SSI_STCR_TEFS |
306                          CCSR_SSI_STCR_TSCKP);
307
308                 out_be32(&ssi->srcr,
309                          CCSR_SSI_SRCR_RXBIT0 | CCSR_SSI_SRCR_RFEN0 |
310                          CCSR_SSI_SRCR_RFSI | CCSR_SSI_SRCR_REFS |
311                          CCSR_SSI_SRCR_RSCKP);
312
313                 /*
314                  * The DC and PM bits are only used if the SSI is the clock
315                  * master.
316                  */
317
318                 /* 4. Enable the interrupts and DMA requests */
319                 out_be32(&ssi->sier,
320                          CCSR_SSI_SIER_TFRC_EN | CCSR_SSI_SIER_TDMAE |
321                          CCSR_SSI_SIER_TIE | CCSR_SSI_SIER_TUE0_EN |
322                          CCSR_SSI_SIER_TUE1_EN | CCSR_SSI_SIER_RFRC_EN |
323                          CCSR_SSI_SIER_RDMAE | CCSR_SSI_SIER_RIE |
324                          CCSR_SSI_SIER_ROE0_EN | CCSR_SSI_SIER_ROE1_EN);
325
326                 /*
327                  * Set the watermark for transmit FIFI 0 and receive FIFO 0. We
328                  * don't use FIFO 1.  Since the SSI only supports stereo, the
329                  * watermark should never be an odd number.
330                  */
331                 out_be32(&ssi->sfcsr,
332                          CCSR_SSI_SFCSR_TFWM0(6) | CCSR_SSI_SFCSR_RFWM0(2));
333
334                 /*
335                  * We keep the SSI disabled because if we enable it, then the
336                  * DMA controller will start.  It's not supposed to start until
337                  * the SCR.TE (or SCR.RE) bit is set, but it does anyway.  The
338                  * DMA controller will transfer one "BWC" of data (i.e. the
339                  * amount of data that the MR.BWC bits are set to).  The reason
340                  * this is bad is because at this point, the PCM driver has not
341                  * finished initializing the DMA controller.
342                  */
343         }
344
345         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
346                 ssi_private->playback++;
347
348         if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
349                 ssi_private->capture++;
350
351         return 0;
352 }
353
354 /**
355  * fsl_ssi_prepare: prepare the SSI.
356  *
357  * Most of the SSI registers have been programmed in the startup function,
358  * but the word length must be programmed here.  Unfortunately, programming
359  * the SxCCR.WL bits requires the SSI to be temporarily disabled.  This can
360  * cause a problem with supporting simultaneous playback and capture.  If
361  * the SSI is already playing a stream, then that stream may be temporarily
362  * stopped when you start capture.
363  *
364  * Note: The SxCCR.DC and SxCCR.PM bits are only used if the SSI is the
365  * clock master.
366  */
367 static int fsl_ssi_prepare(struct snd_pcm_substream *substream)
368 {
369         struct snd_pcm_runtime *runtime = substream->runtime;
370         struct snd_soc_pcm_runtime *rtd = substream->private_data;
371         struct fsl_ssi_private *ssi_private = rtd->dai->cpu_dai->private_data;
372
373         struct ccsr_ssi __iomem *ssi = ssi_private->ssi;
374         u32 wl;
375
376         wl = CCSR_SSI_SxCCR_WL(snd_pcm_format_width(runtime->format));
377
378         clrbits32(&ssi->scr, CCSR_SSI_SCR_SSIEN);
379
380         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
381                 clrsetbits_be32(&ssi->stccr, CCSR_SSI_SxCCR_WL_MASK, wl);
382         else
383                 clrsetbits_be32(&ssi->srccr, CCSR_SSI_SxCCR_WL_MASK, wl);
384
385         setbits32(&ssi->scr, CCSR_SSI_SCR_SSIEN);
386
387         return 0;
388 }
389
390 /**
391  * fsl_ssi_trigger: start and stop the DMA transfer.
392  *
393  * This function is called by ALSA to start, stop, pause, and resume the DMA
394  * transfer of data.
395  *
396  * The DMA channel is in external master start and pause mode, which
397  * means the SSI completely controls the flow of data.
398  */
399 static int fsl_ssi_trigger(struct snd_pcm_substream *substream, int cmd)
400 {
401         struct snd_soc_pcm_runtime *rtd = substream->private_data;
402         struct fsl_ssi_private *ssi_private = rtd->dai->cpu_dai->private_data;
403         struct ccsr_ssi __iomem *ssi = ssi_private->ssi;
404
405         switch (cmd) {
406         case SNDRV_PCM_TRIGGER_START:
407         case SNDRV_PCM_TRIGGER_RESUME:
408         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
409                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
410                         setbits32(&ssi->scr, CCSR_SSI_SCR_TE);
411                 } else {
412                         setbits32(&ssi->scr, CCSR_SSI_SCR_RE);
413
414                         /*
415                          * I think we need this delay to allow time for the SSI
416                          * to put data into its FIFO.  Without it, ALSA starts
417                          * to complain about overruns.
418                          */
419                         mdelay(1);
420                 }
421                 break;
422
423         case SNDRV_PCM_TRIGGER_STOP:
424         case SNDRV_PCM_TRIGGER_SUSPEND:
425         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
426                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
427                         clrbits32(&ssi->scr, CCSR_SSI_SCR_TE);
428                 else
429                         clrbits32(&ssi->scr, CCSR_SSI_SCR_RE);
430                 break;
431
432         default:
433                 return -EINVAL;
434         }
435
436         return 0;
437 }
438
439 /**
440  * fsl_ssi_shutdown: shutdown the SSI
441  *
442  * Shutdown the SSI if there are no other substreams open.
443  */
444 static void fsl_ssi_shutdown(struct snd_pcm_substream *substream)
445 {
446         struct snd_soc_pcm_runtime *rtd = substream->private_data;
447         struct fsl_ssi_private *ssi_private = rtd->dai->cpu_dai->private_data;
448
449         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
450                 ssi_private->playback--;
451
452         if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
453                 ssi_private->capture--;
454
455         /*
456          * If this is the last active substream, disable the SSI and release
457          * the IRQ.
458          */
459         if (!ssi_private->playback && !ssi_private->capture) {
460                 struct ccsr_ssi __iomem *ssi = ssi_private->ssi;
461
462                 clrbits32(&ssi->scr, CCSR_SSI_SCR_SSIEN);
463
464                 free_irq(ssi_private->irq, ssi_private);
465         }
466 }
467
468 /**
469  * fsl_ssi_set_sysclk: set the clock frequency and direction
470  *
471  * This function is called by the machine driver to tell us what the clock
472  * frequency and direction are.
473  *
474  * Currently, we only support operating as a clock slave (SND_SOC_CLOCK_IN),
475  * and we don't care about the frequency.  Return an error if the direction
476  * is not SND_SOC_CLOCK_IN.
477  *
478  * @clk_id: reserved, should be zero
479  * @freq: the frequency of the given clock ID, currently ignored
480  * @dir: SND_SOC_CLOCK_IN (clock slave) or SND_SOC_CLOCK_OUT (clock master)
481  */
482 static int fsl_ssi_set_sysclk(struct snd_soc_cpu_dai *cpu_dai,
483                               int clk_id, unsigned int freq, int dir)
484 {
485
486         return (dir == SND_SOC_CLOCK_IN) ? 0 : -EINVAL;
487 }
488
489 /**
490  * fsl_ssi_set_fmt: set the serial format.
491  *
492  * This function is called by the machine driver to tell us what serial
493  * format to use.
494  *
495  * Currently, we only support I2S mode.  Return an error if the format is
496  * not SND_SOC_DAIFMT_I2S.
497  *
498  * @format: one of SND_SOC_DAIFMT_xxx
499  */
500 static int fsl_ssi_set_fmt(struct snd_soc_cpu_dai *cpu_dai, unsigned int format)
501 {
502         return (format == SND_SOC_DAIFMT_I2S) ? 0 : -EINVAL;
503 }
504
505 /**
506  * fsl_ssi_dai_template: template CPU DAI for the SSI
507  */
508 static struct snd_soc_cpu_dai fsl_ssi_dai_template = {
509         .playback = {
510                 /* The SSI does not support monaural audio. */
511                 .channels_min = 2,
512                 .channels_max = 2,
513                 .rates = FSLSSI_I2S_RATES,
514                 .formats = FSLSSI_I2S_FORMATS,
515         },
516         .capture = {
517                 .channels_min = 2,
518                 .channels_max = 2,
519                 .rates = FSLSSI_I2S_RATES,
520                 .formats = FSLSSI_I2S_FORMATS,
521         },
522         .ops = {
523                 .startup = fsl_ssi_startup,
524                 .prepare = fsl_ssi_prepare,
525                 .shutdown = fsl_ssi_shutdown,
526                 .trigger = fsl_ssi_trigger,
527         },
528         .dai_ops = {
529                 .set_sysclk = fsl_ssi_set_sysclk,
530                 .set_fmt = fsl_ssi_set_fmt,
531         },
532 };
533
534 /**
535  * fsl_sysfs_ssi_show: display SSI statistics
536  *
537  * Display the statistics for the current SSI device.
538  */
539 static ssize_t fsl_sysfs_ssi_show(struct device *dev,
540         struct device_attribute *attr, char *buf)
541 {
542         struct fsl_ssi_private *ssi_private =
543         container_of(attr, struct fsl_ssi_private, dev_attr);
544         ssize_t length;
545
546         length = sprintf(buf, "rfrc=%u", ssi_private->stats.rfrc);
547         length += sprintf(buf + length, "\ttfrc=%u", ssi_private->stats.tfrc);
548         length += sprintf(buf + length, "\tcmdau=%u", ssi_private->stats.cmdau);
549         length += sprintf(buf + length, "\tcmddu=%u", ssi_private->stats.cmddu);
550         length += sprintf(buf + length, "\trxt=%u", ssi_private->stats.rxt);
551         length += sprintf(buf + length, "\trdr1=%u", ssi_private->stats.rdr1);
552         length += sprintf(buf + length, "\trdr0=%u", ssi_private->stats.rdr0);
553         length += sprintf(buf + length, "\ttde1=%u", ssi_private->stats.tde1);
554         length += sprintf(buf + length, "\ttde0=%u", ssi_private->stats.tde0);
555         length += sprintf(buf + length, "\troe1=%u", ssi_private->stats.roe1);
556         length += sprintf(buf + length, "\troe0=%u", ssi_private->stats.roe0);
557         length += sprintf(buf + length, "\ttue1=%u", ssi_private->stats.tue1);
558         length += sprintf(buf + length, "\ttue0=%u", ssi_private->stats.tue0);
559         length += sprintf(buf + length, "\ttfs=%u", ssi_private->stats.tfs);
560         length += sprintf(buf + length, "\trfs=%u", ssi_private->stats.rfs);
561         length += sprintf(buf + length, "\ttls=%u", ssi_private->stats.tls);
562         length += sprintf(buf + length, "\trls=%u", ssi_private->stats.rls);
563         length += sprintf(buf + length, "\trff1=%u", ssi_private->stats.rff1);
564         length += sprintf(buf + length, "\trff0=%u", ssi_private->stats.rff0);
565         length += sprintf(buf + length, "\ttfe1=%u", ssi_private->stats.tfe1);
566         length += sprintf(buf + length, "\ttfe0=%u\n", ssi_private->stats.tfe0);
567
568         return length;
569 }
570
571 /**
572  * fsl_ssi_create_dai: create a snd_soc_cpu_dai structure
573  *
574  * This function is called by the machine driver to create a snd_soc_cpu_dai
575  * structure.  The function creates an ssi_private object, which contains
576  * the snd_soc_cpu_dai.  It also creates the sysfs statistics device.
577  */
578 struct snd_soc_cpu_dai *fsl_ssi_create_dai(struct fsl_ssi_info *ssi_info)
579 {
580         struct snd_soc_cpu_dai *fsl_ssi_dai;
581         struct fsl_ssi_private *ssi_private;
582         int ret = 0;
583         struct device_attribute *dev_attr;
584
585         ssi_private = kzalloc(sizeof(struct fsl_ssi_private), GFP_KERNEL);
586         if (!ssi_private) {
587                 dev_err(ssi_info->dev, "could not allocate DAI object\n");
588                 return NULL;
589         }
590         memcpy(&ssi_private->cpu_dai, &fsl_ssi_dai_template,
591                sizeof(struct snd_soc_cpu_dai));
592
593         fsl_ssi_dai = &ssi_private->cpu_dai;
594         dev_attr = &ssi_private->dev_attr;
595
596         sprintf(ssi_private->name, "ssi%u", (u8) ssi_info->id);
597         ssi_private->ssi = ssi_info->ssi;
598         ssi_private->ssi_phys = ssi_info->ssi_phys;
599         ssi_private->irq = ssi_info->irq;
600         ssi_private->dev = ssi_info->dev;
601
602         ssi_private->dev->driver_data = fsl_ssi_dai;
603
604         /* Initialize the the device_attribute structure */
605         dev_attr->attr.name = "ssi-stats";
606         dev_attr->attr.mode = S_IRUGO;
607         dev_attr->show = fsl_sysfs_ssi_show;
608
609         ret = device_create_file(ssi_private->dev, dev_attr);
610         if (ret) {
611                 dev_err(ssi_info->dev, "could not create sysfs %s file\n",
612                         ssi_private->dev_attr.attr.name);
613                 kfree(fsl_ssi_dai);
614                 return NULL;
615         }
616
617         fsl_ssi_dai->private_data = ssi_private;
618         fsl_ssi_dai->name = ssi_private->name;
619         fsl_ssi_dai->id = ssi_info->id;
620
621         return fsl_ssi_dai;
622 }
623 EXPORT_SYMBOL_GPL(fsl_ssi_create_dai);
624
625 /**
626  * fsl_ssi_destroy_dai: destroy the snd_soc_cpu_dai object
627  *
628  * This function undoes the operations of fsl_ssi_create_dai()
629  */
630 void fsl_ssi_destroy_dai(struct snd_soc_cpu_dai *fsl_ssi_dai)
631 {
632         struct fsl_ssi_private *ssi_private =
633         container_of(fsl_ssi_dai, struct fsl_ssi_private, cpu_dai);
634
635         device_remove_file(ssi_private->dev, &ssi_private->dev_attr);
636
637         kfree(ssi_private);
638 }
639 EXPORT_SYMBOL_GPL(fsl_ssi_destroy_dai);
640
641 MODULE_AUTHOR("Timur Tabi <timur@freescale.com>");
642 MODULE_DESCRIPTION("Freescale Synchronous Serial Interface (SSI) ASoC Driver");
643 MODULE_LICENSE("GPL");