* [PATCH 01/13] ASoC: Intel: Add catpt device
2020-08-07 11:06 [PATCH 00/13] ASoC: Intel: Catpt - Lynx and Wildcat point Cezary Rojewski
@ 2020-08-07 11:06 ` Cezary Rojewski
2020-08-08 11:50 ` Andy Shevchenko
2020-08-07 11:06 ` [PATCH 02/13] ASoC: Intel: catpt: Define DSP operations Cezary Rojewski
` (13 subsequent siblings)
14 siblings, 1 reply; 24+ messages in thread
From: Cezary Rojewski @ 2020-08-07 11:06 UTC (permalink / raw)
To: alsa-devel
Cc: pierre-louis.bossart, Cezary Rojewski, andriy.shevchenko,
filip.kaczmarski, harshapriya.n, marcin.barlik, zwisler,
lgirdwood, tiwai, filip.proborszcz, broonie, michal.wasko,
cujomalainey, ppapierkowski, vamshi.krishna.gopal
Declare base structures, registers and device routines for the catpt
solution. Catpt deprecates and is a direct replacement for
sound/soc/intel/haswell. Supports Lynxpoint and Wildcat Point both.
Signed-off-by: Cezary Rojewski <cezary.rojewski@intel.com>
---
sound/soc/intel/catpt/core.h | 224 +++++++++++++++++
sound/soc/intel/catpt/device.c | 389 ++++++++++++++++++++++++++++++
sound/soc/intel/catpt/registers.h | 191 +++++++++++++++
3 files changed, 804 insertions(+)
create mode 100644 sound/soc/intel/catpt/core.h
create mode 100644 sound/soc/intel/catpt/device.c
create mode 100644 sound/soc/intel/catpt/registers.h
diff --git a/sound/soc/intel/catpt/core.h b/sound/soc/intel/catpt/core.h
new file mode 100644
index 000000000000..184ae1ae22ae
--- /dev/null
+++ b/sound/soc/intel/catpt/core.h
@@ -0,0 +1,224 @@
+/* SPDX-License-Identifier: GPL-2.0-only
+ *
+ * Copyright(c) 2020 Intel Corporation. All rights reserved.
+ *
+ * Author: Cezary Rojewski <cezary.rojewski@intel.com>
+ */
+
+#ifndef __SND_SOC_INTEL_CATPT_CORE_H
+#define __SND_SOC_INTEL_CATPT_CORE_H
+
+#include <linux/dma/dw.h>
+#include <linux/irqreturn.h>
+#include "messages.h"
+#include "registers.h"
+
+struct catpt_mbank {
+ u32 start;
+ u32 end;
+ u32 mask;
+ struct mutex mutex;
+ struct list_head region_list;
+};
+
+static inline size_t catpt_mbank_size(const struct catpt_mbank *sram)
+{
+ return sram->end - sram->start + 1;
+}
+
+struct catpt_mregion {
+ u32 start;
+ u32 end;
+ bool busy;
+ struct list_head node;
+};
+
+static inline size_t catpt_mregion_size(const struct catpt_mregion *reg)
+{
+ return reg->end - reg->start + 1;
+}
+
+/* True if region r1 intersects region r2 */
+static inline bool catpt_mregion_intersects(struct catpt_mregion *r1,
+ struct catpt_mregion *r2)
+{
+ return (r1->start >= r2->start && r1->start <= r2->end) ||
+ (r1->end >= r2->start && r1->end <= r2->end);
+}
+
+static inline bool catpt_mregion_intersecting(struct catpt_mregion *r1,
+ struct catpt_mregion *r2,
+ struct catpt_mregion *ret)
+{
+ if (!catpt_mregion_intersects(r1, r2))
+ return false;
+ ret->start = max(r1->start, r2->start);
+ ret->end = min(r1->end, r2->end);
+ return true;
+}
+
+int catpt_mbank_create(struct catpt_mbank *sram, u32 start, u32 size, u32 mask);
+void catpt_mbank_remove(struct catpt_mbank *sram);
+
+struct catpt_mregion *
+catpt_mbank_request_region(struct catpt_mbank *sram, u32 size);
+struct catpt_mregion *
+catpt_mbank_reserve_region(struct catpt_mbank *sram, u32 start, u32 size);
+void catpt_mbank_release_region(struct catpt_mbank *sram,
+ struct catpt_mregion *region);
+
+struct catpt_ipc_msg {
+ union {
+ u32 header;
+ union catpt_global_msg rsp;
+ };
+ void *data;
+ size_t size;
+};
+
+struct catpt_ipc {
+ struct device *dev;
+
+ struct catpt_ipc_msg rx;
+ struct catpt_fw_ready config;
+ u32 default_timeout;
+ bool ready;
+
+ spinlock_t lock;
+ struct mutex mutex;
+ struct completion done_completion;
+ struct completion busy_completion;
+};
+
+void catpt_ipc_init(struct catpt_ipc *ipc, struct device *dev);
+
+struct catpt_module_type {
+ bool loaded;
+ u32 entry_point;
+ u32 persistent_size;
+ u32 scratch_size;
+ /* DRAM, initial module state */
+ u32 state_offset;
+ u32 state_size;
+
+ struct list_head node;
+};
+
+struct catpt_pdata {
+ struct snd_soc_acpi_mach *machines;
+ u8 core_id;
+ u32 host_dram_offset;
+ u32 host_iram_offset;
+ u32 host_shim_offset;
+ u32 host_dma_offset[CATPT_DMA_COUNT];
+ u32 host_ssp_offset[CATPT_SSP_COUNT];
+ u32 dram_mask;
+ u32 iram_mask;
+ void (*pll_shutdown)(struct catpt_dev *cdev, bool enable);
+ int (*power_up)(struct catpt_dev *cdev);
+ int (*power_down)(struct catpt_dev *cdev);
+};
+
+struct catpt_dev {
+ struct device *dev;
+ struct dw_dma_chip *dmac;
+ struct catpt_ipc ipc;
+
+ void __iomem *pci_ba;
+ void __iomem *lpe_ba;
+ u32 lpe_base;
+ int irq;
+
+ const struct catpt_pdata *pdata;
+ struct completion fw_ready;
+
+ struct catpt_mbank dram;
+ struct catpt_mbank iram;
+ struct catpt_mregion *scratch;
+
+ struct catpt_mixer_stream_info mixer;
+ struct catpt_module_type modules[CATPT_MODULE_COUNT];
+ struct catpt_ssp_device_format devfmt[CATPT_SSP_COUNT];
+ struct list_head stream_list;
+ spinlock_t list_lock;
+ struct mutex clk_mutex;
+
+ struct catpt_dx_context dx_ctx;
+ void *dxbuf_vaddr;
+ dma_addr_t dxbuf_paddr;
+};
+
+int catpt_dmac_probe(struct catpt_dev *cdev);
+void catpt_dmac_remove(struct catpt_dev *cdev);
+struct dma_chan *catpt_dma_request_config_chan(struct catpt_dev *cdev);
+int catpt_dma_memcpy_todsp(struct catpt_dev *cdev, struct dma_chan *chan,
+ dma_addr_t dst_addr, dma_addr_t src_addr,
+ size_t size);
+int catpt_dma_memcpy_fromdsp(struct catpt_dev *cdev, struct dma_chan *chan,
+ dma_addr_t dst_addr, dma_addr_t src_addr,
+ size_t size);
+
+void lpt_dsp_pll_shutdown(struct catpt_dev *cdev, bool enable);
+void wpt_dsp_pll_shutdown(struct catpt_dev *cdev, bool enable);
+int lpt_dsp_power_up(struct catpt_dev *cdev);
+int lpt_dsp_power_down(struct catpt_dev *cdev);
+int wpt_dsp_power_up(struct catpt_dev *cdev);
+int wpt_dsp_power_down(struct catpt_dev *cdev);
+int catpt_dsp_stall(struct catpt_dev *cdev, bool stall);
+void catpt_dsp_update_srampge(struct catpt_dev *cdev, struct catpt_mbank *sram);
+int catpt_dsp_update_lpclock(struct catpt_dev *cdev);
+irqreturn_t catpt_dsp_irq_handler(int irq, void *dev_id);
+irqreturn_t catpt_dsp_irq_thread(int irq, void *dev_id);
+
+/*
+ * IPC handlers may return positive values which denote successful
+ * HOST <-> DSP communication yet failure to process specific request.
+ * Use below macro to convert returned non-zero values appropriately
+ */
+#define CATPT_IPC_ERROR(err) ((err < 0) ? err : -EREMOTEIO)
+
+int catpt_dsp_send_msg_timeout(struct catpt_dev *cdev,
+ struct catpt_ipc_msg request,
+ struct catpt_ipc_msg *reply, int timeout);
+int catpt_dsp_send_msg(struct catpt_dev *cdev, struct catpt_ipc_msg request,
+ struct catpt_ipc_msg *reply);
+
+int catpt_first_boot_firmware(struct catpt_dev *cdev);
+int catpt_boot_firmware(struct catpt_dev *cdev, bool restore);
+int catpt_store_streams_context(struct catpt_dev *cdev, struct dma_chan *chan);
+int catpt_store_module_states(struct catpt_dev *cdev, struct dma_chan *chan);
+int catpt_store_memdumps(struct catpt_dev *cdev, struct dma_chan *chan);
+int catpt_coredump(struct catpt_dev *cdev);
+
+int catpt_sysfs_create(struct catpt_dev *cdev);
+void catpt_sysfs_remove(struct catpt_dev *cdev);
+
+#include <sound/memalloc.h>
+#include <uapi/sound/asound.h>
+
+struct snd_pcm_substream;
+struct catpt_stream_template;
+
+struct catpt_stream_runtime {
+ struct snd_pcm_substream *substream;
+
+ struct catpt_stream_template *template;
+ struct catpt_stream_info info;
+ struct catpt_mregion *persistent;
+ struct snd_dma_buffer pgtbl;
+
+ bool allocated:1;
+ bool prepared:1;
+
+ struct list_head node;
+};
+
+int catpt_register_plat_component(struct catpt_dev *cdev);
+void catpt_stream_update_position(struct catpt_dev *cdev,
+ struct catpt_stream_runtime *stream,
+ struct catpt_notify_position *pos);
+struct catpt_stream_runtime *
+catpt_stream_find(struct catpt_dev *cdev, u8 stream_hw_id);
+int catpt_arm_stream_templates(struct catpt_dev *cdev);
+
+#endif
diff --git a/sound/soc/intel/catpt/device.c b/sound/soc/intel/catpt/device.c
new file mode 100644
index 000000000000..2e880a320def
--- /dev/null
+++ b/sound/soc/intel/catpt/device.c
@@ -0,0 +1,389 @@
+// SPDX-License-Identifier: GPL-2.0-only
+//
+// Copyright(c) 2020 Intel Corporation. All rights reserved.
+//
+// Author: Cezary Rojewski <cezary.rojewski@intel.com>
+//
+// Special thanks to:
+// Marcin Barlik <marcin.barlik@intel.com>
+// Piotr Papierkowski <piotr.papierkowski@intel.com>
+//
+// for sharing LPT-LP and WTP-LP AudioDSP architecture expertise and
+// helping backtrack its historical background
+//
+
+#include <linux/acpi.h>
+#include <linux/dma-mapping.h>
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/pm_runtime.h>
+#include <sound/soc.h>
+#include <sound/soc-acpi.h>
+#include <sound/soc-acpi-intel-match.h>
+#include "core.h"
+#include "registers.h"
+
+#define CREATE_TRACE_POINTS
+#include "trace.h"
+
+#ifdef CONFIG_PM
+static int catpt_suspend(struct device *dev)
+{
+ struct catpt_dev *cdev = dev_get_drvdata(dev);
+ struct dma_chan *chan;
+ int ret;
+
+ chan = catpt_dma_request_config_chan(cdev);
+ if (IS_ERR(chan))
+ return PTR_ERR(chan);
+
+ memset(&cdev->dx_ctx, 0, sizeof(cdev->dx_ctx));
+ ret = catpt_ipc_enter_dxstate(cdev, CATPT_DX_STATE_D3, &cdev->dx_ctx);
+ if (ret) {
+ ret = CATPT_IPC_ERROR(ret);
+ goto exit;
+ }
+
+ ret = catpt_dsp_stall(cdev, true);
+ if (ret < 0)
+ goto exit;
+
+ ret = catpt_store_memdumps(cdev, chan);
+ if (ret < 0) {
+ dev_err(cdev->dev, "store memdumps failed: %d\n", ret);
+ goto exit;
+ }
+
+ ret = catpt_store_module_states(cdev, chan);
+ if (ret < 0) {
+ dev_err(cdev->dev, "store module states failed: %d\n", ret);
+ goto exit;
+ }
+
+ ret = catpt_store_streams_context(cdev, chan);
+ if (ret < 0) {
+ dev_err(cdev->dev, "store streams ctx failed: %d\n", ret);
+ goto exit;
+ }
+exit:
+ dma_release_channel(chan);
+ if (ret < 0)
+ return ret;
+ return cdev->pdata->power_down(cdev);
+}
+
+static int catpt_resume(struct device *dev)
+{
+ struct catpt_dev *cdev = dev_get_drvdata(dev);
+ int ret, i;
+
+ ret = cdev->pdata->power_up(cdev);
+ if (ret < 0)
+ return ret;
+
+ if (!module_is_live(dev->driver->owner)) {
+ dev_info(dev, "module unloading, skipping fw boot\n");
+ return 0;
+ }
+
+ ret = catpt_boot_firmware(cdev, true);
+ if (ret < 0) {
+ dev_err(cdev->dev, "boot firmware failed: %d\n", ret);
+ return ret;
+ }
+
+ /* reconfigure SSP devices after dx transition */
+ for (i = 0; i < CATPT_SSP_COUNT; i++) {
+ if (cdev->devfmt[i].iface == UINT_MAX)
+ continue;
+
+ ret = catpt_ipc_set_device_format(cdev, &cdev->devfmt[i]);
+ if (ret)
+ return CATPT_IPC_ERROR(ret);
+ }
+
+ return 0;
+}
+#endif
+
+#ifdef CONFIG_PM_SLEEP
+static int catpt_runtime_suspend(struct device *dev)
+{
+ return catpt_suspend(dev);
+}
+
+static int catpt_runtime_resume(struct device *dev)
+{
+ return catpt_resume(dev);
+}
+#endif
+
+static const struct dev_pm_ops catpt_dev_pm = {
+ SET_SYSTEM_SLEEP_PM_OPS(catpt_suspend, catpt_resume)
+ SET_RUNTIME_PM_OPS(catpt_runtime_suspend, catpt_runtime_resume, NULL)
+};
+
+/* machine board owned by CATPT is removed with this hook */
+static void board_pdev_unregister(void *data)
+{
+ platform_device_unregister(data);
+}
+
+static int catpt_register_board(struct catpt_dev *cdev)
+{
+ const struct catpt_pdata *pdata = cdev->pdata;
+ struct snd_soc_acpi_mach *mach;
+ struct platform_device *board;
+ int ret;
+
+ mach = snd_soc_acpi_find_machine(pdata->machines);
+ if (!mach) {
+ dev_info(cdev->dev, "no machines present\n");
+ return 0;
+ }
+
+ mach->mach_params.platform = "catpt-platform";
+ board = platform_device_register_data(NULL, mach->drv_name,
+ PLATFORM_DEVID_NONE,
+ (const void *)mach, sizeof(*mach));
+ if (!board) {
+ dev_err(cdev->dev, "board register failed\n");
+ return PTR_ERR(board);
+ }
+
+ ret = devm_add_action(cdev->dev, board_pdev_unregister, board);
+ if (ret < 0) {
+ platform_device_unregister(board);
+ return ret;
+ }
+
+ return 0;
+}
+
+static int catpt_probe_components(struct catpt_dev *cdev)
+{
+ int ret;
+
+ ret = cdev->pdata->power_up(cdev);
+ if (ret < 0)
+ return ret;
+
+ ret = catpt_dmac_probe(cdev);
+ if (ret < 0) {
+ dev_err(cdev->dev, "DMAC probe failed: %d\n", ret);
+ goto dmac_err;
+ }
+
+ ret = catpt_first_boot_firmware(cdev);
+ if (ret < 0) {
+ dev_err(cdev->dev, "first fw boot failed: %d\n", ret);
+ goto boot_fw_err;
+ }
+
+ ret = catpt_register_plat_component(cdev);
+ if (ret < 0) {
+ dev_err(cdev->dev, "register plat comp failed: %d\n", ret);
+ goto boot_fw_err;
+ }
+
+ ret = catpt_register_board(cdev);
+ if (ret < 0) {
+ dev_err(cdev->dev, "register board failed: %d\n", ret);
+ goto board_err;
+ }
+
+ ret = catpt_sysfs_create(cdev);
+ if (ret < 0)
+ goto board_err;
+
+ /* reflect actual ADSP state in pm_runtime */
+ pm_runtime_set_active(cdev->dev);
+
+ pm_runtime_set_autosuspend_delay(cdev->dev, 2000);
+ pm_runtime_use_autosuspend(cdev->dev);
+ pm_runtime_mark_last_busy(cdev->dev);
+ pm_runtime_enable(cdev->dev);
+ return 0;
+
+board_err:
+ snd_soc_unregister_component(cdev->dev);
+boot_fw_err:
+ catpt_dmac_remove(cdev);
+dmac_err:
+ cdev->pdata->power_down(cdev);
+
+ return ret;
+}
+
+static void catpt_dev_init(struct catpt_dev *cdev, struct device *dev)
+{
+ cdev->dev = dev;
+ init_completion(&cdev->fw_ready);
+ INIT_LIST_HEAD(&cdev->stream_list);
+ spin_lock_init(&cdev->list_lock);
+ mutex_init(&cdev->clk_mutex);
+ /*
+ * Mark both device formats as uninitialized. Once corresponding
+ * cpu_dai's pcm is created, proper values are assigned
+ */
+ cdev->devfmt[CATPT_SSP_IFACE_0].iface = UINT_MAX;
+ cdev->devfmt[CATPT_SSP_IFACE_1].iface = UINT_MAX;
+
+ catpt_ipc_init(&cdev->ipc, dev);
+}
+
+static int catpt_acpi_probe(struct platform_device *pdev)
+{
+ struct device *dev = &pdev->dev;
+ struct catpt_dev *cdev;
+ struct resource *res;
+ int ret;
+
+ cdev = devm_kzalloc(dev, sizeof(*cdev), GFP_KERNEL);
+ if (!cdev)
+ return -ENOMEM;
+
+ catpt_dev_init(cdev, dev);
+
+ cdev->pdata = device_get_match_data(dev);
+ if (!cdev->pdata)
+ return -ENODEV;
+
+ /* map DSP bar address */
+ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ if (!res)
+ return -ENODEV;
+ cdev->lpe_ba = devm_ioremap(dev, res->start, resource_size(res));
+ if (!cdev->lpe_ba)
+ return -EIO;
+ cdev->lpe_base = res->start;
+
+ /* map PCI bar address */
+ res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+ if (!res)
+ return -ENODEV;
+ cdev->pci_ba = devm_ioremap(dev, res->start, resource_size(res));
+ if (!cdev->pci_ba)
+ return -EIO;
+
+ /* DRAM spans from lpe_ba offset 0x0 till start of IRAM area */
+ ret = catpt_mbank_create(&cdev->dram, 0x0,
+ catpt_dram_size(cdev),
+ cdev->pdata->dram_mask);
+ if (ret < 0)
+ return ret;
+ ret = catpt_mbank_create(&cdev->iram, cdev->pdata->host_iram_offset,
+ catpt_iram_size(cdev),
+ cdev->pdata->iram_mask);
+ if (ret < 0)
+ goto iram_err;
+
+ /* alloc buffer for storing DRAM context during dx transitions */
+ cdev->dxbuf_vaddr = dma_alloc_coherent(dev, catpt_dram_size(cdev),
+ &cdev->dxbuf_paddr, GFP_KERNEL);
+ if (!cdev->dxbuf_vaddr) {
+ ret = -ENOMEM;
+ goto dma_alloc_err;
+ }
+
+ ret = platform_get_irq(pdev, 0);
+ if (ret < 0)
+ goto irq_err;
+ cdev->irq = ret;
+
+ platform_set_drvdata(pdev, cdev);
+
+ ret = devm_request_threaded_irq(dev, cdev->irq, catpt_dsp_irq_handler,
+ catpt_dsp_irq_thread,
+ IRQF_SHARED, "AudioDSP", cdev);
+ if (ret < 0)
+ goto irq_err;
+
+ ret = catpt_probe_components(cdev);
+ if (ret < 0)
+ goto irq_err;
+ return 0;
+
+irq_err:
+ dma_free_coherent(cdev->dev, catpt_dram_size(cdev),
+ cdev->dxbuf_vaddr, cdev->dxbuf_paddr);
+dma_alloc_err:
+ catpt_mbank_remove(&cdev->iram);
+iram_err:
+ catpt_mbank_remove(&cdev->dram);
+
+ return ret;
+}
+
+static int catpt_acpi_remove(struct platform_device *pdev)
+{
+ struct catpt_dev *cdev = platform_get_drvdata(pdev);
+
+ pm_runtime_disable(cdev->dev);
+
+ snd_soc_unregister_component(cdev->dev);
+ catpt_dmac_remove(cdev);
+ cdev->pdata->power_down(cdev);
+
+ dma_free_coherent(cdev->dev, catpt_dram_size(cdev),
+ cdev->dxbuf_vaddr, cdev->dxbuf_paddr);
+ catpt_mbank_remove(&cdev->iram);
+ catpt_mbank_remove(&cdev->dram);
+
+ catpt_sysfs_remove(cdev);
+
+ return 0;
+}
+
+static struct catpt_pdata lpt_desc = {
+ .machines = snd_soc_acpi_intel_haswell_machines,
+ .core_id = 0x01,
+ .host_dram_offset = 0x000000,
+ .host_iram_offset = 0x080000,
+ .host_shim_offset = 0x0E7000,
+ .host_dma_offset = { 0x0F0000, 0x0F8000 },
+ .host_ssp_offset = { 0x0E8000, 0x0E9000 },
+ .dram_mask = LPT_VDRTCTL0_DSRAMPGE_MASK,
+ .iram_mask = LPT_VDRTCTL0_ISRAMPGE_MASK,
+ .pll_shutdown = lpt_dsp_pll_shutdown,
+ .power_up = lpt_dsp_power_up,
+ .power_down = lpt_dsp_power_down,
+};
+
+static struct catpt_pdata wpt_desc = {
+ .machines = snd_soc_acpi_intel_broadwell_machines,
+ .core_id = 0x02,
+ .host_dram_offset = 0x000000,
+ .host_iram_offset = 0x0A0000,
+ .host_shim_offset = 0x0FB000,
+ .host_dma_offset = { 0x0FE000, 0x0FF000 },
+ .host_ssp_offset = { 0x0FC000, 0x0FD000 },
+ .dram_mask = WPT_VDRTCTL0_DSRAMPGE_MASK,
+ .iram_mask = WPT_VDRTCTL0_ISRAMPGE_MASK,
+ .pll_shutdown = wpt_dsp_pll_shutdown,
+ .power_up = wpt_dsp_power_up,
+ .power_down = wpt_dsp_power_down,
+};
+
+static const struct acpi_device_id catpt_ids[] = {
+ { "INT33C8", (unsigned long)&lpt_desc },
+ { "INT3438", (unsigned long)&wpt_desc },
+ { },
+};
+MODULE_DEVICE_TABLE(acpi, catpt_ids);
+
+static struct platform_driver catpt_acpi_driver = {
+ .probe = catpt_acpi_probe,
+ .remove = catpt_acpi_remove,
+ .driver = {
+ .name = "catpt_adsp",
+ .acpi_match_table = ACPI_PTR(catpt_ids),
+ .pm = &catpt_dev_pm,
+ },
+};
+module_platform_driver(catpt_acpi_driver);
+
+MODULE_AUTHOR("Cezary Rojewski <cezary.rojewski@intel.com>");
+MODULE_DESCRIPTION("Intel LPT/WPT AudioDSP driver");
+MODULE_LICENSE("GPL v2");
diff --git a/sound/soc/intel/catpt/registers.h b/sound/soc/intel/catpt/registers.h
new file mode 100644
index 000000000000..65e9b5905577
--- /dev/null
+++ b/sound/soc/intel/catpt/registers.h
@@ -0,0 +1,191 @@
+/* SPDX-License-Identifier: GPL-2.0-only
+ *
+ * Copyright(c) 2020 Intel Corporation. All rights reserved.
+ *
+ * Author: Cezary Rojewski <cezary.rojewski@intel.com>
+ */
+
+#ifndef __SND_SOC_INTEL_CATPT_REGS_H
+#define __SND_SOC_INTEL_CATPT_REGS_H
+
+#include <linux/iopoll.h>
+
+#define CATPT_SHIM_REGS_SIZE 4096
+#define CATPT_DMA_REGS_SIZE 1024
+#define CATPT_DMA_COUNT 2
+#define CATPT_SSP_REGS_SIZE 512
+
+/* DSP Shim registers */
+
+#define CATPT_SHIM_REG_CS 0x0
+#define CATPT_SHIM_REG_ISC 0x18
+#define CATPT_SHIM_REG_ISD 0x20
+#define CATPT_SHIM_REG_IMC 0x28
+#define CATPT_SHIM_REG_IMD 0x30
+#define CATPT_SHIM_REG_IPCC 0x38
+#define CATPT_SHIM_REG_IPCD 0x40
+#define CATPT_SHIM_REG_CLKCTL 0x78
+#define CATPT_SHIM_REG_CS2 0x80
+#define CATPT_SHIM_REG_LTRC 0xE0
+#define CATPT_SHIM_REG_HMDC 0xE8
+
+#define CATPT_CS_LPCS BIT(31)
+#define CATPT_CS_SFCR(ssp) BIT(27 + ssp)
+#define CATPT_CS_S1IOCS BIT(23)
+#define CATPT_CS_S0IOCS BIT(21)
+#define CATPT_CS_PCE BIT(15)
+#define CATPT_CS_SDPM(ssp) BIT(11 + ssp)
+#define CATPT_CS_STALL BIT(10)
+#define CATPT_CS_DCS GENMASK(6, 4)
+/* b100 DSP core & audio fabric high clock */
+#define CATPT_CS_DCS_HIGH (0x4 << 4)
+#define CATPT_CS_SBCS(ssp) BIT(2 + ssp)
+#define CATPT_CS_RST BIT(1)
+
+#define CATPT_ISC_IPCDB BIT(1)
+#define CATPT_ISC_IPCCD BIT(0)
+#define CATPT_ISD_DCPWM BIT(31)
+#define CATPT_ISD_IPCCB BIT(1)
+#define CATPT_ISD_IPCDD BIT(0)
+
+#define CATPT_IMC_IPCDB BIT(1)
+#define CATPT_IMC_IPCCD BIT(0)
+#define CATPT_IMD_IPCCB BIT(1)
+#define CATPT_IMD_IPCDD BIT(0)
+
+#define CATPT_IPCC_BUSY BIT(31)
+#define CATPT_IPCC_DONE BIT(30)
+#define CATPT_IPCD_BUSY BIT(31)
+#define CATPT_IPCD_DONE BIT(30)
+
+#define CATPT_CLKCTL_CFCIP BIT(31)
+#define CATPT_CLKCTL_SMOS GENMASK(25, 24)
+
+#define CATPT_HMDC_HDDA(e, ch) BIT(8 * e + ch)
+
+#define CATPT_CS_DEFAULT 0x8480040E
+#define CATPT_ISC_DEFAULT 0x0
+#define CATPT_ISD_DEFAULT 0x0
+#define CATPT_IMC_DEFAULT 0x7FFF0003
+#define CATPT_IMD_DEFAULT 0x7FFF0003
+#define CATPT_IPCC_DEFAULT 0x0
+#define CATPT_IPCD_DEFAULT 0x0
+#define CATPT_CLKCTL_DEFAULT 0x7FF
+#define CATPT_CS2_DEFAULT 0x0
+#define CATPT_LTRC_DEFAULT 0x0
+#define CATPT_HMDC_DEFAULT 0x0
+
+/* PCI Configuration registers */
+
+#define CATPT_PCI_REG_PMCS 0x84
+#define CATPT_PCI_REG_VDRTCTL0 0xA0
+#define CATPT_PCI_REG_VDRTCTL2 0xA8
+
+#define CATPT_PMCS_PS GENMASK(1, 0)
+#define CATPT_PMCS_PS_D3HOT (0x3 << 0)
+
+#define CATPT_VDRTCTL2_DTCGE BIT(10)
+#define CATPT_VDRTCTL2_DCLCGE BIT(1)
+#define CATPT_VDRTCTL2_CGEALL 0xF7F
+
+/* LPT PCI Configuration bits */
+
+#define LPT_VDRTCTL0_DSRAMPGE(b) BIT(16 + b)
+#define LPT_VDRTCTL0_DSRAMPGE_MASK GENMASK(31, 16)
+#define LPT_VDRTCTL0_ISRAMPGE(b) BIT(6 + b)
+#define LPT_VDRTCTL0_ISRAMPGE_MASK GENMASK(15, 6)
+#define LPT_VDRTCTL0_D3SRAMPGD BIT(2)
+#define LPT_VDRTCTL0_D3PGD BIT(1)
+#define LPT_VDRTCTL0_APLLSE BIT(0)
+
+/* WPT PCI Configuration bits */
+
+#define WPT_VDRTCTL0_DSRAMPGE(b) BIT(12 + b)
+#define WPT_VDRTCTL0_DSRAMPGE_MASK GENMASK(31, 12)
+#define WPT_VDRTCTL0_ISRAMPGE(b) BIT(2 + b)
+#define WPT_VDRTCTL0_ISRAMPGE_MASK GENMASK(11, 2)
+#define WPT_VDRTCTL0_D3SRAMPGD BIT(1)
+#define WPT_VDRTCTL0_D3PGD BIT(0)
+
+#define WPT_VDRTCTL2_APLLSE BIT(31)
+
+/* SSP Interface registers */
+
+#define CATPT_SSP_SSC0 0x0
+#define CATPT_SSP_SSC1 0x4
+#define CATPT_SSP_SSS 0x8
+#define CATPT_SSP_SSIT 0xC
+#define CATPT_SSP_SSD 0x10
+#define CATPT_SSP_SSTO 0x28
+#define CATPT_SSP_SSPSP 0x2C
+#define CATPT_SSP_SSTSA 0x30
+#define CATPT_SSP_SSRSA 0x34
+#define CATPT_SSP_SSTSS 0x38
+#define CATPT_SSP_SSC2 0x40
+#define CATPT_SSP_SSPSP2 0x44
+
+#define CATPT_SSP_SSC0_DEFAULT 0x0
+#define CATPT_SSP_SSC1_DEFAULT 0x0
+#define CATPT_SSP_SSS_DEFAULT 0xF004
+#define CATPT_SSP_SSIT_DEFAULT 0x0
+#define CATPT_SSP_SSD_DEFAULT 0xC43893A3
+#define CATPT_SSP_SSTO_DEFAULT 0x0
+#define CATPT_SSP_SSPSP_DEFAULT 0x0
+#define CATPT_SSP_SSTSA_DEFAULT 0x0
+#define CATPT_SSP_SSRSA_DEFAULT 0x0
+#define CATPT_SSP_SSTSS_DEFAULT 0x0
+#define CATPT_SSP_SSC2_DEFAULT 0x0
+#define CATPT_SSP_SSPSP2_DEFAULT 0x0
+
+/* Physically the same block, access address differs between host and dsp */
+#define CATPT_DSP_DRAM_OFFSET 0x400000
+#define catpt_to_host_offset(offset) (offset & ~(CATPT_DSP_DRAM_OFFSET))
+#define catpt_to_dsp_offset(offset) (offset | CATPT_DSP_DRAM_OFFSET)
+
+#define CATPT_MEMBLOCK_SIZE 0x8000
+#define catpt_num_dram(cdev) (hweight_long((cdev)->pdata->dram_mask))
+#define catpt_num_iram(cdev) (hweight_long((cdev)->pdata->iram_mask))
+#define catpt_dram_size(cdev) (catpt_num_dram(cdev) * CATPT_MEMBLOCK_SIZE)
+#define catpt_iram_size(cdev) (catpt_num_iram(cdev) * CATPT_MEMBLOCK_SIZE)
+
+/* registry I/O helpers */
+
+#define catpt_shim_addr(cdev) \
+ ((cdev)->lpe_ba + (cdev)->pdata->host_shim_offset)
+#define catpt_dma_addr(cdev, dma) \
+ ((cdev)->lpe_ba + (cdev)->pdata->host_dma_offset[dma])
+#define catpt_ssp_addr(cdev, ssp) \
+ ((cdev)->lpe_ba + (cdev)->pdata->host_ssp_offset[ssp])
+#define catpt_inbox_addr(cdev) \
+ ((cdev)->lpe_ba + (cdev)->ipc.config.inbox_offset)
+#define catpt_outbox_addr(cdev) \
+ ((cdev)->lpe_ba + (cdev)->ipc.config.outbox_offset)
+
+#define catpt_writel_ssp(cdev, ssp, reg, val) \
+ writel(val, catpt_ssp_addr(cdev, ssp) + CATPT_SSP_##reg)
+
+#define catpt_readl_shim(cdev, reg) \
+ readl(catpt_shim_addr(cdev) + CATPT_SHIM_REG_##reg)
+#define catpt_writel_shim(cdev, reg, val) \
+ writel(val, catpt_shim_addr(cdev) + CATPT_SHIM_REG_##reg)
+#define catpt_updatel_shim(cdev, reg, mask, val) \
+ catpt_writel_shim(cdev, reg, \
+ (catpt_readl_shim(cdev, reg) & ~(mask)) | val)
+
+#define catpt_readl_poll_shim(cdev, reg, val, cond, delay_us, timeout_us) \
+ readl_poll_timeout(catpt_shim_addr(cdev) + CATPT_SHIM_REG_##reg, \
+ val, cond, delay_us, timeout_us)
+
+#define catpt_readl_pci(cdev, reg) \
+ readl(cdev->pci_ba + CATPT_PCI_REG_##reg)
+#define catpt_writel_pci(cdev, reg, val) \
+ writel(val, cdev->pci_ba + CATPT_PCI_REG_##reg)
+#define catpt_updatel_pci(cdev, reg, mask, val) \
+ catpt_writel_pci(cdev, reg, \
+ (catpt_readl_pci(cdev, reg) & ~(mask)) | val)
+
+#define catpt_readl_poll_pci(cdev, reg, val, cond, delay_us, timeout_us) \
+ readl_poll_timeout((cdev)->pci_ba + CATPT_PCI_REG_##reg, \
+ val, cond, delay_us, timeout_us)
+
+#endif
--
2.17.1
^ permalink raw reply related [flat|nested] 24+ messages in thread* Re: [PATCH 01/13] ASoC: Intel: Add catpt device
2020-08-07 11:06 ` [PATCH 01/13] ASoC: Intel: Add catpt device Cezary Rojewski
@ 2020-08-08 11:50 ` Andy Shevchenko
2020-08-11 10:04 ` Cezary Rojewski
0 siblings, 1 reply; 24+ messages in thread
From: Andy Shevchenko @ 2020-08-08 11:50 UTC (permalink / raw)
To: Cezary Rojewski
Cc: pierre-louis.bossart, alsa-devel, filip.kaczmarski,
harshapriya.n, marcin.barlik, zwisler, lgirdwood, tiwai,
filip.proborszcz, broonie, michal.wasko, cujomalainey,
ppapierkowski, vamshi.krishna.gopal
On Fri, Aug 07, 2020 at 01:06:37PM +0200, Cezary Rojewski wrote:
> Declare base structures, registers and device routines for the catpt
> solution. Catpt deprecates and is a direct replacement for
> sound/soc/intel/haswell. Supports Lynxpoint and Wildcat Point both.
...
> +struct catpt_mregion {
> + u32 start;
> + u32 end;
> + bool busy;
> + struct list_head node;
> +};
I'm wondering if struct resource can be used instead.
You know that you may introduce a new type of resource if you want to.
> +static inline size_t catpt_mregion_size(const struct catpt_mregion *reg)
> +{
> + return reg->end - reg->start + 1;
> +}
> +
> +/* True if region r1 intersects region r2 */
> +static inline bool catpt_mregion_intersects(struct catpt_mregion *r1,
> + struct catpt_mregion *r2)
> +{
> + return (r1->start >= r2->start && r1->start <= r2->end) ||
> + (r1->end >= r2->start && r1->end <= r2->end);
> +}
> +
> +static inline bool catpt_mregion_intersecting(struct catpt_mregion *r1,
> + struct catpt_mregion *r2,
> + struct catpt_mregion *ret)
> +{
> + if (!catpt_mregion_intersects(r1, r2))
> + return false;
> + ret->start = max(r1->start, r2->start);
> + ret->end = min(r1->end, r2->end);
> + return true;
> +}
Yeah, it reminds the existing resource infrastructure. Why to repeat it?
--
With Best Regards,
Andy Shevchenko
^ permalink raw reply [flat|nested] 24+ messages in thread* Re: [PATCH 01/13] ASoC: Intel: Add catpt device
2020-08-08 11:50 ` Andy Shevchenko
@ 2020-08-11 10:04 ` Cezary Rojewski
0 siblings, 0 replies; 24+ messages in thread
From: Cezary Rojewski @ 2020-08-11 10:04 UTC (permalink / raw)
To: Andy Shevchenko
Cc: pierre-louis.bossart, alsa-devel, filip.kaczmarski,
harshapriya.n, marcin.barlik, zwisler, lgirdwood, tiwai,
filip.proborszcz, broonie, michal.wasko, cujomalainey,
ppapierkowski, vamshi.krishna.gopal
On 2020-08-08 1:50 PM, Andy Shevchenko wrote:
> On Fri, Aug 07, 2020 at 01:06:37PM +0200, Cezary Rojewski wrote:
>> Declare base structures, registers and device routines for the catpt
>> solution. Catpt deprecates and is a direct replacement for
>> sound/soc/intel/haswell. Supports Lynxpoint and Wildcat Point both.
>
>
> ...
>
>> +struct catpt_mregion {
>> + u32 start;
>> + u32 end;
>> + bool busy;
>> + struct list_head node;
>> +};
>
> I'm wondering if struct resource can be used instead.
>
> You know that you may introduce a new type of resource if you want to.
>
>> +static inline size_t catpt_mregion_size(const struct catpt_mregion *reg)
>> +{
>> + return reg->end - reg->start + 1;
>> +}
>> +
>> +/* True if region r1 intersects region r2 */
>> +static inline bool catpt_mregion_intersects(struct catpt_mregion *r1,
>> + struct catpt_mregion *r2)
>> +{
>> + return (r1->start >= r2->start && r1->start <= r2->end) ||
>> + (r1->end >= r2->start && r1->end <= r2->end);
>> +}
>> +
>> +static inline bool catpt_mregion_intersecting(struct catpt_mregion *r1,
>> + struct catpt_mregion *r2,
>> + struct catpt_mregion *ret)
>> +{
>> + if (!catpt_mregion_intersects(r1, r2))
>> + return false;
>> + ret->start = max(r1->start, r2->start);
>> + ret->end = min(r1->end, r2->end);
>> + return true;
>> +}
>
> Yeah, it reminds the existing resource infrastructure. Why to repeat it?
>
As mentioned in the followup message:
https://www.spinics.net/lists/alsa-devel/msg113563.html
(Resource management section)
I opted out of 'struct resource' usage due to differences in its layout
and preferred usage. Perhaps I shouldn't have.
I've embraced 'struct resource' fully in v2. Your suggestion cascaded
into several other changes and some things were made redundant with
removal of struct catpt_mbank and catpt_mregion. Change log has been
added in v2 cover-letter describing consequences of said change.
Thanks,
Czarek
^ permalink raw reply [flat|nested] 24+ messages in thread
* [PATCH 02/13] ASoC: Intel: catpt: Define DSP operations
2020-08-07 11:06 [PATCH 00/13] ASoC: Intel: Catpt - Lynx and Wildcat point Cezary Rojewski
2020-08-07 11:06 ` [PATCH 01/13] ASoC: Intel: Add catpt device Cezary Rojewski
@ 2020-08-07 11:06 ` Cezary Rojewski
2020-08-07 11:06 ` [PATCH 03/13] ASoC: Intel: catpt: Firmware loading and context restore Cezary Rojewski
` (12 subsequent siblings)
14 siblings, 0 replies; 24+ messages in thread
From: Cezary Rojewski @ 2020-08-07 11:06 UTC (permalink / raw)
To: alsa-devel
Cc: pierre-louis.bossart, Cezary Rojewski, andriy.shevchenko,
filip.kaczmarski, harshapriya.n, marcin.barlik, zwisler,
lgirdwood, tiwai, filip.proborszcz, broonie, michal.wasko,
cujomalainey, ppapierkowski, vamshi.krishna.gopal
Implement dsp lifecycle functions such as core RESET and STALL,
SRAM power control and LP clock selection. This also adds functions for
handling transport over DW DMA controller.
Signed-off-by: Cezary Rojewski <cezary.rojewski@intel.com>
---
sound/soc/intel/catpt/dsp.c | 491 ++++++++++++++++++++++++++++++++++++
1 file changed, 491 insertions(+)
create mode 100644 sound/soc/intel/catpt/dsp.c
diff --git a/sound/soc/intel/catpt/dsp.c b/sound/soc/intel/catpt/dsp.c
new file mode 100644
index 000000000000..137c43ca521d
--- /dev/null
+++ b/sound/soc/intel/catpt/dsp.c
@@ -0,0 +1,491 @@
+// SPDX-License-Identifier: GPL-2.0-only
+//
+// Copyright(c) 2020 Intel Corporation. All rights reserved.
+//
+// Author: Cezary Rojewski <cezary.rojewski@intel.com>
+//
+
+#include <linux/dma-mapping.h>
+#include <linux/acpi_dma.h>
+#include <linux/firmware.h>
+#include "core.h"
+#include "messages.h"
+#include "registers.h"
+#include "trace.h"
+
+static void catpt_dma_transfer_complete(void *arg)
+{
+ struct catpt_dev *cdev = arg;
+
+ dev_dbg(cdev->dev, "%s\n", __func__);
+}
+
+static bool catpt_dma_filter(struct dma_chan *chan, void *param)
+{
+ return chan->device->dev == (struct device *)param;
+}
+
+#define CATPT_DMA_DEVID 1 /* dma engine used */
+#define CATPT_DMA_MAXBURST 0x3
+#define CATPT_DMA_DSP_ADDR_MASK 0xFFF00000
+
+struct dma_chan *catpt_dma_request_config_chan(struct catpt_dev *cdev)
+{
+ struct dma_slave_config config;
+ struct dma_chan *chan;
+ dma_cap_mask_t mask;
+ int ret;
+
+ dma_cap_zero(mask);
+ dma_cap_set(DMA_SLAVE, mask);
+ dma_cap_set(DMA_MEMCPY, mask);
+
+ chan = dma_request_channel(mask, catpt_dma_filter, cdev->dev);
+ if (!chan) {
+ dev_err(cdev->dev, "request channel failed\n");
+ dump_stack();
+ return ERR_PTR(-EPROBE_DEFER);
+ }
+
+ memset(&config, 0, sizeof(config));
+ config.direction = DMA_MEM_TO_DEV;
+ config.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
+ config.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
+ config.src_maxburst = CATPT_DMA_MAXBURST;
+ config.dst_maxburst = CATPT_DMA_MAXBURST;
+
+ ret = dmaengine_slave_config(chan, &config);
+ if (ret) {
+ dev_err(cdev->dev, "slave config failed: %d\n", ret);
+ dma_release_channel(chan);
+ return ERR_PTR(ret);
+ }
+
+ return chan;
+}
+
+static int catpt_dma_memcpy(struct catpt_dev *cdev, struct dma_chan *chan,
+ dma_addr_t dst_addr, dma_addr_t src_addr,
+ size_t size)
+{
+ struct dma_async_tx_descriptor *desc;
+ enum dma_status status;
+
+ desc = dmaengine_prep_dma_memcpy(chan, dst_addr, src_addr, size,
+ DMA_CTRL_ACK);
+ if (!desc) {
+ dev_err(cdev->dev, "prep dma memcpy failed\n");
+ return -EIO;
+ }
+
+ /* enable demand mode for dma channel */
+ catpt_updatel_shim(cdev, HMDC,
+ CATPT_HMDC_HDDA(CATPT_DMA_DEVID, chan->chan_id),
+ CATPT_HMDC_HDDA(CATPT_DMA_DEVID, chan->chan_id));
+ desc->callback = catpt_dma_transfer_complete;
+ desc->callback_param = cdev;
+ dmaengine_submit(desc);
+
+ status = dma_wait_for_async_tx(desc);
+ catpt_updatel_shim(cdev, HMDC,
+ CATPT_HMDC_HDDA(CATPT_DMA_DEVID, chan->chan_id), 0);
+
+ return (status == DMA_COMPLETE) ? 0 : -EPROTO;
+}
+
+int catpt_dma_memcpy_todsp(struct catpt_dev *cdev, struct dma_chan *chan,
+ dma_addr_t dst_addr, dma_addr_t src_addr,
+ size_t size)
+{
+ return catpt_dma_memcpy(cdev, chan, dst_addr | CATPT_DMA_DSP_ADDR_MASK,
+ src_addr, size);
+}
+
+int catpt_dma_memcpy_fromdsp(struct catpt_dev *cdev, struct dma_chan *chan,
+ dma_addr_t dst_addr, dma_addr_t src_addr,
+ size_t size)
+{
+ return catpt_dma_memcpy(cdev, chan, dst_addr,
+ src_addr | CATPT_DMA_DSP_ADDR_MASK, size);
+}
+
+int catpt_dmac_probe(struct catpt_dev *cdev)
+{
+ struct dw_dma_chip *dmac;
+ struct resource res;
+ int ret;
+
+ dmac = devm_kzalloc(cdev->dev, sizeof(*dmac), GFP_KERNEL);
+ if (!dmac)
+ return -ENOMEM;
+
+ memset(&res, 0, sizeof(res));
+ res.start = cdev->lpe_base +
+ cdev->pdata->host_dma_offset[CATPT_DMA_DEVID];
+ res.end = res.start + (CATPT_DMA_REGS_SIZE - 1);
+ res.flags = IORESOURCE_MEM;
+ dmac->dev = cdev->dev;
+ dmac->irq = cdev->irq;
+
+ dmac->regs = devm_ioremap_resource(cdev->dev, &res);
+ if (IS_ERR(dmac->regs))
+ return PTR_ERR(dmac->regs);
+
+ ret = dma_coerce_mask_and_coherent(cdev->dev, DMA_BIT_MASK(31));
+ if (ret < 0)
+ return ret;
+ /*
+ * Caller is responsible for putting device in D0 to allow
+ * for I/O and memory access before probing DW
+ */
+ ret = dw_dma_probe(dmac);
+ if (ret < 0)
+ return ret;
+
+ cdev->dmac = dmac;
+ return 0;
+}
+
+void catpt_dmac_remove(struct catpt_dev *cdev)
+{
+ /*
+ * As do_dma_remove() juggles with pm_runtime_get_xxx() and
+ * pm_runtime_put_xxx() while both ADSP and DW 'devices' are part of
+ * the same module, caller makes sure pm_runtime_disable() is invoked
+ * before removing DW to prevent postmortem resume and suspend
+ */
+ dw_dma_remove(cdev->dmac);
+}
+
+static void catpt_dsp_set_srampge(struct catpt_dev *cdev,
+ struct catpt_mbank *sram, unsigned long new)
+{
+ unsigned long old;
+ u32 off = sram->start;
+ u32 b = __ffs(sram->mask);
+
+ old = catpt_readl_pci(cdev, VDRTCTL0) & sram->mask;
+ trace_catpt_updatel("SRAMPGE", sram->mask, old, new);
+ if (old == new)
+ return;
+
+ catpt_updatel_pci(cdev, VDRTCTL0, sram->mask, new);
+ udelay(60);
+
+ /*
+ * dummy read as the very first access after block enable
+ * to prevent byte loss in future operations
+ */
+ for_each_clear_bit_from(b, &new, fls(sram->mask)) {
+ u8 buf[4];
+
+ /* newly enabled: new bit=0 while old bit=1 */
+ if (test_bit(b, &old)) {
+ dev_dbg(cdev->dev, "sanitize block %ld: off 0x%08x\n",
+ (b - __ffs(sram->mask)), off);
+ memcpy_fromio(buf, cdev->lpe_ba + off, sizeof(buf));
+ }
+ off += CATPT_MEMBLOCK_SIZE;
+ }
+}
+
+void catpt_dsp_update_srampge(struct catpt_dev *cdev, struct catpt_mbank *sram)
+{
+ struct catpt_mregion *reg;
+ unsigned long new = 0;
+
+ /* flag all busy blocks */
+ list_for_each_entry(reg, &sram->region_list, node) {
+ u32 h, l;
+
+ if (!reg->busy)
+ continue;
+ h = (reg->end - sram->start) / CATPT_MEMBLOCK_SIZE;
+ l = (reg->start - sram->start) / CATPT_MEMBLOCK_SIZE;
+ new |= GENMASK(h, l);
+ }
+
+ /* offset value given mask's start and invert it as ON=b0 */
+ new <<= __ffs(sram->mask);
+ new = ~(new) & sram->mask;
+
+ /* disable core clock gating */
+ catpt_updatel_pci(cdev, VDRTCTL2, CATPT_VDRTCTL2_DCLCGE, 0);
+
+ catpt_dsp_set_srampge(cdev, sram, new);
+
+ /* enable core clock gating */
+ catpt_updatel_pci(cdev, VDRTCTL2, CATPT_VDRTCTL2_DCLCGE,
+ CATPT_VDRTCTL2_DCLCGE);
+}
+
+int catpt_dsp_stall(struct catpt_dev *cdev, bool stall)
+{
+ u32 reg, val;
+
+ val = stall ? CATPT_CS_STALL : 0;
+ catpt_updatel_shim(cdev, CS, CATPT_CS_STALL, val);
+
+ return catpt_readl_poll_shim(cdev, CS,
+ reg, (reg & CATPT_CS_STALL) == val,
+ 500, 10000);
+}
+
+static int catpt_dsp_reset(struct catpt_dev *cdev, bool reset)
+{
+ u32 reg, val;
+
+ val = reset ? CATPT_CS_RST : 0;
+ catpt_updatel_shim(cdev, CS, CATPT_CS_RST, val);
+
+ return catpt_readl_poll_shim(cdev, CS,
+ reg, (reg & CATPT_CS_RST) == val,
+ 500, 10000);
+}
+
+void lpt_dsp_pll_shutdown(struct catpt_dev *cdev, bool enable)
+{
+ u32 val;
+
+ val = enable ? LPT_VDRTCTL0_APLLSE : 0;
+ catpt_updatel_pci(cdev, VDRTCTL0, LPT_VDRTCTL0_APLLSE, val);
+}
+
+void wpt_dsp_pll_shutdown(struct catpt_dev *cdev, bool enable)
+{
+ u32 val;
+
+ val = enable ? WPT_VDRTCTL2_APLLSE : 0;
+ catpt_updatel_pci(cdev, VDRTCTL2, WPT_VDRTCTL2_APLLSE, val);
+}
+
+static int catpt_dsp_select_lpclock(struct catpt_dev *cdev, bool lp, bool waiti)
+{
+ u32 mask, reg, val;
+ int ret;
+
+ mutex_lock(&cdev->clk_mutex);
+
+ val = lp ? CATPT_CS_LPCS : 0;
+ reg = catpt_readl_shim(cdev, CS) & CATPT_CS_LPCS;
+ trace_catpt_updatel("LPCS", CATPT_CS_LPCS, reg, val);
+
+ if (reg == val) {
+ mutex_unlock(&cdev->clk_mutex);
+ return 0;
+ }
+
+ if (waiti) {
+ /* wait for DSP to signal WAIT state */
+ ret = catpt_readl_poll_shim(cdev, ISD,
+ reg, (reg & CATPT_ISD_DCPWM),
+ 500, 10000);
+ if (ret < 0) {
+ dev_warn(cdev->dev, "await WAITI timeout\n");
+ mutex_unlock(&cdev->clk_mutex);
+ return ret;
+ }
+ }
+
+ ret = catpt_readl_poll_shim(cdev, CLKCTL,
+ reg, !(reg & CATPT_CLKCTL_CFCIP),
+ 500, 10000);
+ if (ret < 0)
+ dev_warn(cdev->dev, "clock change still in progress\n");
+
+ /* default to DSP core & audio fabric high clock */
+ val |= CATPT_CS_DCS_HIGH;
+ mask = CATPT_CS_LPCS | CATPT_CS_DCS;
+ catpt_updatel_shim(cdev, CS, mask, val);
+
+ ret = catpt_readl_poll_shim(cdev, CLKCTL,
+ reg, !(reg & CATPT_CLKCTL_CFCIP),
+ 500, 10000);
+ if (ret < 0)
+ dev_warn(cdev->dev, "clock change still in progress\n");
+
+ /* update PLL accordingly */
+ cdev->pdata->pll_shutdown(cdev, lp);
+
+ mutex_unlock(&cdev->clk_mutex);
+ return 0;
+}
+
+int catpt_dsp_update_lpclock(struct catpt_dev *cdev)
+{
+ struct catpt_stream_runtime *stream;
+ bool lp;
+
+ if (list_empty(&cdev->stream_list))
+ return catpt_dsp_select_lpclock(cdev, true, true);
+
+ lp = true;
+ list_for_each_entry(stream, &cdev->stream_list, node) {
+ if (stream->prepared) {
+ lp = false;
+ break;
+ }
+ }
+
+ return catpt_dsp_select_lpclock(cdev, lp, true);
+}
+
+/* bring registers to their defaults as HW won't reset itself */
+static void catpt_dsp_set_regs_defaults(struct catpt_dev *cdev)
+{
+ int i;
+
+ catpt_writel_shim(cdev, CS, CATPT_CS_DEFAULT);
+ catpt_writel_shim(cdev, ISC, CATPT_ISC_DEFAULT);
+ catpt_writel_shim(cdev, ISD, CATPT_ISD_DEFAULT);
+ catpt_writel_shim(cdev, IMC, CATPT_IMC_DEFAULT);
+ catpt_writel_shim(cdev, IMD, CATPT_IMD_DEFAULT);
+ catpt_writel_shim(cdev, IPCC, CATPT_IPCC_DEFAULT);
+ catpt_writel_shim(cdev, IPCD, CATPT_IPCD_DEFAULT);
+ catpt_writel_shim(cdev, CLKCTL, CATPT_CLKCTL_DEFAULT);
+ catpt_writel_shim(cdev, CS2, CATPT_CS2_DEFAULT);
+ catpt_writel_shim(cdev, LTRC, CATPT_LTRC_DEFAULT);
+ catpt_writel_shim(cdev, HMDC, CATPT_HMDC_DEFAULT);
+
+ for (i = 0; i < CATPT_SSP_COUNT; i++) {
+ catpt_writel_ssp(cdev, i, SSC0, CATPT_SSP_SSC0_DEFAULT);
+ catpt_writel_ssp(cdev, i, SSC1, CATPT_SSP_SSC1_DEFAULT);
+ catpt_writel_ssp(cdev, i, SSS, CATPT_SSP_SSS_DEFAULT);
+ catpt_writel_ssp(cdev, i, SSIT, CATPT_SSP_SSIT_DEFAULT);
+ catpt_writel_ssp(cdev, i, SSD, CATPT_SSP_SSD_DEFAULT);
+ catpt_writel_ssp(cdev, i, SSTO, CATPT_SSP_SSTO_DEFAULT);
+ catpt_writel_ssp(cdev, i, SSPSP, CATPT_SSP_SSPSP_DEFAULT);
+ catpt_writel_ssp(cdev, i, SSTSA, CATPT_SSP_SSTSA_DEFAULT);
+ catpt_writel_ssp(cdev, i, SSRSA, CATPT_SSP_SSRSA_DEFAULT);
+ catpt_writel_ssp(cdev, i, SSTSS, CATPT_SSP_SSTSS_DEFAULT);
+ catpt_writel_ssp(cdev, i, SSC2, CATPT_SSP_SSC2_DEFAULT);
+ catpt_writel_ssp(cdev, i, SSPSP2, CATPT_SSP_SSPSP2_DEFAULT);
+ }
+}
+
+int lpt_dsp_power_down(struct catpt_dev *cdev)
+{
+ catpt_dsp_reset(cdev, true);
+
+ /* set 24Mhz clock for both SSPs */
+ catpt_updatel_shim(cdev, CS, CATPT_CS_SBCS(0) | CATPT_CS_SBCS(1),
+ CATPT_CS_SBCS(0) | CATPT_CS_SBCS(1));
+ catpt_dsp_select_lpclock(cdev, true, false);
+
+ /* DRAM power gating all */
+ catpt_dsp_set_srampge(cdev, &cdev->dram, cdev->dram.mask);
+ catpt_dsp_set_srampge(cdev, &cdev->iram, cdev->iram.mask);
+
+ /* set D3 */
+ catpt_updatel_pci(cdev, PMCS, CATPT_PMCS_PS, CATPT_PMCS_PS_D3HOT);
+ udelay(50);
+
+ return 0;
+}
+
+int lpt_dsp_power_up(struct catpt_dev *cdev)
+{
+ /* SRAM power gating none */
+ catpt_dsp_set_srampge(cdev, &cdev->dram, 0);
+ catpt_dsp_set_srampge(cdev, &cdev->iram, 0);
+
+ /* set D0 */
+ catpt_updatel_pci(cdev, PMCS, CATPT_PMCS_PS, 0);
+ udelay(100);
+
+ catpt_dsp_select_lpclock(cdev, false, false);
+ catpt_updatel_shim(cdev, CS,
+ CATPT_CS_SBCS(0) | CATPT_CS_SBCS(1),
+ CATPT_CS_SBCS(0) | CATPT_CS_SBCS(1));
+ udelay(50);
+
+ catpt_dsp_reset(cdev, false);
+ /* generate int deassert msg to fix inversed int logic */
+ catpt_updatel_shim(cdev, IMC, CATPT_IMC_IPCDB | CATPT_IMC_IPCCD, 0);
+
+ return 0;
+}
+
+int wpt_dsp_power_down(struct catpt_dev *cdev)
+{
+ u32 mask, val;
+
+ /* disable core clock gating */
+ catpt_updatel_pci(cdev, VDRTCTL2, CATPT_VDRTCTL2_DCLCGE, 0);
+
+ catpt_dsp_reset(cdev, true);
+ /* set 24Mhz clock for both SSPs */
+ catpt_updatel_shim(cdev, CS, CATPT_CS_SBCS(0) | CATPT_CS_SBCS(1),
+ CATPT_CS_SBCS(0) | CATPT_CS_SBCS(1));
+ catpt_dsp_select_lpclock(cdev, true, false);
+ /* disable MCLK */
+ catpt_updatel_shim(cdev, CLKCTL, CATPT_CLKCTL_SMOS, 0);
+
+ catpt_dsp_set_regs_defaults(cdev);
+
+ /* switch clock gating */
+ mask = CATPT_VDRTCTL2_CGEALL & (~CATPT_VDRTCTL2_DCLCGE);
+ val = mask & (~CATPT_VDRTCTL2_DTCGE);
+ catpt_updatel_pci(cdev, VDRTCTL2, mask, val);
+ /* enable DTCGE separatelly */
+ catpt_updatel_pci(cdev, VDRTCTL2, CATPT_VDRTCTL2_DTCGE,
+ CATPT_VDRTCTL2_DTCGE);
+
+ /* SRAM power gating all */
+ catpt_dsp_set_srampge(cdev, &cdev->dram, cdev->dram.mask);
+ catpt_dsp_set_srampge(cdev, &cdev->iram, cdev->iram.mask);
+ mask = WPT_VDRTCTL0_D3SRAMPGD | WPT_VDRTCTL0_D3PGD;
+ catpt_updatel_pci(cdev, VDRTCTL0, mask, WPT_VDRTCTL0_D3PGD);
+
+ /* set D3 */
+ catpt_updatel_pci(cdev, PMCS, CATPT_PMCS_PS, CATPT_PMCS_PS_D3HOT);
+ udelay(50);
+
+ /* enable core clock gating */
+ catpt_updatel_pci(cdev, VDRTCTL2, CATPT_VDRTCTL2_DCLCGE,
+ CATPT_VDRTCTL2_DCLCGE);
+ udelay(50);
+
+ return 0;
+}
+
+int wpt_dsp_power_up(struct catpt_dev *cdev)
+{
+ u32 mask, val;
+
+ /* disable core clock gating */
+ catpt_updatel_pci(cdev, VDRTCTL2, CATPT_VDRTCTL2_DCLCGE, 0);
+
+ /* switch clock gating */
+ mask = CATPT_VDRTCTL2_CGEALL & (~CATPT_VDRTCTL2_DCLCGE);
+ val = mask & (~CATPT_VDRTCTL2_DTCGE);
+ catpt_updatel_pci(cdev, VDRTCTL2, mask, val);
+
+ /* set D0 */
+ catpt_updatel_pci(cdev, PMCS, CATPT_PMCS_PS, 0);
+
+ /* SRAM power gating none */
+ mask = WPT_VDRTCTL0_D3SRAMPGD | WPT_VDRTCTL0_D3PGD;
+ catpt_updatel_pci(cdev, VDRTCTL0, mask, mask);
+ catpt_dsp_set_srampge(cdev, &cdev->dram, 0);
+ catpt_dsp_set_srampge(cdev, &cdev->iram, 0);
+
+ catpt_dsp_set_regs_defaults(cdev);
+
+ /* restore MCLK */
+ catpt_updatel_shim(cdev, CLKCTL, CATPT_CLKCTL_SMOS, CATPT_CLKCTL_SMOS);
+ catpt_dsp_select_lpclock(cdev, false, false);
+ /* set 24Mhz clock for both SSPs */
+ catpt_updatel_shim(cdev, CS, CATPT_CS_SBCS(0) | CATPT_CS_SBCS(1),
+ CATPT_CS_SBCS(0) | CATPT_CS_SBCS(1));
+ catpt_dsp_reset(cdev, false);
+
+ /* enable core clock gating */
+ catpt_updatel_pci(cdev, VDRTCTL2, CATPT_VDRTCTL2_DCLCGE,
+ CATPT_VDRTCTL2_DCLCGE);
+
+ /* generate int deassert msg to fix inversed int logic */
+ catpt_updatel_shim(cdev, IMC, CATPT_IMC_IPCDB | CATPT_IMC_IPCCD, 0);
+
+ return 0;
+}
--
2.17.1
^ permalink raw reply related [flat|nested] 24+ messages in thread* [PATCH 03/13] ASoC: Intel: catpt: Firmware loading and context restore
2020-08-07 11:06 [PATCH 00/13] ASoC: Intel: Catpt - Lynx and Wildcat point Cezary Rojewski
2020-08-07 11:06 ` [PATCH 01/13] ASoC: Intel: Add catpt device Cezary Rojewski
2020-08-07 11:06 ` [PATCH 02/13] ASoC: Intel: catpt: Define DSP operations Cezary Rojewski
@ 2020-08-07 11:06 ` Cezary Rojewski
2020-08-07 11:06 ` [PATCH 04/13] ASoC: Intel: catpt: Implement IPC protocol Cezary Rojewski
` (11 subsequent siblings)
14 siblings, 0 replies; 24+ messages in thread
From: Cezary Rojewski @ 2020-08-07 11:06 UTC (permalink / raw)
To: alsa-devel
Cc: pierre-louis.bossart, Cezary Rojewski, andriy.shevchenko,
filip.kaczmarski, harshapriya.n, marcin.barlik, zwisler,
lgirdwood, tiwai, filip.proborszcz, broonie, michal.wasko,
cujomalainey, ppapierkowski, vamshi.krishna.gopal
For Lynxpoint and Wildcat Point solution, is it host's responsibility to
allocate SRAM regions and ensure those already taken are not overwritten
with other data until released. Blocks are transferred to SRAM - either
IRAM or DRAM - via DW DMA controller. Once basefw is booted, ownership
of DMA transfer is lost in favour of DSP.
Hosts reponsibilities don't end on initial block allocation and binary
transfer. During Dx transitions host must store FW runtime context from
DRAM before putting AudioDSP subsystem into lower power state. Said
context gets flashed after D0 entry to bring DSP right where it was just
before suspending.
Load and restore procedures are finalized with SRAM power gating and
adequate clock level selection. This power gates unused EBBs and clock
speed effectively reducing power consumption.
Signed-off-by: Cezary Rojewski <cezary.rojewski@intel.com>
---
sound/soc/intel/catpt/loader.c | 837 +++++++++++++++++++++++++++++++++
1 file changed, 837 insertions(+)
create mode 100644 sound/soc/intel/catpt/loader.c
diff --git a/sound/soc/intel/catpt/loader.c b/sound/soc/intel/catpt/loader.c
new file mode 100644
index 000000000000..bee9dee4e0a6
--- /dev/null
+++ b/sound/soc/intel/catpt/loader.c
@@ -0,0 +1,837 @@
+// SPDX-License-Identifier: GPL-2.0-only
+//
+// Copyright(c) 2020 Intel Corporation. All rights reserved.
+//
+// Author: Cezary Rojewski <cezary.rojewski@intel.com>
+//
+
+#include <linux/dma-mapping.h>
+#include <linux/firmware.h>
+#include "core.h"
+#include "registers.h"
+#include "trace.h"
+
+/* FW load (200ms) plus operational delays */
+#define FW_READY_TIMEOUT_MSECS 250
+
+#define FW_SIGNATURE "$SST"
+#define FW_SIGNATURE_SIZE 4
+
+/* some nice binary layout picture here */
+
+struct catpt_fw_hdr {
+ char signature[FW_SIGNATURE_SIZE];
+ u32 file_size;
+ u32 modules;
+ u32 file_format;
+ u32 reserved[4];
+} __packed;
+
+struct catpt_fw_mod_hdr {
+ char signature[FW_SIGNATURE_SIZE];
+ u32 mod_size;
+ u32 blocks;
+ u16 slot;
+ enum catpt_module_id id:16;
+ u32 entry_point;
+ u32 persistent_size;
+ u32 scratch_size;
+} __packed;
+
+enum catpt_ram_type {
+ CATPT_RAM_TYPE_IRAM = 1,
+ CATPT_RAM_TYPE_DRAM = 2,
+ /* DRAM with module's initial state */
+ CATPT_RAM_TYPE_INSTANCE = 3,
+};
+
+struct catpt_fw_block_hdr {
+ enum catpt_ram_type type __aligned(4);
+ u32 size;
+ u32 ram_offset;
+ u32 rsvd;
+} __packed;
+
+int catpt_mbank_create(struct catpt_mbank *sram, u32 start, u32 size, u32 mask)
+{
+ struct catpt_mregion *region;
+
+ sram->start = start;
+ sram->end = start + size - 1;
+ sram->mask = mask;
+ mutex_init(&sram->mutex);
+ INIT_LIST_HEAD(&sram->region_list);
+
+ region = kmalloc(sizeof(*region), GFP_KERNEL);
+ if (!region)
+ return -ENOMEM;
+
+ region->start = sram->start;
+ region->end = sram->end;
+ region->busy = false;
+ INIT_LIST_HEAD(®ion->node);
+
+ list_add_tail(®ion->node, &sram->region_list);
+ return 0;
+}
+
+void catpt_mbank_remove(struct catpt_mbank *sram)
+{
+ struct catpt_mregion *reg, *save;
+
+ list_for_each_entry_safe(reg, save, &sram->region_list, node) {
+ list_del(®->node);
+ kfree(reg);
+ }
+}
+
+static struct catpt_mregion *
+catpt_mregion_split(struct catpt_mregion *region, u32 offset)
+{
+ struct catpt_mregion *new;
+
+ new = kmalloc(sizeof(*new), GFP_KERNEL);
+ if (!new)
+ return NULL;
+
+ new->start = region->start;
+ new->end = offset;
+ new->busy = 0;
+ INIT_LIST_HEAD(&new->node);
+ region->start = new->end + 1;
+ list_add_tail(&new->node, ®ion->node);
+
+ trace_catpt_mregion(new, region, "split");
+
+ return new;
+}
+
+static void
+catpt_mregion_join(struct catpt_mregion *r1, struct catpt_mregion *r2)
+{
+ trace_catpt_mregion(r1, r2, "join");
+
+ r1->end = r2->end;
+ list_del(&r2->node);
+ kfree(r2);
+}
+
+static struct catpt_mregion *
+catpt_mregion_extract(struct catpt_mregion *region, u32 start, u32 end)
+{
+ struct catpt_mregion *ext;
+
+ if (start == region->start) {
+ if (end == region->end)
+ ext = region; /* entire block */
+ else
+ ext = catpt_mregion_split(region, end);
+ } else {
+ ext = catpt_mregion_split(region, start - 1);
+ if (IS_ERR(ext))
+ return ext;
+ ext = region; /* get the latter of two */
+ if (end != region->end)
+ ext = catpt_mregion_split(region, end);
+ }
+
+ return ext;
+}
+
+struct catpt_mregion *
+catpt_mbank_request_region(struct catpt_mbank *sram, u32 size)
+{
+ struct catpt_mregion *pos, *reg;
+ struct catpt_mregion *found = NULL;
+
+ trace_catpt_mbank(sram, "request", UINT_MAX, size);
+
+ if (!size || size > catpt_mbank_size(sram))
+ return ERR_PTR(-EINVAL);
+
+ mutex_lock(&sram->mutex);
+ list_for_each_entry_reverse(pos, &sram->region_list, node) {
+ if (pos->busy)
+ continue;
+ if (catpt_mregion_size(pos) >= size) {
+ found = pos;
+ break;
+ }
+ }
+ if (!found) {
+ reg = ERR_PTR(-EBUSY);
+ goto exit;
+ }
+
+ trace_catpt_mbank(sram, "found", found->start, found->end);
+
+ reg = catpt_mregion_extract(found, found->end - size + 1, found->end);
+ if (IS_ERR(reg))
+ goto exit;
+
+ reg->busy = 1;
+ trace_catpt_mbank(sram, "allocated", reg->start, reg->end);
+exit:
+ mutex_unlock(&sram->mutex);
+ return reg;
+}
+
+struct catpt_mregion *
+catpt_mbank_reserve_region(struct catpt_mbank *sram, u32 start, u32 size)
+{
+ struct catpt_mregion *pos, *reg;
+ struct catpt_mregion *found = NULL;
+ u32 end = start + size - 1;
+
+ trace_catpt_mbank(sram, "reserve", start, end);
+
+ if (!size || start < sram->start || end > sram->end)
+ return ERR_PTR(-EINVAL);
+
+ mutex_lock(&sram->mutex);
+ list_for_each_entry_reverse(pos, &sram->region_list, node) {
+ if (pos->busy)
+ continue;
+ if (pos->start <= start && pos->end >= end) {
+ found = pos;
+ break;
+ }
+ }
+ if (!found) {
+ reg = ERR_PTR(-EBUSY);
+ goto exit;
+ }
+
+ trace_catpt_mbank(sram, "found", found->start, found->end);
+
+ reg = catpt_mregion_extract(found, start, end);
+ if (IS_ERR(reg))
+ goto exit;
+
+ reg->busy = 1;
+ trace_catpt_mbank(sram, "allocated", reg->start, reg->end);
+exit:
+ mutex_unlock(&sram->mutex);
+ return reg;
+}
+
+void catpt_mbank_release_region(struct catpt_mbank *sram,
+ struct catpt_mregion *region)
+{
+ struct catpt_mregion *r;
+
+ trace_catpt_mbank(sram, "release", region->start, region->end);
+
+ mutex_lock(&sram->mutex);
+
+ region->busy = 0;
+ if (list_is_singular(&sram->region_list)) {
+ mutex_unlock(&sram->mutex);
+ return;
+ }
+ /*
+ * region may have free block next to it: from the left,
+ * right or both. Attempt to join them together
+ */
+ if (!list_is_last(®ion->node, &sram->region_list)) {
+ r = list_next_entry(region, node);
+ if (!r->busy)
+ catpt_mregion_join(region, r);
+ }
+
+ if (!list_is_first(®ion->node, &sram->region_list)) {
+ r = list_prev_entry(region, node);
+ if (!r->busy)
+ catpt_mregion_join(r, region);
+ }
+
+ mutex_unlock(&sram->mutex);
+}
+
+int catpt_store_streams_context(struct catpt_dev *cdev, struct dma_chan *chan)
+{
+ struct catpt_stream_runtime *stream;
+
+ list_for_each_entry(stream, &cdev->stream_list, node) {
+ u32 off, size;
+ int ret;
+
+ off = stream->persistent->start;
+ size = catpt_mregion_size(stream->persistent);
+ dev_dbg(cdev->dev, "storing stream %d ctx: off 0x%08x size %d\n",
+ stream->info.stream_hw_id, off, size);
+
+ ret = catpt_dma_memcpy_fromdsp(cdev, chan,
+ cdev->dxbuf_paddr + off,
+ cdev->lpe_base + off,
+ ALIGN(size, 4));
+ if (ret < 0) {
+ dev_err(cdev->dev, "memcpy fromdsp failed: %d\n", ret);
+ return ret;
+ }
+ }
+
+ return 0;
+}
+
+int catpt_store_module_states(struct catpt_dev *cdev, struct dma_chan *chan)
+{
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(cdev->modules); i++) {
+ struct catpt_module_type *type;
+ u32 off;
+ int ret;
+
+ type = &cdev->modules[i];
+ if (!type->loaded || !type->state_size)
+ continue;
+
+ off = type->state_offset;
+ dev_dbg(cdev->dev, "storing mod %d state: off 0x%08x size %d\n",
+ i, off, type->state_size);
+
+ ret = catpt_dma_memcpy_fromdsp(cdev, chan,
+ cdev->dxbuf_paddr + off,
+ cdev->lpe_base + off,
+ ALIGN(type->state_size, 4));
+ if (ret < 0) {
+ dev_err(cdev->dev, "memcpy fromdsp failed: %d\n", ret);
+ return ret;
+ }
+ }
+
+ return 0;
+}
+
+int catpt_store_memdumps(struct catpt_dev *cdev, struct dma_chan *chan)
+{
+ int i;
+
+ for (i = 0; i < cdev->dx_ctx.num_meminfo; i++) {
+ struct catpt_save_meminfo *info;
+ u32 off;
+ int ret;
+
+ info = &cdev->dx_ctx.meminfo[i];
+ if (info->source != CATPT_DX_TYPE_MEMORY_DUMP)
+ continue;
+
+ off = catpt_to_host_offset(info->offset);
+ if (off < cdev->dram.start || off > cdev->dram.end)
+ continue;
+
+ dev_dbg(cdev->dev, "storing memdump: off 0x%08x size %d\n",
+ off, info->size);
+
+ ret = catpt_dma_memcpy_fromdsp(cdev, chan,
+ cdev->dxbuf_paddr + off,
+ cdev->lpe_base + off,
+ ALIGN(info->size, 4));
+ if (ret < 0) {
+ dev_err(cdev->dev, "memcpy fromdsp failed: %d\n", ret);
+ return ret;
+ }
+ }
+
+ return 0;
+}
+
+static int
+catpt_restore_streams_context(struct catpt_dev *cdev, struct dma_chan *chan)
+{
+ struct catpt_stream_runtime *stream;
+
+ list_for_each_entry(stream, &cdev->stream_list, node) {
+ u32 off, size;
+ int ret;
+
+ off = stream->persistent->start;
+ size = catpt_mregion_size(stream->persistent);
+ dev_dbg(cdev->dev, "restoring stream %d ctx: off 0x%08x size %d\n",
+ stream->info.stream_hw_id, off, size);
+
+ ret = catpt_dma_memcpy_todsp(cdev, chan,
+ cdev->lpe_base + off,
+ cdev->dxbuf_paddr + off,
+ ALIGN(size, 4));
+ if (ret < 0) {
+ dev_err(cdev->dev, "memcpy fromdsp failed: %d\n", ret);
+ return ret;
+ }
+ }
+
+ return 0;
+}
+
+static int catpt_restore_memdumps(struct catpt_dev *cdev, struct dma_chan *chan)
+{
+ int i;
+
+ for (i = 0; i < cdev->dx_ctx.num_meminfo; i++) {
+ struct catpt_save_meminfo *info;
+ u32 off;
+ int ret;
+
+ info = &cdev->dx_ctx.meminfo[i];
+ if (info->source != CATPT_DX_TYPE_MEMORY_DUMP)
+ continue;
+
+ off = catpt_to_host_offset(info->offset);
+ if (off < cdev->dram.start || off > cdev->dram.end)
+ continue;
+
+ dev_dbg(cdev->dev, "restoring memdump: off 0x%08x size %d\n",
+ off, info->size);
+
+ ret = catpt_dma_memcpy_todsp(cdev, chan,
+ cdev->lpe_base + off,
+ cdev->dxbuf_paddr + off,
+ ALIGN(info->size, 4));
+ if (ret < 0) {
+ dev_err(cdev->dev, "restore block failed: %d\n", ret);
+ return ret;
+ }
+ }
+
+ return 0;
+}
+
+static int catpt_restore_fwimage(struct catpt_dev *cdev,
+ struct dma_chan *chan, dma_addr_t paddr,
+ struct catpt_fw_block_hdr *blk)
+{
+ struct catpt_mregion r1, r2, common;
+ int i;
+
+ print_hex_dump_debug(__func__, DUMP_PREFIX_OFFSET, 8, 4,
+ blk, sizeof(*blk), false);
+
+ r1.start = cdev->dram.start + blk->ram_offset;
+ r1.end = r1.start + blk->size - 1;
+ /* advance to data area */
+ paddr += sizeof(*blk);
+
+ for (i = 0; i < cdev->dx_ctx.num_meminfo; i++) {
+ struct catpt_save_meminfo *info;
+ u32 off;
+ int ret;
+
+ info = &cdev->dx_ctx.meminfo[i];
+
+ if (info->source != CATPT_DX_TYPE_FW_IMAGE)
+ continue;
+
+ off = catpt_to_host_offset(info->offset);
+ if (off < cdev->dram.start || off > cdev->dram.end)
+ continue;
+
+ r2.start = off;
+ r2.end = r2.start + info->size - 1;
+
+ if (!catpt_mregion_intersecting(&r2, &r1, &common))
+ continue;
+ /* calculate start offset of common data area */
+ off = common.start - r1.start;
+
+ dev_dbg(cdev->dev, "found intersecting region: 0x%08x-%08x\n",
+ common.start, common.end);
+ dev_dbg(cdev->dev, "restoring fwimage: start 0x%08x size %ld\n",
+ common.start, catpt_mregion_size(&common));
+
+ ret = catpt_dma_memcpy_todsp(cdev, chan, common.start,
+ paddr + off,
+ catpt_mregion_size(&common));
+ if (ret < 0) {
+ dev_err(cdev->dev, "memcpy todsp failed: %d\n", ret);
+ return ret;
+ }
+ }
+
+ return 0;
+}
+
+static int catpt_load_block(struct catpt_dev *cdev,
+ struct dma_chan *chan, dma_addr_t paddr,
+ struct catpt_fw_block_hdr *blk, bool alloc)
+{
+ struct catpt_mregion *reg = NULL;
+ struct catpt_mbank *sram;
+ dma_addr_t dst_addr;
+ int ret;
+
+ print_hex_dump_debug(__func__, DUMP_PREFIX_OFFSET, 8, 4,
+ blk, sizeof(*blk), false);
+
+ switch (blk->type) {
+ case CATPT_RAM_TYPE_IRAM:
+ sram = &cdev->iram;
+ break;
+ default:
+ sram = &cdev->dram;
+ break;
+ };
+
+ dst_addr = sram->start + blk->ram_offset;
+ if (alloc) {
+ reg = catpt_mbank_reserve_region(sram, dst_addr, blk->size);
+ if (IS_ERR(reg))
+ return PTR_ERR(reg);
+ }
+
+ /* advance to data area */
+ paddr += sizeof(*blk);
+
+ ret = catpt_dma_memcpy_todsp(cdev, chan, dst_addr, paddr, blk->size);
+ if (ret < 0) {
+ dev_err(cdev->dev, "memcpy error: %d\n", ret);
+ if (reg && IS_ERR(reg))
+ catpt_mbank_release_region(sram, reg);
+ }
+
+ return ret;
+}
+
+static int catpt_restore_basefw(struct catpt_dev *cdev,
+ struct dma_chan *chan, dma_addr_t paddr,
+ struct catpt_fw_mod_hdr *basefw)
+{
+ u32 offset = sizeof(*basefw);
+ int ret, i;
+
+ print_hex_dump_debug(__func__, DUMP_PREFIX_OFFSET, 8, 4,
+ basefw, sizeof(*basefw), false);
+
+ /* restore basefw image */
+ for (i = 0; i < basefw->blocks; i++) {
+ struct catpt_fw_block_hdr *blk;
+
+ blk = (struct catpt_fw_block_hdr *)((u8 *)basefw + offset);
+
+ switch (blk->type) {
+ case CATPT_RAM_TYPE_IRAM:
+ ret = catpt_load_block(cdev, chan, paddr + offset,
+ blk, false);
+ break;
+ default:
+ ret = catpt_restore_fwimage(cdev, chan, paddr + offset,
+ blk);
+ break;
+ }
+
+ if (ret < 0) {
+ dev_err(cdev->dev, "restore block failed: %d\n", ret);
+ return ret;
+ }
+
+ offset += sizeof(*blk) + blk->size;
+ }
+
+ /* then proceed with memory dumps */
+ ret = catpt_restore_memdumps(cdev, chan);
+ if (ret < 0)
+ dev_err(cdev->dev, "restore memdumps failed: %d\n", ret);
+
+ return ret;
+}
+
+static int catpt_restore_module(struct catpt_dev *cdev,
+ struct dma_chan *chan, dma_addr_t paddr,
+ struct catpt_fw_mod_hdr *mod)
+{
+ u32 offset = sizeof(*mod);
+ int i;
+
+ print_hex_dump_debug(__func__, DUMP_PREFIX_OFFSET, 8, 4,
+ mod, sizeof(*mod), false);
+
+ for (i = 0; i < mod->blocks; i++) {
+ struct catpt_fw_block_hdr *blk;
+ int ret;
+
+ blk = (struct catpt_fw_block_hdr *)((u8 *)mod + offset);
+
+ switch (blk->type) {
+ case CATPT_RAM_TYPE_INSTANCE:
+ /* restore module state */
+ ret = catpt_dma_memcpy_todsp(cdev, chan,
+ cdev->lpe_base + blk->ram_offset,
+ cdev->dxbuf_paddr + blk->ram_offset,
+ ALIGN(blk->size, 4));
+ break;
+ default:
+ ret = catpt_load_block(cdev, chan, paddr + offset,
+ blk, false);
+ break;
+ }
+
+ if (ret < 0) {
+ dev_err(cdev->dev, "restore block failed: %d\n", ret);
+ return ret;
+ }
+
+ offset += sizeof(*blk) + blk->size;
+ }
+
+ return 0;
+}
+
+static int catpt_load_module(struct catpt_dev *cdev,
+ struct dma_chan *chan, dma_addr_t paddr,
+ struct catpt_fw_mod_hdr *mod)
+{
+ struct catpt_module_type *type;
+ u32 offset = sizeof(*mod);
+ int i;
+
+ print_hex_dump_debug(__func__, DUMP_PREFIX_OFFSET, 8, 4,
+ mod, sizeof(*mod), false);
+
+ type = &cdev->modules[mod->id];
+
+ for (i = 0; i < mod->blocks; i++) {
+ struct catpt_fw_block_hdr *blk;
+ int ret;
+
+ blk = (struct catpt_fw_block_hdr *)((u8 *)mod + offset);
+
+ ret = catpt_load_block(cdev, chan, paddr + offset, blk, true);
+ if (ret < 0) {
+ dev_err(cdev->dev, "load block failed: %d\n", ret);
+ return ret;
+ }
+
+ /*
+ * Save state window coordinates - these will be
+ * used to capture module state on D0 exit
+ */
+ if (blk->type == CATPT_RAM_TYPE_INSTANCE) {
+ type->state_offset = blk->ram_offset;
+ type->state_size = blk->size;
+ }
+
+ offset += sizeof(*blk) + blk->size;
+ }
+
+ /* init module type static info */
+ type->loaded = true;
+ /* DSP expects address from module header substracted by 4 */
+ type->entry_point = mod->entry_point - 4;
+ type->persistent_size = mod->persistent_size;
+ type->scratch_size = mod->scratch_size;
+
+ return 0;
+}
+
+static int catpt_restore_firmware(struct catpt_dev *cdev,
+ struct dma_chan *chan, dma_addr_t paddr,
+ struct catpt_fw_hdr *fw)
+{
+ u32 offset = sizeof(*fw);
+ int i;
+
+ print_hex_dump_debug(__func__, DUMP_PREFIX_OFFSET, 8, 4,
+ fw, sizeof(*fw), false);
+
+ for (i = 0; i < fw->modules; i++) {
+ struct catpt_fw_mod_hdr *mod;
+ int ret;
+
+ mod = (struct catpt_fw_mod_hdr *)((u8 *)fw + offset);
+ if (strncmp(fw->signature, mod->signature,
+ FW_SIGNATURE_SIZE)) {
+ dev_err(cdev->dev, "module signature mismatch\n");
+ return -EINVAL;
+ }
+
+ if (mod->id > CATPT_MODID_LAST)
+ return -EINVAL;
+
+ switch (mod->id) {
+ case CATPT_MODID_BASE_FW:
+ ret = catpt_restore_basefw(cdev, chan, paddr + offset,
+ mod);
+ break;
+ default:
+ ret = catpt_restore_module(cdev, chan, paddr + offset,
+ mod);
+ break;
+ }
+
+ if (ret < 0) {
+ dev_err(cdev->dev, "restore module failed: %d\n", ret);
+ return ret;
+ }
+
+ offset += sizeof(*mod) + mod->mod_size;
+ }
+
+ return 0;
+}
+
+static int catpt_load_firmware(struct catpt_dev *cdev,
+ struct dma_chan *chan, dma_addr_t paddr,
+ struct catpt_fw_hdr *fw)
+{
+ u32 offset = sizeof(*fw);
+ int i;
+
+ print_hex_dump_debug(__func__, DUMP_PREFIX_OFFSET, 8, 4,
+ fw, sizeof(*fw), false);
+
+ for (i = 0; i < fw->modules; i++) {
+ struct catpt_fw_mod_hdr *mod;
+ int ret;
+
+ mod = (struct catpt_fw_mod_hdr *)((u8 *)fw + offset);
+ if (strncmp(fw->signature, mod->signature,
+ FW_SIGNATURE_SIZE)) {
+ dev_err(cdev->dev, "module signature mismatch\n");
+ return -EINVAL;
+ }
+
+ if (mod->id > CATPT_MODID_LAST)
+ return -EINVAL;
+
+ ret = catpt_load_module(cdev, chan, paddr + offset, mod);
+ if (ret < 0) {
+ dev_err(cdev->dev, "load module failed: %d\n", ret);
+ return ret;
+ }
+
+ offset += sizeof(*mod) + mod->mod_size;
+ }
+
+ return 0;
+}
+
+static int catpt_load_image(struct catpt_dev *cdev, struct dma_chan *chan,
+ const char *name, const char *signature,
+ bool restore)
+{
+ struct catpt_fw_hdr *fw;
+ struct firmware *img;
+ dma_addr_t paddr;
+ void *vaddr;
+ int ret;
+
+ ret = request_firmware((const struct firmware **)&img, name, cdev->dev);
+ if (ret < 0)
+ return ret;
+
+ fw = (struct catpt_fw_hdr *)img->data;
+ if (strncmp(fw->signature, signature, FW_SIGNATURE_SIZE)) {
+ dev_err(cdev->dev, "firmware signature mismatch\n");
+ ret = -EINVAL;
+ goto release_fw;
+ }
+
+ vaddr = dma_alloc_coherent(cdev->dev, img->size, &paddr, GFP_KERNEL);
+ if (!vaddr) {
+ ret = -ENOMEM;
+ goto release_fw;
+ }
+
+ memcpy(vaddr, img->data, img->size);
+ fw = (struct catpt_fw_hdr *)vaddr;
+ if (restore)
+ ret = catpt_restore_firmware(cdev, chan, paddr, fw);
+ else
+ ret = catpt_load_firmware(cdev, chan, paddr, fw);
+
+ dma_free_coherent(cdev->dev, img->size, vaddr, paddr);
+release_fw:
+ release_firmware(img);
+ return ret;
+}
+
+static int catpt_load_images(struct catpt_dev *cdev, bool restore)
+{
+ static const char *const names[] = {
+ "intel/IntcSST1.bin",
+ "intel/IntcSST2.bin",
+ };
+ struct dma_chan *chan;
+ int ret;
+
+ chan = catpt_dma_request_config_chan(cdev);
+ if (IS_ERR(chan))
+ return PTR_ERR(chan);
+
+ ret = catpt_load_image(cdev, chan, names[cdev->pdata->core_id - 1],
+ FW_SIGNATURE, restore);
+ if (ret < 0)
+ goto exit;
+
+ if (!restore)
+ goto exit;
+ ret = catpt_restore_streams_context(cdev, chan);
+ if (ret < 0)
+ dev_err(cdev->dev, "restore streams ctx failed: %d\n", ret);
+exit:
+ dma_release_channel(chan);
+ return ret;
+}
+
+int catpt_boot_firmware(struct catpt_dev *cdev, bool restore)
+{
+ int ret;
+
+ catpt_dsp_stall(cdev, true);
+
+ ret = catpt_load_images(cdev, restore);
+ if (ret < 0) {
+ dev_err(cdev->dev, "load binaries failed: %d\n", ret);
+ return ret;
+ }
+
+ reinit_completion(&cdev->fw_ready);
+ catpt_dsp_stall(cdev, false);
+
+ ret = wait_for_completion_timeout(&cdev->fw_ready,
+ msecs_to_jiffies(FW_READY_TIMEOUT_MSECS));
+ if (!ret) {
+ dev_err(cdev->dev, "firmware ready timeout\n");
+ return -ETIMEDOUT;
+ }
+
+ /* update sram pg & clock once done booting */
+ catpt_dsp_update_srampge(cdev, &cdev->dram);
+ catpt_dsp_update_srampge(cdev, &cdev->iram);
+
+ return catpt_dsp_update_lpclock(cdev);
+}
+
+int catpt_first_boot_firmware(struct catpt_dev *cdev)
+{
+ struct catpt_mregion *reg;
+ int ret;
+
+ ret = catpt_boot_firmware(cdev, false);
+ if (ret < 0) {
+ dev_err(cdev->dev, "basefw boot failed: %d\n", ret);
+ return ret;
+ }
+
+ /* restrict FW Core dump area */
+ catpt_mbank_reserve_region(&cdev->dram, 0, 0x200);
+ /* restrict entire area following BASE_FW - highest offset in DRAM */
+ reg = list_last_entry(&cdev->dram.region_list, struct catpt_mregion,
+ node);
+ reg->busy = true;
+
+ ret = catpt_ipc_get_mixer_stream_info(cdev, &cdev->mixer);
+ if (ret)
+ return CATPT_IPC_ERROR(ret);
+
+ ret = catpt_arm_stream_templates(cdev);
+ if (ret < 0) {
+ dev_err(cdev->dev, "arm templates failed: %d\n", ret);
+ return ret;
+ }
+
+ /* update dram pg for scratch and restricted regions */
+ catpt_dsp_update_srampge(cdev, &cdev->dram);
+
+ return 0;
+}
--
2.17.1
^ permalink raw reply related [flat|nested] 24+ messages in thread* [PATCH 04/13] ASoC: Intel: catpt: Implement IPC protocol
2020-08-07 11:06 [PATCH 00/13] ASoC: Intel: Catpt - Lynx and Wildcat point Cezary Rojewski
` (2 preceding siblings ...)
2020-08-07 11:06 ` [PATCH 03/13] ASoC: Intel: catpt: Firmware loading and context restore Cezary Rojewski
@ 2020-08-07 11:06 ` Cezary Rojewski
2020-08-07 11:06 ` [PATCH 05/13] ASoC: Intel: catpt: Add IPC messages Cezary Rojewski
` (10 subsequent siblings)
14 siblings, 0 replies; 24+ messages in thread
From: Cezary Rojewski @ 2020-08-07 11:06 UTC (permalink / raw)
To: alsa-devel
Cc: pierre-louis.bossart, Cezary Rojewski, andriy.shevchenko,
filip.kaczmarski, harshapriya.n, marcin.barlik, zwisler,
lgirdwood, tiwai, filip.proborszcz, broonie, michal.wasko,
cujomalainey, ppapierkowski, vamshi.krishna.gopal
Implement IRQ handlers for immediate and delayed replies and
notifications. Communication is synchronous and allows for serialization
of maximum one message at a time.
DSP may respond with ADSP_PENDING status for a request - known as
delayed reply - and when situation occurs, framework keeps the lock and
awaits upcoming response through IPCD channel which is handled in
bottom-half. Immediate replies spawn no BH at all as their processing is
very short.
Signed-off-by: Cezary Rojewski <cezary.rojewski@intel.com>
---
sound/soc/intel/catpt/dsp.c | 99 ++++++++++++
sound/soc/intel/catpt/ipc.c | 298 ++++++++++++++++++++++++++++++++++++
2 files changed, 397 insertions(+)
create mode 100644 sound/soc/intel/catpt/ipc.c
diff --git a/sound/soc/intel/catpt/dsp.c b/sound/soc/intel/catpt/dsp.c
index 137c43ca521d..fadca3ad36d8 100644
--- a/sound/soc/intel/catpt/dsp.c
+++ b/sound/soc/intel/catpt/dsp.c
@@ -5,6 +5,7 @@
// Author: Cezary Rojewski <cezary.rojewski@intel.com>
//
+#include <linux/devcoredump.h>
#include <linux/dma-mapping.h>
#include <linux/acpi_dma.h>
#include <linux/firmware.h>
@@ -489,3 +490,101 @@ int wpt_dsp_power_up(struct catpt_dev *cdev)
return 0;
}
+
+#define CATPT_DUMP_MAGIC 0xcd42
+#define CATPT_DUMP_SECTION_ID_FILE 0x00
+#define CATPT_DUMP_SECTION_ID_IRAM 0x01
+#define CATPT_DUMP_SECTION_ID_DRAM 0x02
+#define CATPT_DUMP_SECTION_ID_REGS 0x03
+
+struct catpt_dump_section_hdr {
+ u16 magic;
+ u8 core_id;
+ u8 section_id;
+ u32 size;
+};
+
+int catpt_coredump(struct catpt_dev *cdev)
+{
+ struct catpt_dump_section_hdr *hdr;
+ size_t dump_size, regs_size;
+ u8 *dump, *pos;
+ int i, j;
+
+ regs_size = CATPT_SHIM_REGS_SIZE;
+ regs_size += CATPT_DMA_COUNT * CATPT_DMA_REGS_SIZE;
+ regs_size += CATPT_SSP_COUNT * CATPT_SSP_REGS_SIZE;
+ dump_size = catpt_mbank_size(&cdev->dram);
+ dump_size += catpt_mbank_size(&cdev->iram);
+ dump_size += regs_size;
+ dump_size += 4 * sizeof(*hdr) + 20; /* hdrs and fw hash */
+
+ dump = vzalloc(dump_size);
+ if (!dump)
+ return -ENOMEM;
+
+ pos = dump;
+
+ hdr = (struct catpt_dump_section_hdr *)pos;
+ hdr->magic = CATPT_DUMP_MAGIC;
+ hdr->core_id = cdev->pdata->core_id;
+ hdr->section_id = CATPT_DUMP_SECTION_ID_FILE;
+ hdr->size = dump_size - sizeof(*hdr);
+ pos += sizeof(*hdr);
+
+ for (i = j = 0; i < FW_INFO_SIZE_MAX; i++)
+ if (cdev->ipc.config.fw_info[i] == ' ')
+ if (++j == 4)
+ break;
+ for (j = ++i; j < FW_INFO_SIZE_MAX && j - i < 20; j++) {
+ if (cdev->ipc.config.fw_info[j] == ' ')
+ break;
+ *(pos + j - i) = cdev->ipc.config.fw_info[j];
+ }
+ pos += 20;
+
+ hdr = (struct catpt_dump_section_hdr *)pos;
+ hdr->magic = CATPT_DUMP_MAGIC;
+ hdr->core_id = cdev->pdata->core_id;
+ hdr->section_id = CATPT_DUMP_SECTION_ID_IRAM;
+ hdr->size = catpt_mbank_size(&cdev->iram);
+ pos += sizeof(*hdr);
+
+ memcpy_fromio(pos, cdev->lpe_ba + cdev->iram.start, hdr->size);
+ pos += hdr->size;
+
+ hdr = (struct catpt_dump_section_hdr *)pos;
+ hdr->magic = CATPT_DUMP_MAGIC;
+ hdr->core_id = cdev->pdata->core_id;
+ hdr->section_id = CATPT_DUMP_SECTION_ID_DRAM;
+ hdr->size = catpt_mbank_size(&cdev->dram);
+ pos += sizeof(*hdr);
+
+ memcpy_fromio(pos, cdev->lpe_ba + cdev->dram.start, hdr->size);
+ pos += hdr->size;
+
+ hdr = (struct catpt_dump_section_hdr *)pos;
+ hdr->magic = CATPT_DUMP_MAGIC;
+ hdr->core_id = cdev->pdata->core_id;
+ hdr->section_id = CATPT_DUMP_SECTION_ID_REGS;
+ hdr->size = regs_size;
+ pos += sizeof(*hdr);
+
+ memcpy_fromio(pos, catpt_shim_addr(cdev), CATPT_SHIM_REGS_SIZE);
+ pos += CATPT_SHIM_REGS_SIZE;
+
+ for (i = 0; i < CATPT_SSP_COUNT; i++) {
+ memcpy_fromio(pos, catpt_ssp_addr(cdev, i),
+ CATPT_SSP_REGS_SIZE);
+ pos += CATPT_SSP_REGS_SIZE;
+ }
+ for (i = 0; i < CATPT_DMA_COUNT; i++) {
+ memcpy_fromio(pos, catpt_dma_addr(cdev, i),
+ CATPT_DMA_REGS_SIZE);
+ pos += CATPT_DMA_REGS_SIZE;
+ }
+
+ dev_coredumpv(cdev->dev, dump, dump_size, GFP_KERNEL);
+
+ return 0;
+}
diff --git a/sound/soc/intel/catpt/ipc.c b/sound/soc/intel/catpt/ipc.c
new file mode 100644
index 000000000000..a2cec2ba12e7
--- /dev/null
+++ b/sound/soc/intel/catpt/ipc.c
@@ -0,0 +1,298 @@
+// SPDX-License-Identifier: GPL-2.0-only
+//
+// Copyright(c) 2020 Intel Corporation. All rights reserved.
+//
+// Author: Cezary Rojewski <cezary.rojewski@intel.com>
+//
+
+#include <linux/irqreturn.h>
+#include "core.h"
+#include "messages.h"
+#include "registers.h"
+#include "trace.h"
+
+#define CATPT_IPC_TIMEOUT_MSECS 300
+
+void catpt_ipc_init(struct catpt_ipc *ipc, struct device *dev)
+{
+ ipc->dev = dev;
+ ipc->ready = false;
+ ipc->default_timeout = CATPT_IPC_TIMEOUT_MSECS;
+ init_completion(&ipc->done_completion);
+ init_completion(&ipc->busy_completion);
+ spin_lock_init(&ipc->lock);
+ mutex_init(&ipc->mutex);
+}
+
+static int catpt_ipc_arm(struct catpt_ipc *ipc, struct catpt_fw_ready *config)
+{
+ /*
+ * Both tx and rx are put into and received from outbox. Inbox is
+ * only used for notifications where payload size is known upfront,
+ * thus no separate buffer is allocated for it
+ */
+ ipc->rx.data = devm_kzalloc(ipc->dev, config->outbox_size, GFP_KERNEL);
+ if (!ipc->rx.data)
+ return -ENOMEM;
+
+ memcpy(&ipc->config, config, sizeof(*config));
+ ipc->ready = true;
+
+ return 0;
+}
+
+static void catpt_ipc_msg_init(struct catpt_ipc *ipc,
+ struct catpt_ipc_msg *reply)
+{
+ lockdep_assert_held(&ipc->lock);
+
+ ipc->rx.header = 0;
+ ipc->rx.size = reply ? reply->size : 0;
+ reinit_completion(&ipc->done_completion);
+ reinit_completion(&ipc->busy_completion);
+}
+
+static void catpt_dsp_send_tx(struct catpt_dev *cdev,
+ const struct catpt_ipc_msg *tx)
+{
+ u32 header = tx->header | CATPT_IPCC_BUSY;
+
+ trace_catpt_ipc_request(header);
+ trace_catpt_ipc_payload(tx->data, tx->size);
+
+ if (tx->size)
+ memcpy_toio(catpt_outbox_addr(cdev), tx->data, tx->size);
+ catpt_writel_shim(cdev, IPCC, header);
+}
+
+static int catpt_wait_msg_completion(struct catpt_dev *cdev, int timeout)
+{
+ struct catpt_ipc *ipc = &cdev->ipc;
+ int ret;
+
+ ret = wait_for_completion_timeout(&ipc->done_completion,
+ msecs_to_jiffies(timeout));
+ if (!ret)
+ return -ETIMEDOUT;
+ if (ipc->rx.rsp.status != CATPT_REPLY_PENDING)
+ return 0;
+
+ /* wait for delayed reply */
+ ret = wait_for_completion_timeout(&ipc->busy_completion,
+ msecs_to_jiffies(timeout));
+ return ret ? 0 : -ETIMEDOUT;
+}
+
+static int catpt_dsp_do_send_msg(struct catpt_dev *cdev,
+ struct catpt_ipc_msg request,
+ struct catpt_ipc_msg *reply, int timeout)
+{
+ struct catpt_ipc *ipc = &cdev->ipc;
+ unsigned long flags;
+ int ret;
+
+ if (!ipc->ready)
+ return -EPERM;
+ if (request.size > ipc->config.outbox_size ||
+ (reply && reply->size > ipc->config.outbox_size))
+ return -EINVAL;
+
+ spin_lock_irqsave(&ipc->lock, flags);
+ catpt_ipc_msg_init(ipc, reply);
+ catpt_dsp_send_tx(cdev, &request);
+ spin_unlock_irqrestore(&ipc->lock, flags);
+
+ ret = catpt_wait_msg_completion(cdev, timeout);
+ if (ret < 0) {
+ dev_crit(cdev->dev, "communication severed: %d, rebooting dsp..\n",
+ ret);
+ ipc->ready = false;
+ /* TODO: attempt recovery */
+ return ret;
+ }
+
+ ret = ipc->rx.rsp.status;
+ if (reply) {
+ reply->header = ipc->rx.header;
+ if (!ret && reply->data && reply->size)
+ memcpy(reply->data, ipc->rx.data, ipc->rx.size);
+ }
+
+ return ret;
+}
+
+int catpt_dsp_send_msg_timeout(struct catpt_dev *cdev,
+ struct catpt_ipc_msg request,
+ struct catpt_ipc_msg *reply, int timeout)
+{
+ struct catpt_ipc *ipc = &cdev->ipc;
+ int ret;
+
+ mutex_lock(&ipc->mutex);
+ ret = catpt_dsp_do_send_msg(cdev, request, reply, timeout);
+ mutex_unlock(&ipc->mutex);
+
+ return ret;
+}
+
+int catpt_dsp_send_msg(struct catpt_dev *cdev, struct catpt_ipc_msg request,
+ struct catpt_ipc_msg *reply)
+{
+ return catpt_dsp_send_msg_timeout(cdev, request, reply,
+ cdev->ipc.default_timeout);
+}
+
+static void
+catpt_dsp_notify_stream(struct catpt_dev *cdev, union catpt_notify_msg msg)
+{
+ struct catpt_stream_runtime *stream;
+ struct catpt_notify_position pos;
+ struct catpt_notify_glitch glitch;
+
+ stream = catpt_stream_find(cdev, msg.stream_hw_id);
+ if (!stream) {
+ dev_warn(cdev->dev, "notify %d for non-existent stream %d\n",
+ msg.notify_reason, msg.stream_hw_id);
+ return;
+ }
+
+ switch (msg.notify_reason) {
+ case CATPT_NOTIFY_POSITION_CHANGED:
+ memcpy_fromio(&pos, catpt_inbox_addr(cdev), sizeof(pos));
+ trace_catpt_ipc_payload((u8 *)&pos, sizeof(pos));
+
+ catpt_stream_update_position(cdev, stream, &pos);
+ break;
+
+ case CATPT_NOTIFY_GLITCH_OCCURRED:
+ memcpy_fromio(&glitch, catpt_inbox_addr(cdev), sizeof(glitch));
+ trace_catpt_ipc_payload((u8 *)&glitch, sizeof(glitch));
+
+ dev_warn(cdev->dev, "glitch %d at pos: 0x%08llx, wp: 0x%08x\n",
+ glitch.type, glitch.presentation_pos,
+ glitch.write_pos);
+ break;
+
+ default:
+ dev_warn(cdev->dev, "unknown notification: %d received\n",
+ msg.notify_reason);
+ break;
+ }
+}
+
+static void catpt_dsp_copy_rx(struct catpt_dev *cdev, u32 header)
+{
+ struct catpt_ipc *ipc = &cdev->ipc;
+
+ ipc->rx.header = header;
+ if (ipc->rx.size && ipc->rx.rsp.status == CATPT_REPLY_SUCCESS) {
+ memcpy_fromio(ipc->rx.data, catpt_outbox_addr(cdev),
+ ipc->rx.size);
+ trace_catpt_ipc_payload(ipc->rx.data, ipc->rx.size);
+ }
+}
+
+static void catpt_dsp_process_response(struct catpt_dev *cdev, u32 header)
+{
+ union catpt_notify_msg msg = CATPT_MSG(header);
+ struct catpt_ipc *ipc = &cdev->ipc;
+
+ if (msg.fw_ready) {
+ struct catpt_fw_ready config;
+ /* to fit 32b header original address is shifted right by 3 */
+ u32 off = msg.mailbox_address << 3;
+
+ memcpy_fromio(&config, cdev->lpe_ba + off, sizeof(config));
+ trace_catpt_ipc_payload((u8 *)&config, sizeof(config));
+
+ catpt_ipc_arm(ipc, &config);
+ complete(&cdev->fw_ready);
+ return;
+ }
+
+ switch (msg.type) {
+ case CATPT_GLB_REQUEST_CORE_DUMP:
+ dev_err(cdev->dev, "ADSP device coredump received\n");
+ ipc->ready = false;
+ catpt_coredump(cdev);
+ /* TODO: attempt recovery */
+ break;
+
+ case CATPT_GLB_STREAM_MESSAGE:
+ switch (msg.subtype) {
+ case CATPT_STRM_NOTIFICATION:
+ catpt_dsp_notify_stream(cdev, msg);
+ break;
+ default:
+ catpt_dsp_copy_rx(cdev, header);
+ /* signal completion of delayed reply */
+ complete(&ipc->busy_completion);
+ break;
+ }
+ break;
+
+ default:
+ dev_warn(cdev->dev, "unknown response: %d received\n",
+ msg.type);
+ break;
+ }
+}
+
+irqreturn_t catpt_dsp_irq_thread(int irq, void *dev_id)
+{
+ struct catpt_dev *cdev = dev_id;
+ u32 ipcd;
+
+ ipcd = catpt_readl_shim(cdev, IPCD);
+ trace_catpt_ipc_notify(ipcd);
+
+ /* ensure there is delayed reply or notification to process */
+ if (!(ipcd & CATPT_IPCD_BUSY))
+ return IRQ_NONE;
+
+ catpt_dsp_process_response(cdev, ipcd);
+
+ /* tell DSP processing is completed */
+ catpt_updatel_shim(cdev, IPCD, CATPT_IPCD_BUSY | CATPT_IPCD_DONE,
+ CATPT_IPCD_DONE);
+ /* unmask dsp BUSY interrupt */
+ catpt_updatel_shim(cdev, IMC, CATPT_IMC_IPCDB, 0);
+
+ return IRQ_HANDLED;
+}
+
+irqreturn_t catpt_dsp_irq_handler(int irq, void *dev_id)
+{
+ struct catpt_dev *cdev = dev_id;
+ irqreturn_t ret = IRQ_NONE;
+ u32 isc, ipcc;
+
+ isc = catpt_readl_shim(cdev, ISC);
+ trace_catpt_irq(isc);
+
+ /* immediate reply */
+ if (isc & CATPT_ISC_IPCCD) {
+ /* mask host DONE interrupt */
+ catpt_updatel_shim(cdev, IMC, CATPT_IMC_IPCCD, CATPT_IMC_IPCCD);
+
+ ipcc = catpt_readl_shim(cdev, IPCC);
+ trace_catpt_ipc_reply(ipcc);
+ catpt_dsp_copy_rx(cdev, ipcc);
+ complete(&cdev->ipc.done_completion);
+
+ /* tell DSP processing is completed */
+ catpt_updatel_shim(cdev, IPCC, CATPT_IPCC_DONE, 0);
+ /* unmask host DONE interrupt */
+ catpt_updatel_shim(cdev, IMC, CATPT_IMC_IPCCD, 0);
+ ret = IRQ_HANDLED;
+ }
+
+ /* delayed reply or notification */
+ if (isc & CATPT_ISC_IPCDB) {
+ /* mask dsp BUSY interrupt */
+ catpt_updatel_shim(cdev, IMC, CATPT_IMC_IPCDB, CATPT_IMC_IPCDB);
+ ret = IRQ_WAKE_THREAD;
+ }
+
+ return ret;
+}
--
2.17.1
^ permalink raw reply related [flat|nested] 24+ messages in thread* [PATCH 05/13] ASoC: Intel: catpt: Add IPC messages
2020-08-07 11:06 [PATCH 00/13] ASoC: Intel: Catpt - Lynx and Wildcat point Cezary Rojewski
` (3 preceding siblings ...)
2020-08-07 11:06 ` [PATCH 04/13] ASoC: Intel: catpt: Implement IPC protocol Cezary Rojewski
@ 2020-08-07 11:06 ` Cezary Rojewski
2020-08-07 11:06 ` [PATCH 06/13] ASoC: Intel: catpt: PCM operations Cezary Rojewski
` (9 subsequent siblings)
14 siblings, 0 replies; 24+ messages in thread
From: Cezary Rojewski @ 2020-08-07 11:06 UTC (permalink / raw)
To: alsa-devel
Cc: pierre-louis.bossart, Cezary Rojewski, andriy.shevchenko,
filip.kaczmarski, harshapriya.n, marcin.barlik, zwisler,
lgirdwood, tiwai, filip.proborszcz, broonie, michal.wasko,
cujomalainey, ppapierkowski, vamshi.krishna.gopal
Declare global and stream IPC message types and define appropriate
message handlers.
Signed-off-by: Cezary Rojewski <cezary.rojewski@intel.com>
---
sound/soc/intel/catpt/messages.c | 312 ++++++++++++++++++++++++
sound/soc/intel/catpt/messages.h | 402 +++++++++++++++++++++++++++++++
2 files changed, 714 insertions(+)
create mode 100644 sound/soc/intel/catpt/messages.c
create mode 100644 sound/soc/intel/catpt/messages.h
diff --git a/sound/soc/intel/catpt/messages.c b/sound/soc/intel/catpt/messages.c
new file mode 100644
index 000000000000..dd798dc2cc11
--- /dev/null
+++ b/sound/soc/intel/catpt/messages.c
@@ -0,0 +1,312 @@
+// SPDX-License-Identifier: GPL-2.0-only
+//
+// Copyright(c) 2020 Intel Corporation. All rights reserved.
+//
+// Author: Cezary Rojewski <cezary.rojewski@intel.com>
+//
+
+#include "core.h"
+#include "messages.h"
+#include "registers.h"
+
+int catpt_ipc_get_fw_version(struct catpt_dev *cdev,
+ struct catpt_fw_version *version)
+{
+ union catpt_global_msg msg = CATPT_GLOBAL_MSG(GET_FW_VERSION);
+ struct catpt_ipc_msg request = {{0}}, reply;
+ int ret;
+
+ request.header = msg.val;
+ reply.size = sizeof(*version);
+ reply.data = version;
+
+ ret = catpt_dsp_send_msg(cdev, request, &reply);
+ if (ret)
+ dev_err(cdev->dev, "get fw version failed: %d\n", ret);
+
+ return ret;
+}
+
+struct catpt_alloc_stream_input {
+ enum catpt_path_id path_id:8;
+ enum catpt_stream_type stream_type:8;
+ enum catpt_format_id format_id:8;
+ u8 reserved;
+ struct catpt_audio_format input_format;
+ struct catpt_ring_info ring_info;
+ u8 num_entries;
+ /* flex array with entries here */
+ struct catpt_memory_info persistent_mem;
+ struct catpt_memory_info scratch_mem;
+ u32 num_notifications; /* obsolete */
+} __packed;
+
+int catpt_ipc_alloc_stream(struct catpt_dev *cdev,
+ enum catpt_path_id path_id,
+ enum catpt_stream_type type,
+ struct catpt_audio_format *afmt,
+ struct catpt_ring_info *rinfo,
+ u8 num_modules,
+ struct catpt_module_entry *modules,
+ struct catpt_mregion *persistent,
+ struct catpt_mregion *scratch,
+ struct catpt_stream_info *sinfo)
+{
+ union catpt_global_msg msg = CATPT_GLOBAL_MSG(ALLOCATE_STREAM);
+ struct catpt_alloc_stream_input input;
+ struct catpt_ipc_msg request, reply;
+ size_t size, arrsz;
+ u8 *payload;
+ off_t off;
+ int ret;
+
+ off = offsetof(struct catpt_alloc_stream_input, persistent_mem);
+ arrsz = sizeof(*modules) * num_modules;
+ size = sizeof(input) + arrsz;
+
+ payload = kzalloc(size, GFP_KERNEL);
+ if (!payload)
+ return -ENOMEM;
+
+ memset(&input, 0, sizeof(input));
+ input.path_id = path_id;
+ input.stream_type = type;
+ input.format_id = CATPT_FORMAT_PCM;
+ input.input_format = *afmt;
+ input.ring_info = *rinfo;
+ input.num_entries = num_modules;
+ input.persistent_mem.offset = catpt_to_dsp_offset(persistent->start);
+ input.persistent_mem.size = catpt_mregion_size(persistent);
+ if (scratch) {
+ input.scratch_mem.offset = catpt_to_dsp_offset(scratch->start);
+ input.scratch_mem.size = catpt_mregion_size(scratch);
+ }
+
+ /* re-arrange the input: account for flex array 'entries' */
+ memcpy(payload, &input, sizeof(input));
+ memmove(payload + off + arrsz, payload + off, sizeof(input) - off);
+ memcpy(payload + off, modules, arrsz);
+
+ request.header = msg.val;
+ request.size = size;
+ request.data = payload;
+ reply.size = sizeof(*sinfo);
+ reply.data = sinfo;
+
+ ret = catpt_dsp_send_msg(cdev, request, &reply);
+ if (ret)
+ dev_err(cdev->dev, "alloc stream type %d failed: %d\n",
+ type, ret);
+
+ kfree(payload);
+ return ret;
+}
+
+int catpt_ipc_free_stream(struct catpt_dev *cdev, u8 stream_hw_id)
+{
+ union catpt_global_msg msg = CATPT_GLOBAL_MSG(FREE_STREAM);
+ struct catpt_ipc_msg request;
+ int ret;
+
+ request.header = msg.val;
+ request.size = sizeof(stream_hw_id);
+ request.data = &stream_hw_id;
+
+ ret = catpt_dsp_send_msg(cdev, request, NULL);
+ if (ret)
+ dev_err(cdev->dev, "free stream %d failed: %d\n",
+ stream_hw_id, ret);
+
+ return ret;
+}
+
+int catpt_ipc_set_device_format(struct catpt_dev *cdev,
+ struct catpt_ssp_device_format *devfmt)
+{
+ union catpt_global_msg msg = CATPT_GLOBAL_MSG(SET_DEVICE_FORMATS);
+ struct catpt_ipc_msg request;
+ int ret;
+
+ request.header = msg.val;
+ request.size = sizeof(*devfmt);
+ request.data = devfmt;
+
+ ret = catpt_dsp_send_msg(cdev, request, NULL);
+ if (ret)
+ dev_err(cdev->dev, "set device format failed: %d\n", ret);
+
+ return ret;
+}
+
+int catpt_ipc_enter_dxstate(struct catpt_dev *cdev, enum catpt_dx_state state,
+ struct catpt_dx_context *dx_ctx)
+{
+ union catpt_global_msg msg = CATPT_GLOBAL_MSG(ENTER_DX_STATE);
+ struct catpt_ipc_msg request, reply;
+ int ret;
+
+ request.header = msg.val;
+ request.size = sizeof(state);
+ request.data = &state;
+ reply.size = sizeof(*dx_ctx);
+ reply.data = dx_ctx;
+
+ ret = catpt_dsp_send_msg(cdev, request, &reply);
+ if (ret)
+ dev_err(cdev->dev, "enter dx state failed: %d\n", ret);
+
+ return ret;
+}
+
+int catpt_ipc_get_mixer_stream_info(struct catpt_dev *cdev,
+ struct catpt_mixer_stream_info *info)
+{
+ union catpt_global_msg msg = CATPT_GLOBAL_MSG(GET_MIXER_STREAM_INFO);
+ struct catpt_ipc_msg request = {{0}}, reply;
+ int ret;
+
+ request.header = msg.val;
+ reply.size = sizeof(*info);
+ reply.data = info;
+
+ ret = catpt_dsp_send_msg(cdev, request, &reply);
+ if (ret)
+ dev_err(cdev->dev, "get mixer info failed: %d\n", ret);
+
+ return ret;
+}
+
+int catpt_ipc_reset_stream(struct catpt_dev *cdev, u8 stream_hw_id)
+{
+ union catpt_stream_msg msg = CATPT_STREAM_MSG(RESET_STREAM);
+ struct catpt_ipc_msg request = {{0}};
+ int ret;
+
+ msg.stream_hw_id = stream_hw_id;
+ request.header = msg.val;
+
+ ret = catpt_dsp_send_msg(cdev, request, NULL);
+ if (ret)
+ dev_err(cdev->dev, "reset stream %d failed: %d\n",
+ stream_hw_id, ret);
+
+ return ret;
+}
+
+int catpt_ipc_pause_stream(struct catpt_dev *cdev, u8 stream_hw_id)
+{
+ union catpt_stream_msg msg = CATPT_STREAM_MSG(PAUSE_STREAM);
+ struct catpt_ipc_msg request = {{0}};
+ int ret;
+
+ msg.stream_hw_id = stream_hw_id;
+ request.header = msg.val;
+
+ ret = catpt_dsp_send_msg(cdev, request, NULL);
+ if (ret)
+ dev_err(cdev->dev, "pause stream %d failed: %d\n",
+ stream_hw_id, ret);
+
+ return ret;
+}
+
+int catpt_ipc_resume_stream(struct catpt_dev *cdev, u8 stream_hw_id)
+{
+ union catpt_stream_msg msg = CATPT_STREAM_MSG(RESUME_STREAM);
+ struct catpt_ipc_msg request = {{0}};
+ int ret;
+
+ msg.stream_hw_id = stream_hw_id;
+ request.header = msg.val;
+
+ ret = catpt_dsp_send_msg(cdev, request, NULL);
+ if (ret)
+ dev_err(cdev->dev, "resume stream %d failed: %d\n",
+ stream_hw_id, ret);
+
+ return ret;
+}
+
+struct catpt_set_volume_input {
+ u32 channel;
+ u32 target_volume;
+ u64 curve_duration;
+ enum catpt_audio_curve_type curve_type __aligned(4);
+} __packed;
+
+int catpt_ipc_set_volume(struct catpt_dev *cdev, u8 stream_hw_id,
+ u32 channel, u32 volume,
+ u32 curve_duration,
+ enum catpt_audio_curve_type curve_type)
+{
+ union catpt_stream_msg msg = CATPT_STAGE_MSG(SET_VOLUME);
+ struct catpt_ipc_msg request;
+ struct catpt_set_volume_input input;
+ int ret;
+
+ msg.stream_hw_id = stream_hw_id;
+ input.channel = channel;
+ input.target_volume = volume;
+ input.curve_duration = curve_duration;
+ input.curve_type = curve_type;
+
+ request.header = msg.val;
+ request.size = sizeof(input);
+ request.data = &input;
+
+ ret = catpt_dsp_send_msg(cdev, request, NULL);
+ if (ret)
+ dev_err(cdev->dev, "set stream %d volume failed: %d\n",
+ stream_hw_id, ret);
+
+ return ret;
+}
+
+struct catpt_set_write_pos_input {
+ u32 new_write_pos;
+ bool end_of_buffer;
+ bool low_latency;
+} __packed;
+
+int catpt_ipc_set_write_pos(struct catpt_dev *cdev, u8 stream_hw_id,
+ u32 pos, bool eob, bool ll)
+{
+ union catpt_stream_msg msg = CATPT_STAGE_MSG(SET_WRITE_POSITION);
+ struct catpt_ipc_msg request;
+ struct catpt_set_write_pos_input input;
+ int ret;
+
+ msg.stream_hw_id = stream_hw_id;
+ input.new_write_pos = pos;
+ input.end_of_buffer = eob;
+ input.low_latency = ll;
+
+ request.header = msg.val;
+ request.size = sizeof(input);
+ request.data = &input;
+
+ ret = catpt_dsp_send_msg(cdev, request, NULL);
+ if (ret)
+ dev_err(cdev->dev, "set stream %d write pos failed: %d\n",
+ stream_hw_id, ret);
+
+ return ret;
+}
+
+int catpt_ipc_mute_loopback(struct catpt_dev *cdev, u8 stream_hw_id, bool mute)
+{
+ union catpt_stream_msg msg = CATPT_STAGE_MSG(MUTE_LOOPBACK);
+ struct catpt_ipc_msg request;
+ int ret;
+
+ msg.stream_hw_id = stream_hw_id;
+ request.header = msg.val;
+ request.size = sizeof(mute);
+ request.data = &mute;
+
+ ret = catpt_dsp_send_msg(cdev, request, NULL);
+ if (ret)
+ dev_err(cdev->dev, "mute loopback failed: %d\n", ret);
+
+ return ret;
+}
diff --git a/sound/soc/intel/catpt/messages.h b/sound/soc/intel/catpt/messages.h
new file mode 100644
index 000000000000..8524e282a6a6
--- /dev/null
+++ b/sound/soc/intel/catpt/messages.h
@@ -0,0 +1,402 @@
+/* SPDX-License-Identifier: GPL-2.0-only
+ *
+ * Copyright(c) 2020 Intel Corporation. All rights reserved.
+ *
+ * Author: Cezary Rojewski <cezary.rojewski@intel.com>
+ */
+
+#ifndef __SND_SOC_INTEL_CATPT_MSG_H
+#define __SND_SOC_INTEL_CATPT_MSG_H
+
+struct catpt_dev;
+struct catpt_mregion;
+
+/* IPC messages base types */
+
+enum catpt_reply_status {
+ CATPT_REPLY_SUCCESS = 0,
+ CATPT_REPLY_ERROR_INVALID_PARAM = 1,
+ CATPT_REPLY_UNKNOWN_MESSAGE_TYPE = 2,
+ CATPT_REPLY_OUT_OF_RESOURCES = 3,
+ CATPT_REPLY_BUSY = 4,
+ CATPT_REPLY_PENDING = 5,
+ CATPT_REPLY_FAILURE = 6,
+ CATPT_REPLY_INVALID_REQUEST = 7,
+ CATPT_REPLY_UNINITIALIZED = 8,
+ CATPT_REPLY_NOT_FOUND = 9,
+ CATPT_REPLY_SOURCE_NOT_STARTED = 10,
+};
+
+/* GLOBAL messages */
+
+enum catpt_global_msg_type {
+ CATPT_GLB_GET_FW_VERSION = 0,
+ CATPT_GLB_ALLOCATE_STREAM = 3,
+ CATPT_GLB_FREE_STREAM = 4,
+ CATPT_GLB_STREAM_MESSAGE = 6,
+ CATPT_GLB_REQUEST_CORE_DUMP = 7,
+ CATPT_GLB_SET_DEVICE_FORMATS = 10,
+ CATPT_GLB_ENTER_DX_STATE = 12,
+ CATPT_GLB_GET_MIXER_STREAM_INFO = 13,
+};
+
+union catpt_global_msg {
+ u32 val;
+ struct {
+ enum catpt_reply_status status:5;
+ u32 context:19; /* stream or module specific */
+ enum catpt_global_msg_type type:5;
+ u32 fw_ready:1;
+ u32 done:1;
+ u32 busy:1;
+ };
+} __packed;
+
+#define CATPT_MSG(hdr) { .val = hdr }
+#define CATPT_GLOBAL_MSG(msg_type) \
+ { .type = CATPT_GLB_##msg_type }
+
+#define BUILD_HASH_SIZE 40
+
+struct catpt_fw_version {
+ u8 build;
+ u8 minor;
+ u8 major;
+ u8 type;
+ u8 build_hash[BUILD_HASH_SIZE];
+ u32 log_providers_hash;
+} __packed;
+
+int catpt_ipc_get_fw_version(struct catpt_dev *cdev,
+ struct catpt_fw_version *version);
+
+enum catpt_pin_id {
+ CATPT_PIN_ID_SYSTEM = 0,
+ CATPT_PIN_ID_REFERENCE = 1,
+ CATPT_PIN_ID_CAPTURE1 = 2,
+ CATPT_PIN_ID_CAPTURE2 = 3,
+ CATPT_PIN_ID_OFFLOAD1 = 4,
+ CATPT_PIN_ID_OFFLOAD2 = 5,
+ CATPT_PIN_ID_MIXER = 7,
+ CATPT_PIN_ID_BLUETOOTH_CAPTURE = 8,
+ CATPT_PIN_ID_BLUETOOTH_RENDER = 9,
+};
+
+enum catpt_path_id {
+ CATPT_PATH_SSP0_OUT = 0,
+ CATPT_PATH_SSP0_IN = 1,
+ CATPT_PATH_SSP1_OUT = 2,
+ CATPT_PATH_SSP1_IN = 3,
+ /* duplicated audio in capture path */
+ CATPT_PATH_SSP0_IN_DUP = 4,
+};
+
+enum catpt_stream_type {
+ CATPT_STRM_TYPE_RENDER = 0, /* offload */
+ CATPT_STRM_TYPE_SYSTEM = 1,
+ CATPT_STRM_TYPE_CAPTURE = 2,
+ CATPT_STRM_TYPE_LOOPBACK = 3,
+ CATPT_STRM_TYPE_BLUETOOTH_RENDER = 4,
+ CATPT_STRM_TYPE_BLUETOOTH_CAPTURE = 5,
+};
+
+enum catpt_format_id {
+ CATPT_FORMAT_PCM = 0,
+ CATPT_FORMAT_MP3 = 1,
+ CATPT_FORMAT_AAC = 2,
+ CATPT_FORMAT_WMA = 3,
+};
+
+enum catpt_channel_index {
+ CATPT_CHANNEL_LEFT = 0x0,
+ CATPT_CHANNEL_CENTER = 0x1,
+ CATPT_CHANNEL_RIGHT = 0x2,
+ CATPT_CHANNEL_LEFT_SURROUND = 0x3,
+ CATPT_CHANNEL_CENTER_SURROUND = 0x3,
+ CATPT_CHANNEL_RIGHT_SURROUND = 0x4,
+ CATPT_CHANNEL_LFE = 0x7,
+ CATPT_CHANNEL_INVALID = 0xF,
+};
+
+enum catpt_channel_config {
+ CATPT_CHANNEL_CONFIG_MONO = 0, /* One channel only */
+ CATPT_CHANNEL_CONFIG_STEREO = 1, /* L & R */
+ CATPT_CHANNEL_CONFIG_2_POINT_1 = 2, /* L, R & LFE; PCM only */
+ CATPT_CHANNEL_CONFIG_3_POINT_0 = 3, /* L, C & R; MP3 & AAC only */
+ CATPT_CHANNEL_CONFIG_3_POINT_1 = 4, /* L, C, R & LFE; PCM only */
+ CATPT_CHANNEL_CONFIG_QUATRO = 5, /* L, R, Ls & Rs; PCM only */
+ CATPT_CHANNEL_CONFIG_4_POINT_0 = 6, /* L, C, R & Cs; MP3 & AAC only */
+ CATPT_CHANNEL_CONFIG_5_POINT_0 = 7, /* L, C, R, Ls & Rs */
+ CATPT_CHANNEL_CONFIG_5_POINT_1 = 8, /* L, C, R, Ls, Rs & LFE */
+ CATPT_CHANNEL_CONFIG_DUAL_MONO = 9, /* One channel replicated in two */
+ CATPT_CHANNEL_CONFIG_INVALID = 10,
+};
+
+enum catpt_interleaving_style {
+ CATPT_INTERLEAVING_PER_CHANNEL = 0,
+ CATPT_INTERLEAVING_PER_SAMPLE = 1,
+};
+
+struct catpt_audio_format {
+ u32 sample_rate;
+ u32 bit_depth;
+ u32 channel_map;
+ enum catpt_channel_config channel_config __aligned(4);
+ enum catpt_interleaving_style interleaving __aligned(4);
+ u8 num_channels;
+ u8 valid_bit_depth;
+ u8 reserved[2];
+} __packed;
+
+struct catpt_ring_info {
+ u32 page_table_addr;
+ u32 num_pages;
+ u32 size;
+ u32 offset;
+ u32 ring_first_page_pfn;
+} __packed;
+
+#define CATPT_MODULE_COUNT (CATPT_MODID_LAST + 1)
+
+enum catpt_module_id {
+ CATPT_MODID_BASE_FW = 0x0,
+ CATPT_MODID_MP3 = 0x1,
+ CATPT_MODID_AAC_5_1 = 0x2,
+ CATPT_MODID_AAC_2_0 = 0x3,
+ CATPT_MODID_SRC = 0x4,
+ CATPT_MODID_WAVES = 0x5,
+ CATPT_MODID_DOLBY = 0x6,
+ CATPT_MODID_BOOST = 0x7,
+ CATPT_MODID_LPAL = 0x8,
+ CATPT_MODID_DTS = 0x9,
+ CATPT_MODID_PCM_CAPTURE = 0xA,
+ CATPT_MODID_PCM_SYSTEM = 0xB,
+ CATPT_MODID_PCM_REFERENCE = 0xC,
+ CATPT_MODID_PCM = 0xD, /* offload */
+ CATPT_MODID_BLUETOOTH_RENDER = 0xE,
+ CATPT_MODID_BLUETOOTH_CAPTURE = 0xF,
+ CATPT_MODID_LAST = CATPT_MODID_BLUETOOTH_CAPTURE,
+};
+
+struct catpt_module_entry {
+ enum catpt_module_id module_id __aligned(4);
+ u32 entry_point;
+} __packed;
+
+struct catpt_module_map {
+ u8 num_entries;
+ struct catpt_module_entry entries[];
+} __packed;
+
+struct catpt_memory_info {
+ u32 offset;
+ u32 size;
+} __packed;
+
+#define CATPT_CHANNELS_MAX 4
+#define CATPT_ALL_CHANNELS_MASK UINT_MAX
+
+struct catpt_stream_info {
+ u32 stream_hw_id;
+ u32 reserved;
+ u32 read_pos_regaddr;
+ u32 pres_pos_regaddr;
+ u32 peak_meter_regaddr[CATPT_CHANNELS_MAX];
+ u32 volume_regaddr[CATPT_CHANNELS_MAX];
+} __packed;
+
+int catpt_ipc_alloc_stream(struct catpt_dev *cdev,
+ enum catpt_path_id path_id,
+ enum catpt_stream_type type,
+ struct catpt_audio_format *afmt,
+ struct catpt_ring_info *rinfo,
+ u8 num_modules,
+ struct catpt_module_entry *modules,
+ struct catpt_mregion *persistent,
+ struct catpt_mregion *scratch,
+ struct catpt_stream_info *sinfo);
+int catpt_ipc_free_stream(struct catpt_dev *cdev, u8 stream_hw_id);
+
+#define CATPT_SSP_COUNT (CATPT_SSP_IFACE_LAST + 1)
+
+enum catpt_ssp_iface {
+ CATPT_SSP_IFACE_0 = 0,
+ CATPT_SSP_IFACE_1 = 1,
+ CATPT_SSP_IFACE_LAST = CATPT_SSP_IFACE_1,
+};
+
+enum catpt_mclk_frequency {
+ CATPT_MCLK_OFF = 0,
+ CATPT_MCLK_FREQ_6_MHZ = 1,
+ CATPT_MCLK_FREQ_21_MHZ = 2,
+ CATPT_MCLK_FREQ_24_MHZ = 3,
+};
+
+enum catpt_ssp_mode {
+ CATPT_SSP_MODE_I2S_SLAVE = 0,
+ CATPT_SSP_MODE_I2S_MASTER = 1,
+ CATPT_SSP_MODE_TDM_MASTER = 2,
+};
+
+struct catpt_ssp_device_format {
+ enum catpt_ssp_iface iface __aligned(4);
+ enum catpt_mclk_frequency mclk __aligned(4);
+ enum catpt_ssp_mode mode __aligned(4);
+ u16 clock_divider;
+ u8 channels;
+} __packed;
+
+int catpt_ipc_set_device_format(struct catpt_dev *cdev,
+ struct catpt_ssp_device_format *devfmt);
+
+enum catpt_dx_state {
+ CATPT_DX_STATE_D3 = 3,
+};
+
+enum catpt_dx_type {
+ CATPT_DX_TYPE_FW_IMAGE = 0,
+ CATPT_DX_TYPE_MEMORY_DUMP = 1,
+};
+
+struct catpt_save_meminfo {
+ u32 offset;
+ u32 size;
+ enum catpt_dx_type source __aligned(4);
+} __packed;
+
+#define SAVE_MEMINFO_MAX 14
+
+struct catpt_dx_context {
+ u32 num_meminfo;
+ struct catpt_save_meminfo meminfo[SAVE_MEMINFO_MAX];
+} __packed;
+
+int catpt_ipc_enter_dxstate(struct catpt_dev *cdev, enum catpt_dx_state state,
+ struct catpt_dx_context *context);
+
+struct catpt_mixer_stream_info {
+ u32 mixer_hw_id;
+ u32 peak_meter_regaddr[CATPT_CHANNELS_MAX];
+ u32 volume_regaddr[CATPT_CHANNELS_MAX];
+} __packed;
+
+int catpt_ipc_get_mixer_stream_info(struct catpt_dev *cdev,
+ struct catpt_mixer_stream_info *info);
+
+/* STREAM messages */
+
+enum catpt_stream_msg_type {
+ CATPT_STRM_RESET_STREAM = 0,
+ CATPT_STRM_PAUSE_STREAM = 1,
+ CATPT_STRM_RESUME_STREAM = 2,
+ CATPT_STRM_STAGE_MESSAGE = 3,
+ CATPT_STRM_NOTIFICATION = 4,
+};
+
+enum catpt_stage_action {
+ CATPT_STG_SET_VOLUME = 1,
+ CATPT_STG_SET_WRITE_POSITION = 2,
+ CATPT_STG_MUTE_LOOPBACK = 3,
+};
+
+union catpt_stream_msg {
+ u32 val;
+ struct {
+ enum catpt_reply_status status:5;
+ u32 reserved:7;
+ enum catpt_stage_action stage_action:4;
+ u32 stream_hw_id:4;
+ enum catpt_stream_msg_type subtype:4;
+ enum catpt_global_msg_type type:5;
+ u32 fw_ready:1;
+ u32 done:1;
+ u32 busy:1;
+ };
+} __packed;
+
+#define CATPT_STREAM_MSG(msg_type) \
+{ \
+ .subtype = CATPT_STRM_##msg_type, \
+ .type = CATPT_GLB_STREAM_MESSAGE }
+#define CATPT_STAGE_MSG(msg_type) \
+{ \
+ .stage_action = CATPT_STG_##msg_type, \
+ .subtype = CATPT_STRM_STAGE_MESSAGE, \
+ .type = CATPT_GLB_STREAM_MESSAGE }
+
+int catpt_ipc_reset_stream(struct catpt_dev *cdev, u8 stream_hw_id);
+int catpt_ipc_pause_stream(struct catpt_dev *cdev, u8 stream_hw_id);
+int catpt_ipc_resume_stream(struct catpt_dev *cdev, u8 stream_hw_id);
+
+/* STREAM messages - STAGE subtype */
+
+enum catpt_audio_curve_type {
+ CATPT_AUDIO_CURVE_NONE = 0,
+ CATPT_AUDIO_CURVE_WINDOWS_FADE = 1,
+};
+
+int catpt_ipc_set_volume(struct catpt_dev *cdev, u8 stream_hw_id,
+ u32 channel, u32 volume,
+ u32 curve_duration,
+ enum catpt_audio_curve_type curve_type);
+
+int catpt_ipc_set_write_pos(struct catpt_dev *cdev, u8 stream_hw_id,
+ u32 pos, bool eob, bool ll);
+
+int catpt_ipc_mute_loopback(struct catpt_dev *cdev, u8 stream_hw_id, bool mute);
+
+/* NOTIFICATION messages */
+
+enum catpt_notify_reason {
+ CATPT_NOTIFY_POSITION_CHANGED = 0,
+ CATPT_NOTIFY_GLITCH_OCCURRED = 1,
+};
+
+union catpt_notify_msg {
+ u32 val;
+ struct {
+ u32 mailbox_address:29;
+ u32 fw_ready:1;
+ u32 done:1;
+ u32 busy:1;
+ };
+ struct {
+ enum catpt_reply_status status:5;
+ u32 reserved:7;
+ enum catpt_notify_reason notify_reason:4;
+ u32 stream_hw_id:4;
+ enum catpt_stream_msg_type subtype:4;
+ enum catpt_global_msg_type type:5;
+ u32 hdr:3; /* fw_ready, done, busy */
+ };
+} __packed;
+
+#define FW_INFO_SIZE_MAX 100
+
+struct catpt_fw_ready {
+ u32 inbox_offset;
+ u32 outbox_offset;
+ u32 inbox_size;
+ u32 outbox_size;
+ u32 fw_info_size;
+ char fw_info[FW_INFO_SIZE_MAX];
+} __packed;
+
+struct catpt_notify_position {
+ u32 stream_position;
+ u32 fw_cycle_count;
+} __packed;
+
+enum catpt_glitch_type {
+ CATPT_GLITCH_UNDERRUN = 1,
+ CATPT_GLITCH_DECODER_ERROR = 2,
+ CATPT_GLITCH_DOUBLED_WRITE_POS = 3,
+};
+
+struct catpt_notify_glitch {
+ enum catpt_glitch_type type __aligned(4);
+ u64 presentation_pos;
+ u32 write_pos;
+} __packed;
+
+#endif
--
2.17.1
^ permalink raw reply related [flat|nested] 24+ messages in thread* [PATCH 06/13] ASoC: Intel: catpt: PCM operations
2020-08-07 11:06 [PATCH 00/13] ASoC: Intel: Catpt - Lynx and Wildcat point Cezary Rojewski
` (4 preceding siblings ...)
2020-08-07 11:06 ` [PATCH 05/13] ASoC: Intel: catpt: Add IPC messages Cezary Rojewski
@ 2020-08-07 11:06 ` Cezary Rojewski
2020-08-07 11:06 ` [PATCH 07/13] ASoC: Intel: catpt: Event tracing Cezary Rojewski
` (8 subsequent siblings)
14 siblings, 0 replies; 24+ messages in thread
From: Cezary Rojewski @ 2020-08-07 11:06 UTC (permalink / raw)
To: alsa-devel
Cc: pierre-louis.bossart, Cezary Rojewski, andriy.shevchenko,
filip.kaczmarski, harshapriya.n, marcin.barlik, zwisler,
lgirdwood, tiwai, filip.proborszcz, broonie, michal.wasko,
cujomalainey, ppapierkowski, vamshi.krishna.gopal
DSP designed for Lynxpoint and Wildcat Point offers no dynamic topology
i.e. all pipelines are already defined within firmware and host is
relegated to allocing stream for predefined pins. This is represented by
'catpt_topology' member.
Implementation covers all available pin types:
- system playback and capture
- two offload streams
- loopback (reference)
- bluetooth playback and capture
PCM DAI operations differentiate between those pins as some (mainly
offload) are to be handled differently - DSP expects wp updates on each
notify_position notification.
System playback has no volume control capability as it is routed to
mixer stream directly. Other primary streams - capture and two offloads
- offer individual volume controls.
Compared to sound/soc/intel/haswell this configures SSP device format
automatically on pcm creation.
Signed-off-by: Cezary Rojewski <cezary.rojewski@intel.com>
---
sound/soc/intel/catpt/pcm.c | 1194 +++++++++++++++++++++++++++++++++++
1 file changed, 1194 insertions(+)
create mode 100644 sound/soc/intel/catpt/pcm.c
diff --git a/sound/soc/intel/catpt/pcm.c b/sound/soc/intel/catpt/pcm.c
new file mode 100644
index 000000000000..2e1158eaa7ff
--- /dev/null
+++ b/sound/soc/intel/catpt/pcm.c
@@ -0,0 +1,1194 @@
+// SPDX-License-Identifier: GPL-2.0-pcm
+//
+// Copyright(c) 2020 Intel Corporation. All rights reserved.
+//
+// Author: Cezary Rojewski <cezary.rojewski@intel.com>
+//
+
+#include <linux/pm_runtime.h>
+#include <sound/soc.h>
+#include <sound/pcm_params.h>
+#include <uapi/sound/tlv.h>
+#include "core.h"
+#include "messages.h"
+
+struct catpt_stream_template {
+ enum catpt_path_id path_id;
+ enum catpt_stream_type type;
+ u32 persistent_size;
+ u8 num_entries;
+ struct catpt_module_entry entries[];
+};
+
+static struct catpt_stream_template system_pb = {
+ .path_id = CATPT_PATH_SSP0_OUT,
+ .type = CATPT_STRM_TYPE_SYSTEM,
+ .num_entries = 1,
+ .entries = {{ CATPT_MODID_PCM_SYSTEM, 0 }},
+};
+
+static struct catpt_stream_template system_cp = {
+ .path_id = CATPT_PATH_SSP0_IN,
+ .type = CATPT_STRM_TYPE_CAPTURE,
+ .num_entries = 1,
+ .entries = {{ CATPT_MODID_PCM_CAPTURE, 0 }},
+};
+
+static struct catpt_stream_template offload_pb = {
+ .path_id = CATPT_PATH_SSP0_OUT,
+ .type = CATPT_STRM_TYPE_RENDER,
+ .num_entries = 1,
+ .entries = {{ CATPT_MODID_PCM, 0 }},
+};
+
+static struct catpt_stream_template loopback_cp = {
+ .path_id = CATPT_PATH_SSP0_OUT,
+ .type = CATPT_STRM_TYPE_LOOPBACK,
+ .num_entries = 1,
+ .entries = {{ CATPT_MODID_PCM_REFERENCE, 0 }},
+};
+
+static struct catpt_stream_template bluetooth_pb = {
+ .path_id = CATPT_PATH_SSP1_OUT,
+ .type = CATPT_STRM_TYPE_BLUETOOTH_RENDER,
+ .num_entries = 1,
+ .entries = {{ CATPT_MODID_BLUETOOTH_RENDER, 0 }},
+};
+
+static struct catpt_stream_template bluetooth_cp = {
+ .path_id = CATPT_PATH_SSP1_IN,
+ .type = CATPT_STRM_TYPE_BLUETOOTH_CAPTURE,
+ .num_entries = 1,
+ .entries = {{ CATPT_MODID_BLUETOOTH_CAPTURE, 0 }},
+};
+
+static struct catpt_stream_template *catpt_topology[] = {
+ [CATPT_STRM_TYPE_RENDER] = &offload_pb,
+ [CATPT_STRM_TYPE_SYSTEM] = &system_pb,
+ [CATPT_STRM_TYPE_CAPTURE] = &system_cp,
+ [CATPT_STRM_TYPE_LOOPBACK] = &loopback_cp,
+ [CATPT_STRM_TYPE_BLUETOOTH_RENDER] = &bluetooth_pb,
+ [CATPT_STRM_TYPE_BLUETOOTH_CAPTURE] = &bluetooth_cp,
+};
+
+static struct catpt_stream_template *
+catpt_get_stream_template(struct snd_pcm_substream *substream)
+{
+ struct snd_soc_pcm_runtime *rtm = substream->private_data;
+ struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtm, 0);
+ enum catpt_stream_type type;
+
+ type = cpu_dai->driver->id;
+
+ /* account for capture in bidirectional dais */
+ switch (type) {
+ case CATPT_STRM_TYPE_SYSTEM:
+ if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
+ type = CATPT_STRM_TYPE_CAPTURE;
+ break;
+ case CATPT_STRM_TYPE_BLUETOOTH_RENDER:
+ if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
+ type = CATPT_STRM_TYPE_BLUETOOTH_CAPTURE;
+ break;
+ default:
+ break;
+ };
+
+ return catpt_topology[type];
+}
+
+struct catpt_stream_runtime *
+catpt_stream_find(struct catpt_dev *cdev, u8 stream_hw_id)
+{
+ struct catpt_stream_runtime *pos, *result = NULL;
+
+ spin_lock(&cdev->list_lock);
+ list_for_each_entry(pos, &cdev->stream_list, node) {
+ if (pos->info.stream_hw_id == stream_hw_id) {
+ result = pos;
+ break;
+ }
+ }
+
+ spin_unlock(&cdev->list_lock);
+ return result;
+}
+
+static u32 catpt_stream_read_position(struct catpt_dev *cdev,
+ struct catpt_stream_runtime *stream)
+{
+ u32 pos;
+
+ memcpy_fromio(&pos, cdev->lpe_ba + stream->info.read_pos_regaddr,
+ sizeof(pos));
+ return pos;
+}
+
+static u32 catpt_stream_volume(struct catpt_dev *cdev,
+ struct catpt_stream_runtime *stream, u32 channel)
+{
+ u32 volume, offset;
+
+ if (channel >= CATPT_CHANNELS_MAX)
+ channel = 0;
+
+ offset = stream->info.volume_regaddr[channel];
+ memcpy_fromio(&volume, cdev->lpe_ba + offset, sizeof(volume));
+ return volume;
+}
+
+static u32 catpt_mixer_volume(struct catpt_dev *cdev,
+ struct catpt_mixer_stream_info *info, u32 channel)
+{
+ u32 volume, offset;
+
+ if (channel >= CATPT_CHANNELS_MAX)
+ channel = 0;
+
+ offset = info->volume_regaddr[channel];
+ memcpy_fromio(&volume, cdev->lpe_ba + offset, sizeof(volume));
+ return volume;
+}
+
+static void catpt_arrange_page_table(struct snd_pcm_substream *substream,
+ struct snd_dma_buffer *pgtbl)
+{
+ struct snd_pcm_runtime *rtm = substream->runtime;
+ struct snd_dma_buffer *databuf = snd_pcm_get_dma_buf(substream);
+ int i, pages;
+
+ pages = snd_sgbuf_aligned_pages(rtm->dma_bytes);
+
+ for (i = 0; i < pages; i++) {
+ u32 pfn, offset;
+ u32 *page_table;
+
+ pfn = snd_sgbuf_get_addr(databuf, i * PAGE_SIZE) >> PAGE_SHIFT;
+ /* incrementing by 2 on even and 3 on odd */
+ offset = ((i << 2) + i) >> 1;
+ page_table = (u32 *)(pgtbl->area + offset);
+
+ if (i & 1)
+ *page_table |= (pfn << 4);
+ else
+ *page_table |= pfn;
+ }
+}
+
+static u32 catpt_get_channel_map(enum catpt_channel_config config)
+{
+ switch (config) {
+ case CATPT_CHANNEL_CONFIG_MONO:
+ return (0xFFFFFFF0 | CATPT_CHANNEL_CENTER);
+
+ case CATPT_CHANNEL_CONFIG_STEREO:
+ return (0xFFFFFF00 | CATPT_CHANNEL_LEFT
+ | (CATPT_CHANNEL_RIGHT << 4));
+
+ case CATPT_CHANNEL_CONFIG_2_POINT_1:
+ return (0xFFFFF000 | CATPT_CHANNEL_LEFT
+ | (CATPT_CHANNEL_RIGHT << 4)
+ | (CATPT_CHANNEL_LFE << 8));
+
+ case CATPT_CHANNEL_CONFIG_3_POINT_0:
+ return (0xFFFFF000 | CATPT_CHANNEL_LEFT
+ | (CATPT_CHANNEL_CENTER << 4)
+ | (CATPT_CHANNEL_RIGHT << 8));
+
+ case CATPT_CHANNEL_CONFIG_3_POINT_1:
+ return (0xFFFF0000 | CATPT_CHANNEL_LEFT
+ | (CATPT_CHANNEL_CENTER << 4)
+ | (CATPT_CHANNEL_RIGHT << 8)
+ | (CATPT_CHANNEL_LFE << 12));
+
+ case CATPT_CHANNEL_CONFIG_QUATRO:
+ return (0xFFFF0000 | CATPT_CHANNEL_LEFT
+ | (CATPT_CHANNEL_RIGHT << 4)
+ | (CATPT_CHANNEL_LEFT_SURROUND << 8)
+ | (CATPT_CHANNEL_RIGHT_SURROUND << 12));
+
+ case CATPT_CHANNEL_CONFIG_4_POINT_0:
+ return (0xFFFF0000 | CATPT_CHANNEL_LEFT
+ | (CATPT_CHANNEL_CENTER << 4)
+ | (CATPT_CHANNEL_RIGHT << 8)
+ | (CATPT_CHANNEL_CENTER_SURROUND << 12));
+
+ case CATPT_CHANNEL_CONFIG_5_POINT_0:
+ return (0xFFF00000 | CATPT_CHANNEL_LEFT
+ | (CATPT_CHANNEL_CENTER << 4)
+ | (CATPT_CHANNEL_RIGHT << 8)
+ | (CATPT_CHANNEL_LEFT_SURROUND << 12)
+ | (CATPT_CHANNEL_RIGHT_SURROUND << 16));
+
+ case CATPT_CHANNEL_CONFIG_5_POINT_1:
+ return (0xFF000000 | CATPT_CHANNEL_CENTER
+ | (CATPT_CHANNEL_LEFT << 4)
+ | (CATPT_CHANNEL_RIGHT << 8)
+ | (CATPT_CHANNEL_LEFT_SURROUND << 12)
+ | (CATPT_CHANNEL_RIGHT_SURROUND << 16)
+ | (CATPT_CHANNEL_LFE << 20));
+
+ case CATPT_CHANNEL_CONFIG_DUAL_MONO:
+ return (0xFFFFFF00 | CATPT_CHANNEL_LEFT
+ | (CATPT_CHANNEL_LEFT << 4));
+
+ default:
+ return 0xFFFFFFFF;
+ }
+}
+
+static enum catpt_channel_config catpt_get_channel_config(u32 num_channels)
+{
+ switch (num_channels) {
+ case 6:
+ return CATPT_CHANNEL_CONFIG_5_POINT_1;
+ case 5:
+ return CATPT_CHANNEL_CONFIG_5_POINT_0;
+ case 4:
+ return CATPT_CHANNEL_CONFIG_QUATRO;
+ case 3:
+ return CATPT_CHANNEL_CONFIG_2_POINT_1;
+ case 1:
+ return CATPT_CHANNEL_CONFIG_MONO;
+ case 2:
+ default:
+ return CATPT_CHANNEL_CONFIG_STEREO;
+ }
+}
+
+static int catpt_dai_startup(struct snd_pcm_substream *substream,
+ struct snd_soc_dai *dai)
+{
+ struct catpt_dev *cdev = dev_get_drvdata(dai->dev);
+ struct catpt_stream_template *template;
+ struct catpt_stream_runtime *stream;
+ struct catpt_mregion *reg;
+ int ret;
+
+ template = catpt_get_stream_template(substream);
+
+ stream = kzalloc(sizeof(*stream), GFP_KERNEL);
+ if (!stream)
+ return -ENOMEM;
+
+ ret = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, cdev->dev, PAGE_SIZE,
+ &stream->pgtbl);
+ if (ret < 0)
+ goto pgtbl_err;
+
+ reg = catpt_mbank_request_region(&cdev->dram,
+ template->persistent_size);
+ if (IS_ERR(reg)) {
+ ret = PTR_ERR(reg);
+ goto request_err;
+ }
+
+ catpt_dsp_update_srampge(cdev, &cdev->dram);
+
+ stream->template = template;
+ stream->persistent = reg;
+ stream->substream = substream;
+ INIT_LIST_HEAD(&stream->node);
+ snd_soc_dai_set_dma_data(dai, substream, stream);
+
+ spin_lock(&cdev->list_lock);
+ list_add_tail(&stream->node, &cdev->stream_list);
+ spin_unlock(&cdev->list_lock);
+
+ return 0;
+
+request_err:
+ snd_dma_free_pages(&stream->pgtbl);
+pgtbl_err:
+ kfree(stream);
+ return ret;
+}
+
+static void catpt_dai_shutdown(struct snd_pcm_substream *substream,
+ struct snd_soc_dai *dai)
+{
+ struct catpt_dev *cdev = dev_get_drvdata(dai->dev);
+ struct catpt_stream_runtime *stream;
+
+ stream = snd_soc_dai_get_dma_data(dai, substream);
+
+ spin_lock(&cdev->list_lock);
+ list_del(&stream->node);
+ spin_unlock(&cdev->list_lock);
+
+ catpt_mbank_release_region(&cdev->dram, stream->persistent);
+ catpt_dsp_update_srampge(cdev, &cdev->dram);
+
+ snd_dma_free_pages(&stream->pgtbl);
+ kfree(stream);
+ snd_soc_dai_set_dma_data(dai, substream, NULL);
+}
+
+static int catpt_dai_hw_params(struct snd_pcm_substream *substream,
+ struct snd_pcm_hw_params *params,
+ struct snd_soc_dai *dai)
+{
+ struct catpt_dev *cdev = dev_get_drvdata(dai->dev);
+ struct catpt_stream_runtime *stream;
+ struct catpt_audio_format afmt;
+ struct catpt_ring_info rinfo;
+ struct snd_pcm_runtime *rtm = substream->runtime;
+ struct snd_dma_buffer *dmab;
+ int ret;
+
+ stream = snd_soc_dai_get_dma_data(dai, substream);
+ if (stream->allocated)
+ return 0;
+
+ memset(&afmt, 0, sizeof(afmt));
+ afmt.sample_rate = params_rate(params);
+ afmt.bit_depth = params_physical_width(params);
+ afmt.valid_bit_depth = params_width(params);
+ afmt.bit_depth = params_physical_width(params);
+ afmt.valid_bit_depth = params_width(params);
+ afmt.num_channels = params_channels(params);
+ afmt.channel_config = catpt_get_channel_config(afmt.num_channels);
+ afmt.channel_map = catpt_get_channel_map(afmt.channel_config);
+ afmt.interleaving = CATPT_INTERLEAVING_PER_CHANNEL;
+
+ dmab = snd_pcm_get_dma_buf(substream);
+ catpt_arrange_page_table(substream, &stream->pgtbl);
+
+ memset(&rinfo, 0, sizeof(rinfo));
+ rinfo.page_table_addr = stream->pgtbl.addr;
+ rinfo.num_pages = DIV_ROUND_UP(rtm->dma_bytes, PAGE_SIZE);
+ rinfo.size = rtm->dma_bytes;
+ rinfo.offset = 0;
+ rinfo.ring_first_page_pfn = snd_sgbuf_get_addr(dmab, 0) >> PAGE_SHIFT;
+
+ ret = catpt_ipc_alloc_stream(cdev, stream->template->path_id,
+ stream->template->type,
+ &afmt, &rinfo,
+ stream->template->num_entries,
+ stream->template->entries,
+ stream->persistent,
+ cdev->scratch,
+ &stream->info);
+ if (ret)
+ return CATPT_IPC_ERROR(ret);
+
+ stream->allocated = true;
+ return 0;
+}
+
+static int catpt_dai_hw_free(struct snd_pcm_substream *substream,
+ struct snd_soc_dai *dai)
+{
+ struct catpt_dev *cdev = dev_get_drvdata(dai->dev);
+ struct catpt_stream_runtime *stream;
+
+ stream = snd_soc_dai_get_dma_data(dai, substream);
+ if (!stream->allocated)
+ return 0;
+
+ catpt_ipc_reset_stream(cdev, stream->info.stream_hw_id);
+ catpt_ipc_free_stream(cdev, stream->info.stream_hw_id);
+
+ stream->allocated = false;
+ return 0;
+}
+
+static int catpt_set_ctlvol(struct catpt_dev *cdev, u8 stream_id, long *ctlvol);
+
+static int catpt_dai_apply_usettings(struct snd_soc_dai *dai,
+ struct catpt_stream_runtime *stream)
+{
+ struct catpt_dev *cdev = dev_get_drvdata(dai->dev);
+ struct snd_soc_component *component = dai->component;
+ struct snd_kcontrol *pos, *kctl = NULL;
+ int ret;
+ u32 id;
+
+ /* only selected streams have individual controls */
+ if (stream->template->type != CATPT_STRM_TYPE_RENDER &&
+ stream->template->type != CATPT_STRM_TYPE_CAPTURE &&
+ stream->template->type != CATPT_STRM_TYPE_LOOPBACK)
+ return 0;
+
+ id = stream->info.stream_hw_id;
+ list_for_each_entry(pos, &component->card->snd_card->controls, list) {
+ if (pos->id.device == id && pos->private_data == component) {
+ kctl = pos;
+ break;
+ }
+ }
+ if (!kctl)
+ return -ENOENT;
+
+ if (stream->template->type != CATPT_STRM_TYPE_LOOPBACK)
+ return catpt_set_ctlvol(cdev, stream->info.stream_hw_id,
+ (long *)kctl->private_value);
+
+ ret = catpt_ipc_mute_loopback(cdev, id, *(bool *)kctl->private_value);
+ if (ret)
+ return CATPT_IPC_ERROR(ret);
+ return 0;
+}
+
+static int catpt_dai_prepare(struct snd_pcm_substream *substream,
+ struct snd_soc_dai *dai)
+{
+ struct catpt_dev *cdev = dev_get_drvdata(dai->dev);
+ struct catpt_stream_runtime *stream;
+ int ret;
+
+ stream = snd_soc_dai_get_dma_data(dai, substream);
+ if (stream->prepared)
+ return 0;
+
+ ret = catpt_ipc_reset_stream(cdev, stream->info.stream_hw_id);
+ if (ret)
+ return CATPT_IPC_ERROR(ret);
+
+ ret = catpt_ipc_pause_stream(cdev, stream->info.stream_hw_id);
+ if (ret)
+ return CATPT_IPC_ERROR(ret);
+
+ ret = catpt_dsp_update_lpclock(cdev);
+ if (ret < 0)
+ return ret;
+
+ ret = catpt_dai_apply_usettings(dai, stream);
+ if (ret < 0)
+ return ret;
+
+ stream->prepared = true;
+ return 0;
+}
+
+static int catpt_dai_trigger(struct snd_pcm_substream *substream, int cmd,
+ struct snd_soc_dai *dai)
+{
+ struct catpt_dev *cdev = dev_get_drvdata(dai->dev);
+ struct catpt_stream_runtime *stream;
+ struct snd_pcm_runtime *runtime = substream->runtime;
+ snd_pcm_uframes_t pos;
+ int ret;
+
+ stream = snd_soc_dai_get_dma_data(dai, substream);
+
+ switch (cmd) {
+ case SNDRV_PCM_TRIGGER_START:
+ /* only offload is set_write_pos driven */
+ if (stream->template->type != CATPT_STRM_TYPE_RENDER)
+ goto resume_stream;
+
+ pos = frames_to_bytes(runtime, runtime->start_threshold);
+ /*
+ * Dsp operates on buffer halves, thus max 2x set_write_pos
+ * (entire buffer filled) prior to stream start
+ */
+ ret = catpt_ipc_set_write_pos(cdev, stream->info.stream_hw_id,
+ pos, false, false);
+ if (ret)
+ return CATPT_IPC_ERROR(ret);
+ fallthrough;
+ case SNDRV_PCM_TRIGGER_RESUME:
+ case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+ resume_stream:
+ ret = catpt_ipc_resume_stream(cdev, stream->info.stream_hw_id);
+ if (ret)
+ return CATPT_IPC_ERROR(ret);
+ break;
+
+ case SNDRV_PCM_TRIGGER_STOP:
+ stream->prepared = false;
+ catpt_dsp_update_lpclock(cdev);
+ fallthrough;
+ case SNDRV_PCM_TRIGGER_SUSPEND:
+ case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+ ret = catpt_ipc_pause_stream(cdev, stream->info.stream_hw_id);
+ if (ret)
+ return CATPT_IPC_ERROR(ret);
+ break;
+
+ default:
+ break;
+ }
+
+ return 0;
+}
+
+void catpt_stream_update_position(struct catpt_dev *cdev,
+ struct catpt_stream_runtime *stream,
+ struct catpt_notify_position *pos)
+{
+ struct snd_pcm_substream *substream = stream->substream;
+ struct snd_pcm_runtime *r = substream->runtime;
+ snd_pcm_uframes_t dsppos, newpos;
+ int ret;
+
+ dsppos = bytes_to_frames(r, pos->stream_position);
+
+ /* only offload is set_write_pos driven */
+ if (stream->template->type != CATPT_STRM_TYPE_RENDER)
+ goto exit;
+
+ if (dsppos >= r->buffer_size / 2)
+ newpos = r->buffer_size / 2;
+ else
+ newpos = 0;
+ /*
+ * Dsp operates on buffer halves, thus on every notify position
+ * (buffer half consumed) update wp to allow stream progression
+ */
+ ret = catpt_ipc_set_write_pos(cdev, stream->info.stream_hw_id,
+ frames_to_bytes(r, newpos),
+ false, false);
+ if (ret) {
+ dev_err(cdev->dev, "update position for stream %d failed: %d\n",
+ stream->info.stream_hw_id, ret);
+ return;
+ }
+exit:
+ snd_pcm_period_elapsed(substream);
+}
+
+#define CATPT_BUFFER_MAX_SIZE 76800 /* 200ms native format */
+#define CATPT_PCM_PERIODS_MAX 4
+#define CATPT_PCM_PERIODS_MIN 2
+
+static const struct snd_pcm_hardware catpt_pcm_hardware = {
+ .info = SNDRV_PCM_INFO_MMAP |
+ SNDRV_PCM_INFO_MMAP_VALID |
+ SNDRV_PCM_INFO_INTERLEAVED |
+ SNDRV_PCM_INFO_PAUSE |
+ SNDRV_PCM_INFO_RESUME |
+ SNDRV_PCM_INFO_NO_PERIOD_WAKEUP,
+ .formats = SNDRV_PCM_FMTBIT_S16_LE |
+ SNDRV_PCM_FMTBIT_S24_LE |
+ SNDRV_PCM_FMTBIT_S32_LE,
+ .period_bytes_min = PAGE_SIZE,
+ .period_bytes_max = CATPT_BUFFER_MAX_SIZE / CATPT_PCM_PERIODS_MIN,
+ .periods_min = CATPT_PCM_PERIODS_MIN,
+ .periods_max = CATPT_PCM_PERIODS_MAX,
+ .buffer_bytes_max = CATPT_BUFFER_MAX_SIZE,
+};
+
+static int catpt_component_pcm_construct(struct snd_soc_component *component,
+ struct snd_soc_pcm_runtime *rtd)
+{
+ struct catpt_dev *cdev = dev_get_drvdata(component->dev);
+
+ snd_pcm_set_managed_buffer_all(rtd->pcm, SNDRV_DMA_TYPE_DEV_SG,
+ cdev->dev,
+ catpt_pcm_hardware.buffer_bytes_max,
+ catpt_pcm_hardware.buffer_bytes_max);
+
+ return 0;
+}
+
+static int catpt_component_open(struct snd_soc_component *component,
+ struct snd_pcm_substream *substream)
+{
+ struct snd_soc_pcm_runtime *rtm = substream->private_data;
+
+ if (rtm->dai_link->no_pcm)
+ return 0;
+ snd_soc_set_runtime_hwparams(substream, &catpt_pcm_hardware);
+ return 0;
+}
+
+static snd_pcm_uframes_t
+catpt_component_pointer(struct snd_soc_component *component,
+ struct snd_pcm_substream *substream)
+{
+ struct catpt_dev *cdev = dev_get_drvdata(component->dev);
+ struct catpt_stream_runtime *stream;
+ struct snd_soc_pcm_runtime *rtm = substream->private_data;
+ struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtm, 0);
+ u32 pos;
+
+ if (rtm->dai_link->no_pcm)
+ return 0;
+
+ stream = snd_soc_dai_get_dma_data(cpu_dai, substream);
+ pos = catpt_stream_read_position(cdev, stream);
+
+ return bytes_to_frames(substream->runtime, pos);
+}
+
+static const struct snd_soc_dai_ops catpt_fe_dai_ops = {
+ .startup = catpt_dai_startup,
+ .shutdown = catpt_dai_shutdown,
+ .hw_params = catpt_dai_hw_params,
+ .hw_free = catpt_dai_hw_free,
+ .prepare = catpt_dai_prepare,
+ .trigger = catpt_dai_trigger,
+};
+
+static int catpt_dai_pcm_new(struct snd_soc_pcm_runtime *rtd,
+ struct snd_soc_dai *dai)
+{
+ struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
+ struct catpt_dev *cdev = dev_get_drvdata(dai->dev);
+ struct catpt_ssp_device_format devfmt;
+ int ret;
+
+ devfmt.iface = dai->driver->id;
+ devfmt.channels = codec_dai->driver->capture.channels_max;
+
+ switch (devfmt.iface) {
+ case CATPT_SSP_IFACE_0:
+ devfmt.mclk = CATPT_MCLK_FREQ_24_MHZ;
+
+ switch (devfmt.channels) {
+ case 4:
+ devfmt.mode = CATPT_SSP_MODE_TDM_MASTER;
+ devfmt.clock_divider = 4;
+ break;
+ case 2:
+ default:
+ devfmt.mode = CATPT_SSP_MODE_I2S_MASTER;
+ devfmt.clock_divider = 9;
+ break;
+ }
+ break;
+
+ case CATPT_SSP_IFACE_1:
+ devfmt.mclk = CATPT_MCLK_OFF;
+ devfmt.mode = CATPT_SSP_MODE_I2S_SLAVE;
+ devfmt.clock_divider = 0;
+ break;
+ }
+
+ ret = catpt_ipc_set_device_format(cdev, &devfmt);
+ if (ret)
+ return CATPT_IPC_ERROR(ret);
+
+ /* store device format set for given SSP */
+ memcpy(&cdev->devfmt[devfmt.iface], &devfmt, sizeof(devfmt));
+ return 0;
+}
+
+static struct snd_soc_dai_driver dai_drivers[] = {
+/* FE DAIs */
+{
+ .name = "System Pin",
+ .id = CATPT_STRM_TYPE_SYSTEM,
+ .ops = &catpt_fe_dai_ops,
+ .playback = {
+ .stream_name = "System Playback",
+ .channels_min = 2,
+ .channels_max = 2,
+ .rates = SNDRV_PCM_RATE_48000,
+ .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE,
+ },
+ .capture = {
+ .stream_name = "Analog Capture",
+ .channels_min = 2,
+ .channels_max = 4,
+ .rates = SNDRV_PCM_RATE_48000,
+ .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE,
+ },
+},
+{
+ .name = "Offload0 Pin",
+ .id = CATPT_STRM_TYPE_RENDER,
+ .ops = &catpt_fe_dai_ops,
+ .playback = {
+ .stream_name = "Offload0 Playback",
+ .channels_min = 2,
+ .channels_max = 2,
+ .rates = SNDRV_PCM_RATE_8000_192000,
+ .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE,
+ },
+},
+{
+ .name = "Offload1 Pin",
+ .id = CATPT_STRM_TYPE_RENDER,
+ .ops = &catpt_fe_dai_ops,
+ .playback = {
+ .stream_name = "Offload1 Playback",
+ .channels_min = 2,
+ .channels_max = 2,
+ .rates = SNDRV_PCM_RATE_8000_192000,
+ .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE,
+ },
+},
+{
+ .name = "Loopback Pin",
+ .id = CATPT_STRM_TYPE_LOOPBACK,
+ .ops = &catpt_fe_dai_ops,
+ .capture = {
+ .stream_name = "Loopback Capture",
+ .channels_min = 2,
+ .channels_max = 2,
+ .rates = SNDRV_PCM_RATE_48000,
+ .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE,
+ },
+},
+{
+ .name = "Bluetooth Pin",
+ .id = CATPT_STRM_TYPE_BLUETOOTH_RENDER,
+ .ops = &catpt_fe_dai_ops,
+ .playback = {
+ .stream_name = "Bluetooth Playback",
+ .channels_min = 1,
+ .channels_max = 1,
+ .rates = SNDRV_PCM_RATE_8000,
+ .formats = SNDRV_PCM_FMTBIT_S16_LE,
+ },
+ .capture = {
+ .stream_name = "Bluetooth Capture",
+ .channels_min = 1,
+ .channels_max = 1,
+ .rates = SNDRV_PCM_RATE_8000,
+ .formats = SNDRV_PCM_FMTBIT_S16_LE,
+ },
+},
+/* BE DAIs */
+{
+ .name = "ssp0-port",
+ .id = CATPT_SSP_IFACE_0,
+ .pcm_new = catpt_dai_pcm_new,
+ .playback = {
+ .channels_min = 1,
+ .channels_max = 8,
+ },
+ .capture = {
+ .channels_min = 1,
+ .channels_max = 8,
+ },
+},
+{
+ .name = "ssp1-port",
+ .id = CATPT_SSP_IFACE_1,
+ .pcm_new = catpt_dai_pcm_new,
+ .playback = {
+ .channels_min = 1,
+ .channels_max = 8,
+ },
+ .capture = {
+ .channels_min = 1,
+ .channels_max = 8,
+ },
+},
+};
+
+#define DSP_VOLUME_MAX 0x7FFFFFFF /* 0db */
+
+static const u32 volume_map[] = {
+ DSP_VOLUME_MAX >> 30,
+ DSP_VOLUME_MAX >> 29,
+ DSP_VOLUME_MAX >> 28,
+ DSP_VOLUME_MAX >> 27,
+ DSP_VOLUME_MAX >> 26,
+ DSP_VOLUME_MAX >> 25,
+ DSP_VOLUME_MAX >> 24,
+ DSP_VOLUME_MAX >> 23,
+ DSP_VOLUME_MAX >> 22,
+ DSP_VOLUME_MAX >> 21,
+ DSP_VOLUME_MAX >> 20,
+ DSP_VOLUME_MAX >> 19,
+ DSP_VOLUME_MAX >> 18,
+ DSP_VOLUME_MAX >> 17,
+ DSP_VOLUME_MAX >> 16,
+ DSP_VOLUME_MAX >> 15,
+ DSP_VOLUME_MAX >> 14,
+ DSP_VOLUME_MAX >> 13,
+ DSP_VOLUME_MAX >> 12,
+ DSP_VOLUME_MAX >> 11,
+ DSP_VOLUME_MAX >> 10,
+ DSP_VOLUME_MAX >> 9,
+ DSP_VOLUME_MAX >> 8,
+ DSP_VOLUME_MAX >> 7,
+ DSP_VOLUME_MAX >> 6,
+ DSP_VOLUME_MAX >> 5,
+ DSP_VOLUME_MAX >> 4,
+ DSP_VOLUME_MAX >> 3,
+ DSP_VOLUME_MAX >> 2,
+ DSP_VOLUME_MAX >> 1,
+ DSP_VOLUME_MAX >> 0,
+};
+
+static u32 ctlvol_to_dspvol(u32 value)
+{
+ if (value >= ARRAY_SIZE(volume_map))
+ value = 0;
+ return volume_map[value];
+}
+
+static u32 dspvol_to_ctlvol(u32 volume)
+{
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(volume_map); i++)
+ if (volume_map[i] >= volume)
+ return i;
+ return i - 1;
+}
+
+static int catpt_set_ctlvol(struct catpt_dev *cdev, u8 stream_id, long *ctlvol)
+{
+ u32 dspvol;
+ int ret, i;
+
+ if (ctlvol[0] == ctlvol[1]) {
+ dspvol = ctlvol_to_dspvol(ctlvol[0]);
+
+ ret = catpt_ipc_set_volume(cdev, stream_id,
+ CATPT_ALL_CHANNELS_MASK, dspvol,
+ 0, CATPT_AUDIO_CURVE_NONE);
+ } else {
+ for (i = 0; i < CATPT_CHANNELS_MAX; i++) {
+ dspvol = ctlvol_to_dspvol(ctlvol[i]);
+
+ ret = catpt_ipc_set_volume(cdev, stream_id,
+ i, dspvol,
+ 0, CATPT_AUDIO_CURVE_NONE);
+ if (ret)
+ goto exit;
+ }
+ }
+exit:
+ if (ret)
+ return CATPT_IPC_ERROR(ret);
+ return 0;
+}
+
+static int catpt_volume_info(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_info *uinfo)
+{
+ uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+ uinfo->count = CATPT_CHANNELS_MAX;
+ uinfo->value.integer.min = 0;
+ uinfo->value.integer.max = ARRAY_SIZE(volume_map) - 1;
+ return 0;
+}
+
+static int catpt_mixer_volume_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ struct snd_soc_component *component =
+ snd_soc_kcontrol_component(kcontrol);
+ struct catpt_dev *cdev = dev_get_drvdata(component->dev);
+ u32 dspvol;
+ int i;
+
+ pm_runtime_get_sync(cdev->dev);
+
+ for (i = 0; i < CATPT_CHANNELS_MAX; i++) {
+ dspvol = catpt_mixer_volume(cdev, &cdev->mixer, i);
+ ucontrol->value.integer.value[i] = dspvol_to_ctlvol(dspvol);
+ }
+
+ pm_runtime_mark_last_busy(cdev->dev);
+ pm_runtime_put_autosuspend(cdev->dev);
+
+ return 0;
+}
+
+static int catpt_mixer_volume_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ struct snd_soc_component *component =
+ snd_soc_kcontrol_component(kcontrol);
+ struct catpt_dev *cdev = dev_get_drvdata(component->dev);
+ int ret;
+
+ pm_runtime_get_sync(cdev->dev);
+
+ ret = catpt_set_ctlvol(cdev, cdev->mixer.mixer_hw_id,
+ ucontrol->value.integer.value);
+
+ pm_runtime_mark_last_busy(cdev->dev);
+ pm_runtime_put_autosuspend(cdev->dev);
+
+ return ret;
+}
+
+static int catpt_stream_volume_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ struct snd_soc_component *component =
+ snd_soc_kcontrol_component(kcontrol);
+ struct catpt_dev *cdev = dev_get_drvdata(component->dev);
+ struct catpt_stream_runtime *stream;
+ long *ctlvol = (long *)kcontrol->private_value;
+ u32 dspvol;
+ int i;
+
+ stream = catpt_stream_find(cdev, kcontrol->id.device);
+ if (!stream) {
+ for (i = 0; i < CATPT_CHANNELS_MAX; i++)
+ ucontrol->value.integer.value[i] = ctlvol[i];
+ return 0;
+ }
+
+ pm_runtime_get_sync(cdev->dev);
+
+ for (i = 0; i < CATPT_CHANNELS_MAX; i++) {
+ dspvol = catpt_stream_volume(cdev, stream, i);
+ ucontrol->value.integer.value[i] = dspvol_to_ctlvol(dspvol);
+ }
+
+ pm_runtime_mark_last_busy(cdev->dev);
+ pm_runtime_put_autosuspend(cdev->dev);
+
+ return 0;
+}
+
+static int catpt_stream_volume_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ struct snd_soc_component *component =
+ snd_soc_kcontrol_component(kcontrol);
+ struct catpt_dev *cdev = dev_get_drvdata(component->dev);
+ struct catpt_stream_runtime *stream;
+ long *ctlvol = (long *)kcontrol->private_value;
+ int ret, i;
+
+ stream = catpt_stream_find(cdev, kcontrol->id.device);
+ if (!stream) {
+ for (i = 0; i < CATPT_CHANNELS_MAX; i++)
+ ctlvol[i] = ucontrol->value.integer.value[i];
+ return 0;
+ }
+
+ pm_runtime_get_sync(cdev->dev);
+
+ ret = catpt_set_ctlvol(cdev, stream->info.stream_hw_id,
+ ucontrol->value.integer.value);
+
+ pm_runtime_mark_last_busy(cdev->dev);
+ pm_runtime_put_autosuspend(cdev->dev);
+
+ if (ret < 0)
+ return ret;
+
+ for (i = 0; i < CATPT_CHANNELS_MAX; i++)
+ ctlvol[i] = ucontrol->value.integer.value[i];
+ return 0;
+}
+
+static int catpt_loopback_switch_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ ucontrol->value.integer.value[0] = *(bool *)kcontrol->private_value;
+ return 0;
+}
+
+static int catpt_loopback_switch_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ struct snd_soc_component *component =
+ snd_soc_kcontrol_component(kcontrol);
+ struct catpt_dev *cdev = dev_get_drvdata(component->dev);
+ struct catpt_stream_runtime *stream;
+ bool mute;
+ int ret;
+
+ mute = (bool)ucontrol->value.integer.value[0];
+
+ stream = catpt_stream_find(cdev, kcontrol->id.device);
+ if (!stream) {
+ *(bool *)kcontrol->private_value = mute;
+ return 0;
+ }
+
+ pm_runtime_get_sync(cdev->dev);
+
+ ret = catpt_ipc_mute_loopback(cdev, stream->info.stream_hw_id, mute);
+
+ pm_runtime_mark_last_busy(cdev->dev);
+ pm_runtime_put_autosuspend(cdev->dev);
+
+ if (ret)
+ return CATPT_IPC_ERROR(ret);
+
+ *(bool *)kcontrol->private_value = mute;
+ return 0;
+}
+
+static const SNDRV_CTL_TLVD_DECLARE_DB_SCALE(catpt_volume_tlv, -9000, 300, 1);
+
+static int catpt_component_probe(struct snd_soc_component *component)
+{
+ struct snd_kcontrol_new templates[5];
+ struct snd_kcontrol_new volctl = {
+ .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+ .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |
+ SNDRV_CTL_ELEM_ACCESS_READWRITE,
+ .info = catpt_volume_info,
+ .tlv.p = catpt_volume_tlv,
+ };
+ void *p;
+ int i;
+
+ /* master volume (mixer stream) */
+ templates[0] = volctl;
+ templates[0].name = "Master Playback Volume";
+ templates[0].get = catpt_mixer_volume_get;
+ templates[0].put = catpt_mixer_volume_put;
+
+ /* individual volume controls for offload and capture */
+ for (i = 1; i < 4; i++) {
+ /* volume storage for each of CATPT_CHANNELS_MAX */
+ p = devm_kcalloc(component->dev, CATPT_CHANNELS_MAX,
+ sizeof(long), GFP_KERNEL);
+ if (!p)
+ return -ENOMEM;
+ templates[i] = volctl;
+ templates[i].get = catpt_stream_volume_get;
+ templates[i].put = catpt_stream_volume_put;
+ templates[i].private_value = (unsigned long)p;
+ }
+
+ templates[1].name = "Media0 Playback Volume";
+ templates[1].device = CATPT_PIN_ID_OFFLOAD1;
+ templates[2].name = "Media1 Playback Volume";
+ templates[2].device = CATPT_PIN_ID_OFFLOAD2;
+ templates[3].name = "Mic Capture Volume";
+ templates[3].device = CATPT_PIN_ID_CAPTURE1;
+
+ /* reference stream mute */
+ p = devm_kzalloc(component->dev, sizeof(bool), GFP_KERNEL);
+ if (!p)
+ return -ENOMEM;
+ templates[4] = (struct snd_kcontrol_new)
+ SOC_SINGLE_BOOL_EXT("Loopback Mute", (unsigned long)p,
+ catpt_loopback_switch_get,
+ catpt_loopback_switch_put);
+ templates[4].device = CATPT_PIN_ID_REFERENCE;
+
+ return snd_soc_add_component_controls(component, templates,
+ ARRAY_SIZE(templates));
+}
+
+static int catpt_waves_switch_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ return 0;
+}
+
+static int catpt_waves_switch_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ return 0;
+}
+
+static int catpt_waves_param_get(struct snd_kcontrol *kcontrol,
+ unsigned int __user *bytes,
+ unsigned int size)
+{
+ return 0;
+}
+
+static int catpt_waves_param_put(struct snd_kcontrol *kcontrol,
+ const unsigned int __user *bytes,
+ unsigned int size)
+{
+ return 0;
+}
+
+static const struct snd_kcontrol_new component_kcontrols[] = {
+/* Enable or disable WAVES module */
+SOC_SINGLE_BOOL_EXT("Waves Switch", 0,
+ catpt_waves_switch_get, catpt_waves_switch_put),
+/* WAVES module parameter control */
+SND_SOC_BYTES_TLV("Waves Set Param", 128,
+ catpt_waves_param_get, catpt_waves_param_put),
+};
+
+static const struct snd_soc_dapm_widget component_widgets[] = {
+ SND_SOC_DAPM_AIF_IN("SSP0 CODEC IN", NULL, 0, SND_SOC_NOPM, 0, 0),
+ SND_SOC_DAPM_AIF_OUT("SSP0 CODEC OUT", NULL, 0, SND_SOC_NOPM, 0, 0),
+ SND_SOC_DAPM_AIF_IN("SSP1 BT IN", NULL, 0, SND_SOC_NOPM, 0, 0),
+ SND_SOC_DAPM_AIF_OUT("SSP1 BT OUT", NULL, 0, SND_SOC_NOPM, 0, 0),
+
+ SND_SOC_DAPM_MIXER("Playback VMixer", SND_SOC_NOPM, 0, 0, NULL, 0),
+};
+
+static const struct snd_soc_dapm_route component_routes[] = {
+ {"Playback VMixer", NULL, "System Playback"},
+ {"Playback VMixer", NULL, "Offload0 Playback"},
+ {"Playback VMixer", NULL, "Offload1 Playback"},
+
+ {"SSP0 CODEC OUT", NULL, "Playback VMixer"},
+
+ {"Analog Capture", NULL, "SSP0 CODEC IN"},
+ {"Loopback Capture", NULL, "SSP0 CODEC IN"},
+
+ {"SSP1 BT OUT", NULL, "Bluetooth Playback"},
+ {"Bluetooth Capture", NULL, "SSP1 BT IN"},
+};
+
+static const struct snd_soc_component_driver catpt_comp_driver = {
+ .name = "catpt-platform",
+
+ .probe = catpt_component_probe,
+ .pcm_construct = catpt_component_pcm_construct,
+ .open = catpt_component_open,
+ .pointer = catpt_component_pointer,
+
+ .controls = component_kcontrols,
+ .num_controls = ARRAY_SIZE(component_kcontrols),
+ .dapm_widgets = component_widgets,
+ .num_dapm_widgets = ARRAY_SIZE(component_widgets),
+ .dapm_routes = component_routes,
+ .num_dapm_routes = ARRAY_SIZE(component_routes),
+};
+
+int catpt_arm_stream_templates(struct catpt_dev *cdev)
+{
+ struct catpt_mregion *reg;
+ u32 scratch_size = 0;
+ int i, j;
+
+ for (i = 0; i < ARRAY_SIZE(catpt_topology); i++) {
+ struct catpt_stream_template *template;
+ struct catpt_module_entry *entry;
+ struct catpt_module_type *type;
+
+ template = catpt_topology[i];
+ template->persistent_size = 0;
+
+ for (j = 0; j < template->num_entries; j++) {
+ entry = &template->entries[j];
+ type = &cdev->modules[entry->module_id];
+
+ if (!type->loaded)
+ return -ENOENT;
+
+ entry->entry_point = type->entry_point;
+ template->persistent_size += type->persistent_size;
+ if (type->scratch_size > scratch_size)
+ scratch_size = type->scratch_size;
+ }
+ }
+
+ if (scratch_size) {
+ /* allocate single scratch area for all modules */
+ reg = catpt_mbank_request_region(&cdev->dram, scratch_size);
+ if (IS_ERR(reg))
+ return PTR_ERR(reg);
+ cdev->scratch = reg;
+ }
+
+ return 0;
+}
+
+int catpt_register_plat_component(struct catpt_dev *cdev)
+{
+ struct snd_soc_component *component;
+ int ret;
+
+ component = devm_kzalloc(cdev->dev, sizeof(*component), GFP_KERNEL);
+ if (!component)
+ return -ENOMEM;
+
+ ret = snd_soc_component_initialize(component, &catpt_comp_driver,
+ cdev->dev);
+ if (ret < 0)
+ return ret;
+
+ component->name = catpt_comp_driver.name;
+ return snd_soc_add_component(component, dai_drivers,
+ ARRAY_SIZE(dai_drivers));
+}
--
2.17.1
^ permalink raw reply related [flat|nested] 24+ messages in thread* [PATCH 07/13] ASoC: Intel: catpt: Event tracing
2020-08-07 11:06 [PATCH 00/13] ASoC: Intel: Catpt - Lynx and Wildcat point Cezary Rojewski
` (5 preceding siblings ...)
2020-08-07 11:06 ` [PATCH 06/13] ASoC: Intel: catpt: PCM operations Cezary Rojewski
@ 2020-08-07 11:06 ` Cezary Rojewski
2020-08-07 15:09 ` Mark Brown
2020-08-07 11:06 ` [PATCH 08/13] ASoC: Intel: catpt: Simple sysfs attributes Cezary Rojewski
` (7 subsequent siblings)
14 siblings, 1 reply; 24+ messages in thread
From: Cezary Rojewski @ 2020-08-07 11:06 UTC (permalink / raw)
To: alsa-devel
Cc: pierre-louis.bossart, Cezary Rojewski, andriy.shevchenko,
filip.kaczmarski, harshapriya.n, marcin.barlik, zwisler,
lgirdwood, tiwai, filip.proborszcz, broonie, michal.wasko,
cujomalainey, ppapierkowski, vamshi.krishna.gopal
Define tracing macros for easy catpt debug. These are divided into
memory, registry and ipc event categories.
Signed-off-by: Cezary Rojewski <cezary.rojewski@intel.com>
---
sound/soc/intel/catpt/trace.h | 169 ++++++++++++++++++++++++++++++++++
1 file changed, 169 insertions(+)
create mode 100644 sound/soc/intel/catpt/trace.h
diff --git a/sound/soc/intel/catpt/trace.h b/sound/soc/intel/catpt/trace.h
new file mode 100644
index 000000000000..92f79667b73b
--- /dev/null
+++ b/sound/soc/intel/catpt/trace.h
@@ -0,0 +1,169 @@
+/* SPDX-License-Identifier: GPL-2.0
+ *
+ * Copyright(c) 2020 Intel Corporation. All rights reserved.
+ *
+ * Author: Cezary Rojewski <cezary.rojewski@intel.com>
+ */
+
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM intel_catpt
+
+#if !defined(__SND_SOC_INTEL_CATPT_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
+#define __SND_SOC_INTEL_CATPT_TRACE_H
+
+#include <linux/types.h>
+#include <linux/tracepoint.h>
+
+struct catpt_mbank;
+struct catpt_mregion;
+
+TRACE_EVENT(catpt_mbank,
+ TP_PROTO(struct catpt_mbank *sram, const char *action,
+ u32 start, u32 end),
+
+ TP_ARGS(sram, action, start, end),
+
+ TP_STRUCT__entry(
+ __field(u32, bank_start)
+ __field(u32, bank_end)
+ __string(action, action)
+ __field(u32, start)
+ __field(u32, end)
+ ),
+
+ TP_fast_assign(
+ __entry->bank_start = sram->start;
+ __entry->bank_end = sram->end;
+ __assign_str(action, action);
+ __entry->start = start;
+ __entry->end = end;
+ ),
+
+ TP_printk("[0x%08x-%08x] %s 0x%08x-%08x",
+ __entry->bank_start, __entry->bank_end,
+ __get_str(action),
+ __entry->start, __entry->end)
+);
+
+TRACE_EVENT(catpt_mregion,
+ TP_PROTO(struct catpt_mregion *r1, struct catpt_mregion *r2,
+ const char *action),
+
+ TP_ARGS(r1, r2, action),
+
+ TP_STRUCT__entry(
+ __field(u32, r1_start)
+ __field(u32, r1_end)
+ __field(u32, r2_start)
+ __field(u32, r2_end)
+ __string(action, action)
+ ),
+
+ TP_fast_assign(
+ __entry->r1_start = r1->start;
+ __entry->r1_end = r1->end;
+ __entry->r2_start = r2->start;
+ __entry->r2_end = r2->end;
+ __assign_str(action, action);
+ ),
+
+ TP_printk("0x%08x-%08x %s 0x%08x-%08x",
+ __entry->r1_start, __entry->r1_end,
+ __get_str(action),
+ __entry->r2_start, __entry->r2_end)
+);
+
+TRACE_EVENT(catpt_updatel,
+
+ TP_PROTO(const char *title, u32 mask, u32 old, u32 new),
+
+ TP_ARGS(title, mask, old, new),
+
+ TP_STRUCT__entry(
+ __string(title, title)
+ __field(u32, mask)
+ __field(u32, old)
+ __field(u32, new)
+ ),
+
+ TP_fast_assign(
+ __assign_str(title, title);
+ __entry->mask = mask;
+ __entry->old = old;
+ __entry->new = new;
+ ),
+
+ TP_printk("%s [0x%08x] 0x%08x -> 0x%08x",
+ __get_str(title),
+ __entry->mask,
+ __entry->old,
+ __entry->new)
+);
+
+DECLARE_EVENT_CLASS(catpt_ipc_msg,
+
+ TP_PROTO(u32 header),
+
+ TP_ARGS(header),
+
+ TP_STRUCT__entry(
+ __field(u32, header)
+ ),
+
+ TP_fast_assign(
+ __entry->header = header;
+ ),
+
+ TP_printk("0x%08x", __entry->header)
+);
+
+DEFINE_EVENT(catpt_ipc_msg, catpt_irq,
+ TP_PROTO(u32 header),
+ TP_ARGS(header)
+);
+
+DEFINE_EVENT(catpt_ipc_msg, catpt_ipc_request,
+ TP_PROTO(u32 header),
+ TP_ARGS(header)
+);
+
+DEFINE_EVENT(catpt_ipc_msg, catpt_ipc_reply,
+ TP_PROTO(u32 header),
+ TP_ARGS(header)
+);
+
+DEFINE_EVENT(catpt_ipc_msg, catpt_ipc_notify,
+ TP_PROTO(u32 header),
+ TP_ARGS(header)
+);
+
+TRACE_EVENT_CONDITION(catpt_ipc_payload,
+
+ TP_PROTO(const u8 *data, size_t size),
+
+ TP_ARGS(data, size),
+
+ TP_CONDITION(data && size),
+
+ TP_STRUCT__entry(
+ __dynamic_array(u8, buf, size)
+ ),
+
+ TP_fast_assign(
+ memcpy(__get_dynamic_array(buf), data, size);
+ ),
+
+ TP_printk("%u byte(s)%s",
+ __get_dynamic_array_len(buf),
+ __print_hex_dump("", DUMP_PREFIX_NONE, 16, 4,
+ __get_dynamic_array(buf),
+ __get_dynamic_array_len(buf), false))
+);
+
+#endif /* __SND_SOC_INTEL_CATPT_TRACE_H */
+
+/* This part must be outside protection */
+#undef TRACE_INCLUDE_PATH
+#define TRACE_INCLUDE_PATH .
+#define TRACE_INCLUDE_FILE trace
+#include <trace/define_trace.h>
--
2.17.1
^ permalink raw reply related [flat|nested] 24+ messages in thread* Re: [PATCH 07/13] ASoC: Intel: catpt: Event tracing
2020-08-07 11:06 ` [PATCH 07/13] ASoC: Intel: catpt: Event tracing Cezary Rojewski
@ 2020-08-07 15:09 ` Mark Brown
2020-08-10 7:16 ` Cezary Rojewski
0 siblings, 1 reply; 24+ messages in thread
From: Mark Brown @ 2020-08-07 15:09 UTC (permalink / raw)
To: Cezary Rojewski
Cc: pierre-louis.bossart, alsa-devel, andriy.shevchenko,
filip.kaczmarski, harshapriya.n, marcin.barlik, zwisler,
lgirdwood, tiwai, filip.proborszcz, michal.wasko, cujomalainey,
ppapierkowski, vamshi.krishna.gopal
[-- Attachment #1: Type: text/plain, Size: 478 bytes --]
On Fri, Aug 07, 2020 at 01:06:43PM +0200, Cezary Rojewski wrote:
> Define tracing macros for easy catpt debug. These are divided into
> memory, registry and ipc event categories.
>
> Signed-off-by: Cezary Rojewski <cezary.rojewski@intel.com>
> ---
> sound/soc/intel/catpt/trace.h | 169 ++++++++++++++++++++++++++++++++++
Usually events go into include/trace/events/
> +/* SPDX-License-Identifier: GPL-2.0
This needs to be a separate comment to match the spec.
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: [PATCH 07/13] ASoC: Intel: catpt: Event tracing
2020-08-07 15:09 ` Mark Brown
@ 2020-08-10 7:16 ` Cezary Rojewski
2020-08-11 7:30 ` Cezary Rojewski
0 siblings, 1 reply; 24+ messages in thread
From: Cezary Rojewski @ 2020-08-10 7:16 UTC (permalink / raw)
To: Mark Brown
Cc: pierre-louis.bossart, alsa-devel, andriy.shevchenko,
filip.kaczmarski, harshapriya.n, marcin.barlik, zwisler,
lgirdwood, tiwai, filip.proborszcz, michal.wasko, cujomalainey,
ppapierkowski, vamshi.krishna.gopal
On 2020-08-07 5:09 PM, Mark Brown wrote:
> On Fri, Aug 07, 2020 at 01:06:43PM +0200, Cezary Rojewski wrote:
>> Define tracing macros for easy catpt debug. These are divided into
>> memory, registry and ipc event categories.
>>
>> Signed-off-by: Cezary Rojewski <cezary.rojewski@intel.com>
>> ---
>> sound/soc/intel/catpt/trace.h | 169 ++++++++++++++++++++++++++++++++++
>
> Usually events go into include/trace/events/
>
Thought TRACE_INCLUDE_FILE/ _PATH are designed specifically to remove
the need for trace.h to go into mentioned folder. Based my decision on
fact that sound/hda and sound/core have their traces defined locally.
What's the preferred way?
>> +/* SPDX-License-Identifier: GPL-2.0
>
> This needs to be a separate comment to match the spec.
>
Ack.
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: [PATCH 07/13] ASoC: Intel: catpt: Event tracing
2020-08-10 7:16 ` Cezary Rojewski
@ 2020-08-11 7:30 ` Cezary Rojewski
2020-08-11 9:40 ` Mark Brown
0 siblings, 1 reply; 24+ messages in thread
From: Cezary Rojewski @ 2020-08-11 7:30 UTC (permalink / raw)
To: Mark Brown
Cc: pierre-louis.bossart, alsa-devel, andriy.shevchenko,
filip.kaczmarski, harshapriya.n, marcin.barlik, zwisler,
lgirdwood, tiwai, filip.proborszcz, michal.wasko, cujomalainey,
ppapierkowski, vamshi.krishna.gopal
On 2020-08-10 9:16 AM, Cezary Rojewski wrote:
> On 2020-08-07 5:09 PM, Mark Brown wrote:
>> On Fri, Aug 07, 2020 at 01:06:43PM +0200, Cezary Rojewski wrote:
>>> Define tracing macros for easy catpt debug. These are divided into
>>> memory, registry and ipc event categories.
>>>
>>> Signed-off-by: Cezary Rojewski <cezary.rojewski@intel.com>
>>> ---
>>> sound/soc/intel/catpt/trace.h | 169 ++++++++++++++++++++++++++++++++++
>>
>> Usually events go into include/trace/events/
>>
>
> Thought TRACE_INCLUDE_FILE/ _PATH are designed specifically to remove
> the need for trace.h to go into mentioned folder. Based my decision on
> fact that sound/hda and sound/core have their traces defined locally.
>
> What's the preferred way?
>
In regard to preferences, one more question Mark, if I may:
snd_soc_catpt vs snd_soc_intel_catpt
while developers usually prefer the shorter ones, I understand there
might be some subsystem level preferences and currently chosen name
could have easily slipped reviewers given the length of patchset.
Czarek
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: [PATCH 07/13] ASoC: Intel: catpt: Event tracing
2020-08-11 7:30 ` Cezary Rojewski
@ 2020-08-11 9:40 ` Mark Brown
0 siblings, 0 replies; 24+ messages in thread
From: Mark Brown @ 2020-08-11 9:40 UTC (permalink / raw)
To: Cezary Rojewski
Cc: pierre-louis.bossart, alsa-devel, andriy.shevchenko,
filip.kaczmarski, harshapriya.n, marcin.barlik, zwisler,
lgirdwood, tiwai, filip.proborszcz, michal.wasko, cujomalainey,
ppapierkowski, vamshi.krishna.gopal
[-- Attachment #1: Type: text/plain, Size: 759 bytes --]
On Tue, Aug 11, 2020 at 09:30:20AM +0200, Cezary Rojewski wrote:
> On 2020-08-10 9:16 AM, Cezary Rojewski wrote:
> > Thought TRACE_INCLUDE_FILE/ _PATH are designed specifically to remove
> > the need for trace.h to go into mentioned folder. Based my decision on
> > fact that sound/hda and sound/core have their traces defined locally.
> > What's the preferred way?
If other sound stuff is using this it's fine.
> In regard to preferences, one more question Mark, if I may:
> snd_soc_catpt vs snd_soc_intel_catpt
> while developers usually prefer the shorter ones, I understand there might
> be some subsystem level preferences and currently chosen name could have
> easily slipped reviewers given the length of patchset.
I don't care either way here.
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 24+ messages in thread
* [PATCH 08/13] ASoC: Intel: catpt: Simple sysfs attributes
2020-08-07 11:06 [PATCH 00/13] ASoC: Intel: Catpt - Lynx and Wildcat point Cezary Rojewski
` (6 preceding siblings ...)
2020-08-07 11:06 ` [PATCH 07/13] ASoC: Intel: catpt: Event tracing Cezary Rojewski
@ 2020-08-07 11:06 ` Cezary Rojewski
2020-08-07 15:00 ` Mark Brown
2020-08-07 11:06 ` [PATCH 09/13] ASoC: Intel: Select catpt and deprecate haswell Cezary Rojewski
` (6 subsequent siblings)
14 siblings, 1 reply; 24+ messages in thread
From: Cezary Rojewski @ 2020-08-07 11:06 UTC (permalink / raw)
To: alsa-devel
Cc: pierre-louis.bossart, Cezary Rojewski, andriy.shevchenko,
filip.kaczmarski, harshapriya.n, marcin.barlik, zwisler,
lgirdwood, tiwai, filip.proborszcz, broonie, michal.wasko,
cujomalainey, ppapierkowski, vamshi.krishna.gopal
Add sysfs entries for displaying version of FW currently in use as well
as binary dump of entire version info, including build and log providers
hashes.
Signed-off-by: Cezary Rojewski <cezary.rojewski@intel.com>
---
sound/soc/intel/catpt/fs.c | 79 ++++++++++++++++++++++++++++++++++++++
1 file changed, 79 insertions(+)
create mode 100644 sound/soc/intel/catpt/fs.c
diff --git a/sound/soc/intel/catpt/fs.c b/sound/soc/intel/catpt/fs.c
new file mode 100644
index 000000000000..5102641b57f1
--- /dev/null
+++ b/sound/soc/intel/catpt/fs.c
@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: GPL-2.0-pcm
+//
+// Copyright(c) 2020 Intel Corporation. All rights reserved.
+//
+// Author: Cezary Rojewski <cezary.rojewski@intel.com>
+//
+
+#include <linux/pm_runtime.h>
+#include "core.h"
+
+static ssize_t fw_version_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct catpt_dev *cdev = dev_get_drvdata(dev);
+ struct catpt_fw_version version;
+ int ret;
+
+ pm_runtime_get_sync(cdev->dev);
+
+ ret = catpt_ipc_get_fw_version(cdev, &version);
+
+ pm_runtime_mark_last_busy(cdev->dev);
+ pm_runtime_put_autosuspend(cdev->dev);
+
+ if (ret)
+ return CATPT_IPC_ERROR(ret);
+
+ return sprintf(buf, "%d.%d.%d.%d\n", version.type, version.major,
+ version.minor, version.build);
+}
+
+static DEVICE_ATTR_RO(fw_version);
+
+static ssize_t fw_build_read(struct file *filp, struct kobject *kobj,
+ struct bin_attribute *bin_attr, char *buf,
+ loff_t off, size_t count)
+{
+ struct catpt_dev *cdev = dev_get_drvdata(kobj_to_dev(kobj));
+ struct catpt_fw_version version;
+ int ret;
+
+ pm_runtime_get_sync(cdev->dev);
+
+ ret = catpt_ipc_get_fw_version(cdev, &version);
+
+ pm_runtime_mark_last_busy(cdev->dev);
+ pm_runtime_put_autosuspend(cdev->dev);
+
+ if (ret)
+ return CATPT_IPC_ERROR(ret);
+
+ memcpy(buf, &version, count);
+ return count;
+}
+
+static BIN_ATTR_RO(fw_build, sizeof(struct catpt_fw_version));
+
+int catpt_sysfs_create(struct catpt_dev *cdev)
+{
+ int ret;
+
+ ret = sysfs_create_file(&cdev->dev->kobj, &dev_attr_fw_version.attr);
+ if (ret)
+ return ret;
+
+ ret = sysfs_create_bin_file(&cdev->dev->kobj, &bin_attr_fw_build);
+ if (ret) {
+ sysfs_remove_file(&cdev->dev->kobj, &dev_attr_fw_version.attr);
+ return ret;
+ }
+
+ return 0;
+}
+
+void catpt_sysfs_remove(struct catpt_dev *cdev)
+{
+ sysfs_remove_bin_file(&cdev->dev->kobj, &bin_attr_fw_build);
+ sysfs_remove_file(&cdev->dev->kobj, &dev_attr_fw_version.attr);
+}
--
2.17.1
^ permalink raw reply related [flat|nested] 24+ messages in thread* Re: [PATCH 08/13] ASoC: Intel: catpt: Simple sysfs attributes
2020-08-07 11:06 ` [PATCH 08/13] ASoC: Intel: catpt: Simple sysfs attributes Cezary Rojewski
@ 2020-08-07 15:00 ` Mark Brown
2020-08-10 7:17 ` Cezary Rojewski
0 siblings, 1 reply; 24+ messages in thread
From: Mark Brown @ 2020-08-07 15:00 UTC (permalink / raw)
To: Cezary Rojewski
Cc: pierre-louis.bossart, alsa-devel, andriy.shevchenko,
filip.kaczmarski, harshapriya.n, marcin.barlik, zwisler,
lgirdwood, tiwai, filip.proborszcz, michal.wasko, cujomalainey,
ppapierkowski, vamshi.krishna.gopal
[-- Attachment #1: Type: text/plain, Size: 725 bytes --]
On Fri, Aug 07, 2020 at 01:06:44PM +0200, Cezary Rojewski wrote:
> +// SPDX-License-Identifier: GPL-2.0-pcm
I'm not able to find any references to what license this is - it's not
in https://spdx.org/licenses/ for example.
> + struct catpt_fw_version version;
> + int ret;
> +
> + pm_runtime_get_sync(cdev->dev);
> +
> + ret = catpt_ipc_get_fw_version(cdev, &version);
> +
> + pm_runtime_mark_last_busy(cdev->dev);
> + pm_runtime_put_autosuspend(cdev->dev);
> +
> + if (ret)
> + return CATPT_IPC_ERROR(ret);
> +
> + memcpy(buf, &version, count);
This will copy count bytes from version regardless of the size of
version - this allows userspace to read the stack and won't truncate the
count to the size of the data read.
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: [PATCH 08/13] ASoC: Intel: catpt: Simple sysfs attributes
2020-08-07 15:00 ` Mark Brown
@ 2020-08-10 7:17 ` Cezary Rojewski
0 siblings, 0 replies; 24+ messages in thread
From: Cezary Rojewski @ 2020-08-10 7:17 UTC (permalink / raw)
To: Mark Brown
Cc: pierre-louis.bossart, alsa-devel, andriy.shevchenko,
filip.kaczmarski, harshapriya.n, marcin.barlik, zwisler,
lgirdwood, tiwai, filip.proborszcz, michal.wasko, cujomalainey,
ppapierkowski, vamshi.krishna.gopal
On 2020-08-07 5:00 PM, Mark Brown wrote:
> On Fri, Aug 07, 2020 at 01:06:44PM +0200, Cezary Rojewski wrote:
>
>> +// SPDX-License-Identifier: GPL-2.0-pcm
>
> I'm not able to find any references to what license this is - it's not
> in https://spdx.org/licenses/ for example.
>
Indeed. this is a mistake. Will fix in v2.
>> + struct catpt_fw_version version;
>> + int ret;
>> +
>> + pm_runtime_get_sync(cdev->dev);
>> +
>> + ret = catpt_ipc_get_fw_version(cdev, &version);
>> +
>> + pm_runtime_mark_last_busy(cdev->dev);
>> + pm_runtime_put_autosuspend(cdev->dev);
>> +
>> + if (ret)
>> + return CATPT_IPC_ERROR(ret);
>> +
>> + memcpy(buf, &version, count);
>
> This will copy count bytes from version regardless of the size of
> version - this allows userspace to read the stack and won't truncate the
> count to the size of the data read.
>
Good catch Mark. Ack.
^ permalink raw reply [flat|nested] 24+ messages in thread
* [PATCH 09/13] ASoC: Intel: Select catpt and deprecate haswell
2020-08-07 11:06 [PATCH 00/13] ASoC: Intel: Catpt - Lynx and Wildcat point Cezary Rojewski
` (7 preceding siblings ...)
2020-08-07 11:06 ` [PATCH 08/13] ASoC: Intel: catpt: Simple sysfs attributes Cezary Rojewski
@ 2020-08-07 11:06 ` Cezary Rojewski
2020-08-07 11:06 ` [PATCH 10/13] ASoC: Intel: haswell: Remove haswell-solution specific code Cezary Rojewski
` (5 subsequent siblings)
14 siblings, 0 replies; 24+ messages in thread
From: Cezary Rojewski @ 2020-08-07 11:06 UTC (permalink / raw)
To: alsa-devel
Cc: pierre-louis.bossart, Cezary Rojewski, andriy.shevchenko,
filip.kaczmarski, harshapriya.n, marcin.barlik, zwisler,
lgirdwood, tiwai, filip.proborszcz, broonie, michal.wasko,
cujomalainey, ppapierkowski, vamshi.krishna.gopal
Prevent sound/soc/intel/haswell code compile and select catpt instead as
a recommended solution. Userspace-exposed members are compatible with
what is exposed by deprecated solution thus no harm is done. The only
visible difference is the newly added 'Loopback Mute' kcontrol.
Signed-off-by: Cezary Rojewski <cezary.rojewski@intel.com>
---
sound/soc/intel/Kconfig | 22 +++++++++++-----------
sound/soc/intel/Makefile | 2 +-
sound/soc/intel/boards/Kconfig | 8 ++++----
sound/soc/intel/catpt/Makefile | 6 ++++++
4 files changed, 22 insertions(+), 16 deletions(-)
create mode 100644 sound/soc/intel/catpt/Makefile
diff --git a/sound/soc/intel/Kconfig b/sound/soc/intel/Kconfig
index 82805a8681e5..4a18e8f83eeb 100644
--- a/sound/soc/intel/Kconfig
+++ b/sound/soc/intel/Kconfig
@@ -47,21 +47,21 @@ config SND_SOC_INTEL_SST_FIRMWARE
# Haswell/Broadwell/Baytrail legacy and will be set
# when these platforms are enabled
-config SND_SOC_INTEL_HASWELL
- tristate "Haswell/Broadwell Platforms"
+config SND_SOC_INTEL_CATPT
+ tristate "Haswell and Broadwell"
depends on SND_DMA_SGBUF
depends on DMADEVICES && ACPI
- select SND_SOC_INTEL_SST
- select SND_SOC_INTEL_SST_ACPI
- select SND_SOC_INTEL_SST_FIRMWARE
+ select DW_DMAC_CORE
select SND_SOC_ACPI_INTEL_MATCH
help
- If you have a Intel Haswell or Broadwell platform connected to
- an I2S codec, then enable this option by saying Y or m. This is
- typically used for Chromebooks. This is a recommended option.
- This option is mutually exclusive with the SOF support on
- Broadwell. If you want to enable SOF on Broadwell, you need to
- deselect this option first.
+ Enable support for Intel(R) Haswell and Broadwell platforms
+ with I2S codec present. This is a recommended option.
+ Say Y or m if you have such device.
+ If unsure, say N.
+
+config SND_SOC_INTEL_HASWELL
+ tristate
+ select SND_SOC_INTEL_CATPT
config SND_SOC_INTEL_BAYTRAIL
tristate "Baytrail (legacy) Platforms"
diff --git a/sound/soc/intel/Makefile b/sound/soc/intel/Makefile
index 04ee48204fc9..c88c615f85f7 100644
--- a/sound/soc/intel/Makefile
+++ b/sound/soc/intel/Makefile
@@ -3,9 +3,9 @@
obj-$(CONFIG_SND_SOC) += common/
# Platform Support
-obj-$(CONFIG_SND_SOC_INTEL_HASWELL) += haswell/
obj-$(CONFIG_SND_SOC_INTEL_BAYTRAIL) += baytrail/
obj-$(CONFIG_SND_SST_ATOM_HIFI2_PLATFORM) += atom/
+obj-$(CONFIG_SND_SOC_INTEL_CATPT) += catpt/
obj-$(CONFIG_SND_SOC_INTEL_SKYLAKE) += skylake/
obj-$(CONFIG_SND_SOC_INTEL_KEEMBAY) += keembay/
diff --git a/sound/soc/intel/boards/Kconfig b/sound/soc/intel/boards/Kconfig
index d96fc1313434..f4358c33059b 100644
--- a/sound/soc/intel/boards/Kconfig
+++ b/sound/soc/intel/boards/Kconfig
@@ -26,7 +26,7 @@ config SND_SOC_INTEL_USER_FRIENDLY_LONG_NAMES
interface.
If unsure select N.
-if SND_SOC_INTEL_HASWELL
+if SND_SOC_INTEL_CATPT
config SND_SOC_INTEL_HASWELL_MACH
tristate "Haswell Lynxpoint"
@@ -40,9 +40,9 @@ config SND_SOC_INTEL_HASWELL_MACH
Say Y or m if you have such a device.
If unsure select "N".
-endif ## SND_SOC_INTEL_HASWELL
+endif ## SND_SOC_INTEL_CATPT
-if SND_SOC_INTEL_HASWELL || SND_SOC_SOF_BROADWELL
+if SND_SOC_INTEL_CATPT || SND_SOC_SOF_BROADWELL
config SND_SOC_INTEL_BDW_RT5650_MACH
tristate "Broadwell with RT5650 codec"
@@ -83,7 +83,7 @@ config SND_SOC_INTEL_BROADWELL_MACH
Ultrabook platforms.
Say Y or m if you have such a device. This is a recommended option.
If unsure select "N".
-endif ## SND_SOC_INTEL_HASWELL || SND_SOC_SOF_BROADWELL
+endif ## SND_SOC_INTEL_CATPT || SND_SOC_SOF_BROADWELL
if SND_SOC_INTEL_BAYTRAIL
diff --git a/sound/soc/intel/catpt/Makefile b/sound/soc/intel/catpt/Makefile
new file mode 100644
index 000000000000..0717190106d9
--- /dev/null
+++ b/sound/soc/intel/catpt/Makefile
@@ -0,0 +1,6 @@
+snd-soc-catpt-objs := device.o dsp.o loader.o ipc.o messages.o pcm.o fs.o
+
+# tell define_trace.h where to find the trace header
+CFLAGS_device.o := -I$(src)
+
+obj-$(CONFIG_SND_SOC_INTEL_CATPT) += snd-soc-catpt.o
--
2.17.1
^ permalink raw reply related [flat|nested] 24+ messages in thread* [PATCH 10/13] ASoC: Intel: haswell: Remove haswell-solution specific code
2020-08-07 11:06 [PATCH 00/13] ASoC: Intel: Catpt - Lynx and Wildcat point Cezary Rojewski
` (8 preceding siblings ...)
2020-08-07 11:06 ` [PATCH 09/13] ASoC: Intel: Select catpt and deprecate haswell Cezary Rojewski
@ 2020-08-07 11:06 ` Cezary Rojewski
2020-08-07 11:06 ` [PATCH 11/13] ASoC: Intel: broadwell: " Cezary Rojewski
` (4 subsequent siblings)
14 siblings, 0 replies; 24+ messages in thread
From: Cezary Rojewski @ 2020-08-07 11:06 UTC (permalink / raw)
To: alsa-devel
Cc: pierre-louis.bossart, Cezary Rojewski, andriy.shevchenko,
filip.kaczmarski, harshapriya.n, marcin.barlik, zwisler,
lgirdwood, tiwai, filip.proborszcz, broonie, michal.wasko,
cujomalainey, ppapierkowski, vamshi.krishna.gopal
Remove code specific to sound/soc/intel/haswell. Update BE dai_link
definition to provide seamless transition to catpt solution.
Signed-off-by: Cezary Rojewski <cezary.rojewski@intel.com>
---
sound/soc/intel/boards/haswell.c | 28 ++++------------------------
1 file changed, 4 insertions(+), 24 deletions(-)
diff --git a/sound/soc/intel/boards/haswell.c b/sound/soc/intel/boards/haswell.c
index 744b7b5b8106..c268405e5594 100644
--- a/sound/soc/intel/boards/haswell.c
+++ b/sound/soc/intel/boards/haswell.c
@@ -13,9 +13,6 @@
#include <sound/soc-acpi.h>
#include <sound/pcm_params.h>
-#include "../common/sst-dsp.h"
-#include "../haswell/sst-haswell-ipc.h"
-
#include "../../codecs/rt5640.h"
/* Haswell ULT platforms have a Headphone and Mic jack */
@@ -77,25 +74,6 @@ static const struct snd_soc_ops haswell_rt5640_ops = {
.hw_params = haswell_rt5640_hw_params,
};
-static int haswell_rtd_init(struct snd_soc_pcm_runtime *rtd)
-{
- struct snd_soc_component *component = snd_soc_rtdcom_lookup(rtd, DRV_NAME);
- struct sst_pdata *pdata = dev_get_platdata(component->dev);
- struct sst_hsw *haswell = pdata->dsp;
- int ret;
-
- /* Set ADSP SSP port settings */
- ret = sst_hsw_device_set_config(haswell, SST_HSW_DEVICE_SSP_0,
- SST_HSW_DEVICE_MCLK_FREQ_24_MHZ,
- SST_HSW_DEVICE_CLOCK_MASTER, 9);
- if (ret < 0) {
- dev_err(rtd->dev, "failed to set device config\n");
- return ret;
- }
-
- return 0;
-}
-
SND_SOC_DAILINK_DEF(dummy,
DAILINK_COMP_ARRAY(COMP_DUMMY()));
@@ -117,13 +95,15 @@ SND_SOC_DAILINK_DEF(codec,
SND_SOC_DAILINK_DEF(platform,
DAILINK_COMP_ARRAY(COMP_PLATFORM("haswell-pcm-audio")));
+SND_SOC_DAILINK_DEF(ssp0_port,
+ DAILINK_COMP_ARRAY(COMP_CPU("ssp0-port")));
+
static struct snd_soc_dai_link haswell_rt5640_dais[] = {
/* Front End DAI links */
{
.name = "System",
.stream_name = "System Playback/Capture",
.dynamic = 1,
- .init = haswell_rtd_init,
.trigger = {SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
.dpcm_playback = 1,
.dpcm_capture = 1,
@@ -167,7 +147,7 @@ static struct snd_soc_dai_link haswell_rt5640_dais[] = {
.ops = &haswell_rt5640_ops,
.dpcm_playback = 1,
.dpcm_capture = 1,
- SND_SOC_DAILINK_REG(dummy, codec, dummy),
+ SND_SOC_DAILINK_REG(ssp0_port, codec, platform),
},
};
--
2.17.1
^ permalink raw reply related [flat|nested] 24+ messages in thread* [PATCH 11/13] ASoC: Intel: broadwell: Remove haswell-solution specific code
2020-08-07 11:06 [PATCH 00/13] ASoC: Intel: Catpt - Lynx and Wildcat point Cezary Rojewski
` (9 preceding siblings ...)
2020-08-07 11:06 ` [PATCH 10/13] ASoC: Intel: haswell: Remove haswell-solution specific code Cezary Rojewski
@ 2020-08-07 11:06 ` Cezary Rojewski
2020-08-07 11:06 ` [PATCH 12/13] ASoC: Intel: bdw-5650: " Cezary Rojewski
` (3 subsequent siblings)
14 siblings, 0 replies; 24+ messages in thread
From: Cezary Rojewski @ 2020-08-07 11:06 UTC (permalink / raw)
To: alsa-devel
Cc: pierre-louis.bossart, Cezary Rojewski, andriy.shevchenko,
filip.kaczmarski, harshapriya.n, marcin.barlik, zwisler,
lgirdwood, tiwai, filip.proborszcz, broonie, michal.wasko,
cujomalainey, ppapierkowski, vamshi.krishna.gopal
Remove code specific to sound/soc/intel/haswell. Update BE dai_link
definition to provide seamless transition to catpt solution.
Signed-off-by: Cezary Rojewski <cezary.rojewski@intel.com>
---
sound/soc/intel/boards/broadwell.c | 33 ------------------------------
1 file changed, 33 deletions(-)
diff --git a/sound/soc/intel/boards/broadwell.c b/sound/soc/intel/boards/broadwell.c
index f6399077d291..ea2818f27105 100644
--- a/sound/soc/intel/boards/broadwell.c
+++ b/sound/soc/intel/boards/broadwell.c
@@ -14,9 +14,6 @@
#include <sound/pcm_params.h>
#include <sound/soc-acpi.h>
-#include "../common/sst-dsp.h"
-#include "../haswell/sst-haswell-ipc.h"
-
#include "../../codecs/rt286.h"
static struct snd_soc_jack broadwell_headset;
@@ -122,27 +119,6 @@ static const struct snd_soc_ops broadwell_rt286_ops = {
.hw_params = broadwell_rt286_hw_params,
};
-#if !IS_ENABLED(CONFIG_SND_SOC_SOF_BROADWELL)
-static int broadwell_rtd_init(struct snd_soc_pcm_runtime *rtd)
-{
- struct snd_soc_component *component = snd_soc_rtdcom_lookup(rtd, DRV_NAME);
- struct sst_pdata *pdata = dev_get_platdata(component->dev);
- struct sst_hsw *broadwell = pdata->dsp;
- int ret;
-
- /* Set ADSP SSP port settings */
- ret = sst_hsw_device_set_config(broadwell, SST_HSW_DEVICE_SSP_0,
- SST_HSW_DEVICE_MCLK_FREQ_24_MHZ,
- SST_HSW_DEVICE_CLOCK_MASTER, 9);
- if (ret < 0) {
- dev_err(rtd->dev, "error: failed to set device config\n");
- return ret;
- }
-
- return 0;
-}
-#endif
-
static const unsigned int channels[] = {
2,
};
@@ -189,10 +165,8 @@ SND_SOC_DAILINK_DEF(platform,
SND_SOC_DAILINK_DEF(codec,
DAILINK_COMP_ARRAY(COMP_CODEC("i2c-INT343A:00", "rt286-aif1")));
-#if IS_ENABLED(CONFIG_SND_SOC_SOF_BROADWELL)
SND_SOC_DAILINK_DEF(ssp0_port,
DAILINK_COMP_ARRAY(COMP_CPU("ssp0-port")));
-#endif
/* broadwell digital audio interface glue - connects codec <--> CPU */
static struct snd_soc_dai_link broadwell_rt286_dais[] = {
@@ -201,9 +175,6 @@ static struct snd_soc_dai_link broadwell_rt286_dais[] = {
.name = "System PCM",
.stream_name = "System Playback/Capture",
.dynamic = 1,
-#if !IS_ENABLED(CONFIG_SND_SOC_SOF_BROADWELL)
- .init = broadwell_rtd_init,
-#endif
.trigger = {SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
.ops = &broadwell_fe_ops,
.dpcm_playback = 1,
@@ -248,11 +219,7 @@ static struct snd_soc_dai_link broadwell_rt286_dais[] = {
.ops = &broadwell_rt286_ops,
.dpcm_playback = 1,
.dpcm_capture = 1,
-#if !IS_ENABLED(CONFIG_SND_SOC_SOF_BROADWELL)
- SND_SOC_DAILINK_REG(dummy, codec, dummy),
-#else
SND_SOC_DAILINK_REG(ssp0_port, codec, platform),
-#endif
},
};
--
2.17.1
^ permalink raw reply related [flat|nested] 24+ messages in thread* [PATCH 12/13] ASoC: Intel: bdw-5650: Remove haswell-solution specific code
2020-08-07 11:06 [PATCH 00/13] ASoC: Intel: Catpt - Lynx and Wildcat point Cezary Rojewski
` (10 preceding siblings ...)
2020-08-07 11:06 ` [PATCH 11/13] ASoC: Intel: broadwell: " Cezary Rojewski
@ 2020-08-07 11:06 ` Cezary Rojewski
2020-08-07 11:06 ` [PATCH 13/13] ASoC: Intel: bdw-5677: " Cezary Rojewski
` (2 subsequent siblings)
14 siblings, 0 replies; 24+ messages in thread
From: Cezary Rojewski @ 2020-08-07 11:06 UTC (permalink / raw)
To: alsa-devel
Cc: pierre-louis.bossart, Cezary Rojewski, andriy.shevchenko,
filip.kaczmarski, harshapriya.n, marcin.barlik, zwisler,
lgirdwood, tiwai, filip.proborszcz, broonie, michal.wasko,
cujomalainey, ppapierkowski, vamshi.krishna.gopal
Remove code specific to sound/soc/intel/haswell. Update BE dai_link
definition to provide seamless transition to catpt solution.
Signed-off-by: Cezary Rojewski <cezary.rojewski@intel.com>
---
sound/soc/intel/boards/bdw-rt5650.c | 36 -----------------------------
1 file changed, 36 deletions(-)
diff --git a/sound/soc/intel/boards/bdw-rt5650.c b/sound/soc/intel/boards/bdw-rt5650.c
index ce7320916b22..c5820787c53e 100644
--- a/sound/soc/intel/boards/bdw-rt5650.c
+++ b/sound/soc/intel/boards/bdw-rt5650.c
@@ -16,9 +16,6 @@
#include <sound/soc.h>
#include <sound/soc-acpi.h>
-#include "../common/sst-dsp.h"
-#include "../haswell/sst-haswell-ipc.h"
-
#include "../../codecs/rt5645.h"
struct bdw_rt5650_priv {
@@ -138,30 +135,6 @@ static struct snd_soc_ops bdw_rt5650_ops = {
.hw_params = bdw_rt5650_hw_params,
};
-#if !IS_ENABLED(CONFIG_SND_SOC_SOF_BROADWELL)
-static int bdw_rt5650_rtd_init(struct snd_soc_pcm_runtime *rtd)
-{
- struct snd_soc_component *component =
- snd_soc_rtdcom_lookup(rtd, DRV_NAME);
- struct sst_pdata *pdata = dev_get_platdata(component->dev);
- struct sst_hsw *broadwell = pdata->dsp;
- int ret;
-
- /* Set ADSP SSP port settings
- * clock_divider = 4 means BCLK = MCLK/5 = 24MHz/5 = 4.8MHz
- */
- ret = sst_hsw_device_set_config(broadwell, SST_HSW_DEVICE_SSP_0,
- SST_HSW_DEVICE_MCLK_FREQ_24_MHZ,
- SST_HSW_DEVICE_TDM_CLOCK_MASTER, 4);
- if (ret < 0) {
- dev_err(rtd->dev, "error: failed to set device config\n");
- return ret;
- }
-
- return 0;
-}
-#endif
-
static const unsigned int channels[] = {
2, 4,
};
@@ -251,10 +224,8 @@ SND_SOC_DAILINK_DEF(platform,
SND_SOC_DAILINK_DEF(be,
DAILINK_COMP_ARRAY(COMP_CODEC("i2c-10EC5650:00", "rt5645-aif1")));
-#if IS_ENABLED(CONFIG_SND_SOC_SOF_BROADWELL)
SND_SOC_DAILINK_DEF(ssp0_port,
DAILINK_COMP_ARRAY(COMP_CPU("ssp0-port")));
-#endif
static struct snd_soc_dai_link bdw_rt5650_dais[] = {
/* Front End DAI links */
@@ -263,9 +234,6 @@ static struct snd_soc_dai_link bdw_rt5650_dais[] = {
.stream_name = "System Playback",
.dynamic = 1,
.ops = &bdw_rt5650_fe_ops,
-#if !IS_ENABLED(CONFIG_SND_SOC_SOF_BROADWELL)
- .init = bdw_rt5650_rtd_init,
-#endif
.trigger = {
SND_SOC_DPCM_TRIGGER_POST,
SND_SOC_DPCM_TRIGGER_POST
@@ -289,11 +257,7 @@ static struct snd_soc_dai_link bdw_rt5650_dais[] = {
.dpcm_playback = 1,
.dpcm_capture = 1,
.init = bdw_rt5650_init,
-#if !IS_ENABLED(CONFIG_SND_SOC_SOF_BROADWELL)
- SND_SOC_DAILINK_REG(dummy, be, dummy),
-#else
SND_SOC_DAILINK_REG(ssp0_port, be, platform),
-#endif
},
};
--
2.17.1
^ permalink raw reply related [flat|nested] 24+ messages in thread* [PATCH 13/13] ASoC: Intel: bdw-5677: Remove haswell-solution specific code
2020-08-07 11:06 [PATCH 00/13] ASoC: Intel: Catpt - Lynx and Wildcat point Cezary Rojewski
` (11 preceding siblings ...)
2020-08-07 11:06 ` [PATCH 12/13] ASoC: Intel: bdw-5650: " Cezary Rojewski
@ 2020-08-07 11:06 ` Cezary Rojewski
2020-08-07 11:09 ` [PATCH 00/13] ASoC: Intel: Catpt - Lynx and Wildcat point Cezary Rojewski
2020-08-07 13:05 ` Amadeusz Sławiński
14 siblings, 0 replies; 24+ messages in thread
From: Cezary Rojewski @ 2020-08-07 11:06 UTC (permalink / raw)
To: alsa-devel
Cc: pierre-louis.bossart, Cezary Rojewski, andriy.shevchenko,
filip.kaczmarski, harshapriya.n, marcin.barlik, zwisler,
lgirdwood, tiwai, filip.proborszcz, broonie, michal.wasko,
cujomalainey, ppapierkowski, vamshi.krishna.gopal
Remove code specific to sound/soc/intel/haswell. Update BE dai_link
definition to provide seamless transition to catpt solution.
Signed-off-by: Cezary Rojewski <cezary.rojewski@intel.com>
---
sound/soc/intel/boards/bdw-rt5677.c | 33 -----------------------------
1 file changed, 33 deletions(-)
diff --git a/sound/soc/intel/boards/bdw-rt5677.c b/sound/soc/intel/boards/bdw-rt5677.c
index 86e427e3822f..4451957fc170 100644
--- a/sound/soc/intel/boards/bdw-rt5677.c
+++ b/sound/soc/intel/boards/bdw-rt5677.c
@@ -17,9 +17,6 @@
#include <sound/jack.h>
#include <sound/soc-acpi.h>
-#include "../common/sst-dsp.h"
-#include "../haswell/sst-haswell-ipc.h"
-
#include "../../codecs/rt5677.h"
struct bdw_rt5677_priv {
@@ -201,27 +198,6 @@ static const struct snd_soc_ops bdw_rt5677_dsp_ops = {
.hw_params = bdw_rt5677_dsp_hw_params,
};
-#if !IS_ENABLED(CONFIG_SND_SOC_SOF_BROADWELL)
-static int bdw_rt5677_rtd_init(struct snd_soc_pcm_runtime *rtd)
-{
- struct snd_soc_component *component = snd_soc_rtdcom_lookup(rtd, DRV_NAME);
- struct sst_pdata *pdata = dev_get_platdata(component->dev);
- struct sst_hsw *broadwell = pdata->dsp;
- int ret;
-
- /* Set ADSP SSP port settings */
- ret = sst_hsw_device_set_config(broadwell, SST_HSW_DEVICE_SSP_0,
- SST_HSW_DEVICE_MCLK_FREQ_24_MHZ,
- SST_HSW_DEVICE_CLOCK_MASTER, 9);
- if (ret < 0) {
- dev_err(rtd->dev, "error: failed to set device config\n");
- return ret;
- }
-
- return 0;
-}
-#endif
-
static const unsigned int channels[] = {
2,
};
@@ -333,10 +309,8 @@ SND_SOC_DAILINK_DEF(platform,
SND_SOC_DAILINK_DEF(be,
DAILINK_COMP_ARRAY(COMP_CODEC("i2c-RT5677CE:00", "rt5677-aif1")));
-#if IS_ENABLED(CONFIG_SND_SOC_SOF_BROADWELL)
SND_SOC_DAILINK_DEF(ssp0_port,
DAILINK_COMP_ARRAY(COMP_CPU("ssp0-port")));
-#endif
/* Wake on voice interface */
SND_SOC_DAILINK_DEFS(dsp,
@@ -350,9 +324,6 @@ static struct snd_soc_dai_link bdw_rt5677_dais[] = {
.name = "System PCM",
.stream_name = "System Playback/Capture",
.dynamic = 1,
-#if !IS_ENABLED(CONFIG_SND_SOC_SOF_BROADWELL)
- .init = bdw_rt5677_rtd_init,
-#endif
.trigger = {
SND_SOC_DPCM_TRIGGER_POST,
SND_SOC_DPCM_TRIGGER_POST
@@ -387,11 +358,7 @@ static struct snd_soc_dai_link bdw_rt5677_dais[] = {
.dpcm_capture = 1,
.init = bdw_rt5677_init,
.exit = bdw_rt5677_exit,
-#if !IS_ENABLED(CONFIG_SND_SOC_SOF_BROADWELL)
- SND_SOC_DAILINK_REG(dummy, be, dummy),
-#else
SND_SOC_DAILINK_REG(ssp0_port, be, platform),
-#endif
},
};
--
2.17.1
^ permalink raw reply related [flat|nested] 24+ messages in thread* Re: [PATCH 00/13] ASoC: Intel: Catpt - Lynx and Wildcat point
2020-08-07 11:06 [PATCH 00/13] ASoC: Intel: Catpt - Lynx and Wildcat point Cezary Rojewski
` (12 preceding siblings ...)
2020-08-07 11:06 ` [PATCH 13/13] ASoC: Intel: bdw-5677: " Cezary Rojewski
@ 2020-08-07 11:09 ` Cezary Rojewski
2020-08-07 13:05 ` Amadeusz Sławiński
14 siblings, 0 replies; 24+ messages in thread
From: Cezary Rojewski @ 2020-08-07 11:09 UTC (permalink / raw)
To: alsa-devel
Cc: pierre-louis.bossart, andriy.shevchenko, filip.kaczmarski,
harshapriya.n, marcin.barlik, zwisler, lgirdwood, tiwai,
filip.proborszcz, broonie, michal.wasko, cujomalainey,
ppapierkowski, vamshi.krishna.gopal
On 2020-08-07 1:06 PM, Cezary Rojewski wrote:
> Implement support for Lynxpoint and Wildcat Point AudioDSP. Catpt
> solution deprecates existing sound/soc/intel/haswell which is removed in
> the following series. This cover-letter is followed by 'Developer's deep
> dive' message schedding light on catpt's key concepts and areas
> addressed.
Developer's deep dive
=====================
Purpose of this message is explanation of Catpt's key concepts, problems
addressed when compared to /soc/intel/haswell/ (which from now on will
be addressed to as /haswell/) as well as answeing major why(s)
surrounding the subject. Message does not explain every detail of every
process as it's length is already high without doing so.
In case of any question and areas which have not beed mentioned here,
please don't hesitate to send an email.
Following removal of /haswell/ and moving forward
-------------------------------------------------
Catpt is a direct replacement for existing /haswell/ solution. Because
of userspace API being inherited as well as FW binary re-used, /haswell/
is going to be removed entirely in the follow-up series. In consequence
of that action, majority of processing code found in /soc/intel/common
becomes redundant. /common/ was supposed to host code common to Intel
AudioDSP architectures. Unfortunately, it never lived up to the
expecations. Most of code found there is LPT/WPT specific with some
/soc/intel/baytail/ deviates while /soc/intel/skylake/ moved most of
it's stuff away from /common/ - even DSP initialization.
To my knowledge, no device makes use of legacy /baytail/ solution any
longer with all the products enlisting either /soc/intel/atom/ or
/soc/sof/intel/. Following the sanitization of /common/ folder, the
logical next step is removal of /baytrail/.
LPT and catpt
-------------
I'm not aware of any released Haswell-based product with AudioDSP
capability, despite these being planned for some Ultrabooks initially.
Broadwell ADSP on the other hand, was released and is present on the marked.
Decision not to cut LPT's ACPI ID off from /catpt/device.c is
maintainance based. While a piece of most of the models found on the
market is in IGK or Bangalore validation teams hands, the quantity is
very limited (~1 per model). On top of that, production stuff is poor
ContinuousIntegration medium. Our CI, once attached to the platform,
takes basically entire control over it, in exchange allowing to perform
test cycles in rapid fashion. Tests areas include but are not limited to
D3/D0, S3, S4, S5, G3 (power off), individual streaming, concurrent
streaming, cpu overload (so on and so forth..). That comes in cost of
preparation - GPIOs and other pins need to be exposed and available
for our CI and external hw: power switches, hydras for dynamic external
codec connections and disconnections and more. Production stuff, for
obvious reasons does not expose such capabilities. This is different on
RVPs which are made for that very purpose and are very CI-friendly.
There are more of them available too.
Age of the LPT/WPT architecture has its toll, though. Not many working
RVP exemplars are available and even less CPUs - yes, you need a special
one to match the RVP, production CPU won't cut it. TLDR: there are not
enough working WPT RVPs when combined with pre-release CPUs to mark
catpt CI healthy for long-term validation (2-3 years+). To compensate,
holes have been filled with LPT equivalents.
Considering DSP hw capabilities are basically identical between LPT and
WPT with FW code being shared for both of them (one branch) this allows
for high test coverage of DSP functionality regardless of PCH present.
Codecs support is shared too - /soc/intel/boards/haswell.c aka
hsw-rt5640.c and /soc/intel/boards/broadwell.c aka bdw-rt286.c are PCH
agnostic.
Kernel code differences are minimal between the two and will probably be
reduced even more in the future. Given the reasons presented
above, I believe gains from healthy CI and test coverage heavily
outweight the maintainance cost of few lines of code appending LPT
device support.
Device and its components
-------------------------
Device probing has been redesigned to accommodate for:
single platform_device solution
coupling dw_dma dev with actual ADSP device
Starting point was two platform_devices as in
/soc/intel/common/sst-acpi.c. First gets created when specific acpi_id
is found within DSDT ACPI table and then callback is performed on
successful firmware file request which creates yet another device: this
time for PCM operations - haswell-pcm-audio. Having in mind Greg KH's
idea of reduction of number of platform_devices in Linux environment,
decision was made to cut the later off.
This raised a dependency issue as DW DMA Controller - one of LPT/WPT
AudioDsp device components - requires the device to be up and running
before being probed. Moreover, because of said controller making use of
pm_runtime during release, it is paramount pm_runtime is disabled before
invoking it. To address this, catpt's .probe() calls _dsp_power_up() -
which takes device out of D3 and allows for I/O access before proceeding
with DW DMA controller. .remove() starts with pm_runtime_disable()
so postmortem suspend and resumes are prevented.
DMAC plays a ADSP personal memcopier role, there are two engines
available 8 channels each. It's neither entirely owned by HOST nor DSP:
ownership is instead shared. As per spec, to prevent de-synchronization,
the following protocol is obeyed: HOST owns DW DMA controller as long as
FW isn't alive - that is, FW_READY notification has not been received.
Once DSP is unstalled and firmware boots, it is expected that HOST stops
all DMA operations and entire ownership of all 16 channels is taken by
FW. This effectively limits HOST's DMA usage to FW booting procedure.
Device begins its life in D3 state (11b for PCI PMCS::PS register), and
needs to be taken out of it via _dsp_power_up(). That has to be done
before FW image loading. Since LPT/WPT ADSP has no IMR - memory region
for storing firmware image - capability, context is lost on each D0
exit. In consequence image has to be reloaded on each resume. Here,
additional optimization has been added to prevent redundant image
flashing from occurring when module is about to be unloaded:
module_is_live check.
DMAC is not the only component tied to catpt. After allocating all the
necessary resources, probing DMAC and flashing FW, ASoC platform
component and card need to be created. The latter is triggered by
creation of child platform_device - as is the case for all
snd_soc_card(s). As a child device owned by catpt, it's catpt's
responsibility to remove it before solution gets unloaded. This is done
by the devm_add_action hook provided with platform_device_unregister
function.
Compared to /haswell/, catpt allows for core device probing regardless
of snd_soc_acpi_mach being present or not. This is similar to
codec-driver behaviour which probe right after matching device id on I2S
bus and is more logical than complete abort when no machines are present.
Allows for core device debug or tests (e.g. power sequences) in the
codec-less environment.
Resource management
-------------------
In contrast to its younger brothers and sisters from cAVS architecture
(SKL+), it's HOST's responsibility to manage SRAM - memory allocation
and power gating. SRAM is split into two banks: Data SRAM and
Instruction SRAM, subsequently divided into several EBBs with 32kBs
each. IRAM is targeted for fixed (static) data while DRAM holds both,
static and dynamic information.
Both, FW_BASE module and feature modules require persistent memory
allocated to them as well as some temporary one. The temporary block is
called scratch and is shared by all modules and thus only one gets
allocated compared to persistent ones which are module's individual
area. As FW context is lost on each D0 exit, to speed-up the boot
process HOST is expected to store dynamic information regions from DRAM.
Those regions contain module and stream states which subsequently allow
for bringing base FW as well as streams right back to where they were
before leaving D0.
Model seen in /soc/intel/common/sst-firmware.c has been redesigned. Two
simple structs have been enlisted:
catpt_mbank
catpt_mregion
to provide resource-like memory management. 'struct resource' serves
different purpose and its layout does not fit all needs of catpt and
that's why new types have been provided instead. catpt_mbank represents
SRAM bank of one type: IRAM -or- DRAM. It's made of _one_ or more
catpt_regions, never less.
catpt core device requests memory region for either fixed or dynamic
allocation by calling catpt_mbank_request_region or
catpt_mbank_reserve_region. Once allocated, catpt_mregion::busy field
gets flagged to ensure said region is no longer available until freed by
catpt_mbank_release_region.
In the very beginning each mbank is made of singular list of regions -
one element spanning entire SRAM with ::busy=0. On each allocation this
situation changes and more and more blocks are being extracted from the
free space. Banks maintain actual list of regions and perform a 'join'
procedure when a region gets yielded back to pool of free regions. Said
procedure attempts to join adjacent regions as long as they too are
::busy=0.
Presented mechanism allows for keeping lowest possible amount of EBBs
alive while power gating rest of them, saving maximum amount of power.
There are few exceptions, meaning regions which must always be power
un-gated. That goes for 0x200 (FW dump) at the front of DRAM and
everything past the highest module offset - that always goes for
FW_BASE. Everything else is available for dynamic allocation and should
be power gated when possible.
Last but not least is the LPCS - low power clock selection. While clock
selection is granular as per hw spec (6+ configurations), catpt deals
with it in binary fashion only. Clock is either set to low-power when
DSP is idle or high-power when streaming is done. This limitation is
inherited from equivalent Windows solution and in order to eliminate it,
much more testing has be to done. For now catpt sticks to what's stable.
Clock selection itself is guarded by in-progress register and may not be
performed until it's cleared. On top of that, as long as FW is alive,
HOST should await WAITI state before attempting any selection. This is
to ensure work on DSP side is not disrupted by unexpected clock change.
While in D3, HOST bypasses that rule and is free to select clock forcibly.
IPC protocol
------------
Catpt features simple, synchronized '1 message out - 1message in' FW
communication. This deviates from /soc/intel/common/sst-ipc.c as there
are no lists involved and there is no sst_plat_ipc_ops::reply_msg_match.
Vast majority of IPCs are one-shots meaning they flag DSP with busy
status and until response is received, no further messaging is allowed.
There is only one communication channel for request-response called
'downlink' with secondary channel called 'uplink' available for FW alone
to sent notifications to HOST. While most IPCs are one-shots, FW may
choose to delay the response. In such cases status PENDING is returned
back and HOST is expected to await actual replay coming from the
notification channel. Catpt verifies status of incoming response and
yields on success or failure but re-awaits the completion on said
PENDING status to ensure synchronization remains intact. Example of such
delayed reply is RESET_STREAM for low power offload pipe. Until response
is received, stream cannot progress in state machine, through operation
PAUSE and ultimately, RESUME.
Steps have been taken to reduce kmallocs/ kzallocs in IPC messages. This
is done by removal of temporary buffers in requests (/catpt/messages.c)
and instead working with provided ret-pointers directly - that is, only
when reply with SUCCESS status is returned back. Otherwise ret-pointer
is untouched. Moreover, tx buffer has been removed
(/catpt/ipc.c::catpt_ipc_arm) as once request is copied to hardware
registers, it is no longer of use for IPC framework. Said framework
gates the communication - field 'catpt_ipc::ready'. Once FW_READY
notification is received, mailbox is initialized and further messaging
is allowed. On critical failures: COREDUMP notification -or- IPC timeout
ready status is revoked. Things stay that way until DSP is recovered
from failure.
ASoC Platform component
-----------------------
Solution maintains backwards compatibility with previous one, /haswell/.
Kcontrols which were available there - master playback, capture and 2x
offload volumes - make they return in catpt. Differences:
new kcontrol 'Loopback Mute' has been added
volume controls now support quad rather than just stereo
The former is self-explanatory and has been missing in /haswell/.
Targets Loopback stream only. The later is an adjustment to align with
requirements and FW spec. Years ago, during LPT/WPT development change
request has been filed to increase the number of supported channels.
Looks like that information didn't get back to Linux, but in catpt this
has been addressed. As already noted, WAVES and module support in
general, is scheduled for later release.
Both volume and mute controls are stored within kcontrols::private_value
and are applied during pcm prepare() operation. As soc_mixer_control is
featured in every iteration of helpful macros present in
/include/sound/soc.h - which is stereo-configuration biased - decision
has been made to relocate control creation to component's .probe().
In regard to PCM operations alone, some invisible to userspace stuff has
been re-used from /haswell/ e.g.: volume_map and page_table arranging.
As internal FW pipes are governed with state machine, changes have been
made to ensure following in obeyed:
ALLOC -> RESET -> PAUSE -> RESUME
FREE <- RESET <- PAUSE <- RESUME
On existing solution, RESET could have been bypassed and stream moved to
PAUSE directly. In catpt, .trigger() and .prepare() functions do the
majority of stream's preparation and state changing ensuring these are
changed properly.
Another area of interest is substream's private data handling. This has
been modified from static block: struct hsw_priv_data::pcm and struct
hsw_priv_data::dmab to dynamic - on .startup() _dma_data is allocated
and assigned to given DAI. In catpt, said private data is the chest of
solution's PCM: struct catpt_stream_runtime. It stores current state,
template used and memory allocated. As LPT/WPT DSP does not offer
flexible topology, static one is applied. This is manifested via
catpt_topology global which describes the shape of every stream. There
are seven of them, 2 Bluetooth streams for SSP1 and 5 (system playback &
capture, two offloads and loopback) for SSP0.
This data is essential during stream allocation in .hw_params().
On D0 exit SSP device configuration is lost, just like other FW context.
SSP device formats are expected to be resent once FW resumes operations.
Catpt removes the need for /soc/intel/boards to play with IPCs
(sst_hsw_device_set_config) and assigns formats automatically on .pcm_new().
Heavy lifting has also been done for stream-position-update handled by
catpt_stream_update_position and POSITION_CHANGED notification. This
time, payload dumped by the later is always accounted for instead of
being ignored and combined with SET_WRITE_POS ipc, allows for stream
progression for OFFLOAD pins. On Dell XPS 13, all exposed DAIs apart
from the system one were not working correctly. For offload, HOST owns
write-pointer and is expected to send SET_WRITE_POS IPC periodically -
that can be done twice prior to stream's start aka RESUME and from
there, once on every POSITION_CHANGE notification. For loopback stream,
DAPM routes were missing what too has been addressed to ensure stream is
functional.
Thanks for bearing with me. In case of any questions, send me an email.
Kind Regards,
Czarek
^ permalink raw reply [flat|nested] 24+ messages in thread* Re: [PATCH 00/13] ASoC: Intel: Catpt - Lynx and Wildcat point
2020-08-07 11:06 [PATCH 00/13] ASoC: Intel: Catpt - Lynx and Wildcat point Cezary Rojewski
` (13 preceding siblings ...)
2020-08-07 11:09 ` [PATCH 00/13] ASoC: Intel: Catpt - Lynx and Wildcat point Cezary Rojewski
@ 2020-08-07 13:05 ` Amadeusz Sławiński
14 siblings, 0 replies; 24+ messages in thread
From: Amadeusz Sławiński @ 2020-08-07 13:05 UTC (permalink / raw)
To: Cezary Rojewski, alsa-devel
Cc: andriy.shevchenko, filip.kaczmarski, harshapriya.n,
ppapierkowski, marcin.barlik, zwisler, pierre-louis.bossart,
lgirdwood, filip.proborszcz, broonie, michal.wasko, tiwai,
cujomalainey, vamshi.krishna.gopal
On 8/7/2020 1:06 PM, Cezary Rojewski wrote:
>
> Special thanks go to Marcin Barlik and Piotr Papierkowski for sharing
> their LPT/WPT AudioDSP architecture expertise as well as helping
> backtrack its historical background.
> My thanks go to Amadeusz Slawinski for reviews and improvements proposed
> on and off the internal list. Most of diff below is his contribution.
> Krzysztof Hejmowski helped me setup my own Xtensa environment and
> recompile LPT/WPT FW binary sources what sped up the development greatly.
>
As mentioned I've already seen those patches before and gone through
them once again now, as I have no more comments:
Reviewed-by: Amadeusz Sławiński <amadeuszx.slawinski@linux.intel.com>
^ permalink raw reply [flat|nested] 24+ messages in thread