common.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 *
 * Copyright(c) 2016 Intel Corporation. All rights reserved.
 *
 * Author: Liam Girdwood <liam.r.girdwood@linux.intel.com>
 *         Keyon Jie <yang.jie@linux.intel.com>
 */
 
#ifndef __SOF_IPC_COMMON_H__
#define __SOF_IPC_COMMON_H__
 
#include <rtos/bit.h>
#include <rtos/alloc.h>
#include <sof/list.h>
#include <rtos/task.h>
#include <rtos/spinlock.h>
#include <rtos/sof.h>
#include <user/trace.h>
#include <ipc/header.h>
#include <ipc/stream.h>
#include <sof/ipc/ipc_reply.h>
 
#include <stdbool.h>
#include <stdint.h>
 
struct comp_driver;
struct dma_sg_elem_array;
struct ipc_msg;
struct ipc4_message_request;
 
/* validates internal non tail structures within IPC command structure */
#define IPC_IS_SIZE_INVALID(object)                 \
    ((object).hdr.size != sizeof(object))
 
#define IPC_TAIL_IS_SIZE_INVALID(object)                    \
    ((object).comp.hdr.size + (object).comp.ext_data_length < sizeof(object))
 
/* ipc trace context, used by multiple units */
extern struct tr_ctx ipc_tr;
 
/* convenience error trace for mismatched internal structures */
#define IPC_SIZE_ERROR_TRACE(ctx, object)       \
    tr_err(ctx, "ipc: size %d expected %zu",    \
           (object).hdr.size, sizeof(object))
 
/* Returns pipeline source component */
#define ipc_get_ppl_src_comp(ipc, ppl_id) \
    ipc_get_ppl_comp(ipc, ppl_id, PPL_DIR_UPSTREAM)
 
/* Returns pipeline sink component */
#define ipc_get_ppl_sink_comp(ipc, ppl_id) \
    ipc_get_ppl_comp(ipc, ppl_id, PPL_DIR_DOWNSTREAM)
 
#define IPC_TASK_INLINE     BIT(0)
#define IPC_TASK_IN_THREAD  BIT(1)
#define IPC_TASK_SECONDARY_CORE BIT(2)
#define IPC_TASK_POWERDOWN      BIT(3)
 
#ifdef CONFIG_CORE_COUNT
#define IPC_DSP_CORE_COUNT CONFIG_CORE_COUNT
#else
#define IPC_DSP_CORE_COUNT 1
#endif
 
struct ipc_user {
    struct k_thread *thread[IPC_DSP_CORE_COUNT];
    struct k_sem *sem;
    struct k_event *event[IPC_DSP_CORE_COUNT];
    uint32_t ipc_msg_pri;
    uint32_t ipc_msg_ext;
    int result;
    uint32_t reply_ext;
    uint32_t reply_tx_size;
    void *reply_tx_data;
    struct ipc *ipc;
    struct k_thread *audio_thread[IPC_DSP_CORE_COUNT];
    const struct comp_driver *init_drv;
    bool init_needed[IPC_DSP_CORE_COUNT];
    uint8_t init_drv_data[160] __aligned(4);
};
 
struct ipc {
    struct k_spinlock lock; /* locking mechanism */
    void *comp_data;
 
    /* PM */
    int pm_prepare_D3;  /* do we need to prepare for D3 */
 
    struct list_item msg_list;  /* queue of messages to be sent */
    bool is_notification_pending;   /* notification is being sent to host */
    uint32_t task_mask;     /* tasks to be completed by this IPC */
    unsigned int core;      /* core, processing the IPC */
 
    struct list_item comp_list; /* list of component devices */
 
    /* processing task */
#if CONFIG_TWB_IPC_TASK
    struct task *ipc_task;
#else
    struct task ipc_task;
#endif
 
#ifdef CONFIG_SOF_USERSPACE_LL
    struct ipc_user *ipc_user_pdata;
    struct mod_alloc_ctx *ll_alloc;
#endif
 
#ifdef CONFIG_SOF_TELEMETRY_IO_PERFORMANCE_MEASUREMENTS
    /* io performance measurement */
    struct io_perf_data_item *io_perf_in_msg_count;
    struct io_perf_data_item *io_perf_out_msg_count;
#endif
 
#ifdef __ZEPHYR__
    struct k_work_delayable z_delayed_work;
    struct k_work_q ipc_send_wq;
#endif
 
    void *private;
};
 
#define ipc_set_drvdata(ipc, data) \
    ((ipc)->private = data)
#define ipc_get_drvdata(ipc) \
    ((ipc)->private)
 
extern struct task_ops ipc_task_ops;
 
#ifdef CONFIG_SOF_USERSPACE_LL
 
struct ipc *ipc_get(void);
 
#else
 
static inline struct ipc *ipc_get(void)
{
    return sof_get()->ipc;
}
 
#endif /* CONFIG_SOF_USERSPACE_LL */
 
int ipc_init(struct sof *sof);
 
void ipc_free(struct ipc *ipc);
 
struct ipc_data_host_buffer {
    /* DMA */
#if CONFIG_ZEPHYR_NATIVE_DRIVERS
    struct sof_dma *dmac;
#else
    struct dma *dmac;
#endif
    uint8_t *page_table;
};
 
int ipc_process_host_buffer(struct ipc *ipc,
                struct sof_ipc_host_buffer *ring,
                uint32_t direction,
                struct dma_sg_elem_array *elem_array,
                uint32_t *ring_size);
 
int ipc_dma_trace_send_position(void);
 
void ipc_send_buffer_status_notify(void);
 
struct dai_data;
int ipc_dai_data_config(struct dai_data *dd, struct comp_dev *dev);
 
int ipc4_user_process_module_message(struct ipc4_message_request *ipc4, struct ipc_msg *reply);
 
int ipc4_user_process_glb_message(struct ipc4_message_request *ipc4, struct ipc_msg *reply);
 
void ipc_compound_msg_done(uint32_t msg_id, int error);
 
void ipc_boot_complete_msg(struct ipc_cmd_hdr *header, uint32_t data);
 
#if defined(CONFIG_PM_DEVICE) && defined(CONFIG_IPC_SERVICE_BACKEND_INTEL_ADSP_HOST_IPC)
void ipc_send_failed_power_transition_response(void);
#endif /* CONFIG_PM_DEVICE && CONFIG_IPC_SERVICE_BACKEND_INTEL_ADSP_HOST_IPC */
void ipc_send_panic_notification(void);
 
struct ipc_cmd_hdr *ipc_compact_read_msg(void);
 
int ipc_compact_write_msg(struct ipc_cmd_hdr *hdr);
 
struct ipc_cmd_hdr *ipc_prepare_to_send(const struct ipc_msg *msg);
 
struct ipc_cmd_hdr *mailbox_validate(void);
 
void ipc_cmd(struct ipc_cmd_hdr *_hdr);
 
int ipc_process_on_core(uint32_t core, bool blocking);
 
void ipc_complete_cmd(struct ipc *ipc);
 
/* GDB stub: should enter GDB after completing the IPC processing */
extern bool ipc_enter_gdb;
 
#ifdef CONFIG_SOF_USERSPACE_LL
int ipc_user_forward_cmd(uint32_t primary, uint32_t extension, unsigned int core);
 
int ipc_user_thread_dispatch(struct ipc_user *ipc_user);
 
int ipc_user_init_secondary(unsigned int core);
#endif
 
struct k_thread *ipc_thread_user(unsigned int core);
 
#endif /* __SOF_DRIVERS_IPC_H__ */