dp_schedule.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause */
/*
 * Copyright(c) 2023 Intel Corporation. All rights reserved.
 *
 * Author: Marcin Szkudlinski
 */
 
#ifndef __SOF_SCHEDULE_DP_SCHEDULE_H__
#define __SOF_SCHEDULE_DP_SCHEDULE_H__
 
#include <rtos/task.h>
#include <sof/trace/trace.h>
#include <user/trace.h>
#include <stdint.h>
#include <ipc4/base_fw.h>
#include <ipc4/module.h>
#include <ipc4/pipeline.h>
#include <module/module/interface.h>
 
struct processing_module;
struct module_ext_init_data;
 
int scheduler_dp_init(void);
 
int scheduler_dp_task_init(struct task **task,
               const struct sof_uuid_entry *uid,
               const struct task_ops *ops,
               struct processing_module *mod,
               uint16_t core,
               size_t stack_size,
               uint32_t options);
 
#if defined(__ZEPHYR__) && CONFIG_SOF_FULL_ZEPHYR_APPLICATION
__syscall void scheduler_dp_internal_free(struct task *task);
 
__syscall void scheduler_dp_ll_tick(void);
#include <zephyr/syscalls/dp_schedule.h>
#endif
 
void scheduler_get_task_info_dp(struct scheduler_props *scheduler_props,
                uint32_t *data_off_size);
 
enum {
    DP_TASK_EVENT_PROCESS   = BIT(0),   /* Need to process data */
    DP_TASK_EVENT_CANCEL    = BIT(1),   /* Thread cancellation */
    DP_TASK_EVENT_IPC   = BIT(2),   /* IPC message */
    DP_TASK_EVENT_IPC_DONE  = BIT(3),   /* IPC processing has completed. */
};
 
struct bind_info;
struct sof_source;
struct sof_sink;
/*
 * Keeps the scheduler_dp_thread_ipc() flow simple - just one call that does all
 * the IPC-message specific parameter packing internally. This is slightly
 * suboptimal because IPC parameters first have to be collected in this
 * structure and then packed in DP-accessible memory inside
 * scheduler_dp_thread_ipc(). This could be split into two levels, by adding
 * IPC-specific functions like ipc_flatten_pipeline_state() and similar, but
 * that would add multiple functions to the API.
 */
union scheduler_dp_thread_ipc_param {
    const struct bind_info *bind_data;
    /* SOF_IPC4_MOD_INIT_INSTANCE: ext_data points to the caller's stack frame and is
     * only valid until scheduler_dp_thread_ipc() returns; ipc_thread_flatten() copies
     * it by value into DP-thread-accessible memory before the DP thread runs init().
     */
    const struct module_ext_init_data *ext_data;
    struct {
        unsigned int trigger_cmd;
        enum ipc4_pipeline_state state;
        int n_sources;
        struct sof_source **sources;
        int n_sinks;
        struct sof_sink **sinks;
    } pipeline_state;
    struct {
        uint32_t param_id;
        enum module_cfg_fragment_position position;
        uint32_t data_offset_size;
        size_t fragment_size;
        const char *data;
    } set_config;
    struct {
        uint32_t param_id;
        uint32_t data_offset_size;
        size_t fragment_size;
        char *data;
    } get_config;
};
 
#if CONFIG_ZEPHYR_DP_SCHEDULER
int scheduler_dp_thread_ipc(struct processing_module *pmod, unsigned int cmd,
                union scheduler_dp_thread_ipc_param *param);
#else
static inline int scheduler_dp_thread_ipc(struct processing_module *pmod,
                      unsigned int cmd,
                      union scheduler_dp_thread_ipc_param *param)
{
    return 0;
}
#endif
 
#endif /* __SOF_SCHEDULE_DP_SCHEDULE_H__ */