pipeline.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>
 */
 
#ifndef __SOF_AUDIO_PIPELINE_H__
#define __SOF_AUDIO_PIPELINE_H__
 
#include <sof/lib/cpu.h>
#include <sof/list.h>
#include <rtos/task.h>
#include <rtos/sof.h>
#include <rtos/spinlock.h>
#include <sof/audio/pipeline-trace.h>
#include <ipc/topology.h>
#include <user/trace.h>
#include <errno.h>
#include <stdbool.h>
#include <stdint.h>
 
struct comp_buffer;
struct comp_dev;
struct ipc;
struct ipc_msg;
struct k_heap;
struct mod_alloc_ctx;
 
#define PPL_STATUS_PATH_STOP        1
 
#define PPL_STATUS_PATH_TERMINATE   2
 
#define PPL_STATUS_SCHEDULED    2
 
#define PPL_CONN_DIR_COMP_TO_BUFFER 0   
#define PPL_CONN_DIR_BUFFER_TO_COMP 1   
#define PPL_DIR_DOWNSTREAM  0   
#define PPL_DIR_UPSTREAM    1   
struct pipeline {
    struct mod_alloc_ctx *alloc;    
    uint32_t comp_id;   
    uint32_t pipeline_id;   
    uint32_t sched_id;  
    uint32_t core;      
    uint32_t period;    
    uint32_t priority;  
    uint32_t period_mips;   
    uint32_t frames_per_sched;
    uint32_t xrun_limit_usecs; 
    uint32_t time_domain;   
    uint32_t attributes;   
    /* runtime status */
    int32_t xrun_bytes;     
    uint32_t status;        
    struct tr_ctx tctx;     
    /* scheduling */
#ifdef CONFIG_IPC_MAJOR_4
    struct task *trigger_task;  
#endif
    struct task *pipe_task;     
    struct pipeline *sched_next;    
    struct pipeline *sched_prev;    
    /* component that drives scheduling in this pipe */
    struct comp_dev *sched_comp;    
    /* source component for this pipe */
    struct comp_dev *source_comp;   
    /* sink component for this pipe */
    struct comp_dev *sink_comp; 
    struct list_item list;  
    /* position update */
    uint32_t posn_offset;       
    struct ipc_msg *msg;        
    struct {
        int cmd;        
        struct comp_dev *host;  
        unsigned int delay; 
        bool aborted;       
        bool pending;       
    } trigger;          
};
 
struct pipeline_walk_context {
    int (*comp_func)(struct comp_dev *cd, struct comp_buffer *buffer,
             struct pipeline_walk_context *ctx, int dir);
    void *comp_data;    
    void (*buff_func)(struct comp_buffer *buffer, void *data);
    void *buff_data;    
    struct comp_buffer *incoming;   
    struct list_item pipelines; 
    /*
     * If this flag is set, pipeline_for_each_comp() will skip all
     * incompletely initialised components, i.e. those, whose .pipeline ==
     * NULL. Such components should not be skipped during initialisation
     * and clean up, but they should be skipped during streaming.
     */
    bool skip_incomplete;   
};
 
struct pipeline_data {
    struct comp_dev *start;         
    struct sof_ipc_pcm_params *params;  
    struct sof_ipc_stream_posn *posn;   
    struct pipeline *p;         
    int cmd;                
    uint32_t delay_ms;          
#if CONFIG_KCPS_DYNAMIC_CLOCK_CONTROL
    int32_t kcps[CONFIG_CORE_COUNT];    
#endif
};
 
struct pipeline_task {
    struct task task;       
    bool registrable;       
    struct comp_dev *sched_comp;    
};
 
struct ipc4_pipeline_ext_obj_mem_data;
 
struct create_pipeline_params {
    const struct ipc4_pipeline_ext_obj_mem_data *mem_data;  
};
 
#define pipeline_task_get(t) container_of(t, struct pipeline_task, task)
 
/*
 * Pipeline Graph APIs
 *
 * These APIs are used to construct and bind pipeline graphs. They are also
 * used to query pipeline fundamental configuration.
 */
 
struct pipeline *pipeline_new(struct k_heap *heap, uint32_t pipeline_id, uint32_t priority,
                  uint32_t comp_id, struct create_pipeline_params *pparams);
 
