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