sound/soc/intel/avs/core.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 //
   3 // Copyright(c) 2021-2022 Intel Corporation. All rights reserved.
   4 //
   5 // Authors: Cezary Rojewski <cezary.rojewski@intel.com>
   6 //          Amadeusz Slawinski <amadeuszx.slawinski@linux.intel.com>
   7 //
   8 // Special thanks to:
   9 //    Krzysztof Hejmowski <krzysztof.hejmowski@intel.com>
  10 //    Michal Sienkiewicz <michal.sienkiewicz@intel.com>
  11 //    Filip Proborszcz
  12 //
  13 // for sharing Intel AudioDSP expertise and helping shape the very
  14 // foundation of this driver
  15 //
  16
  17 #include <linux/module.h>
  18 #include <linux/pci.h>
  19 #include <sound/hda_codec.h>
  20 #include <sound/hda_i915.h>
  21 #include <sound/hda_register.h>
  22 #include <sound/hdaudio.h>
  23 #include <sound/hdaudio_ext.h>
  24 #include <sound/intel-dsp-config.h>
  25 #include <sound/intel-nhlt.h>
  26 #include "../../codecs/hda.h"
  27 #include "avs.h"
  28 #include "cldma.h"
  29
  30 static u32 pgctl_mask = AZX_PGCTL_LSRMD_MASK;
  31 module_param(pgctl_mask, uint, 0444);
  32 MODULE_PARM_DESC(pgctl_mask, "PCI PGCTL policy override");
  33
  34 static u32 cgctl_mask = AZX_CGCTL_MISCBDCGE_MASK;
  35 module_param(cgctl_mask, uint, 0444);
  36 MODULE_PARM_DESC(cgctl_mask, "PCI CGCTL policy override");
  37
  38 static void
  39 avs_hda_update_config_dword(struct hdac_bus *bus, u32 reg, u32 mask, u32 value)
  40 {
  41         struct pci_dev *pci = to_pci_dev(bus->dev);
  42         u32 data;
  43
  44         pci_read_config_dword(pci, reg, &data);
  45         data &= ~mask;
  46         data |= (value & mask);
  47         pci_write_config_dword(pci, reg, data);
  48 }
  49
  50 void avs_hda_power_gating_enable(struct avs_dev *adev, bool enable)
  51 {
  52         u32 value = enable ? 0 : pgctl_mask;
  53
  54         avs_hda_update_config_dword(&adev->base.core, AZX_PCIREG_PGCTL, pgctl_mask, value);
  55 }
  56
  57 static void avs_hdac_clock_gating_enable(struct hdac_bus *bus, bool enable)
  58 {
  59         u32 value = enable ? cgctl_mask : 0;
  60
  61         avs_hda_update_config_dword(bus, AZX_PCIREG_CGCTL, cgctl_mask, value);
  62 }
  63
  64 void avs_hda_clock_gating_enable(struct avs_dev *adev, bool enable)
  65 {
  66         avs_hdac_clock_gating_enable(&adev->base.core, enable);
  67 }
  68
  69 void avs_hda_l1sen_enable(struct avs_dev *adev, bool enable)
  70 {
  71         u32 value = enable ? AZX_VS_EM2_L1SEN : 0;
  72
  73         snd_hdac_chip_updatel(&adev->base.core, VS_EM2, AZX_VS_EM2_L1SEN, value);
  74 }
  75
  76 static int avs_hdac_bus_init_streams(struct hdac_bus *bus)
  77 {
  78         unsigned int cp_streams, pb_streams;
  79         unsigned int gcap;
  80
  81         gcap = snd_hdac_chip_readw(bus, GCAP);
  82         cp_streams = (gcap >> 8) & 0x0F;
  83         pb_streams = (gcap >> 12) & 0x0F;
  84         bus->num_streams = cp_streams + pb_streams;
  85
  86         snd_hdac_ext_stream_init_all(bus, 0, cp_streams, SNDRV_PCM_STREAM_CAPTURE);
  87         snd_hdac_ext_stream_init_all(bus, cp_streams, pb_streams, SNDRV_PCM_STREAM_PLAYBACK);
  88
  89         return snd_hdac_bus_alloc_stream_pages(bus);
  90 }
  91
  92 static bool avs_hdac_bus_init_chip(struct hdac_bus *bus, bool full_reset)
  93 {
  94         struct hdac_ext_link *hlink;
  95         bool ret;
  96
  97         avs_hdac_clock_gating_enable(bus, false);
  98         ret = snd_hdac_bus_init_chip(bus, full_reset);
  99
 100         /* Reset stream-to-link mapping */
 101         list_for_each_entry(hlink, &bus->hlink_list, list)
 102                 writel(0, hlink->ml_addr + AZX_REG_ML_LOSIDV);
 103
 104         avs_hdac_clock_gating_enable(bus, true);
 105
 106         /* Set DUM bit to address incorrect position reporting for capture
 107          * streams. In order to do so, CTRL needs to be out of reset state
 108          */
 109         snd_hdac_chip_updatel(bus, VS_EM2, AZX_VS_EM2_DUM, AZX_VS_EM2_DUM);
 110
 111         return ret;
 112 }
 113
 114 static int probe_codec(struct hdac_bus *bus, int addr)
 115 {
 116         struct hda_codec *codec;
 117         unsigned int cmd = (addr << 28) | (AC_NODE_ROOT << 20) |
 118                            (AC_VERB_PARAMETERS << 8) | AC_PAR_VENDOR_ID;
 119         unsigned int res = -1;
 120         int ret;
 121
 122         mutex_lock(&bus->cmd_mutex);
 123         snd_hdac_bus_send_cmd(bus, cmd);
 124         snd_hdac_bus_get_response(bus, addr, &res);
 125         mutex_unlock(&bus->cmd_mutex);
 126         if (res == -1)
 127                 return -EIO;
 128
 129         dev_dbg(bus->dev, "codec #%d probed OK: 0x%x\n", addr, res);
 130
 131         codec = snd_hda_codec_device_init(to_hda_bus(bus), addr, "hdaudioB%dD%d", bus->idx, addr);
 132         if (IS_ERR(codec)) {
 133                 dev_err(bus->dev, "init codec failed: %ld\n", PTR_ERR(codec));
 134                 return PTR_ERR(codec);
 135         }
 136         /*
 137          * Allow avs_core suspend by forcing suspended state on all
 138          * of its codec child devices. Component interested in
 139          * dealing with hda codecs directly takes pm responsibilities
 140          */
 141         pm_runtime_set_suspended(hda_codec_dev(codec));
 142
 143         /* configure effectively creates new ASoC component */
 144         ret = snd_hda_codec_configure(codec);
 145         if (ret < 0) {
 146                 dev_err(bus->dev, "failed to config codec %d\n", ret);
 147                 return ret;
 148         }
 149
 150         return 0;
 151 }
 152
 153 static void avs_hdac_bus_probe_codecs(struct hdac_bus *bus)
 154 {
 155         int c;
 156
 157         /* First try to probe all given codec slots */
 158         for (c = 0; c < HDA_MAX_CODECS; c++) {
 159                 if (!(bus->codec_mask & BIT(c)))
 160                         continue;
 161
 162                 if (!probe_codec(bus, c))
 163                         /* success, continue probing */
 164                         continue;
 165
 166                 /*
 167                  * Some BIOSen give you wrong codec addresses
 168                  * that don't exist
 169                  */
 170                 dev_warn(bus->dev, "Codec #%d probe error; disabling it...\n", c);
 171                 bus->codec_mask &= ~BIT(c);
 172                 /*
 173                  * More badly, accessing to a non-existing
 174                  * codec often screws up the controller bus,
 175                  * and disturbs the further communications.
 176                  * Thus if an error occurs during probing,
 177                  * better to reset the controller bus to get
 178                  * back to the sanity state.
 179                  */
 180                 snd_hdac_bus_stop_chip(bus);
 181                 avs_hdac_bus_init_chip(bus, true);
 182         }
 183 }
 184
 185 static void avs_hda_probe_work(struct work_struct *work)
 186 {
 187         struct avs_dev *adev = container_of(work, struct avs_dev, probe_work);
 188         struct hdac_bus *bus = &adev->base.core;
 189         struct hdac_ext_link *hlink;
 190         int ret;
 191
 192         pm_runtime_set_active(bus->dev); /* clear runtime_error flag */
 193
 194         ret = snd_hdac_i915_init(bus);
 195         if (ret < 0)
 196                 dev_info(bus->dev, "i915 init unsuccessful: %d\n", ret);
 197
 198         snd_hdac_display_power(bus, HDA_CODEC_IDX_CONTROLLER, true);
 199         avs_hdac_bus_init_chip(bus, true);
 200         avs_hdac_bus_probe_codecs(bus);
 201         snd_hdac_display_power(bus, HDA_CODEC_IDX_CONTROLLER, false);
 202
 203         /* with all codecs probed, links can be powered down */
 204         list_for_each_entry(hlink, &bus->hlink_list, list)
 205                 snd_hdac_ext_bus_link_put(bus, hlink);
 206
 207         snd_hdac_ext_bus_ppcap_enable(bus, true);
 208         snd_hdac_ext_bus_ppcap_int_enable(bus, true);
 209
 210         ret = avs_dsp_first_boot_firmware(adev);
 211         if (ret < 0)
 212                 return;
 213
 214         adev->nhlt = intel_nhlt_init(adev->dev);
 215         if (!adev->nhlt)
 216                 dev_info(bus->dev, "platform has no NHLT\n");
 217
 218         avs_register_all_boards(adev);
 219
 220         /* configure PM */
 221         pm_runtime_set_autosuspend_delay(bus->dev, 2000);
 222         pm_runtime_use_autosuspend(bus->dev);
 223         pm_runtime_mark_last_busy(bus->dev);
 224         pm_runtime_put_autosuspend(bus->dev);
 225         pm_runtime_allow(bus->dev);
 226 }
 227
 228 static void hdac_stream_update_pos(struct hdac_stream *stream, u64 buffer_size)
 229 {
 230         u64 prev_pos, pos, num_bytes;
 231
 232         div64_u64_rem(stream->curr_pos, buffer_size, &prev_pos);
 233         pos = snd_hdac_stream_get_pos_posbuf(stream);
 234
 235         if (pos < prev_pos)
 236                 num_bytes = (buffer_size - prev_pos) +  pos;
 237         else
 238                 num_bytes = pos - prev_pos;
 239
 240         stream->curr_pos += num_bytes;
 241 }
 242
 243 /* called from IRQ */
 244 static void hdac_update_stream(struct hdac_bus *bus, struct hdac_stream *stream)
 245 {
 246         if (stream->substream) {
 247                 snd_pcm_period_elapsed(stream->substream);
 248         } else if (stream->cstream) {
 249                 u64 buffer_size = stream->cstream->runtime->buffer_size;
 250
 251                 hdac_stream_update_pos(stream, buffer_size);
 252                 snd_compr_fragment_elapsed(stream->cstream);
 253         }
 254 }
 255
 256 static irqreturn_t hdac_bus_irq_handler(int irq, void *context)
 257 {
 258         struct hdac_bus *bus = context;
 259         u32 mask, int_enable;
 260         u32 status;
 261         int ret = IRQ_NONE;
 262
 263         if (!pm_runtime_active(bus->dev))
 264                 return ret;
 265
 266         spin_lock(&bus->reg_lock);
 267
 268         status = snd_hdac_chip_readl(bus, INTSTS);
 269         if (status == 0 || status == UINT_MAX) {
 270                 spin_unlock(&bus->reg_lock);
 271                 return ret;
 272         }
 273
 274         /* clear rirb int */
 275         status = snd_hdac_chip_readb(bus, RIRBSTS);
 276         if (status & RIRB_INT_MASK) {
 277                 if (status & RIRB_INT_RESPONSE)
 278                         snd_hdac_bus_update_rirb(bus);
 279                 snd_hdac_chip_writeb(bus, RIRBSTS, RIRB_INT_MASK);
 280         }
 281
 282         mask = (0x1 << bus->num_streams) - 1;
 283
 284         status = snd_hdac_chip_readl(bus, INTSTS);
 285         status &= mask;
 286         if (status) {
 287                 /* Disable stream interrupts; Re-enable in bottom half */
 288                 int_enable = snd_hdac_chip_readl(bus, INTCTL);
 289                 snd_hdac_chip_writel(bus, INTCTL, (int_enable & (~mask)));
 290                 ret = IRQ_WAKE_THREAD;
 291         } else {
 292                 ret = IRQ_HANDLED;
 293         }
 294
 295         spin_unlock(&bus->reg_lock);
 296         return ret;
 297 }
 298
 299 static irqreturn_t hdac_bus_irq_thread(int irq, void *context)
 300 {
 301         struct hdac_bus *bus = context;
 302         u32 status;
 303         u32 int_enable;
 304         u32 mask;
 305         unsigned long flags;
 306
 307         status = snd_hdac_chip_readl(bus, INTSTS);
 308
 309         snd_hdac_bus_handle_stream_irq(bus, status, hdac_update_stream);
 310
 311         /* Re-enable stream interrupts */
 312         mask = (0x1 << bus->num_streams) - 1;
 313         spin_lock_irqsave(&bus->reg_lock, flags);
 314         int_enable = snd_hdac_chip_readl(bus, INTCTL);
 315         snd_hdac_chip_writel(bus, INTCTL, (int_enable | mask));
 316         spin_unlock_irqrestore(&bus->reg_lock, flags);
 317
 318         return IRQ_HANDLED;
 319 }
 320
 321 static int avs_hdac_acquire_irq(struct avs_dev *adev)
 322 {
 323         struct hdac_bus *bus = &adev->base.core;
 324         struct pci_dev *pci = to_pci_dev(bus->dev);
 325         int ret;
 326
 327         /* request one and check that we only got one interrupt */
 328         ret = pci_alloc_irq_vectors(pci, 1, 1, PCI_IRQ_MSI | PCI_IRQ_LEGACY);
 329         if (ret != 1) {
 330                 dev_err(adev->dev, "Failed to allocate IRQ vector: %d\n", ret);
 331                 return ret;
 332         }
 333
 334         ret = pci_request_irq(pci, 0, hdac_bus_irq_handler, hdac_bus_irq_thread, bus,
 335                               KBUILD_MODNAME);
 336         if (ret < 0) {
 337                 dev_err(adev->dev, "Failed to request stream IRQ handler: %d\n", ret);
 338                 goto free_vector;
 339         }
 340
 341         ret = pci_request_irq(pci, 0, avs_dsp_irq_handler, avs_dsp_irq_thread, adev,
 342                               KBUILD_MODNAME);
 343         if (ret < 0) {
 344                 dev_err(adev->dev, "Failed to request IPC IRQ handler: %d\n", ret);
 345                 goto free_stream_irq;
 346         }
 347
 348         return 0;
 349
 350 free_stream_irq:
 351         pci_free_irq(pci, 0, bus);
 352 free_vector:
 353         pci_free_irq_vectors(pci);
 354         return ret;
 355 }
 356
 357 static int avs_bus_init(struct avs_dev *adev, struct pci_dev *pci, const struct pci_device_id *id)
 358 {
 359         struct hda_bus *bus = &adev->base;
 360         struct avs_ipc *ipc;
 361         struct device *dev = &pci->dev;
 362         int ret;
 363
 364         ret = snd_hdac_ext_bus_init(&bus->core, dev, NULL, &soc_hda_ext_bus_ops);
 365         if (ret < 0)
 366                 return ret;
 367
 368         bus->core.use_posbuf = 1;
 369         bus->core.bdl_pos_adj = 0;
 370         bus->core.sync_write = 1;
 371         bus->pci = pci;
 372         bus->mixer_assigned = -1;
 373         mutex_init(&bus->prepare_mutex);
 374
 375         ipc = devm_kzalloc(dev, sizeof(*ipc), GFP_KERNEL);
 376         if (!ipc)
 377                 return -ENOMEM;
 378         ret = avs_ipc_init(ipc, dev);
 379         if (ret < 0)
 380                 return ret;
 381
 382         adev->dev = dev;
 383         adev->spec = (const struct avs_spec *)id->driver_data;
 384         adev->ipc = ipc;
 385         adev->hw_cfg.dsp_cores = hweight_long(AVS_MAIN_CORE_MASK);
 386         INIT_WORK(&adev->probe_work, avs_hda_probe_work);
 387         INIT_LIST_HEAD(&adev->comp_list);
 388         INIT_LIST_HEAD(&adev->path_list);
 389         INIT_LIST_HEAD(&adev->fw_list);
 390         init_completion(&adev->fw_ready);
 391         spin_lock_init(&adev->path_list_lock);
 392         mutex_init(&adev->modres_mutex);
 393         mutex_init(&adev->comp_list_mutex);
 394         mutex_init(&adev->path_mutex);
 395
 396         return 0;
 397 }
 398
 399 static int avs_pci_probe(struct pci_dev *pci, const struct pci_device_id *id)
 400 {
 401         struct hdac_bus *bus;
 402         struct avs_dev *adev;
 403         struct device *dev = &pci->dev;
 404         int ret;
 405
 406         ret = snd_intel_dsp_driver_probe(pci);
 407         if (ret != SND_INTEL_DSP_DRIVER_ANY && ret != SND_INTEL_DSP_DRIVER_AVS)
 408                 return -ENODEV;
 409
 410         ret = pcim_enable_device(pci);
 411         if (ret < 0)
 412                 return ret;
 413
 414         adev = devm_kzalloc(dev, sizeof(*adev), GFP_KERNEL);
 415         if (!adev)
 416                 return -ENOMEM;
 417         ret = avs_bus_init(adev, pci, id);
 418         if (ret < 0) {
 419                 dev_err(dev, "failed to init avs bus: %d\n", ret);
 420                 return ret;
 421         }
 422
 423         ret = pci_request_regions(pci, "AVS HDAudio");
 424         if (ret < 0)
 425                 return ret;
 426
 427         bus = &adev->base.core;
 428         bus->addr = pci_resource_start(pci, 0);
 429         bus->remap_addr = pci_ioremap_bar(pci, 0);
 430         if (!bus->remap_addr) {
 431                 dev_err(bus->dev, "ioremap error\n");
 432                 ret = -ENXIO;
 433                 goto err_remap_bar0;
 434         }
 435
 436         adev->dsp_ba = pci_ioremap_bar(pci, 4);
 437         if (!adev->dsp_ba) {
 438                 dev_err(bus->dev, "ioremap error\n");
 439                 ret = -ENXIO;
 440                 goto err_remap_bar4;
 441         }
 442
 443         snd_hdac_bus_parse_capabilities(bus);
 444         if (bus->mlcap)
 445                 snd_hdac_ext_bus_get_ml_capabilities(bus);
 446
 447         if (dma_set_mask_and_coherent(dev, DMA_BIT_MASK(64)))
 448                 dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32));
 449         dma_set_max_seg_size(dev, UINT_MAX);
 450
 451         ret = avs_hdac_bus_init_streams(bus);
 452         if (ret < 0) {
 453                 dev_err(dev, "failed to init streams: %d\n", ret);
 454                 goto err_init_streams;
 455         }
 456
 457         ret = avs_hdac_acquire_irq(adev);
 458         if (ret < 0) {
 459                 dev_err(bus->dev, "failed to acquire irq: %d\n", ret);
 460                 goto err_acquire_irq;
 461         }
 462
 463         pci_set_master(pci);
 464         pci_set_drvdata(pci, bus);
 465         device_disable_async_suspend(dev);
 466
 467         schedule_work(&adev->probe_work);
 468
 469         return 0;
 470
 471 err_acquire_irq:
 472         snd_hdac_bus_free_stream_pages(bus);
 473         snd_hdac_ext_stream_free_all(bus);
 474 err_init_streams:
 475         iounmap(adev->dsp_ba);
 476 err_remap_bar4:
 477         iounmap(bus->remap_addr);
 478 err_remap_bar0:
 479         pci_release_regions(pci);
 480         return ret;
 481 }
 482
 483 static void avs_pci_remove(struct pci_dev *pci)
 484 {
 485         struct hdac_device *hdev, *save;
 486         struct hdac_bus *bus = pci_get_drvdata(pci);
 487         struct avs_dev *adev = hdac_to_avs(bus);
 488
 489         cancel_work_sync(&adev->probe_work);
 490         avs_ipc_block(adev->ipc);
 491
 492         avs_unregister_all_boards(adev);
 493
 494         if (adev->nhlt)
 495                 intel_nhlt_free(adev->nhlt);
 496
 497         if (avs_platattr_test(adev, CLDMA))
 498                 hda_cldma_free(&code_loader);
 499
 500         snd_hdac_stop_streams_and_chip(bus);
 501         avs_dsp_op(adev, int_control, false);
 502         snd_hdac_ext_bus_ppcap_int_enable(bus, false);
 503
 504         /* it is safe to remove all codecs from the system now */
 505         list_for_each_entry_safe(hdev, save, &bus->codec_list, list)
 506                 snd_hda_codec_unregister(hdac_to_hda_codec(hdev));
 507
 508         snd_hdac_bus_free_stream_pages(bus);
 509         snd_hdac_ext_stream_free_all(bus);
 510         /* reverse ml_capabilities */
 511         snd_hdac_ext_link_free_all(bus);
 512         snd_hdac_ext_bus_exit(bus);
 513
 514         avs_dsp_core_disable(adev, GENMASK(adev->hw_cfg.dsp_cores - 1, 0));
 515         snd_hdac_ext_bus_ppcap_enable(bus, false);
 516
 517         /* snd_hdac_stop_streams_and_chip does that already? */
 518         snd_hdac_bus_stop_chip(bus);
 519         snd_hdac_display_power(bus, HDA_CODEC_IDX_CONTROLLER, false);
 520         if (bus->audio_component)
 521                 snd_hdac_i915_exit(bus);
 522
 523         avs_module_info_free(adev);
 524         pci_free_irq(pci, 0, adev);
 525         pci_free_irq(pci, 0, bus);
 526         pci_free_irq_vectors(pci);
 527         iounmap(bus->remap_addr);
 528         iounmap(adev->dsp_ba);
 529         pci_release_regions(pci);
 530
 531         /* Firmware is not needed anymore */
 532         avs_release_firmwares(adev);
 533
 534         /* pm_runtime_forbid() can rpm_resume() which we do not want */
 535         pm_runtime_disable(&pci->dev);
 536         pm_runtime_forbid(&pci->dev);
 537         pm_runtime_enable(&pci->dev);
 538         pm_runtime_get_noresume(&pci->dev);
 539 }
 540
 541 static int avs_suspend_standby(struct avs_dev *adev)
 542 {
 543         struct hdac_bus *bus = &adev->base.core;
 544         struct pci_dev *pci = adev->base.pci;
 545
 546         if (bus->cmd_dma_state)
 547                 snd_hdac_bus_stop_cmd_io(bus);
 548
 549         snd_hdac_ext_bus_link_power_down_all(bus);
 550
 551         enable_irq_wake(pci->irq);
 552         pci_save_state(pci);
 553
 554         return 0;
 555 }
 556
 557 static int __maybe_unused avs_suspend_common(struct avs_dev *adev, bool low_power)
 558 {
 559         struct hdac_bus *bus = &adev->base.core;
 560         int ret;
 561
 562         flush_work(&adev->probe_work);
 563         if (low_power && adev->num_lp_paths)
 564                 return avs_suspend_standby(adev);
 565
 566         snd_hdac_ext_bus_link_power_down_all(bus);
 567
 568         ret = avs_ipc_set_dx(adev, AVS_MAIN_CORE_MASK, false);
 569         /*
 570          * pm_runtime is blocked on DSP failure but system-wide suspend is not.
 571          * Do not block entire system from suspending if that's the case.
 572          */
 573         if (ret && ret != -EPERM) {
 574                 dev_err(adev->dev, "set dx failed: %d\n", ret);
 575                 return AVS_IPC_RET(ret);
 576         }
 577
 578         avs_ipc_block(adev->ipc);
 579         avs_dsp_op(adev, int_control, false);
 580         snd_hdac_ext_bus_ppcap_int_enable(bus, false);
 581
 582         ret = avs_dsp_core_disable(adev, AVS_MAIN_CORE_MASK);
 583         if (ret < 0) {
 584                 dev_err(adev->dev, "core_mask %ld disable failed: %d\n", AVS_MAIN_CORE_MASK, ret);
 585                 return ret;
 586         }
 587
 588         snd_hdac_ext_bus_ppcap_enable(bus, false);
 589         /* disable LP SRAM retention */
 590         avs_hda_power_gating_enable(adev, false);
 591         snd_hdac_bus_stop_chip(bus);
 592         /* disable CG when putting controller to reset */
 593         avs_hdac_clock_gating_enable(bus, false);
 594         snd_hdac_bus_enter_link_reset(bus);
 595         avs_hdac_clock_gating_enable(bus, true);
 596
 597         snd_hdac_display_power(bus, HDA_CODEC_IDX_CONTROLLER, false);
 598
 599         return 0;
 600 }
 601
 602 static int avs_resume_standby(struct avs_dev *adev)
 603 {
 604         struct hdac_bus *bus = &adev->base.core;
 605         struct pci_dev *pci = adev->base.pci;
 606
 607         pci_restore_state(pci);
 608         disable_irq_wake(pci->irq);
 609
 610         snd_hdac_ext_bus_link_power_up_all(bus);
 611
 612         if (bus->cmd_dma_state)
 613                 snd_hdac_bus_init_cmd_io(bus);
 614
 615         return 0;
 616 }
 617
 618 static int __maybe_unused avs_resume_common(struct avs_dev *adev, bool low_power, bool purge)
 619 {
 620         struct hdac_bus *bus = &adev->base.core;
 621         int ret;
 622
 623         if (low_power && adev->num_lp_paths)
 624                 return avs_resume_standby(adev);
 625
 626         snd_hdac_display_power(bus, HDA_CODEC_IDX_CONTROLLER, true);
 627         avs_hdac_bus_init_chip(bus, true);
 628
 629         snd_hdac_ext_bus_ppcap_enable(bus, true);
 630         snd_hdac_ext_bus_ppcap_int_enable(bus, true);
 631
 632         ret = avs_dsp_boot_firmware(adev, purge);
 633         if (ret < 0) {
 634                 dev_err(adev->dev, "firmware boot failed: %d\n", ret);
 635                 return ret;
 636         }
 637
 638         return 0;
 639 }
 640
 641 static int __maybe_unused avs_suspend(struct device *dev)
 642 {
 643         return avs_suspend_common(to_avs_dev(dev), true);
 644 }
 645
 646 static int __maybe_unused avs_resume(struct device *dev)
 647 {
 648         return avs_resume_common(to_avs_dev(dev), true, true);
 649 }
 650
 651 static int __maybe_unused avs_runtime_suspend(struct device *dev)
 652 {
 653         return avs_suspend_common(to_avs_dev(dev), true);
 654 }
 655
 656 static int __maybe_unused avs_runtime_resume(struct device *dev)
 657 {
 658         return avs_resume_common(to_avs_dev(dev), true, false);
 659 }
 660
 661 static int __maybe_unused avs_freeze(struct device *dev)
 662 {
 663         return avs_suspend_common(to_avs_dev(dev), false);
 664 }
 665 static int __maybe_unused avs_thaw(struct device *dev)
 666 {
 667         return avs_resume_common(to_avs_dev(dev), false, true);
 668 }
 669
 670 static int __maybe_unused avs_poweroff(struct device *dev)
 671 {
 672         return avs_suspend_common(to_avs_dev(dev), false);
 673 }
 674
 675 static int __maybe_unused avs_restore(struct device *dev)
 676 {
 677         return avs_resume_common(to_avs_dev(dev), false, true);
 678 }
 679
 680 static const struct dev_pm_ops avs_dev_pm = {
 681         .suspend = avs_suspend,
 682         .resume = avs_resume,
 683         .freeze = avs_freeze,
 684         .thaw = avs_thaw,
 685         .poweroff = avs_poweroff,
 686         .restore = avs_restore,
 687         SET_RUNTIME_PM_OPS(avs_runtime_suspend, avs_runtime_resume, NULL)
 688 };
 689
 690 static const struct avs_spec skl_desc = {
 691         .name = "skl",
 692         .min_fw_version = {
 693                 .major = 9,
 694                 .minor = 21,
 695                 .hotfix = 0,
 696                 .build = 4732,
 697         },
 698         .dsp_ops = &skl_dsp_ops,
 699         .core_init_mask = 1,
 700         .attributes = AVS_PLATATTR_CLDMA,
 701         .sram_base_offset = SKL_ADSP_SRAM_BASE_OFFSET,
 702         .sram_window_size = SKL_ADSP_SRAM_WINDOW_SIZE,
 703         .rom_status = SKL_ADSP_SRAM_BASE_OFFSET,
 704 };
 705
 706 static const struct avs_spec apl_desc = {
 707         .name = "apl",
 708         .min_fw_version = {
 709                 .major = 9,
 710                 .minor = 22,
 711                 .hotfix = 1,
 712                 .build = 4323,
 713         },
 714         .dsp_ops = &apl_dsp_ops,
 715         .core_init_mask = 3,
 716         .attributes = AVS_PLATATTR_IMR,
 717         .sram_base_offset = APL_ADSP_SRAM_BASE_OFFSET,
 718         .sram_window_size = APL_ADSP_SRAM_WINDOW_SIZE,
 719         .rom_status = APL_ADSP_SRAM_BASE_OFFSET,
 720 };
 721
 722 static const struct pci_device_id avs_ids[] = {
 723         { PCI_VDEVICE(INTEL, 0x9d70), (unsigned long)&skl_desc }, /* SKL */
 724         { PCI_VDEVICE(INTEL, 0xa170), (unsigned long)&skl_desc }, /* SKL-H */
 725         { PCI_VDEVICE(INTEL, 0x9d71), (unsigned long)&skl_desc }, /* KBL */
 726         { PCI_VDEVICE(INTEL, 0xa171), (unsigned long)&skl_desc }, /* KBL-H */
 727         { PCI_VDEVICE(INTEL, 0xa2f0), (unsigned long)&skl_desc }, /* KBL-S */
 728         { PCI_VDEVICE(INTEL, 0xa3f0), (unsigned long)&skl_desc }, /* CML-V */
 729         { PCI_VDEVICE(INTEL, 0x5a98), (unsigned long)&apl_desc }, /* APL */
 730         { PCI_VDEVICE(INTEL, 0x3198), (unsigned long)&apl_desc }, /* GML */
 731         { 0 }
 732 };
 733 MODULE_DEVICE_TABLE(pci, avs_ids);
 734
 735 static struct pci_driver avs_pci_driver = {
 736         .name = KBUILD_MODNAME,
 737         .id_table = avs_ids,
 738         .probe = avs_pci_probe,
 739         .remove = avs_pci_remove,
 740         .driver = {
 741                 .pm = &avs_dev_pm,
 742         },
 743 };
 744 module_pci_driver(avs_pci_driver);
 745
 746 MODULE_AUTHOR("Cezary Rojewski <cezary.rojewski@intel.com>");
 747 MODULE_AUTHOR("Amadeusz Slawinski <amadeuszx.slawinski@linux.intel.com>");
 748 MODULE_DESCRIPTION("Intel cAVS sound driver");
 749 MODULE_LICENSE("GPL");