int pipeline_free(struct pipeline *p);
 
int pipeline_connect(struct comp_dev *comp, struct comp_buffer *buffer,
             int dir);
 
void pipeline_disconnect(struct comp_dev *comp, struct comp_buffer *buffer,
             int dir);
 
int pipeline_complete(struct pipeline *p, struct comp_dev *source,
              struct comp_dev *sink);
 
void pipeline_posn_init(struct sof *sof);
 
#ifdef CONFIG_SOF_USERSPACE_LL
void pipeline_posn_grant_access(struct k_thread *thread);
#endif
 
int pipeline_reset(struct pipeline *p, struct comp_dev *host_cd);
 
void pipeline_set_eos(struct pipeline *p, bool eos);
 
int pipeline_for_each_comp(struct comp_dev *current,
               struct pipeline_walk_context *ctx, int dir);
 
struct comp_dev *pipeline_get_dai_comp(uint32_t pipeline_id, int dir);
 
#if CONFIG_IPC_MAJOR_4
struct comp_dev *pipeline_get_dai_comp_latency(uint32_t pipeline_id, uint32_t *latency);
#endif
 
static inline uint32_t pipeline_id(struct pipeline *p)
{
    return p->pipeline_id;
}
 
/*
 * Pipeline configuration APIs
 *
 * These APIs are used to configure the runtime parameters of a pipeline.
 */
 
int pipeline_params(struct pipeline *p, struct comp_dev *cd,
            struct sof_ipc_pcm_params *params);
 
int pipeline_prepare(struct pipeline *p, struct comp_dev *cd);
 
/*
 * Pipeline stream APIs
 *
 * These APIs are used to control pipeline processing work.
 */
 
int pipeline_trigger(struct pipeline *p, struct comp_dev *host, int cmd);
 
int pipeline_trigger_run(struct pipeline *p, struct comp_dev *host, int cmd);
 
int pipeline_copy(struct pipeline *p);
 
void pipeline_get_timestamp(struct pipeline *p, struct comp_dev *host_dev,
                struct sof_ipc_stream_posn *posn);
 
/*
 * Pipeline scheduling APIs
 *
 * These APIs are used to schedule pipeline processing work.
 */
 
static inline bool pipeline_is_same_sched_comp(struct pipeline *current,
                           struct pipeline *previous)
{
    return current->sched_comp == previous->sched_comp;
}
 
static inline bool pipeline_is_timer_driven(struct pipeline *p)
{
    return p->time_domain == SOF_TIME_DOMAIN_TIMER;
}
 
static inline bool pipeline_is_this_cpu(struct pipeline *p)
{
    return p->core == cpu_get_id();
}
 
int pipeline_comp_ll_task_init(struct pipeline *p);
 
void pipeline_comp_ll_task_free(struct pipeline *p);
 
int pipeline_comp_dp_task_init(struct comp_dev *comp);
 
void pipeline_schedule_copy(struct pipeline *p, uint64_t start);
 
void pipeline_comp_trigger_sched_comp(struct pipeline *p,
                      struct comp_dev *comp,
                      struct pipeline_walk_context *ctx);
 
void pipeline_schedule_triggered(struct pipeline_walk_context *ctx,
                 int cmd);
 
void pipeline_schedule_config(struct pipeline *p, uint32_t sched_id,
                  uint32_t core, uint32_t period,
                  uint32_t period_mips, uint32_t frames_per_sched,
                  uint32_t time_domain);
 
/*
 * Pipeline error handling APIs
 *
 * These APIs are used to handle, report and recover from pipeline errors.
 */
 
int pipeline_xrun_recover(struct pipeline *p);
 
int pipeline_xrun_handle_trigger(struct pipeline *p, int cmd);
 
void pipeline_xrun(struct pipeline *p, struct comp_dev *dev, int32_t bytes);
 
int pipeline_xrun_set_limit(struct pipeline *p, uint32_t xrun_limit_usecs);
 
void pipeline_comp_copy_error_notify(const struct comp_dev *component, int error_code);
 
#endif /* __SOF_AUDIO_PIPELINE_H__ */