Version:  2.0.40 2.2.26 2.4.37 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2

Linux/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/atmel_pdc.h>
 17 #include <linux/init.h>
 18 #include <linux/interrupt.h>
 19 #include <linux/module.h>
 20 #include <linux/platform_device.h>
 21 #include <linux/mutex.h>
 22 #include <linux/gpio.h>
 23 #include <linux/types.h>
 24 #include <linux/io.h>
 25 #include <linux/of.h>
 26 #include <linux/of_gpio.h>
 27 #include <linux/of_device.h>
 28 
 29 #include <sound/core.h>
 30 #include <sound/initval.h>
 31 #include <sound/pcm.h>
 32 #include <sound/pcm_params.h>
 33 #include <sound/ac97_codec.h>
 34 #include <sound/atmel-ac97c.h>
 35 #include <sound/memalloc.h>
 36 
 37 #include <linux/platform_data/dma-dw.h>
 38 #include <linux/dma/dw.h>
 39 
 40 #ifdef CONFIG_AVR32
 41 #include <mach/cpu.h>
 42 #else
 43 #define cpu_is_at32ap7000() 0
 44 #endif
 45 
 46 #include "ac97c.h"
 47 
 48 enum {
 49         DMA_TX_READY = 0,
 50         DMA_RX_READY,
 51         DMA_TX_CHAN_PRESENT,
 52         DMA_RX_CHAN_PRESENT,
 53 };
 54 
 55 /* Serialize access to opened variable */
 56 static DEFINE_MUTEX(opened_mutex);
 57 
 58 struct atmel_ac97c_dma {
 59         struct dma_chan                 *rx_chan;
 60         struct dma_chan                 *tx_chan;
 61 };
 62 
 63 struct atmel_ac97c {
 64         struct clk                      *pclk;
 65         struct platform_device          *pdev;
 66         struct atmel_ac97c_dma          dma;
 67 
 68         struct snd_pcm_substream        *playback_substream;
 69         struct snd_pcm_substream        *capture_substream;
 70         struct snd_card                 *card;
 71         struct snd_pcm                  *pcm;
 72         struct snd_ac97                 *ac97;
 73         struct snd_ac97_bus             *ac97_bus;
 74 
 75         u64                             cur_format;
 76         unsigned int                    cur_rate;
 77         unsigned long                   flags;
 78         int                             playback_period, capture_period;
 79         /* Serialize access to opened variable */
 80         spinlock_t                      lock;
 81         void __iomem                    *regs;
 82         int                             irq;
 83         int                             opened;
 84         int                             reset_pin;
 85 };
 86 
 87 #define get_chip(card) ((struct atmel_ac97c *)(card)->private_data)
 88 
 89 #define ac97c_writel(chip, reg, val)                    \
 90         __raw_writel((val), (chip)->regs + AC97C_##reg)
 91 #define ac97c_readl(chip, reg)                          \
 92         __raw_readl((chip)->regs + AC97C_##reg)
 93 
 94 /* This function is called by the DMA driver. */
 95 static void atmel_ac97c_dma_playback_period_done(void *arg)
 96 {
 97         struct atmel_ac97c *chip = arg;
 98         snd_pcm_period_elapsed(chip->playback_substream);
 99 }
100 
101 static void atmel_ac97c_dma_capture_period_done(void *arg)
102 {
103         struct atmel_ac97c *chip = arg;
104         snd_pcm_period_elapsed(chip->capture_substream);
105 }
106 
107 static int atmel_ac97c_prepare_dma(struct atmel_ac97c *chip,
108                 struct snd_pcm_substream *substream,
109                 enum dma_transfer_direction direction)
110 {
111         struct dma_chan                 *chan;
112         struct dw_cyclic_desc           *cdesc;
113         struct snd_pcm_runtime          *runtime = substream->runtime;
114         unsigned long                   buffer_len, period_len;
115 
116         /*
117          * We don't do DMA on "complex" transfers, i.e. with
118          * non-halfword-aligned buffers or lengths.
119          */
120         if (runtime->dma_addr & 1 || runtime->buffer_size & 1) {
121                 dev_dbg(&chip->pdev->dev, "too complex transfer\n");
122                 return -EINVAL;
123         }
124 
125         if (direction == DMA_MEM_TO_DEV)
126                 chan = chip->dma.tx_chan;
127         else
128                 chan = chip->dma.rx_chan;
129 
130         buffer_len = frames_to_bytes(runtime, runtime->buffer_size);
131         period_len = frames_to_bytes(runtime, runtime->period_size);
132 
133         cdesc = dw_dma_cyclic_prep(chan, runtime->dma_addr, buffer_len,
134                         period_len, direction);
135         if (IS_ERR(cdesc)) {
136                 dev_dbg(&chip->pdev->dev, "could not prepare cyclic DMA\n");
137                 return PTR_ERR(cdesc);
138         }
139 
140         if (direction == DMA_MEM_TO_DEV) {
141                 cdesc->period_callback = atmel_ac97c_dma_playback_period_done;
142                 set_bit(DMA_TX_READY, &chip->flags);
143         } else {
144                 cdesc->period_callback = atmel_ac97c_dma_capture_period_done;
145                 set_bit(DMA_RX_READY, &chip->flags);
146         }
147 
148         cdesc->period_callback_param = chip;
149 
150         return 0;
151 }
152 
153 static struct snd_pcm_hardware atmel_ac97c_hw = {
154         .info                   = (SNDRV_PCM_INFO_MMAP
155                                   | SNDRV_PCM_INFO_MMAP_VALID
156                                   | SNDRV_PCM_INFO_INTERLEAVED
157                                   | SNDRV_PCM_INFO_BLOCK_TRANSFER
158                                   | SNDRV_PCM_INFO_JOINT_DUPLEX
159                                   | SNDRV_PCM_INFO_RESUME
160                                   | SNDRV_PCM_INFO_PAUSE),
161         .formats                = (SNDRV_PCM_FMTBIT_S16_BE
162                                   | SNDRV_PCM_FMTBIT_S16_LE),
163         .rates                  = (SNDRV_PCM_RATE_CONTINUOUS),
164         .rate_min               = 4000,
165         .rate_max               = 48000,
166         .channels_min           = 1,
167         .channels_max           = 2,
168         .buffer_bytes_max       = 2 * 2 * 64 * 2048,
169         .period_bytes_min       = 4096,
170         .period_bytes_max       = 4096,
171         .periods_min            = 6,
172         .periods_max            = 64,
173 };
174 
175 static int atmel_ac97c_playback_open(struct snd_pcm_substream *substream)
176 {
177         struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
178         struct snd_pcm_runtime *runtime = substream->runtime;
179 
180         mutex_lock(&opened_mutex);
181         chip->opened++;
182         runtime->hw = atmel_ac97c_hw;
183         if (chip->cur_rate) {
184                 runtime->hw.rate_min = chip->cur_rate;
185                 runtime->hw.rate_max = chip->cur_rate;
186         }
187         if (chip->cur_format)
188                 runtime->hw.formats = pcm_format_to_bits(chip->cur_format);
189         mutex_unlock(&opened_mutex);
190         chip->playback_substream = substream;
191         return 0;
192 }
193 
194 static int atmel_ac97c_capture_open(struct snd_pcm_substream *substream)
195 {
196         struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
197         struct snd_pcm_runtime *runtime = substream->runtime;
198 
199         mutex_lock(&opened_mutex);
200         chip->opened++;
201         runtime->hw = atmel_ac97c_hw;
202         if (chip->cur_rate) {
203                 runtime->hw.rate_min = chip->cur_rate;
204                 runtime->hw.rate_max = chip->cur_rate;
205         }
206         if (chip->cur_format)
207                 runtime->hw.formats = pcm_format_to_bits(chip->cur_format);
208         mutex_unlock(&opened_mutex);
209         chip->capture_substream = substream;
210         return 0;
211 }
212 
213 static int atmel_ac97c_playback_close(struct snd_pcm_substream *substream)
214 {
215         struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
216 
217         mutex_lock(&opened_mutex);
218         chip->opened--;
219         if (!chip->opened) {
220                 chip->cur_rate = 0;
221                 chip->cur_format = 0;
222         }
223         mutex_unlock(&opened_mutex);
224 
225         chip->playback_substream = NULL;
226 
227         return 0;
228 }
229 
230 static int atmel_ac97c_capture_close(struct snd_pcm_substream *substream)
231 {
232         struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
233 
234         mutex_lock(&opened_mutex);
235         chip->opened--;
236         if (!chip->opened) {
237                 chip->cur_rate = 0;
238                 chip->cur_format = 0;
239         }
240         mutex_unlock(&opened_mutex);
241 
242         chip->capture_substream = NULL;
243 
244         return 0;
245 }
246 
247 static int atmel_ac97c_playback_hw_params(struct snd_pcm_substream *substream,
248                 struct snd_pcm_hw_params *hw_params)
249 {
250         struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
251         int retval;
252 
253         retval = snd_pcm_lib_malloc_pages(substream,
254                                         params_buffer_bytes(hw_params));
255         if (retval < 0)
256                 return retval;
257         /* snd_pcm_lib_malloc_pages returns 1 if buffer is changed. */
258         if (cpu_is_at32ap7000()) {
259                 /* snd_pcm_lib_malloc_pages returns 1 if buffer is changed. */
260                 if (retval == 1)
261                         if (test_and_clear_bit(DMA_TX_READY, &chip->flags))
262                                 dw_dma_cyclic_free(chip->dma.tx_chan);
263         }
264         /* Set restrictions to params. */
265         mutex_lock(&opened_mutex);
266         chip->cur_rate = params_rate(hw_params);
267         chip->cur_format = params_format(hw_params);
268         mutex_unlock(&opened_mutex);
269 
270         return retval;
271 }
272 
273 static int atmel_ac97c_capture_hw_params(struct snd_pcm_substream *substream,
274                 struct snd_pcm_hw_params *hw_params)
275 {
276         struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
277         int retval;
278 
279         retval = snd_pcm_lib_malloc_pages(substream,
280                                         params_buffer_bytes(hw_params));
281         if (retval < 0)
282                 return retval;
283         /* snd_pcm_lib_malloc_pages returns 1 if buffer is changed. */
284         if (cpu_is_at32ap7000() && retval == 1)
285                 if (test_and_clear_bit(DMA_RX_READY, &chip->flags))
286                         dw_dma_cyclic_free(chip->dma.rx_chan);
287 
288         /* Set restrictions to params. */
289         mutex_lock(&opened_mutex);
290         chip->cur_rate = params_rate(hw_params);
291         chip->cur_format = params_format(hw_params);
292         mutex_unlock(&opened_mutex);
293 
294         return retval;
295 }
296 
297 static int atmel_ac97c_playback_hw_free(struct snd_pcm_substream *substream)
298 {
299         struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
300         if (cpu_is_at32ap7000()) {
301                 if (test_and_clear_bit(DMA_TX_READY, &chip->flags))
302                         dw_dma_cyclic_free(chip->dma.tx_chan);
303         }
304         return snd_pcm_lib_free_pages(substream);
305 }
306 
307 static int atmel_ac97c_capture_hw_free(struct snd_pcm_substream *substream)
308 {
309         struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
310         if (cpu_is_at32ap7000()) {
311                 if (test_and_clear_bit(DMA_RX_READY, &chip->flags))
312                         dw_dma_cyclic_free(chip->dma.rx_chan);
313         }
314         return snd_pcm_lib_free_pages(substream);
315 }
316 
317 static int atmel_ac97c_playback_prepare(struct snd_pcm_substream *substream)
318 {
319         struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
320         struct snd_pcm_runtime *runtime = substream->runtime;
321         int block_size = frames_to_bytes(runtime, runtime->period_size);
322         unsigned long word = ac97c_readl(chip, OCA);
323         int retval;
324 
325         chip->playback_period = 0;
326         word &= ~(AC97C_CH_MASK(PCM_LEFT) | AC97C_CH_MASK(PCM_RIGHT));
327 
328         /* assign channels to AC97C channel A */
329         switch (runtime->channels) {
330         case 1:
331                 word |= AC97C_CH_ASSIGN(PCM_LEFT, A);
332                 break;
333         case 2:
334                 word |= AC97C_CH_ASSIGN(PCM_LEFT, A)
335                         | AC97C_CH_ASSIGN(PCM_RIGHT, A);
336                 break;
337         default:
338                 /* TODO: support more than two channels */
339                 return -EINVAL;
340         }
341         ac97c_writel(chip, OCA, word);
342 
343         /* configure sample format and size */
344         word = ac97c_readl(chip, CAMR);
345         if (chip->opened <= 1)
346                 word = AC97C_CMR_DMAEN | AC97C_CMR_SIZE_16;
347         else
348                 word |= AC97C_CMR_DMAEN | AC97C_CMR_SIZE_16;
349 
350         switch (runtime->format) {
351         case SNDRV_PCM_FORMAT_S16_LE:
352                 if (cpu_is_at32ap7000())
353                         word |= AC97C_CMR_CEM_LITTLE;
354                 break;
355         case SNDRV_PCM_FORMAT_S16_BE: /* fall through */
356                 word &= ~(AC97C_CMR_CEM_LITTLE);
357                 break;
358         default:
359                 word = ac97c_readl(chip, OCA);
360                 word &= ~(AC97C_CH_MASK(PCM_LEFT) | AC97C_CH_MASK(PCM_RIGHT));
361                 ac97c_writel(chip, OCA, word);
362                 return -EINVAL;
363         }
364 
365         /* Enable underrun interrupt on channel A */
366         word |= AC97C_CSR_UNRUN;
367 
368         ac97c_writel(chip, CAMR, word);
369 
370         /* Enable channel A event interrupt */
371         word = ac97c_readl(chip, IMR);
372         word |= AC97C_SR_CAEVT;
373         ac97c_writel(chip, IER, word);
374 
375         /* set variable rate if needed */
376         if (runtime->rate != 48000) {
377                 word = ac97c_readl(chip, MR);
378                 word |= AC97C_MR_VRA;
379                 ac97c_writel(chip, MR, word);
380         } else {
381                 word = ac97c_readl(chip, MR);
382                 word &= ~(AC97C_MR_VRA);
383                 ac97c_writel(chip, MR, word);
384         }
385 
386         retval = snd_ac97_set_rate(chip->ac97, AC97_PCM_FRONT_DAC_RATE,
387                         runtime->rate);
388         if (retval)
389                 dev_dbg(&chip->pdev->dev, "could not set rate %d Hz\n",
390                                 runtime->rate);
391 
392         if (cpu_is_at32ap7000()) {
393                 if (!test_bit(DMA_TX_READY, &chip->flags))
394                         retval = atmel_ac97c_prepare_dma(chip, substream,
395                                         DMA_MEM_TO_DEV);
396         } else {
397                 /* Initialize and start the PDC */
398                 writel(runtime->dma_addr, chip->regs + ATMEL_PDC_TPR);
399                 writel(block_size / 2, chip->regs + ATMEL_PDC_TCR);
400                 writel(runtime->dma_addr + block_size,
401                                 chip->regs + ATMEL_PDC_TNPR);
402                 writel(block_size / 2, chip->regs + ATMEL_PDC_TNCR);
403         }
404 
405         return retval;
406 }
407 
408 static int atmel_ac97c_capture_prepare(struct snd_pcm_substream *substream)
409 {
410         struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
411         struct snd_pcm_runtime *runtime = substream->runtime;
412         int block_size = frames_to_bytes(runtime, runtime->period_size);
413         unsigned long word = ac97c_readl(chip, ICA);
414         int retval;
415 
416         chip->capture_period = 0;
417         word &= ~(AC97C_CH_MASK(PCM_LEFT) | AC97C_CH_MASK(PCM_RIGHT));
418 
419         /* assign channels to AC97C channel A */
420         switch (runtime->channels) {
421         case 1:
422                 word |= AC97C_CH_ASSIGN(PCM_LEFT, A);
423                 break;
424         case 2:
425                 word |= AC97C_CH_ASSIGN(PCM_LEFT, A)
426                         | AC97C_CH_ASSIGN(PCM_RIGHT, A);
427                 break;
428         default:
429                 /* TODO: support more than two channels */
430                 return -EINVAL;
431         }
432         ac97c_writel(chip, ICA, word);
433 
434         /* configure sample format and size */
435         word = ac97c_readl(chip, CAMR);
436         if (chip->opened <= 1)
437                 word = AC97C_CMR_DMAEN | AC97C_CMR_SIZE_16;
438         else
439                 word |= AC97C_CMR_DMAEN | AC97C_CMR_SIZE_16;
440 
441         switch (runtime->format) {
442         case SNDRV_PCM_FORMAT_S16_LE:
443                 if (cpu_is_at32ap7000())
444                         word |= AC97C_CMR_CEM_LITTLE;
445                 break;
446         case SNDRV_PCM_FORMAT_S16_BE: /* fall through */
447                 word &= ~(AC97C_CMR_CEM_LITTLE);
448                 break;
449         default:
450                 word = ac97c_readl(chip, ICA);
451                 word &= ~(AC97C_CH_MASK(PCM_LEFT) | AC97C_CH_MASK(PCM_RIGHT));
452                 ac97c_writel(chip, ICA, word);
453                 return -EINVAL;
454         }
455 
456         /* Enable overrun interrupt on channel A */
457         word |= AC97C_CSR_OVRUN;
458 
459         ac97c_writel(chip, CAMR, word);
460 
461         /* Enable channel A event interrupt */
462         word = ac97c_readl(chip, IMR);
463         word |= AC97C_SR_CAEVT;
464         ac97c_writel(chip, IER, word);
465 
466         /* set variable rate if needed */
467         if (runtime->rate != 48000) {
468                 word = ac97c_readl(chip, MR);
469                 word |= AC97C_MR_VRA;
470                 ac97c_writel(chip, MR, word);
471         } else {
472                 word = ac97c_readl(chip, MR);
473                 word &= ~(AC97C_MR_VRA);
474                 ac97c_writel(chip, MR, word);
475         }
476 
477         retval = snd_ac97_set_rate(chip->ac97, AC97_PCM_LR_ADC_RATE,
478                         runtime->rate);
479         if (retval)
480                 dev_dbg(&chip->pdev->dev, "could not set rate %d Hz\n",
481                                 runtime->rate);
482 
483         if (cpu_is_at32ap7000()) {
484                 if (!test_bit(DMA_RX_READY, &chip->flags))
485                         retval = atmel_ac97c_prepare_dma(chip, substream,
486                                         DMA_DEV_TO_MEM);
487         } else {
488                 /* Initialize and start the PDC */
489                 writel(runtime->dma_addr, chip->regs + ATMEL_PDC_RPR);
490                 writel(block_size / 2, chip->regs + ATMEL_PDC_RCR);
491                 writel(runtime->dma_addr + block_size,
492                                 chip->regs + ATMEL_PDC_RNPR);
493                 writel(block_size / 2, chip->regs + ATMEL_PDC_RNCR);
494         }
495 
496         return retval;
497 }
498 
499 static int
500 atmel_ac97c_playback_trigger(struct snd_pcm_substream *substream, int cmd)
501 {
502         struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
503         unsigned long camr, ptcr = 0;
504         int retval = 0;
505 
506         camr = ac97c_readl(chip, CAMR);
507 
508         switch (cmd) {
509         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: /* fall through */
510         case SNDRV_PCM_TRIGGER_RESUME: /* fall through */
511         case SNDRV_PCM_TRIGGER_START:
512                 if (cpu_is_at32ap7000()) {
513                         retval = dw_dma_cyclic_start(chip->dma.tx_chan);
514                         if (retval)
515                                 goto out;
516                 } else {
517                         ptcr = ATMEL_PDC_TXTEN;
518                 }
519                 camr |= AC97C_CMR_CENA | AC97C_CSR_ENDTX;
520                 break;
521         case SNDRV_PCM_TRIGGER_PAUSE_PUSH: /* fall through */
522         case SNDRV_PCM_TRIGGER_SUSPEND: /* fall through */
523         case SNDRV_PCM_TRIGGER_STOP:
524                 if (cpu_is_at32ap7000())
525                         dw_dma_cyclic_stop(chip->dma.tx_chan);
526                 else
527                         ptcr |= ATMEL_PDC_TXTDIS;
528                 if (chip->opened <= 1)
529                         camr &= ~AC97C_CMR_CENA;
530                 break;
531         default:
532                 retval = -EINVAL;
533                 goto out;
534         }
535 
536         ac97c_writel(chip, CAMR, camr);
537         if (!cpu_is_at32ap7000())
538                 writel(ptcr, chip->regs + ATMEL_PDC_PTCR);
539 out:
540         return retval;
541 }
542 
543 static int
544 atmel_ac97c_capture_trigger(struct snd_pcm_substream *substream, int cmd)
545 {
546         struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
547         unsigned long camr, ptcr = 0;
548         int retval = 0;
549 
550         camr = ac97c_readl(chip, CAMR);
551         ptcr = readl(chip->regs + ATMEL_PDC_PTSR);
552 
553         switch (cmd) {
554         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: /* fall through */
555         case SNDRV_PCM_TRIGGER_RESUME: /* fall through */
556         case SNDRV_PCM_TRIGGER_START:
557                 if (cpu_is_at32ap7000()) {
558                         retval = dw_dma_cyclic_start(chip->dma.rx_chan);
559                         if (retval)
560                                 goto out;
561                 } else {
562                         ptcr = ATMEL_PDC_RXTEN;
563                 }
564                 camr |= AC97C_CMR_CENA | AC97C_CSR_ENDRX;
565                 break;
566         case SNDRV_PCM_TRIGGER_PAUSE_PUSH: /* fall through */
567         case SNDRV_PCM_TRIGGER_SUSPEND: /* fall through */
568         case SNDRV_PCM_TRIGGER_STOP:
569                 if (cpu_is_at32ap7000())
570                         dw_dma_cyclic_stop(chip->dma.rx_chan);
571                 else
572                         ptcr |= (ATMEL_PDC_RXTDIS);
573                 if (chip->opened <= 1)
574                         camr &= ~AC97C_CMR_CENA;
575                 break;
576         default:
577                 retval = -EINVAL;
578                 break;
579         }
580 
581         ac97c_writel(chip, CAMR, camr);
582         if (!cpu_is_at32ap7000())
583                 writel(ptcr, chip->regs + ATMEL_PDC_PTCR);
584 out:
585         return retval;
586 }
587 
588 static snd_pcm_uframes_t
589 atmel_ac97c_playback_pointer(struct snd_pcm_substream *substream)
590 {
591         struct atmel_ac97c      *chip = snd_pcm_substream_chip(substream);
592         struct snd_pcm_runtime  *runtime = substream->runtime;
593         snd_pcm_uframes_t       frames;
594         unsigned long           bytes;
595 
596         if (cpu_is_at32ap7000())
597                 bytes = dw_dma_get_src_addr(chip->dma.tx_chan);
598         else
599                 bytes = readl(chip->regs + ATMEL_PDC_TPR);
600         bytes -= runtime->dma_addr;
601 
602         frames = bytes_to_frames(runtime, bytes);
603         if (frames >= runtime->buffer_size)
604                 frames -= runtime->buffer_size;
605         return frames;
606 }
607 
608 static snd_pcm_uframes_t
609 atmel_ac97c_capture_pointer(struct snd_pcm_substream *substream)
610 {
611         struct atmel_ac97c      *chip = snd_pcm_substream_chip(substream);
612         struct snd_pcm_runtime  *runtime = substream->runtime;
613         snd_pcm_uframes_t       frames;
614         unsigned long           bytes;
615 
616         if (cpu_is_at32ap7000())
617                 bytes = dw_dma_get_dst_addr(chip->dma.rx_chan);
618         else
619                 bytes = readl(chip->regs + ATMEL_PDC_RPR);
620         bytes -= runtime->dma_addr;
621 
622         frames = bytes_to_frames(runtime, bytes);
623         if (frames >= runtime->buffer_size)
624                 frames -= runtime->buffer_size;
625         return frames;
626 }
627 
628 static struct snd_pcm_ops atmel_ac97_playback_ops = {
629         .open           = atmel_ac97c_playback_open,
630         .close          = atmel_ac97c_playback_close,
631         .ioctl          = snd_pcm_lib_ioctl,
632         .hw_params      = atmel_ac97c_playback_hw_params,
633         .hw_free        = atmel_ac97c_playback_hw_free,
634         .prepare        = atmel_ac97c_playback_prepare,
635         .trigger        = atmel_ac97c_playback_trigger,
636         .pointer        = atmel_ac97c_playback_pointer,
637 };
638 
639 static struct snd_pcm_ops atmel_ac97_capture_ops = {
640         .open           = atmel_ac97c_capture_open,
641         .close          = atmel_ac97c_capture_close,
642         .ioctl          = snd_pcm_lib_ioctl,
643         .hw_params      = atmel_ac97c_capture_hw_params,
644         .hw_free        = atmel_ac97c_capture_hw_free,
645         .prepare        = atmel_ac97c_capture_prepare,
646         .trigger        = atmel_ac97c_capture_trigger,
647         .pointer        = atmel_ac97c_capture_pointer,
648 };
649 
650 static irqreturn_t atmel_ac97c_interrupt(int irq, void *dev)
651 {
652         struct atmel_ac97c      *chip  = (struct atmel_ac97c *)dev;
653         irqreturn_t             retval = IRQ_NONE;
654         u32                     sr     = ac97c_readl(chip, SR);
655         u32                     casr   = ac97c_readl(chip, CASR);
656         u32                     cosr   = ac97c_readl(chip, COSR);
657         u32                     camr   = ac97c_readl(chip, CAMR);
658 
659         if (sr & AC97C_SR_CAEVT) {
660                 struct snd_pcm_runtime *runtime;
661                 int offset, next_period, block_size;
662                 dev_dbg(&chip->pdev->dev, "channel A event%s%s%s%s%s%s\n",
663                                 casr & AC97C_CSR_OVRUN   ? " OVRUN"   : "",
664                                 casr & AC97C_CSR_RXRDY   ? " RXRDY"   : "",
665                                 casr & AC97C_CSR_UNRUN   ? " UNRUN"   : "",
666                                 casr & AC97C_CSR_TXEMPTY ? " TXEMPTY" : "",
667                                 casr & AC97C_CSR_TXRDY   ? " TXRDY"   : "",
668                                 !casr                    ? " NONE"    : "");
669                 if (!cpu_is_at32ap7000()) {
670                         if ((casr & camr) & AC97C_CSR_ENDTX) {
671                                 runtime = chip->playback_substream->runtime;
672                                 block_size = frames_to_bytes(runtime,
673                                                 runtime->period_size);
674                                 chip->playback_period++;
675 
676                                 if (chip->playback_period == runtime->periods)
677                                         chip->playback_period = 0;
678                                 next_period = chip->playback_period + 1;
679                                 if (next_period == runtime->periods)
680                                         next_period = 0;
681 
682                                 offset = block_size * next_period;
683 
684                                 writel(runtime->dma_addr + offset,
685                                                 chip->regs + ATMEL_PDC_TNPR);
686                                 writel(block_size / 2,
687                                                 chip->regs + ATMEL_PDC_TNCR);
688 
689                                 snd_pcm_period_elapsed(
690                                                 chip->playback_substream);
691                         }
692                         if ((casr & camr) & AC97C_CSR_ENDRX) {
693                                 runtime = chip->capture_substream->runtime;
694                                 block_size = frames_to_bytes(runtime,
695                                                 runtime->period_size);
696                                 chip->capture_period++;
697 
698                                 if (chip->capture_period == runtime->periods)
699                                         chip->capture_period = 0;
700                                 next_period = chip->capture_period + 1;
701                                 if (next_period == runtime->periods)
702                                         next_period = 0;
703 
704                                 offset = block_size * next_period;
705 
706                                 writel(runtime->dma_addr + offset,
707                                                 chip->regs + ATMEL_PDC_RNPR);
708                                 writel(block_size / 2,
709                                                 chip->regs + ATMEL_PDC_RNCR);
710                                 snd_pcm_period_elapsed(chip->capture_substream);
711                         }
712                 }
713                 retval = IRQ_HANDLED;
714         }
715 
716         if (sr & AC97C_SR_COEVT) {
717                 dev_info(&chip->pdev->dev, "codec channel event%s%s%s%s%s\n",
718                                 cosr & AC97C_CSR_OVRUN   ? " OVRUN"   : "",
719                                 cosr & AC97C_CSR_RXRDY   ? " RXRDY"   : "",
720                                 cosr & AC97C_CSR_TXEMPTY ? " TXEMPTY" : "",
721                                 cosr & AC97C_CSR_TXRDY   ? " TXRDY"   : "",
722                                 !cosr                    ? " NONE"    : "");
723                 retval = IRQ_HANDLED;
724         }
725 
726         if (retval == IRQ_NONE) {
727                 dev_err(&chip->pdev->dev, "spurious interrupt sr 0x%08x "
728                                 "casr 0x%08x cosr 0x%08x\n", sr, casr, cosr);
729         }
730 
731         return retval;
732 }
733 
734 static struct ac97_pcm at91_ac97_pcm_defs[] = {
735         /* Playback */
736         {
737                 .exclusive = 1,
738                 .r = { {
739                         .slots = ((1 << AC97_SLOT_PCM_LEFT)
740                                   | (1 << AC97_SLOT_PCM_RIGHT)),
741                 } },
742         },
743         /* PCM in */
744         {
745                 .stream = 1,
746                 .exclusive = 1,
747                 .r = { {
748                         .slots = ((1 << AC97_SLOT_PCM_LEFT)
749                                         | (1 << AC97_SLOT_PCM_RIGHT)),
750                 } }
751         },
752         /* Mic in */
753         {
754                 .stream = 1,
755                 .exclusive = 1,
756                 .r = { {
757                         .slots = (1<<AC97_SLOT_MIC),
758                 } }
759         },
760 };
761 
762 static int atmel_ac97c_pcm_new(struct atmel_ac97c *chip)
763 {
764         struct snd_pcm          *pcm;
765         struct snd_pcm_hardware hw = atmel_ac97c_hw;
766         int                     capture, playback, retval, err;
767 
768         capture = test_bit(DMA_RX_CHAN_PRESENT, &chip->flags);
769         playback = test_bit(DMA_TX_CHAN_PRESENT, &chip->flags);
770 
771         if (!cpu_is_at32ap7000()) {
772                 err = snd_ac97_pcm_assign(chip->ac97_bus,
773                                 ARRAY_SIZE(at91_ac97_pcm_defs),
774                                 at91_ac97_pcm_defs);
775                 if (err)
776                         return err;
777         }
778         retval = snd_pcm_new(chip->card, chip->card->shortname,
779                         0, playback, capture, &pcm);
780         if (retval)
781                 return retval;
782 
783         if (capture)
784                 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
785                                 &atmel_ac97_capture_ops);
786         if (playback)
787                 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
788                                 &atmel_ac97_playback_ops);
789 
790         retval = snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
791                         &chip->pdev->dev, hw.periods_min * hw.period_bytes_min,
792                         hw.buffer_bytes_max);
793         if (retval)
794                 return retval;
795 
796         pcm->private_data = chip;
797         pcm->info_flags = 0;
798         strcpy(pcm->name, chip->card->shortname);
799         chip->pcm = pcm;
800 
801         return 0;
802 }
803 
804 static int atmel_ac97c_mixer_new(struct atmel_ac97c *chip)
805 {
806         struct snd_ac97_template template;
807         memset(&template, 0, sizeof(template));
808         template.private_data = chip;
809         return snd_ac97_mixer(chip->ac97_bus, &template, &chip->ac97);
810 }
811 
812 static void atmel_ac97c_write(struct snd_ac97 *ac97, unsigned short reg,
813                 unsigned short val)
814 {
815         struct atmel_ac97c *chip = get_chip(ac97);
816         unsigned long word;
817         int timeout = 40;
818 
819         word = (reg & 0x7f) << 16 | val;
820 
821         do {
822                 if (ac97c_readl(chip, COSR) & AC97C_CSR_TXRDY) {
823                         ac97c_writel(chip, COTHR, word);
824                         return;
825                 }
826                 udelay(1);
827         } while (--timeout);
828 
829         dev_dbg(&chip->pdev->dev, "codec write timeout\n");
830 }
831 
832 static unsigned short atmel_ac97c_read(struct snd_ac97 *ac97,
833                 unsigned short reg)
834 {
835         struct atmel_ac97c *chip = get_chip(ac97);
836         unsigned long word;
837         int timeout = 40;
838         int write = 10;
839 
840         word = (0x80 | (reg & 0x7f)) << 16;
841 
842         if ((ac97c_readl(chip, COSR) & AC97C_CSR_RXRDY) != 0)
843                 ac97c_readl(chip, CORHR);
844 
845 retry_write:
846         timeout = 40;
847 
848         do {
849                 if ((ac97c_readl(chip, COSR) & AC97C_CSR_TXRDY) != 0) {
850                         ac97c_writel(chip, COTHR, word);
851                         goto read_reg;
852                 }
853                 udelay(10);
854         } while (--timeout);
855 
856         if (!--write)
857                 goto timed_out;
858         goto retry_write;
859 
860 read_reg:
861         do {
862                 if ((ac97c_readl(chip, COSR) & AC97C_CSR_RXRDY) != 0) {
863                         unsigned short val = ac97c_readl(chip, CORHR);
864                         return val;
865                 }
866                 udelay(10);
867         } while (--timeout);
868 
869         if (!--write)
870                 goto timed_out;
871         goto retry_write;
872 
873 timed_out:
874         dev_dbg(&chip->pdev->dev, "codec read timeout\n");
875         return 0xffff;
876 }
877 
878 static bool filter(struct dma_chan *chan, void *slave)
879 {
880         struct dw_dma_slave *dws = slave;
881 
882         if (dws->dma_dev == chan->device->dev) {
883                 chan->private = dws;
884                 return true;
885         } else
886                 return false;
887 }
888 
889 static void atmel_ac97c_reset(struct atmel_ac97c *chip)
890 {
891         ac97c_writel(chip, MR,   0);
892         ac97c_writel(chip, MR,   AC97C_MR_ENA);
893         ac97c_writel(chip, CAMR, 0);
894         ac97c_writel(chip, COMR, 0);
895 
896         if (gpio_is_valid(chip->reset_pin)) {
897                 gpio_set_value(chip->reset_pin, 0);
898                 /* AC97 v2.2 specifications says minimum 1 us. */
899                 udelay(2);
900                 gpio_set_value(chip->reset_pin, 1);
901         } else {
902                 ac97c_writel(chip, MR, AC97C_MR_WRST | AC97C_MR_ENA);
903                 udelay(2);
904                 ac97c_writel(chip, MR, AC97C_MR_ENA);
905         }
906 }
907 
908 #ifdef CONFIG_OF
909 static const struct of_device_id atmel_ac97c_dt_ids[] = {
910         { .compatible = "atmel,at91sam9263-ac97c", },
911         { }
912 };
913 MODULE_DEVICE_TABLE(of, atmel_ac97c_dt_ids);
914 
915 static struct ac97c_platform_data *atmel_ac97c_probe_dt(struct device *dev)
916 {
917         struct ac97c_platform_data *pdata;
918         struct device_node *node = dev->of_node;
919 
920         if (!node) {
921                 dev_err(dev, "Device does not have associated DT data\n");
922                 return ERR_PTR(-EINVAL);
923         }
924 
925         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
926         if (!pdata)
927                 return ERR_PTR(-ENOMEM);
928 
929         pdata->reset_pin = of_get_named_gpio(dev->of_node, "ac97-gpios", 2);
930 
931         return pdata;
932 }
933 #else
934 static struct ac97c_platform_data *atmel_ac97c_probe_dt(struct device *dev)
935 {
936         dev_err(dev, "no platform data defined\n");
937         return ERR_PTR(-ENXIO);
938 }
939 #endif
940 
941 static int atmel_ac97c_probe(struct platform_device *pdev)
942 {
943         struct snd_card                 *card;
944         struct atmel_ac97c              *chip;
945         struct resource                 *regs;
946         struct ac97c_platform_data      *pdata;
947         struct clk                      *pclk;
948         static struct snd_ac97_bus_ops  ops = {
949                 .write  = atmel_ac97c_write,
950                 .read   = atmel_ac97c_read,
951         };
952         int                             retval;
953         int                             irq;
954 
955         regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
956         if (!regs) {
957                 dev_dbg(&pdev->dev, "no memory resource\n");
958                 return -ENXIO;
959         }
960 
961         pdata = dev_get_platdata(&pdev->dev);
962         if (!pdata) {
963                 pdata = atmel_ac97c_probe_dt(&pdev->dev);
964                 if (IS_ERR(pdata))
965                         return PTR_ERR(pdata);
966         }
967 
968         irq = platform_get_irq(pdev, 0);
969         if (irq < 0) {
970                 dev_dbg(&pdev->dev, "could not get irq\n");
971                 return -ENXIO;
972         }
973 
974         if (cpu_is_at32ap7000()) {
975                 pclk = clk_get(&pdev->dev, "pclk");
976         } else {
977                 pclk = clk_get(&pdev->dev, "ac97_clk");
978         }
979 
980         if (IS_ERR(pclk)) {
981                 dev_dbg(&pdev->dev, "no peripheral clock\n");
982                 return PTR_ERR(pclk);
983         }
984         clk_prepare_enable(pclk);
985 
986         retval = snd_card_new(&pdev->dev, SNDRV_DEFAULT_IDX1,
987                               SNDRV_DEFAULT_STR1, THIS_MODULE,
988                               sizeof(struct atmel_ac97c), &card);
989         if (retval) {
990                 dev_dbg(&pdev->dev, "could not create sound card device\n");
991                 goto err_snd_card_new;
992         }
993 
994         chip = get_chip(card);
995 
996         retval = request_irq(irq, atmel_ac97c_interrupt, 0, "AC97C", chip);
997         if (retval) {
998                 dev_dbg(&pdev->dev, "unable to request irq %d\n", irq);
999                 goto err_request_irq;
1000         }
1001         chip->irq = irq;
1002 
1003         spin_lock_init(&chip->lock);
1004 
1005         strcpy(card->driver, "Atmel AC97C");
1006         strcpy(card->shortname, "Atmel AC97C");
1007         sprintf(card->longname, "Atmel AC97 controller");
1008 
1009         chip->card = card;
1010         chip->pclk = pclk;
1011         chip->pdev = pdev;
1012         chip->regs = ioremap(regs->start, resource_size(regs));
1013 
1014         if (!chip->regs) {
1015                 dev_dbg(&pdev->dev, "could not remap register memory\n");
1016                 retval = -ENOMEM;
1017                 goto err_ioremap;
1018         }
1019 
1020         if (gpio_is_valid(pdata->reset_pin)) {
1021                 if (gpio_request(pdata->reset_pin, "reset_pin")) {
1022                         dev_dbg(&pdev->dev, "reset pin not available\n");
1023                         chip->reset_pin = -ENODEV;
1024                 } else {
1025                         gpio_direction_output(pdata->reset_pin, 1);
1026                         chip->reset_pin = pdata->reset_pin;
1027                 }
1028         } else {
1029                 chip->reset_pin = -EINVAL;
1030         }
1031 
1032         atmel_ac97c_reset(chip);
1033 
1034         /* Enable overrun interrupt from codec channel */
1035         ac97c_writel(chip, COMR, AC97C_CSR_OVRUN);
1036         ac97c_writel(chip, IER, ac97c_readl(chip, IMR) | AC97C_SR_COEVT);
1037 
1038         retval = snd_ac97_bus(card, 0, &ops, chip, &chip->ac97_bus);
1039         if (retval) {
1040                 dev_dbg(&pdev->dev, "could not register on ac97 bus\n");
1041                 goto err_ac97_bus;
1042         }
1043 
1044         retval = atmel_ac97c_mixer_new(chip);
1045         if (retval) {
1046                 dev_dbg(&pdev->dev, "could not register ac97 mixer\n");
1047                 goto err_ac97_bus;
1048         }
1049 
1050         if (cpu_is_at32ap7000()) {
1051                 if (pdata->rx_dws.dma_dev) {
1052                         dma_cap_mask_t mask;
1053 
1054                         dma_cap_zero(mask);
1055                         dma_cap_set(DMA_SLAVE, mask);
1056 
1057                         chip->dma.rx_chan = dma_request_channel(mask, filter,
1058                                                                 &pdata->rx_dws);
1059                         if (chip->dma.rx_chan) {
1060                                 struct dma_slave_config dma_conf = {
1061                                         .src_addr = regs->start + AC97C_CARHR +
1062                                                 2,
1063                                         .src_addr_width =
1064                                                 DMA_SLAVE_BUSWIDTH_2_BYTES,
1065                                         .src_maxburst = 1,
1066                                         .dst_maxburst = 1,
1067                                         .direction = DMA_DEV_TO_MEM,
1068                                         .device_fc = false,
1069                                 };
1070 
1071                                 dmaengine_slave_config(chip->dma.rx_chan,
1072                                                 &dma_conf);
1073                         }
1074 
1075                         dev_info(&chip->pdev->dev, "using %s for DMA RX\n",
1076                                 dev_name(&chip->dma.rx_chan->dev->device));
1077                         set_bit(DMA_RX_CHAN_PRESENT, &chip->flags);
1078                 }
1079 
1080                 if (pdata->tx_dws.dma_dev) {
1081                         dma_cap_mask_t mask;
1082 
1083                         dma_cap_zero(mask);
1084                         dma_cap_set(DMA_SLAVE, mask);
1085 
1086                         chip->dma.tx_chan = dma_request_channel(mask, filter,
1087                                                                 &pdata->tx_dws);
1088                         if (chip->dma.tx_chan) {
1089                                 struct dma_slave_config dma_conf = {
1090                                         .dst_addr = regs->start + AC97C_CATHR +
1091                                                 2,
1092                                         .dst_addr_width =
1093                                                 DMA_SLAVE_BUSWIDTH_2_BYTES,
1094                                         .src_maxburst = 1,
1095                                         .dst_maxburst = 1,
1096                                         .direction = DMA_MEM_TO_DEV,
1097                                         .device_fc = false,
1098                                 };
1099 
1100                                 dmaengine_slave_config(chip->dma.tx_chan,
1101                                                 &dma_conf);
1102                         }
1103 
1104                         dev_info(&chip->pdev->dev, "using %s for DMA TX\n",
1105                                 dev_name(&chip->dma.tx_chan->dev->device));
1106                         set_bit(DMA_TX_CHAN_PRESENT, &chip->flags);
1107                 }
1108 
1109                 if (!test_bit(DMA_RX_CHAN_PRESENT, &chip->flags) &&
1110                                 !test_bit(DMA_TX_CHAN_PRESENT, &chip->flags)) {
1111                         dev_dbg(&pdev->dev, "DMA not available\n");
1112                         retval = -ENODEV;
1113                         goto err_dma;
1114                 }
1115         } else {
1116                 /* Just pretend that we have DMA channel(for at91 i is actually
1117                  * the PDC) */
1118                 set_bit(DMA_RX_CHAN_PRESENT, &chip->flags);
1119                 set_bit(DMA_TX_CHAN_PRESENT, &chip->flags);
1120         }
1121 
1122         retval = atmel_ac97c_pcm_new(chip);
1123         if (retval) {
1124                 dev_dbg(&pdev->dev, "could not register ac97 pcm device\n");
1125                 goto err_dma;
1126         }
1127 
1128         retval = snd_card_register(card);
1129         if (retval) {
1130                 dev_dbg(&pdev->dev, "could not register sound card\n");
1131                 goto err_dma;
1132         }
1133 
1134         platform_set_drvdata(pdev, card);
1135 
1136         dev_info(&pdev->dev, "Atmel AC97 controller at 0x%p, irq = %d\n",
1137                         chip->regs, irq);
1138 
1139         return 0;
1140 
1141 err_dma:
1142         if (cpu_is_at32ap7000()) {
1143                 if (test_bit(DMA_RX_CHAN_PRESENT, &chip->flags))
1144                         dma_release_channel(chip->dma.rx_chan);
1145                 if (test_bit(DMA_TX_CHAN_PRESENT, &chip->flags))
1146                         dma_release_channel(chip->dma.tx_chan);
1147                 clear_bit(DMA_RX_CHAN_PRESENT, &chip->flags);
1148                 clear_bit(DMA_TX_CHAN_PRESENT, &chip->flags);
1149                 chip->dma.rx_chan = NULL;
1150                 chip->dma.tx_chan = NULL;
1151         }
1152 err_ac97_bus:
1153         if (gpio_is_valid(chip->reset_pin))
1154                 gpio_free(chip->reset_pin);
1155 
1156         iounmap(chip->regs);
1157 err_ioremap:
1158         free_irq(irq, chip);
1159 err_request_irq:
1160         snd_card_free(card);
1161 err_snd_card_new:
1162         clk_disable_unprepare(pclk);
1163         clk_put(pclk);
1164         return retval;
1165 }
1166 
1167 #ifdef CONFIG_PM_SLEEP
1168 static int atmel_ac97c_suspend(struct device *pdev)
1169 {
1170         struct snd_card *card = dev_get_drvdata(pdev);
1171         struct atmel_ac97c *chip = card->private_data;
1172 
1173         if (cpu_is_at32ap7000()) {
1174                 if (test_bit(DMA_RX_READY, &chip->flags))
1175                         dw_dma_cyclic_stop(chip->dma.rx_chan);
1176                 if (test_bit(DMA_TX_READY, &chip->flags))
1177                         dw_dma_cyclic_stop(chip->dma.tx_chan);
1178         }
1179         clk_disable_unprepare(chip->pclk);
1180 
1181         return 0;
1182 }
1183 
1184 static int atmel_ac97c_resume(struct device *pdev)
1185 {
1186         struct snd_card *card = dev_get_drvdata(pdev);
1187         struct atmel_ac97c *chip = card->private_data;
1188 
1189         clk_prepare_enable(chip->pclk);
1190         if (cpu_is_at32ap7000()) {
1191                 if (test_bit(DMA_RX_READY, &chip->flags))
1192                         dw_dma_cyclic_start(chip->dma.rx_chan);
1193                 if (test_bit(DMA_TX_READY, &chip->flags))
1194                         dw_dma_cyclic_start(chip->dma.tx_chan);
1195         }
1196         return 0;
1197 }
1198 
1199 static SIMPLE_DEV_PM_OPS(atmel_ac97c_pm, atmel_ac97c_suspend, atmel_ac97c_resume);
1200 #define ATMEL_AC97C_PM_OPS      &atmel_ac97c_pm
1201 #else
1202 #define ATMEL_AC97C_PM_OPS      NULL
1203 #endif
1204 
1205 static int atmel_ac97c_remove(struct platform_device *pdev)
1206 {
1207         struct snd_card *card = platform_get_drvdata(pdev);
1208         struct atmel_ac97c *chip = get_chip(card);
1209 
1210         if (gpio_is_valid(chip->reset_pin))
1211                 gpio_free(chip->reset_pin);
1212 
1213         ac97c_writel(chip, CAMR, 0);
1214         ac97c_writel(chip, COMR, 0);
1215         ac97c_writel(chip, MR,   0);
1216 
1217         clk_disable_unprepare(chip->pclk);
1218         clk_put(chip->pclk);
1219         iounmap(chip->regs);
1220         free_irq(chip->irq, chip);
1221 
1222         if (cpu_is_at32ap7000()) {
1223                 if (test_bit(DMA_RX_CHAN_PRESENT, &chip->flags))
1224                         dma_release_channel(chip->dma.rx_chan);
1225                 if (test_bit(DMA_TX_CHAN_PRESENT, &chip->flags))
1226                         dma_release_channel(chip->dma.tx_chan);
1227                 clear_bit(DMA_RX_CHAN_PRESENT, &chip->flags);
1228                 clear_bit(DMA_TX_CHAN_PRESENT, &chip->flags);
1229                 chip->dma.rx_chan = NULL;
1230                 chip->dma.tx_chan = NULL;
1231         }
1232 
1233         snd_card_free(card);
1234 
1235         return 0;
1236 }
1237 
1238 static struct platform_driver atmel_ac97c_driver = {
1239         .probe          = atmel_ac97c_probe,
1240         .remove         = atmel_ac97c_remove,
1241         .driver         = {
1242                 .name   = "atmel_ac97c",
1243                 .pm     = ATMEL_AC97C_PM_OPS,
1244                 .of_match_table = of_match_ptr(atmel_ac97c_dt_ids),
1245         },
1246 };
1247 module_platform_driver(atmel_ac97c_driver);
1248 
1249 MODULE_LICENSE("GPL");
1250 MODULE_DESCRIPTION("Driver for Atmel AC97 controller");
1251 MODULE_AUTHOR("Hans-Christian Egtvedt <egtvedt@samfundet.no>");
1252 

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