sound/soc/sof/sof-audio.c

   1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)
   2 //
   3 // This file is provided under a dual BSD/GPLv2 license.  When using or
   4 // redistributing this file, you may do so under either license.
   5 //
   6 // Copyright(c) 2019 Intel Corporation
   7 //
   8 // Author: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
   9 //
  10
  11 #include <linux/bitfield.h>
  12 #include <trace/events/sof.h>
  13 #include "sof-audio.h"
  14 #include "ops.h"
  15
  16 static bool is_virtual_widget(struct snd_sof_dev *sdev, struct snd_soc_dapm_widget *widget,
  17                               const char *func)
  18 {
  19         switch (widget->id) {
  20         case snd_soc_dapm_out_drv:
  21         case snd_soc_dapm_output:
  22         case snd_soc_dapm_input:
  23                 dev_dbg(sdev->dev, "%s: %s is a virtual widget\n", func, widget->name);
  24                 return true;
  25         default:
  26                 return false;
  27         }
  28 }
  29
  30 static void sof_reset_route_setup_status(struct snd_sof_dev *sdev, struct snd_sof_widget *widget)
  31 {
  32         const struct sof_ipc_tplg_ops *tplg_ops = sof_ipc_get_ops(sdev, tplg);
  33         struct snd_sof_route *sroute;
  34
  35         list_for_each_entry(sroute, &sdev->route_list, list)
  36                 if (sroute->src_widget == widget || sroute->sink_widget == widget) {
  37                         if (sroute->setup && tplg_ops && tplg_ops->route_free)
  38                                 tplg_ops->route_free(sdev, sroute);
  39
  40                         sroute->setup = false;
  41                 }
  42 }
  43
  44 static int sof_widget_free_unlocked(struct snd_sof_dev *sdev,
  45                                     struct snd_sof_widget *swidget)
  46 {
  47         const struct sof_ipc_tplg_ops *tplg_ops = sof_ipc_get_ops(sdev, tplg);
  48         struct snd_sof_pipeline *spipe = swidget->spipe;
  49         int err = 0;
  50         int ret;
  51
  52         if (!swidget->private)
  53                 return 0;
  54
  55         trace_sof_widget_free(swidget);
  56
  57         /* only free when use_count is 0 */
  58         if (--swidget->use_count)
  59                 return 0;
  60
  61         /* reset route setup status for all routes that contain this widget */
  62         sof_reset_route_setup_status(sdev, swidget);
  63
  64         /* free DAI config and continue to free widget even if it fails */
  65         if (WIDGET_IS_DAI(swidget->id)) {
  66                 struct snd_sof_dai_config_data data;
  67                 unsigned int flags = SOF_DAI_CONFIG_FLAGS_HW_FREE;
  68
  69                 data.dai_data = DMA_CHAN_INVALID;
  70
  71                 if (tplg_ops && tplg_ops->dai_config) {
  72                         err = tplg_ops->dai_config(sdev, swidget, flags, &data);
  73                         if (err < 0)
  74                                 dev_err(sdev->dev, "failed to free config for widget %s\n",
  75                                         swidget->widget->name);
  76                 }
  77         }
  78
  79         /* continue to disable core even if IPC fails */
  80         if (tplg_ops && tplg_ops->widget_free) {
  81                 ret = tplg_ops->widget_free(sdev, swidget);
  82                 if (ret < 0 && !err)
  83                         err = ret;
  84         }
  85
  86         /*
  87          * decrement ref count for cores associated with all modules in the pipeline and clear
  88          * the complete flag
  89          */
  90         if (swidget->id == snd_soc_dapm_scheduler) {
  91                 int i;
  92
  93                 for_each_set_bit(i, &spipe->core_mask, sdev->num_cores) {
  94                         ret = snd_sof_dsp_core_put(sdev, i);
  95                         if (ret < 0) {
  96                                 dev_err(sdev->dev, "failed to disable target core: %d for pipeline %s\n",
  97                                         i, swidget->widget->name);
  98                                 if (!err)
  99                                         err = ret;
 100                         }
 101                 }
 102                 swidget->spipe->complete = 0;
 103         }
 104
 105         /*
 106          * free the scheduler widget (same as pipe_widget) associated with the current swidget.
 107          * skip for static pipelines
 108          */
 109         if (swidget->spipe && swidget->dynamic_pipeline_widget &&
 110             swidget->id != snd_soc_dapm_scheduler) {
 111                 ret = sof_widget_free_unlocked(sdev, swidget->spipe->pipe_widget);
 112                 if (ret < 0 && !err)
 113                         err = ret;
 114         }
 115
 116         if (!err)
 117                 dev_dbg(sdev->dev, "widget %s freed\n", swidget->widget->name);
 118
 119         return err;
 120 }
 121
 122 int sof_widget_free(struct snd_sof_dev *sdev, struct snd_sof_widget *swidget)
 123 {
 124         int ret;
 125
 126         mutex_lock(&swidget->setup_mutex);
 127         ret = sof_widget_free_unlocked(sdev, swidget);
 128         mutex_unlock(&swidget->setup_mutex);
 129
 130         return ret;
 131 }
 132 EXPORT_SYMBOL(sof_widget_free);
 133
 134 static int sof_widget_setup_unlocked(struct snd_sof_dev *sdev,
 135                                      struct snd_sof_widget *swidget)
 136 {
 137         const struct sof_ipc_tplg_ops *tplg_ops = sof_ipc_get_ops(sdev, tplg);
 138         struct snd_sof_pipeline *spipe = swidget->spipe;
 139         bool use_count_decremented = false;
 140         int ret;
 141         int i;
 142
 143         /* skip if there is no private data */
 144         if (!swidget->private)
 145                 return 0;
 146
 147         trace_sof_widget_setup(swidget);
 148
 149         /* widget already set up */
 150         if (++swidget->use_count > 1)
 151                 return 0;
 152
 153         /*
 154          * The scheduler widget for a pipeline is not part of the connected DAPM
 155          * widget list and it needs to be set up before the widgets in the pipeline
 156          * are set up. The use_count for the scheduler widget is incremented for every
 157          * widget in a given pipeline to ensure that it is freed only after the last
 158          * widget in the pipeline is freed. Skip setting up scheduler widget for static pipelines.
 159          */
 160         if (swidget->dynamic_pipeline_widget && swidget->id != snd_soc_dapm_scheduler) {
 161                 if (!swidget->spipe || !swidget->spipe->pipe_widget) {
 162                         dev_err(sdev->dev, "No pipeline set for %s\n", swidget->widget->name);
 163                         ret = -EINVAL;
 164                         goto use_count_dec;
 165                 }
 166
 167                 ret = sof_widget_setup_unlocked(sdev, swidget->spipe->pipe_widget);
 168                 if (ret < 0)
 169                         goto use_count_dec;
 170         }
 171
 172         /* update ref count for cores associated with all modules in the pipeline */
 173         if (swidget->id == snd_soc_dapm_scheduler) {
 174                 for_each_set_bit(i, &spipe->core_mask, sdev->num_cores) {
 175                         ret = snd_sof_dsp_core_get(sdev, i);
 176                         if (ret < 0) {
 177                                 dev_err(sdev->dev, "failed to enable target core %d for pipeline %s\n",
 178                                         i, swidget->widget->name);
 179                                 goto pipe_widget_free;
 180                         }
 181                 }
 182         }
 183
 184         /* setup widget in the DSP */
 185         if (tplg_ops && tplg_ops->widget_setup) {
 186                 ret = tplg_ops->widget_setup(sdev, swidget);
 187                 if (ret < 0)
 188                         goto pipe_widget_free;
 189         }
 190
 191         /* send config for DAI components */
 192         if (WIDGET_IS_DAI(swidget->id)) {
 193                 unsigned int flags = SOF_DAI_CONFIG_FLAGS_HW_PARAMS;
 194
 195                 /*
 196                  * The config flags saved during BE DAI hw_params will be used for IPC3. IPC4 does
 197                  * not use the flags argument.
 198                  */
 199                 if (tplg_ops && tplg_ops->dai_config) {
 200                         ret = tplg_ops->dai_config(sdev, swidget, flags, NULL);
 201                         if (ret < 0)
 202                                 goto widget_free;
 203                 }
 204         }
 205
 206         /* restore kcontrols for widget */
 207         if (tplg_ops && tplg_ops->control && tplg_ops->control->widget_kcontrol_setup) {
 208                 ret = tplg_ops->control->widget_kcontrol_setup(sdev, swidget);
 209                 if (ret < 0)
 210                         goto widget_free;
 211         }
 212
 213         dev_dbg(sdev->dev, "widget %s setup complete\n", swidget->widget->name);
 214
 215         return 0;
 216
 217 widget_free:
 218         /* widget use_count will be decremented by sof_widget_free() */
 219         sof_widget_free_unlocked(sdev, swidget);
 220         use_count_decremented = true;
 221 pipe_widget_free:
 222         if (swidget->id != snd_soc_dapm_scheduler) {
 223                 sof_widget_free_unlocked(sdev, swidget->spipe->pipe_widget);
 224         } else {
 225                 int j;
 226
 227                 /* decrement ref count for all cores that were updated previously */
 228                 for_each_set_bit(j, &spipe->core_mask, sdev->num_cores) {
 229                         if (j >= i)
 230                                 break;
 231                         snd_sof_dsp_core_put(sdev, j);
 232                 }
 233         }
 234 use_count_dec:
 235         if (!use_count_decremented)
 236                 swidget->use_count--;
 237
 238         return ret;
 239 }
 240
 241 int sof_widget_setup(struct snd_sof_dev *sdev, struct snd_sof_widget *swidget)
 242 {
 243         int ret;
 244
 245         mutex_lock(&swidget->setup_mutex);
 246         ret = sof_widget_setup_unlocked(sdev, swidget);
 247         mutex_unlock(&swidget->setup_mutex);
 248
 249         return ret;
 250 }
 251 EXPORT_SYMBOL(sof_widget_setup);
 252
 253 int sof_route_setup(struct snd_sof_dev *sdev, struct snd_soc_dapm_widget *wsource,
 254                     struct snd_soc_dapm_widget *wsink)
 255 {
 256         const struct sof_ipc_tplg_ops *tplg_ops = sof_ipc_get_ops(sdev, tplg);
 257         struct snd_sof_widget *src_widget = wsource->dobj.private;
 258         struct snd_sof_widget *sink_widget = wsink->dobj.private;
 259         struct snd_sof_route *sroute;
 260         bool route_found = false;
 261
 262         /* ignore routes involving virtual widgets in topology */
 263         if (is_virtual_widget(sdev, src_widget->widget, __func__) ||
 264             is_virtual_widget(sdev, sink_widget->widget, __func__))
 265                 return 0;
 266
 267         /* find route matching source and sink widgets */
 268         list_for_each_entry(sroute, &sdev->route_list, list)
 269                 if (sroute->src_widget == src_widget && sroute->sink_widget == sink_widget) {
 270                         route_found = true;
 271                         break;
 272                 }
 273
 274         if (!route_found) {
 275                 dev_err(sdev->dev, "error: cannot find SOF route for source %s -> %s sink\n",
 276                         wsource->name, wsink->name);
 277                 return -EINVAL;
 278         }
 279
 280         /* nothing to do if route is already set up */
 281         if (sroute->setup)
 282                 return 0;
 283
 284         if (tplg_ops && tplg_ops->route_setup) {
 285                 int ret = tplg_ops->route_setup(sdev, sroute);
 286
 287                 if (ret < 0)
 288                         return ret;
 289         }
 290
 291         sroute->setup = true;
 292         return 0;
 293 }
 294
 295 static int sof_setup_pipeline_connections(struct snd_sof_dev *sdev,
 296                                           struct snd_soc_dapm_widget_list *list, int dir)
 297 {
 298         const struct sof_ipc_tplg_ops *tplg_ops = sof_ipc_get_ops(sdev, tplg);
 299         struct snd_soc_dapm_widget *widget;
 300         struct snd_sof_route *sroute;
 301         struct snd_soc_dapm_path *p;
 302         int ret = 0;
 303         int i;
 304
 305         /*
 306          * Set up connections between widgets in the sink/source paths based on direction.
 307          * Some non-SOF widgets exist in topology either for compatibility or for the
 308          * purpose of connecting a pipeline from a host to a DAI in order to receive the DAPM
 309          * events. But they are not handled by the firmware. So ignore them.
 310          */
 311         if (dir == SNDRV_PCM_STREAM_PLAYBACK) {
 312                 for_each_dapm_widgets(list, i, widget) {
 313                         if (!widget->dobj.private)
 314                                 continue;
 315
 316                         snd_soc_dapm_widget_for_each_sink_path(widget, p) {
 317                                 if (!widget_in_list(list, p->sink))
 318                                         continue;
 319
 320                                 if (p->sink->dobj.private) {
 321                                         ret = sof_route_setup(sdev, widget, p->sink);
 322                                         if (ret < 0)
 323                                                 return ret;
 324                                 }
 325                         }
 326                 }
 327         } else {
 328                 for_each_dapm_widgets(list, i, widget) {
 329                         if (!widget->dobj.private)
 330                                 continue;
 331
 332                         snd_soc_dapm_widget_for_each_source_path(widget, p) {
 333                                 if (!widget_in_list(list, p->source))
 334                                         continue;
 335
 336                                 if (p->source->dobj.private) {
 337                                         ret = sof_route_setup(sdev, p->source, widget);
 338                                         if (ret < 0)
 339                                                 return ret;
 340                                 }
 341                         }
 342                 }
 343         }
 344
 345         /*
 346          * The above loop handles connections between widgets that belong to the DAPM widget list.
 347          * This is not sufficient to handle loopback cases between pipelines configured with
 348          * different directions, e.g. a sidetone or an amplifier feedback connected to a speaker
 349          * protection module.
 350          */
 351         list_for_each_entry(sroute, &sdev->route_list, list) {
 352                 bool src_widget_in_dapm_list, sink_widget_in_dapm_list;
 353                 struct snd_sof_widget *swidget;
 354
 355                 if (sroute->setup)
 356                         continue;
 357
 358                 src_widget_in_dapm_list = widget_in_list(list, sroute->src_widget->widget);
 359                 sink_widget_in_dapm_list = widget_in_list(list, sroute->sink_widget->widget);
 360
 361                 /*
 362                  * if both source and sink are in the DAPM list, the route must already have been
 363                  * set up above. And if neither are in the DAPM list, the route shouldn't be
 364                  * handled now.
 365                  */
 366                 if (src_widget_in_dapm_list == sink_widget_in_dapm_list)
 367                         continue;
 368
 369                 /*
 370                  * At this point either the source widget or the sink widget is in the DAPM list
 371                  * with a route that might need to be set up. Check the use_count of the widget
 372                  * that is not in the DAPM list to confirm if it is in use currently before setting
 373                  * up the route.
 374                  */
 375                 if (src_widget_in_dapm_list)
 376                         swidget = sroute->sink_widget;
 377                 else
 378                         swidget = sroute->src_widget;
 379
 380                 mutex_lock(&swidget->setup_mutex);
 381                 if (!swidget->use_count) {
 382                         mutex_unlock(&swidget->setup_mutex);
 383                         continue;
 384                 }
 385
 386                 if (tplg_ops && tplg_ops->route_setup) {
 387                         /*
 388                          * this route will get freed when either the source widget or the sink
 389                          * widget is freed during hw_free
 390                          */
 391                         ret = tplg_ops->route_setup(sdev, sroute);
 392                         if (!ret)
 393                                 sroute->setup = true;
 394                 }
 395
 396                 mutex_unlock(&swidget->setup_mutex);
 397
 398                 if (ret < 0)
 399                         return ret;
 400         }
 401
 402         return 0;
 403 }
 404
 405 static void
 406 sof_unprepare_widgets_in_path(struct snd_sof_dev *sdev, struct snd_soc_dapm_widget *widget,
 407                               struct snd_soc_dapm_widget_list *list)
 408 {
 409         const struct sof_ipc_tplg_ops *tplg_ops = sof_ipc_get_ops(sdev, tplg);
 410         struct snd_sof_widget *swidget = widget->dobj.private;
 411         const struct sof_ipc_tplg_widget_ops *widget_ops;
 412         struct snd_soc_dapm_path *p;
 413
 414         if (is_virtual_widget(sdev, widget, __func__))
 415                 return;
 416
 417         /* skip if the widget is in use or if it is already unprepared */
 418         if (!swidget || !swidget->prepared || swidget->use_count > 0)
 419                 goto sink_unprepare;
 420
 421         widget_ops = tplg_ops ? tplg_ops->widget : NULL;
 422         if (widget_ops && widget_ops[widget->id].ipc_unprepare)
 423                 /* unprepare the source widget */
 424                 widget_ops[widget->id].ipc_unprepare(swidget);
 425
 426         swidget->prepared = false;
 427
 428 sink_unprepare:
 429         /* unprepare all widgets in the sink paths */
 430         snd_soc_dapm_widget_for_each_sink_path(widget, p) {
 431                 if (!widget_in_list(list, p->sink))
 432                         continue;
 433                 if (!p->walking && p->sink->dobj.private) {
 434                         p->walking = true;
 435                         sof_unprepare_widgets_in_path(sdev, p->sink, list);
 436                         p->walking = false;
 437                 }
 438         }
 439 }
 440
 441 static int
 442 sof_prepare_widgets_in_path(struct snd_sof_dev *sdev, struct snd_soc_dapm_widget *widget,
 443                             struct snd_pcm_hw_params *fe_params,
 444                             struct snd_sof_platform_stream_params *platform_params,
 445                             struct snd_pcm_hw_params *pipeline_params, int dir,
 446                             struct snd_soc_dapm_widget_list *list)
 447 {
 448         const struct sof_ipc_tplg_ops *tplg_ops = sof_ipc_get_ops(sdev, tplg);
 449         struct snd_sof_widget *swidget = widget->dobj.private;
 450         const struct sof_ipc_tplg_widget_ops *widget_ops;
 451         struct snd_soc_dapm_path *p;
 452         int ret;
 453
 454         if (is_virtual_widget(sdev, widget, __func__))
 455                 return 0;
 456
 457         widget_ops = tplg_ops ? tplg_ops->widget : NULL;
 458         if (!widget_ops)
 459                 return 0;
 460
 461         if (!swidget || !widget_ops[widget->id].ipc_prepare || swidget->prepared)
 462                 goto sink_prepare;
 463
 464         /* prepare the source widget */
 465         ret = widget_ops[widget->id].ipc_prepare(swidget, fe_params, platform_params,
 466                                              pipeline_params, dir);
 467         if (ret < 0) {
 468                 dev_err(sdev->dev, "failed to prepare widget %s\n", widget->name);
 469                 return ret;
 470         }
 471
 472         swidget->prepared = true;
 473
 474 sink_prepare:
 475         /* prepare all widgets in the sink paths */
 476         snd_soc_dapm_widget_for_each_sink_path(widget, p) {
 477                 if (!widget_in_list(list, p->sink))
 478                         continue;
 479                 if (!p->walking && p->sink->dobj.private) {
 480                         p->walking = true;
 481                         ret = sof_prepare_widgets_in_path(sdev, p->sink,  fe_params,
 482                                                           platform_params, pipeline_params, dir,
 483                                                           list);
 484                         p->walking = false;
 485                         if (ret < 0) {
 486                                 /* unprepare the source widget */
 487                                 if (widget_ops[widget->id].ipc_unprepare &&
 488                                     swidget && swidget->prepared) {
 489                                         widget_ops[widget->id].ipc_unprepare(swidget);
 490                                         swidget->prepared = false;
 491                                 }
 492                                 return ret;
 493                         }
 494                 }
 495         }
 496
 497         return 0;
 498 }
 499
 500 /*
 501  * free all widgets in the sink path starting from the source widget
 502  * (DAI type for capture, AIF type for playback)
 503  */
 504 static int sof_free_widgets_in_path(struct snd_sof_dev *sdev, struct snd_soc_dapm_widget *widget,
 505                                     int dir, struct snd_sof_pcm *spcm)
 506 {
 507         struct snd_soc_dapm_widget_list *list = spcm->stream[dir].list;
 508         struct snd_soc_dapm_path *p;
 509         int err;
 510         int ret = 0;
 511
 512         if (is_virtual_widget(sdev, widget, __func__))
 513                 return 0;
 514
 515         if (widget->dobj.private) {
 516                 err = sof_widget_free(sdev, widget->dobj.private);
 517                 if (err < 0)
 518                         ret = err;
 519         }
 520
 521         /* free all widgets in the sink paths even in case of error to keep use counts balanced */
 522         snd_soc_dapm_widget_for_each_sink_path(widget, p) {
 523                 if (!p->walking) {
 524                         if (!widget_in_list(list, p->sink))
 525                                 continue;
 526
 527                         p->walking = true;
 528
 529                         err = sof_free_widgets_in_path(sdev, p->sink, dir, spcm);
 530                         if (err < 0)
 531                                 ret = err;
 532                         p->walking = false;
 533                 }
 534         }
 535
 536         return ret;
 537 }
 538
 539 /*
 540  * set up all widgets in the sink path starting from the source widget
 541  * (DAI type for capture, AIF type for playback).
 542  * The error path in this function ensures that all successfully set up widgets getting freed.
 543  */
 544 static int sof_set_up_widgets_in_path(struct snd_sof_dev *sdev, struct snd_soc_dapm_widget *widget,
 545                                       int dir, struct snd_sof_pcm *spcm)
 546 {
 547         struct snd_sof_pcm_stream_pipeline_list *pipeline_list = &spcm->stream[dir].pipeline_list;
 548         struct snd_soc_dapm_widget_list *list = spcm->stream[dir].list;
 549         struct snd_sof_widget *swidget = widget->dobj.private;
 550         struct snd_sof_pipeline *spipe;
 551         struct snd_soc_dapm_path *p;
 552         int ret;
 553
 554         if (is_virtual_widget(sdev, widget, __func__))
 555                 return 0;
 556
 557         if (swidget) {
 558                 int i;
 559
 560                 ret = sof_widget_setup(sdev, widget->dobj.private);
 561                 if (ret < 0)
 562                         return ret;
 563
 564                 /* skip populating the pipe_widgets array if it is NULL */
 565                 if (!pipeline_list->pipelines)
 566                         goto sink_setup;
 567
 568                 /*
 569                  * Add the widget's pipe_widget to the list of pipelines to be triggered if not
 570                  * already in the list. This will result in the pipelines getting added in the
 571                  * order source to sink.
 572                  */
 573                 for (i = 0; i < pipeline_list->count; i++) {
 574                         spipe = pipeline_list->pipelines[i];
 575                         if (spipe == swidget->spipe)
 576                                 break;
 577                 }
 578
 579                 if (i == pipeline_list->count) {
 580                         pipeline_list->count++;
 581                         pipeline_list->pipelines[i] = swidget->spipe;
 582                 }
 583         }
 584
 585 sink_setup:
 586         snd_soc_dapm_widget_for_each_sink_path(widget, p) {
 587                 if (!p->walking) {
 588                         if (!widget_in_list(list, p->sink))
 589                                 continue;
 590
 591                         p->walking = true;
 592
 593                         ret = sof_set_up_widgets_in_path(sdev, p->sink, dir, spcm);
 594                         p->walking = false;
 595                         if (ret < 0) {
 596                                 if (swidget)
 597                                         sof_widget_free(sdev, swidget);
 598                                 return ret;
 599                         }
 600                 }
 601         }
 602
 603         return 0;
 604 }
 605
 606 static int
 607 sof_walk_widgets_in_order(struct snd_sof_dev *sdev, struct snd_sof_pcm *spcm,
 608                           struct snd_pcm_hw_params *fe_params,
 609                           struct snd_sof_platform_stream_params *platform_params, int dir,
 610                           enum sof_widget_op op)
 611 {
 612         struct snd_soc_dapm_widget_list *list = spcm->stream[dir].list;
 613         struct snd_soc_dapm_widget *widget;
 614         char *str;
 615         int ret = 0;
 616         int i;
 617
 618         if (!list)
 619                 return 0;
 620
 621         for_each_dapm_widgets(list, i, widget) {
 622                 if (is_virtual_widget(sdev, widget, __func__))
 623                         continue;
 624
 625                 /* starting widget for playback is AIF type */
 626                 if (dir == SNDRV_PCM_STREAM_PLAYBACK && widget->id != snd_soc_dapm_aif_in)
 627                         continue;
 628
 629                 /* starting widget for capture is DAI type */
 630                 if (dir == SNDRV_PCM_STREAM_CAPTURE && widget->id != snd_soc_dapm_dai_out)
 631                         continue;
 632
 633                 switch (op) {
 634                 case SOF_WIDGET_SETUP:
 635                         ret = sof_set_up_widgets_in_path(sdev, widget, dir, spcm);
 636                         str = "set up";
 637                         break;
 638                 case SOF_WIDGET_FREE:
 639                         ret = sof_free_widgets_in_path(sdev, widget, dir, spcm);
 640                         str = "free";
 641                         break;
 642                 case SOF_WIDGET_PREPARE:
 643                 {
 644                         struct snd_pcm_hw_params pipeline_params;
 645
 646                         str = "prepare";
 647                         /*
 648                          * When walking the list of connected widgets, the pipeline_params for each
 649                          * widget is modified by the source widget in the path. Use a local
 650                          * copy of the runtime params as the pipeline_params so that the runtime
 651                          * params does not get overwritten.
 652                          */
 653                         memcpy(&pipeline_params, fe_params, sizeof(*fe_params));
 654
 655                         ret = sof_prepare_widgets_in_path(sdev, widget, fe_params, platform_params,
 656                                                           &pipeline_params, dir, list);
 657                         break;
 658                 }
 659                 case SOF_WIDGET_UNPREPARE:
 660                         sof_unprepare_widgets_in_path(sdev, widget, list);
 661                         break;
 662                 default:
 663                         dev_err(sdev->dev, "Invalid widget op %d\n", op);
 664                         return -EINVAL;
 665                 }
 666                 if (ret < 0) {
 667                         dev_err(sdev->dev, "Failed to %s connected widgets\n", str);
 668                         return ret;
 669                 }
 670         }
 671
 672         return 0;
 673 }
 674
 675 int sof_widget_list_setup(struct snd_sof_dev *sdev, struct snd_sof_pcm *spcm,
 676                           struct snd_pcm_hw_params *fe_params,
 677                           struct snd_sof_platform_stream_params *platform_params,
 678                           int dir)
 679 {
 680         const struct sof_ipc_tplg_ops *tplg_ops = sof_ipc_get_ops(sdev, tplg);
 681         struct snd_soc_dapm_widget_list *list = spcm->stream[dir].list;
 682         struct snd_soc_dapm_widget *widget;
 683         int i, ret;
 684
 685         /* nothing to set up */
 686         if (!list)
 687                 return 0;
 688
 689         /*
 690          * Prepare widgets for set up. The prepare step is used to allocate memory, assign
 691          * instance ID and pick the widget configuration based on the runtime PCM params.
 692          */
 693         ret = sof_walk_widgets_in_order(sdev, spcm, fe_params, platform_params,
 694                                         dir, SOF_WIDGET_PREPARE);
 695         if (ret < 0)
 696                 return ret;
 697
 698         /* Set up is used to send the IPC to the DSP to create the widget */
 699         ret = sof_walk_widgets_in_order(sdev, spcm, fe_params, platform_params,
 700                                         dir, SOF_WIDGET_SETUP);
 701         if (ret < 0) {
 702                 sof_walk_widgets_in_order(sdev, spcm, fe_params, platform_params,
 703                                           dir, SOF_WIDGET_UNPREPARE);
 704                 return ret;
 705         }
 706
 707         /*
 708          * error in setting pipeline connections will result in route status being reset for
 709          * routes that were successfully set up when the widgets are freed.
 710          */
 711         ret = sof_setup_pipeline_connections(sdev, list, dir);
 712         if (ret < 0)
 713                 goto widget_free;
 714
 715         /* complete pipelines */
 716         for_each_dapm_widgets(list, i, widget) {
 717                 struct snd_sof_widget *swidget = widget->dobj.private;
 718                 struct snd_sof_widget *pipe_widget;
 719                 struct snd_sof_pipeline *spipe;
 720
 721                 if (!swidget || sdev->dspless_mode_selected)
 722                         continue;
 723
 724                 spipe = swidget->spipe;
 725                 if (!spipe) {
 726                         dev_err(sdev->dev, "no pipeline found for %s\n",
 727                                 swidget->widget->name);
 728                         ret = -EINVAL;
 729                         goto widget_free;
 730                 }
 731
 732                 pipe_widget = spipe->pipe_widget;
 733                 if (!pipe_widget) {
 734                         dev_err(sdev->dev, "error: no pipeline widget found for %s\n",
 735                                 swidget->widget->name);
 736                         ret = -EINVAL;
 737                         goto widget_free;
 738                 }
 739
 740                 if (spipe->complete)
 741                         continue;
 742
 743                 if (tplg_ops && tplg_ops->pipeline_complete) {
 744                         spipe->complete = tplg_ops->pipeline_complete(sdev, pipe_widget);
 745                         if (spipe->complete < 0) {
 746                                 ret = spipe->complete;
 747                                 goto widget_free;
 748                         }
 749                 }
 750         }
 751
 752         return 0;
 753
 754 widget_free:
 755         sof_walk_widgets_in_order(sdev, spcm, fe_params, platform_params, dir,
 756                                   SOF_WIDGET_FREE);
 757         sof_walk_widgets_in_order(sdev, spcm, NULL, NULL, dir, SOF_WIDGET_UNPREPARE);
 758
 759         return ret;
 760 }
 761
 762 int sof_widget_list_free(struct snd_sof_dev *sdev, struct snd_sof_pcm *spcm, int dir)
 763 {
 764         struct snd_sof_pcm_stream_pipeline_list *pipeline_list = &spcm->stream[dir].pipeline_list;
 765         struct snd_soc_dapm_widget_list *list = spcm->stream[dir].list;
 766         int ret;
 767
 768         /* nothing to free */
 769         if (!list)
 770                 return 0;
 771
 772         /* send IPC to free widget in the DSP */
 773         ret = sof_walk_widgets_in_order(sdev, spcm, NULL, NULL, dir, SOF_WIDGET_FREE);
 774
 775         /* unprepare the widget */
 776         sof_walk_widgets_in_order(sdev, spcm, NULL, NULL, dir, SOF_WIDGET_UNPREPARE);
 777
 778         snd_soc_dapm_dai_free_widgets(&list);
 779         spcm->stream[dir].list = NULL;
 780
 781         pipeline_list->count = 0;
 782
 783         return ret;
 784 }
 785
 786 /*
 787  * helper to determine if there are only D0i3 compatible
 788  * streams active
 789  */
 790 bool snd_sof_dsp_only_d0i3_compatible_stream_active(struct snd_sof_dev *sdev)
 791 {
 792         struct snd_pcm_substream *substream;
 793         struct snd_sof_pcm *spcm;
 794         bool d0i3_compatible_active = false;
 795         int dir;
 796
 797         list_for_each_entry(spcm, &sdev->pcm_list, list) {
 798                 for_each_pcm_streams(dir) {
 799                         substream = spcm->stream[dir].substream;
 800                         if (!substream || !substream->runtime)
 801                                 continue;
 802
 803                         /*
 804                          * substream->runtime being not NULL indicates
 805                          * that the stream is open. No need to check the
 806                          * stream state.
 807                          */
 808                         if (!spcm->stream[dir].d0i3_compatible)
 809                                 return false;
 810
 811                         d0i3_compatible_active = true;
 812                 }
 813         }
 814
 815         return d0i3_compatible_active;
 816 }
 817 EXPORT_SYMBOL(snd_sof_dsp_only_d0i3_compatible_stream_active);
 818
 819 bool snd_sof_stream_suspend_ignored(struct snd_sof_dev *sdev)
 820 {
 821         struct snd_sof_pcm *spcm;
 822
 823         list_for_each_entry(spcm, &sdev->pcm_list, list) {
 824                 if (spcm->stream[SNDRV_PCM_STREAM_PLAYBACK].suspend_ignored ||
 825                     spcm->stream[SNDRV_PCM_STREAM_CAPTURE].suspend_ignored)
 826                         return true;
 827         }
 828
 829         return false;
 830 }
 831
 832 int sof_pcm_stream_free(struct snd_sof_dev *sdev, struct snd_pcm_substream *substream,
 833                         struct snd_sof_pcm *spcm, int dir, bool free_widget_list)
 834 {
 835         const struct sof_ipc_pcm_ops *pcm_ops = sof_ipc_get_ops(sdev, pcm);
 836         int ret;
 837         int err = 0;
 838
 839         if (spcm->prepared[substream->stream]) {
 840                 /* stop DMA first if needed */
 841                 if (pcm_ops && pcm_ops->platform_stop_during_hw_free)
 842                         snd_sof_pcm_platform_trigger(sdev, substream, SNDRV_PCM_TRIGGER_STOP);
 843
 844                 /* free PCM in the DSP */
 845                 if (pcm_ops && pcm_ops->hw_free) {
 846                         ret = pcm_ops->hw_free(sdev->component, substream);
 847                         if (ret < 0) {
 848                                 dev_err(sdev->dev, "%s: pcm_ops hw_free failed %d\n",
 849                                         __func__, ret);
 850                                 err = ret;
 851                         }
 852                 }
 853
 854                 spcm->prepared[substream->stream] = false;
 855                 spcm->pending_stop[substream->stream] = false;
 856         }
 857
 858         /* reset the DMA */
 859         ret = snd_sof_pcm_platform_hw_free(sdev, substream);
 860         if (ret < 0) {
 861                 dev_err(sdev->dev, "%s: platform hw free failed %d\n",
 862                         __func__, ret);
 863                 if (!err)
 864                         err = ret;
 865         }
 866
 867         /* free widget list */
 868         if (free_widget_list) {
 869                 ret = sof_widget_list_free(sdev, spcm, dir);
 870                 if (ret < 0) {
 871                         dev_err(sdev->dev, "%s: sof_widget_list_free failed %d\n",
 872                                 __func__, ret);
 873                         if (!err)
 874                                 err = ret;
 875                 }
 876         }
 877
 878         return err;
 879 }
 880
 881 /*
 882  * Generic object lookup APIs.
 883  */
 884
 885 struct snd_sof_pcm *snd_sof_find_spcm_name(struct snd_soc_component *scomp,
 886                                            const char *name)
 887 {
 888         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
 889         struct snd_sof_pcm *spcm;
 890
 891         list_for_each_entry(spcm, &sdev->pcm_list, list) {
 892                 /* match with PCM dai name */
 893                 if (strcmp(spcm->pcm.dai_name, name) == 0)
 894                         return spcm;
 895
 896                 /* match with playback caps name if set */
 897                 if (*spcm->pcm.caps[0].name &&
 898                     !strcmp(spcm->pcm.caps[0].name, name))
 899                         return spcm;
 900
 901                 /* match with capture caps name if set */
 902                 if (*spcm->pcm.caps[1].name &&
 903                     !strcmp(spcm->pcm.caps[1].name, name))
 904                         return spcm;
 905         }
 906
 907         return NULL;
 908 }
 909
 910 struct snd_sof_pcm *snd_sof_find_spcm_comp(struct snd_soc_component *scomp,
 911                                            unsigned int comp_id,
 912                                            int *direction)
 913 {
 914         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
 915         struct snd_sof_pcm *spcm;
 916         int dir;
 917
 918         list_for_each_entry(spcm, &sdev->pcm_list, list) {
 919                 for_each_pcm_streams(dir) {
 920                         if (spcm->stream[dir].comp_id == comp_id) {
 921                                 *direction = dir;
 922                                 return spcm;
 923                         }
 924                 }
 925         }
 926
 927         return NULL;
 928 }
 929
 930 struct snd_sof_widget *snd_sof_find_swidget(struct snd_soc_component *scomp,
 931                                             const char *name)
 932 {
 933         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
 934         struct snd_sof_widget *swidget;
 935
 936         list_for_each_entry(swidget, &sdev->widget_list, list) {
 937                 if (strcmp(name, swidget->widget->name) == 0)
 938                         return swidget;
 939         }
 940
 941         return NULL;
 942 }
 943
 944 /* find widget by stream name and direction */
 945 struct snd_sof_widget *
 946 snd_sof_find_swidget_sname(struct snd_soc_component *scomp,
 947                            const char *pcm_name, int dir)
 948 {
 949         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
 950         struct snd_sof_widget *swidget;
 951         enum snd_soc_dapm_type type;
 952
 953         if (dir == SNDRV_PCM_STREAM_PLAYBACK)
 954                 type = snd_soc_dapm_aif_in;
 955         else
 956                 type = snd_soc_dapm_aif_out;
 957
 958         list_for_each_entry(swidget, &sdev->widget_list, list) {
 959                 if (!strcmp(pcm_name, swidget->widget->sname) &&
 960                     swidget->id == type)
 961                         return swidget;
 962         }
 963
 964         return NULL;
 965 }
 966
 967 struct snd_sof_dai *snd_sof_find_dai(struct snd_soc_component *scomp,
 968                                      const char *name)
 969 {
 970         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
 971         struct snd_sof_dai *dai;
 972
 973         list_for_each_entry(dai, &sdev->dai_list, list) {
 974                 if (dai->name && (strcmp(name, dai->name) == 0))
 975                         return dai;
 976         }
 977
 978         return NULL;
 979 }
 980
 981 static int sof_dai_get_clk(struct snd_soc_pcm_runtime *rtd, int clk_type)
 982 {
 983         struct snd_soc_component *component =
 984                 snd_soc_rtdcom_lookup(rtd, SOF_AUDIO_PCM_DRV_NAME);
 985         struct snd_sof_dai *dai =
 986                 snd_sof_find_dai(component, (char *)rtd->dai_link->name);
 987         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(component);
 988         const struct sof_ipc_tplg_ops *tplg_ops = sof_ipc_get_ops(sdev, tplg);
 989
 990         /* use the tplg configured mclk if existed */
 991         if (!dai)
 992                 return 0;
 993
 994         if (tplg_ops && tplg_ops->dai_get_clk)
 995                 return tplg_ops->dai_get_clk(sdev, dai, clk_type);
 996
 997         return 0;
 998 }
 999
1000 /*
1001  * Helper to get SSP MCLK from a pcm_runtime.
1002  * Return 0 if not exist.
1003  */
1004 int sof_dai_get_mclk(struct snd_soc_pcm_runtime *rtd)
1005 {
1006         return sof_dai_get_clk(rtd, SOF_DAI_CLK_INTEL_SSP_MCLK);
1007 }
1008 EXPORT_SYMBOL(sof_dai_get_mclk);
1009
1010 /*
1011  * Helper to get SSP BCLK from a pcm_runtime.
1012  * Return 0 if not exist.
1013  */
1014 int sof_dai_get_bclk(struct snd_soc_pcm_runtime *rtd)
1015 {
1016         return sof_dai_get_clk(rtd, SOF_DAI_CLK_INTEL_SSP_BCLK);
1017 }
1018 EXPORT_SYMBOL(sof_dai_get_bclk);