schedule.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 *
 * Copyright(c) 2019 Intel Corporation. All rights reserved.
 *
 * Author: Bartosz Kokoszko <bartoszx.kokoszko@linux.intel.com>
 */
 
#ifndef __SOF_SCHEDULE_SCHEDULE_H__
#define __SOF_SCHEDULE_SCHEDULE_H__
 
#include <sof/common.h>
#include <sof/list.h>
#include <rtos/task.h>
#include <sof/trace/trace.h>
#include <user/trace.h>
#include <errno.h>
#include <stddef.h>
#include <stdint.h>
#include <ipc4/base_fw.h>
 
enum {
    SOF_SCHEDULE_EDF = 0,
    SOF_SCHEDULE_LL_TIMER,
    SOF_SCHEDULE_LL_DMA,
    SOF_SCHEDULE_DP,
    SOF_SCHEDULE_TWB,
    SOF_SCHEDULE_COUNT
};
 
#define SOF_SCHEDULER_FREE_IRQ_ONLY BIT(0) 
struct scheduler_ops {
    int (*schedule_task)(void *data, struct task *task, uint64_t start,
                 uint64_t period);
 
    int (*schedule_task_before)(void *data, struct task *task, uint64_t start,
                    uint64_t period, struct task *before);
 
    int (*schedule_task_after)(void *data, struct task *task, uint64_t start,
                   uint64_t period, struct task *after);
 
    int (*schedule_task_running)(void *data, struct task *task);
 
    int (*reschedule_task)(void *data, struct task *task, uint64_t start);
 
    int (*schedule_task_cancel)(void *data, struct task *task);
 
    int (*schedule_task_free)(void *data, struct task *task);
 
#if CONFIG_SOF_BOOT_TEST_STANDALONE || CONFIG_LIBRARY
    void (*scheduler_free)(void *data, uint32_t flags);
#endif
 
    struct k_thread *(*scheduler_init_context)(void *data, struct task *task);
};
 
struct schedule_data {
    struct list_item list;          
    int type;               
    const struct scheduler_ops *ops;    
    void *data;             
};
 
struct schedulers {
    struct list_item list;  
};
 
struct schedulers **arch_schedulers_get(void);
 
struct schedulers **arch_user_schedulers_get(void);
 
struct schedulers **arch_user_schedulers_get_for_core(int core);
 
static inline void *scheduler_list_get_data(struct schedulers *schedulers, uint16_t type)
{
    struct schedule_data *sch;
    struct list_item *slist;
 
    if (!schedulers)
        return NULL;
 
    list_for_item(slist, &schedulers->list) {
        sch = container_of(slist, struct schedule_data, list);
        if (type == sch->type)
            return sch->data;
    }
 
    return NULL;
}
 
static inline void *scheduler_get_data(uint16_t type)
{
    return scheduler_list_get_data(*arch_schedulers_get(), type);
}
 
static inline void *scheduler_get_user_data(uint16_t type)
{
    return scheduler_list_get_data(*arch_user_schedulers_get(), type);
}
 
static inline int schedule_task_running(struct task *task)
{
    struct schedule_data *sch;
 
    assert(task);
    sch = task->sch;
 
    if (!sch->ops->schedule_task_running)
        return 0;
 
    return sch->ops->schedule_task_running(sch->data, task);
}
 
static inline int schedule_task(struct task *task, uint64_t start,
                uint64_t period)
{
    struct schedule_data *sch;
 
    if (!task)
        return -EINVAL;
 
    sch = task->sch;
 
    return sch->ops->schedule_task(sch->data, task, start, period);
}
 
static inline int schedule_task_before(struct task *task, uint64_t start,
                       uint64_t period, struct task *before)
{
    struct schedule_data *sch;
 
    if (!task || !before)
        return -EINVAL;
 
    sch = task->sch;
 
    if (sch->ops->schedule_task_before)
        return sch->ops->schedule_task_before(sch->data, task, start,
                              period, before);
 
    return sch->ops->schedule_task(sch->data, task, start, period);
}
 
static inline int schedule_task_after(struct task *task, uint64_t start,
                      uint64_t period, struct task *after)
{
    struct schedule_data *sch;
 
    if (!task || !after)
        return -EINVAL;
 
    sch = task->sch;
 
    if (sch->ops->schedule_task_after)
        return sch->ops->schedule_task_after(sch->data, task, start,
                             period, after);
 
    return sch->ops->schedule_task(sch->data, task, start, period);
}
 
static inline int reschedule_task(struct task *task, uint64_t start)
{
    struct schedule_data *sch;
 
    assert(task);
    sch = task->sch;
 
    /* optional operation */
    if (!sch->ops->reschedule_task)
        return 0;
 
    return sch->ops->reschedule_task(sch->data, task, start);
}
 
static inline int schedule_task_cancel(struct task *task)
{
    struct schedule_data *sch;
 
    if (!task || !task->sch)
        return -EINVAL;
 
    sch = task->sch;
 
    return sch->ops->schedule_task_cancel(sch->data, task);
}
 
static inline int schedule_task_free(struct task *task)
{
    struct schedule_data *sch;
 
    if (!task || !task->sch)
        return -EINVAL;
 
    sch = task->sch;
 
    return sch->ops->schedule_task_free(sch->data, task);
}
 
/* Only used in a stand-alone test and in a testbench test */
#if CONFIG_SOF_BOOT_TEST_STANDALONE || CONFIG_LIBRARY
static inline void schedule_free(uint32_t flags)
{
    struct schedulers *schedulers = *arch_schedulers_get();
    struct schedule_data *sch;
    struct list_item *slist;
 
    list_for_item(slist, &schedulers->list) {
        sch = container_of(slist, struct schedule_data, list);
        if (sch->ops->scheduler_free)
            sch->ops->scheduler_free(sch->data, flags);
    }
}
#endif
 
static inline struct k_thread *scheduler_init_context(struct task *task)
{
    struct schedule_data *sch;
 
    assert(task && task->sch);
    sch = task->sch;
 
    if (sch->ops->scheduler_init_context)
        return sch->ops->scheduler_init_context(sch->data, task);
 
    return NULL;
}
 
int schedule_task_init(struct task *task,
               const struct sof_uuid_entry *uid, uint16_t type,
               int16_t priority, enum task_state (*run)(void *data),
               void *data, uint16_t core, uint32_t flags);
 
void scheduler_init(int type, const struct scheduler_ops *ops, void *data);
 
void scheduler_get_task_info(struct scheduler_props *scheduler_props,
                 uint32_t *data_off_size, struct list_item *tasks);
 
#endif /* __SOF_SCHEDULE_SCHEDULE_H__ */