From: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
To: Cezary Rojewski <cezary.rojewski@intel.com>
Cc: pierre-louis.bossart@linux.intel.com,
alsa-devel@alsa-project.org, filip.kaczmarski@intel.com,
harshapriya.n@intel.com, gregkh@linuxfoundation.org,
marcin.barlik@intel.com, zwisler@google.com, lgirdwood@gmail.com,
tiwai@suse.com, filip.proborszcz@intel.com, broonie@kernel.org,
amadeuszx.slawinski@linux.intel.com, michal.wasko@intel.com,
cujomalainey@chromium.org, krzysztof.hejmowski@intel.com,
ppapierkowski@habana.ai, vamshi.krishna.gopal@intel.com
Subject: Re: [PATCH v7 02/14] ASoC: Intel: catpt: Implement IPC protocol
Date: Mon, 21 Sep 2020 16:00:40 +0300 [thread overview]
Message-ID: <20200921130040.GU3956970@smile.fi.intel.com> (raw)
In-Reply-To: <20200921115424.4105-3-cezary.rojewski@intel.com>
On Mon, Sep 21, 2020 at 01:54:12PM +0200, Cezary Rojewski wrote:
> 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/core.h | 43 ++++
> sound/soc/intel/catpt/ipc.c | 246 ++++++++++++++++++
> sound/soc/intel/catpt/messages.h | 401 ++++++++++++++++++++++++++++++
> sound/soc/intel/catpt/registers.h | 1 -
> 4 files changed, 690 insertions(+), 1 deletion(-)
> create mode 100644 sound/soc/intel/catpt/ipc.c
> create mode 100644 sound/soc/intel/catpt/messages.h
>
> diff --git a/sound/soc/intel/catpt/core.h b/sound/soc/intel/catpt/core.h
> index 48952e93d86f..0953989e24b3 100644
> --- a/sound/soc/intel/catpt/core.h
> +++ b/sound/soc/intel/catpt/core.h
> @@ -9,6 +9,7 @@
> #define __SND_SOC_INTEL_CATPT_CORE_H
>
> #include <linux/dma/dw.h>
> +#include "messages.h"
> #include "registers.h"
>
> struct catpt_dev;
> @@ -29,6 +30,31 @@ static inline bool catpt_resource_overlapping(struct resource *r1,
> return true;
> }
>
> +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;
> @@ -59,6 +85,7 @@ struct catpt_spec {
> struct catpt_dev {
> struct device *dev;
> struct dw_dma_chip *dmac;
> + struct catpt_ipc ipc;
>
> void __iomem *pci_ba;
> void __iomem *lpe_ba;
> @@ -83,4 +110,20 @@ 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);
>
> +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);
> +
> #endif
> diff --git a/sound/soc/intel/catpt/ipc.c b/sound/soc/intel/catpt/ipc.c
> new file mode 100644
> index 000000000000..500d4845a7cf
> --- /dev/null
> +++ b/sound/soc/intel/catpt/ipc.c
> @@ -0,0 +1,246 @@
> +// 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"
> +
> +#define CATPT_IPC_TIMEOUT_MSECS 300
A nit-pick: _MS is enough.
> +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;
> +
> + 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) {
> + 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_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);
> + }
> +}
> +
> +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));
> +
> + catpt_ipc_arm(ipc, &config);
> + complete(&cdev->fw_ready);
> + return;
> + }
> +
> + switch (msg.type) {
> + case CATPT_GLB_REQUEST_CORE_DUMP:
> + break;
> +
> + case CATPT_GLB_STREAM_MESSAGE:
> + switch (msg.subtype) {
> + case CATPT_STRM_NOTIFICATION:
> + 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);
> +
> + /* 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);
> +
> + /* 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);
> + 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;
> +}
> diff --git a/sound/soc/intel/catpt/messages.h b/sound/soc/intel/catpt/messages.h
> new file mode 100644
> index 000000000000..5ce56e033ad2
> --- /dev/null
> +++ b/sound/soc/intel/catpt/messages.h
> @@ -0,0 +1,401 @@
> +/* 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;
> +
> +/* 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 resource *persistent,
> + struct resource *scratch,
> + struct catpt_stream_info *sinfo);
> +int catpt_ipc_free_stream(struct catpt_dev *cdev, u8 stream_hw_id);
> +
> +enum catpt_ssp_iface {
> + CATPT_SSP_IFACE_0 = 0,
> + CATPT_SSP_IFACE_1 = 1,
> + CATPT_SSP_IFACE_LAST = CATPT_SSP_IFACE_1,
> +};
> +
> +#define CATPT_SSP_COUNT (CATPT_SSP_IFACE_LAST + 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_CONSUMER = 0,
> + CATPT_SSP_MODE_I2S_PROVIDER = 1,
> + CATPT_SSP_MODE_TDM_PROVIDER = 2,
> +};
> +
> +struct catpt_ssp_device_format {
> + enum catpt_ssp_iface iface;
> + enum catpt_mclk_frequency mclk;
> + enum catpt_ssp_mode mode;
> + 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
> diff --git a/sound/soc/intel/catpt/registers.h b/sound/soc/intel/catpt/registers.h
> index a051d8b36d88..47280d82842e 100644
> --- a/sound/soc/intel/catpt/registers.h
> +++ b/sound/soc/intel/catpt/registers.h
> @@ -15,7 +15,6 @@
> #define CATPT_SHIM_REGS_SIZE 4096
> #define CATPT_DMA_REGS_SIZE 1024
> #define CATPT_DMA_COUNT 2
> -#define CATPT_SSP_COUNT 2
> #define CATPT_SSP_REGS_SIZE 512
>
> /* DSP Shim registers */
> --
> 2.17.1
>
--
With Best Regards,
Andy Shevchenko
next prev parent reply other threads:[~2020-09-21 13:02 UTC|newest]
Thread overview: 32+ messages / expand[flat|nested] mbox.gz Atom feed top
2020-09-21 11:54 [PATCH v7 00/14] ASoC: Intel: Catpt - Lynx and Wildcat point Cezary Rojewski
2020-09-21 11:54 ` [PATCH v7 01/14] ASoC: Intel: Add catpt base members Cezary Rojewski
2020-09-21 11:54 ` [PATCH v7 02/14] ASoC: Intel: catpt: Implement IPC protocol Cezary Rojewski
2020-09-21 13:00 ` Andy Shevchenko [this message]
2020-09-21 17:57 ` Rojewski, Cezary
2020-09-21 11:54 ` [PATCH v7 03/14] ASoC: Intel: catpt: Add IPC message handlers Cezary Rojewski
2020-09-21 12:59 ` Andy Shevchenko
2020-09-21 13:58 ` Amadeusz Sławiński
2020-09-21 14:20 ` Andy Shevchenko
2020-09-21 14:23 ` Andy Shevchenko
2020-09-21 18:14 ` Rojewski, Cezary
2020-09-21 18:13 ` Rojewski, Cezary
2020-09-21 18:41 ` Andy Shevchenko
2020-09-21 20:48 ` Rojewski, Cezary
2020-09-22 9:04 ` Andy Shevchenko
2020-09-22 11:04 ` Rojewski, Cezary
2020-09-22 11:29 ` Andy Shevchenko
2020-09-22 11:30 ` Andy Shevchenko
2020-09-22 11:56 ` Rojewski, Cezary
2020-09-21 11:54 ` [PATCH v7 04/14] ASoC: Intel: catpt: Define DSP operations Cezary Rojewski
2020-09-21 11:54 ` [PATCH v7 05/14] ASoC: Intel: catpt: Firmware loading and context restore Cezary Rojewski
2020-09-21 11:54 ` [PATCH v7 06/14] ASoC: Intel: catpt: PCM operations Cezary Rojewski
2020-09-21 14:08 ` Andy Shevchenko
2020-09-21 18:50 ` Rojewski, Cezary
2020-09-21 11:54 ` [PATCH v7 07/14] ASoC: Intel: catpt: Device driver lifecycle Cezary Rojewski
2020-09-21 11:54 ` [PATCH v7 08/14] ASoC: Intel: catpt: Event tracing Cezary Rojewski
2020-09-21 11:54 ` [PATCH v7 09/14] ASoC: Intel: catpt: Simple sysfs attributes Cezary Rojewski
2020-09-21 11:54 ` [PATCH v7 10/14] ASoC: Intel: haswell: Remove haswell-solution specific code Cezary Rojewski
2020-09-21 11:54 ` [PATCH v7 11/14] ASoC: Intel: broadwell: " Cezary Rojewski
2020-09-21 11:54 ` [PATCH v7 12/14] ASoC: Intel: bdw-5650: " Cezary Rojewski
2020-09-21 11:54 ` [PATCH v7 13/14] ASoC: Intel: bdw-5677: " Cezary Rojewski
2020-09-21 11:54 ` [PATCH v7 14/14] ASoC: Intel: Select catpt and deprecate haswell Cezary Rojewski
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20200921130040.GU3956970@smile.fi.intel.com \
--to=andriy.shevchenko@linux.intel.com \
--cc=alsa-devel@alsa-project.org \
--cc=amadeuszx.slawinski@linux.intel.com \
--cc=broonie@kernel.org \
--cc=cezary.rojewski@intel.com \
--cc=cujomalainey@chromium.org \
--cc=filip.kaczmarski@intel.com \
--cc=filip.proborszcz@intel.com \
--cc=gregkh@linuxfoundation.org \
--cc=harshapriya.n@intel.com \
--cc=krzysztof.hejmowski@intel.com \
--cc=lgirdwood@gmail.com \
--cc=marcin.barlik@intel.com \
--cc=michal.wasko@intel.com \
--cc=pierre-louis.bossart@linux.intel.com \
--cc=ppapierkowski@habana.ai \
--cc=tiwai@suse.com \
--cc=vamshi.krishna.gopal@intel.com \
--cc=zwisler@google.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.