sound/soc/sof/intel/hda-dsp.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 // Authors: Liam Girdwood <liam.r.girdwood@linux.intel.com>
   9 //          Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
  10 //          Rander Wang <rander.wang@intel.com>
  11 //          Keyon Jie <yang.jie@linux.intel.com>
  12 //
  13
  14 /*
  15  * Hardware interface for generic Intel audio DSP HDA IP
  16  */
  17
  18 #include <linux/module.h>
  19 #include <sound/hdaudio_ext.h>
  20 #include <sound/hda_register.h>
  21 #include "../sof-audio.h"
  22 #include "../ops.h"
  23 #include "hda.h"
  24 #include "hda-ipc.h"
  25
  26 static bool hda_enable_trace_D0I3_S0;
  27 #if IS_ENABLED(CONFIG_SND_SOC_SOF_DEBUG)
  28 module_param_named(enable_trace_D0I3_S0, hda_enable_trace_D0I3_S0, bool, 0444);
  29 MODULE_PARM_DESC(enable_trace_D0I3_S0,
  30                  "SOF HDA enable trace when the DSP is in D0I3 in S0");
  31 #endif
  32
  33 /*
  34  * DSP Core control.
  35  */
  36
  37 int hda_dsp_core_reset_enter(struct snd_sof_dev *sdev, unsigned int core_mask)
  38 {
  39         u32 adspcs;
  40         u32 reset;
  41         int ret;
  42
  43         /* set reset bits for cores */
  44         reset = HDA_DSP_ADSPCS_CRST_MASK(core_mask);
  45         snd_sof_dsp_update_bits_unlocked(sdev, HDA_DSP_BAR,
  46                                          HDA_DSP_REG_ADSPCS,
  47                                          reset, reset),
  48
  49         /* poll with timeout to check if operation successful */
  50         ret = snd_sof_dsp_read_poll_timeout(sdev, HDA_DSP_BAR,
  51                                         HDA_DSP_REG_ADSPCS, adspcs,
  52                                         ((adspcs & reset) == reset),
  53                                         HDA_DSP_REG_POLL_INTERVAL_US,
  54                                         HDA_DSP_RESET_TIMEOUT_US);
  55         if (ret < 0) {
  56                 dev_err(sdev->dev,
  57                         "error: %s: timeout on HDA_DSP_REG_ADSPCS read\n",
  58                         __func__);
  59                 return ret;
  60         }
  61
  62         /* has core entered reset ? */
  63         adspcs = snd_sof_dsp_read(sdev, HDA_DSP_BAR,
  64                                   HDA_DSP_REG_ADSPCS);
  65         if ((adspcs & HDA_DSP_ADSPCS_CRST_MASK(core_mask)) !=
  66                 HDA_DSP_ADSPCS_CRST_MASK(core_mask)) {
  67                 dev_err(sdev->dev,
  68                         "error: reset enter failed: core_mask %x adspcs 0x%x\n",
  69                         core_mask, adspcs);
  70                 ret = -EIO;
  71         }
  72
  73         return ret;
  74 }
  75
  76 int hda_dsp_core_reset_leave(struct snd_sof_dev *sdev, unsigned int core_mask)
  77 {
  78         unsigned int crst;
  79         u32 adspcs;
  80         int ret;
  81
  82         /* clear reset bits for cores */
  83         snd_sof_dsp_update_bits_unlocked(sdev, HDA_DSP_BAR,
  84                                          HDA_DSP_REG_ADSPCS,
  85                                          HDA_DSP_ADSPCS_CRST_MASK(core_mask),
  86                                          0);
  87
  88         /* poll with timeout to check if operation successful */
  89         crst = HDA_DSP_ADSPCS_CRST_MASK(core_mask);
  90         ret = snd_sof_dsp_read_poll_timeout(sdev, HDA_DSP_BAR,
  91                                             HDA_DSP_REG_ADSPCS, adspcs,
  92                                             !(adspcs & crst),
  93                                             HDA_DSP_REG_POLL_INTERVAL_US,
  94                                             HDA_DSP_RESET_TIMEOUT_US);
  95
  96         if (ret < 0) {
  97                 dev_err(sdev->dev,
  98                         "error: %s: timeout on HDA_DSP_REG_ADSPCS read\n",
  99                         __func__);
 100                 return ret;
 101         }
 102
 103         /* has core left reset ? */
 104         adspcs = snd_sof_dsp_read(sdev, HDA_DSP_BAR,
 105                                   HDA_DSP_REG_ADSPCS);
 106         if ((adspcs & HDA_DSP_ADSPCS_CRST_MASK(core_mask)) != 0) {
 107                 dev_err(sdev->dev,
 108                         "error: reset leave failed: core_mask %x adspcs 0x%x\n",
 109                         core_mask, adspcs);
 110                 ret = -EIO;
 111         }
 112
 113         return ret;
 114 }
 115
 116 int hda_dsp_core_stall_reset(struct snd_sof_dev *sdev, unsigned int core_mask)
 117 {
 118         /* stall core */
 119         snd_sof_dsp_update_bits_unlocked(sdev, HDA_DSP_BAR,
 120                                          HDA_DSP_REG_ADSPCS,
 121                                          HDA_DSP_ADSPCS_CSTALL_MASK(core_mask),
 122                                          HDA_DSP_ADSPCS_CSTALL_MASK(core_mask));
 123
 124         /* set reset state */
 125         return hda_dsp_core_reset_enter(sdev, core_mask);
 126 }
 127
 128 int hda_dsp_core_run(struct snd_sof_dev *sdev, unsigned int core_mask)
 129 {
 130         int ret;
 131
 132         /* leave reset state */
 133         ret = hda_dsp_core_reset_leave(sdev, core_mask);
 134         if (ret < 0)
 135                 return ret;
 136
 137         /* run core */
 138         dev_dbg(sdev->dev, "unstall/run core: core_mask = %x\n", core_mask);
 139         snd_sof_dsp_update_bits_unlocked(sdev, HDA_DSP_BAR,
 140                                          HDA_DSP_REG_ADSPCS,
 141                                          HDA_DSP_ADSPCS_CSTALL_MASK(core_mask),
 142                                          0);
 143
 144         /* is core now running ? */
 145         if (!hda_dsp_core_is_enabled(sdev, core_mask)) {
 146                 hda_dsp_core_stall_reset(sdev, core_mask);
 147                 dev_err(sdev->dev, "error: DSP start core failed: core_mask %x\n",
 148                         core_mask);
 149                 ret = -EIO;
 150         }
 151
 152         return ret;
 153 }
 154
 155 /*
 156  * Power Management.
 157  */
 158
 159 int hda_dsp_core_power_up(struct snd_sof_dev *sdev, unsigned int core_mask)
 160 {
 161         unsigned int cpa;
 162         u32 adspcs;
 163         int ret;
 164
 165         /* update bits */
 166         snd_sof_dsp_update_bits(sdev, HDA_DSP_BAR, HDA_DSP_REG_ADSPCS,
 167                                 HDA_DSP_ADSPCS_SPA_MASK(core_mask),
 168                                 HDA_DSP_ADSPCS_SPA_MASK(core_mask));
 169
 170         /* poll with timeout to check if operation successful */
 171         cpa = HDA_DSP_ADSPCS_CPA_MASK(core_mask);
 172         ret = snd_sof_dsp_read_poll_timeout(sdev, HDA_DSP_BAR,
 173                                             HDA_DSP_REG_ADSPCS, adspcs,
 174                                             (adspcs & cpa) == cpa,
 175                                             HDA_DSP_REG_POLL_INTERVAL_US,
 176                                             HDA_DSP_RESET_TIMEOUT_US);
 177         if (ret < 0) {
 178                 dev_err(sdev->dev,
 179                         "error: %s: timeout on HDA_DSP_REG_ADSPCS read\n",
 180                         __func__);
 181                 return ret;
 182         }
 183
 184         /* did core power up ? */
 185         adspcs = snd_sof_dsp_read(sdev, HDA_DSP_BAR,
 186                                   HDA_DSP_REG_ADSPCS);
 187         if ((adspcs & HDA_DSP_ADSPCS_CPA_MASK(core_mask)) !=
 188                 HDA_DSP_ADSPCS_CPA_MASK(core_mask)) {
 189                 dev_err(sdev->dev,
 190                         "error: power up core failed core_mask %xadspcs 0x%x\n",
 191                         core_mask, adspcs);
 192                 ret = -EIO;
 193         }
 194
 195         return ret;
 196 }
 197
 198 int hda_dsp_core_power_down(struct snd_sof_dev *sdev, unsigned int core_mask)
 199 {
 200         u32 adspcs;
 201         int ret;
 202
 203         /* update bits */
 204         snd_sof_dsp_update_bits_unlocked(sdev, HDA_DSP_BAR,
 205                                          HDA_DSP_REG_ADSPCS,
 206                                          HDA_DSP_ADSPCS_SPA_MASK(core_mask), 0);
 207
 208         ret = snd_sof_dsp_read_poll_timeout(sdev, HDA_DSP_BAR,
 209                                 HDA_DSP_REG_ADSPCS, adspcs,
 210                                 !(adspcs & HDA_DSP_ADSPCS_SPA_MASK(core_mask)),
 211                                 HDA_DSP_REG_POLL_INTERVAL_US,
 212                                 HDA_DSP_PD_TIMEOUT * USEC_PER_MSEC);
 213         if (ret < 0)
 214                 dev_err(sdev->dev,
 215                         "error: %s: timeout on HDA_DSP_REG_ADSPCS read\n",
 216                         __func__);
 217
 218         return ret;
 219 }
 220
 221 bool hda_dsp_core_is_enabled(struct snd_sof_dev *sdev,
 222                              unsigned int core_mask)
 223 {
 224         int val;
 225         bool is_enable;
 226
 227         val = snd_sof_dsp_read(sdev, HDA_DSP_BAR, HDA_DSP_REG_ADSPCS);
 228
 229         is_enable = ((val & HDA_DSP_ADSPCS_CPA_MASK(core_mask)) &&
 230                         (val & HDA_DSP_ADSPCS_SPA_MASK(core_mask)) &&
 231                         !(val & HDA_DSP_ADSPCS_CRST_MASK(core_mask)) &&
 232                         !(val & HDA_DSP_ADSPCS_CSTALL_MASK(core_mask)));
 233
 234         dev_dbg(sdev->dev, "DSP core(s) enabled? %d : core_mask %x\n",
 235                 is_enable, core_mask);
 236
 237         return is_enable;
 238 }
 239
 240 int hda_dsp_enable_core(struct snd_sof_dev *sdev, unsigned int core_mask)
 241 {
 242         int ret;
 243
 244         /* return if core is already enabled */
 245         if (hda_dsp_core_is_enabled(sdev, core_mask))
 246                 return 0;
 247
 248         /* power up */
 249         ret = hda_dsp_core_power_up(sdev, core_mask);
 250         if (ret < 0) {
 251                 dev_err(sdev->dev, "error: dsp core power up failed: core_mask %x\n",
 252                         core_mask);
 253                 return ret;
 254         }
 255
 256         return hda_dsp_core_run(sdev, core_mask);
 257 }
 258
 259 int hda_dsp_core_reset_power_down(struct snd_sof_dev *sdev,
 260                                   unsigned int core_mask)
 261 {
 262         int ret;
 263
 264         /* place core in reset prior to power down */
 265         ret = hda_dsp_core_stall_reset(sdev, core_mask);
 266         if (ret < 0) {
 267                 dev_err(sdev->dev, "error: dsp core reset failed: core_mask %x\n",
 268                         core_mask);
 269                 return ret;
 270         }
 271
 272         /* power down core */
 273         ret = hda_dsp_core_power_down(sdev, core_mask);
 274         if (ret < 0) {
 275                 dev_err(sdev->dev, "error: dsp core power down fail mask %x: %d\n",
 276                         core_mask, ret);
 277                 return ret;
 278         }
 279
 280         /* make sure we are in OFF state */
 281         if (hda_dsp_core_is_enabled(sdev, core_mask)) {
 282                 dev_err(sdev->dev, "error: dsp core disable fail mask %x: %d\n",
 283                         core_mask, ret);
 284                 ret = -EIO;
 285         }
 286
 287         return ret;
 288 }
 289
 290 void hda_dsp_ipc_int_enable(struct snd_sof_dev *sdev)
 291 {
 292         struct sof_intel_hda_dev *hda = sdev->pdata->hw_pdata;
 293         const struct sof_intel_dsp_desc *chip = hda->desc;
 294
 295         /* enable IPC DONE and BUSY interrupts */
 296         snd_sof_dsp_update_bits(sdev, HDA_DSP_BAR, chip->ipc_ctl,
 297                         HDA_DSP_REG_HIPCCTL_DONE | HDA_DSP_REG_HIPCCTL_BUSY,
 298                         HDA_DSP_REG_HIPCCTL_DONE | HDA_DSP_REG_HIPCCTL_BUSY);
 299
 300         /* enable IPC interrupt */
 301         snd_sof_dsp_update_bits(sdev, HDA_DSP_BAR, HDA_DSP_REG_ADSPIC,
 302                                 HDA_DSP_ADSPIC_IPC, HDA_DSP_ADSPIC_IPC);
 303 }
 304
 305 void hda_dsp_ipc_int_disable(struct snd_sof_dev *sdev)
 306 {
 307         struct sof_intel_hda_dev *hda = sdev->pdata->hw_pdata;
 308         const struct sof_intel_dsp_desc *chip = hda->desc;
 309
 310         /* disable IPC interrupt */
 311         snd_sof_dsp_update_bits(sdev, HDA_DSP_BAR, HDA_DSP_REG_ADSPIC,
 312                                 HDA_DSP_ADSPIC_IPC, 0);
 313
 314         /* disable IPC BUSY and DONE interrupt */
 315         snd_sof_dsp_update_bits(sdev, HDA_DSP_BAR, chip->ipc_ctl,
 316                         HDA_DSP_REG_HIPCCTL_BUSY | HDA_DSP_REG_HIPCCTL_DONE, 0);
 317 }
 318
 319 static int hda_dsp_wait_d0i3c_done(struct snd_sof_dev *sdev)
 320 {
 321         struct hdac_bus *bus = sof_to_bus(sdev);
 322         int retry = HDA_DSP_REG_POLL_RETRY_COUNT;
 323
 324         while (snd_hdac_chip_readb(bus, VS_D0I3C) & SOF_HDA_VS_D0I3C_CIP) {
 325                 if (!retry--)
 326                         return -ETIMEDOUT;
 327                 usleep_range(10, 15);
 328         }
 329
 330         return 0;
 331 }
 332
 333 static int hda_dsp_send_pm_gate_ipc(struct snd_sof_dev *sdev, u32 flags)
 334 {
 335         struct sof_ipc_pm_gate pm_gate;
 336         struct sof_ipc_reply reply;
 337
 338         memset(&pm_gate, 0, sizeof(pm_gate));
 339
 340         /* configure pm_gate ipc message */
 341         pm_gate.hdr.size = sizeof(pm_gate);
 342         pm_gate.hdr.cmd = SOF_IPC_GLB_PM_MSG | SOF_IPC_PM_GATE;
 343         pm_gate.flags = flags;
 344
 345         /* send pm_gate ipc to dsp */
 346         return sof_ipc_tx_message_no_pm(sdev->ipc, pm_gate.hdr.cmd,
 347                                         &pm_gate, sizeof(pm_gate), &reply,
 348                                         sizeof(reply));
 349 }
 350
 351 static int hda_dsp_update_d0i3c_register(struct snd_sof_dev *sdev, u8 value)
 352 {
 353         struct hdac_bus *bus = sof_to_bus(sdev);
 354         int ret;
 355
 356         /* Write to D0I3C after Command-In-Progress bit is cleared */
 357         ret = hda_dsp_wait_d0i3c_done(sdev);
 358         if (ret < 0) {
 359                 dev_err(bus->dev, "CIP timeout before D0I3C update!\n");
 360                 return ret;
 361         }
 362
 363         /* Update D0I3C register */
 364         snd_hdac_chip_updateb(bus, VS_D0I3C, SOF_HDA_VS_D0I3C_I3, value);
 365
 366         /* Wait for cmd in progress to be cleared before exiting the function */
 367         ret = hda_dsp_wait_d0i3c_done(sdev);
 368         if (ret < 0) {
 369                 dev_err(bus->dev, "CIP timeout after D0I3C update!\n");
 370                 return ret;
 371         }
 372
 373         dev_vdbg(bus->dev, "D0I3C updated, register = 0x%x\n",
 374                  snd_hdac_chip_readb(bus, VS_D0I3C));
 375
 376         return 0;
 377 }
 378
 379 static int hda_dsp_set_D0_state(struct snd_sof_dev *sdev,
 380                                 const struct sof_dsp_power_state *target_state)
 381 {
 382         u32 flags = 0;
 383         int ret;
 384         u8 value = 0;
 385
 386         /*
 387          * Sanity check for illegal state transitions
 388          * The only allowed transitions are:
 389          * 1. D3 -> D0I0
 390          * 2. D0I0 -> D0I3
 391          * 3. D0I3 -> D0I0
 392          */
 393         switch (sdev->dsp_power_state.state) {
 394         case SOF_DSP_PM_D0:
 395                 /* Follow the sequence below for D0 substate transitions */
 396                 break;
 397         case SOF_DSP_PM_D3:
 398                 /* Follow regular flow for D3 -> D0 transition */
 399                 return 0;
 400         default:
 401                 dev_err(sdev->dev, "error: transition from %d to %d not allowed\n",
 402                         sdev->dsp_power_state.state, target_state->state);
 403                 return -EINVAL;
 404         }
 405
 406         /* Set flags and register value for D0 target substate */
 407         if (target_state->substate == SOF_HDA_DSP_PM_D0I3) {
 408                 value = SOF_HDA_VS_D0I3C_I3;
 409
 410                 /*
 411                  * Trace DMA is disabled by default when the DSP enters D0I3.
 412                  * But it can be kept enabled when the DSP enters D0I3 while the
 413                  * system is in S0 for debug.
 414                  */
 415                 if (hda_enable_trace_D0I3_S0 &&
 416                     sdev->system_suspend_target != SOF_SUSPEND_NONE)
 417                         flags = HDA_PM_NO_DMA_TRACE;
 418         } else {
 419                 /* prevent power gating in D0I0 */
 420                 flags = HDA_PM_PPG;
 421         }
 422
 423         /* update D0I3C register */
 424         ret = hda_dsp_update_d0i3c_register(sdev, value);
 425         if (ret < 0)
 426                 return ret;
 427
 428         /*
 429          * Notify the DSP of the state change.
 430          * If this IPC fails, revert the D0I3C register update in order
 431          * to prevent partial state change.
 432          */
 433         ret = hda_dsp_send_pm_gate_ipc(sdev, flags);
 434         if (ret < 0) {
 435                 dev_err(sdev->dev,
 436                         "error: PM_GATE ipc error %d\n", ret);
 437                 goto revert;
 438         }
 439
 440         return ret;
 441
 442 revert:
 443         /* fallback to the previous register value */
 444         value = value ? 0 : SOF_HDA_VS_D0I3C_I3;
 445
 446         /*
 447          * This can fail but return the IPC error to signal that
 448          * the state change failed.
 449          */
 450         hda_dsp_update_d0i3c_register(sdev, value);
 451
 452         return ret;
 453 }
 454
 455 /*
 456  * All DSP power state transitions are initiated by the driver.
 457  * If the requested state change fails, the error is simply returned.
 458  * Further state transitions are attempted only when the set_power_save() op
 459  * is called again either because of a new IPC sent to the DSP or
 460  * during system suspend/resume.
 461  */
 462 int hda_dsp_set_power_state(struct snd_sof_dev *sdev,
 463                             const struct sof_dsp_power_state *target_state)
 464 {
 465         int ret = 0;
 466
 467         /*
 468          * When the DSP is already in D0I3 and the target state is D0I3,
 469          * it could be the case that the DSP is in D0I3 during S0
 470          * and the system is suspending to S0Ix. Therefore,
 471          * hda_dsp_set_D0_state() must be called to disable trace DMA
 472          * by sending the PM_GATE IPC to the FW.
 473          */
 474         if (target_state->substate == SOF_HDA_DSP_PM_D0I3 &&
 475             sdev->system_suspend_target == SOF_SUSPEND_S0IX)
 476                 goto set_state;
 477
 478         /*
 479          * For all other cases, return without doing anything if
 480          * the DSP is already in the target state.
 481          */
 482         if (target_state->state == sdev->dsp_power_state.state &&
 483             target_state->substate == sdev->dsp_power_state.substate)
 484                 return 0;
 485
 486 set_state:
 487         switch (target_state->state) {
 488         case SOF_DSP_PM_D0:
 489                 ret = hda_dsp_set_D0_state(sdev, target_state);
 490                 break;
 491         case SOF_DSP_PM_D3:
 492                 /* The only allowed transition is: D0I0 -> D3 */
 493                 if (sdev->dsp_power_state.state == SOF_DSP_PM_D0 &&
 494                     sdev->dsp_power_state.substate == SOF_HDA_DSP_PM_D0I0)
 495                         break;
 496
 497                 dev_err(sdev->dev,
 498                         "error: transition from %d to %d not allowed\n",
 499                         sdev->dsp_power_state.state, target_state->state);
 500                 return -EINVAL;
 501         default:
 502                 dev_err(sdev->dev, "error: target state unsupported %d\n",
 503                         target_state->state);
 504                 return -EINVAL;
 505         }
 506         if (ret < 0) {
 507                 dev_err(sdev->dev,
 508                         "failed to set requested target DSP state %d substate %d\n",
 509                         target_state->state, target_state->substate);
 510                 return ret;
 511         }
 512
 513         sdev->dsp_power_state = *target_state;
 514         dev_dbg(sdev->dev, "New DSP state %d substate %d\n",
 515                 target_state->state, target_state->substate);
 516         return ret;
 517 }
 518
 519 /*
 520  * Audio DSP states may transform as below:-
 521  *
 522  *                                         Opportunistic D0I3 in S0
 523  *     Runtime    +---------------------+  Delayed D0i3 work timeout
 524  *     suspend    |                     +--------------------+
 525  *   +------------+       D0I0(active)  |                    |
 526  *   |            |                     <---------------+    |
 527  *   |   +-------->                     |    New IPC    |    |
 528  *   |   |Runtime +--^--+---------^--+--+ (via mailbox) |    |
 529  *   |   |resume     |  |         |  |                  |    |
 530  *   |   |           |  |         |  |                  |    |
 531  *   |   |     System|  |         |  |                  |    |
 532  *   |   |     resume|  | S3/S0IX |  |                  |    |
 533  *   |   |           |  | suspend |  | S0IX             |    |
 534  *   |   |           |  |         |  |suspend           |    |
 535  *   |   |           |  |         |  |                  |    |
 536  *   |   |           |  |         |  |                  |    |
 537  * +-v---+-----------+--v-------+ |  |           +------+----v----+
 538  * |                            | |  +----------->                |
 539  * |       D3 (suspended)       | |              |      D0I3      |
 540  * |                            | +--------------+                |
 541  * |                            |  System resume |                |
 542  * +----------------------------+                +----------------+
 543  *
 544  * S0IX suspend: The DSP is in D0I3 if any D0I3-compatible streams
 545  *               ignored the suspend trigger. Otherwise the DSP
 546  *               is in D3.
 547  */
 548
 549 static int hda_suspend(struct snd_sof_dev *sdev, bool runtime_suspend)
 550 {
 551         struct sof_intel_hda_dev *hda = sdev->pdata->hw_pdata;
 552         const struct sof_intel_dsp_desc *chip = hda->desc;
 553 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA)
 554         struct hdac_bus *bus = sof_to_bus(sdev);
 555 #endif
 556         int ret;
 557
 558         /* disable IPC interrupts */
 559         hda_dsp_ipc_int_disable(sdev);
 560
 561 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA)
 562         if (runtime_suspend)
 563                 hda_codec_jack_wake_enable(sdev);
 564
 565         /* power down all hda link */
 566         snd_hdac_ext_bus_link_power_down_all(bus);
 567 #endif
 568
 569         /* power down DSP */
 570         ret = hda_dsp_core_reset_power_down(sdev, chip->cores_mask);
 571         if (ret < 0) {
 572                 dev_err(sdev->dev,
 573                         "error: failed to power down core during suspend\n");
 574                 return ret;
 575         }
 576
 577         /* disable ppcap interrupt */
 578         hda_dsp_ctrl_ppcap_enable(sdev, false);
 579         hda_dsp_ctrl_ppcap_int_enable(sdev, false);
 580
 581         /* disable hda bus irq and streams */
 582         hda_dsp_ctrl_stop_chip(sdev);
 583
 584         /* disable LP retention mode */
 585         snd_sof_pci_update_bits(sdev, PCI_PGCTL,
 586                                 PCI_PGCTL_LSRMD_MASK, PCI_PGCTL_LSRMD_MASK);
 587
 588         /* reset controller */
 589         ret = hda_dsp_ctrl_link_reset(sdev, true);
 590         if (ret < 0) {
 591                 dev_err(sdev->dev,
 592                         "error: failed to reset controller during suspend\n");
 593                 return ret;
 594         }
 595
 596         return 0;
 597 }
 598
 599 static int hda_resume(struct snd_sof_dev *sdev, bool runtime_resume)
 600 {
 601 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA)
 602         struct hdac_bus *bus = sof_to_bus(sdev);
 603         struct hdac_ext_link *hlink = NULL;
 604 #endif
 605         int ret;
 606
 607         /*
 608          * clear TCSEL to clear playback on some HD Audio
 609          * codecs. PCI TCSEL is defined in the Intel manuals.
 610          */
 611         snd_sof_pci_update_bits(sdev, PCI_TCSEL, 0x07, 0);
 612
 613         /* reset and start hda controller */
 614         ret = hda_dsp_ctrl_init_chip(sdev, true);
 615         if (ret < 0) {
 616                 dev_err(sdev->dev,
 617                         "error: failed to start controller after resume\n");
 618                 return ret;
 619         }
 620
 621 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA)
 622         /* check jack status */
 623         if (runtime_resume)
 624                 hda_codec_jack_check(sdev);
 625
 626         /* turn off the links that were off before suspend */
 627         list_for_each_entry(hlink, &bus->hlink_list, list) {
 628                 if (!hlink->ref_count)
 629                         snd_hdac_ext_bus_link_power_down(hlink);
 630         }
 631
 632         /* check dma status and clean up CORB/RIRB buffers */
 633         if (!bus->cmd_dma_state)
 634                 snd_hdac_bus_stop_cmd_io(bus);
 635 #endif
 636
 637         /* enable ppcap interrupt */
 638         hda_dsp_ctrl_ppcap_enable(sdev, true);
 639         hda_dsp_ctrl_ppcap_int_enable(sdev, true);
 640
 641         return 0;
 642 }
 643
 644 int hda_dsp_resume(struct snd_sof_dev *sdev)
 645 {
 646         struct sof_intel_hda_dev *hda = sdev->pdata->hw_pdata;
 647         struct pci_dev *pci = to_pci_dev(sdev->dev);
 648         const struct sof_dsp_power_state target_state = {
 649                 .state = SOF_DSP_PM_D0,
 650                 .substate = SOF_HDA_DSP_PM_D0I0,
 651         };
 652         int ret;
 653
 654         /* resume from D0I3 */
 655         if (sdev->dsp_power_state.state == SOF_DSP_PM_D0) {
 656                 /* Set DSP power state */
 657                 ret = hda_dsp_set_power_state(sdev, &target_state);
 658                 if (ret < 0) {
 659                         dev_err(sdev->dev, "error: setting dsp state %d substate %d\n",
 660                                 target_state.state, target_state.substate);
 661                         return ret;
 662                 }
 663
 664                 /* restore L1SEN bit */
 665                 if (hda->l1_support_changed)
 666                         snd_sof_dsp_update_bits(sdev, HDA_DSP_HDA_BAR,
 667                                                 HDA_VS_INTEL_EM2,
 668                                                 HDA_VS_INTEL_EM2_L1SEN, 0);
 669
 670                 /* restore and disable the system wakeup */
 671                 pci_restore_state(pci);
 672                 disable_irq_wake(pci->irq);
 673                 return 0;
 674         }
 675
 676         /* init hda controller. DSP cores will be powered up during fw boot */
 677         ret = hda_resume(sdev, false);
 678         if (ret < 0)
 679                 return ret;
 680
 681         hda_dsp_set_power_state(sdev, &target_state);
 682         return ret;
 683 }
 684
 685 int hda_dsp_runtime_resume(struct snd_sof_dev *sdev)
 686 {
 687         const struct sof_dsp_power_state target_state = {
 688                 .state = SOF_DSP_PM_D0,
 689         };
 690         int ret;
 691
 692         /* init hda controller. DSP cores will be powered up during fw boot */
 693         ret = hda_resume(sdev, true);
 694         if (ret < 0)
 695                 return ret;
 696
 697         return hda_dsp_set_power_state(sdev, &target_state);
 698 }
 699
 700 int hda_dsp_runtime_idle(struct snd_sof_dev *sdev)
 701 {
 702         struct hdac_bus *hbus = sof_to_bus(sdev);
 703
 704         if (hbus->codec_powered) {
 705                 dev_dbg(sdev->dev, "some codecs still powered (%08X), not idle\n",
 706                         (unsigned int)hbus->codec_powered);
 707                 return -EBUSY;
 708         }
 709
 710         return 0;
 711 }
 712
 713 int hda_dsp_runtime_suspend(struct snd_sof_dev *sdev)
 714 {
 715         const struct sof_dsp_power_state target_state = {
 716                 .state = SOF_DSP_PM_D3,
 717         };
 718         int ret;
 719
 720         /* stop hda controller and power dsp off */
 721         ret = hda_suspend(sdev, true);
 722         if (ret < 0)
 723                 return ret;
 724
 725         return hda_dsp_set_power_state(sdev, &target_state);
 726 }
 727
 728 int hda_dsp_suspend(struct snd_sof_dev *sdev, u32 target_state)
 729 {
 730         struct sof_intel_hda_dev *hda = sdev->pdata->hw_pdata;
 731         struct hdac_bus *bus = sof_to_bus(sdev);
 732         struct pci_dev *pci = to_pci_dev(sdev->dev);
 733         const struct sof_dsp_power_state target_dsp_state = {
 734                 .state = target_state,
 735                 .substate = target_state == SOF_DSP_PM_D0 ?
 736                                 SOF_HDA_DSP_PM_D0I3 : 0,
 737         };
 738         int ret;
 739
 740         /* cancel any attempt for DSP D0I3 */
 741         cancel_delayed_work_sync(&hda->d0i3_work);
 742
 743         if (target_state == SOF_DSP_PM_D0) {
 744                 /* Set DSP power state */
 745                 ret = hda_dsp_set_power_state(sdev, &target_dsp_state);
 746                 if (ret < 0) {
 747                         dev_err(sdev->dev, "error: setting dsp state %d substate %d\n",
 748                                 target_dsp_state.state,
 749                                 target_dsp_state.substate);
 750                         return ret;
 751                 }
 752
 753                 /* enable L1SEN to make sure the system can enter S0Ix */
 754                 hda->l1_support_changed =
 755                         snd_sof_dsp_update_bits(sdev, HDA_DSP_HDA_BAR,
 756                                                 HDA_VS_INTEL_EM2,
 757                                                 HDA_VS_INTEL_EM2_L1SEN,
 758                                                 HDA_VS_INTEL_EM2_L1SEN);
 759
 760                 /* enable the system waking up via IPC IRQ */
 761                 enable_irq_wake(pci->irq);
 762                 pci_save_state(pci);
 763                 return 0;
 764         }
 765
 766         /* stop hda controller and power dsp off */
 767         ret = hda_suspend(sdev, false);
 768         if (ret < 0) {
 769                 dev_err(bus->dev, "error: suspending dsp\n");
 770                 return ret;
 771         }
 772
 773         return hda_dsp_set_power_state(sdev, &target_dsp_state);
 774 }
 775
 776 int hda_dsp_set_hw_params_upon_resume(struct snd_sof_dev *sdev)
 777 {
 778 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA)
 779         struct hdac_bus *bus = sof_to_bus(sdev);
 780         struct snd_soc_pcm_runtime *rtd;
 781         struct hdac_ext_stream *stream;
 782         struct hdac_ext_link *link;
 783         struct hdac_stream *s;
 784         const char *name;
 785         int stream_tag;
 786
 787         /* set internal flag for BE */
 788         list_for_each_entry(s, &bus->stream_list, list) {
 789                 stream = stream_to_hdac_ext_stream(s);
 790
 791                 /*
 792                  * clear stream. This should already be taken care for running
 793                  * streams when the SUSPEND trigger is called. But paused
 794                  * streams do not get suspended, so this needs to be done
 795                  * explicitly during suspend.
 796                  */
 797                 if (stream->link_substream) {
 798                         rtd = snd_pcm_substream_chip(stream->link_substream);
 799                         name = rtd->codec_dai->component->name;
 800                         link = snd_hdac_ext_bus_get_link(bus, name);
 801                         if (!link)
 802                                 return -EINVAL;
 803
 804                         stream->link_prepared = 0;
 805
 806                         if (hdac_stream(stream)->direction ==
 807                                 SNDRV_PCM_STREAM_CAPTURE)
 808                                 continue;
 809
 810                         stream_tag = hdac_stream(stream)->stream_tag;
 811                         snd_hdac_ext_link_clear_stream_id(link, stream_tag);
 812                 }
 813         }
 814 #endif
 815         return 0;
 816 }
 817
 818 void hda_dsp_d0i3_work(struct work_struct *work)
 819 {
 820         struct sof_intel_hda_dev *hdev = container_of(work,
 821                                                       struct sof_intel_hda_dev,
 822                                                       d0i3_work.work);
 823         struct hdac_bus *bus = &hdev->hbus.core;
 824         struct snd_sof_dev *sdev = dev_get_drvdata(bus->dev);
 825         struct sof_dsp_power_state target_state;
 826         int ret;
 827
 828         target_state.state = SOF_DSP_PM_D0;
 829
 830         /* DSP can enter D0I3 iff only D0I3-compatible streams are active */
 831         if (snd_sof_dsp_only_d0i3_compatible_stream_active(sdev))
 832                 target_state.substate = SOF_HDA_DSP_PM_D0I3;
 833         else
 834                 target_state.substate = SOF_HDA_DSP_PM_D0I0;
 835
 836         /* remain in D0I0 */
 837         if (target_state.substate == SOF_HDA_DSP_PM_D0I0)
 838                 return;
 839
 840         /* This can fail but error cannot be propagated */
 841         ret = hda_dsp_set_power_state(sdev, &target_state);
 842         if (ret < 0)
 843                 dev_err_ratelimited(sdev->dev,
 844                                     "error: failed to set DSP state %d substate %d\n",
 845                                     target_state.state, target_state.substate);
 846 }