Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Driver for Atmel AC97C
0004  *
0005  * Copyright (C) 2005-2009 Atmel Corporation
0006  */
0007 #include <linux/clk.h>
0008 #include <linux/delay.h>
0009 #include <linux/bitmap.h>
0010 #include <linux/device.h>
0011 #include <linux/atmel_pdc.h>
0012 #include <linux/gpio/consumer.h>
0013 #include <linux/init.h>
0014 #include <linux/interrupt.h>
0015 #include <linux/module.h>
0016 #include <linux/platform_device.h>
0017 #include <linux/mutex.h>
0018 #include <linux/types.h>
0019 #include <linux/io.h>
0020 #include <linux/of.h>
0021 #include <linux/of_device.h>
0022 
0023 #include <sound/core.h>
0024 #include <sound/initval.h>
0025 #include <sound/pcm.h>
0026 #include <sound/pcm_params.h>
0027 #include <sound/ac97_codec.h>
0028 #include <sound/memalloc.h>
0029 
0030 #include "ac97c.h"
0031 
0032 /* Serialize access to opened variable */
0033 static DEFINE_MUTEX(opened_mutex);
0034 
0035 struct atmel_ac97c {
0036     struct clk          *pclk;
0037     struct platform_device      *pdev;
0038 
0039     struct snd_pcm_substream    *playback_substream;
0040     struct snd_pcm_substream    *capture_substream;
0041     struct snd_card         *card;
0042     struct snd_pcm          *pcm;
0043     struct snd_ac97         *ac97;
0044     struct snd_ac97_bus     *ac97_bus;
0045 
0046     u64             cur_format;
0047     unsigned int            cur_rate;
0048     int             playback_period, capture_period;
0049     /* Serialize access to opened variable */
0050     spinlock_t          lock;
0051     void __iomem            *regs;
0052     int             irq;
0053     int             opened;
0054     struct gpio_desc        *reset_pin;
0055 };
0056 
0057 #define get_chip(card) ((struct atmel_ac97c *)(card)->private_data)
0058 
0059 #define ac97c_writel(chip, reg, val)            \
0060     __raw_writel((val), (chip)->regs + AC97C_##reg)
0061 #define ac97c_readl(chip, reg)              \
0062     __raw_readl((chip)->regs + AC97C_##reg)
0063 
0064 static const struct snd_pcm_hardware atmel_ac97c_hw = {
0065     .info           = (SNDRV_PCM_INFO_MMAP
0066                   | SNDRV_PCM_INFO_MMAP_VALID
0067                   | SNDRV_PCM_INFO_INTERLEAVED
0068                   | SNDRV_PCM_INFO_BLOCK_TRANSFER
0069                   | SNDRV_PCM_INFO_JOINT_DUPLEX
0070                   | SNDRV_PCM_INFO_RESUME
0071                   | SNDRV_PCM_INFO_PAUSE),
0072     .formats        = (SNDRV_PCM_FMTBIT_S16_BE
0073                   | SNDRV_PCM_FMTBIT_S16_LE),
0074     .rates          = (SNDRV_PCM_RATE_CONTINUOUS),
0075     .rate_min       = 4000,
0076     .rate_max       = 48000,
0077     .channels_min       = 1,
0078     .channels_max       = 2,
0079     .buffer_bytes_max   = 2 * 2 * 64 * 2048,
0080     .period_bytes_min   = 4096,
0081     .period_bytes_max   = 4096,
0082     .periods_min        = 6,
0083     .periods_max        = 64,
0084 };
0085 
0086 static int atmel_ac97c_playback_open(struct snd_pcm_substream *substream)
0087 {
0088     struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
0089     struct snd_pcm_runtime *runtime = substream->runtime;
0090 
0091     mutex_lock(&opened_mutex);
0092     chip->opened++;
0093     runtime->hw = atmel_ac97c_hw;
0094     if (chip->cur_rate) {
0095         runtime->hw.rate_min = chip->cur_rate;
0096         runtime->hw.rate_max = chip->cur_rate;
0097     }
0098     if (chip->cur_format)
0099         runtime->hw.formats = pcm_format_to_bits(chip->cur_format);
0100     mutex_unlock(&opened_mutex);
0101     chip->playback_substream = substream;
0102     return 0;
0103 }
0104 
0105 static int atmel_ac97c_capture_open(struct snd_pcm_substream *substream)
0106 {
0107     struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
0108     struct snd_pcm_runtime *runtime = substream->runtime;
0109 
0110     mutex_lock(&opened_mutex);
0111     chip->opened++;
0112     runtime->hw = atmel_ac97c_hw;
0113     if (chip->cur_rate) {
0114         runtime->hw.rate_min = chip->cur_rate;
0115         runtime->hw.rate_max = chip->cur_rate;
0116     }
0117     if (chip->cur_format)
0118         runtime->hw.formats = pcm_format_to_bits(chip->cur_format);
0119     mutex_unlock(&opened_mutex);
0120     chip->capture_substream = substream;
0121     return 0;
0122 }
0123 
0124 static int atmel_ac97c_playback_close(struct snd_pcm_substream *substream)
0125 {
0126     struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
0127 
0128     mutex_lock(&opened_mutex);
0129     chip->opened--;
0130     if (!chip->opened) {
0131         chip->cur_rate = 0;
0132         chip->cur_format = 0;
0133     }
0134     mutex_unlock(&opened_mutex);
0135 
0136     chip->playback_substream = NULL;
0137 
0138     return 0;
0139 }
0140 
0141 static int atmel_ac97c_capture_close(struct snd_pcm_substream *substream)
0142 {
0143     struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
0144 
0145     mutex_lock(&opened_mutex);
0146     chip->opened--;
0147     if (!chip->opened) {
0148         chip->cur_rate = 0;
0149         chip->cur_format = 0;
0150     }
0151     mutex_unlock(&opened_mutex);
0152 
0153     chip->capture_substream = NULL;
0154 
0155     return 0;
0156 }
0157 
0158 static int atmel_ac97c_playback_hw_params(struct snd_pcm_substream *substream,
0159         struct snd_pcm_hw_params *hw_params)
0160 {
0161     struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
0162 
0163     /* Set restrictions to params. */
0164     mutex_lock(&opened_mutex);
0165     chip->cur_rate = params_rate(hw_params);
0166     chip->cur_format = params_format(hw_params);
0167     mutex_unlock(&opened_mutex);
0168 
0169     return 0;
0170 }
0171 
0172 static int atmel_ac97c_capture_hw_params(struct snd_pcm_substream *substream,
0173         struct snd_pcm_hw_params *hw_params)
0174 {
0175     struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
0176 
0177     /* Set restrictions to params. */
0178     mutex_lock(&opened_mutex);
0179     chip->cur_rate = params_rate(hw_params);
0180     chip->cur_format = params_format(hw_params);
0181     mutex_unlock(&opened_mutex);
0182 
0183     return 0;
0184 }
0185 
0186 static int atmel_ac97c_playback_prepare(struct snd_pcm_substream *substream)
0187 {
0188     struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
0189     struct snd_pcm_runtime *runtime = substream->runtime;
0190     int block_size = frames_to_bytes(runtime, runtime->period_size);
0191     unsigned long word = ac97c_readl(chip, OCA);
0192     int retval;
0193 
0194     chip->playback_period = 0;
0195     word &= ~(AC97C_CH_MASK(PCM_LEFT) | AC97C_CH_MASK(PCM_RIGHT));
0196 
0197     /* assign channels to AC97C channel A */
0198     switch (runtime->channels) {
0199     case 1:
0200         word |= AC97C_CH_ASSIGN(PCM_LEFT, A);
0201         break;
0202     case 2:
0203         word |= AC97C_CH_ASSIGN(PCM_LEFT, A)
0204             | AC97C_CH_ASSIGN(PCM_RIGHT, A);
0205         break;
0206     default:
0207         /* TODO: support more than two channels */
0208         return -EINVAL;
0209     }
0210     ac97c_writel(chip, OCA, word);
0211 
0212     /* configure sample format and size */
0213     word = ac97c_readl(chip, CAMR);
0214     if (chip->opened <= 1)
0215         word = AC97C_CMR_DMAEN | AC97C_CMR_SIZE_16;
0216     else
0217         word |= AC97C_CMR_DMAEN | AC97C_CMR_SIZE_16;
0218 
0219     switch (runtime->format) {
0220     case SNDRV_PCM_FORMAT_S16_LE:
0221         break;
0222     case SNDRV_PCM_FORMAT_S16_BE:
0223         word &= ~(AC97C_CMR_CEM_LITTLE);
0224         break;
0225     default:
0226         word = ac97c_readl(chip, OCA);
0227         word &= ~(AC97C_CH_MASK(PCM_LEFT) | AC97C_CH_MASK(PCM_RIGHT));
0228         ac97c_writel(chip, OCA, word);
0229         return -EINVAL;
0230     }
0231 
0232     /* Enable underrun interrupt on channel A */
0233     word |= AC97C_CSR_UNRUN;
0234 
0235     ac97c_writel(chip, CAMR, word);
0236 
0237     /* Enable channel A event interrupt */
0238     word = ac97c_readl(chip, IMR);
0239     word |= AC97C_SR_CAEVT;
0240     ac97c_writel(chip, IER, word);
0241 
0242     /* set variable rate if needed */
0243     if (runtime->rate != 48000) {
0244         word = ac97c_readl(chip, MR);
0245         word |= AC97C_MR_VRA;
0246         ac97c_writel(chip, MR, word);
0247     } else {
0248         word = ac97c_readl(chip, MR);
0249         word &= ~(AC97C_MR_VRA);
0250         ac97c_writel(chip, MR, word);
0251     }
0252 
0253     retval = snd_ac97_set_rate(chip->ac97, AC97_PCM_FRONT_DAC_RATE,
0254             runtime->rate);
0255     if (retval)
0256         dev_dbg(&chip->pdev->dev, "could not set rate %d Hz\n",
0257                 runtime->rate);
0258 
0259     /* Initialize and start the PDC */
0260     writel(runtime->dma_addr, chip->regs + ATMEL_PDC_TPR);
0261     writel(block_size / 2, chip->regs + ATMEL_PDC_TCR);
0262     writel(runtime->dma_addr + block_size, chip->regs + ATMEL_PDC_TNPR);
0263     writel(block_size / 2, chip->regs + ATMEL_PDC_TNCR);
0264 
0265     return retval;
0266 }
0267 
0268 static int atmel_ac97c_capture_prepare(struct snd_pcm_substream *substream)
0269 {
0270     struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
0271     struct snd_pcm_runtime *runtime = substream->runtime;
0272     int block_size = frames_to_bytes(runtime, runtime->period_size);
0273     unsigned long word = ac97c_readl(chip, ICA);
0274     int retval;
0275 
0276     chip->capture_period = 0;
0277     word &= ~(AC97C_CH_MASK(PCM_LEFT) | AC97C_CH_MASK(PCM_RIGHT));
0278 
0279     /* assign channels to AC97C channel A */
0280     switch (runtime->channels) {
0281     case 1:
0282         word |= AC97C_CH_ASSIGN(PCM_LEFT, A);
0283         break;
0284     case 2:
0285         word |= AC97C_CH_ASSIGN(PCM_LEFT, A)
0286             | AC97C_CH_ASSIGN(PCM_RIGHT, A);
0287         break;
0288     default:
0289         /* TODO: support more than two channels */
0290         return -EINVAL;
0291     }
0292     ac97c_writel(chip, ICA, word);
0293 
0294     /* configure sample format and size */
0295     word = ac97c_readl(chip, CAMR);
0296     if (chip->opened <= 1)
0297         word = AC97C_CMR_DMAEN | AC97C_CMR_SIZE_16;
0298     else
0299         word |= AC97C_CMR_DMAEN | AC97C_CMR_SIZE_16;
0300 
0301     switch (runtime->format) {
0302     case SNDRV_PCM_FORMAT_S16_LE:
0303         break;
0304     case SNDRV_PCM_FORMAT_S16_BE:
0305         word &= ~(AC97C_CMR_CEM_LITTLE);
0306         break;
0307     default:
0308         word = ac97c_readl(chip, ICA);
0309         word &= ~(AC97C_CH_MASK(PCM_LEFT) | AC97C_CH_MASK(PCM_RIGHT));
0310         ac97c_writel(chip, ICA, word);
0311         return -EINVAL;
0312     }
0313 
0314     /* Enable overrun interrupt on channel A */
0315     word |= AC97C_CSR_OVRUN;
0316 
0317     ac97c_writel(chip, CAMR, word);
0318 
0319     /* Enable channel A event interrupt */
0320     word = ac97c_readl(chip, IMR);
0321     word |= AC97C_SR_CAEVT;
0322     ac97c_writel(chip, IER, word);
0323 
0324     /* set variable rate if needed */
0325     if (runtime->rate != 48000) {
0326         word = ac97c_readl(chip, MR);
0327         word |= AC97C_MR_VRA;
0328         ac97c_writel(chip, MR, word);
0329     } else {
0330         word = ac97c_readl(chip, MR);
0331         word &= ~(AC97C_MR_VRA);
0332         ac97c_writel(chip, MR, word);
0333     }
0334 
0335     retval = snd_ac97_set_rate(chip->ac97, AC97_PCM_LR_ADC_RATE,
0336             runtime->rate);
0337     if (retval)
0338         dev_dbg(&chip->pdev->dev, "could not set rate %d Hz\n",
0339                 runtime->rate);
0340 
0341     /* Initialize and start the PDC */
0342     writel(runtime->dma_addr, chip->regs + ATMEL_PDC_RPR);
0343     writel(block_size / 2, chip->regs + ATMEL_PDC_RCR);
0344     writel(runtime->dma_addr + block_size, chip->regs + ATMEL_PDC_RNPR);
0345     writel(block_size / 2, chip->regs + ATMEL_PDC_RNCR);
0346 
0347     return retval;
0348 }
0349 
0350 static int
0351 atmel_ac97c_playback_trigger(struct snd_pcm_substream *substream, int cmd)
0352 {
0353     struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
0354     unsigned long camr, ptcr = 0;
0355 
0356     camr = ac97c_readl(chip, CAMR);
0357 
0358     switch (cmd) {
0359     case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
0360     case SNDRV_PCM_TRIGGER_RESUME:
0361     case SNDRV_PCM_TRIGGER_START:
0362         ptcr = ATMEL_PDC_TXTEN;
0363         camr |= AC97C_CMR_CENA | AC97C_CSR_ENDTX;
0364         break;
0365     case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
0366     case SNDRV_PCM_TRIGGER_SUSPEND:
0367     case SNDRV_PCM_TRIGGER_STOP:
0368         ptcr |= ATMEL_PDC_TXTDIS;
0369         if (chip->opened <= 1)
0370             camr &= ~AC97C_CMR_CENA;
0371         break;
0372     default:
0373         return -EINVAL;
0374     }
0375 
0376     ac97c_writel(chip, CAMR, camr);
0377     writel(ptcr, chip->regs + ATMEL_PDC_PTCR);
0378     return 0;
0379 }
0380 
0381 static int
0382 atmel_ac97c_capture_trigger(struct snd_pcm_substream *substream, int cmd)
0383 {
0384     struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
0385     unsigned long camr, ptcr = 0;
0386 
0387     camr = ac97c_readl(chip, CAMR);
0388     ptcr = readl(chip->regs + ATMEL_PDC_PTSR);
0389 
0390     switch (cmd) {
0391     case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
0392     case SNDRV_PCM_TRIGGER_RESUME:
0393     case SNDRV_PCM_TRIGGER_START:
0394         ptcr = ATMEL_PDC_RXTEN;
0395         camr |= AC97C_CMR_CENA | AC97C_CSR_ENDRX;
0396         break;
0397     case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
0398     case SNDRV_PCM_TRIGGER_SUSPEND:
0399     case SNDRV_PCM_TRIGGER_STOP:
0400         ptcr |= ATMEL_PDC_RXTDIS;
0401         if (chip->opened <= 1)
0402             camr &= ~AC97C_CMR_CENA;
0403         break;
0404     default:
0405         return -EINVAL;
0406     }
0407 
0408     ac97c_writel(chip, CAMR, camr);
0409     writel(ptcr, chip->regs + ATMEL_PDC_PTCR);
0410     return 0;
0411 }
0412 
0413 static snd_pcm_uframes_t
0414 atmel_ac97c_playback_pointer(struct snd_pcm_substream *substream)
0415 {
0416     struct atmel_ac97c  *chip = snd_pcm_substream_chip(substream);
0417     struct snd_pcm_runtime  *runtime = substream->runtime;
0418     snd_pcm_uframes_t   frames;
0419     unsigned long       bytes;
0420 
0421     bytes = readl(chip->regs + ATMEL_PDC_TPR);
0422     bytes -= runtime->dma_addr;
0423 
0424     frames = bytes_to_frames(runtime, bytes);
0425     if (frames >= runtime->buffer_size)
0426         frames -= runtime->buffer_size;
0427     return frames;
0428 }
0429 
0430 static snd_pcm_uframes_t
0431 atmel_ac97c_capture_pointer(struct snd_pcm_substream *substream)
0432 {
0433     struct atmel_ac97c  *chip = snd_pcm_substream_chip(substream);
0434     struct snd_pcm_runtime  *runtime = substream->runtime;
0435     snd_pcm_uframes_t   frames;
0436     unsigned long       bytes;
0437 
0438     bytes = readl(chip->regs + ATMEL_PDC_RPR);
0439     bytes -= runtime->dma_addr;
0440 
0441     frames = bytes_to_frames(runtime, bytes);
0442     if (frames >= runtime->buffer_size)
0443         frames -= runtime->buffer_size;
0444     return frames;
0445 }
0446 
0447 static const struct snd_pcm_ops atmel_ac97_playback_ops = {
0448     .open       = atmel_ac97c_playback_open,
0449     .close      = atmel_ac97c_playback_close,
0450     .hw_params  = atmel_ac97c_playback_hw_params,
0451     .prepare    = atmel_ac97c_playback_prepare,
0452     .trigger    = atmel_ac97c_playback_trigger,
0453     .pointer    = atmel_ac97c_playback_pointer,
0454 };
0455 
0456 static const struct snd_pcm_ops atmel_ac97_capture_ops = {
0457     .open       = atmel_ac97c_capture_open,
0458     .close      = atmel_ac97c_capture_close,
0459     .hw_params  = atmel_ac97c_capture_hw_params,
0460     .prepare    = atmel_ac97c_capture_prepare,
0461     .trigger    = atmel_ac97c_capture_trigger,
0462     .pointer    = atmel_ac97c_capture_pointer,
0463 };
0464 
0465 static irqreturn_t atmel_ac97c_interrupt(int irq, void *dev)
0466 {
0467     struct atmel_ac97c  *chip  = (struct atmel_ac97c *)dev;
0468     irqreturn_t     retval = IRQ_NONE;
0469     u32         sr     = ac97c_readl(chip, SR);
0470     u32         casr   = ac97c_readl(chip, CASR);
0471     u32         cosr   = ac97c_readl(chip, COSR);
0472     u32         camr   = ac97c_readl(chip, CAMR);
0473 
0474     if (sr & AC97C_SR_CAEVT) {
0475         struct snd_pcm_runtime *runtime;
0476         int offset, next_period, block_size;
0477         dev_dbg(&chip->pdev->dev, "channel A event%s%s%s%s%s%s\n",
0478             (casr & AC97C_CSR_OVRUN)   ? " OVRUN"   : "",
0479             (casr & AC97C_CSR_RXRDY)   ? " RXRDY"   : "",
0480             (casr & AC97C_CSR_UNRUN)   ? " UNRUN"   : "",
0481             (casr & AC97C_CSR_TXEMPTY) ? " TXEMPTY" : "",
0482             (casr & AC97C_CSR_TXRDY)   ? " TXRDY"   : "",
0483             !casr                      ? " NONE"    : "");
0484         if ((casr & camr) & AC97C_CSR_ENDTX) {
0485             runtime = chip->playback_substream->runtime;
0486             block_size = frames_to_bytes(runtime, runtime->period_size);
0487             chip->playback_period++;
0488 
0489             if (chip->playback_period == runtime->periods)
0490                 chip->playback_period = 0;
0491             next_period = chip->playback_period + 1;
0492             if (next_period == runtime->periods)
0493                 next_period = 0;
0494 
0495             offset = block_size * next_period;
0496 
0497             writel(runtime->dma_addr + offset, chip->regs + ATMEL_PDC_TNPR);
0498             writel(block_size / 2, chip->regs + ATMEL_PDC_TNCR);
0499 
0500             snd_pcm_period_elapsed(chip->playback_substream);
0501         }
0502         if ((casr & camr) & AC97C_CSR_ENDRX) {
0503             runtime = chip->capture_substream->runtime;
0504             block_size = frames_to_bytes(runtime, runtime->period_size);
0505             chip->capture_period++;
0506 
0507             if (chip->capture_period == runtime->periods)
0508                 chip->capture_period = 0;
0509             next_period = chip->capture_period + 1;
0510             if (next_period == runtime->periods)
0511                 next_period = 0;
0512 
0513             offset = block_size * next_period;
0514 
0515             writel(runtime->dma_addr + offset, chip->regs + ATMEL_PDC_RNPR);
0516             writel(block_size / 2, chip->regs + ATMEL_PDC_RNCR);
0517             snd_pcm_period_elapsed(chip->capture_substream);
0518         }
0519         retval = IRQ_HANDLED;
0520     }
0521 
0522     if (sr & AC97C_SR_COEVT) {
0523         dev_info(&chip->pdev->dev, "codec channel event%s%s%s%s%s\n",
0524              (cosr & AC97C_CSR_OVRUN)   ? " OVRUN"   : "",
0525              (cosr & AC97C_CSR_RXRDY)   ? " RXRDY"   : "",
0526              (cosr & AC97C_CSR_TXEMPTY) ? " TXEMPTY" : "",
0527              (cosr & AC97C_CSR_TXRDY)   ? " TXRDY"   : "",
0528              !cosr                      ? " NONE"    : "");
0529         retval = IRQ_HANDLED;
0530     }
0531 
0532     if (retval == IRQ_NONE) {
0533         dev_err(&chip->pdev->dev, "spurious interrupt sr 0x%08x "
0534                 "casr 0x%08x cosr 0x%08x\n", sr, casr, cosr);
0535     }
0536 
0537     return retval;
0538 }
0539 
0540 static const struct ac97_pcm at91_ac97_pcm_defs[] = {
0541     /* Playback */
0542     {
0543         .exclusive = 1,
0544         .r = { {
0545             .slots = ((1 << AC97_SLOT_PCM_LEFT)
0546                   | (1 << AC97_SLOT_PCM_RIGHT)),
0547         } },
0548     },
0549     /* PCM in */
0550     {
0551         .stream = 1,
0552         .exclusive = 1,
0553         .r = { {
0554             .slots = ((1 << AC97_SLOT_PCM_LEFT)
0555                     | (1 << AC97_SLOT_PCM_RIGHT)),
0556         } }
0557     },
0558     /* Mic in */
0559     {
0560         .stream = 1,
0561         .exclusive = 1,
0562         .r = { {
0563             .slots = (1<<AC97_SLOT_MIC),
0564         } }
0565     },
0566 };
0567 
0568 static int atmel_ac97c_pcm_new(struct atmel_ac97c *chip)
0569 {
0570     struct snd_pcm      *pcm;
0571     struct snd_pcm_hardware hw = atmel_ac97c_hw;
0572     int         retval;
0573 
0574     retval = snd_ac97_pcm_assign(chip->ac97_bus,
0575                      ARRAY_SIZE(at91_ac97_pcm_defs),
0576                      at91_ac97_pcm_defs);
0577     if (retval)
0578         return retval;
0579 
0580     retval = snd_pcm_new(chip->card, chip->card->shortname, 0, 1, 1, &pcm);
0581     if (retval)
0582         return retval;
0583 
0584     snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &atmel_ac97_capture_ops);
0585     snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &atmel_ac97_playback_ops);
0586 
0587     snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV,
0588             &chip->pdev->dev, hw.periods_min * hw.period_bytes_min,
0589             hw.buffer_bytes_max);
0590 
0591     pcm->private_data = chip;
0592     pcm->info_flags = 0;
0593     strcpy(pcm->name, chip->card->shortname);
0594     chip->pcm = pcm;
0595 
0596     return 0;
0597 }
0598 
0599 static int atmel_ac97c_mixer_new(struct atmel_ac97c *chip)
0600 {
0601     struct snd_ac97_template template;
0602     memset(&template, 0, sizeof(template));
0603     template.private_data = chip;
0604     return snd_ac97_mixer(chip->ac97_bus, &template, &chip->ac97);
0605 }
0606 
0607 static void atmel_ac97c_write(struct snd_ac97 *ac97, unsigned short reg,
0608         unsigned short val)
0609 {
0610     struct atmel_ac97c *chip = get_chip(ac97);
0611     unsigned long word;
0612     int timeout = 40;
0613 
0614     word = (reg & 0x7f) << 16 | val;
0615 
0616     do {
0617         if (ac97c_readl(chip, COSR) & AC97C_CSR_TXRDY) {
0618             ac97c_writel(chip, COTHR, word);
0619             return;
0620         }
0621         udelay(1);
0622     } while (--timeout);
0623 
0624     dev_dbg(&chip->pdev->dev, "codec write timeout\n");
0625 }
0626 
0627 static unsigned short atmel_ac97c_read(struct snd_ac97 *ac97,
0628         unsigned short reg)
0629 {
0630     struct atmel_ac97c *chip = get_chip(ac97);
0631     unsigned long word;
0632     int timeout = 40;
0633     int write = 10;
0634 
0635     word = (0x80 | (reg & 0x7f)) << 16;
0636 
0637     if ((ac97c_readl(chip, COSR) & AC97C_CSR_RXRDY) != 0)
0638         ac97c_readl(chip, CORHR);
0639 
0640 retry_write:
0641     timeout = 40;
0642 
0643     do {
0644         if ((ac97c_readl(chip, COSR) & AC97C_CSR_TXRDY) != 0) {
0645             ac97c_writel(chip, COTHR, word);
0646             goto read_reg;
0647         }
0648         udelay(10);
0649     } while (--timeout);
0650 
0651     if (!--write)
0652         goto timed_out;
0653     goto retry_write;
0654 
0655 read_reg:
0656     do {
0657         if ((ac97c_readl(chip, COSR) & AC97C_CSR_RXRDY) != 0) {
0658             unsigned short val = ac97c_readl(chip, CORHR);
0659             return val;
0660         }
0661         udelay(10);
0662     } while (--timeout);
0663 
0664     if (!--write)
0665         goto timed_out;
0666     goto retry_write;
0667 
0668 timed_out:
0669     dev_dbg(&chip->pdev->dev, "codec read timeout\n");
0670     return 0xffff;
0671 }
0672 
0673 static void atmel_ac97c_reset(struct atmel_ac97c *chip)
0674 {
0675     ac97c_writel(chip, MR,   0);
0676     ac97c_writel(chip, MR,   AC97C_MR_ENA);
0677     ac97c_writel(chip, CAMR, 0);
0678     ac97c_writel(chip, COMR, 0);
0679 
0680     if (!IS_ERR(chip->reset_pin)) {
0681         gpiod_set_value(chip->reset_pin, 0);
0682         /* AC97 v2.2 specifications says minimum 1 us. */
0683         udelay(2);
0684         gpiod_set_value(chip->reset_pin, 1);
0685     } else {
0686         ac97c_writel(chip, MR, AC97C_MR_WRST | AC97C_MR_ENA);
0687         udelay(2);
0688         ac97c_writel(chip, MR, AC97C_MR_ENA);
0689     }
0690 }
0691 
0692 static const struct of_device_id atmel_ac97c_dt_ids[] = {
0693     { .compatible = "atmel,at91sam9263-ac97c", },
0694     { }
0695 };
0696 MODULE_DEVICE_TABLE(of, atmel_ac97c_dt_ids);
0697 
0698 static int atmel_ac97c_probe(struct platform_device *pdev)
0699 {
0700     struct device           *dev = &pdev->dev;
0701     struct snd_card         *card;
0702     struct atmel_ac97c      *chip;
0703     struct resource         *regs;
0704     struct clk          *pclk;
0705     static const struct snd_ac97_bus_ops    ops = {
0706         .write  = atmel_ac97c_write,
0707         .read   = atmel_ac97c_read,
0708     };
0709     int             retval;
0710     int             irq;
0711 
0712     regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
0713     if (!regs) {
0714         dev_dbg(&pdev->dev, "no memory resource\n");
0715         return -ENXIO;
0716     }
0717 
0718     irq = platform_get_irq(pdev, 0);
0719     if (irq < 0) {
0720         dev_dbg(&pdev->dev, "could not get irq: %d\n", irq);
0721         return irq;
0722     }
0723 
0724     pclk = clk_get(&pdev->dev, "ac97_clk");
0725     if (IS_ERR(pclk)) {
0726         dev_dbg(&pdev->dev, "no peripheral clock\n");
0727         return PTR_ERR(pclk);
0728     }
0729     retval = clk_prepare_enable(pclk);
0730     if (retval)
0731         goto err_prepare_enable;
0732 
0733     retval = snd_card_new(&pdev->dev, SNDRV_DEFAULT_IDX1,
0734                   SNDRV_DEFAULT_STR1, THIS_MODULE,
0735                   sizeof(struct atmel_ac97c), &card);
0736     if (retval) {
0737         dev_dbg(&pdev->dev, "could not create sound card device\n");
0738         goto err_snd_card_new;
0739     }
0740 
0741     chip = get_chip(card);
0742 
0743     retval = request_irq(irq, atmel_ac97c_interrupt, 0, "AC97C", chip);
0744     if (retval) {
0745         dev_dbg(&pdev->dev, "unable to request irq %d\n", irq);
0746         goto err_request_irq;
0747     }
0748     chip->irq = irq;
0749 
0750     spin_lock_init(&chip->lock);
0751 
0752     strcpy(card->driver, "Atmel AC97C");
0753     strcpy(card->shortname, "Atmel AC97C");
0754     sprintf(card->longname, "Atmel AC97 controller");
0755 
0756     chip->card = card;
0757     chip->pclk = pclk;
0758     chip->pdev = pdev;
0759     chip->regs = ioremap(regs->start, resource_size(regs));
0760 
0761     if (!chip->regs) {
0762         dev_dbg(&pdev->dev, "could not remap register memory\n");
0763         retval = -ENOMEM;
0764         goto err_ioremap;
0765     }
0766 
0767     chip->reset_pin = devm_gpiod_get_index(dev, "ac97", 2, GPIOD_OUT_HIGH);
0768     if (IS_ERR(chip->reset_pin))
0769         dev_dbg(dev, "reset pin not available\n");
0770 
0771     atmel_ac97c_reset(chip);
0772 
0773     /* Enable overrun interrupt from codec channel */
0774     ac97c_writel(chip, COMR, AC97C_CSR_OVRUN);
0775     ac97c_writel(chip, IER, ac97c_readl(chip, IMR) | AC97C_SR_COEVT);
0776 
0777     retval = snd_ac97_bus(card, 0, &ops, chip, &chip->ac97_bus);
0778     if (retval) {
0779         dev_dbg(&pdev->dev, "could not register on ac97 bus\n");
0780         goto err_ac97_bus;
0781     }
0782 
0783     retval = atmel_ac97c_mixer_new(chip);
0784     if (retval) {
0785         dev_dbg(&pdev->dev, "could not register ac97 mixer\n");
0786         goto err_ac97_bus;
0787     }
0788 
0789     retval = atmel_ac97c_pcm_new(chip);
0790     if (retval) {
0791         dev_dbg(&pdev->dev, "could not register ac97 pcm device\n");
0792         goto err_ac97_bus;
0793     }
0794 
0795     retval = snd_card_register(card);
0796     if (retval) {
0797         dev_dbg(&pdev->dev, "could not register sound card\n");
0798         goto err_ac97_bus;
0799     }
0800 
0801     platform_set_drvdata(pdev, card);
0802 
0803     dev_info(&pdev->dev, "Atmel AC97 controller at 0x%p, irq = %d\n",
0804             chip->regs, irq);
0805 
0806     return 0;
0807 
0808 err_ac97_bus:
0809     iounmap(chip->regs);
0810 err_ioremap:
0811     free_irq(irq, chip);
0812 err_request_irq:
0813     snd_card_free(card);
0814 err_snd_card_new:
0815     clk_disable_unprepare(pclk);
0816 err_prepare_enable:
0817     clk_put(pclk);
0818     return retval;
0819 }
0820 
0821 #ifdef CONFIG_PM_SLEEP
0822 static int atmel_ac97c_suspend(struct device *pdev)
0823 {
0824     struct snd_card *card = dev_get_drvdata(pdev);
0825     struct atmel_ac97c *chip = card->private_data;
0826 
0827     clk_disable_unprepare(chip->pclk);
0828     return 0;
0829 }
0830 
0831 static int atmel_ac97c_resume(struct device *pdev)
0832 {
0833     struct snd_card *card = dev_get_drvdata(pdev);
0834     struct atmel_ac97c *chip = card->private_data;
0835     int ret = clk_prepare_enable(chip->pclk);
0836 
0837     return ret;
0838 }
0839 
0840 static SIMPLE_DEV_PM_OPS(atmel_ac97c_pm, atmel_ac97c_suspend, atmel_ac97c_resume);
0841 #define ATMEL_AC97C_PM_OPS  &atmel_ac97c_pm
0842 #else
0843 #define ATMEL_AC97C_PM_OPS  NULL
0844 #endif
0845 
0846 static int atmel_ac97c_remove(struct platform_device *pdev)
0847 {
0848     struct snd_card *card = platform_get_drvdata(pdev);
0849     struct atmel_ac97c *chip = get_chip(card);
0850 
0851     ac97c_writel(chip, CAMR, 0);
0852     ac97c_writel(chip, COMR, 0);
0853     ac97c_writel(chip, MR,   0);
0854 
0855     clk_disable_unprepare(chip->pclk);
0856     clk_put(chip->pclk);
0857     iounmap(chip->regs);
0858     free_irq(chip->irq, chip);
0859 
0860     snd_card_free(card);
0861 
0862     return 0;
0863 }
0864 
0865 static struct platform_driver atmel_ac97c_driver = {
0866     .probe      = atmel_ac97c_probe,
0867     .remove     = atmel_ac97c_remove,
0868     .driver     = {
0869         .name   = "atmel_ac97c",
0870         .pm = ATMEL_AC97C_PM_OPS,
0871         .of_match_table = atmel_ac97c_dt_ids,
0872     },
0873 };
0874 module_platform_driver(atmel_ac97c_driver);
0875 
0876 MODULE_LICENSE("GPL");
0877 MODULE_DESCRIPTION("Driver for Atmel AC97 controller");
0878 MODULE_AUTHOR("Hans-Christian Egtvedt <egtvedt@samfundet.no>");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!