async_context.h

Go to the documentation of this file.

/*
 * Copyright (c) 2022 Raspberry Pi (Trading) Ltd.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */

 
#ifndef _PICO_ASYNC_CONTEXT_H
#define _PICO_ASYNC_CONTEXT_H
 
#include "pico.h"
#include "pico/time.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
enum {
    ASYNC_CONTEXT_POLL = 1,
    ASYNC_CONTEXT_THREADSAFE_BACKGROUND = 2,
    ASYNC_CONTEXT_FREERTOS = 3,
};
 
typedef struct async_context async_context_t;

typedef struct async_work_on_timeout {
    struct async_work_on_timeout *next;
    void (*do_work)(async_context_t *context, struct async_work_on_timeout *timeout);
    absolute_time_t next_time;
    void *user_data;
} async_at_time_worker_t;

typedef struct async_when_pending_worker {
    struct async_when_pending_worker *next;
    void (*do_work)(async_context_t *context, struct async_when_pending_worker *worker);
    bool work_pending;
    void *user_data;
} async_when_pending_worker_t;
 
#define ASYNC_CONTEXT_FLAG_CALLBACK_FROM_NON_IRQ 0x1
#define ASYNC_CONTEXT_FLAG_CALLBACK_FROM_IRQ 0x2
#define ASYNC_CONTEXT_FLAG_POLLED 0x4

typedef struct async_context_type {
    uint16_t type; 
    // see wrapper functions for documentation
    void (*acquire_lock_blocking)(async_context_t *self); 
    void (*release_lock)(async_context_t *self); 
    void (*lock_check)(async_context_t *self); 
    uint32_t (*execute_sync)(async_context_t *context, uint32_t (*func)(void *param), void *param); 
    bool (*add_at_time_worker)(async_context_t *self, async_at_time_worker_t *worker); 
    bool (*remove_at_time_worker)(async_context_t *self, async_at_time_worker_t *worker); 
    bool (*add_when_pending_worker)(async_context_t *self, async_when_pending_worker_t *worker); 
    bool (*remove_when_pending_worker)(async_context_t *self, async_when_pending_worker_t *worker); 
    void (*set_work_pending)(async_context_t *self, async_when_pending_worker_t *worker); 
    void (*poll)(async_context_t *self); 
    void (*wait_until)(async_context_t *self, absolute_time_t until); 
    void (*wait_for_work_until)(async_context_t *self, absolute_time_t until); 
    void (*deinit)(async_context_t *self); 
} async_context_type_t;

struct async_context {
    const async_context_type_t *type; 
    async_when_pending_worker_t *when_pending_list; 
    async_at_time_worker_t *at_time_list; 
    absolute_time_t next_time; 
    uint16_t flags; 
    uint8_t core_num; 
};

static inline void async_context_acquire_lock_blocking(async_context_t *context) {
    context->type->acquire_lock_blocking(context);
}

static inline void async_context_release_lock(async_context_t *context) {
    context->type->release_lock(context);
}

static inline void async_context_lock_check(async_context_t *context) {
    context->type->lock_check(context);
}

static inline uint32_t async_context_execute_sync(async_context_t *context, uint32_t (*func)(void *param), void *param) {
    return context->type->execute_sync(context, func, param);
}

static inline bool async_context_add_at_time_worker(async_context_t *context, async_at_time_worker_t *worker) {
    return context->type->add_at_time_worker(context, worker);
}

static inline bool async_context_add_at_time_worker_at(async_context_t *context, async_at_time_worker_t *worker, absolute_time_t at) {
    worker->next_time = at;
    return context->type->add_at_time_worker(context, worker);
}

static inline bool async_context_add_at_time_worker_in_ms(async_context_t *context, async_at_time_worker_t *worker, uint32_t ms) {
    worker->next_time = make_timeout_time_ms(ms);
    return context->type->add_at_time_worker(context, worker);
}

static inline bool async_context_remove_at_time_worker(async_context_t *context, async_at_time_worker_t *worker) {
    return context->type->remove_at_time_worker(context, worker);
}

static inline bool async_context_add_when_pending_worker(async_context_t *context, async_when_pending_worker_t *worker) {
    return context->type->add_when_pending_worker(context, worker);
}

static inline bool async_context_remove_when_pending_worker(async_context_t *context, async_when_pending_worker_t *worker) {
    return context->type->remove_when_pending_worker(context, worker);
}

static inline void async_context_set_work_pending(async_context_t *context, async_when_pending_worker_t *worker) {
    context->type->set_work_pending(context, worker);
}

static inline void async_context_poll(async_context_t *context) {
    if (context->type->poll) context->type->poll(context);
}

static inline void async_context_wait_until(async_context_t *context, absolute_time_t until) {
    context->type->wait_until(context, until);
}

static inline void async_context_wait_for_work_until(async_context_t *context, absolute_time_t until) {
    context->type->wait_for_work_until(context, until);
}

static inline void async_context_wait_for_work_ms(async_context_t *context, uint32_t ms) {
    async_context_wait_for_work_until(context, make_timeout_time_ms(ms));
}

static inline uint async_context_core_num(const async_context_t *context) {
    return context->core_num;
}

static inline void async_context_deinit(async_context_t *context) {
    context->type->deinit(context);
}
 
#ifdef __cplusplus
}
#endif
 
#endif