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/lib/mailbox.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;
 
/*
 * Pipeline status to stop execution of current path, but to keep the
 * pipeline alive, when processing COMP_TRIGGER_STOP or COMP_TRIGGER_PAUSE
 */
#define PPL_STATUS_PATH_STOP        1
/*
 * Pipeline status to stop execution of current path, and to terminate the
 * pipeline, when processing COMP_TRIGGER_STOP or COMP_TRIGGER_PAUSE
 */
#define PPL_STATUS_PATH_TERMINATE   2
 
/* Pipeline scheduled in another thread other than ipc thread */
#define PPL_STATUS_SCHEDULED    2
 
/* pipeline connection directions */
#define PPL_CONN_DIR_COMP_TO_BUFFER 0
#define PPL_CONN_DIR_BUFFER_TO_COMP 1
 
/* pipeline processing directions */
#define PPL_DIR_DOWNSTREAM  0
#define PPL_DIR_UPSTREAM    1
 
/*
 * Audio pipeline.
 */
struct pipeline {
    struct k_heap *heap;    
    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;     /* last xrun length */
    uint32_t status;        /* pipeline status */
    struct tr_ctx tctx;     /* trace settings */
    bool expect_eos;        /* pipeline is expecting end of stream */
 
    /* scheduling */
#ifdef CONFIG_IPC_MAJOR_4
    struct task *trigger_task;  /* IPC4 pipeline trigger task */
#endif
    struct task *pipe_task;     /* IPC3 pipeline processing task or IPC4 pipeline copy task */
    struct pipeline *sched_next;    /* pipeline scheduled after this */
    struct pipeline *sched_prev;    /* pipeline scheduled before this */
 
    /* 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;       /* position update array offset*/
    struct ipc_msg *msg;
    struct {
        int cmd;
        struct comp_dev *host;
        unsigned int delay; /* period count */
        bool aborted;       /* STOP or PAUSE failed, stay active */
        bool pending;       /* trigger scheduled but not executed yet */
    } 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;
};
 
/* generic pipeline data used by pipeline_comp_* functions */
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;      /* between PRE_{START,RELEASE} and {START,RELEASE} */
#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);

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__ */