sound/soc/qcom/lpass-platform.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2010-2011,2013-2015 The Linux Foundation. All rights reserved.
   4  *
   5  * lpass-platform.c -- ALSA SoC platform driver for QTi LPASS
   6  */
   7
   8 #include <linux/dma-mapping.h>
   9 #include <linux/export.h>
  10 #include <linux/kernel.h>
  11 #include <linux/module.h>
  12 #include <linux/platform_device.h>
  13 #include <sound/pcm_params.h>
  14 #include <linux/regmap.h>
  15 #include <sound/soc.h>
  16 #include "lpass-lpaif-reg.h"
  17 #include "lpass.h"
  18
  19 #define DRV_NAME "lpass-platform"
  20
  21 #define LPASS_PLATFORM_BUFFER_SIZE      (24 *  2 * 1024)
  22 #define LPASS_PLATFORM_PERIODS          2
  23 #define LPASS_RXTX_CDC_DMA_LPM_BUFF_SIZE (8 * 1024)
  24 #define LPASS_VA_CDC_DMA_LPM_BUFF_SIZE (12 * 1024)
  25 #define LPASS_CDC_DMA_REGISTER_FIELDS_MAX 15
  26
  27 static const struct snd_pcm_hardware lpass_platform_pcm_hardware = {
  28         .info                   =       SNDRV_PCM_INFO_MMAP |
  29                                         SNDRV_PCM_INFO_MMAP_VALID |
  30                                         SNDRV_PCM_INFO_INTERLEAVED |
  31                                         SNDRV_PCM_INFO_PAUSE |
  32                                         SNDRV_PCM_INFO_RESUME,
  33         .formats                =       SNDRV_PCM_FMTBIT_S16 |
  34                                         SNDRV_PCM_FMTBIT_S24 |
  35                                         SNDRV_PCM_FMTBIT_S32,
  36         .rates                  =       SNDRV_PCM_RATE_8000_192000,
  37         .rate_min               =       8000,
  38         .rate_max               =       192000,
  39         .channels_min           =       1,
  40         .channels_max           =       8,
  41         .buffer_bytes_max       =       LPASS_PLATFORM_BUFFER_SIZE,
  42         .period_bytes_max       =       LPASS_PLATFORM_BUFFER_SIZE /
  43                                                 LPASS_PLATFORM_PERIODS,
  44         .period_bytes_min       =       LPASS_PLATFORM_BUFFER_SIZE /
  45                                                 LPASS_PLATFORM_PERIODS,
  46         .periods_min            =       LPASS_PLATFORM_PERIODS,
  47         .periods_max            =       LPASS_PLATFORM_PERIODS,
  48         .fifo_size              =       0,
  49 };
  50
  51 static const struct snd_pcm_hardware lpass_platform_rxtx_hardware = {
  52         .info                   =       SNDRV_PCM_INFO_MMAP |
  53                                         SNDRV_PCM_INFO_MMAP_VALID |
  54                                         SNDRV_PCM_INFO_INTERLEAVED |
  55                                         SNDRV_PCM_INFO_PAUSE |
  56                                         SNDRV_PCM_INFO_RESUME,
  57         .formats                =       SNDRV_PCM_FMTBIT_S16 |
  58                                         SNDRV_PCM_FMTBIT_S24 |
  59                                         SNDRV_PCM_FMTBIT_S32,
  60         .rates                  =       SNDRV_PCM_RATE_8000_192000,
  61         .rate_min               =       8000,
  62         .rate_max               =       192000,
  63         .channels_min           =       1,
  64         .channels_max           =       8,
  65         .buffer_bytes_max       =       LPASS_RXTX_CDC_DMA_LPM_BUFF_SIZE,
  66         .period_bytes_max       =       LPASS_RXTX_CDC_DMA_LPM_BUFF_SIZE /
  67                                                 LPASS_PLATFORM_PERIODS,
  68         .period_bytes_min       =       LPASS_RXTX_CDC_DMA_LPM_BUFF_SIZE /
  69                                                 LPASS_PLATFORM_PERIODS,
  70         .periods_min            =       LPASS_PLATFORM_PERIODS,
  71         .periods_max            =       LPASS_PLATFORM_PERIODS,
  72         .fifo_size              =       0,
  73 };
  74
  75 static const struct snd_pcm_hardware lpass_platform_va_hardware = {
  76         .info                   =       SNDRV_PCM_INFO_MMAP |
  77                                         SNDRV_PCM_INFO_MMAP_VALID |
  78                                         SNDRV_PCM_INFO_INTERLEAVED |
  79                                         SNDRV_PCM_INFO_PAUSE |
  80                                         SNDRV_PCM_INFO_RESUME,
  81         .formats                =       SNDRV_PCM_FMTBIT_S16 |
  82                                         SNDRV_PCM_FMTBIT_S24 |
  83                                         SNDRV_PCM_FMTBIT_S32,
  84         .rates                  =       SNDRV_PCM_RATE_8000_192000,
  85         .rate_min               =       8000,
  86         .rate_max               =       192000,
  87         .channels_min           =       1,
  88         .channels_max           =       8,
  89         .buffer_bytes_max       =       LPASS_VA_CDC_DMA_LPM_BUFF_SIZE,
  90         .period_bytes_max       =       LPASS_VA_CDC_DMA_LPM_BUFF_SIZE /
  91                                                 LPASS_PLATFORM_PERIODS,
  92         .period_bytes_min       =       LPASS_VA_CDC_DMA_LPM_BUFF_SIZE /
  93                                                 LPASS_PLATFORM_PERIODS,
  94         .periods_min            =       LPASS_PLATFORM_PERIODS,
  95         .periods_max            =       LPASS_PLATFORM_PERIODS,
  96         .fifo_size              =       0,
  97 };
  98
  99 static int lpass_platform_alloc_rxtx_dmactl_fields(struct device *dev,
 100                                          struct regmap *map)
 101 {
 102         struct lpass_data *drvdata = dev_get_drvdata(dev);
 103         struct lpass_variant *v = drvdata->variant;
 104         struct lpaif_dmactl *rd_dmactl, *wr_dmactl;
 105         int rval;
 106
 107         rd_dmactl = devm_kzalloc(dev, sizeof(*rd_dmactl), GFP_KERNEL);
 108         if (!rd_dmactl)
 109                 return -ENOMEM;
 110
 111         wr_dmactl = devm_kzalloc(dev, sizeof(*wr_dmactl), GFP_KERNEL);
 112         if (!wr_dmactl)
 113                 return -ENOMEM;
 114
 115         drvdata->rxtx_rd_dmactl = rd_dmactl;
 116         drvdata->rxtx_wr_dmactl = wr_dmactl;
 117
 118         rval = devm_regmap_field_bulk_alloc(dev, map, &rd_dmactl->intf,
 119                                             &v->rxtx_rdma_intf, LPASS_CDC_DMA_REGISTER_FIELDS_MAX);
 120         if (rval)
 121                 return rval;
 122
 123         return devm_regmap_field_bulk_alloc(dev, map, &wr_dmactl->intf,
 124                                             &v->rxtx_wrdma_intf, LPASS_CDC_DMA_REGISTER_FIELDS_MAX);
 125 }
 126
 127 static int lpass_platform_alloc_va_dmactl_fields(struct device *dev,
 128                                          struct regmap *map)
 129 {
 130         struct lpass_data *drvdata = dev_get_drvdata(dev);
 131         struct lpass_variant *v = drvdata->variant;
 132         struct lpaif_dmactl *wr_dmactl;
 133
 134         wr_dmactl = devm_kzalloc(dev, sizeof(*wr_dmactl), GFP_KERNEL);
 135         if (!wr_dmactl)
 136                 return -ENOMEM;
 137
 138         drvdata->va_wr_dmactl = wr_dmactl;
 139         return devm_regmap_field_bulk_alloc(dev, map, &wr_dmactl->intf,
 140                                             &v->va_wrdma_intf, LPASS_CDC_DMA_REGISTER_FIELDS_MAX);
 141 }
 142
 143
 144 static int lpass_platform_alloc_dmactl_fields(struct device *dev,
 145                                          struct regmap *map)
 146 {
 147         struct lpass_data *drvdata = dev_get_drvdata(dev);
 148         struct lpass_variant *v = drvdata->variant;
 149         struct lpaif_dmactl *rd_dmactl, *wr_dmactl;
 150         int rval;
 151
 152         drvdata->rd_dmactl = devm_kzalloc(dev, sizeof(struct lpaif_dmactl),
 153                                           GFP_KERNEL);
 154         if (drvdata->rd_dmactl == NULL)
 155                 return -ENOMEM;
 156
 157         drvdata->wr_dmactl = devm_kzalloc(dev, sizeof(struct lpaif_dmactl),
 158                                           GFP_KERNEL);
 159         if (drvdata->wr_dmactl == NULL)
 160                 return -ENOMEM;
 161
 162         rd_dmactl = drvdata->rd_dmactl;
 163         wr_dmactl = drvdata->wr_dmactl;
 164
 165         rval = devm_regmap_field_bulk_alloc(dev, map, &rd_dmactl->intf,
 166                                             &v->rdma_intf, 6);
 167         if (rval)
 168                 return rval;
 169
 170         return devm_regmap_field_bulk_alloc(dev, map, &wr_dmactl->intf,
 171                                             &v->wrdma_intf, 6);
 172 }
 173
 174 static int lpass_platform_alloc_hdmidmactl_fields(struct device *dev,
 175                                          struct regmap *map)
 176 {
 177         struct lpass_data *drvdata = dev_get_drvdata(dev);
 178         struct lpass_variant *v = drvdata->variant;
 179         struct lpaif_dmactl *rd_dmactl;
 180
 181         rd_dmactl = devm_kzalloc(dev, sizeof(struct lpaif_dmactl), GFP_KERNEL);
 182         if (rd_dmactl == NULL)
 183                 return -ENOMEM;
 184
 185         drvdata->hdmi_rd_dmactl = rd_dmactl;
 186
 187         return devm_regmap_field_bulk_alloc(dev, map, &rd_dmactl->bursten,
 188                                             &v->hdmi_rdma_bursten, 8);
 189 }
 190
 191 static int lpass_platform_pcmops_open(struct snd_soc_component *component,
 192                                       struct snd_pcm_substream *substream)
 193 {
 194         struct snd_pcm_runtime *runtime = substream->runtime;
 195         struct snd_soc_pcm_runtime *soc_runtime = asoc_substream_to_rtd(substream);
 196         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(soc_runtime, 0);
 197         struct lpass_data *drvdata = snd_soc_component_get_drvdata(component);
 198         struct lpass_variant *v = drvdata->variant;
 199         int ret, dma_ch, dir = substream->stream;
 200         struct lpass_pcm_data *data;
 201         struct regmap *map;
 202         unsigned int dai_id = cpu_dai->driver->id;
 203
 204         component->id = dai_id;
 205         data = kzalloc(sizeof(*data), GFP_KERNEL);
 206         if (!data)
 207                 return -ENOMEM;
 208
 209         data->i2s_port = cpu_dai->driver->id;
 210         runtime->private_data = data;
 211
 212         if (v->alloc_dma_channel)
 213                 dma_ch = v->alloc_dma_channel(drvdata, dir, dai_id);
 214         else
 215                 dma_ch = 0;
 216
 217         if (dma_ch < 0) {
 218                 kfree(data);
 219                 return dma_ch;
 220         }
 221
 222         switch (dai_id) {
 223         case MI2S_PRIMARY ... MI2S_QUINARY:
 224                 map = drvdata->lpaif_map;
 225                 drvdata->substream[dma_ch] = substream;
 226                 break;
 227         case LPASS_DP_RX:
 228                 map = drvdata->hdmiif_map;
 229                 drvdata->hdmi_substream[dma_ch] = substream;
 230                 break;
 231         case LPASS_CDC_DMA_RX0 ... LPASS_CDC_DMA_RX9:
 232         case LPASS_CDC_DMA_TX0 ... LPASS_CDC_DMA_TX8:
 233                 map = drvdata->rxtx_lpaif_map;
 234                 drvdata->rxtx_substream[dma_ch] = substream;
 235                 break;
 236         case LPASS_CDC_DMA_VA_TX0 ... LPASS_CDC_DMA_VA_TX8:
 237                 map = drvdata->va_lpaif_map;
 238                 drvdata->va_substream[dma_ch] = substream;
 239                 break;
 240         default:
 241                 break;
 242         }
 243
 244         data->dma_ch = dma_ch;
 245         switch (dai_id) {
 246         case MI2S_PRIMARY ... MI2S_QUINARY:
 247         case LPASS_DP_RX:
 248                 ret = regmap_write(map, LPAIF_DMACTL_REG(v, dma_ch, dir, data->i2s_port), 0);
 249                 if (ret) {
 250                         kfree(data);
 251                         dev_err(soc_runtime->dev, "error writing to rdmactl reg: %d\n", ret);
 252                         return ret;
 253                 }
 254                 snd_soc_set_runtime_hwparams(substream, &lpass_platform_pcm_hardware);
 255                 runtime->dma_bytes = lpass_platform_pcm_hardware.buffer_bytes_max;
 256                 break;
 257         case LPASS_CDC_DMA_RX0 ... LPASS_CDC_DMA_RX9:
 258         case LPASS_CDC_DMA_TX0 ... LPASS_CDC_DMA_TX8:
 259                 snd_soc_set_runtime_hwparams(substream, &lpass_platform_rxtx_hardware);
 260                 runtime->dma_bytes = lpass_platform_rxtx_hardware.buffer_bytes_max;
 261                 snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
 262                 break;
 263         case LPASS_CDC_DMA_VA_TX0 ... LPASS_CDC_DMA_VA_TX8:
 264                 snd_soc_set_runtime_hwparams(substream, &lpass_platform_va_hardware);
 265                 runtime->dma_bytes = lpass_platform_va_hardware.buffer_bytes_max;
 266                 snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
 267                 break;
 268         default:
 269                 break;
 270         }
 271         ret = snd_pcm_hw_constraint_integer(runtime,
 272                         SNDRV_PCM_HW_PARAM_PERIODS);
 273         if (ret < 0) {
 274                 kfree(data);
 275                 dev_err(soc_runtime->dev, "setting constraints failed: %d\n",
 276                         ret);
 277                 return -EINVAL;
 278         }
 279
 280         return 0;
 281 }
 282
 283 static int lpass_platform_pcmops_close(struct snd_soc_component *component,
 284                                        struct snd_pcm_substream *substream)
 285 {
 286         struct snd_pcm_runtime *runtime = substream->runtime;
 287         struct snd_soc_pcm_runtime *soc_runtime = asoc_substream_to_rtd(substream);
 288         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(soc_runtime, 0);
 289         struct lpass_data *drvdata = snd_soc_component_get_drvdata(component);
 290         struct lpass_variant *v = drvdata->variant;
 291         struct lpass_pcm_data *data;
 292         unsigned int dai_id = cpu_dai->driver->id;
 293
 294         data = runtime->private_data;
 295
 296         switch (dai_id) {
 297         case MI2S_PRIMARY ... MI2S_QUINARY:
 298                 drvdata->substream[data->dma_ch] = NULL;
 299                 break;
 300         case LPASS_DP_RX:
 301                 drvdata->hdmi_substream[data->dma_ch] = NULL;
 302                 break;
 303         case LPASS_CDC_DMA_RX0 ... LPASS_CDC_DMA_RX9:
 304         case LPASS_CDC_DMA_TX0 ... LPASS_CDC_DMA_TX8:
 305                 drvdata->rxtx_substream[data->dma_ch] = NULL;
 306                 break;
 307         case LPASS_CDC_DMA_VA_TX0 ... LPASS_CDC_DMA_VA_TX8:
 308                 drvdata->va_substream[data->dma_ch] = NULL;
 309                 break;
 310         default:
 311                 break;
 312         }
 313
 314         if (v->free_dma_channel)
 315                 v->free_dma_channel(drvdata, data->dma_ch, dai_id);
 316
 317         kfree(data);
 318         return 0;
 319 }
 320
 321 static struct lpaif_dmactl *__lpass_get_dmactl_handle(const struct snd_pcm_substream *substream,
 322                                      struct snd_soc_component *component)
 323 {
 324         struct snd_soc_pcm_runtime *soc_runtime = asoc_substream_to_rtd(substream);
 325         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(soc_runtime, 0);
 326         struct lpass_data *drvdata = snd_soc_component_get_drvdata(component);
 327         struct lpaif_dmactl *dmactl = NULL;
 328
 329         switch (cpu_dai->driver->id) {
 330         case MI2S_PRIMARY ... MI2S_QUINARY:
 331                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 332                         dmactl = drvdata->rd_dmactl;
 333                 else
 334                         dmactl = drvdata->wr_dmactl;
 335                 break;
 336         case LPASS_DP_RX:
 337                 dmactl = drvdata->hdmi_rd_dmactl;
 338                 break;
 339         case LPASS_CDC_DMA_RX0 ... LPASS_CDC_DMA_RX9:
 340                 dmactl = drvdata->rxtx_rd_dmactl;
 341                 break;
 342         case LPASS_CDC_DMA_TX0 ... LPASS_CDC_DMA_TX8:
 343                 dmactl = drvdata->rxtx_wr_dmactl;
 344                 break;
 345         case LPASS_CDC_DMA_VA_TX0 ... LPASS_CDC_DMA_VA_TX8:
 346                 dmactl = drvdata->va_wr_dmactl;
 347                 break;
 348         }
 349
 350         return dmactl;
 351 }
 352
 353 static int __lpass_get_id(const struct snd_pcm_substream *substream,
 354                                      struct snd_soc_component *component)
 355 {
 356         struct snd_soc_pcm_runtime *soc_runtime = asoc_substream_to_rtd(substream);
 357         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(soc_runtime, 0);
 358         struct lpass_data *drvdata = snd_soc_component_get_drvdata(component);
 359         struct snd_pcm_runtime *rt = substream->runtime;
 360         struct lpass_pcm_data *pcm_data = rt->private_data;
 361         struct lpass_variant *v = drvdata->variant;
 362         int id;
 363
 364         switch (cpu_dai->driver->id) {
 365         case MI2S_PRIMARY ... MI2S_QUINARY:
 366                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 367                         id = pcm_data->dma_ch;
 368                 else
 369                         id = pcm_data->dma_ch - v->wrdma_channel_start;
 370                 break;
 371         case LPASS_DP_RX:
 372                 id = pcm_data->dma_ch;
 373                 break;
 374         case LPASS_CDC_DMA_RX0 ... LPASS_CDC_DMA_RX9:
 375                 id = pcm_data->dma_ch;
 376                 break;
 377         case LPASS_CDC_DMA_TX0 ... LPASS_CDC_DMA_TX8:
 378                 id = pcm_data->dma_ch - v->rxtx_wrdma_channel_start;
 379                 break;
 380         case LPASS_CDC_DMA_VA_TX0 ... LPASS_CDC_DMA_VA_TX8:
 381                 id = pcm_data->dma_ch - v->va_wrdma_channel_start;
 382                 break;
 383         }
 384
 385         return id;
 386 }
 387
 388 static struct regmap *__lpass_get_regmap_handle(const struct snd_pcm_substream *substream,
 389                                      struct snd_soc_component *component)
 390 {
 391         struct snd_soc_pcm_runtime *soc_runtime = asoc_substream_to_rtd(substream);
 392         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(soc_runtime, 0);
 393         struct lpass_data *drvdata = snd_soc_component_get_drvdata(component);
 394         struct regmap *map = NULL;
 395
 396         switch (cpu_dai->driver->id) {
 397         case MI2S_PRIMARY ... MI2S_QUINARY:
 398                 map = drvdata->lpaif_map;
 399                 break;
 400         case LPASS_DP_RX:
 401                 map = drvdata->hdmiif_map;
 402                 break;
 403         case LPASS_CDC_DMA_RX0 ... LPASS_CDC_DMA_RX9:
 404         case LPASS_CDC_DMA_TX0 ... LPASS_CDC_DMA_TX8:
 405                 map = drvdata->rxtx_lpaif_map;
 406                 break;
 407         case LPASS_CDC_DMA_VA_TX0 ... LPASS_CDC_DMA_VA_TX8:
 408                 map = drvdata->va_lpaif_map;
 409                 break;
 410         }
 411
 412         return map;
 413 }
 414
 415 static int lpass_platform_pcmops_hw_params(struct snd_soc_component *component,
 416                                            struct snd_pcm_substream *substream,
 417                                            struct snd_pcm_hw_params *params)
 418 {
 419         struct snd_soc_pcm_runtime *soc_runtime = asoc_substream_to_rtd(substream);
 420         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(soc_runtime, 0);
 421         struct lpass_data *drvdata = snd_soc_component_get_drvdata(component);
 422         struct snd_pcm_runtime *rt = substream->runtime;
 423         struct lpass_pcm_data *pcm_data = rt->private_data;
 424         struct lpass_variant *v = drvdata->variant;
 425         snd_pcm_format_t format = params_format(params);
 426         unsigned int channels = params_channels(params);
 427         unsigned int regval;
 428         struct lpaif_dmactl *dmactl;
 429         int id;
 430         int bitwidth;
 431         int ret, dma_port = pcm_data->i2s_port + v->dmactl_audif_start;
 432         unsigned int dai_id = cpu_dai->driver->id;
 433
 434         dmactl = __lpass_get_dmactl_handle(substream, component);
 435         id = __lpass_get_id(substream, component);
 436
 437         bitwidth = snd_pcm_format_width(format);
 438         if (bitwidth < 0) {
 439                 dev_err(soc_runtime->dev, "invalid bit width given: %d\n",
 440                                 bitwidth);
 441                 return bitwidth;
 442         }
 443
 444         ret = regmap_fields_write(dmactl->bursten, id, LPAIF_DMACTL_BURSTEN_INCR4);
 445         if (ret) {
 446                 dev_err(soc_runtime->dev, "error updating bursten field: %d\n", ret);
 447                 return ret;
 448         }
 449
 450         ret = regmap_fields_write(dmactl->fifowm, id, LPAIF_DMACTL_FIFOWM_8);
 451         if (ret) {
 452                 dev_err(soc_runtime->dev, "error updating fifowm field: %d\n", ret);
 453                 return ret;
 454         }
 455
 456         switch (dai_id) {
 457         case LPASS_DP_RX:
 458                 ret = regmap_fields_write(dmactl->burst8, id,
 459                                                         LPAIF_DMACTL_BURSTEN_INCR4);
 460                 if (ret) {
 461                         dev_err(soc_runtime->dev, "error updating burst8en field: %d\n", ret);
 462                         return ret;
 463                 }
 464                 ret = regmap_fields_write(dmactl->burst16, id,
 465                                                         LPAIF_DMACTL_BURSTEN_INCR4);
 466                 if (ret) {
 467                         dev_err(soc_runtime->dev, "error updating burst16en field: %d\n", ret);
 468                         return ret;
 469                 }
 470                 ret = regmap_fields_write(dmactl->dynburst, id,
 471                                                         LPAIF_DMACTL_BURSTEN_INCR4);
 472                 if (ret) {
 473                         dev_err(soc_runtime->dev, "error updating dynbursten field: %d\n", ret);
 474                         return ret;
 475                 }
 476                 break;
 477         case MI2S_PRIMARY:
 478         case MI2S_SECONDARY:
 479         case MI2S_TERTIARY:
 480         case MI2S_QUATERNARY:
 481         case MI2S_QUINARY:
 482                 ret = regmap_fields_write(dmactl->intf, id,
 483                                                 LPAIF_DMACTL_AUDINTF(dma_port));
 484                 if (ret) {
 485                         dev_err(soc_runtime->dev, "error updating audio interface field: %d\n",
 486                                         ret);
 487                         return ret;
 488                 }
 489
 490                 break;
 491         case LPASS_CDC_DMA_RX0 ... LPASS_CDC_DMA_RX9:
 492         case LPASS_CDC_DMA_TX0 ... LPASS_CDC_DMA_TX8:
 493         case LPASS_CDC_DMA_VA_TX0 ... LPASS_CDC_DMA_VA_TX0:
 494                 break;
 495         default:
 496                 dev_err(soc_runtime->dev, "%s: invalid  interface: %d\n", __func__, dai_id);
 497                 break;
 498         }
 499         switch (bitwidth) {
 500         case 16:
 501                 switch (channels) {
 502                 case 1:
 503                 case 2:
 504                         regval = LPAIF_DMACTL_WPSCNT_ONE;
 505                         break;
 506                 case 4:
 507                         regval = LPAIF_DMACTL_WPSCNT_TWO;
 508                         break;
 509                 case 6:
 510                         regval = LPAIF_DMACTL_WPSCNT_THREE;
 511                         break;
 512                 case 8:
 513                         regval = LPAIF_DMACTL_WPSCNT_FOUR;
 514                         break;
 515                 default:
 516                         dev_err(soc_runtime->dev, "invalid PCM config given: bw=%d, ch=%u\n",
 517                                 bitwidth, channels);
 518                         return -EINVAL;
 519                 }
 520                 break;
 521         case 24:
 522         case 32:
 523                 switch (channels) {
 524                 case 1:
 525                         regval = LPAIF_DMACTL_WPSCNT_ONE;
 526                         break;
 527                 case 2:
 528                         regval = (dai_id == LPASS_DP_RX ?
 529                         LPAIF_DMACTL_WPSCNT_ONE :
 530                         LPAIF_DMACTL_WPSCNT_TWO);
 531                         break;
 532                 case 4:
 533                         regval = (dai_id == LPASS_DP_RX ?
 534                         LPAIF_DMACTL_WPSCNT_TWO :
 535                         LPAIF_DMACTL_WPSCNT_FOUR);
 536                         break;
 537                 case 6:
 538                         regval = (dai_id == LPASS_DP_RX ?
 539                         LPAIF_DMACTL_WPSCNT_THREE :
 540                         LPAIF_DMACTL_WPSCNT_SIX);
 541                         break;
 542                 case 8:
 543                         regval = (dai_id == LPASS_DP_RX ?
 544                         LPAIF_DMACTL_WPSCNT_FOUR :
 545                         LPAIF_DMACTL_WPSCNT_EIGHT);
 546                         break;
 547                 default:
 548                         dev_err(soc_runtime->dev, "invalid PCM config given: bw=%d, ch=%u\n",
 549                                 bitwidth, channels);
 550                         return -EINVAL;
 551                 }
 552                 break;
 553         default:
 554                 dev_err(soc_runtime->dev, "invalid PCM config given: bw=%d, ch=%u\n",
 555                         bitwidth, channels);
 556                 return -EINVAL;
 557         }
 558
 559         ret = regmap_fields_write(dmactl->wpscnt, id, regval);
 560         if (ret) {
 561                 dev_err(soc_runtime->dev, "error writing to dmactl reg: %d\n",
 562                         ret);
 563                 return ret;
 564         }
 565
 566         return 0;
 567 }
 568
 569 static int lpass_platform_pcmops_hw_free(struct snd_soc_component *component,
 570                                          struct snd_pcm_substream *substream)
 571 {
 572         struct snd_soc_pcm_runtime *soc_runtime = asoc_substream_to_rtd(substream);
 573         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(soc_runtime, 0);
 574         struct lpass_data *drvdata = snd_soc_component_get_drvdata(component);
 575         struct snd_pcm_runtime *rt = substream->runtime;
 576         struct lpass_pcm_data *pcm_data = rt->private_data;
 577         struct lpass_variant *v = drvdata->variant;
 578         unsigned int reg;
 579         int ret;
 580         struct regmap *map;
 581         unsigned int dai_id = cpu_dai->driver->id;
 582
 583         if (is_cdc_dma_port(dai_id))
 584                 return 0;
 585         map = __lpass_get_regmap_handle(substream, component);
 586
 587         reg = LPAIF_DMACTL_REG(v, pcm_data->dma_ch, substream->stream, dai_id);
 588         ret = regmap_write(map, reg, 0);
 589         if (ret)
 590                 dev_err(soc_runtime->dev, "error writing to rdmactl reg: %d\n",
 591                         ret);
 592
 593         return ret;
 594 }
 595
 596 static int lpass_platform_pcmops_prepare(struct snd_soc_component *component,
 597                                          struct snd_pcm_substream *substream)
 598 {
 599         struct snd_pcm_runtime *runtime = substream->runtime;
 600         struct snd_soc_pcm_runtime *soc_runtime = asoc_substream_to_rtd(substream);
 601         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(soc_runtime, 0);
 602         struct lpass_data *drvdata = snd_soc_component_get_drvdata(component);
 603         struct snd_pcm_runtime *rt = substream->runtime;
 604         struct lpass_pcm_data *pcm_data = rt->private_data;
 605         struct lpass_variant *v = drvdata->variant;
 606         struct lpaif_dmactl *dmactl;
 607         struct regmap *map;
 608         int ret, id, ch, dir = substream->stream;
 609         unsigned int dai_id = cpu_dai->driver->id;
 610
 611         ch = pcm_data->dma_ch;
 612
 613         dmactl = __lpass_get_dmactl_handle(substream, component);
 614         id = __lpass_get_id(substream, component);
 615         map = __lpass_get_regmap_handle(substream, component);
 616
 617         ret = regmap_write(map, LPAIF_DMABASE_REG(v, ch, dir, dai_id),
 618                                 runtime->dma_addr);
 619         if (ret) {
 620                 dev_err(soc_runtime->dev, "error writing to rdmabase reg: %d\n",
 621                         ret);
 622                 return ret;
 623         }
 624
 625         ret = regmap_write(map, LPAIF_DMABUFF_REG(v, ch, dir, dai_id),
 626                         (snd_pcm_lib_buffer_bytes(substream) >> 2) - 1);
 627         if (ret) {
 628                 dev_err(soc_runtime->dev, "error writing to rdmabuff reg: %d\n",
 629                         ret);
 630                 return ret;
 631         }
 632
 633         ret = regmap_write(map, LPAIF_DMAPER_REG(v, ch, dir, dai_id),
 634                         (snd_pcm_lib_period_bytes(substream) >> 2) - 1);
 635         if (ret) {
 636                 dev_err(soc_runtime->dev, "error writing to rdmaper reg: %d\n",
 637                         ret);
 638                 return ret;
 639         }
 640
 641         if (is_cdc_dma_port(dai_id)) {
 642                 ret = regmap_fields_write(dmactl->fifowm, id, LPAIF_DMACTL_FIFOWM_8);
 643                 if (ret) {
 644                         dev_err(soc_runtime->dev, "error writing fifowm field to dmactl reg: %d, id: %d\n",
 645                                 ret, id);
 646                         return ret;
 647                 }
 648         }
 649         ret = regmap_fields_write(dmactl->enable, id, LPAIF_DMACTL_ENABLE_ON);
 650         if (ret) {
 651                 dev_err(soc_runtime->dev, "error writing to rdmactl reg: %d\n",
 652                         ret);
 653                 return ret;
 654         }
 655
 656         return 0;
 657 }
 658
 659 static int lpass_platform_pcmops_trigger(struct snd_soc_component *component,
 660                                          struct snd_pcm_substream *substream,
 661                                          int cmd)
 662 {
 663         struct snd_soc_pcm_runtime *soc_runtime = asoc_substream_to_rtd(substream);
 664         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(soc_runtime, 0);
 665         struct lpass_data *drvdata = snd_soc_component_get_drvdata(component);
 666         struct snd_pcm_runtime *rt = substream->runtime;
 667         struct lpass_pcm_data *pcm_data = rt->private_data;
 668         struct lpass_variant *v = drvdata->variant;
 669         struct lpaif_dmactl *dmactl;
 670         struct regmap *map;
 671         int ret, ch, id;
 672         unsigned int reg_irqclr = 0, val_irqclr = 0;
 673         unsigned int  reg_irqen = 0, val_irqen = 0, val_mask = 0;
 674         unsigned int dai_id = cpu_dai->driver->id;
 675
 676         ch = pcm_data->dma_ch;
 677         dmactl = __lpass_get_dmactl_handle(substream, component);
 678         id = __lpass_get_id(substream, component);
 679         map = __lpass_get_regmap_handle(substream, component);
 680
 681         switch (cmd) {
 682         case SNDRV_PCM_TRIGGER_START:
 683         case SNDRV_PCM_TRIGGER_RESUME:
 684         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 685                 ret = regmap_fields_write(dmactl->enable, id,
 686                                                  LPAIF_DMACTL_ENABLE_ON);
 687                 if (ret) {
 688                         dev_err(soc_runtime->dev,
 689                                 "error writing to rdmactl reg: %d\n", ret);
 690                         return ret;
 691                 }
 692                 switch (dai_id) {
 693                 case LPASS_DP_RX:
 694                         ret = regmap_fields_write(dmactl->dyncclk, id,
 695                                          LPAIF_DMACTL_DYNCLK_ON);
 696                         if (ret) {
 697                                 dev_err(soc_runtime->dev,
 698                                         "error writing to rdmactl reg: %d\n", ret);
 699                                 return ret;
 700                         }
 701                         reg_irqclr = LPASS_HDMITX_APP_IRQCLEAR_REG(v);
 702                         val_irqclr = (LPAIF_IRQ_ALL(ch) |
 703                                         LPAIF_IRQ_HDMI_REQ_ON_PRELOAD(ch) |
 704                                         LPAIF_IRQ_HDMI_METADONE |
 705                                         LPAIF_IRQ_HDMI_SDEEP_AUD_DIS(ch));
 706
 707                         reg_irqen = LPASS_HDMITX_APP_IRQEN_REG(v);
 708                         val_mask = (LPAIF_IRQ_ALL(ch) |
 709                                         LPAIF_IRQ_HDMI_REQ_ON_PRELOAD(ch) |
 710                                         LPAIF_IRQ_HDMI_METADONE |
 711                                         LPAIF_IRQ_HDMI_SDEEP_AUD_DIS(ch));
 712                         val_irqen = (LPAIF_IRQ_ALL(ch) |
 713                                         LPAIF_IRQ_HDMI_REQ_ON_PRELOAD(ch) |
 714                                         LPAIF_IRQ_HDMI_METADONE |
 715                                         LPAIF_IRQ_HDMI_SDEEP_AUD_DIS(ch));
 716                         break;
 717                 case MI2S_PRIMARY:
 718                 case MI2S_SECONDARY:
 719                 case MI2S_TERTIARY:
 720                 case MI2S_QUATERNARY:
 721                 case MI2S_QUINARY:
 722                         reg_irqclr = LPAIF_IRQCLEAR_REG(v, LPAIF_IRQ_PORT_HOST);
 723                         val_irqclr = LPAIF_IRQ_ALL(ch);
 724
 725
 726                         reg_irqen = LPAIF_IRQEN_REG(v, LPAIF_IRQ_PORT_HOST);
 727                         val_mask = LPAIF_IRQ_ALL(ch);
 728                         val_irqen = LPAIF_IRQ_ALL(ch);
 729                         break;
 730                 case LPASS_CDC_DMA_RX0 ... LPASS_CDC_DMA_RX9:
 731                 case LPASS_CDC_DMA_TX0 ... LPASS_CDC_DMA_TX8:
 732                         ret = regmap_fields_write(dmactl->dyncclk, id, LPAIF_DMACTL_DYNCLK_ON);
 733                         if (ret) {
 734                                 dev_err(soc_runtime->dev,
 735                                         "error writing to rdmactl reg field: %d\n", ret);
 736                                 return ret;
 737                         }
 738                         reg_irqclr = LPAIF_RXTX_IRQCLEAR_REG(v, LPAIF_IRQ_PORT_HOST);
 739                         val_irqclr = LPAIF_IRQ_ALL(ch);
 740
 741                         reg_irqen = LPAIF_RXTX_IRQEN_REG(v, LPAIF_IRQ_PORT_HOST);
 742                         val_mask = LPAIF_IRQ_ALL(ch);
 743                         val_irqen = LPAIF_IRQ_ALL(ch);
 744                         break;
 745                 case LPASS_CDC_DMA_VA_TX0 ... LPASS_CDC_DMA_VA_TX8:
 746                         ret = regmap_fields_write(dmactl->dyncclk, id, LPAIF_DMACTL_DYNCLK_ON);
 747                         if (ret) {
 748                                 dev_err(soc_runtime->dev,
 749                                         "error writing to rdmactl reg field: %d\n", ret);
 750                                 return ret;
 751                         }
 752                         reg_irqclr = LPAIF_VA_IRQCLEAR_REG(v, LPAIF_IRQ_PORT_HOST);
 753                         val_irqclr = LPAIF_IRQ_ALL(ch);
 754
 755                         reg_irqen = LPAIF_VA_IRQEN_REG(v, LPAIF_IRQ_PORT_HOST);
 756                         val_mask = LPAIF_IRQ_ALL(ch);
 757                         val_irqen = LPAIF_IRQ_ALL(ch);
 758                         break;
 759                 default:
 760                         dev_err(soc_runtime->dev, "%s: invalid %d interface\n", __func__, dai_id);
 761                         return -EINVAL;
 762                 }
 763
 764                 ret = regmap_write_bits(map, reg_irqclr, val_irqclr, val_irqclr);
 765                 if (ret) {
 766                         dev_err(soc_runtime->dev, "error writing to irqclear reg: %d\n", ret);
 767                         return ret;
 768                 }
 769                 ret = regmap_update_bits(map, reg_irqen, val_mask, val_irqen);
 770                 if (ret) {
 771                         dev_err(soc_runtime->dev, "error writing to irqen reg: %d\n", ret);
 772                         return ret;
 773                 }
 774                 break;
 775         case SNDRV_PCM_TRIGGER_STOP:
 776         case SNDRV_PCM_TRIGGER_SUSPEND:
 777         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 778                 ret = regmap_fields_write(dmactl->enable, id,
 779                                          LPAIF_DMACTL_ENABLE_OFF);
 780                 if (ret) {
 781                         dev_err(soc_runtime->dev,
 782                                 "error writing to rdmactl reg: %d\n", ret);
 783                         return ret;
 784                 }
 785                 switch (dai_id) {
 786                 case LPASS_DP_RX:
 787                         ret = regmap_fields_write(dmactl->dyncclk, id,
 788                                          LPAIF_DMACTL_DYNCLK_OFF);
 789                         if (ret) {
 790                                 dev_err(soc_runtime->dev,
 791                                         "error writing to rdmactl reg: %d\n", ret);
 792                                 return ret;
 793                         }
 794                         reg_irqen = LPASS_HDMITX_APP_IRQEN_REG(v);
 795                         val_mask = (LPAIF_IRQ_ALL(ch) |
 796                                         LPAIF_IRQ_HDMI_REQ_ON_PRELOAD(ch) |
 797                                         LPAIF_IRQ_HDMI_METADONE |
 798                                         LPAIF_IRQ_HDMI_SDEEP_AUD_DIS(ch));
 799                         val_irqen = 0;
 800                         break;
 801                 case MI2S_PRIMARY:
 802                 case MI2S_SECONDARY:
 803                 case MI2S_TERTIARY:
 804                 case MI2S_QUATERNARY:
 805                 case MI2S_QUINARY:
 806                         reg_irqen = LPAIF_IRQEN_REG(v, LPAIF_IRQ_PORT_HOST);
 807                         val_mask = LPAIF_IRQ_ALL(ch);
 808                         val_irqen = 0;
 809                         break;
 810                 case LPASS_CDC_DMA_RX0 ... LPASS_CDC_DMA_RX9:
 811                 case LPASS_CDC_DMA_TX0 ... LPASS_CDC_DMA_TX8:
 812                         ret = regmap_fields_write(dmactl->dyncclk, id, LPAIF_DMACTL_DYNCLK_OFF);
 813                         if (ret) {
 814                                 dev_err(soc_runtime->dev,
 815                                         "error writing to rdmactl reg field: %d\n", ret);
 816                                 return ret;
 817                         }
 818
 819                         reg_irqclr = LPAIF_RXTX_IRQCLEAR_REG(v, LPAIF_IRQ_PORT_HOST);
 820                         val_irqclr = LPAIF_IRQ_ALL(ch);
 821
 822                         reg_irqen = LPAIF_RXTX_IRQEN_REG(v, LPAIF_IRQ_PORT_HOST);
 823                         val_mask = LPAIF_IRQ_ALL(ch);
 824                         val_irqen = LPAIF_IRQ_ALL(ch);
 825                         break;
 826                 case LPASS_CDC_DMA_VA_TX0 ... LPASS_CDC_DMA_VA_TX8:
 827                         ret = regmap_fields_write(dmactl->dyncclk, id, LPAIF_DMACTL_DYNCLK_OFF);
 828                         if (ret) {
 829                                 dev_err(soc_runtime->dev,
 830                                         "error writing to rdmactl reg field: %d\n", ret);
 831                                 return ret;
 832                         }
 833
 834                         reg_irqclr = LPAIF_VA_IRQCLEAR_REG(v, LPAIF_IRQ_PORT_HOST);
 835                         val_irqclr = LPAIF_IRQ_ALL(ch);
 836
 837                         reg_irqen = LPAIF_VA_IRQEN_REG(v, LPAIF_IRQ_PORT_HOST);
 838                         val_mask = LPAIF_IRQ_ALL(ch);
 839                         val_irqen = LPAIF_IRQ_ALL(ch);
 840                         break;
 841                 default:
 842                         dev_err(soc_runtime->dev, "%s: invalid %d interface\n", __func__, dai_id);
 843                         return -EINVAL;
 844                 }
 845
 846                 ret = regmap_update_bits(map, reg_irqen, val_mask, val_irqen);
 847                 if (ret) {
 848                         dev_err(soc_runtime->dev,
 849                                 "error writing to irqen reg: %d\n", ret);
 850                         return ret;
 851                 }
 852                 break;
 853         }
 854
 855         return 0;
 856 }
 857
 858 static snd_pcm_uframes_t lpass_platform_pcmops_pointer(
 859                 struct snd_soc_component *component,
 860                 struct snd_pcm_substream *substream)
 861 {
 862         struct snd_soc_pcm_runtime *soc_runtime = asoc_substream_to_rtd(substream);
 863         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(soc_runtime, 0);
 864         struct lpass_data *drvdata = snd_soc_component_get_drvdata(component);
 865         struct snd_pcm_runtime *rt = substream->runtime;
 866         struct lpass_pcm_data *pcm_data = rt->private_data;
 867         struct lpass_variant *v = drvdata->variant;
 868         unsigned int base_addr, curr_addr;
 869         int ret, ch, dir = substream->stream;
 870         struct regmap *map;
 871         unsigned int dai_id = cpu_dai->driver->id;
 872
 873         map = __lpass_get_regmap_handle(substream, component);
 874         ch = pcm_data->dma_ch;
 875
 876         ret = regmap_read(map,
 877                         LPAIF_DMABASE_REG(v, ch, dir, dai_id), &base_addr);
 878         if (ret) {
 879                 dev_err(soc_runtime->dev,
 880                         "error reading from rdmabase reg: %d\n", ret);
 881                 return ret;
 882         }
 883
 884         ret = regmap_read(map,
 885                         LPAIF_DMACURR_REG(v, ch, dir, dai_id), &curr_addr);
 886         if (ret) {
 887                 dev_err(soc_runtime->dev,
 888                         "error reading from rdmacurr reg: %d\n", ret);
 889                 return ret;
 890         }
 891
 892         return bytes_to_frames(substream->runtime, curr_addr - base_addr);
 893 }
 894
 895 static int lpass_platform_cdc_dma_mmap(struct snd_pcm_substream *substream,
 896                                        struct vm_area_struct *vma)
 897 {
 898         struct snd_pcm_runtime *runtime = substream->runtime;
 899         unsigned long size, offset;
 900
 901         vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
 902         size = vma->vm_end - vma->vm_start;
 903         offset = vma->vm_pgoff << PAGE_SHIFT;
 904         return io_remap_pfn_range(vma, vma->vm_start,
 905                         (runtime->dma_addr + offset) >> PAGE_SHIFT,
 906                         size, vma->vm_page_prot);
 907
 908 }
 909
 910 static int lpass_platform_pcmops_mmap(struct snd_soc_component *component,
 911                                       struct snd_pcm_substream *substream,
 912                                       struct vm_area_struct *vma)
 913 {
 914         struct snd_soc_pcm_runtime *soc_runtime = asoc_substream_to_rtd(substream);
 915         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(soc_runtime, 0);
 916         unsigned int dai_id = cpu_dai->driver->id;
 917
 918         if (is_cdc_dma_port(dai_id))
 919                 return lpass_platform_cdc_dma_mmap(substream, vma);
 920
 921         return snd_pcm_lib_default_mmap(substream, vma);
 922 }
 923
 924 static irqreturn_t lpass_dma_interrupt_handler(
 925                         struct snd_pcm_substream *substream,
 926                         struct lpass_data *drvdata,
 927                         int chan, u32 interrupts)
 928 {
 929         struct snd_soc_pcm_runtime *soc_runtime = asoc_substream_to_rtd(substream);
 930         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(soc_runtime, 0);
 931         struct lpass_variant *v = drvdata->variant;
 932         irqreturn_t ret = IRQ_NONE;
 933         int rv;
 934         unsigned int reg, val, mask;
 935         struct regmap *map;
 936         unsigned int dai_id = cpu_dai->driver->id;
 937
 938         mask = LPAIF_IRQ_ALL(chan);
 939         switch (dai_id) {
 940         case LPASS_DP_RX:
 941                 map = drvdata->hdmiif_map;
 942                 reg = LPASS_HDMITX_APP_IRQCLEAR_REG(v);
 943                 val = (LPAIF_IRQ_HDMI_REQ_ON_PRELOAD(chan) |
 944                 LPAIF_IRQ_HDMI_METADONE |
 945                 LPAIF_IRQ_HDMI_SDEEP_AUD_DIS(chan));
 946         break;
 947         case MI2S_PRIMARY:
 948         case MI2S_SECONDARY:
 949         case MI2S_TERTIARY:
 950         case MI2S_QUATERNARY:
 951         case MI2S_QUINARY:
 952                 map = drvdata->lpaif_map;
 953                 reg = LPAIF_IRQCLEAR_REG(v, LPAIF_IRQ_PORT_HOST);
 954                 val = 0;
 955         break;
 956         case LPASS_CDC_DMA_RX0 ... LPASS_CDC_DMA_RX9:
 957         case LPASS_CDC_DMA_TX0 ... LPASS_CDC_DMA_TX8:
 958                 map = drvdata->rxtx_lpaif_map;
 959                 reg = LPAIF_RXTX_IRQCLEAR_REG(v, LPAIF_IRQ_PORT_HOST);
 960                 val = 0;
 961         break;
 962         case LPASS_CDC_DMA_VA_TX0 ... LPASS_CDC_DMA_VA_TX8:
 963                 map = drvdata->va_lpaif_map;
 964                 reg = LPAIF_VA_IRQCLEAR_REG(v, LPAIF_IRQ_PORT_HOST);
 965                 val = 0;
 966         break;
 967         default:
 968         dev_err(soc_runtime->dev, "%s: invalid  %d interface\n", __func__, dai_id);
 969         return -EINVAL;
 970         }
 971         if (interrupts & LPAIF_IRQ_PER(chan)) {
 972                 rv = regmap_write_bits(map, reg, mask, (LPAIF_IRQ_PER(chan) | val));
 973                 if (rv) {
 974                         dev_err(soc_runtime->dev,
 975                                 "error writing to irqclear reg: %d\n", rv);
 976                         return IRQ_NONE;
 977                 }
 978                 snd_pcm_period_elapsed(substream);
 979                 ret = IRQ_HANDLED;
 980         }
 981
 982         if (interrupts & LPAIF_IRQ_XRUN(chan)) {
 983                 rv = regmap_write_bits(map, reg, mask, (LPAIF_IRQ_XRUN(chan) | val));
 984                 if (rv) {
 985                         dev_err(soc_runtime->dev,
 986                                 "error writing to irqclear reg: %d\n", rv);
 987                         return IRQ_NONE;
 988                 }
 989                 dev_warn_ratelimited(soc_runtime->dev, "xrun warning\n");
 990
 991                 snd_pcm_stop_xrun(substream);
 992                 ret = IRQ_HANDLED;
 993         }
 994
 995         if (interrupts & LPAIF_IRQ_ERR(chan)) {
 996                 rv = regmap_write_bits(map, reg, mask, (LPAIF_IRQ_ERR(chan) | val));
 997                 if (rv) {
 998                         dev_err(soc_runtime->dev,
 999                                 "error writing to irqclear reg: %d\n", rv);
1000                         return IRQ_NONE;
1001                 }
1002                 dev_err(soc_runtime->dev, "bus access error\n");
1003                 snd_pcm_stop(substream, SNDRV_PCM_STATE_DISCONNECTED);
1004                 ret = IRQ_HANDLED;
1005         }
1006
1007         if (interrupts & val) {
1008                 rv = regmap_write(map, reg, val);
1009                 if (rv) {
1010                         dev_err(soc_runtime->dev,
1011                         "error writing to irqclear reg: %d\n", rv);
1012                         return IRQ_NONE;
1013                 }
1014                 ret = IRQ_HANDLED;
1015         }
1016
1017         return ret;
1018 }
1019
1020 static irqreturn_t lpass_platform_lpaif_irq(int irq, void *data)
1021 {
1022         struct lpass_data *drvdata = data;
1023         struct lpass_variant *v = drvdata->variant;
1024         unsigned int irqs;
1025         int rv, chan;
1026
1027         rv = regmap_read(drvdata->lpaif_map,
1028                         LPAIF_IRQSTAT_REG(v, LPAIF_IRQ_PORT_HOST), &irqs);
1029         if (rv) {
1030                 pr_err("error reading from irqstat reg: %d\n", rv);
1031                 return IRQ_NONE;
1032         }
1033
1034         /* Handle per channel interrupts */
1035         for (chan = 0; chan < LPASS_MAX_DMA_CHANNELS; chan++) {
1036                 if (irqs & LPAIF_IRQ_ALL(chan) && drvdata->substream[chan]) {
1037                         rv = lpass_dma_interrupt_handler(
1038                                                 drvdata->substream[chan],
1039                                                 drvdata, chan, irqs);
1040                         if (rv != IRQ_HANDLED)
1041                                 return rv;
1042                 }
1043         }
1044
1045         return IRQ_HANDLED;
1046 }
1047
1048 static irqreturn_t lpass_platform_hdmiif_irq(int irq, void *data)
1049 {
1050         struct lpass_data *drvdata = data;
1051         struct lpass_variant *v = drvdata->variant;
1052         unsigned int irqs;
1053         int rv, chan;
1054
1055         rv = regmap_read(drvdata->hdmiif_map,
1056                         LPASS_HDMITX_APP_IRQSTAT_REG(v), &irqs);
1057         if (rv) {
1058                 pr_err("error reading from irqstat reg: %d\n", rv);
1059                 return IRQ_NONE;
1060         }
1061
1062         /* Handle per channel interrupts */
1063         for (chan = 0; chan < LPASS_MAX_HDMI_DMA_CHANNELS; chan++) {
1064                 if (irqs & (LPAIF_IRQ_ALL(chan) | LPAIF_IRQ_HDMI_REQ_ON_PRELOAD(chan) |
1065                                 LPAIF_IRQ_HDMI_METADONE |
1066                                 LPAIF_IRQ_HDMI_SDEEP_AUD_DIS(chan))
1067                         && drvdata->hdmi_substream[chan]) {
1068                         rv = lpass_dma_interrupt_handler(
1069                                                 drvdata->hdmi_substream[chan],
1070                                                 drvdata, chan, irqs);
1071                         if (rv != IRQ_HANDLED)
1072                                 return rv;
1073                 }
1074         }
1075         return IRQ_HANDLED;
1076 }
1077
1078 static irqreturn_t lpass_platform_rxtxif_irq(int irq, void *data)
1079 {
1080         struct lpass_data *drvdata = data;
1081         struct lpass_variant *v = drvdata->variant;
1082         unsigned int irqs;
1083         irqreturn_t rv;
1084         int chan;
1085
1086         rv = regmap_read(drvdata->rxtx_lpaif_map,
1087                         LPAIF_RXTX_IRQSTAT_REG(v, LPAIF_IRQ_PORT_HOST), &irqs);
1088
1089         /* Handle per channel interrupts */
1090         for (chan = 0; chan < LPASS_MAX_CDC_DMA_CHANNELS; chan++) {
1091                 if (irqs & LPAIF_IRQ_ALL(chan) && drvdata->rxtx_substream[chan]) {
1092                         rv = lpass_dma_interrupt_handler(
1093                                                 drvdata->rxtx_substream[chan],
1094                                                 drvdata, chan, irqs);
1095                         if (rv != IRQ_HANDLED)
1096                                 return rv;
1097                 }
1098         }
1099
1100         return IRQ_HANDLED;
1101 }
1102
1103 static irqreturn_t lpass_platform_vaif_irq(int irq, void *data)
1104 {
1105         struct lpass_data *drvdata = data;
1106         struct lpass_variant *v = drvdata->variant;
1107         unsigned int irqs;
1108         irqreturn_t rv;
1109         int chan;
1110
1111         rv = regmap_read(drvdata->va_lpaif_map,
1112                         LPAIF_VA_IRQSTAT_REG(v, LPAIF_IRQ_PORT_HOST), &irqs);
1113
1114         /* Handle per channel interrupts */
1115         for (chan = 0; chan < LPASS_MAX_VA_CDC_DMA_CHANNELS; chan++) {
1116                 if (irqs & LPAIF_IRQ_ALL(chan) && drvdata->va_substream[chan]) {
1117                         rv = lpass_dma_interrupt_handler(
1118                                                 drvdata->va_substream[chan],
1119                                                 drvdata, chan, irqs);
1120                         if (rv != IRQ_HANDLED)
1121                                 return rv;
1122                 }
1123         }
1124         return IRQ_HANDLED;
1125 }
1126
1127 static int lpass_platform_prealloc_cdc_dma_buffer(struct snd_soc_component *component,
1128                                                   struct snd_pcm *pcm, int dai_id)
1129 {
1130         struct lpass_data *drvdata = snd_soc_component_get_drvdata(component);
1131         struct snd_pcm_substream *substream;
1132         struct snd_dma_buffer *buf;
1133
1134         if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream)
1135                 substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream;
1136         else
1137                 substream = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream;
1138
1139         buf = &substream->dma_buffer;
1140         buf->dev.dev = pcm->card->dev;
1141         buf->private_data = NULL;
1142
1143         /* Assign Codec DMA buffer pointers */
1144         buf->dev.type = SNDRV_DMA_TYPE_CONTINUOUS;
1145
1146         switch (dai_id) {
1147         case LPASS_CDC_DMA_RX0 ... LPASS_CDC_DMA_RX9:
1148                 buf->bytes = lpass_platform_rxtx_hardware.buffer_bytes_max;
1149                 buf->addr = drvdata->rxtx_cdc_dma_lpm_buf;
1150                 break;
1151         case LPASS_CDC_DMA_TX0 ... LPASS_CDC_DMA_TX8:
1152                 buf->bytes = lpass_platform_rxtx_hardware.buffer_bytes_max;
1153                 buf->addr = drvdata->rxtx_cdc_dma_lpm_buf + LPASS_RXTX_CDC_DMA_LPM_BUFF_SIZE;
1154                 break;
1155         case LPASS_CDC_DMA_VA_TX0 ... LPASS_CDC_DMA_VA_TX8:
1156                 buf->bytes = lpass_platform_va_hardware.buffer_bytes_max;
1157                 buf->addr = drvdata->va_cdc_dma_lpm_buf;
1158                 break;
1159         default:
1160                 break;
1161         }
1162
1163         buf->area = (unsigned char * __force)memremap(buf->addr, buf->bytes, MEMREMAP_WC);
1164
1165         return 0;
1166 }
1167
1168 static int lpass_platform_pcm_new(struct snd_soc_component *component,
1169                                   struct snd_soc_pcm_runtime *soc_runtime)
1170 {
1171         struct snd_pcm *pcm = soc_runtime->pcm;
1172         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(soc_runtime, 0);
1173         unsigned int dai_id = cpu_dai->driver->id;
1174
1175         size_t size = lpass_platform_pcm_hardware.buffer_bytes_max;
1176
1177         /*
1178          * Lpass codec dma can access only lpass lpm hardware memory.
1179          * ioremap is for HLOS to access hardware memory.
1180          */
1181         if (is_cdc_dma_port(dai_id))
1182                 return lpass_platform_prealloc_cdc_dma_buffer(component, pcm, dai_id);
1183
1184         return snd_pcm_set_fixed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV,
1185                                             component->dev, size);
1186 }
1187
1188 static int lpass_platform_pcmops_suspend(struct snd_soc_component *component)
1189 {
1190         struct lpass_data *drvdata = snd_soc_component_get_drvdata(component);
1191         struct regmap *map;
1192         unsigned int dai_id = component->id;
1193
1194         if (dai_id == LPASS_DP_RX)
1195                 map = drvdata->hdmiif_map;
1196         else
1197                 map = drvdata->lpaif_map;
1198
1199         regcache_cache_only(map, true);
1200         regcache_mark_dirty(map);
1201
1202         return 0;
1203 }
1204
1205 static int lpass_platform_pcmops_resume(struct snd_soc_component *component)
1206 {
1207         struct lpass_data *drvdata = snd_soc_component_get_drvdata(component);
1208         struct regmap *map;
1209         unsigned int dai_id = component->id;
1210
1211         if (dai_id == LPASS_DP_RX)
1212                 map = drvdata->hdmiif_map;
1213         else
1214                 map = drvdata->lpaif_map;
1215
1216         regcache_cache_only(map, false);
1217         return regcache_sync(map);
1218 }
1219
1220 static int lpass_platform_copy(struct snd_soc_component *component,
1221                                struct snd_pcm_substream *substream, int channel,
1222                                unsigned long pos, void __user *buf, unsigned long bytes)
1223 {
1224         struct snd_pcm_runtime *rt = substream->runtime;
1225         unsigned int dai_id = component->id;
1226         int ret = 0;
1227
1228         void __iomem *dma_buf = (void __iomem *) (rt->dma_area + pos +
1229                                 channel * (rt->dma_bytes / rt->channels));
1230
1231         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1232                 if (is_cdc_dma_port(dai_id)) {
1233                         ret = copy_from_user_toio(dma_buf, buf, bytes);
1234                 } else {
1235                         if (copy_from_user((void __force *)dma_buf, buf, bytes))
1236                                 ret = -EFAULT;
1237                 }
1238         } else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
1239                 if (is_cdc_dma_port(dai_id)) {
1240                         ret = copy_to_user_fromio(buf, dma_buf, bytes);
1241                 } else {
1242                         if (copy_to_user(buf, (void __force *)dma_buf, bytes))
1243                                 ret = -EFAULT;
1244                 }
1245         }
1246
1247         return ret;
1248 }
1249
1250 static const struct snd_soc_component_driver lpass_component_driver = {
1251         .name           = DRV_NAME,
1252         .open           = lpass_platform_pcmops_open,
1253         .close          = lpass_platform_pcmops_close,
1254         .hw_params      = lpass_platform_pcmops_hw_params,
1255         .hw_free        = lpass_platform_pcmops_hw_free,
1256         .prepare        = lpass_platform_pcmops_prepare,
1257         .trigger        = lpass_platform_pcmops_trigger,
1258         .pointer        = lpass_platform_pcmops_pointer,
1259         .mmap           = lpass_platform_pcmops_mmap,
1260         .pcm_construct  = lpass_platform_pcm_new,
1261         .suspend                = lpass_platform_pcmops_suspend,
1262         .resume                 = lpass_platform_pcmops_resume,
1263         .copy_user              = lpass_platform_copy,
1264
1265 };
1266
1267 int asoc_qcom_lpass_platform_register(struct platform_device *pdev)
1268 {
1269         struct lpass_data *drvdata = platform_get_drvdata(pdev);
1270         struct lpass_variant *v = drvdata->variant;
1271         int ret;
1272
1273         drvdata->lpaif_irq = platform_get_irq_byname(pdev, "lpass-irq-lpaif");
1274         if (drvdata->lpaif_irq < 0)
1275                 return -ENODEV;
1276
1277         /* ensure audio hardware is disabled */
1278         ret = regmap_write(drvdata->lpaif_map,
1279                         LPAIF_IRQEN_REG(v, LPAIF_IRQ_PORT_HOST), 0);
1280         if (ret) {
1281                 dev_err(&pdev->dev, "error writing to irqen reg: %d\n", ret);
1282                 return ret;
1283         }
1284
1285         ret = devm_request_irq(&pdev->dev, drvdata->lpaif_irq,
1286                         lpass_platform_lpaif_irq, IRQF_TRIGGER_RISING,
1287                         "lpass-irq-lpaif", drvdata);
1288         if (ret) {
1289                 dev_err(&pdev->dev, "irq request failed: %d\n", ret);
1290                 return ret;
1291         }
1292
1293         ret = lpass_platform_alloc_dmactl_fields(&pdev->dev,
1294                                                  drvdata->lpaif_map);
1295         if (ret) {
1296                 dev_err(&pdev->dev,
1297                         "error initializing dmactl fields: %d\n", ret);
1298                 return ret;
1299         }
1300
1301         if (drvdata->codec_dma_enable) {
1302                 ret = regmap_write(drvdata->rxtx_lpaif_map,
1303                         LPAIF_RXTX_IRQEN_REG(v, LPAIF_IRQ_PORT_HOST), 0x0);
1304                 if (ret) {
1305                         dev_err(&pdev->dev, "error writing to rxtx irqen reg: %d\n", ret);
1306                         return ret;
1307                 }
1308                 ret = regmap_write(drvdata->va_lpaif_map,
1309                         LPAIF_VA_IRQEN_REG(v, LPAIF_IRQ_PORT_HOST), 0x0);
1310                 if (ret) {
1311                         dev_err(&pdev->dev, "error writing to rxtx irqen reg: %d\n", ret);
1312                         return ret;
1313                 }
1314                 drvdata->rxtxif_irq = platform_get_irq_byname(pdev, "lpass-irq-rxtxif");
1315                 if (drvdata->rxtxif_irq < 0)
1316                         return -ENODEV;
1317
1318                 ret = devm_request_irq(&pdev->dev, drvdata->rxtxif_irq,
1319                                 lpass_platform_rxtxif_irq, 0, "lpass-irq-rxtxif", drvdata);
1320                 if (ret) {
1321                         dev_err(&pdev->dev, "rxtx irq request failed: %d\n", ret);
1322                         return ret;
1323                 }
1324
1325                 ret = lpass_platform_alloc_rxtx_dmactl_fields(&pdev->dev,
1326                                                  drvdata->rxtx_lpaif_map);
1327                 if (ret) {
1328                         dev_err(&pdev->dev,
1329                                 "error initializing rxtx dmactl fields: %d\n", ret);
1330                         return ret;
1331                 }
1332
1333                 drvdata->vaif_irq = platform_get_irq_byname(pdev, "lpass-irq-vaif");
1334                 if (drvdata->vaif_irq < 0)
1335                         return -ENODEV;
1336
1337                 ret = devm_request_irq(&pdev->dev, drvdata->vaif_irq,
1338                                 lpass_platform_vaif_irq, 0, "lpass-irq-vaif", drvdata);
1339                 if (ret) {
1340                         dev_err(&pdev->dev, "va irq request failed: %d\n", ret);
1341                         return ret;
1342                 }
1343
1344                 ret = lpass_platform_alloc_va_dmactl_fields(&pdev->dev,
1345                                                  drvdata->va_lpaif_map);
1346                 if (ret) {
1347                         dev_err(&pdev->dev,
1348                                 "error initializing va dmactl fields: %d\n", ret);
1349                         return ret;
1350                 }
1351         }
1352
1353         if (drvdata->hdmi_port_enable) {
1354                 drvdata->hdmiif_irq = platform_get_irq_byname(pdev, "lpass-irq-hdmi");
1355                 if (drvdata->hdmiif_irq < 0)
1356                         return -ENODEV;
1357
1358                 ret = devm_request_irq(&pdev->dev, drvdata->hdmiif_irq,
1359                                 lpass_platform_hdmiif_irq, 0, "lpass-irq-hdmi", drvdata);
1360                 if (ret) {
1361                         dev_err(&pdev->dev, "irq hdmi request failed: %d\n", ret);
1362                         return ret;
1363                 }
1364                 ret = regmap_write(drvdata->hdmiif_map,
1365                                 LPASS_HDMITX_APP_IRQEN_REG(v), 0);
1366                 if (ret) {
1367                         dev_err(&pdev->dev, "error writing to hdmi irqen reg: %d\n", ret);
1368                         return ret;
1369                 }
1370
1371                 ret = lpass_platform_alloc_hdmidmactl_fields(&pdev->dev,
1372                                                          drvdata->hdmiif_map);
1373                 if (ret) {
1374                         dev_err(&pdev->dev,
1375                                 "error initializing hdmidmactl fields: %d\n", ret);
1376                         return ret;
1377                 }
1378         }
1379         return devm_snd_soc_register_component(&pdev->dev,
1380                         &lpass_component_driver, NULL, 0);
1381 }
1382 EXPORT_SYMBOL_GPL(asoc_qcom_lpass_platform_register);
1383
1384 MODULE_DESCRIPTION("QTi LPASS Platform Driver");
1385 MODULE_LICENSE("GPL v2");