task.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 __ZEPHYR_RTOS_TASK_H__
#define __ZEPHYR_RTOS_TASK_H__
 
#include <rtos/panic.h>
#include <sof/list.h>
#include <stdbool.h>
#include <stdint.h>
#include <rtos/kernel.h>
#include <sof/lib/perf_cnt.h>
 
struct comp_dev;
struct sof;
struct schedule_data;

#define SOF_TASK_PRI_HIGH   0   /* priority level 0 - high */
#define SOF_TASK_PRI_MED    4   /* priority level 4 - medium */
#define SOF_TASK_PRI_LOW    9   /* priority level 9 - low */

#define SOF_TASK_DEADLINE_IDLE      UINT64_MAX
#define SOF_TASK_DEADLINE_ALMOST_IDLE   (SOF_TASK_DEADLINE_IDLE - 1)
#define SOF_TASK_DEADLINE_NOW       0

#define SOF_TASK_SKIP_COUNT     0xFFFFu

enum task_state {
    SOF_TASK_STATE_INIT = 0,
    SOF_TASK_STATE_QUEUED,
    SOF_TASK_STATE_PENDING,
    SOF_TASK_STATE_RUNNING,
    SOF_TASK_STATE_PREEMPTED,
    SOF_TASK_STATE_COMPLETED,
    SOF_TASK_STATE_FREE,
    SOF_TASK_STATE_CANCEL,
    SOF_TASK_STATE_RESCHEDULE,
};

struct task_ops {
    enum task_state (*run)(void *data); 
    void (*complete)(void *data);       
    uint64_t (*get_deadline)(void *data);   
};

struct task {
    uint64_t start;     
    const struct sof_uuid_entry *uid; 
    uint16_t type;      
    int16_t priority;   
    uint16_t core;      
    uint16_t flags;     
    struct schedule_data *sch;  
    enum task_state state;  
    void *data;     
    struct list_item list;  
    void *priv_data;    
    struct task_ops ops;    
    struct k_work_delayable z_delayed_work;
    uint32_t cycles_sum;
    uint32_t cycles_max;
    uint32_t cycles_cnt;
#if CONFIG_PERFORMANCE_COUNTERS
    struct perf_cnt_data pcd;
#endif
};
 
static inline bool task_is_active(struct task *task)
{
    switch (task->state) {
    case SOF_TASK_STATE_QUEUED:
    case SOF_TASK_STATE_PENDING:
    case SOF_TASK_STATE_RUNNING:
    case SOF_TASK_STATE_PREEMPTED:
    case SOF_TASK_STATE_RESCHEDULE:
        return true;
    default:
        return false;
    }
}
 
static inline enum task_state task_run(struct task *task)
{
    assert(task->ops.run);
 
    return task->ops.run(task->data);
}
 
static inline void task_complete(struct task *task)
{
    if (task->ops.complete)
        task->ops.complete(task->data);
}
 
static inline uint64_t task_get_deadline(struct task *task)
{
    assert(task->ops.get_deadline);
 
    return task->ops.get_deadline(task->data);
}
 
int task_main_start(struct sof *sof);
int start_complete(void);
 
#endif /* __ZEPHYR_RTOS_TASK_H__ */