linux/sound/soc/uniphier/aio-dma.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2//
   3// Socionext UniPhier AIO DMA driver.
   4//
   5// Copyright (c) 2016-2018 Socionext Inc.
   6
   7#include <linux/dma-mapping.h>
   8#include <linux/errno.h>
   9#include <linux/kernel.h>
  10#include <linux/module.h>
  11#include <sound/core.h>
  12#include <sound/pcm.h>
  13#include <sound/soc.h>
  14
  15#include "aio.h"
  16
  17static struct snd_pcm_hardware uniphier_aiodma_hw = {
  18        .info = SNDRV_PCM_INFO_MMAP |
  19                SNDRV_PCM_INFO_MMAP_VALID |
  20                SNDRV_PCM_INFO_INTERLEAVED,
  21        .period_bytes_min = 256,
  22        .period_bytes_max = 4096,
  23        .periods_min      = 4,
  24        .periods_max      = 1024,
  25        .buffer_bytes_max = 128 * 1024,
  26};
  27
  28static void aiodma_pcm_irq(struct uniphier_aio_sub *sub)
  29{
  30        struct snd_pcm_runtime *runtime = sub->substream->runtime;
  31        int bytes = runtime->period_size *
  32                runtime->channels * samples_to_bytes(runtime, 1);
  33        int ret;
  34
  35        spin_lock(&sub->lock);
  36        ret = aiodma_rb_set_threshold(sub, runtime->dma_bytes,
  37                                      sub->threshold + bytes);
  38        if (!ret)
  39                sub->threshold += bytes;
  40
  41        aiodma_rb_sync(sub, runtime->dma_addr, runtime->dma_bytes, bytes);
  42        aiodma_rb_clear_irq(sub);
  43        spin_unlock(&sub->lock);
  44
  45        snd_pcm_period_elapsed(sub->substream);
  46}
  47
  48static void aiodma_compr_irq(struct uniphier_aio_sub *sub)
  49{
  50        struct snd_compr_runtime *runtime = sub->cstream->runtime;
  51        int bytes = runtime->fragment_size;
  52        int ret;
  53
  54        spin_lock(&sub->lock);
  55        ret = aiodma_rb_set_threshold(sub, sub->compr_bytes,
  56                                      sub->threshold + bytes);
  57        if (!ret)
  58                sub->threshold += bytes;
  59
  60        aiodma_rb_sync(sub, sub->compr_addr, sub->compr_bytes, bytes);
  61        aiodma_rb_clear_irq(sub);
  62        spin_unlock(&sub->lock);
  63
  64        snd_compr_fragment_elapsed(sub->cstream);
  65}
  66
  67static irqreturn_t aiodma_irq(int irq, void *p)
  68{
  69        struct platform_device *pdev = p;
  70        struct uniphier_aio_chip *chip = platform_get_drvdata(pdev);
  71        irqreturn_t ret = IRQ_NONE;
  72        int i, j;
  73
  74        for (i = 0; i < chip->num_aios; i++) {
  75                struct uniphier_aio *aio = &chip->aios[i];
  76
  77                for (j = 0; j < ARRAY_SIZE(aio->sub); j++) {
  78                        struct uniphier_aio_sub *sub = &aio->sub[j];
  79
  80                        /* Skip channel that does not trigger */
  81                        if (!sub->running || !aiodma_rb_is_irq(sub))
  82                                continue;
  83
  84                        if (sub->substream)
  85                                aiodma_pcm_irq(sub);
  86                        if (sub->cstream)
  87                                aiodma_compr_irq(sub);
  88
  89                        ret = IRQ_HANDLED;
  90                }
  91        }
  92
  93        return ret;
  94}
  95
  96static int uniphier_aiodma_open(struct snd_pcm_substream *substream)
  97{
  98        struct snd_pcm_runtime *runtime = substream->runtime;
  99
 100        snd_soc_set_runtime_hwparams(substream, &uniphier_aiodma_hw);
 101
 102        return snd_pcm_hw_constraint_step(runtime, 0,
 103                SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 256);
 104}
 105
 106static int uniphier_aiodma_hw_params(struct snd_pcm_substream *substream,
 107                                     struct snd_pcm_hw_params *params)
 108{
 109        snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
 110        substream->runtime->dma_bytes = params_buffer_bytes(params);
 111
 112        return 0;
 113}
 114
 115static int uniphier_aiodma_hw_free(struct snd_pcm_substream *substream)
 116{
 117        snd_pcm_set_runtime_buffer(substream, NULL);
 118        substream->runtime->dma_bytes = 0;
 119
 120        return 0;
 121}
 122
 123static int uniphier_aiodma_prepare(struct snd_pcm_substream *substream)
 124{
 125        struct snd_pcm_runtime *runtime = substream->runtime;
 126        struct snd_soc_pcm_runtime *rtd = snd_pcm_substream_chip(substream);
 127        struct uniphier_aio *aio = uniphier_priv(rtd->cpu_dai);
 128        struct uniphier_aio_sub *sub = &aio->sub[substream->stream];
 129        int bytes = runtime->period_size *
 130                runtime->channels * samples_to_bytes(runtime, 1);
 131        unsigned long flags;
 132        int ret;
 133
 134        ret = aiodma_ch_set_param(sub);
 135        if (ret)
 136                return ret;
 137
 138        spin_lock_irqsave(&sub->lock, flags);
 139        ret = aiodma_rb_set_buffer(sub, runtime->dma_addr,
 140                                   runtime->dma_addr + runtime->dma_bytes,
 141                                   bytes);
 142        spin_unlock_irqrestore(&sub->lock, flags);
 143        if (ret)
 144                return ret;
 145
 146        return 0;
 147}
 148
 149static int uniphier_aiodma_trigger(struct snd_pcm_substream *substream, int cmd)
 150{
 151        struct snd_pcm_runtime *runtime = substream->runtime;
 152        struct snd_soc_pcm_runtime *rtd = snd_pcm_substream_chip(substream);
 153        struct uniphier_aio *aio = uniphier_priv(rtd->cpu_dai);
 154        struct uniphier_aio_sub *sub = &aio->sub[substream->stream];
 155        struct device *dev = &aio->chip->pdev->dev;
 156        int bytes = runtime->period_size *
 157                runtime->channels * samples_to_bytes(runtime, 1);
 158        unsigned long flags;
 159
 160        spin_lock_irqsave(&sub->lock, flags);
 161        switch (cmd) {
 162        case SNDRV_PCM_TRIGGER_START:
 163                aiodma_rb_sync(sub, runtime->dma_addr, runtime->dma_bytes,
 164                               bytes);
 165                aiodma_ch_set_enable(sub, 1);
 166                sub->running = 1;
 167
 168                break;
 169        case SNDRV_PCM_TRIGGER_STOP:
 170                sub->running = 0;
 171                aiodma_ch_set_enable(sub, 0);
 172
 173                break;
 174        default:
 175                dev_warn(dev, "Unknown trigger(%d) ignored\n", cmd);
 176                break;
 177        }
 178        spin_unlock_irqrestore(&sub->lock, flags);
 179
 180        return 0;
 181}
 182
 183static snd_pcm_uframes_t uniphier_aiodma_pointer(
 184                                        struct snd_pcm_substream *substream)
 185{
 186        struct snd_pcm_runtime *runtime = substream->runtime;
 187        struct snd_soc_pcm_runtime *rtd = snd_pcm_substream_chip(substream);
 188        struct uniphier_aio *aio = uniphier_priv(rtd->cpu_dai);
 189        struct uniphier_aio_sub *sub = &aio->sub[substream->stream];
 190        int bytes = runtime->period_size *
 191                runtime->channels * samples_to_bytes(runtime, 1);
 192        unsigned long flags;
 193        snd_pcm_uframes_t pos;
 194
 195        spin_lock_irqsave(&sub->lock, flags);
 196        aiodma_rb_sync(sub, runtime->dma_addr, runtime->dma_bytes, bytes);
 197
 198        if (sub->swm->dir == PORT_DIR_OUTPUT)
 199                pos = bytes_to_frames(runtime, sub->rd_offs);
 200        else
 201                pos = bytes_to_frames(runtime, sub->wr_offs);
 202        spin_unlock_irqrestore(&sub->lock, flags);
 203
 204        return pos;
 205}
 206
 207static int uniphier_aiodma_mmap(struct snd_pcm_substream *substream,
 208                                struct vm_area_struct *vma)
 209{
 210        vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
 211
 212        return remap_pfn_range(vma, vma->vm_start,
 213                               substream->dma_buffer.addr >> PAGE_SHIFT,
 214                               vma->vm_end - vma->vm_start, vma->vm_page_prot);
 215}
 216
 217static const struct snd_pcm_ops uniphier_aiodma_ops = {
 218        .open      = uniphier_aiodma_open,
 219        .ioctl     = snd_pcm_lib_ioctl,
 220        .hw_params = uniphier_aiodma_hw_params,
 221        .hw_free   = uniphier_aiodma_hw_free,
 222        .prepare   = uniphier_aiodma_prepare,
 223        .trigger   = uniphier_aiodma_trigger,
 224        .pointer   = uniphier_aiodma_pointer,
 225        .mmap      = uniphier_aiodma_mmap,
 226};
 227
 228static int uniphier_aiodma_new(struct snd_soc_pcm_runtime *rtd)
 229{
 230        struct device *dev = rtd->card->snd_card->dev;
 231        struct snd_pcm *pcm = rtd->pcm;
 232        int ret;
 233
 234        ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(33));
 235        if (ret)
 236                return ret;
 237
 238        return snd_pcm_lib_preallocate_pages_for_all(pcm,
 239                SNDRV_DMA_TYPE_DEV, dev,
 240                uniphier_aiodma_hw.buffer_bytes_max,
 241                uniphier_aiodma_hw.buffer_bytes_max);
 242}
 243
 244static void uniphier_aiodma_free(struct snd_pcm *pcm)
 245{
 246        snd_pcm_lib_preallocate_free_for_all(pcm);
 247}
 248
 249static const struct snd_soc_component_driver uniphier_soc_platform = {
 250        .pcm_new   = uniphier_aiodma_new,
 251        .pcm_free  = uniphier_aiodma_free,
 252        .ops       = &uniphier_aiodma_ops,
 253        .compr_ops = &uniphier_aio_compr_ops,
 254};
 255
 256static const struct regmap_config aiodma_regmap_config = {
 257        .reg_bits      = 32,
 258        .reg_stride    = 4,
 259        .val_bits      = 32,
 260        .max_register  = 0x7fffc,
 261        .cache_type    = REGCACHE_NONE,
 262};
 263
 264/**
 265 * uniphier_aiodma_soc_register_platform - register the AIO DMA
 266 * @pdev: the platform device
 267 *
 268 * Register and setup the DMA of AIO to transfer the sound data to device.
 269 * This function need to call once at driver startup and need NOT to call
 270 * unregister function.
 271 *
 272 * Return: Zero if successful, otherwise a negative value on error.
 273 */
 274int uniphier_aiodma_soc_register_platform(struct platform_device *pdev)
 275{
 276        struct uniphier_aio_chip *chip = platform_get_drvdata(pdev);
 277        struct device *dev = &pdev->dev;
 278        struct resource *res;
 279        void __iomem *preg;
 280        int irq, ret;
 281
 282        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 283        preg = devm_ioremap_resource(dev, res);
 284        if (IS_ERR(preg))
 285                return PTR_ERR(preg);
 286
 287        chip->regmap = devm_regmap_init_mmio(dev, preg,
 288                                             &aiodma_regmap_config);
 289        if (IS_ERR(chip->regmap))
 290                return PTR_ERR(chip->regmap);
 291
 292        irq = platform_get_irq(pdev, 0);
 293        if (irq < 0) {
 294                dev_err(dev, "Could not get irq.\n");
 295                return irq;
 296        }
 297
 298        ret = devm_request_irq(dev, irq, aiodma_irq,
 299                               IRQF_SHARED, dev_name(dev), pdev);
 300        if (ret)
 301                return ret;
 302
 303        return devm_snd_soc_register_component(dev, &uniphier_soc_platform,
 304                                               NULL, 0);
 305}
 306EXPORT_SYMBOL_GPL(uniphier_aiodma_soc_register_platform);
 307