sound/soc/sof/pm.c

   1 // SPDX-License-Identifier: (GPL-2.0 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) 2018 Intel Corporation. All rights reserved.
   7 //
   8 // Author: Liam Girdwood <liam.r.girdwood@linux.intel.com>
   9 //
  10
  11 #include "ops.h"
  12 #include "sof-priv.h"
  13
  14 static int sof_restore_kcontrols(struct snd_sof_dev *sdev)
  15 {
  16         struct snd_sof_control *scontrol;
  17         int ipc_cmd, ctrl_type;
  18         int ret = 0;
  19
  20         /* restore kcontrol values */
  21         list_for_each_entry(scontrol, &sdev->kcontrol_list, list) {
  22                 /* reset readback offset for scontrol after resuming */
  23                 scontrol->readback_offset = 0;
  24
  25                 /* notify DSP of kcontrol values */
  26                 switch (scontrol->cmd) {
  27                 case SOF_CTRL_CMD_VOLUME:
  28                 case SOF_CTRL_CMD_ENUM:
  29                 case SOF_CTRL_CMD_SWITCH:
  30                         ipc_cmd = SOF_IPC_COMP_SET_VALUE;
  31                         ctrl_type = SOF_CTRL_TYPE_VALUE_CHAN_SET;
  32                         ret = snd_sof_ipc_set_get_comp_data(sdev->ipc, scontrol,
  33                                                             ipc_cmd, ctrl_type,
  34                                                             scontrol->cmd,
  35                                                             true);
  36                         break;
  37                 case SOF_CTRL_CMD_BINARY:
  38                         ipc_cmd = SOF_IPC_COMP_SET_DATA;
  39                         ctrl_type = SOF_CTRL_TYPE_DATA_SET;
  40                         ret = snd_sof_ipc_set_get_comp_data(sdev->ipc, scontrol,
  41                                                             ipc_cmd, ctrl_type,
  42                                                             scontrol->cmd,
  43                                                             true);
  44                         break;
  45
  46                 default:
  47                         break;
  48                 }
  49
  50                 if (ret < 0) {
  51                         dev_err(sdev->dev,
  52                                 "error: failed kcontrol value set for widget: %d\n",
  53                                 scontrol->comp_id);
  54
  55                         return ret;
  56                 }
  57         }
  58
  59         return 0;
  60 }
  61
  62 static int sof_restore_pipelines(struct snd_sof_dev *sdev)
  63 {
  64         struct snd_sof_widget *swidget;
  65         struct snd_sof_route *sroute;
  66         struct sof_ipc_pipe_new *pipeline;
  67         struct snd_sof_dai *dai;
  68         struct sof_ipc_comp_dai *comp_dai;
  69         struct sof_ipc_cmd_hdr *hdr;
  70         int ret;
  71
  72         /* restore pipeline components */
  73         list_for_each_entry_reverse(swidget, &sdev->widget_list, list) {
  74                 struct sof_ipc_comp_reply r;
  75
  76                 /* skip if there is no private data */
  77                 if (!swidget->private)
  78                         continue;
  79
  80                 switch (swidget->id) {
  81                 case snd_soc_dapm_dai_in:
  82                 case snd_soc_dapm_dai_out:
  83                         dai = swidget->private;
  84                         comp_dai = &dai->comp_dai;
  85                         ret = sof_ipc_tx_message(sdev->ipc,
  86                                                  comp_dai->comp.hdr.cmd,
  87                                                  comp_dai, sizeof(*comp_dai),
  88                                                  &r, sizeof(r));
  89                         break;
  90                 case snd_soc_dapm_scheduler:
  91
  92                         /*
  93                          * During suspend, all DSP cores are powered off.
  94                          * Therefore upon resume, create the pipeline comp
  95                          * and power up the core that the pipeline is
  96                          * scheduled on.
  97                          */
  98                         pipeline = swidget->private;
  99                         ret = sof_load_pipeline_ipc(sdev, pipeline, &r);
 100                         break;
 101                 default:
 102                         hdr = swidget->private;
 103                         ret = sof_ipc_tx_message(sdev->ipc, hdr->cmd,
 104                                                  swidget->private, hdr->size,
 105                                                  &r, sizeof(r));
 106                         break;
 107                 }
 108                 if (ret < 0) {
 109                         dev_err(sdev->dev,
 110                                 "error: failed to load widget type %d with ID: %d\n",
 111                                 swidget->widget->id, swidget->comp_id);
 112
 113                         return ret;
 114                 }
 115         }
 116
 117         /* restore pipeline connections */
 118         list_for_each_entry_reverse(sroute, &sdev->route_list, list) {
 119                 struct sof_ipc_pipe_comp_connect *connect;
 120                 struct sof_ipc_reply reply;
 121
 122                 /* skip if there's no private data */
 123                 if (!sroute->private)
 124                         continue;
 125
 126                 connect = sroute->private;
 127
 128                 /* send ipc */
 129                 ret = sof_ipc_tx_message(sdev->ipc,
 130                                          connect->hdr.cmd,
 131                                          connect, sizeof(*connect),
 132                                          &reply, sizeof(reply));
 133                 if (ret < 0) {
 134                         dev_err(sdev->dev,
 135                                 "error: failed to load route sink %s control %s source %s\n",
 136                                 sroute->route->sink,
 137                                 sroute->route->control ? sroute->route->control
 138                                         : "none",
 139                                 sroute->route->source);
 140
 141                         return ret;
 142                 }
 143         }
 144
 145         /* restore dai links */
 146         list_for_each_entry_reverse(dai, &sdev->dai_list, list) {
 147                 struct sof_ipc_reply reply;
 148                 struct sof_ipc_dai_config *config = dai->dai_config;
 149
 150                 if (!config) {
 151                         dev_err(sdev->dev, "error: no config for DAI %s\n",
 152                                 dai->name);
 153                         continue;
 154                 }
 155
 156                 /*
 157                  * The link DMA channel would be invalidated for running
 158                  * streams but not for streams that were in the PAUSED
 159                  * state during suspend. So invalidate it here before setting
 160                  * the dai config in the DSP.
 161                  */
 162                 if (config->type == SOF_DAI_INTEL_HDA)
 163                         config->hda.link_dma_ch = DMA_CHAN_INVALID;
 164
 165                 ret = sof_ipc_tx_message(sdev->ipc,
 166                                          config->hdr.cmd, config,
 167                                          config->hdr.size,
 168                                          &reply, sizeof(reply));
 169
 170                 if (ret < 0) {
 171                         dev_err(sdev->dev,
 172                                 "error: failed to set dai config for %s\n",
 173                                 dai->name);
 174
 175                         return ret;
 176                 }
 177         }
 178
 179         /* complete pipeline */
 180         list_for_each_entry(swidget, &sdev->widget_list, list) {
 181                 switch (swidget->id) {
 182                 case snd_soc_dapm_scheduler:
 183                         swidget->complete =
 184                                 snd_sof_complete_pipeline(sdev, swidget);
 185                         break;
 186                 default:
 187                         break;
 188                 }
 189         }
 190
 191         /* restore pipeline kcontrols */
 192         ret = sof_restore_kcontrols(sdev);
 193         if (ret < 0)
 194                 dev_err(sdev->dev,
 195                         "error: restoring kcontrols after resume\n");
 196
 197         return ret;
 198 }
 199
 200 static int sof_send_pm_ipc(struct snd_sof_dev *sdev, int cmd)
 201 {
 202         struct sof_ipc_pm_ctx pm_ctx;
 203         struct sof_ipc_reply reply;
 204
 205         memset(&pm_ctx, 0, sizeof(pm_ctx));
 206
 207         /* configure ctx save ipc message */
 208         pm_ctx.hdr.size = sizeof(pm_ctx);
 209         pm_ctx.hdr.cmd = SOF_IPC_GLB_PM_MSG | cmd;
 210
 211         /* send ctx save ipc to dsp */
 212         return sof_ipc_tx_message(sdev->ipc, pm_ctx.hdr.cmd, &pm_ctx,
 213                                  sizeof(pm_ctx), &reply, sizeof(reply));
 214 }
 215
 216 static int sof_set_hw_params_upon_resume(struct snd_sof_dev *sdev)
 217 {
 218         struct snd_pcm_substream *substream;
 219         struct snd_sof_pcm *spcm;
 220         snd_pcm_state_t state;
 221         int dir;
 222
 223         /*
 224          * SOF requires hw_params to be set-up internally upon resume.
 225          * So, set the flag to indicate this for those streams that
 226          * have been suspended.
 227          */
 228         list_for_each_entry(spcm, &sdev->pcm_list, list) {
 229                 for (dir = 0; dir <= SNDRV_PCM_STREAM_CAPTURE; dir++) {
 230                         substream = spcm->stream[dir].substream;
 231                         if (!substream || !substream->runtime)
 232                                 continue;
 233
 234                         state = substream->runtime->status->state;
 235                         if (state == SNDRV_PCM_STATE_SUSPENDED)
 236                                 spcm->prepared[dir] = false;
 237                 }
 238         }
 239
 240         /* set internal flag for BE */
 241         return snd_sof_dsp_hw_params_upon_resume(sdev);
 242 }
 243
 244 #if IS_ENABLED(CONFIG_SND_SOC_SOF_DEBUG_ENABLE_DEBUGFS_CACHE)
 245 static void sof_cache_debugfs(struct snd_sof_dev *sdev)
 246 {
 247         struct snd_sof_dfsentry *dfse;
 248
 249         list_for_each_entry(dfse, &sdev->dfsentry_list, list) {
 250
 251                 /* nothing to do if debugfs buffer is not IO mem */
 252                 if (dfse->type == SOF_DFSENTRY_TYPE_BUF)
 253                         continue;
 254
 255                 /* cache memory that is only accessible in D0 */
 256                 if (dfse->access_type == SOF_DEBUGFS_ACCESS_D0_ONLY)
 257                         memcpy_fromio(dfse->cache_buf, dfse->io_mem,
 258                                       dfse->size);
 259         }
 260 }
 261 #endif
 262
 263 static int sof_resume(struct device *dev, bool runtime_resume)
 264 {
 265         struct snd_sof_dev *sdev = dev_get_drvdata(dev);
 266         int ret;
 267
 268         /* do nothing if dsp resume callbacks are not set */
 269         if (!sof_ops(sdev)->resume || !sof_ops(sdev)->runtime_resume)
 270                 return 0;
 271
 272         /*
 273          * if the runtime_resume flag is set, call the runtime_resume routine
 274          * or else call the system resume routine
 275          */
 276         if (runtime_resume)
 277                 ret = snd_sof_dsp_runtime_resume(sdev);
 278         else
 279                 ret = snd_sof_dsp_resume(sdev);
 280         if (ret < 0) {
 281                 dev_err(sdev->dev,
 282                         "error: failed to power up DSP after resume\n");
 283                 return ret;
 284         }
 285
 286         /* load the firmware */
 287         ret = snd_sof_load_firmware(sdev);
 288         if (ret < 0) {
 289                 dev_err(sdev->dev,
 290                         "error: failed to load DSP firmware after resume %d\n",
 291                         ret);
 292                 return ret;
 293         }
 294
 295         /* boot the firmware */
 296         ret = snd_sof_run_firmware(sdev);
 297         if (ret < 0) {
 298                 dev_err(sdev->dev,
 299                         "error: failed to boot DSP firmware after resume %d\n",
 300                         ret);
 301                 return ret;
 302         }
 303
 304         /* resume DMA trace, only need send ipc */
 305         ret = snd_sof_init_trace_ipc(sdev);
 306         if (ret < 0) {
 307                 /* non fatal */
 308                 dev_warn(sdev->dev,
 309                          "warning: failed to init trace after resume %d\n",
 310                          ret);
 311         }
 312
 313         /* restore pipelines */
 314         ret = sof_restore_pipelines(sdev);
 315         if (ret < 0) {
 316                 dev_err(sdev->dev,
 317                         "error: failed to restore pipeline after resume %d\n",
 318                         ret);
 319                 return ret;
 320         }
 321
 322         /* notify DSP of system resume */
 323         ret = sof_send_pm_ipc(sdev, SOF_IPC_PM_CTX_RESTORE);
 324         if (ret < 0)
 325                 dev_err(sdev->dev,
 326                         "error: ctx_restore ipc error during resume %d\n",
 327                         ret);
 328
 329         return ret;
 330 }
 331
 332 static int sof_suspend(struct device *dev, bool runtime_suspend)
 333 {
 334         struct snd_sof_dev *sdev = dev_get_drvdata(dev);
 335         int ret;
 336
 337         /* do nothing if dsp suspend callback is not set */
 338         if (!sof_ops(sdev)->suspend)
 339                 return 0;
 340
 341         /* release trace */
 342         snd_sof_release_trace(sdev);
 343
 344         /* set restore_stream for all streams during system suspend */
 345         if (!runtime_suspend) {
 346                 ret = sof_set_hw_params_upon_resume(sdev);
 347                 if (ret < 0) {
 348                         dev_err(sdev->dev,
 349                                 "error: setting hw_params flag during suspend %d\n",
 350                                 ret);
 351                         return ret;
 352                 }
 353         }
 354
 355 #if IS_ENABLED(CONFIG_SND_SOC_SOF_DEBUG_ENABLE_DEBUGFS_CACHE)
 356         /* cache debugfs contents during runtime suspend */
 357         if (runtime_suspend)
 358                 sof_cache_debugfs(sdev);
 359 #endif
 360         /* notify DSP of upcoming power down */
 361         ret = sof_send_pm_ipc(sdev, SOF_IPC_PM_CTX_SAVE);
 362         if (ret == -EBUSY || ret == -EAGAIN) {
 363                 /*
 364                  * runtime PM has logic to handle -EBUSY/-EAGAIN so
 365                  * pass these errors up
 366                  */
 367                 dev_err(sdev->dev,
 368                         "error: ctx_save ipc error during suspend %d\n",
 369                         ret);
 370                 return ret;
 371         } else if (ret < 0) {
 372                 /* FW in unexpected state, continue to power down */
 373                 dev_warn(sdev->dev,
 374                          "ctx_save ipc error %d, proceeding with suspend\n",
 375                          ret);
 376         }
 377
 378         /* power down all DSP cores */
 379         if (runtime_suspend)
 380                 ret = snd_sof_dsp_runtime_suspend(sdev);
 381         else
 382                 ret = snd_sof_dsp_suspend(sdev);
 383         if (ret < 0)
 384                 dev_err(sdev->dev,
 385                         "error: failed to power down DSP during suspend %d\n",
 386                         ret);
 387
 388         return ret;
 389 }
 390
 391 int snd_sof_runtime_suspend(struct device *dev)
 392 {
 393         return sof_suspend(dev, true);
 394 }
 395 EXPORT_SYMBOL(snd_sof_runtime_suspend);
 396
 397 int snd_sof_runtime_idle(struct device *dev)
 398 {
 399         struct snd_sof_dev *sdev = dev_get_drvdata(dev);
 400
 401         return snd_sof_dsp_runtime_idle(sdev);
 402 }
 403 EXPORT_SYMBOL(snd_sof_runtime_idle);
 404
 405 int snd_sof_runtime_resume(struct device *dev)
 406 {
 407         return sof_resume(dev, true);
 408 }
 409 EXPORT_SYMBOL(snd_sof_runtime_resume);
 410
 411 int snd_sof_resume(struct device *dev)
 412 {
 413         return sof_resume(dev, false);
 414 }
 415 EXPORT_SYMBOL(snd_sof_resume);
 416
 417 int snd_sof_suspend(struct device *dev)
 418 {
 419         return sof_suspend(dev, false);
 420 }
 421 EXPORT_SYMBOL(snd_sof_suspend);