sound/soc/xilinx/xlnx_formatter_pcm.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 //
   3 // Xilinx ASoC audio formatter support
   4 //
   5 // Copyright (C) 2018 Xilinx, Inc.
   6 //
   7 // Author: Maruthi Srinivas Bayyavarapu <maruthis@xilinx.com>
   8
   9 #include <linux/clk.h>
  10 #include <linux/io.h>
  11 #include <linux/module.h>
  12 #include <linux/of_address.h>
  13 #include <linux/of_irq.h>
  14 #include <linux/sizes.h>
  15
  16 #include <sound/asoundef.h>
  17 #include <sound/soc.h>
  18 #include <sound/pcm_params.h>
  19
  20 #define DRV_NAME "xlnx_formatter_pcm"
  21
  22 #define XLNX_S2MM_OFFSET        0
  23 #define XLNX_MM2S_OFFSET        0x100
  24
  25 #define XLNX_AUD_CORE_CONFIG    0x4
  26 #define XLNX_AUD_CTRL           0x10
  27 #define XLNX_AUD_STS            0x14
  28
  29 #define AUD_CTRL_RESET_MASK     BIT(1)
  30 #define AUD_CFG_MM2S_MASK       BIT(15)
  31 #define AUD_CFG_S2MM_MASK       BIT(31)
  32
  33 #define XLNX_AUD_FS_MULTIPLIER  0x18
  34 #define XLNX_AUD_PERIOD_CONFIG  0x1C
  35 #define XLNX_AUD_BUFF_ADDR_LSB  0x20
  36 #define XLNX_AUD_BUFF_ADDR_MSB  0x24
  37 #define XLNX_AUD_XFER_COUNT     0x28
  38 #define XLNX_AUD_CH_STS_START   0x2C
  39 #define XLNX_BYTES_PER_CH       0x44
  40
  41 #define AUD_STS_IOC_IRQ_MASK    BIT(31)
  42 #define AUD_STS_CH_STS_MASK     BIT(29)
  43 #define AUD_CTRL_IOC_IRQ_MASK   BIT(13)
  44 #define AUD_CTRL_TOUT_IRQ_MASK  BIT(14)
  45 #define AUD_CTRL_DMA_EN_MASK    BIT(0)
  46
  47 #define CFG_MM2S_CH_MASK        GENMASK(11, 8)
  48 #define CFG_MM2S_CH_SHIFT       8
  49 #define CFG_MM2S_XFER_MASK      GENMASK(14, 13)
  50 #define CFG_MM2S_XFER_SHIFT     13
  51 #define CFG_MM2S_PKG_MASK       BIT(12)
  52
  53 #define CFG_S2MM_CH_MASK        GENMASK(27, 24)
  54 #define CFG_S2MM_CH_SHIFT       24
  55 #define CFG_S2MM_XFER_MASK      GENMASK(30, 29)
  56 #define CFG_S2MM_XFER_SHIFT     29
  57 #define CFG_S2MM_PKG_MASK       BIT(28)
  58
  59 #define AUD_CTRL_DATA_WIDTH_SHIFT       16
  60 #define AUD_CTRL_ACTIVE_CH_SHIFT        19
  61 #define PERIOD_CFG_PERIODS_SHIFT        16
  62
  63 #define PERIODS_MIN             2
  64 #define PERIODS_MAX             6
  65 #define PERIOD_BYTES_MIN        192
  66 #define PERIOD_BYTES_MAX        (50 * 1024)
  67 #define XLNX_PARAM_UNKNOWN      0
  68
  69 enum bit_depth {
  70         BIT_DEPTH_8,
  71         BIT_DEPTH_16,
  72         BIT_DEPTH_20,
  73         BIT_DEPTH_24,
  74         BIT_DEPTH_32,
  75 };
  76
  77 struct xlnx_pcm_drv_data {
  78         void __iomem *mmio;
  79         bool s2mm_presence;
  80         bool mm2s_presence;
  81         int s2mm_irq;
  82         int mm2s_irq;
  83         struct snd_pcm_substream *play_stream;
  84         struct snd_pcm_substream *capture_stream;
  85         struct clk *axi_clk;
  86 };
  87
  88 /*
  89  * struct xlnx_pcm_stream_param - stream configuration
  90  * @mmio: base address offset
  91  * @interleaved: audio channels arrangement in buffer
  92  * @xfer_mode: data formatting mode during transfer
  93  * @ch_limit: Maximum channels supported
  94  * @buffer_size: stream ring buffer size
  95  */
  96 struct xlnx_pcm_stream_param {
  97         void __iomem *mmio;
  98         bool interleaved;
  99         u32 xfer_mode;
 100         u32 ch_limit;
 101         u64 buffer_size;
 102 };
 103
 104 static const struct snd_pcm_hardware xlnx_pcm_hardware = {
 105         .info = SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER |
 106                 SNDRV_PCM_INFO_BATCH | SNDRV_PCM_INFO_PAUSE |
 107                 SNDRV_PCM_INFO_RESUME,
 108         .formats = SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_S16_LE |
 109                    SNDRV_PCM_FMTBIT_S24_LE,
 110         .channels_min = 2,
 111         .channels_max = 2,
 112         .rates = SNDRV_PCM_RATE_8000_192000,
 113         .rate_min = 8000,
 114         .rate_max = 192000,
 115         .buffer_bytes_max = PERIODS_MAX * PERIOD_BYTES_MAX,
 116         .period_bytes_min = PERIOD_BYTES_MIN,
 117         .period_bytes_max = PERIOD_BYTES_MAX,
 118         .periods_min = PERIODS_MIN,
 119         .periods_max = PERIODS_MAX,
 120 };
 121
 122 enum {
 123         AES_TO_AES,
 124         AES_TO_PCM,
 125         PCM_TO_PCM,
 126         PCM_TO_AES
 127 };
 128
 129 static void xlnx_parse_aes_params(u32 chsts_reg1_val, u32 chsts_reg2_val,
 130                                   struct device *dev)
 131 {
 132         u32 padded, srate, bit_depth, status[2];
 133
 134         if (chsts_reg1_val & IEC958_AES0_PROFESSIONAL) {
 135                 status[0] = chsts_reg1_val & 0xff;
 136                 status[1] = (chsts_reg1_val >> 16) & 0xff;
 137
 138                 switch (status[0] & IEC958_AES0_PRO_FS) {
 139                 case IEC958_AES0_PRO_FS_44100:
 140                         srate = 44100;
 141                         break;
 142                 case IEC958_AES0_PRO_FS_48000:
 143                         srate = 48000;
 144                         break;
 145                 case IEC958_AES0_PRO_FS_32000:
 146                         srate = 32000;
 147                         break;
 148                 case IEC958_AES0_PRO_FS_NOTID:
 149                 default:
 150                         srate = XLNX_PARAM_UNKNOWN;
 151                         break;
 152                 }
 153
 154                 switch (status[1] & IEC958_AES2_PRO_SBITS) {
 155                 case IEC958_AES2_PRO_WORDLEN_NOTID:
 156                 case IEC958_AES2_PRO_SBITS_20:
 157                         padded = 0;
 158                         break;
 159                 case IEC958_AES2_PRO_SBITS_24:
 160                         padded = 4;
 161                         break;
 162                 default:
 163                         bit_depth = XLNX_PARAM_UNKNOWN;
 164                         goto log_params;
 165                 }
 166
 167                 switch (status[1] & IEC958_AES2_PRO_WORDLEN) {
 168                 case IEC958_AES2_PRO_WORDLEN_20_16:
 169                         bit_depth = 16 + padded;
 170                         break;
 171                 case IEC958_AES2_PRO_WORDLEN_22_18:
 172                         bit_depth = 18 + padded;
 173                         break;
 174                 case IEC958_AES2_PRO_WORDLEN_23_19:
 175                         bit_depth = 19 + padded;
 176                         break;
 177                 case IEC958_AES2_PRO_WORDLEN_24_20:
 178                         bit_depth = 20 + padded;
 179                         break;
 180                 case IEC958_AES2_PRO_WORDLEN_NOTID:
 181                 default:
 182                         bit_depth = XLNX_PARAM_UNKNOWN;
 183                         break;
 184                 }
 185
 186         } else {
 187                 status[0] = (chsts_reg1_val >> 24) & 0xff;
 188                 status[1] = chsts_reg2_val & 0xff;
 189
 190                 switch (status[0] & IEC958_AES3_CON_FS) {
 191                 case IEC958_AES3_CON_FS_44100:
 192                         srate = 44100;
 193                         break;
 194                 case IEC958_AES3_CON_FS_48000:
 195                         srate = 48000;
 196                         break;
 197                 case IEC958_AES3_CON_FS_32000:
 198                         srate = 32000;
 199                         break;
 200                 default:
 201                         srate = XLNX_PARAM_UNKNOWN;
 202                         break;
 203                 }
 204
 205                 if (status[1] & IEC958_AES4_CON_MAX_WORDLEN_24)
 206                         padded = 4;
 207                 else
 208                         padded = 0;
 209
 210                 switch (status[1] & IEC958_AES4_CON_WORDLEN) {
 211                 case IEC958_AES4_CON_WORDLEN_20_16:
 212                         bit_depth = 16 + padded;
 213                         break;
 214                 case IEC958_AES4_CON_WORDLEN_22_18:
 215                         bit_depth = 18 + padded;
 216                         break;
 217                 case IEC958_AES4_CON_WORDLEN_23_19:
 218                         bit_depth = 19 + padded;
 219                         break;
 220                 case IEC958_AES4_CON_WORDLEN_24_20:
 221                         bit_depth = 20 + padded;
 222                         break;
 223                 case IEC958_AES4_CON_WORDLEN_21_17:
 224                         bit_depth = 17 + padded;
 225                         break;
 226                 case IEC958_AES4_CON_WORDLEN_NOTID:
 227                 default:
 228                         bit_depth = XLNX_PARAM_UNKNOWN;
 229                         break;
 230                 }
 231         }
 232
 233 log_params:
 234         if (srate != XLNX_PARAM_UNKNOWN)
 235                 dev_info(dev, "sample rate = %d\n", srate);
 236         else
 237                 dev_info(dev, "sample rate = unknown\n");
 238
 239         if (bit_depth != XLNX_PARAM_UNKNOWN)
 240                 dev_info(dev, "bit_depth = %d\n", bit_depth);
 241         else
 242                 dev_info(dev, "bit_depth = unknown\n");
 243 }
 244
 245 static int xlnx_formatter_pcm_reset(void __iomem *mmio_base)
 246 {
 247         u32 val, retries = 0;
 248
 249         val = readl(mmio_base + XLNX_AUD_CTRL);
 250         val |= AUD_CTRL_RESET_MASK;
 251         writel(val, mmio_base + XLNX_AUD_CTRL);
 252
 253         val = readl(mmio_base + XLNX_AUD_CTRL);
 254         /* Poll for maximum timeout of approximately 100ms (1 * 100)*/
 255         while ((val & AUD_CTRL_RESET_MASK) && (retries < 100)) {
 256                 mdelay(1);
 257                 retries++;
 258                 val = readl(mmio_base + XLNX_AUD_CTRL);
 259         }
 260         if (val & AUD_CTRL_RESET_MASK)
 261                 return -ENODEV;
 262
 263         return 0;
 264 }
 265
 266 static void xlnx_formatter_disable_irqs(void __iomem *mmio_base, int stream)
 267 {
 268         u32 val;
 269
 270         val = readl(mmio_base + XLNX_AUD_CTRL);
 271         val &= ~AUD_CTRL_IOC_IRQ_MASK;
 272         if (stream == SNDRV_PCM_STREAM_CAPTURE)
 273                 val &= ~AUD_CTRL_TOUT_IRQ_MASK;
 274
 275         writel(val, mmio_base + XLNX_AUD_CTRL);
 276 }
 277
 278 static irqreturn_t xlnx_mm2s_irq_handler(int irq, void *arg)
 279 {
 280         u32 val;
 281         void __iomem *reg;
 282         struct device *dev = arg;
 283         struct xlnx_pcm_drv_data *adata = dev_get_drvdata(dev);
 284
 285         reg = adata->mmio + XLNX_MM2S_OFFSET + XLNX_AUD_STS;
 286         val = readl(reg);
 287         if (val & AUD_STS_IOC_IRQ_MASK) {
 288                 writel(val & AUD_STS_IOC_IRQ_MASK, reg);
 289                 if (adata->play_stream)
 290                         snd_pcm_period_elapsed(adata->play_stream);
 291                 return IRQ_HANDLED;
 292         }
 293
 294         return IRQ_NONE;
 295 }
 296
 297 static irqreturn_t xlnx_s2mm_irq_handler(int irq, void *arg)
 298 {
 299         u32 val;
 300         void __iomem *reg;
 301         struct device *dev = arg;
 302         struct xlnx_pcm_drv_data *adata = dev_get_drvdata(dev);
 303
 304         reg = adata->mmio + XLNX_S2MM_OFFSET + XLNX_AUD_STS;
 305         val = readl(reg);
 306         if (val & AUD_STS_IOC_IRQ_MASK) {
 307                 writel(val & AUD_STS_IOC_IRQ_MASK, reg);
 308                 if (adata->capture_stream)
 309                         snd_pcm_period_elapsed(adata->capture_stream);
 310                 return IRQ_HANDLED;
 311         }
 312
 313         return IRQ_NONE;
 314 }
 315
 316 static int xlnx_formatter_pcm_open(struct snd_soc_component *component,
 317                                    struct snd_pcm_substream *substream)
 318 {
 319         int err;
 320         u32 val, data_format_mode;
 321         u32 ch_count_mask, ch_count_shift, data_xfer_mode, data_xfer_shift;
 322         struct xlnx_pcm_stream_param *stream_data;
 323         struct snd_pcm_runtime *runtime = substream->runtime;
 324         struct xlnx_pcm_drv_data *adata = dev_get_drvdata(component->dev);
 325
 326         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
 327             !adata->mm2s_presence)
 328                 return -ENODEV;
 329         else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE &&
 330                  !adata->s2mm_presence)
 331                 return -ENODEV;
 332
 333         stream_data = kzalloc(sizeof(*stream_data), GFP_KERNEL);
 334         if (!stream_data)
 335                 return -ENOMEM;
 336
 337         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 338                 ch_count_mask = CFG_MM2S_CH_MASK;
 339                 ch_count_shift = CFG_MM2S_CH_SHIFT;
 340                 data_xfer_mode = CFG_MM2S_XFER_MASK;
 341                 data_xfer_shift = CFG_MM2S_XFER_SHIFT;
 342                 data_format_mode = CFG_MM2S_PKG_MASK;
 343                 stream_data->mmio = adata->mmio + XLNX_MM2S_OFFSET;
 344                 adata->play_stream = substream;
 345
 346         } else {
 347                 ch_count_mask = CFG_S2MM_CH_MASK;
 348                 ch_count_shift = CFG_S2MM_CH_SHIFT;
 349                 data_xfer_mode = CFG_S2MM_XFER_MASK;
 350                 data_xfer_shift = CFG_S2MM_XFER_SHIFT;
 351                 data_format_mode = CFG_S2MM_PKG_MASK;
 352                 stream_data->mmio = adata->mmio + XLNX_S2MM_OFFSET;
 353                 adata->capture_stream = substream;
 354         }
 355
 356         val = readl(adata->mmio + XLNX_AUD_CORE_CONFIG);
 357
 358         if (!(val & data_format_mode))
 359                 stream_data->interleaved = true;
 360
 361         stream_data->xfer_mode = (val & data_xfer_mode) >> data_xfer_shift;
 362         stream_data->ch_limit = (val & ch_count_mask) >> ch_count_shift;
 363         dev_info(component->dev,
 364                  "stream %d : format = %d mode = %d ch_limit = %d\n",
 365                  substream->stream, stream_data->interleaved,
 366                  stream_data->xfer_mode, stream_data->ch_limit);
 367
 368         snd_soc_set_runtime_hwparams(substream, &xlnx_pcm_hardware);
 369         runtime->private_data = stream_data;
 370
 371         /* Resize the period size divisible by 64 */
 372         err = snd_pcm_hw_constraint_step(runtime, 0,
 373                                          SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 64);
 374         if (err) {
 375                 dev_err(component->dev,
 376                         "unable to set constraint on period bytes\n");
 377                 return err;
 378         }
 379
 380         /* enable DMA IOC irq */
 381         val = readl(stream_data->mmio + XLNX_AUD_CTRL);
 382         val |= AUD_CTRL_IOC_IRQ_MASK;
 383         writel(val, stream_data->mmio + XLNX_AUD_CTRL);
 384
 385         return 0;
 386 }
 387
 388 static int xlnx_formatter_pcm_close(struct snd_soc_component *component,
 389                                     struct snd_pcm_substream *substream)
 390 {
 391         int ret;
 392         struct xlnx_pcm_stream_param *stream_data =
 393                         substream->runtime->private_data;
 394
 395         ret = xlnx_formatter_pcm_reset(stream_data->mmio);
 396         if (ret) {
 397                 dev_err(component->dev, "audio formatter reset failed\n");
 398                 goto err_reset;
 399         }
 400         xlnx_formatter_disable_irqs(stream_data->mmio, substream->stream);
 401
 402 err_reset:
 403         kfree(stream_data);
 404         return 0;
 405 }
 406
 407 static snd_pcm_uframes_t
 408 xlnx_formatter_pcm_pointer(struct snd_soc_component *component,
 409                            struct snd_pcm_substream *substream)
 410 {
 411         u32 pos;
 412         struct snd_pcm_runtime *runtime = substream->runtime;
 413         struct xlnx_pcm_stream_param *stream_data = runtime->private_data;
 414
 415         pos = readl(stream_data->mmio + XLNX_AUD_XFER_COUNT);
 416
 417         if (pos >= stream_data->buffer_size)
 418                 pos = 0;
 419
 420         return bytes_to_frames(runtime, pos);
 421 }
 422
 423 static int xlnx_formatter_pcm_hw_params(struct snd_soc_component *component,
 424                                         struct snd_pcm_substream *substream,
 425                                         struct snd_pcm_hw_params *params)
 426 {
 427         u32 low, high, active_ch, val, bytes_per_ch, bits_per_sample;
 428         u32 aes_reg1_val, aes_reg2_val;
 429         u64 size;
 430         struct snd_pcm_runtime *runtime = substream->runtime;
 431         struct xlnx_pcm_stream_param *stream_data = runtime->private_data;
 432
 433         active_ch = params_channels(params);
 434         if (active_ch > stream_data->ch_limit)
 435                 return -EINVAL;
 436
 437         if (substream->stream == SNDRV_PCM_STREAM_CAPTURE &&
 438             stream_data->xfer_mode == AES_TO_PCM) {
 439                 val = readl(stream_data->mmio + XLNX_AUD_STS);
 440                 if (val & AUD_STS_CH_STS_MASK) {
 441                         aes_reg1_val = readl(stream_data->mmio +
 442                                              XLNX_AUD_CH_STS_START);
 443                         aes_reg2_val = readl(stream_data->mmio +
 444                                              XLNX_AUD_CH_STS_START + 0x4);
 445
 446                         xlnx_parse_aes_params(aes_reg1_val, aes_reg2_val,
 447                                               component->dev);
 448                 }
 449         }
 450
 451         size = params_buffer_bytes(params);
 452
 453         stream_data->buffer_size = size;
 454
 455         low = lower_32_bits(substream->dma_buffer.addr);
 456         high = upper_32_bits(substream->dma_buffer.addr);
 457         writel(low, stream_data->mmio + XLNX_AUD_BUFF_ADDR_LSB);
 458         writel(high, stream_data->mmio + XLNX_AUD_BUFF_ADDR_MSB);
 459
 460         val = readl(stream_data->mmio + XLNX_AUD_CTRL);
 461         bits_per_sample = params_width(params);
 462         switch (bits_per_sample) {
 463         case 8:
 464                 val |= (BIT_DEPTH_8 << AUD_CTRL_DATA_WIDTH_SHIFT);
 465                 break;
 466         case 16:
 467                 val |= (BIT_DEPTH_16 << AUD_CTRL_DATA_WIDTH_SHIFT);
 468                 break;
 469         case 20:
 470                 val |= (BIT_DEPTH_20 << AUD_CTRL_DATA_WIDTH_SHIFT);
 471                 break;
 472         case 24:
 473                 val |= (BIT_DEPTH_24 << AUD_CTRL_DATA_WIDTH_SHIFT);
 474                 break;
 475         case 32:
 476                 val |= (BIT_DEPTH_32 << AUD_CTRL_DATA_WIDTH_SHIFT);
 477                 break;
 478         default:
 479                 return -EINVAL;
 480         }
 481
 482         val |= active_ch << AUD_CTRL_ACTIVE_CH_SHIFT;
 483         writel(val, stream_data->mmio + XLNX_AUD_CTRL);
 484
 485         val = (params_periods(params) << PERIOD_CFG_PERIODS_SHIFT)
 486                 | params_period_bytes(params);
 487         writel(val, stream_data->mmio + XLNX_AUD_PERIOD_CONFIG);
 488         bytes_per_ch = DIV_ROUND_UP(params_period_bytes(params), active_ch);
 489         writel(bytes_per_ch, stream_data->mmio + XLNX_BYTES_PER_CH);
 490
 491         return 0;
 492 }
 493
 494 static int xlnx_formatter_pcm_trigger(struct snd_soc_component *component,
 495                                       struct snd_pcm_substream *substream,
 496                                       int cmd)
 497 {
 498         u32 val;
 499         struct xlnx_pcm_stream_param *stream_data =
 500                         substream->runtime->private_data;
 501
 502         switch (cmd) {
 503         case SNDRV_PCM_TRIGGER_START:
 504         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 505         case SNDRV_PCM_TRIGGER_RESUME:
 506                 val = readl(stream_data->mmio + XLNX_AUD_CTRL);
 507                 val |= AUD_CTRL_DMA_EN_MASK;
 508                 writel(val, stream_data->mmio + XLNX_AUD_CTRL);
 509                 break;
 510         case SNDRV_PCM_TRIGGER_STOP:
 511         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 512         case SNDRV_PCM_TRIGGER_SUSPEND:
 513                 val = readl(stream_data->mmio + XLNX_AUD_CTRL);
 514                 val &= ~AUD_CTRL_DMA_EN_MASK;
 515                 writel(val, stream_data->mmio + XLNX_AUD_CTRL);
 516                 break;
 517         }
 518
 519         return 0;
 520 }
 521
 522 static int xlnx_formatter_pcm_new(struct snd_soc_component *component,
 523                                   struct snd_soc_pcm_runtime *rtd)
 524 {
 525         snd_pcm_set_managed_buffer_all(rtd->pcm,
 526                         SNDRV_DMA_TYPE_DEV, component->dev,
 527                         xlnx_pcm_hardware.buffer_bytes_max,
 528                         xlnx_pcm_hardware.buffer_bytes_max);
 529         return 0;
 530 }
 531
 532 static const struct snd_soc_component_driver xlnx_asoc_component = {
 533         .name           = DRV_NAME,
 534         .open           = xlnx_formatter_pcm_open,
 535         .close          = xlnx_formatter_pcm_close,
 536         .hw_params      = xlnx_formatter_pcm_hw_params,
 537         .trigger        = xlnx_formatter_pcm_trigger,
 538         .pointer        = xlnx_formatter_pcm_pointer,
 539         .pcm_construct  = xlnx_formatter_pcm_new,
 540 };
 541
 542 static int xlnx_formatter_pcm_probe(struct platform_device *pdev)
 543 {
 544         int ret;
 545         u32 val;
 546         struct xlnx_pcm_drv_data *aud_drv_data;
 547         struct device *dev = &pdev->dev;
 548
 549         aud_drv_data = devm_kzalloc(dev, sizeof(*aud_drv_data), GFP_KERNEL);
 550         if (!aud_drv_data)
 551                 return -ENOMEM;
 552
 553         aud_drv_data->axi_clk = devm_clk_get(dev, "s_axi_lite_aclk");
 554         if (IS_ERR(aud_drv_data->axi_clk)) {
 555                 ret = PTR_ERR(aud_drv_data->axi_clk);
 556                 dev_err(dev, "failed to get s_axi_lite_aclk(%d)\n", ret);
 557                 return ret;
 558         }
 559         ret = clk_prepare_enable(aud_drv_data->axi_clk);
 560         if (ret) {
 561                 dev_err(dev,
 562                         "failed to enable s_axi_lite_aclk(%d)\n", ret);
 563                 return ret;
 564         }
 565
 566         aud_drv_data->mmio = devm_platform_ioremap_resource(pdev, 0);
 567         if (IS_ERR(aud_drv_data->mmio)) {
 568                 dev_err(dev, "audio formatter ioremap failed\n");
 569                 ret = PTR_ERR(aud_drv_data->mmio);
 570                 goto clk_err;
 571         }
 572
 573         val = readl(aud_drv_data->mmio + XLNX_AUD_CORE_CONFIG);
 574         if (val & AUD_CFG_MM2S_MASK) {
 575                 aud_drv_data->mm2s_presence = true;
 576                 ret = xlnx_formatter_pcm_reset(aud_drv_data->mmio +
 577                                                XLNX_MM2S_OFFSET);
 578                 if (ret) {
 579                         dev_err(dev, "audio formatter reset failed\n");
 580                         goto clk_err;
 581                 }
 582                 xlnx_formatter_disable_irqs(aud_drv_data->mmio +
 583                                             XLNX_MM2S_OFFSET,
 584                                             SNDRV_PCM_STREAM_PLAYBACK);
 585
 586                 aud_drv_data->mm2s_irq = platform_get_irq_byname(pdev,
 587                                                                  "irq_mm2s");
 588                 if (aud_drv_data->mm2s_irq < 0) {
 589                         ret = aud_drv_data->mm2s_irq;
 590                         goto clk_err;
 591                 }
 592                 ret = devm_request_irq(dev, aud_drv_data->mm2s_irq,
 593                                        xlnx_mm2s_irq_handler, 0,
 594                                        "xlnx_formatter_pcm_mm2s_irq", dev);
 595                 if (ret) {
 596                         dev_err(dev, "xlnx audio mm2s irq request failed\n");
 597                         goto clk_err;
 598                 }
 599         }
 600         if (val & AUD_CFG_S2MM_MASK) {
 601                 aud_drv_data->s2mm_presence = true;
 602                 ret = xlnx_formatter_pcm_reset(aud_drv_data->mmio +
 603                                                XLNX_S2MM_OFFSET);
 604                 if (ret) {
 605                         dev_err(dev, "audio formatter reset failed\n");
 606                         goto clk_err;
 607                 }
 608                 xlnx_formatter_disable_irqs(aud_drv_data->mmio +
 609                                             XLNX_S2MM_OFFSET,
 610                                             SNDRV_PCM_STREAM_CAPTURE);
 611
 612                 aud_drv_data->s2mm_irq = platform_get_irq_byname(pdev,
 613                                                                  "irq_s2mm");
 614                 if (aud_drv_data->s2mm_irq < 0) {
 615                         ret = aud_drv_data->s2mm_irq;
 616                         goto clk_err;
 617                 }
 618                 ret = devm_request_irq(dev, aud_drv_data->s2mm_irq,
 619                                        xlnx_s2mm_irq_handler, 0,
 620                                        "xlnx_formatter_pcm_s2mm_irq",
 621                                        dev);
 622                 if (ret) {
 623                         dev_err(dev, "xlnx audio s2mm irq request failed\n");
 624                         goto clk_err;
 625                 }
 626         }
 627
 628         dev_set_drvdata(dev, aud_drv_data);
 629
 630         ret = devm_snd_soc_register_component(dev, &xlnx_asoc_component,
 631                                               NULL, 0);
 632         if (ret) {
 633                 dev_err(dev, "pcm platform device register failed\n");
 634                 goto clk_err;
 635         }
 636
 637         return 0;
 638
 639 clk_err:
 640         clk_disable_unprepare(aud_drv_data->axi_clk);
 641         return ret;
 642 }
 643
 644 static int xlnx_formatter_pcm_remove(struct platform_device *pdev)
 645 {
 646         int ret = 0;
 647         struct xlnx_pcm_drv_data *adata = dev_get_drvdata(&pdev->dev);
 648
 649         if (adata->s2mm_presence)
 650                 ret = xlnx_formatter_pcm_reset(adata->mmio + XLNX_S2MM_OFFSET);
 651
 652         /* Try MM2S reset, even if S2MM  reset fails */
 653         if (adata->mm2s_presence)
 654                 ret = xlnx_formatter_pcm_reset(adata->mmio + XLNX_MM2S_OFFSET);
 655
 656         if (ret)
 657                 dev_err(&pdev->dev, "audio formatter reset failed\n");
 658
 659         clk_disable_unprepare(adata->axi_clk);
 660         return ret;
 661 }
 662
 663 static const struct of_device_id xlnx_formatter_pcm_of_match[] = {
 664         { .compatible = "xlnx,audio-formatter-1.0"},
 665         {},
 666 };
 667 MODULE_DEVICE_TABLE(of, xlnx_formatter_pcm_of_match);
 668
 669 static struct platform_driver xlnx_formatter_pcm_driver = {
 670         .probe  = xlnx_formatter_pcm_probe,
 671         .remove = xlnx_formatter_pcm_remove,
 672         .driver = {
 673                 .name   = DRV_NAME,
 674                 .of_match_table = xlnx_formatter_pcm_of_match,
 675         },
 676 };
 677
 678 module_platform_driver(xlnx_formatter_pcm_driver);
 679 MODULE_AUTHOR("Maruthi Srinivas Bayyavarapu <maruthis@xilinx.com>");
 680 MODULE_LICENSE("GPL v2");