90527c14901ef5e0c6f49a39aaa85434fdea169a
[linux-2.6.git] / 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,   0);
734         ac97c_writel(chip, MR,   AC97C_MR_ENA);
735         ac97c_writel(chip, CAMR, 0);
736         ac97c_writel(chip, COMR, 0);
737
738         if (gpio_is_valid(chip->reset_pin)) {
739                 gpio_set_value(chip->reset_pin, 0);
740                 /* AC97 v2.2 specifications says minimum 1 us. */
741                 udelay(2);
742                 gpio_set_value(chip->reset_pin, 1);
743         }
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         atmel_ac97c_reset(chip);
830
831         /* Enable overrun interrupt from codec channel */
832         ac97c_writel(chip, COMR, AC97C_CSR_OVRUN);
833         ac97c_writel(chip, IER, ac97c_readl(chip, IMR) | AC97C_SR_COEVT);
834
835         retval = snd_ac97_bus(card, 0, &ops, chip, &chip->ac97_bus);
836         if (retval) {
837                 dev_dbg(&pdev->dev, "could not register on ac97 bus\n");
838                 goto err_ac97_bus;
839         }
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>");