catpt/pcm.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 //
   3 // Copyright(c) 2020 Intel Corporation. All rights reserved.
   4 //
   5 // Author: Cezary Rojewski <cezary.rojewski@intel.com>
   6 //
   7
   8 #include <linux/pm_runtime.h>
   9 #include <sound/soc.h>
  10 #include <sound/pcm_params.h>
  11 #include <uapi/sound/tlv.h>
  12 #include "core.h"
  13 #include "messages.h"
  14
  15 struct catpt_stream_template {
  16         enum catpt_path_id path_id;
  17         enum catpt_stream_type type;
  18         u32 persistent_size;
  19         u8 num_entries;
  20         struct catpt_module_entry entries[];
  21 };
  22
  23 static struct catpt_stream_template system_pb = {
  24         .path_id = CATPT_PATH_SSP0_OUT,
  25         .type = CATPT_STRM_TYPE_SYSTEM,
  26         .num_entries = 1,
  27         .entries = {{ CATPT_MODID_PCM_SYSTEM, 0 }},
  28 };
  29
  30 static struct catpt_stream_template system_cp = {
  31         .path_id = CATPT_PATH_SSP0_IN,
  32         .type = CATPT_STRM_TYPE_CAPTURE,
  33         .num_entries = 1,
  34         .entries = {{ CATPT_MODID_PCM_CAPTURE, 0 }},
  35 };
  36
  37 static struct catpt_stream_template offload_pb = {
  38         .path_id = CATPT_PATH_SSP0_OUT,
  39         .type = CATPT_STRM_TYPE_RENDER,
  40         .num_entries = 1,
  41         .entries = {{ CATPT_MODID_PCM, 0 }},
  42 };
  43
  44 static struct catpt_stream_template loopback_cp = {
  45         .path_id = CATPT_PATH_SSP0_OUT,
  46         .type = CATPT_STRM_TYPE_LOOPBACK,
  47         .num_entries = 1,
  48         .entries = {{ CATPT_MODID_PCM_REFERENCE, 0 }},
  49 };
  50
  51 static struct catpt_stream_template bluetooth_pb = {
  52         .path_id = CATPT_PATH_SSP1_OUT,
  53         .type = CATPT_STRM_TYPE_BLUETOOTH_RENDER,
  54         .num_entries = 1,
  55         .entries = {{ CATPT_MODID_BLUETOOTH_RENDER, 0 }},
  56 };
  57
  58 static struct catpt_stream_template bluetooth_cp = {
  59         .path_id = CATPT_PATH_SSP1_IN,
  60         .type = CATPT_STRM_TYPE_BLUETOOTH_CAPTURE,
  61         .num_entries = 1,
  62         .entries = {{ CATPT_MODID_BLUETOOTH_CAPTURE, 0 }},
  63 };
  64
  65 static struct catpt_stream_template *catpt_topology[] = {
  66         [CATPT_STRM_TYPE_RENDER]                = &offload_pb,
  67         [CATPT_STRM_TYPE_SYSTEM]                = &system_pb,
  68         [CATPT_STRM_TYPE_CAPTURE]               = &system_cp,
  69         [CATPT_STRM_TYPE_LOOPBACK]              = &loopback_cp,
  70         [CATPT_STRM_TYPE_BLUETOOTH_RENDER]      = &bluetooth_pb,
  71         [CATPT_STRM_TYPE_BLUETOOTH_CAPTURE]     = &bluetooth_cp,
  72 };
  73
  74 static struct catpt_stream_template *
  75 catpt_get_stream_template(struct snd_pcm_substream *substream)
  76 {
  77         struct snd_soc_pcm_runtime *rtm = substream->private_data;
  78         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtm, 0);
  79         enum catpt_stream_type type;
  80
  81         type = cpu_dai->driver->id;
  82
  83         /* account for capture in bidirectional dais */
  84         switch (type) {
  85         case CATPT_STRM_TYPE_SYSTEM:
  86                 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
  87                         type = CATPT_STRM_TYPE_CAPTURE;
  88                 break;
  89         case CATPT_STRM_TYPE_BLUETOOTH_RENDER:
  90                 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
  91                         type = CATPT_STRM_TYPE_BLUETOOTH_CAPTURE;
  92                 break;
  93         default:
  94                 break;
  95         };
  96
  97         return catpt_topology[type];
  98 }
  99
 100 struct catpt_stream_runtime *
 101 catpt_stream_find(struct catpt_dev *cdev, u8 stream_hw_id)
 102 {
 103         struct catpt_stream_runtime *pos, *result = NULL;
 104
 105         spin_lock(&cdev->list_lock);
 106         list_for_each_entry(pos, &cdev->stream_list, node) {
 107                 if (pos->info.stream_hw_id == stream_hw_id) {
 108                         result = pos;
 109                         break;
 110                 }
 111         }
 112
 113         spin_unlock(&cdev->list_lock);
 114         return result;
 115 }
 116
 117 static u32 catpt_stream_read_position(struct catpt_dev *cdev,
 118                                       struct catpt_stream_runtime *stream)
 119 {
 120         u32 pos;
 121
 122         memcpy_fromio(&pos, cdev->lpe_ba + stream->info.read_pos_regaddr,
 123                       sizeof(pos));
 124         return pos;
 125 }
 126
 127 static u32 catpt_stream_volume(struct catpt_dev *cdev,
 128                                struct catpt_stream_runtime *stream, u32 channel)
 129 {
 130         u32 volume, offset;
 131
 132         if (channel >= CATPT_CHANNELS_MAX)
 133                 channel = 0;
 134
 135         offset = stream->info.volume_regaddr[channel];
 136         memcpy_fromio(&volume, cdev->lpe_ba + offset, sizeof(volume));
 137         return volume;
 138 }
 139
 140 static u32 catpt_mixer_volume(struct catpt_dev *cdev,
 141                               struct catpt_mixer_stream_info *info, u32 channel)
 142 {
 143         u32 volume, offset;
 144
 145         if (channel >= CATPT_CHANNELS_MAX)
 146                 channel = 0;
 147
 148         offset = info->volume_regaddr[channel];
 149         memcpy_fromio(&volume, cdev->lpe_ba + offset, sizeof(volume));
 150         return volume;
 151 }
 152
 153 static void catpt_arrange_page_table(struct snd_pcm_substream *substream,
 154                                      struct snd_dma_buffer *pgtbl)
 155 {
 156         struct snd_pcm_runtime *rtm = substream->runtime;
 157         struct snd_dma_buffer *databuf = snd_pcm_get_dma_buf(substream);
 158         int i, pages;
 159
 160         pages = snd_sgbuf_aligned_pages(rtm->dma_bytes);
 161
 162         for (i = 0; i < pages; i++) {
 163                 u32 pfn, offset;
 164                 u32 *page_table;
 165
 166                 pfn = PFN_DOWN(snd_sgbuf_get_addr(databuf, i * PAGE_SIZE));
 167                 /* incrementing by 2 on even and 3 on odd */
 168                 offset = ((i << 2) + i) >> 1;
 169                 page_table = (u32 *)(pgtbl->area + offset);
 170
 171                 if (i & 1)
 172                         *page_table |= (pfn << 4);
 173                 else
 174                         *page_table |= pfn;
 175         }
 176 }
 177
 178 static u32 catpt_get_channel_map(enum catpt_channel_config config)
 179 {
 180         switch (config) {
 181         case CATPT_CHANNEL_CONFIG_MONO:
 182                 return GENMASK(31, 4) | CATPT_CHANNEL_CENTER;
 183
 184         case CATPT_CHANNEL_CONFIG_STEREO:
 185                 return GENMASK(31, 8) | CATPT_CHANNEL_LEFT
 186                                       | (CATPT_CHANNEL_RIGHT << 4);
 187
 188         case CATPT_CHANNEL_CONFIG_2_POINT_1:
 189                 return GENMASK(31, 12) | CATPT_CHANNEL_LEFT
 190                                        | (CATPT_CHANNEL_RIGHT << 4)
 191                                        | (CATPT_CHANNEL_LFE << 8);
 192
 193         case CATPT_CHANNEL_CONFIG_3_POINT_0:
 194                 return GENMASK(31, 12) | CATPT_CHANNEL_LEFT
 195                                        | (CATPT_CHANNEL_CENTER << 4)
 196                                        | (CATPT_CHANNEL_RIGHT << 8);
 197
 198         case CATPT_CHANNEL_CONFIG_3_POINT_1:
 199                 return GENMASK(31, 16) | CATPT_CHANNEL_LEFT
 200                                        | (CATPT_CHANNEL_CENTER << 4)
 201                                        | (CATPT_CHANNEL_RIGHT << 8)
 202                                        | (CATPT_CHANNEL_LFE << 12);
 203
 204         case CATPT_CHANNEL_CONFIG_QUATRO:
 205                 return GENMASK(31, 16) | CATPT_CHANNEL_LEFT
 206                                        | (CATPT_CHANNEL_RIGHT << 4)
 207                                        | (CATPT_CHANNEL_LEFT_SURROUND << 8)
 208                                        | (CATPT_CHANNEL_RIGHT_SURROUND << 12);
 209
 210         case CATPT_CHANNEL_CONFIG_4_POINT_0:
 211                 return GENMASK(31, 16) | CATPT_CHANNEL_LEFT
 212                                        | (CATPT_CHANNEL_CENTER << 4)
 213                                        | (CATPT_CHANNEL_RIGHT << 8)
 214                                        | (CATPT_CHANNEL_CENTER_SURROUND << 12);
 215
 216         case CATPT_CHANNEL_CONFIG_5_POINT_0:
 217                 return GENMASK(31, 20) | CATPT_CHANNEL_LEFT
 218                                        | (CATPT_CHANNEL_CENTER << 4)
 219                                        | (CATPT_CHANNEL_RIGHT << 8)
 220                                        | (CATPT_CHANNEL_LEFT_SURROUND << 12)
 221                                        | (CATPT_CHANNEL_RIGHT_SURROUND << 16);
 222
 223         case CATPT_CHANNEL_CONFIG_5_POINT_1:
 224                 return GENMASK(31, 24) | CATPT_CHANNEL_CENTER
 225                                        | (CATPT_CHANNEL_LEFT << 4)
 226                                        | (CATPT_CHANNEL_RIGHT << 8)
 227                                        | (CATPT_CHANNEL_LEFT_SURROUND << 12)
 228                                        | (CATPT_CHANNEL_RIGHT_SURROUND << 16)
 229                                        | (CATPT_CHANNEL_LFE << 20);
 230
 231         case CATPT_CHANNEL_CONFIG_DUAL_MONO:
 232                 return GENMASK(31, 8) | CATPT_CHANNEL_LEFT
 233                                       | (CATPT_CHANNEL_LEFT << 4);
 234
 235         default:
 236                 return U32_MAX;
 237         }
 238 }
 239
 240 static enum catpt_channel_config catpt_get_channel_config(u32 num_channels)
 241 {
 242         switch (num_channels) {
 243         case 6:
 244                 return CATPT_CHANNEL_CONFIG_5_POINT_1;
 245         case 5:
 246                 return CATPT_CHANNEL_CONFIG_5_POINT_0;
 247         case 4:
 248                 return CATPT_CHANNEL_CONFIG_QUATRO;
 249         case 3:
 250                 return CATPT_CHANNEL_CONFIG_2_POINT_1;
 251         case 1:
 252                 return CATPT_CHANNEL_CONFIG_MONO;
 253         case 2:
 254         default:
 255                 return CATPT_CHANNEL_CONFIG_STEREO;
 256         }
 257 }
 258
 259 static int catpt_dai_startup(struct snd_pcm_substream *substream,
 260                              struct snd_soc_dai *dai)
 261 {
 262         struct catpt_dev *cdev = dev_get_drvdata(dai->dev);
 263         struct catpt_stream_template *template;
 264         struct catpt_stream_runtime *stream;
 265         struct resource *res;
 266         int ret;
 267
 268         template = catpt_get_stream_template(substream);
 269
 270         stream = kzalloc(sizeof(*stream), GFP_KERNEL);
 271         if (!stream)
 272                 return -ENOMEM;
 273
 274         ret = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, cdev->dev, PAGE_SIZE,
 275                                   &stream->pgtbl);
 276         if (ret)
 277                 goto err_pgtbl;
 278
 279         res = catpt_request_region(&cdev->dram, template->persistent_size);
 280         if (!res) {
 281                 ret = -EBUSY;
 282                 goto err_request;
 283         }
 284
 285         catpt_dsp_update_srampge(cdev, &cdev->dram, cdev->spec->dram_mask);
 286
 287         stream->template = template;
 288         stream->persistent = res;
 289         stream->substream = substream;
 290         INIT_LIST_HEAD(&stream->node);
 291         snd_soc_dai_set_dma_data(dai, substream, stream);
 292
 293         spin_lock(&cdev->list_lock);
 294         list_add_tail(&stream->node, &cdev->stream_list);
 295         spin_unlock(&cdev->list_lock);
 296
 297         return 0;
 298
 299 err_request:
 300         snd_dma_free_pages(&stream->pgtbl);
 301 err_pgtbl:
 302         kfree(stream);
 303         return ret;
 304 }
 305
 306 static void catpt_dai_shutdown(struct snd_pcm_substream *substream,
 307                                struct snd_soc_dai *dai)
 308 {
 309         struct catpt_dev *cdev = dev_get_drvdata(dai->dev);
 310         struct catpt_stream_runtime *stream;
 311
 312         stream = snd_soc_dai_get_dma_data(dai, substream);
 313
 314         spin_lock(&cdev->list_lock);
 315         list_del(&stream->node);
 316         spin_unlock(&cdev->list_lock);
 317
 318         release_resource(stream->persistent);
 319         kfree(stream->persistent);
 320         catpt_dsp_update_srampge(cdev, &cdev->dram, cdev->spec->dram_mask);
 321
 322         snd_dma_free_pages(&stream->pgtbl);
 323         kfree(stream);
 324         snd_soc_dai_set_dma_data(dai, substream, NULL);
 325 }
 326
 327 static int catpt_dai_hw_params(struct snd_pcm_substream *substream,
 328                                struct snd_pcm_hw_params *params,
 329                                struct snd_soc_dai *dai)
 330 {
 331         struct catpt_dev *cdev = dev_get_drvdata(dai->dev);
 332         struct catpt_stream_runtime *stream;
 333         struct catpt_audio_format afmt;
 334         struct catpt_ring_info rinfo;
 335         struct snd_pcm_runtime *rtm = substream->runtime;
 336         struct snd_dma_buffer *dmab;
 337         int ret;
 338
 339         stream = snd_soc_dai_get_dma_data(dai, substream);
 340         if (stream->allocated)
 341                 return 0;
 342
 343         memset(&afmt, 0, sizeof(afmt));
 344         afmt.sample_rate = params_rate(params);
 345         afmt.bit_depth = params_physical_width(params);
 346         afmt.valid_bit_depth = params_width(params);
 347         afmt.num_channels = params_channels(params);
 348         afmt.channel_config = catpt_get_channel_config(afmt.num_channels);
 349         afmt.channel_map = catpt_get_channel_map(afmt.channel_config);
 350         afmt.interleaving = CATPT_INTERLEAVING_PER_CHANNEL;
 351
 352         dmab = snd_pcm_get_dma_buf(substream);
 353         catpt_arrange_page_table(substream, &stream->pgtbl);
 354
 355         memset(&rinfo, 0, sizeof(rinfo));
 356         rinfo.page_table_addr = stream->pgtbl.addr;
 357         rinfo.num_pages = DIV_ROUND_UP(rtm->dma_bytes, PAGE_SIZE);
 358         rinfo.size = rtm->dma_bytes;
 359         rinfo.offset = 0;
 360         rinfo.ring_first_page_pfn = PFN_DOWN(snd_sgbuf_get_addr(dmab, 0));
 361
 362         ret = catpt_ipc_alloc_stream(cdev, stream->template->path_id,
 363                                      stream->template->type,
 364                                      &afmt, &rinfo,
 365                                      stream->template->num_entries,
 366                                      stream->template->entries,
 367                                      stream->persistent,
 368                                      cdev->scratch,
 369                                      &stream->info);
 370         if (ret)
 371                 return CATPT_IPC_ERROR(ret);
 372
 373         stream->allocated = true;
 374         return 0;
 375 }
 376
 377 static int catpt_dai_hw_free(struct snd_pcm_substream *substream,
 378                              struct snd_soc_dai *dai)
 379 {
 380         struct catpt_dev *cdev = dev_get_drvdata(dai->dev);
 381         struct catpt_stream_runtime *stream;
 382
 383         stream = snd_soc_dai_get_dma_data(dai, substream);
 384         if (!stream->allocated)
 385                 return 0;
 386
 387         catpt_ipc_reset_stream(cdev, stream->info.stream_hw_id);
 388         catpt_ipc_free_stream(cdev, stream->info.stream_hw_id);
 389
 390         stream->allocated = false;
 391         return 0;
 392 }
 393
 394 static int catpt_set_dspvol(struct catpt_dev *cdev, u8 stream_id, long *ctlvol);
 395
 396 static int catpt_dai_apply_usettings(struct snd_soc_dai *dai,
 397                                      struct catpt_stream_runtime *stream)
 398 {
 399         struct catpt_dev *cdev = dev_get_drvdata(dai->dev);
 400         struct snd_soc_component *component = dai->component;
 401         struct snd_kcontrol *pos, *kctl = NULL;
 402         const char *name;
 403         int ret;
 404         u32 id = stream->info.stream_hw_id;
 405
 406         /* only selected streams have individual controls */
 407         switch (id) {
 408         case CATPT_PIN_ID_OFFLOAD1:
 409                 name = "Media0 Playback Volume";
 410                 break;
 411         case CATPT_PIN_ID_OFFLOAD2:
 412                 name = "Media1 Playback Volume";
 413                 break;
 414         case CATPT_PIN_ID_CAPTURE1:
 415                 name = "Mic Capture Volume";
 416                 break;
 417         case CATPT_PIN_ID_REFERENCE:
 418                 name = "Loopback Mute";
 419                 break;
 420         default:
 421                 return 0;
 422         };
 423
 424         list_for_each_entry(pos, &component->card->snd_card->controls, list) {
 425                 if (pos->private_data == component &&
 426                     !strncmp(name, pos->id.name, sizeof(pos->id.name))) {
 427                         kctl = pos;
 428                         break;
 429                 }
 430         }
 431         if (!kctl)
 432                 return -ENOENT;
 433
 434         if (stream->template->type != CATPT_STRM_TYPE_LOOPBACK)
 435                 return catpt_set_dspvol(cdev, id, (long *)kctl->private_value);
 436         ret = catpt_ipc_mute_loopback(cdev, id, *(bool *)kctl->private_value);
 437         if (ret)
 438                 return CATPT_IPC_ERROR(ret);
 439         return 0;
 440 }
 441
 442 static int catpt_dai_prepare(struct snd_pcm_substream *substream,
 443                              struct snd_soc_dai *dai)
 444 {
 445         struct catpt_dev *cdev = dev_get_drvdata(dai->dev);
 446         struct catpt_stream_runtime *stream;
 447         int ret;
 448
 449         stream = snd_soc_dai_get_dma_data(dai, substream);
 450         if (stream->prepared)
 451                 return 0;
 452
 453         ret = catpt_ipc_reset_stream(cdev, stream->info.stream_hw_id);
 454         if (ret)
 455                 return CATPT_IPC_ERROR(ret);
 456
 457         ret = catpt_ipc_pause_stream(cdev, stream->info.stream_hw_id);
 458         if (ret)
 459                 return CATPT_IPC_ERROR(ret);
 460
 461         ret = catpt_dai_apply_usettings(dai, stream);
 462         if (ret)
 463                 return ret;
 464
 465         stream->prepared = true;
 466         return 0;
 467 }
 468
 469 static int catpt_dai_trigger(struct snd_pcm_substream *substream, int cmd,
 470                              struct snd_soc_dai *dai)
 471 {
 472         struct catpt_dev *cdev = dev_get_drvdata(dai->dev);
 473         struct catpt_stream_runtime *stream;
 474         struct snd_pcm_runtime *runtime = substream->runtime;
 475         snd_pcm_uframes_t pos;
 476         int ret;
 477
 478         stream = snd_soc_dai_get_dma_data(dai, substream);
 479
 480         switch (cmd) {
 481         case SNDRV_PCM_TRIGGER_START:
 482                 /* only offload is set_write_pos driven */
 483                 if (stream->template->type != CATPT_STRM_TYPE_RENDER)
 484                         goto resume_stream;
 485
 486                 pos = frames_to_bytes(runtime, runtime->start_threshold);
 487                 /*
 488                  * Dsp operates on buffer halves, thus max 2x set_write_pos
 489                  * (entire buffer filled) prior to stream start.
 490                  */
 491                 ret = catpt_ipc_set_write_pos(cdev, stream->info.stream_hw_id,
 492                                               pos, false, false);
 493                 if (ret)
 494                         return CATPT_IPC_ERROR(ret);
 495                 fallthrough;
 496         case SNDRV_PCM_TRIGGER_RESUME:
 497         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 498         resume_stream:
 499                 catpt_dsp_update_lpclock(cdev);
 500                 ret = catpt_ipc_resume_stream(cdev, stream->info.stream_hw_id);
 501                 if (ret)
 502                         return CATPT_IPC_ERROR(ret);
 503                 break;
 504
 505         case SNDRV_PCM_TRIGGER_STOP:
 506                 stream->prepared = false;
 507                 fallthrough;
 508         case SNDRV_PCM_TRIGGER_SUSPEND:
 509         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 510                 ret = catpt_ipc_pause_stream(cdev, stream->info.stream_hw_id);
 511                 catpt_dsp_update_lpclock(cdev);
 512                 if (ret)
 513                         return CATPT_IPC_ERROR(ret);
 514                 break;
 515
 516         default:
 517                 break;
 518         }
 519
 520         return 0;
 521 }
 522
 523 void catpt_stream_update_position(struct catpt_dev *cdev,
 524                                   struct catpt_stream_runtime *stream,
 525                                   struct catpt_notify_position *pos)
 526 {
 527         struct snd_pcm_substream *substream = stream->substream;
 528         struct snd_pcm_runtime *r = substream->runtime;
 529         snd_pcm_uframes_t dsppos, newpos;
 530         int ret;
 531
 532         dsppos = bytes_to_frames(r, pos->stream_position);
 533
 534         if (!stream->prepared)
 535                 goto exit;
 536         /* only offload is set_write_pos driven */
 537         if (stream->template->type != CATPT_STRM_TYPE_RENDER)
 538                 goto exit;
 539
 540         if (dsppos >= r->buffer_size / 2)
 541                 newpos = r->buffer_size / 2;
 542         else
 543                 newpos = 0;
 544         /*
 545          * Dsp operates on buffer halves, thus on every notify position
 546          * (buffer half consumed) update wp to allow stream progression.
 547          */
 548         ret = catpt_ipc_set_write_pos(cdev, stream->info.stream_hw_id,
 549                                       frames_to_bytes(r, newpos),
 550                                       false, false);
 551         if (ret) {
 552                 dev_err(cdev->dev, "update position for stream %d failed: %d\n",
 553                         stream->info.stream_hw_id, ret);
 554                 return;
 555         }
 556 exit:
 557         snd_pcm_period_elapsed(substream);
 558 }
 559
 560 /* 200 ms for 2 32-bit channels at 48kHz (native format) */
 561 #define CATPT_BUFFER_MAX_SIZE   76800
 562 #define CATPT_PCM_PERIODS_MAX   4
 563 #define CATPT_PCM_PERIODS_MIN   2
 564
 565 static const struct snd_pcm_hardware catpt_pcm_hardware = {
 566         .info                   = SNDRV_PCM_INFO_MMAP |
 567                                   SNDRV_PCM_INFO_MMAP_VALID |
 568                                   SNDRV_PCM_INFO_INTERLEAVED |
 569                                   SNDRV_PCM_INFO_PAUSE |
 570                                   SNDRV_PCM_INFO_RESUME |
 571                                   SNDRV_PCM_INFO_NO_PERIOD_WAKEUP,
 572         .formats                = SNDRV_PCM_FMTBIT_S16_LE |
 573                                   SNDRV_PCM_FMTBIT_S24_LE |
 574                                   SNDRV_PCM_FMTBIT_S32_LE,
 575         .period_bytes_min       = PAGE_SIZE,
 576         .period_bytes_max       = CATPT_BUFFER_MAX_SIZE / CATPT_PCM_PERIODS_MIN,
 577         .periods_min            = CATPT_PCM_PERIODS_MIN,
 578         .periods_max            = CATPT_PCM_PERIODS_MAX,
 579         .buffer_bytes_max       = CATPT_BUFFER_MAX_SIZE,
 580 };
 581
 582 static int catpt_component_pcm_construct(struct snd_soc_component *component,
 583                                          struct snd_soc_pcm_runtime *rtm)
 584 {
 585         struct catpt_dev *cdev = dev_get_drvdata(component->dev);
 586
 587         snd_pcm_set_managed_buffer_all(rtm->pcm, SNDRV_DMA_TYPE_DEV_SG,
 588                                        cdev->dev,
 589                                        catpt_pcm_hardware.buffer_bytes_max,
 590                                        catpt_pcm_hardware.buffer_bytes_max);
 591
 592         return 0;
 593 }
 594
 595 static int catpt_component_open(struct snd_soc_component *component,
 596                                 struct snd_pcm_substream *substream)
 597 {
 598         struct snd_soc_pcm_runtime *rtm = substream->private_data;
 599
 600         if (rtm->dai_link->no_pcm)
 601                 return 0;
 602         snd_soc_set_runtime_hwparams(substream, &catpt_pcm_hardware);
 603         return 0;
 604 }
 605
 606 static snd_pcm_uframes_t
 607 catpt_component_pointer(struct snd_soc_component *component,
 608                         struct snd_pcm_substream *substream)
 609 {
 610         struct catpt_dev *cdev = dev_get_drvdata(component->dev);
 611         struct catpt_stream_runtime *stream;
 612         struct snd_soc_pcm_runtime *rtm = substream->private_data;
 613         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtm, 0);
 614         u32 pos;
 615
 616         if (rtm->dai_link->no_pcm)
 617                 return 0;
 618
 619         stream = snd_soc_dai_get_dma_data(cpu_dai, substream);
 620         pos = catpt_stream_read_position(cdev, stream);
 621
 622         return bytes_to_frames(substream->runtime, pos);
 623 }
 624
 625 static const struct snd_soc_dai_ops catpt_fe_dai_ops = {
 626         .startup = catpt_dai_startup,
 627         .shutdown = catpt_dai_shutdown,
 628         .hw_params = catpt_dai_hw_params,
 629         .hw_free = catpt_dai_hw_free,
 630         .prepare = catpt_dai_prepare,
 631         .trigger = catpt_dai_trigger,
 632 };
 633
 634 static int catpt_dai_pcm_new(struct snd_soc_pcm_runtime *rtm,
 635                              struct snd_soc_dai *dai)
 636 {
 637         struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtm, 0);
 638         struct catpt_dev *cdev = dev_get_drvdata(dai->dev);
 639         struct catpt_ssp_device_format devfmt;
 640         int ret;
 641
 642         devfmt.iface = dai->driver->id;
 643         devfmt.channels = codec_dai->driver->capture.channels_max;
 644
 645         switch (devfmt.iface) {
 646         case CATPT_SSP_IFACE_0:
 647                 devfmt.mclk = CATPT_MCLK_FREQ_24_MHZ;
 648
 649                 switch (devfmt.channels) {
 650                 case 4:
 651                         devfmt.mode = CATPT_SSP_MODE_TDM_PROVIDER;
 652                         devfmt.clock_divider = 4;
 653                         break;
 654                 case 2:
 655                 default:
 656                         devfmt.mode = CATPT_SSP_MODE_I2S_PROVIDER;
 657                         devfmt.clock_divider = 9;
 658                         break;
 659                 }
 660                 break;
 661
 662         case CATPT_SSP_IFACE_1:
 663                 devfmt.mclk = CATPT_MCLK_OFF;
 664                 devfmt.mode = CATPT_SSP_MODE_I2S_CONSUMER;
 665                 devfmt.clock_divider = 0;
 666                 break;
 667         }
 668
 669         /* see if this is a new configuration */
 670         if (!memcmp(&cdev->devfmt[devfmt.iface], &devfmt, sizeof(devfmt)))
 671                 return 0;
 672
 673         pm_runtime_get_sync(cdev->dev);
 674
 675         ret = catpt_ipc_set_device_format(cdev, &devfmt);
 676
 677         pm_runtime_mark_last_busy(cdev->dev);
 678         pm_runtime_put_autosuspend(cdev->dev);
 679
 680         if (ret)
 681                 return CATPT_IPC_ERROR(ret);
 682
 683         /* store device format set for given SSP */
 684         memcpy(&cdev->devfmt[devfmt.iface], &devfmt, sizeof(devfmt));
 685         return 0;
 686 }
 687
 688 static struct snd_soc_dai_driver dai_drivers[] = {
 689 /* FE DAIs */
 690 {
 691         .name  = "System Pin",
 692         .id = CATPT_STRM_TYPE_SYSTEM,
 693         .ops = &catpt_fe_dai_ops,
 694         .playback = {
 695                 .stream_name = "System Playback",
 696                 .channels_min = 2,
 697                 .channels_max = 2,
 698                 .rates = SNDRV_PCM_RATE_48000,
 699                 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE,
 700         },
 701         .capture = {
 702                 .stream_name = "Analog Capture",
 703                 .channels_min = 2,
 704                 .channels_max = 4,
 705                 .rates = SNDRV_PCM_RATE_48000,
 706                 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE,
 707         },
 708 },
 709 {
 710         .name  = "Offload0 Pin",
 711         .id = CATPT_STRM_TYPE_RENDER,
 712         .ops = &catpt_fe_dai_ops,
 713         .playback = {
 714                 .stream_name = "Offload0 Playback",
 715                 .channels_min = 2,
 716                 .channels_max = 2,
 717                 .rates = SNDRV_PCM_RATE_8000_192000,
 718                 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE,
 719         },
 720 },
 721 {
 722         .name  = "Offload1 Pin",
 723         .id = CATPT_STRM_TYPE_RENDER,
 724         .ops = &catpt_fe_dai_ops,
 725         .playback = {
 726                 .stream_name = "Offload1 Playback",
 727                 .channels_min = 2,
 728                 .channels_max = 2,
 729                 .rates = SNDRV_PCM_RATE_8000_192000,
 730                 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE,
 731         },
 732 },
 733 {
 734         .name  = "Loopback Pin",
 735         .id = CATPT_STRM_TYPE_LOOPBACK,
 736         .ops = &catpt_fe_dai_ops,
 737         .capture = {
 738                 .stream_name = "Loopback Capture",
 739                 .channels_min = 2,
 740                 .channels_max = 2,
 741                 .rates = SNDRV_PCM_RATE_48000,
 742                 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE,
 743         },
 744 },
 745 {
 746         .name  = "Bluetooth Pin",
 747         .id = CATPT_STRM_TYPE_BLUETOOTH_RENDER,
 748         .ops = &catpt_fe_dai_ops,
 749         .playback = {
 750                 .stream_name = "Bluetooth Playback",
 751                 .channels_min = 1,
 752                 .channels_max = 1,
 753                 .rates = SNDRV_PCM_RATE_8000,
 754                 .formats = SNDRV_PCM_FMTBIT_S16_LE,
 755         },
 756         .capture = {
 757                 .stream_name = "Bluetooth Capture",
 758                 .channels_min = 1,
 759                 .channels_max = 1,
 760                 .rates = SNDRV_PCM_RATE_8000,
 761                 .formats = SNDRV_PCM_FMTBIT_S16_LE,
 762         },
 763 },
 764 /* BE DAIs */
 765 {
 766         .name = "ssp0-port",
 767         .id = CATPT_SSP_IFACE_0,
 768         .pcm_new = catpt_dai_pcm_new,
 769         .playback = {
 770                 .channels_min = 1,
 771                 .channels_max = 8,
 772         },
 773         .capture = {
 774                 .channels_min = 1,
 775                 .channels_max = 8,
 776         },
 777 },
 778 {
 779         .name = "ssp1-port",
 780         .id = CATPT_SSP_IFACE_1,
 781         .pcm_new = catpt_dai_pcm_new,
 782         .playback = {
 783                 .channels_min = 1,
 784                 .channels_max = 8,
 785         },
 786         .capture = {
 787                 .channels_min = 1,
 788                 .channels_max = 8,
 789         },
 790 },
 791 };
 792
 793 #define DSP_VOLUME_MAX          S32_MAX /* 0db */
 794 #define DSP_VOLUME_STEP_MAX     30
 795
 796 static u32 ctlvol_to_dspvol(u32 value)
 797 {
 798         if (value > DSP_VOLUME_STEP_MAX)
 799                 value = 0;
 800         return DSP_VOLUME_MAX >> (DSP_VOLUME_STEP_MAX - value);
 801 }
 802
 803 static u32 dspvol_to_ctlvol(u32 volume)
 804 {
 805         if (volume > DSP_VOLUME_MAX)
 806                 return DSP_VOLUME_STEP_MAX;
 807         return volume ? __fls(volume) : 0;
 808 }
 809
 810 static int catpt_set_dspvol(struct catpt_dev *cdev, u8 stream_id, long *ctlvol)
 811 {
 812         u32 dspvol;
 813         int ret, i;
 814
 815         for (i = 1; i < CATPT_CHANNELS_MAX; i++)
 816                 if (ctlvol[i] != ctlvol[0])
 817                         break;
 818
 819         if (i == CATPT_CHANNELS_MAX) {
 820                 dspvol = ctlvol_to_dspvol(ctlvol[0]);
 821
 822                 ret = catpt_ipc_set_volume(cdev, stream_id,
 823                                            CATPT_ALL_CHANNELS_MASK, dspvol,
 824                                            0, CATPT_AUDIO_CURVE_NONE);
 825         } else {
 826                 for (i = 0; i < CATPT_CHANNELS_MAX; i++) {
 827                         dspvol = ctlvol_to_dspvol(ctlvol[i]);
 828
 829                         ret = catpt_ipc_set_volume(cdev, stream_id,
 830                                                    i, dspvol,
 831                                                    0, CATPT_AUDIO_CURVE_NONE);
 832                         if (ret)
 833                                 break;
 834                 }
 835         }
 836
 837         if (ret)
 838                 return CATPT_IPC_ERROR(ret);
 839         return 0;
 840 }
 841
 842 static int catpt_volume_info(struct snd_kcontrol *kcontrol,
 843                              struct snd_ctl_elem_info *uinfo)
 844 {
 845         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 846         uinfo->count = CATPT_CHANNELS_MAX;
 847         uinfo->value.integer.min = 0;
 848         uinfo->value.integer.max = DSP_VOLUME_STEP_MAX;
 849         return 0;
 850 }
 851
 852 static int catpt_mixer_volume_get(struct snd_kcontrol *kcontrol,
 853                                   struct snd_ctl_elem_value *ucontrol)
 854 {
 855         struct snd_soc_component *component =
 856                 snd_soc_kcontrol_component(kcontrol);
 857         struct catpt_dev *cdev = dev_get_drvdata(component->dev);
 858         u32 dspvol;
 859         int i;
 860
 861         pm_runtime_get_sync(cdev->dev);
 862
 863         for (i = 0; i < CATPT_CHANNELS_MAX; i++) {
 864                 dspvol = catpt_mixer_volume(cdev, &cdev->mixer, i);
 865                 ucontrol->value.integer.value[i] = dspvol_to_ctlvol(dspvol);
 866         }
 867
 868         pm_runtime_mark_last_busy(cdev->dev);
 869         pm_runtime_put_autosuspend(cdev->dev);
 870
 871         return 0;
 872 }
 873
 874 static int catpt_mixer_volume_put(struct snd_kcontrol *kcontrol,
 875                                   struct snd_ctl_elem_value *ucontrol)
 876 {
 877         struct snd_soc_component *component =
 878                 snd_soc_kcontrol_component(kcontrol);
 879         struct catpt_dev *cdev = dev_get_drvdata(component->dev);
 880         int ret;
 881
 882         pm_runtime_get_sync(cdev->dev);
 883
 884         ret = catpt_set_dspvol(cdev, cdev->mixer.mixer_hw_id,
 885                                ucontrol->value.integer.value);
 886
 887         pm_runtime_mark_last_busy(cdev->dev);
 888         pm_runtime_put_autosuspend(cdev->dev);
 889
 890         return ret;
 891 }
 892
 893 static int catpt_stream_volume_get(struct snd_kcontrol *kcontrol,
 894                                    struct snd_ctl_elem_value *ucontrol,
 895                                    enum catpt_pin_id pin_id)
 896 {
 897         struct snd_soc_component *component =
 898                 snd_soc_kcontrol_component(kcontrol);
 899         struct catpt_dev *cdev = dev_get_drvdata(component->dev);
 900         struct catpt_stream_runtime *stream;
 901         long *ctlvol = (long *)kcontrol->private_value;
 902         u32 dspvol;
 903         int i;
 904
 905         stream = catpt_stream_find(cdev, pin_id);
 906         if (!stream) {
 907                 for (i = 0; i < CATPT_CHANNELS_MAX; i++)
 908                         ucontrol->value.integer.value[i] = ctlvol[i];
 909                 return 0;
 910         }
 911
 912         pm_runtime_get_sync(cdev->dev);
 913
 914         for (i = 0; i < CATPT_CHANNELS_MAX; i++) {
 915                 dspvol = catpt_stream_volume(cdev, stream, i);
 916                 ucontrol->value.integer.value[i] = dspvol_to_ctlvol(dspvol);
 917         }
 918
 919         pm_runtime_mark_last_busy(cdev->dev);
 920         pm_runtime_put_autosuspend(cdev->dev);
 921
 922         return 0;
 923 }
 924
 925 static int catpt_stream_volume_put(struct snd_kcontrol *kcontrol,
 926                                    struct snd_ctl_elem_value *ucontrol,
 927                                    enum catpt_pin_id pin_id)
 928 {
 929         struct snd_soc_component *component =
 930                 snd_soc_kcontrol_component(kcontrol);
 931         struct catpt_dev *cdev = dev_get_drvdata(component->dev);
 932         struct catpt_stream_runtime *stream;
 933         long *ctlvol = (long *)kcontrol->private_value;
 934         int ret, i;
 935
 936         stream = catpt_stream_find(cdev, pin_id);
 937         if (!stream) {
 938                 for (i = 0; i < CATPT_CHANNELS_MAX; i++)
 939                         ctlvol[i] = ucontrol->value.integer.value[i];
 940                 return 0;
 941         }
 942
 943         pm_runtime_get_sync(cdev->dev);
 944
 945         ret = catpt_set_dspvol(cdev, stream->info.stream_hw_id,
 946                                ucontrol->value.integer.value);
 947
 948         pm_runtime_mark_last_busy(cdev->dev);
 949         pm_runtime_put_autosuspend(cdev->dev);
 950
 951         if (ret)
 952                 return ret;
 953
 954         for (i = 0; i < CATPT_CHANNELS_MAX; i++)
 955                 ctlvol[i] = ucontrol->value.integer.value[i];
 956         return 0;
 957 }
 958
 959 static int catpt_offload1_volume_get(struct snd_kcontrol *kctl,
 960                                      struct snd_ctl_elem_value *uctl)
 961 {
 962         return catpt_stream_volume_get(kctl, uctl, CATPT_PIN_ID_OFFLOAD1);
 963 }
 964
 965 static int catpt_offload1_volume_put(struct snd_kcontrol *kctl,
 966                                      struct snd_ctl_elem_value *uctl)
 967 {
 968         return catpt_stream_volume_put(kctl, uctl, CATPT_PIN_ID_OFFLOAD1);
 969 }
 970
 971 static int catpt_offload2_volume_get(struct snd_kcontrol *kctl,
 972                                      struct snd_ctl_elem_value *uctl)
 973 {
 974         return catpt_stream_volume_get(kctl, uctl, CATPT_PIN_ID_OFFLOAD2);
 975 }
 976
 977 static int catpt_offload2_volume_put(struct snd_kcontrol *kctl,
 978                                      struct snd_ctl_elem_value *uctl)
 979 {
 980         return catpt_stream_volume_put(kctl, uctl, CATPT_PIN_ID_OFFLOAD2);
 981 }
 982
 983 static int catpt_capture_volume_get(struct snd_kcontrol *kctl,
 984                                     struct snd_ctl_elem_value *uctl)
 985 {
 986         return catpt_stream_volume_get(kctl, uctl, CATPT_PIN_ID_CAPTURE1);
 987 }
 988
 989 static int catpt_capture_volume_put(struct snd_kcontrol *kctl,
 990                                     struct snd_ctl_elem_value *uctl)
 991 {
 992         return catpt_stream_volume_put(kctl, uctl, CATPT_PIN_ID_CAPTURE1);
 993 }
 994
 995 static int catpt_loopback_switch_get(struct snd_kcontrol *kcontrol,
 996                                      struct snd_ctl_elem_value *ucontrol)
 997 {
 998         ucontrol->value.integer.value[0] = *(bool *)kcontrol->private_value;
 999         return 0;
1000 }
1001
1002 static int catpt_loopback_switch_put(struct snd_kcontrol *kcontrol,
1003                                      struct snd_ctl_elem_value *ucontrol)
1004 {
1005         struct snd_soc_component *component =
1006                 snd_soc_kcontrol_component(kcontrol);
1007         struct catpt_dev *cdev = dev_get_drvdata(component->dev);
1008         struct catpt_stream_runtime *stream;
1009         bool mute;
1010         int ret;
1011
1012         mute = (bool)ucontrol->value.integer.value[0];
1013         stream = catpt_stream_find(cdev, CATPT_PIN_ID_REFERENCE);
1014         if (!stream) {
1015                 *(bool *)kcontrol->private_value = mute;
1016                 return 0;
1017         }
1018
1019         pm_runtime_get_sync(cdev->dev);
1020
1021         ret = catpt_ipc_mute_loopback(cdev, stream->info.stream_hw_id, mute);
1022
1023         pm_runtime_mark_last_busy(cdev->dev);
1024         pm_runtime_put_autosuspend(cdev->dev);
1025
1026         if (ret)
1027                 return CATPT_IPC_ERROR(ret);
1028
1029         *(bool *)kcontrol->private_value = mute;
1030         return 0;
1031 }
1032
1033 static int catpt_waves_switch_get(struct snd_kcontrol *kcontrol,
1034                                   struct snd_ctl_elem_value *ucontrol)
1035 {
1036         return 0;
1037 }
1038
1039 static int catpt_waves_switch_put(struct snd_kcontrol *kcontrol,
1040                                   struct snd_ctl_elem_value *ucontrol)
1041 {
1042         return 0;
1043 }
1044
1045 static int catpt_waves_param_get(struct snd_kcontrol *kcontrol,
1046                                  unsigned int __user *bytes,
1047                                  unsigned int size)
1048 {
1049         return 0;
1050 }
1051
1052 static int catpt_waves_param_put(struct snd_kcontrol *kcontrol,
1053                                  const unsigned int __user *bytes,
1054                                  unsigned int size)
1055 {
1056         return 0;
1057 }
1058
1059 static const SNDRV_CTL_TLVD_DECLARE_DB_SCALE(catpt_volume_tlv, -9000, 300, 1);
1060
1061 #define CATPT_VOLUME_CTL(kname, sname) \
1062 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1063         .name = (kname), \
1064         .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
1065                   SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1066         .info = catpt_volume_info, \
1067         .get = catpt_##sname##_volume_get, \
1068         .put = catpt_##sname##_volume_put, \
1069         .tlv.p = catpt_volume_tlv, \
1070         .private_value = (unsigned long) \
1071                 &(long[CATPT_CHANNELS_MAX]) {0} }
1072
1073 static const struct snd_kcontrol_new component_kcontrols[] = {
1074 /* Master volume (mixer stream) */
1075 CATPT_VOLUME_CTL("Master Playback Volume", mixer),
1076 /* Individual volume controls for offload and capture */
1077 CATPT_VOLUME_CTL("Media0 Playback Volume", offload1),
1078 CATPT_VOLUME_CTL("Media1 Playback Volume", offload2),
1079 CATPT_VOLUME_CTL("Mic Capture Volume", capture),
1080 SOC_SINGLE_BOOL_EXT("Loopback Mute", (unsigned long)&(bool[1]) {0},
1081                     catpt_loopback_switch_get, catpt_loopback_switch_put),
1082 /* Enable or disable WAVES module */
1083 SOC_SINGLE_BOOL_EXT("Waves Switch", 0,
1084                     catpt_waves_switch_get, catpt_waves_switch_put),
1085 /* WAVES module parameter control */
1086 SND_SOC_BYTES_TLV("Waves Set Param", 128,
1087                   catpt_waves_param_get, catpt_waves_param_put),
1088 };
1089
1090 static const struct snd_soc_dapm_widget component_widgets[] = {
1091         SND_SOC_DAPM_AIF_IN("SSP0 CODEC IN", NULL, 0, SND_SOC_NOPM, 0, 0),
1092         SND_SOC_DAPM_AIF_OUT("SSP0 CODEC OUT", NULL, 0, SND_SOC_NOPM, 0, 0),
1093         SND_SOC_DAPM_AIF_IN("SSP1 BT IN", NULL, 0, SND_SOC_NOPM, 0, 0),
1094         SND_SOC_DAPM_AIF_OUT("SSP1 BT OUT", NULL, 0, SND_SOC_NOPM, 0, 0),
1095
1096         SND_SOC_DAPM_MIXER("Playback VMixer", SND_SOC_NOPM, 0, 0, NULL, 0),
1097 };
1098
1099 static const struct snd_soc_dapm_route component_routes[] = {
1100         {"Playback VMixer", NULL, "System Playback"},
1101         {"Playback VMixer", NULL, "Offload0 Playback"},
1102         {"Playback VMixer", NULL, "Offload1 Playback"},
1103
1104         {"SSP0 CODEC OUT", NULL, "Playback VMixer"},
1105
1106         {"Analog Capture", NULL, "SSP0 CODEC IN"},
1107         {"Loopback Capture", NULL, "SSP0 CODEC IN"},
1108
1109         {"SSP1 BT OUT", NULL, "Bluetooth Playback"},
1110         {"Bluetooth Capture", NULL, "SSP1 BT IN"},
1111 };
1112
1113 static const struct snd_soc_component_driver catpt_comp_driver = {
1114         .name = "catpt-platform",
1115
1116         .pcm_construct = catpt_component_pcm_construct,
1117         .open = catpt_component_open,
1118         .pointer = catpt_component_pointer,
1119
1120         .controls = component_kcontrols,
1121         .num_controls = ARRAY_SIZE(component_kcontrols),
1122         .dapm_widgets = component_widgets,
1123         .num_dapm_widgets = ARRAY_SIZE(component_widgets),
1124         .dapm_routes = component_routes,
1125         .num_dapm_routes = ARRAY_SIZE(component_routes),
1126 };
1127
1128 int catpt_arm_stream_templates(struct catpt_dev *cdev)
1129 {
1130         struct resource *res;
1131         u32 scratch_size = 0;
1132         int i, j;
1133
1134         for (i = 0; i < ARRAY_SIZE(catpt_topology); i++) {
1135                 struct catpt_stream_template *template;
1136                 struct catpt_module_entry *entry;
1137                 struct catpt_module_type *type;
1138
1139                 template = catpt_topology[i];
1140                 template->persistent_size = 0;
1141
1142                 for (j = 0; j < template->num_entries; j++) {
1143                         entry = &template->entries[j];
1144                         type = &cdev->modules[entry->module_id];
1145
1146                         if (!type->loaded)
1147                                 return -ENOENT;
1148
1149                         entry->entry_point = type->entry_point;
1150                         template->persistent_size += type->persistent_size;
1151                         if (type->scratch_size > scratch_size)
1152                                 scratch_size = type->scratch_size;
1153                 }
1154         }
1155
1156         if (scratch_size) {
1157                 /* allocate single scratch area for all modules */
1158                 res = catpt_request_region(&cdev->dram, scratch_size);
1159                 if (!res)
1160                         return -EBUSY;
1161                 cdev->scratch = res;
1162         }
1163
1164         return 0;
1165 }
1166
1167 int catpt_register_plat_component(struct catpt_dev *cdev)
1168 {
1169         struct snd_soc_component *component;
1170         int ret;
1171
1172         component = devm_kzalloc(cdev->dev, sizeof(*component), GFP_KERNEL);
1173         if (!component)
1174                 return -ENOMEM;
1175
1176         ret = snd_soc_component_initialize(component, &catpt_comp_driver,
1177                                            cdev->dev);
1178         if (ret)
1179                 return ret;
1180
1181         component->name = catpt_comp_driver.name;
1182         return snd_soc_add_component(component, dai_drivers,
1183                                      ARRAY_SIZE(dai_drivers));
1184 }