git.oblomov.eu Git - linux-2.6/blob - sound/soc/s6000/s6000-i2s.c

   1 /*
   2  * ALSA SoC I2S Audio Layer for the Stretch S6000 family
   3  *
   4  * Author:      Daniel Gloeckner, <dg@emlix.com>
   5  * Copyright:   (C) 2009 emlix GmbH <info@emlix.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  */
  11
  12 #include <linux/init.h>
  13 #include <linux/module.h>
  14 #include <linux/device.h>
  15 #include <linux/delay.h>
  16 #include <linux/clk.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/io.h>
  19
  20 #include <sound/core.h>
  21 #include <sound/pcm.h>
  22 #include <sound/pcm_params.h>
  23 #include <sound/initval.h>
  24 #include <sound/soc.h>
  25
  26 #include "s6000-i2s.h"
  27 #include "s6000-pcm.h"
  28
  29 struct s6000_i2s_dev {
  30         dma_addr_t sifbase;
  31         u8 __iomem *scbbase;
  32         unsigned int wide;
  33         unsigned int channel_in;
  34         unsigned int channel_out;
  35         unsigned int lines_in;
  36         unsigned int lines_out;
  37         struct s6000_pcm_dma_params dma_params;
  38 };
  39
  40 #define S6_I2S_INTERRUPT_STATUS 0x00
  41 #define   S6_I2S_INT_OVERRUN    1
  42 #define   S6_I2S_INT_UNDERRUN   2
  43 #define   S6_I2S_INT_ALIGNMENT  4
  44 #define S6_I2S_INTERRUPT_ENABLE 0x04
  45 #define S6_I2S_INTERRUPT_RAW    0x08
  46 #define S6_I2S_INTERRUPT_CLEAR  0x0C
  47 #define S6_I2S_INTERRUPT_SET    0x10
  48 #define S6_I2S_MODE             0x20
  49 #define   S6_I2S_DUAL           0
  50 #define   S6_I2S_WIDE           1
  51 #define S6_I2S_TX_DEFAULT       0x24
  52 #define S6_I2S_DATA_CFG(c)      (0x40 + 0x10 * (c))
  53 #define   S6_I2S_IN             0
  54 #define   S6_I2S_OUT            1
  55 #define   S6_I2S_UNUSED         2
  56 #define S6_I2S_INTERFACE_CFG(c) (0x44 + 0x10 * (c))
  57 #define   S6_I2S_DIV_MASK       0x001fff
  58 #define   S6_I2S_16BIT          0x000000
  59 #define   S6_I2S_20BIT          0x002000
  60 #define   S6_I2S_24BIT          0x004000
  61 #define   S6_I2S_32BIT          0x006000
  62 #define   S6_I2S_BITS_MASK      0x006000
  63 #define   S6_I2S_MEM_16BIT      0x000000
  64 #define   S6_I2S_MEM_32BIT      0x008000
  65 #define   S6_I2S_MEM_MASK       0x008000
  66 #define   S6_I2S_CHANNELS_SHIFT 16
  67 #define   S6_I2S_CHANNELS_MASK  0x030000
  68 #define   S6_I2S_SCK_IN         0x000000
  69 #define   S6_I2S_SCK_OUT        0x040000
  70 #define   S6_I2S_SCK_DIR        0x040000
  71 #define   S6_I2S_WS_IN          0x000000
  72 #define   S6_I2S_WS_OUT         0x080000
  73 #define   S6_I2S_WS_DIR         0x080000
  74 #define   S6_I2S_LEFT_FIRST     0x000000
  75 #define   S6_I2S_RIGHT_FIRST    0x100000
  76 #define   S6_I2S_FIRST          0x100000
  77 #define   S6_I2S_CUR_SCK        0x200000
  78 #define   S6_I2S_CUR_WS         0x400000
  79 #define S6_I2S_ENABLE(c)        (0x48 + 0x10 * (c))
  80 #define   S6_I2S_DISABLE_IF     0x02
  81 #define   S6_I2S_ENABLE_IF      0x03
  82 #define   S6_I2S_IS_BUSY        0x04
  83 #define   S6_I2S_DMA_ACTIVE     0x08
  84 #define   S6_I2S_IS_ENABLED     0x10
  85
  86 #define S6_I2S_NUM_LINES        4
  87
  88 #define S6_I2S_SIF_PORT0        0x0000000
  89 #define S6_I2S_SIF_PORT1        0x0000080 /* docs say 0x0000010 */
  90
  91 static inline void s6_i2s_write_reg(struct s6000_i2s_dev *dev, int reg, u32 val)
  92 {
  93         writel(val, dev->scbbase + reg);
  94 }
  95
  96 static inline u32 s6_i2s_read_reg(struct s6000_i2s_dev *dev, int reg)
  97 {
  98         return readl(dev->scbbase + reg);
  99 }
 100
 101 static inline void s6_i2s_mod_reg(struct s6000_i2s_dev *dev, int reg,
 102                                   u32 mask, u32 val)
 103 {
 104         val ^= s6_i2s_read_reg(dev, reg) & ~mask;
 105         s6_i2s_write_reg(dev, reg, val);
 106 }
 107
 108 static void s6000_i2s_start_channel(struct s6000_i2s_dev *dev, int channel)
 109 {
 110         int i, j, cur, prev;
 111
 112         /*
 113          * Wait for WCLK to toggle 5 times before enabling the channel
 114          * s6000 Family Datasheet 3.6.4:
 115          *   "At least two cycles of WS must occur between commands
 116          *    to disable or enable the interface"
 117          */
 118         j = 0;
 119         prev = ~S6_I2S_CUR_WS;
 120         for (i = 1000000; --i && j < 6; ) {
 121                 cur = s6_i2s_read_reg(dev, S6_I2S_INTERFACE_CFG(channel))
 122                        & S6_I2S_CUR_WS;
 123                 if (prev != cur) {
 124                         prev = cur;
 125                         j++;
 126                 }
 127         }
 128         if (j < 6)
 129                 printk(KERN_WARNING "s6000-i2s: timeout waiting for WCLK\n");
 130
 131         s6_i2s_write_reg(dev, S6_I2S_ENABLE(channel), S6_I2S_ENABLE_IF);
 132 }
 133
 134 static void s6000_i2s_stop_channel(struct s6000_i2s_dev *dev, int channel)
 135 {
 136         s6_i2s_write_reg(dev, S6_I2S_ENABLE(channel), S6_I2S_DISABLE_IF);
 137 }
 138
 139 static void s6000_i2s_start(struct snd_pcm_substream *substream)
 140 {
 141         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 142         struct s6000_i2s_dev *dev = rtd->dai->cpu_dai->private_data;
 143         int channel;
 144
 145         channel = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
 146                         dev->channel_out : dev->channel_in;
 147
 148         s6000_i2s_start_channel(dev, channel);
 149 }
 150
 151 static void s6000_i2s_stop(struct snd_pcm_substream *substream)
 152 {
 153         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 154         struct s6000_i2s_dev *dev = rtd->dai->cpu_dai->private_data;
 155         int channel;
 156
 157         channel = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
 158                         dev->channel_out : dev->channel_in;
 159
 160         s6000_i2s_stop_channel(dev, channel);
 161 }
 162
 163 static int s6000_i2s_trigger(struct snd_pcm_substream *substream, int cmd,
 164                              int after)
 165 {
 166         switch (cmd) {
 167         case SNDRV_PCM_TRIGGER_START:
 168         case SNDRV_PCM_TRIGGER_RESUME:
 169         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 170                 if ((substream->stream == SNDRV_PCM_STREAM_CAPTURE) ^ !after)
 171                         s6000_i2s_start(substream);
 172                 break;
 173         case SNDRV_PCM_TRIGGER_STOP:
 174         case SNDRV_PCM_TRIGGER_SUSPEND:
 175         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 176                 if (!after)
 177                         s6000_i2s_stop(substream);
 178         }
 179         return 0;
 180 }
 181
 182 static unsigned int s6000_i2s_int_sources(struct s6000_i2s_dev *dev)
 183 {
 184         unsigned int pending;
 185         pending = s6_i2s_read_reg(dev, S6_I2S_INTERRUPT_RAW);
 186         pending &= S6_I2S_INT_ALIGNMENT |
 187                    S6_I2S_INT_UNDERRUN |
 188                    S6_I2S_INT_OVERRUN;
 189         s6_i2s_write_reg(dev, S6_I2S_INTERRUPT_CLEAR, pending);
 190
 191         return pending;
 192 }
 193
 194 static unsigned int s6000_i2s_check_xrun(struct snd_soc_dai *cpu_dai)
 195 {
 196         struct s6000_i2s_dev *dev = cpu_dai->private_data;
 197         unsigned int errors;
 198         unsigned int ret;
 199
 200         errors = s6000_i2s_int_sources(dev);
 201         if (likely(!errors))
 202                 return 0;
 203
 204         ret = 0;
 205         if (errors & S6_I2S_INT_ALIGNMENT)
 206                 printk(KERN_ERR "s6000-i2s: WCLK misaligned\n");
 207         if (errors & S6_I2S_INT_UNDERRUN)
 208                 ret |= 1 << SNDRV_PCM_STREAM_PLAYBACK;
 209         if (errors & S6_I2S_INT_OVERRUN)
 210                 ret |= 1 << SNDRV_PCM_STREAM_CAPTURE;
 211         return ret;
 212 }
 213
 214 static void s6000_i2s_wait_disabled(struct s6000_i2s_dev *dev)
 215 {
 216         int channel;
 217         int n = 50;
 218         for (channel = 0; channel < 2; channel++) {
 219                 while (--n >= 0) {
 220                         int v = s6_i2s_read_reg(dev, S6_I2S_ENABLE(channel));
 221                         if ((v & S6_I2S_IS_ENABLED)
 222                             || !(v & (S6_I2S_DMA_ACTIVE | S6_I2S_IS_BUSY)))
 223                                 break;
 224                         udelay(20);
 225                 }
 226         }
 227         if (n < 0)
 228                 printk(KERN_WARNING "s6000-i2s: timeout disabling interfaces");
 229 }
 230
 231 static int s6000_i2s_set_dai_fmt(struct snd_soc_dai *cpu_dai,
 232                                    unsigned int fmt)
 233 {
 234         struct s6000_i2s_dev *dev = cpu_dai->private_data;
 235         u32 w;
 236
 237         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
 238         case SND_SOC_DAIFMT_CBM_CFM:
 239                 w = S6_I2S_SCK_IN | S6_I2S_WS_IN;
 240                 break;
 241         case SND_SOC_DAIFMT_CBS_CFM:
 242                 w = S6_I2S_SCK_OUT | S6_I2S_WS_IN;
 243                 break;
 244         case SND_SOC_DAIFMT_CBM_CFS:
 245                 w = S6_I2S_SCK_IN | S6_I2S_WS_OUT;
 246                 break;
 247         case SND_SOC_DAIFMT_CBS_CFS:
 248                 w = S6_I2S_SCK_OUT | S6_I2S_WS_OUT;
 249                 break;
 250         default:
 251                 return -EINVAL;
 252         }
 253
 254         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
 255         case SND_SOC_DAIFMT_NB_NF:
 256                 w |= S6_I2S_LEFT_FIRST;
 257                 break;
 258         case SND_SOC_DAIFMT_NB_IF:
 259                 w |= S6_I2S_RIGHT_FIRST;
 260                 break;
 261         default:
 262                 return -EINVAL;
 263         }
 264
 265         s6_i2s_mod_reg(dev, S6_I2S_INTERFACE_CFG(0),
 266                        S6_I2S_FIRST | S6_I2S_WS_DIR | S6_I2S_SCK_DIR, w);
 267         s6_i2s_mod_reg(dev, S6_I2S_INTERFACE_CFG(1),
 268                        S6_I2S_FIRST | S6_I2S_WS_DIR | S6_I2S_SCK_DIR, w);
 269
 270         return 0;
 271 }
 272
 273 static int s6000_i2s_set_clkdiv(struct snd_soc_dai *dai, int div_id, int div)
 274 {
 275         struct s6000_i2s_dev *dev = dai->private_data;
 276
 277         if (!div || (div & 1) || div > (S6_I2S_DIV_MASK + 1) * 2)
 278                 return -EINVAL;
 279
 280         s6_i2s_mod_reg(dev, S6_I2S_INTERFACE_CFG(div_id),
 281                        S6_I2S_DIV_MASK, div / 2 - 1);
 282         return 0;
 283 }
 284
 285 static int s6000_i2s_hw_params(struct snd_pcm_substream *substream,
 286                                struct snd_pcm_hw_params *params,
 287                                struct snd_soc_dai *dai)
 288 {
 289         struct s6000_i2s_dev *dev = dai->private_data;
 290         int interf;
 291         u32 w = 0;
 292
 293         if (dev->wide)
 294                 interf = 0;
 295         else {
 296                 w |= (((params_channels(params) - 2) / 2)
 297                       << S6_I2S_CHANNELS_SHIFT) & S6_I2S_CHANNELS_MASK;
 298                 interf = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 299                                 ? dev->channel_out : dev->channel_in;
 300         }
 301
 302         switch (params_format(params)) {
 303         case SNDRV_PCM_FORMAT_S16_LE:
 304                 w |= S6_I2S_16BIT | S6_I2S_MEM_16BIT;
 305                 break;
 306         case SNDRV_PCM_FORMAT_S32_LE:
 307                 w |= S6_I2S_32BIT | S6_I2S_MEM_32BIT;
 308                 break;
 309         default:
 310                 printk(KERN_WARNING "s6000-i2s: unsupported PCM format %x\n",
 311                        params_format(params));
 312                 return -EINVAL;
 313         }
 314
 315         if (s6_i2s_read_reg(dev, S6_I2S_INTERFACE_CFG(interf))
 316              & S6_I2S_IS_ENABLED) {
 317                 printk(KERN_ERR "s6000-i2s: interface already enabled\n");
 318                 return -EBUSY;
 319         }
 320
 321         s6_i2s_mod_reg(dev, S6_I2S_INTERFACE_CFG(interf),
 322                        S6_I2S_CHANNELS_MASK|S6_I2S_MEM_MASK|S6_I2S_BITS_MASK,
 323                        w);
 324
 325         return 0;
 326 }
 327
 328 static int s6000_i2s_dai_probe(struct platform_device *pdev,
 329                                struct snd_soc_dai *dai)
 330 {
 331         struct s6000_i2s_dev *dev = dai->private_data;
 332         struct s6000_snd_platform_data *pdata = pdev->dev.platform_data;
 333
 334         if (!pdata)
 335                 return -EINVAL;
 336
 337         dev->wide = pdata->wide;
 338         dev->channel_in = pdata->channel_in;
 339         dev->channel_out = pdata->channel_out;
 340         dev->lines_in = pdata->lines_in;
 341         dev->lines_out = pdata->lines_out;
 342
 343         s6_i2s_write_reg(dev, S6_I2S_MODE,
 344                          dev->wide ? S6_I2S_WIDE : S6_I2S_DUAL);
 345
 346         if (dev->wide) {
 347                 int i;
 348
 349                 if (dev->lines_in + dev->lines_out > S6_I2S_NUM_LINES)
 350                         return -EINVAL;
 351
 352                 dev->channel_in = 0;
 353                 dev->channel_out = 1;
 354                 dai->capture.channels_min = 2 * dev->lines_in;
 355                 dai->capture.channels_max = dai->capture.channels_min;
 356                 dai->playback.channels_min = 2 * dev->lines_out;
 357                 dai->playback.channels_max = dai->playback.channels_min;
 358
 359                 for (i = 0; i < dev->lines_out; i++)
 360                         s6_i2s_write_reg(dev, S6_I2S_DATA_CFG(i), S6_I2S_OUT);
 361
 362                 for (; i < S6_I2S_NUM_LINES - dev->lines_in; i++)
 363                         s6_i2s_write_reg(dev, S6_I2S_DATA_CFG(i),
 364                                          S6_I2S_UNUSED);
 365
 366                 for (; i < S6_I2S_NUM_LINES; i++)
 367                         s6_i2s_write_reg(dev, S6_I2S_DATA_CFG(i), S6_I2S_IN);
 368         } else {
 369                 unsigned int cfg[2] = {S6_I2S_UNUSED, S6_I2S_UNUSED};
 370
 371                 if (dev->lines_in > 1 || dev->lines_out > 1)
 372                         return -EINVAL;
 373
 374                 dai->capture.channels_min = 2 * dev->lines_in;
 375                 dai->capture.channels_max = 8 * dev->lines_in;
 376                 dai->playback.channels_min = 2 * dev->lines_out;
 377                 dai->playback.channels_max = 8 * dev->lines_out;
 378
 379                 if (dev->lines_in)
 380                         cfg[dev->channel_in] = S6_I2S_IN;
 381                 if (dev->lines_out)
 382                         cfg[dev->channel_out] = S6_I2S_OUT;
 383
 384                 s6_i2s_write_reg(dev, S6_I2S_DATA_CFG(0), cfg[0]);
 385                 s6_i2s_write_reg(dev, S6_I2S_DATA_CFG(1), cfg[1]);
 386         }
 387
 388         if (dev->lines_out) {
 389                 if (dev->lines_in) {
 390                         if (!dev->dma_params.dma_out)
 391                                 return -ENODEV;
 392                 } else {
 393                         dev->dma_params.dma_out = dev->dma_params.dma_in;
 394                         dev->dma_params.dma_in = 0;
 395                 }
 396         }
 397         dev->dma_params.sif_in = dev->sifbase + (dev->channel_in ?
 398                                         S6_I2S_SIF_PORT1 : S6_I2S_SIF_PORT0);
 399         dev->dma_params.sif_out = dev->sifbase + (dev->channel_out ?
 400                                         S6_I2S_SIF_PORT1 : S6_I2S_SIF_PORT0);
 401         dev->dma_params.same_rate = pdata->same_rate | pdata->wide;
 402         return 0;
 403 }
 404
 405 #define S6000_I2S_RATES (SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_5512 | \
 406                          SNDRV_PCM_RATE_8000_192000)
 407 #define S6000_I2S_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE)
 408
 409 static struct snd_soc_dai_ops s6000_i2s_dai_ops = {
 410         .set_fmt = s6000_i2s_set_dai_fmt,
 411         .set_clkdiv = s6000_i2s_set_clkdiv,
 412         .hw_params = s6000_i2s_hw_params,
 413 };
 414
 415 struct snd_soc_dai s6000_i2s_dai = {
 416         .name = "s6000-i2s",
 417         .id = 0,
 418         .probe = s6000_i2s_dai_probe,
 419         .playback = {
 420                 .channels_min = 2,
 421                 .channels_max = 8,
 422                 .formats = S6000_I2S_FORMATS,
 423                 .rates = S6000_I2S_RATES,
 424                 .rate_min = 0,
 425                 .rate_max = 1562500,
 426         },
 427         .capture = {
 428                 .channels_min = 2,
 429                 .channels_max = 8,
 430                 .formats = S6000_I2S_FORMATS,
 431                 .rates = S6000_I2S_RATES,
 432                 .rate_min = 0,
 433                 .rate_max = 1562500,
 434         },
 435         .ops = &s6000_i2s_dai_ops,
 436 }
 437 EXPORT_SYMBOL_GPL(s6000_i2s_dai);
 438
 439 static int __devinit s6000_i2s_probe(struct platform_device *pdev)
 440 {
 441         struct s6000_i2s_dev *dev;
 442         struct resource *scbmem, *sifmem, *region, *dma1, *dma2;
 443         u8 __iomem *mmio;
 444         int ret;
 445
 446         scbmem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 447         if (!scbmem) {
 448                 dev_err(&pdev->dev, "no mem resource?\n");
 449                 ret = -ENODEV;
 450                 goto err_release_none;
 451         }
 452
 453         region = request_mem_region(scbmem->start,
 454                                     scbmem->end - scbmem->start + 1,
 455                                     pdev->name);
 456         if (!region) {
 457                 dev_err(&pdev->dev, "I2S SCB region already claimed\n");
 458                 ret = -EBUSY;
 459                 goto err_release_none;
 460         }
 461
 462         mmio = ioremap(scbmem->start, scbmem->end - scbmem->start + 1);
 463         if (!mmio) {
 464                 dev_err(&pdev->dev, "can't ioremap SCB region\n");
 465                 ret = -ENOMEM;
 466                 goto err_release_scb;
 467         }
 468
 469         sifmem = platform_get_resource(pdev, IORESOURCE_MEM, 1);
 470         if (!sifmem) {
 471                 dev_err(&pdev->dev, "no second mem resource?\n");
 472                 ret = -ENODEV;
 473                 goto err_release_map;
 474         }
 475
 476         region = request_mem_region(sifmem->start,
 477                                     sifmem->end - sifmem->start + 1,
 478                                     pdev->name);
 479         if (!region) {
 480                 dev_err(&pdev->dev, "I2S SIF region already claimed\n");
 481                 ret = -EBUSY;
 482                 goto err_release_map;
 483         }
 484
 485         dma1 = platform_get_resource(pdev, IORESOURCE_DMA, 0);
 486         if (!dma1) {
 487                 dev_err(&pdev->dev, "no dma resource?\n");
 488                 ret = -ENODEV;
 489                 goto err_release_sif;
 490         }
 491
 492         region = request_mem_region(dma1->start, dma1->end - dma1->start + 1,
 493                                     pdev->name);
 494         if (!region) {
 495                 dev_err(&pdev->dev, "I2S DMA region already claimed\n");
 496                 ret = -EBUSY;
 497                 goto err_release_sif;
 498         }
 499
 500         dma2 = platform_get_resource(pdev, IORESOURCE_DMA, 1);
 501         if (dma2) {
 502                 region = request_mem_region(dma2->start,
 503                                             dma2->end - dma2->start + 1,
 504                                             pdev->name);
 505                 if (!region) {
 506                         dev_err(&pdev->dev,
 507                                 "I2S DMA region already claimed\n");
 508                         ret = -EBUSY;
 509                         goto err_release_dma1;
 510                 }
 511         }
 512
 513         dev = kzalloc(sizeof(struct s6000_i2s_dev), GFP_KERNEL);
 514         if (!dev) {
 515                 ret = -ENOMEM;
 516                 goto err_release_dma2;
 517         }
 518
 519         s6000_i2s_dai.dev = &pdev->dev;
 520         s6000_i2s_dai.private_data = dev;
 521         s6000_i2s_dai.dma_data = &dev->dma_params;
 522
 523         dev->sifbase = sifmem->start;
 524         dev->scbbase = mmio;
 525
 526         s6_i2s_write_reg(dev, S6_I2S_INTERRUPT_ENABLE, 0);
 527         s6_i2s_write_reg(dev, S6_I2S_INTERRUPT_CLEAR,
 528                          S6_I2S_INT_ALIGNMENT |
 529                          S6_I2S_INT_UNDERRUN |
 530                          S6_I2S_INT_OVERRUN);
 531
 532         s6000_i2s_stop_channel(dev, 0);
 533         s6000_i2s_stop_channel(dev, 1);
 534         s6000_i2s_wait_disabled(dev);
 535
 536         dev->dma_params.check_xrun = s6000_i2s_check_xrun;
 537         dev->dma_params.trigger = s6000_i2s_trigger;
 538         dev->dma_params.dma_in = dma1->start;
 539         dev->dma_params.dma_out = dma2 ? dma2->start : 0;
 540         dev->dma_params.irq = platform_get_irq(pdev, 0);
 541         if (dev->dma_params.irq < 0) {
 542                 dev_err(&pdev->dev, "no irq resource?\n");
 543                 ret = -ENODEV;
 544                 goto err_release_dev;
 545         }
 546
 547         s6_i2s_write_reg(dev, S6_I2S_INTERRUPT_ENABLE,
 548                          S6_I2S_INT_ALIGNMENT |
 549                          S6_I2S_INT_UNDERRUN |
 550                          S6_I2S_INT_OVERRUN);
 551
 552         ret = snd_soc_register_dai(&s6000_i2s_dai);
 553         if (ret)
 554                 goto err_release_dev;
 555
 556         return 0;
 557
 558 err_release_dev:
 559         kfree(dev);
 560 err_release_dma2:
 561         if (dma2)
 562                 release_mem_region(dma2->start, dma2->end - dma2->start + 1);
 563 err_release_dma1:
 564         release_mem_region(dma1->start, dma1->end - dma1->start + 1);
 565 err_release_sif:
 566         release_mem_region(sifmem->start, (sifmem->end - sifmem->start) + 1);
 567 err_release_map:
 568         iounmap(mmio);
 569 err_release_scb:
 570         release_mem_region(scbmem->start, (scbmem->end - scbmem->start) + 1);
 571 err_release_none:
 572         return ret;
 573 }
 574
 575 static void __devexit s6000_i2s_remove(struct platform_device *pdev)
 576 {
 577         struct s6000_i2s_dev *dev = s6000_i2s_dai.private_data;
 578         struct resource *region;
 579         void __iomem *mmio = dev->scbbase;
 580
 581         snd_soc_unregister_dai(&s6000_i2s_dai);
 582
 583         s6000_i2s_stop_channel(dev, 0);
 584         s6000_i2s_stop_channel(dev, 1);
 585
 586         s6_i2s_write_reg(dev, S6_I2S_INTERRUPT_ENABLE, 0);
 587         s6000_i2s_dai.private_data = 0;
 588         kfree(dev);
 589
 590         region = platform_get_resource(pdev, IORESOURCE_DMA, 0);
 591         release_mem_region(region->start, region->end - region->start + 1);
 592
 593         region = platform_get_resource(pdev, IORESOURCE_DMA, 1);
 594         if (region)
 595                 release_mem_region(region->start,
 596                                    region->end - region->start + 1);
 597
 598         region = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 599         release_mem_region(region->start, (region->end - region->start) + 1);
 600
 601         iounmap(mmio);
 602         region = platform_get_resource(pdev, IORESOURCE_IO, 0);
 603         release_mem_region(region->start, (region->end - region->start) + 1);
 604 }
 605
 606 static struct platform_driver s6000_i2s_driver = {
 607         .probe  = s6000_i2s_probe,
 608         .remove = __devexit_p(s6000_i2s_remove),
 609         .driver = {
 610                 .name   = "s6000-i2s",
 611                 .owner  = THIS_MODULE,
 612         },
 613 };
 614
 615 static int __init s6000_i2s_init(void)
 616 {
 617         return platform_driver_register(&s6000_i2s_driver);
 618 }
 619 module_init(s6000_i2s_init);
 620
 621 static void __exit s6000_i2s_exit(void)
 622 {
 623         platform_driver_unregister(&s6000_i2s_driver);
 624 }
 625 module_exit(s6000_i2s_exit);
 626
 627 MODULE_AUTHOR("Daniel Gloeckner");
 628 MODULE_DESCRIPTION("Stretch s6000 family I2S SoC Interface");
 629 MODULE_LICENSE("GPL");