SAFE public projects git trees. - safe/jmp/linux-2.6/blob - sound/atmel/ac97c.c

   1 /*
   2  * Driver for Atmel AC97C
   3  *
   4  * Copyright (C) 2005-2009 Atmel Corporation
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 as published by
   8  * the Free Software Foundation.
   9  */
  10 #include <linux/clk.h>
  11 #include <linux/delay.h>
  12 #include <linux/bitmap.h>
  13 #include <linux/device.h>
  14 #include <linux/dmaengine.h>
  15 #include <linux/dma-mapping.h>
  16 #include <linux/init.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/module.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/mutex.h>
  21 #include <linux/gpio.h>
  22 #include <linux/io.h>
  23
  24 #include <sound/core.h>
  25 #include <sound/initval.h>
  26 #include <sound/pcm.h>
  27 #include <sound/pcm_params.h>
  28 #include <sound/ac97_codec.h>
  29 #include <sound/atmel-ac97c.h>
  30 #include <sound/memalloc.h>
  31
  32 #include <linux/dw_dmac.h>
  33
  34 #include "ac97c.h"
  35
  36 enum {
  37         DMA_TX_READY = 0,
  38         DMA_RX_READY,
  39         DMA_TX_CHAN_PRESENT,
  40         DMA_RX_CHAN_PRESENT,
  41 };
  42
  43 /* Serialize access to opened variable */
  44 static DEFINE_MUTEX(opened_mutex);
  45
  46 struct atmel_ac97c_dma {
  47         struct dma_chan                 *rx_chan;
  48         struct dma_chan                 *tx_chan;
  49 };
  50
  51 struct atmel_ac97c {
  52         struct clk                      *pclk;
  53         struct platform_device          *pdev;
  54         struct atmel_ac97c_dma          dma;
  55
  56         struct snd_pcm_substream        *playback_substream;
  57         struct snd_pcm_substream        *capture_substream;
  58         struct snd_card                 *card;
  59         struct snd_pcm                  *pcm;
  60         struct snd_ac97                 *ac97;
  61         struct snd_ac97_bus             *ac97_bus;
  62
  63         u64                             cur_format;
  64         unsigned int                    cur_rate;
  65         unsigned long                   flags;
  66         /* Serialize access to opened variable */
  67         spinlock_t                      lock;
  68         void __iomem                    *regs;
  69         int                             irq;
  70         int                             opened;
  71         int                             reset_pin;
  72 };
  73
  74 #define get_chip(card) ((struct atmel_ac97c *)(card)->private_data)
  75
  76 #define ac97c_writel(chip, reg, val)                    \
  77         __raw_writel((val), (chip)->regs + AC97C_##reg)
  78 #define ac97c_readl(chip, reg)                          \
  79         __raw_readl((chip)->regs + AC97C_##reg)
  80
  81 /* This function is called by the DMA driver. */
  82 static void atmel_ac97c_dma_playback_period_done(void *arg)
  83 {
  84         struct atmel_ac97c *chip = arg;
  85         snd_pcm_period_elapsed(chip->playback_substream);
  86 }
  87
  88 static void atmel_ac97c_dma_capture_period_done(void *arg)
  89 {
  90         struct atmel_ac97c *chip = arg;
  91         snd_pcm_period_elapsed(chip->capture_substream);
  92 }
  93
  94 static int atmel_ac97c_prepare_dma(struct atmel_ac97c *chip,
  95                 struct snd_pcm_substream *substream,
  96                 enum dma_data_direction direction)
  97 {
  98         struct dma_chan                 *chan;
  99         struct dw_cyclic_desc           *cdesc;
 100         struct snd_pcm_runtime          *runtime = substream->runtime;
 101         unsigned long                   buffer_len, period_len;
 102
 103         /*
 104          * We don't do DMA on "complex" transfers, i.e. with
 105          * non-halfword-aligned buffers or lengths.
 106          */
 107         if (runtime->dma_addr & 1 || runtime->buffer_size & 1) {
 108                 dev_dbg(&chip->pdev->dev, "too complex transfer\n");
 109                 return -EINVAL;
 110         }
 111
 112         if (direction == DMA_TO_DEVICE)
 113                 chan = chip->dma.tx_chan;
 114         else
 115                 chan = chip->dma.rx_chan;
 116
 117         buffer_len = frames_to_bytes(runtime, runtime->buffer_size);
 118         period_len = frames_to_bytes(runtime, runtime->period_size);
 119
 120         cdesc = dw_dma_cyclic_prep(chan, runtime->dma_addr, buffer_len,
 121                         period_len, direction);
 122         if (IS_ERR(cdesc)) {
 123                 dev_dbg(&chip->pdev->dev, "could not prepare cyclic DMA\n");
 124                 return PTR_ERR(cdesc);
 125         }
 126
 127         if (direction == DMA_TO_DEVICE) {
 128                 cdesc->period_callback = atmel_ac97c_dma_playback_period_done;
 129                 set_bit(DMA_TX_READY, &chip->flags);
 130         } else {
 131                 cdesc->period_callback = atmel_ac97c_dma_capture_period_done;
 132                 set_bit(DMA_RX_READY, &chip->flags);
 133         }
 134
 135         cdesc->period_callback_param = chip;
 136
 137         return 0;
 138 }
 139
 140 static struct snd_pcm_hardware atmel_ac97c_hw = {
 141         .info                   = (SNDRV_PCM_INFO_MMAP
 142                                   | SNDRV_PCM_INFO_MMAP_VALID
 143                                   | SNDRV_PCM_INFO_INTERLEAVED
 144                                   | SNDRV_PCM_INFO_BLOCK_TRANSFER
 145                                   | SNDRV_PCM_INFO_JOINT_DUPLEX
 146                                   | SNDRV_PCM_INFO_RESUME
 147                                   | SNDRV_PCM_INFO_PAUSE),
 148         .formats                = (SNDRV_PCM_FMTBIT_S16_BE
 149                                   | SNDRV_PCM_FMTBIT_S16_LE),
 150         .rates                  = (SNDRV_PCM_RATE_CONTINUOUS),
 151         .rate_min               = 4000,
 152         .rate_max               = 48000,
 153         .channels_min           = 1,
 154         .channels_max           = 2,
 155         .buffer_bytes_max       = 2 * 2 * 64 * 2048,
 156         .period_bytes_min       = 4096,
 157         .period_bytes_max       = 4096,
 158         .periods_min            = 6,
 159         .periods_max            = 64,
 160 };
 161
 162 static int atmel_ac97c_playback_open(struct snd_pcm_substream *substream)
 163 {
 164         struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
 165         struct snd_pcm_runtime *runtime = substream->runtime;
 166
 167         mutex_lock(&opened_mutex);
 168         chip->opened++;
 169         runtime->hw = atmel_ac97c_hw;
 170         if (chip->cur_rate) {
 171                 runtime->hw.rate_min = chip->cur_rate;
 172                 runtime->hw.rate_max = chip->cur_rate;
 173         }
 174         if (chip->cur_format)
 175                 runtime->hw.formats = (1ULL << chip->cur_format);
 176         mutex_unlock(&opened_mutex);
 177         chip->playback_substream = substream;
 178         return 0;
 179 }
 180
 181 static int atmel_ac97c_capture_open(struct snd_pcm_substream *substream)
 182 {
 183         struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
 184         struct snd_pcm_runtime *runtime = substream->runtime;
 185
 186         mutex_lock(&opened_mutex);
 187         chip->opened++;
 188         runtime->hw = atmel_ac97c_hw;
 189         if (chip->cur_rate) {
 190                 runtime->hw.rate_min = chip->cur_rate;
 191                 runtime->hw.rate_max = chip->cur_rate;
 192         }
 193         if (chip->cur_format)
 194                 runtime->hw.formats = (1ULL << chip->cur_format);
 195         mutex_unlock(&opened_mutex);
 196         chip->capture_substream = substream;
 197         return 0;
 198 }
 199
 200 static int atmel_ac97c_playback_close(struct snd_pcm_substream *substream)
 201 {
 202         struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
 203
 204         mutex_lock(&opened_mutex);
 205         chip->opened--;
 206         if (!chip->opened) {
 207                 chip->cur_rate = 0;
 208                 chip->cur_format = 0;
 209         }
 210         mutex_unlock(&opened_mutex);
 211
 212         chip->playback_substream = NULL;
 213
 214         return 0;
 215 }
 216
 217 static int atmel_ac97c_capture_close(struct snd_pcm_substream *substream)
 218 {
 219         struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
 220
 221         mutex_lock(&opened_mutex);
 222         chip->opened--;
 223         if (!chip->opened) {
 224                 chip->cur_rate = 0;
 225                 chip->cur_format = 0;
 226         }
 227         mutex_unlock(&opened_mutex);
 228
 229         chip->capture_substream = NULL;
 230
 231         return 0;
 232 }
 233
 234 static int atmel_ac97c_playback_hw_params(struct snd_pcm_substream *substream,
 235                 struct snd_pcm_hw_params *hw_params)
 236 {
 237         struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
 238         int retval;
 239
 240         retval = snd_pcm_lib_malloc_pages(substream,
 241                                         params_buffer_bytes(hw_params));
 242         if (retval < 0)
 243                 return retval;
 244         /* snd_pcm_lib_malloc_pages returns 1 if buffer is changed. */
 245         if (retval == 1)
 246                 if (test_and_clear_bit(DMA_TX_READY, &chip->flags))
 247                         dw_dma_cyclic_free(chip->dma.tx_chan);
 248
 249         /* Set restrictions to params. */
 250         mutex_lock(&opened_mutex);
 251         chip->cur_rate = params_rate(hw_params);
 252         chip->cur_format = params_format(hw_params);
 253         mutex_unlock(&opened_mutex);
 254
 255         return retval;
 256 }
 257
 258 static int atmel_ac97c_capture_hw_params(struct snd_pcm_substream *substream,
 259                 struct snd_pcm_hw_params *hw_params)
 260 {
 261         struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
 262         int retval;
 263
 264         retval = snd_pcm_lib_malloc_pages(substream,
 265                                         params_buffer_bytes(hw_params));
 266         if (retval < 0)
 267                 return retval;
 268         /* snd_pcm_lib_malloc_pages returns 1 if buffer is changed. */
 269         if (retval == 1)
 270                 if (test_and_clear_bit(DMA_RX_READY, &chip->flags))
 271                         dw_dma_cyclic_free(chip->dma.rx_chan);
 272
 273         /* Set restrictions to params. */
 274         mutex_lock(&opened_mutex);
 275         chip->cur_rate = params_rate(hw_params);
 276         chip->cur_format = params_format(hw_params);
 277         mutex_unlock(&opened_mutex);
 278
 279         return retval;
 280 }
 281
 282 static int atmel_ac97c_playback_hw_free(struct snd_pcm_substream *substream)
 283 {
 284         struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
 285         if (test_and_clear_bit(DMA_TX_READY, &chip->flags))
 286                 dw_dma_cyclic_free(chip->dma.tx_chan);
 287         return snd_pcm_lib_free_pages(substream);
 288 }
 289
 290 static int atmel_ac97c_capture_hw_free(struct snd_pcm_substream *substream)
 291 {
 292         struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
 293         if (test_and_clear_bit(DMA_RX_READY, &chip->flags))
 294                 dw_dma_cyclic_free(chip->dma.rx_chan);
 295         return snd_pcm_lib_free_pages(substream);
 296 }
 297
 298 static int atmel_ac97c_playback_prepare(struct snd_pcm_substream *substream)
 299 {
 300         struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
 301         struct snd_pcm_runtime *runtime = substream->runtime;
 302         unsigned long word = ac97c_readl(chip, OCA);
 303         int retval;
 304
 305         word &= ~(AC97C_CH_MASK(PCM_LEFT) | AC97C_CH_MASK(PCM_RIGHT));
 306
 307         /* assign channels to AC97C channel A */
 308         switch (runtime->channels) {
 309         case 1:
 310                 word |= AC97C_CH_ASSIGN(PCM_LEFT, A);
 311                 break;
 312         case 2:
 313                 word |= AC97C_CH_ASSIGN(PCM_LEFT, A)
 314                         | AC97C_CH_ASSIGN(PCM_RIGHT, A);
 315                 break;
 316         default:
 317                 /* TODO: support more than two channels */
 318                 return -EINVAL;
 319         }
 320         ac97c_writel(chip, OCA, word);
 321
 322         /* configure sample format and size */
 323         word = AC97C_CMR_DMAEN | AC97C_CMR_SIZE_16;
 324
 325         switch (runtime->format) {
 326         case SNDRV_PCM_FORMAT_S16_LE:
 327                 word |= AC97C_CMR_CEM_LITTLE;
 328                 break;
 329         case SNDRV_PCM_FORMAT_S16_BE: /* fall through */
 330                 word &= ~(AC97C_CMR_CEM_LITTLE);
 331                 break;
 332         default:
 333                 word = ac97c_readl(chip, OCA);
 334                 word &= ~(AC97C_CH_MASK(PCM_LEFT) | AC97C_CH_MASK(PCM_RIGHT));
 335                 ac97c_writel(chip, OCA, word);
 336                 return -EINVAL;
 337         }
 338
 339         /* Enable underrun interrupt on channel A */
 340         word |= AC97C_CSR_UNRUN;
 341
 342         ac97c_writel(chip, CAMR, word);
 343
 344         /* Enable channel A event interrupt */
 345         word = ac97c_readl(chip, IMR);
 346         word |= AC97C_SR_CAEVT;
 347         ac97c_writel(chip, IER, word);
 348
 349         /* set variable rate if needed */
 350         if (runtime->rate != 48000) {
 351                 word = ac97c_readl(chip, MR);
 352                 word |= AC97C_MR_VRA;
 353                 ac97c_writel(chip, MR, word);
 354         } else {
 355                 word = ac97c_readl(chip, MR);
 356                 word &= ~(AC97C_MR_VRA);
 357                 ac97c_writel(chip, MR, word);
 358         }
 359
 360         retval = snd_ac97_set_rate(chip->ac97, AC97_PCM_FRONT_DAC_RATE,
 361                         runtime->rate);
 362         if (retval)
 363                 dev_dbg(&chip->pdev->dev, "could not set rate %d Hz\n",
 364                                 runtime->rate);
 365
 366         if (!test_bit(DMA_TX_READY, &chip->flags))
 367                 retval = atmel_ac97c_prepare_dma(chip, substream,
 368                                 DMA_TO_DEVICE);
 369
 370         return retval;
 371 }
 372
 373 static int atmel_ac97c_capture_prepare(struct snd_pcm_substream *substream)
 374 {
 375         struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
 376         struct snd_pcm_runtime *runtime = substream->runtime;
 377         unsigned long word = ac97c_readl(chip, ICA);
 378         int retval;
 379
 380         word &= ~(AC97C_CH_MASK(PCM_LEFT) | AC97C_CH_MASK(PCM_RIGHT));
 381
 382         /* assign channels to AC97C channel A */
 383         switch (runtime->channels) {
 384         case 1:
 385                 word |= AC97C_CH_ASSIGN(PCM_LEFT, A);
 386                 break;
 387         case 2:
 388                 word |= AC97C_CH_ASSIGN(PCM_LEFT, A)
 389                         | AC97C_CH_ASSIGN(PCM_RIGHT, A);
 390                 break;
 391         default:
 392                 /* TODO: support more than two channels */
 393                 return -EINVAL;
 394         }
 395         ac97c_writel(chip, ICA, word);
 396
 397         /* configure sample format and size */
 398         word = AC97C_CMR_DMAEN | AC97C_CMR_SIZE_16;
 399
 400         switch (runtime->format) {
 401         case SNDRV_PCM_FORMAT_S16_LE:
 402                 word |= AC97C_CMR_CEM_LITTLE;
 403                 break;
 404         case SNDRV_PCM_FORMAT_S16_BE: /* fall through */
 405                 word &= ~(AC97C_CMR_CEM_LITTLE);
 406                 break;
 407         default:
 408                 word = ac97c_readl(chip, ICA);
 409                 word &= ~(AC97C_CH_MASK(PCM_LEFT) | AC97C_CH_MASK(PCM_RIGHT));
 410                 ac97c_writel(chip, ICA, word);
 411                 return -EINVAL;
 412         }
 413
 414         /* Enable overrun interrupt on channel A */
 415         word |= AC97C_CSR_OVRUN;
 416
 417         ac97c_writel(chip, CAMR, word);
 418
 419         /* Enable channel A event interrupt */
 420         word = ac97c_readl(chip, IMR);
 421         word |= AC97C_SR_CAEVT;
 422         ac97c_writel(chip, IER, word);
 423
 424         /* set variable rate if needed */
 425         if (runtime->rate != 48000) {
 426                 word = ac97c_readl(chip, MR);
 427                 word |= AC97C_MR_VRA;
 428                 ac97c_writel(chip, MR, word);
 429         } else {
 430                 word = ac97c_readl(chip, MR);
 431                 word &= ~(AC97C_MR_VRA);
 432                 ac97c_writel(chip, MR, word);
 433         }
 434
 435         retval = snd_ac97_set_rate(chip->ac97, AC97_PCM_LR_ADC_RATE,
 436                         runtime->rate);
 437         if (retval)
 438                 dev_dbg(&chip->pdev->dev, "could not set rate %d Hz\n",
 439                                 runtime->rate);
 440
 441         if (!test_bit(DMA_RX_READY, &chip->flags))
 442                 retval = atmel_ac97c_prepare_dma(chip, substream,
 443                                 DMA_FROM_DEVICE);
 444
 445         return retval;
 446 }
 447
 448 static int
 449 atmel_ac97c_playback_trigger(struct snd_pcm_substream *substream, int cmd)
 450 {
 451         struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
 452         unsigned long camr;
 453         int retval = 0;
 454
 455         camr = ac97c_readl(chip, CAMR);
 456
 457         switch (cmd) {
 458         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: /* fall through */
 459         case SNDRV_PCM_TRIGGER_RESUME: /* fall through */
 460         case SNDRV_PCM_TRIGGER_START:
 461                 retval = dw_dma_cyclic_start(chip->dma.tx_chan);
 462                 if (retval)
 463                         goto out;
 464                 camr |= AC97C_CMR_CENA;
 465                 break;
 466         case SNDRV_PCM_TRIGGER_PAUSE_PUSH: /* fall through */
 467         case SNDRV_PCM_TRIGGER_SUSPEND: /* fall through */
 468         case SNDRV_PCM_TRIGGER_STOP:
 469                 dw_dma_cyclic_stop(chip->dma.tx_chan);
 470                 if (chip->opened <= 1)
 471                         camr &= ~AC97C_CMR_CENA;
 472                 break;
 473         default:
 474                 retval = -EINVAL;
 475                 goto out;
 476         }
 477
 478         ac97c_writel(chip, CAMR, camr);
 479 out:
 480         return retval;
 481 }
 482
 483 static int
 484 atmel_ac97c_capture_trigger(struct snd_pcm_substream *substream, int cmd)
 485 {
 486         struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
 487         unsigned long camr;
 488         int retval = 0;
 489
 490         camr = ac97c_readl(chip, CAMR);
 491
 492         switch (cmd) {
 493         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: /* fall through */
 494         case SNDRV_PCM_TRIGGER_RESUME: /* fall through */
 495         case SNDRV_PCM_TRIGGER_START:
 496                 retval = dw_dma_cyclic_start(chip->dma.rx_chan);
 497                 if (retval)
 498                         goto out;
 499                 camr |= AC97C_CMR_CENA;
 500                 break;
 501         case SNDRV_PCM_TRIGGER_PAUSE_PUSH: /* fall through */
 502         case SNDRV_PCM_TRIGGER_SUSPEND: /* fall through */
 503         case SNDRV_PCM_TRIGGER_STOP:
 504                 dw_dma_cyclic_stop(chip->dma.rx_chan);
 505                 if (chip->opened <= 1)
 506                         camr &= ~AC97C_CMR_CENA;
 507                 break;
 508         default:
 509                 retval = -EINVAL;
 510                 break;
 511         }
 512
 513         ac97c_writel(chip, CAMR, camr);
 514 out:
 515         return retval;
 516 }
 517
 518 static snd_pcm_uframes_t
 519 atmel_ac97c_playback_pointer(struct snd_pcm_substream *substream)
 520 {
 521         struct atmel_ac97c      *chip = snd_pcm_substream_chip(substream);
 522         struct snd_pcm_runtime  *runtime = substream->runtime;
 523         snd_pcm_uframes_t       frames;
 524         unsigned long           bytes;
 525
 526         bytes = dw_dma_get_src_addr(chip->dma.tx_chan);
 527         bytes -= runtime->dma_addr;
 528
 529         frames = bytes_to_frames(runtime, bytes);
 530         if (frames >= runtime->buffer_size)
 531                 frames -= runtime->buffer_size;
 532         return frames;
 533 }
 534
 535 static snd_pcm_uframes_t
 536 atmel_ac97c_capture_pointer(struct snd_pcm_substream *substream)
 537 {
 538         struct atmel_ac97c      *chip = snd_pcm_substream_chip(substream);
 539         struct snd_pcm_runtime  *runtime = substream->runtime;
 540         snd_pcm_uframes_t       frames;
 541         unsigned long           bytes;
 542
 543         bytes = dw_dma_get_dst_addr(chip->dma.rx_chan);
 544         bytes -= runtime->dma_addr;
 545
 546         frames = bytes_to_frames(runtime, bytes);
 547         if (frames >= runtime->buffer_size)
 548                 frames -= runtime->buffer_size;
 549         return frames;
 550 }
 551
 552 static struct snd_pcm_ops atmel_ac97_playback_ops = {
 553         .open           = atmel_ac97c_playback_open,
 554         .close          = atmel_ac97c_playback_close,
 555         .ioctl          = snd_pcm_lib_ioctl,
 556         .hw_params      = atmel_ac97c_playback_hw_params,
 557         .hw_free        = atmel_ac97c_playback_hw_free,
 558         .prepare        = atmel_ac97c_playback_prepare,
 559         .trigger        = atmel_ac97c_playback_trigger,
 560         .pointer        = atmel_ac97c_playback_pointer,
 561 };
 562
 563 static struct snd_pcm_ops atmel_ac97_capture_ops = {
 564         .open           = atmel_ac97c_capture_open,
 565         .close          = atmel_ac97c_capture_close,
 566         .ioctl          = snd_pcm_lib_ioctl,
 567         .hw_params      = atmel_ac97c_capture_hw_params,
 568         .hw_free        = atmel_ac97c_capture_hw_free,
 569         .prepare        = atmel_ac97c_capture_prepare,
 570         .trigger        = atmel_ac97c_capture_trigger,
 571         .pointer        = atmel_ac97c_capture_pointer,
 572 };
 573
 574 static irqreturn_t atmel_ac97c_interrupt(int irq, void *dev)
 575 {
 576         struct atmel_ac97c      *chip  = (struct atmel_ac97c *)dev;
 577         irqreturn_t             retval = IRQ_NONE;
 578         u32                     sr     = ac97c_readl(chip, SR);
 579         u32                     casr   = ac97c_readl(chip, CASR);
 580         u32                     cosr   = ac97c_readl(chip, COSR);
 581
 582         if (sr & AC97C_SR_CAEVT) {
 583                 dev_info(&chip->pdev->dev, "channel A event%s%s%s%s%s%s\n",
 584                                 casr & AC97C_CSR_OVRUN   ? " OVRUN"   : "",
 585                                 casr & AC97C_CSR_RXRDY   ? " RXRDY"   : "",
 586                                 casr & AC97C_CSR_UNRUN   ? " UNRUN"   : "",
 587                                 casr & AC97C_CSR_TXEMPTY ? " TXEMPTY" : "",
 588                                 casr & AC97C_CSR_TXRDY   ? " TXRDY"   : "",
 589                                 !casr                    ? " NONE"    : "");
 590                 retval = IRQ_HANDLED;
 591         }
 592
 593         if (sr & AC97C_SR_COEVT) {
 594                 dev_info(&chip->pdev->dev, "codec channel event%s%s%s%s%s\n",
 595                                 cosr & AC97C_CSR_OVRUN   ? " OVRUN"   : "",
 596                                 cosr & AC97C_CSR_RXRDY   ? " RXRDY"   : "",
 597                                 cosr & AC97C_CSR_TXEMPTY ? " TXEMPTY" : "",
 598                                 cosr & AC97C_CSR_TXRDY   ? " TXRDY"   : "",
 599                                 !cosr                    ? " NONE"    : "");
 600                 retval = IRQ_HANDLED;
 601         }
 602
 603         if (retval == IRQ_NONE) {
 604                 dev_err(&chip->pdev->dev, "spurious interrupt sr 0x%08x "
 605                                 "casr 0x%08x cosr 0x%08x\n", sr, casr, cosr);
 606         }
 607
 608         return retval;
 609 }
 610
 611 static int __devinit atmel_ac97c_pcm_new(struct atmel_ac97c *chip)
 612 {
 613         struct snd_pcm          *pcm;
 614         struct snd_pcm_hardware hw = atmel_ac97c_hw;
 615         int                     capture, playback, retval;
 616
 617         capture = test_bit(DMA_RX_CHAN_PRESENT, &chip->flags);
 618         playback = test_bit(DMA_TX_CHAN_PRESENT, &chip->flags);
 619
 620         retval = snd_pcm_new(chip->card, chip->card->shortname,
 621                         chip->pdev->id, playback, capture, &pcm);
 622         if (retval)
 623                 return retval;
 624
 625         if (capture)
 626                 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
 627                                 &atmel_ac97_capture_ops);
 628         if (playback)
 629                 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
 630                                 &atmel_ac97_playback_ops);
 631
 632         retval = snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
 633                         &chip->pdev->dev, hw.periods_min * hw.period_bytes_min,
 634                         hw.buffer_bytes_max);
 635         if (retval)
 636                 return retval;
 637
 638         pcm->private_data = chip;
 639         pcm->info_flags = 0;
 640         strcpy(pcm->name, chip->card->shortname);
 641         chip->pcm = pcm;
 642
 643         return 0;
 644 }
 645
 646 static int atmel_ac97c_mixer_new(struct atmel_ac97c *chip)
 647 {
 648         struct snd_ac97_template template;
 649         memset(&template, 0, sizeof(template));
 650         template.private_data = chip;
 651         return snd_ac97_mixer(chip->ac97_bus, &template, &chip->ac97);
 652 }
 653
 654 static void atmel_ac97c_write(struct snd_ac97 *ac97, unsigned short reg,
 655                 unsigned short val)
 656 {
 657         struct atmel_ac97c *chip = get_chip(ac97);
 658         unsigned long word;
 659         int timeout = 40;
 660
 661         word = (reg & 0x7f) << 16 | val;
 662
 663         do {
 664                 if (ac97c_readl(chip, COSR) & AC97C_CSR_TXRDY) {
 665                         ac97c_writel(chip, COTHR, word);
 666                         return;
 667                 }
 668                 udelay(1);
 669         } while (--timeout);
 670
 671         dev_dbg(&chip->pdev->dev, "codec write timeout\n");
 672 }
 673
 674 static unsigned short atmel_ac97c_read(struct snd_ac97 *ac97,
 675                 unsigned short reg)
 676 {
 677         struct atmel_ac97c *chip = get_chip(ac97);
 678         unsigned long word;
 679         int timeout = 40;
 680         int write = 10;
 681
 682         word = (0x80 | (reg & 0x7f)) << 16;
 683
 684         if ((ac97c_readl(chip, COSR) & AC97C_CSR_RXRDY) != 0)
 685                 ac97c_readl(chip, CORHR);
 686
 687 retry_write:
 688         timeout = 40;
 689
 690         do {
 691                 if ((ac97c_readl(chip, COSR) & AC97C_CSR_TXRDY) != 0) {
 692                         ac97c_writel(chip, COTHR, word);
 693                         goto read_reg;
 694                 }
 695                 udelay(10);
 696         } while (--timeout);
 697
 698         if (!--write)
 699                 goto timed_out;
 700         goto retry_write;
 701
 702 read_reg:
 703         do {
 704                 if ((ac97c_readl(chip, COSR) & AC97C_CSR_RXRDY) != 0) {
 705                         unsigned short val = ac97c_readl(chip, CORHR);
 706                         return val;
 707                 }
 708                 udelay(10);
 709         } while (--timeout);
 710
 711         if (!--write)
 712                 goto timed_out;
 713         goto retry_write;
 714
 715 timed_out:
 716         dev_dbg(&chip->pdev->dev, "codec read timeout\n");
 717         return 0xffff;
 718 }
 719
 720 static bool filter(struct dma_chan *chan, void *slave)
 721 {
 722         struct dw_dma_slave *dws = slave;
 723
 724         if (dws->dma_dev == chan->device->dev) {
 725                 chan->private = dws;
 726                 return true;
 727         } else
 728                 return false;
 729 }
 730
 731 static void atmel_ac97c_reset(struct atmel_ac97c *chip)
 732 {
 733         ac97c_writel(chip, MR, AC97C_MR_WRST);
 734
 735         if (gpio_is_valid(chip->reset_pin)) {
 736                 gpio_set_value(chip->reset_pin, 0);
 737                 /* AC97 v2.2 specifications says minimum 1 us. */
 738                 udelay(10);
 739                 gpio_set_value(chip->reset_pin, 1);
 740         }
 741
 742         udelay(1);
 743         ac97c_writel(chip, MR, AC97C_MR_ENA);
 744 }
 745
 746 static int __devinit atmel_ac97c_probe(struct platform_device *pdev)
 747 {
 748         struct snd_card                 *card;
 749         struct atmel_ac97c              *chip;
 750         struct resource                 *regs;
 751         struct ac97c_platform_data      *pdata;
 752         struct clk                      *pclk;
 753         static struct snd_ac97_bus_ops  ops = {
 754                 .write  = atmel_ac97c_write,
 755                 .read   = atmel_ac97c_read,
 756         };
 757         int                             retval;
 758         int                             irq;
 759
 760         regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 761         if (!regs) {
 762                 dev_dbg(&pdev->dev, "no memory resource\n");
 763                 return -ENXIO;
 764         }
 765
 766         pdata = pdev->dev.platform_data;
 767         if (!pdata) {
 768                 dev_dbg(&pdev->dev, "no platform data\n");
 769                 return -ENXIO;
 770         }
 771
 772         irq = platform_get_irq(pdev, 0);
 773         if (irq < 0) {
 774                 dev_dbg(&pdev->dev, "could not get irq\n");
 775                 return -ENXIO;
 776         }
 777
 778         pclk = clk_get(&pdev->dev, "pclk");
 779         if (IS_ERR(pclk)) {
 780                 dev_dbg(&pdev->dev, "no peripheral clock\n");
 781                 return PTR_ERR(pclk);
 782         }
 783         clk_enable(pclk);
 784
 785         retval = snd_card_create(SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
 786                         THIS_MODULE, sizeof(struct atmel_ac97c), &card);
 787         if (retval) {
 788                 dev_dbg(&pdev->dev, "could not create sound card device\n");
 789                 goto err_snd_card_new;
 790         }
 791
 792         chip = get_chip(card);
 793
 794         retval = request_irq(irq, atmel_ac97c_interrupt, 0, "AC97C", chip);
 795         if (retval) {
 796                 dev_dbg(&pdev->dev, "unable to request irq %d\n", irq);
 797                 goto err_request_irq;
 798         }
 799         chip->irq = irq;
 800
 801         spin_lock_init(&chip->lock);
 802
 803         strcpy(card->driver, "Atmel AC97C");
 804         strcpy(card->shortname, "Atmel AC97C");
 805         sprintf(card->longname, "Atmel AC97 controller");
 806
 807         chip->card = card;
 808         chip->pclk = pclk;
 809         chip->pdev = pdev;
 810         chip->regs = ioremap(regs->start, regs->end - regs->start + 1);
 811
 812         if (!chip->regs) {
 813                 dev_dbg(&pdev->dev, "could not remap register memory\n");
 814                 goto err_ioremap;
 815         }
 816
 817         if (gpio_is_valid(pdata->reset_pin)) {
 818                 if (gpio_request(pdata->reset_pin, "reset_pin")) {
 819                         dev_dbg(&pdev->dev, "reset pin not available\n");
 820                         chip->reset_pin = -ENODEV;
 821                 } else {
 822                         gpio_direction_output(pdata->reset_pin, 1);
 823                         chip->reset_pin = pdata->reset_pin;
 824                 }
 825         }
 826
 827         snd_card_set_dev(card, &pdev->dev);
 828
 829         /* Enable overrun interrupt from codec channel */
 830         ac97c_writel(chip, COMR, AC97C_CSR_OVRUN);
 831         ac97c_writel(chip, IER, ac97c_readl(chip, IMR) | AC97C_SR_COEVT);
 832
 833         retval = snd_ac97_bus(card, 0, &ops, chip, &chip->ac97_bus);
 834         if (retval) {
 835                 dev_dbg(&pdev->dev, "could not register on ac97 bus\n");
 836                 goto err_ac97_bus;
 837         }
 838
 839         atmel_ac97c_reset(chip);
 840
 841         retval = atmel_ac97c_mixer_new(chip);
 842         if (retval) {
 843                 dev_dbg(&pdev->dev, "could not register ac97 mixer\n");
 844                 goto err_ac97_bus;
 845         }
 846
 847         if (pdata->rx_dws.dma_dev) {
 848                 struct dw_dma_slave *dws = &pdata->rx_dws;
 849                 dma_cap_mask_t mask;
 850
 851                 dws->rx_reg = regs->start + AC97C_CARHR + 2;
 852
 853                 dma_cap_zero(mask);
 854                 dma_cap_set(DMA_SLAVE, mask);
 855
 856                 chip->dma.rx_chan = dma_request_channel(mask, filter, dws);
 857
 858                 dev_info(&chip->pdev->dev, "using %s for DMA RX\n",
 859                                         chip->dma.rx_chan->dev->device.bus_id);
 860                 set_bit(DMA_RX_CHAN_PRESENT, &chip->flags);
 861         }
 862
 863         if (pdata->tx_dws.dma_dev) {
 864                 struct dw_dma_slave *dws = &pdata->tx_dws;
 865                 dma_cap_mask_t mask;
 866
 867                 dws->tx_reg = regs->start + AC97C_CATHR + 2;
 868
 869                 dma_cap_zero(mask);
 870                 dma_cap_set(DMA_SLAVE, mask);
 871
 872                 chip->dma.tx_chan = dma_request_channel(mask, filter, dws);
 873
 874                 dev_info(&chip->pdev->dev, "using %s for DMA TX\n",
 875                                         chip->dma.tx_chan->dev->device.bus_id);
 876                 set_bit(DMA_TX_CHAN_PRESENT, &chip->flags);
 877         }
 878
 879         if (!test_bit(DMA_RX_CHAN_PRESENT, &chip->flags) &&
 880                         !test_bit(DMA_TX_CHAN_PRESENT, &chip->flags)) {
 881                 dev_dbg(&pdev->dev, "DMA not available\n");
 882                 retval = -ENODEV;
 883                 goto err_dma;
 884         }
 885
 886         retval = atmel_ac97c_pcm_new(chip);
 887         if (retval) {
 888                 dev_dbg(&pdev->dev, "could not register ac97 pcm device\n");
 889                 goto err_dma;
 890         }
 891
 892         retval = snd_card_register(card);
 893         if (retval) {
 894                 dev_dbg(&pdev->dev, "could not register sound card\n");
 895                 goto err_dma;
 896         }
 897
 898         platform_set_drvdata(pdev, card);
 899
 900         dev_info(&pdev->dev, "Atmel AC97 controller at 0x%p\n",
 901                         chip->regs);
 902
 903         return 0;
 904
 905 err_dma:
 906         if (test_bit(DMA_RX_CHAN_PRESENT, &chip->flags))
 907                 dma_release_channel(chip->dma.rx_chan);
 908         if (test_bit(DMA_TX_CHAN_PRESENT, &chip->flags))
 909                 dma_release_channel(chip->dma.tx_chan);
 910         clear_bit(DMA_RX_CHAN_PRESENT, &chip->flags);
 911         clear_bit(DMA_TX_CHAN_PRESENT, &chip->flags);
 912         chip->dma.rx_chan = NULL;
 913         chip->dma.tx_chan = NULL;
 914 err_ac97_bus:
 915         snd_card_set_dev(card, NULL);
 916
 917         if (gpio_is_valid(chip->reset_pin))
 918                 gpio_free(chip->reset_pin);
 919
 920         iounmap(chip->regs);
 921 err_ioremap:
 922         free_irq(irq, chip);
 923 err_request_irq:
 924         snd_card_free(card);
 925 err_snd_card_new:
 926         clk_disable(pclk);
 927         clk_put(pclk);
 928         return retval;
 929 }
 930
 931 #ifdef CONFIG_PM
 932 static int atmel_ac97c_suspend(struct platform_device *pdev, pm_message_t msg)
 933 {
 934         struct snd_card *card = platform_get_drvdata(pdev);
 935         struct atmel_ac97c *chip = card->private_data;
 936
 937         if (test_bit(DMA_RX_READY, &chip->flags))
 938                 dw_dma_cyclic_stop(chip->dma.rx_chan);
 939         if (test_bit(DMA_TX_READY, &chip->flags))
 940                 dw_dma_cyclic_stop(chip->dma.tx_chan);
 941         clk_disable(chip->pclk);
 942
 943         return 0;
 944 }
 945
 946 static int atmel_ac97c_resume(struct platform_device *pdev)
 947 {
 948         struct snd_card *card = platform_get_drvdata(pdev);
 949         struct atmel_ac97c *chip = card->private_data;
 950
 951         clk_enable(chip->pclk);
 952         if (test_bit(DMA_RX_READY, &chip->flags))
 953                 dw_dma_cyclic_start(chip->dma.rx_chan);
 954         if (test_bit(DMA_TX_READY, &chip->flags))
 955                 dw_dma_cyclic_start(chip->dma.tx_chan);
 956
 957         return 0;
 958 }
 959 #else
 960 #define atmel_ac97c_suspend NULL
 961 #define atmel_ac97c_resume NULL
 962 #endif
 963
 964 static int __devexit atmel_ac97c_remove(struct platform_device *pdev)
 965 {
 966         struct snd_card *card = platform_get_drvdata(pdev);
 967         struct atmel_ac97c *chip = get_chip(card);
 968
 969         if (gpio_is_valid(chip->reset_pin))
 970                 gpio_free(chip->reset_pin);
 971
 972         clk_disable(chip->pclk);
 973         clk_put(chip->pclk);
 974         iounmap(chip->regs);
 975         free_irq(chip->irq, chip);
 976
 977         if (test_bit(DMA_RX_CHAN_PRESENT, &chip->flags))
 978                 dma_release_channel(chip->dma.rx_chan);
 979         if (test_bit(DMA_TX_CHAN_PRESENT, &chip->flags))
 980                 dma_release_channel(chip->dma.tx_chan);
 981         clear_bit(DMA_RX_CHAN_PRESENT, &chip->flags);
 982         clear_bit(DMA_TX_CHAN_PRESENT, &chip->flags);
 983         chip->dma.rx_chan = NULL;
 984         chip->dma.tx_chan = NULL;
 985
 986         snd_card_set_dev(card, NULL);
 987         snd_card_free(card);
 988
 989         platform_set_drvdata(pdev, NULL);
 990
 991         return 0;
 992 }
 993
 994 static struct platform_driver atmel_ac97c_driver = {
 995         .remove         = __devexit_p(atmel_ac97c_remove),
 996         .driver         = {
 997                 .name   = "atmel_ac97c",
 998         },
 999         .suspend        = atmel_ac97c_suspend,
1000         .resume         = atmel_ac97c_resume,
1001 };
1002
1003 static int __init atmel_ac97c_init(void)
1004 {
1005         return platform_driver_probe(&atmel_ac97c_driver,
1006                         atmel_ac97c_probe);
1007 }
1008 module_init(atmel_ac97c_init);
1009
1010 static void __exit atmel_ac97c_exit(void)
1011 {
1012         platform_driver_unregister(&atmel_ac97c_driver);
1013 }
1014 module_exit(atmel_ac97c_exit);
1015
1016 MODULE_LICENSE("GPL");
1017 MODULE_DESCRIPTION("Driver for Atmel AC97 controller");
1018 MODULE_AUTHOR("Hans-Christian Egtvedt <hans-christian.egtvedt@atmel.com>");