~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/atmel/ac97c.c

Version: ~ [ linux-5.15-rc6 ] ~ [ linux-5.14.14 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.75 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.155 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.213 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.252 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.287 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.289 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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                                 dev_name(&chip->dma.rx_chan->dev->device));
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                                 dev_name(&chip->dma.tx_chan->dev->device));
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         ac97c_writel(chip, CAMR, 0);
973         ac97c_writel(chip, COMR, 0);
974         ac97c_writel(chip, MR,   0);
975 
976         clk_disable(chip->pclk);
977         clk_put(chip->pclk);
978         iounmap(chip->regs);
979         free_irq(chip->irq, chip);
980 
981         if (test_bit(DMA_RX_CHAN_PRESENT, &chip->flags))
982                 dma_release_channel(chip->dma.rx_chan);
983         if (test_bit(DMA_TX_CHAN_PRESENT, &chip->flags))
984                 dma_release_channel(chip->dma.tx_chan);
985         clear_bit(DMA_RX_CHAN_PRESENT, &chip->flags);
986         clear_bit(DMA_TX_CHAN_PRESENT, &chip->flags);
987         chip->dma.rx_chan = NULL;
988         chip->dma.tx_chan = NULL;
989 
990         snd_card_set_dev(card, NULL);
991         snd_card_free(card);
992 
993         platform_set_drvdata(pdev, NULL);
994 
995         return 0;
996 }
997 
998 static struct platform_driver atmel_ac97c_driver = {
999         .remove         = __devexit_p(atmel_ac97c_remove),
1000         .driver         = {
1001                 .name   = "atmel_ac97c",
1002         },
1003         .suspend        = atmel_ac97c_suspend,
1004         .resume         = atmel_ac97c_resume,
1005 };
1006 
1007 static int __init atmel_ac97c_init(void)
1008 {
1009         return platform_driver_probe(&atmel_ac97c_driver,
1010                         atmel_ac97c_probe);
1011 }
1012 module_init(atmel_ac97c_init);
1013 
1014 static void __exit atmel_ac97c_exit(void)
1015 {
1016         platform_driver_unregister(&atmel_ac97c_driver);
1017 }
1018 module_exit(atmel_ac97c_exit);
1019 
1020 MODULE_LICENSE("GPL");
1021 MODULE_DESCRIPTION("Driver for Atmel AC97 controller");
1022 MODULE_AUTHOR("Hans-Christian Egtvedt <hans-christian.egtvedt@atmel.com>");
1023 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp