linux/sound/soc/intel/avs/core.c

// SPDX-License-Identifier: GPL-2.0-only
//
// Copyright(c) 2021-2022 Intel Corporation
//
// Authors: Cezary Rojewski <[email protected]>
//          Amadeusz Slawinski <[email protected]>
//
// Special thanks to:
//    Krzysztof Hejmowski <[email protected]>
//    Michal Sienkiewicz <[email protected]>
//    Filip Proborszcz
//
// for sharing Intel AudioDSP expertise and helping shape the very
// foundation of this driver
//

#include <linux/acpi.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <acpi/nhlt.h>
#include <sound/hda_codec.h>
#include <sound/hda_i915.h>
#include <sound/hda_register.h>
#include <sound/hdaudio.h>
#include <sound/hdaudio_ext.h>
#include <sound/intel-dsp-config.h>
#include "../../codecs/hda.h"
#include "avs.h"
#include "cldma.h"
#include "messages.h"
#include "pcm.h"

static u32 pgctl_mask = …;
module_param(pgctl_mask, uint, 0444);
MODULE_PARM_DESC(…) …;

static u32 cgctl_mask = …;
module_param(cgctl_mask, uint, 0444);
MODULE_PARM_DESC(…) …;

static void
avs_hda_update_config_dword(struct hdac_bus *bus, u32 reg, u32 mask, u32 value)
{ … }

void avs_hda_power_gating_enable(struct avs_dev *adev, bool enable)
{ … }

static void avs_hdac_clock_gating_enable(struct hdac_bus *bus, bool enable)
{ … }

void avs_hda_clock_gating_enable(struct avs_dev *adev, bool enable)
{ … }

void avs_hda_l1sen_enable(struct avs_dev *adev, bool enable)
{ … }

static int avs_hdac_bus_init_streams(struct hdac_bus *bus)
{ … }

static bool avs_hdac_bus_init_chip(struct hdac_bus *bus, bool full_reset)
{ … }

static int probe_codec(struct hdac_bus *bus, int addr)
{ … }

static void avs_hdac_bus_probe_codecs(struct hdac_bus *bus)
{ … }

static void avs_hda_probe_work(struct work_struct *work)
{ … }

static void hdac_stream_update_pos(struct hdac_stream *stream, u64 buffer_size)
{ … }

/* called from IRQ */
static void hdac_update_stream(struct hdac_bus *bus, struct hdac_stream *stream)
{ … }

static irqreturn_t avs_hda_interrupt(struct hdac_bus *bus)
{ … }

static irqreturn_t avs_hda_irq_handler(int irq, void *dev_id)
{ … }

static irqreturn_t avs_hda_irq_thread(int irq, void *dev_id)
{ … }

static irqreturn_t avs_dsp_irq_handler(int irq, void *dev_id)
{ … }

static irqreturn_t avs_dsp_irq_thread(int irq, void *dev_id)
{ … }

static int avs_hdac_acquire_irq(struct avs_dev *adev)
{ … }

static int avs_bus_init(struct avs_dev *adev, struct pci_dev *pci, const struct pci_device_id *id)
{ … }

static int avs_pci_probe(struct pci_dev *pci, const struct pci_device_id *id)
{ … }

static void avs_pci_shutdown(struct pci_dev *pci)
{ … }

static void avs_pci_remove(struct pci_dev *pci)
{ … }

static int avs_suspend_standby(struct avs_dev *adev)
{ … }

static int __maybe_unused avs_suspend_common(struct avs_dev *adev, bool low_power)
{ … }

static int avs_resume_standby(struct avs_dev *adev)
{ … }

static int __maybe_unused avs_resume_common(struct avs_dev *adev, bool low_power, bool purge)
{ … }

static int __maybe_unused avs_suspend(struct device *dev)
{ … }

static int __maybe_unused avs_resume(struct device *dev)
{ … }

static int __maybe_unused avs_runtime_suspend(struct device *dev)
{ … }

static int __maybe_unused avs_runtime_resume(struct device *dev)
{ … }

static int __maybe_unused avs_freeze(struct device *dev)
{ … }
static int __maybe_unused avs_thaw(struct device *dev)
{ … }

static int __maybe_unused avs_poweroff(struct device *dev)
{ … }

static int __maybe_unused avs_restore(struct device *dev)
{ … }

static const struct dev_pm_ops avs_dev_pm = …;

static const struct avs_sram_spec skl_sram_spec = …;

static const struct avs_sram_spec apl_sram_spec = …;

static const struct avs_hipc_spec skl_hipc_spec = …;

static const struct avs_hipc_spec cnl_hipc_spec = …;

static const struct avs_spec skl_desc = …;

static const struct avs_spec apl_desc = …;

static const struct avs_spec cnl_desc = …;

static const struct avs_spec icl_desc = …;

static const struct avs_spec jsl_desc = …;

#define AVS_TGL_BASED_SPEC(sname) …

AVS_TGL_BASED_SPEC(lkf);
AVS_TGL_BASED_SPEC(tgl);
AVS_TGL_BASED_SPEC(ehl);
AVS_TGL_BASED_SPEC(adl);
AVS_TGL_BASED_SPEC(adl_n);

static const struct pci_device_id avs_ids[] = …;
MODULE_DEVICE_TABLE(pci, avs_ids);

static struct pci_driver avs_pci_driver = …;
module_pci_driver(…) …;

MODULE_AUTHOR(…) …;
MODULE_AUTHOR(…) …;
MODULE_DESCRIPTION(…) …;
MODULE_LICENSE(…) …;