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