multicore.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef _PICO_MULTICORE_H
#define _PICO_MULTICORE_H
 
#include "pico/types.h"
#include "pico/sync.h"
#include "hardware/structs/sio.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
// PICO_CONFIG: PARAM_ASSERTIONS_ENABLED_PICO_MULTICORE, Enable/disable assertions in the pico_multicore module, type=bool, default=0, group=pico_multicore
#ifndef PARAM_ASSERTIONS_ENABLED_PICO_MULTICORE
#define PARAM_ASSERTIONS_ENABLED_PICO_MULTICORE 0
#endif

 
// PICO_CONFIG: PICO_CORE1_STACK_SIZE, Minimum amount of stack space reserved in the linker script for core 1 - if zero then no space is reserved and the user must provide their own stack, min=0, max=0x10000, default=PICO_STACK_SIZE (0x800), group=pico_multicore
#ifndef PICO_CORE1_STACK_SIZE
#ifdef PICO_STACK_SIZE
#define PICO_CORE1_STACK_SIZE PICO_STACK_SIZE
#else
#define PICO_CORE1_STACK_SIZE 0x800
#endif
#endif
 
// PICO_CONFIG: PICO_MULTICORE_LOCKOUT_BEFORE_CORE1_STARTED, Allow multicore_lockout functions called from core 0 to succeed if core1 has not been started, type=bool, default=1, group=pico_multicore
#ifndef PICO_MULTICORE_LOCKOUT_BEFORE_CORE1_STARTED
#define PICO_MULTICORE_LOCKOUT_BEFORE_CORE1_STARTED 1
#endif

#ifndef SIO_FIFO_IRQ_NUM
#if !PICO_RP2040
#define SIO_FIFO_IRQ_NUM(core) SIO_IRQ_FIFO
#else
static_assert(SIO_IRQ_PROC1 == SIO_IRQ_PROC0 + 1, "");
#define SIO_FIFO_IRQ_NUM(core) (SIO_IRQ_PROC0 + (core))
#endif
#endif

void multicore_reset_core1(void);

void multicore_launch_core1(void (*entry)(void));

void multicore_launch_core1_with_stack(void (*entry)(void), uint32_t *stack_bottom, size_t stack_size_bytes);

void multicore_launch_core1_raw(void (*entry)(void), uint32_t *sp, uint32_t vector_table);


static inline bool multicore_fifo_rvalid(void) {
    return sio_hw->fifo_st & SIO_FIFO_ST_VLD_BITS;
}

static inline bool multicore_fifo_wready(void) {
    return sio_hw->fifo_st & SIO_FIFO_ST_RDY_BITS;
}

void multicore_fifo_push_blocking(uint32_t data);

static inline void multicore_fifo_push_blocking_inline(uint32_t data) {
    // We wait for the fifo to have some space
    while (!multicore_fifo_wready())
        tight_loop_contents();
 
    sio_hw->fifo_wr = data;
 
    // Fire off an event to the other core
    __sev();
}

bool multicore_fifo_push_timeout_us(uint32_t data, uint64_t timeout_us);

uint32_t multicore_fifo_pop_blocking(void);

static inline uint32_t multicore_fifo_pop_blocking_inline(void) {
    // If nothing there yet, we wait for an event first,
    // to try and avoid too much busy waiting
    while (!multicore_fifo_rvalid())
        __wfe();
 
    return sio_hw->fifo_rd;
}

bool multicore_fifo_pop_timeout_us(uint64_t timeout_us, uint32_t *out);

static inline void multicore_fifo_drain(void) {
    while (multicore_fifo_rvalid())
        (void) sio_hw->fifo_rd;
}

static inline void multicore_fifo_clear_irq(void) {
    // Write any value to clear the error flags
    sio_hw->fifo_st = 0xff;
}

static inline uint32_t multicore_fifo_get_status(void) {
    return sio_hw->fifo_st;
}

 
#if NUM_DOORBELLS
static inline void check_doorbell_num_param(__unused uint doorbell_num) {
    invalid_params_if(PICO_MULTICORE, doorbell_num >= NUM_DOORBELLS);
}
 
static inline void check_core_mask_param(__unused uint core_mask) {
    invalid_params_if(PICO_MULTICORE, core_mask >= (1u << NUM_CORES));
}

void multicore_doorbell_claim(uint doorbell_num, uint core_mask);

int multicore_doorbell_claim_unused(uint core_mask, bool required);

void multicore_doorbell_unclaim(uint doorbell_num, uint core_mask);

static inline void multicore_doorbell_set_other_core(uint doorbell_num) {
    check_doorbell_num_param(doorbell_num);
    sio_hw->doorbell_out_set = 1u << doorbell_num;
}

static inline void multicore_doorbell_clear_other_core(uint doorbell_num) {
    check_doorbell_num_param(doorbell_num);
    sio_hw->doorbell_out_clr = 1u << doorbell_num;
}

static inline void multicore_doorbell_set_current_core(uint doorbell_num) {
    check_doorbell_num_param(doorbell_num);
    sio_hw->doorbell_in_set = 1u << doorbell_num;
}

static inline void multicore_doorbell_clear_current_core(uint doorbell_num) {
    check_doorbell_num_param(doorbell_num);
    sio_hw->doorbell_in_clr = 1u << doorbell_num;
}

static inline bool multicore_doorbell_is_set_current_core(uint doorbell_num) {
    check_doorbell_num_param(doorbell_num);
    return sio_hw->doorbell_in_set & (1u << doorbell_num);
}

static inline bool multicore_doorbell_is_set_other_core(uint doorbell_num) {
    check_doorbell_num_param(doorbell_num);
    return sio_hw->doorbell_out_set & (1u << doorbell_num);
}

#ifndef DOORBELL_IRQ_NUM
#define DOORBELL_IRQ_NUM(doorbell_num) SIO_IRQ_BELL
#endif
 
static inline uint multicore_doorbell_irq_num(uint doorbell_num) {
    check_doorbell_num_param(doorbell_num);
    return DOORBELL_IRQ_NUM(doorbell_num);
}
 
#endif


void multicore_lockout_victim_init(void);

void multicore_lockout_victim_deinit(void);

bool multicore_lockout_victim_is_initialized(uint core_num);

bool multicore_lockout_ready(void);

void multicore_lockout_start_blocking(void);

bool multicore_lockout_start_timeout_us(uint64_t timeout_us);

void multicore_lockout_end_blocking(void);

bool multicore_lockout_end_timeout_us(uint64_t timeout_us);
 
#ifdef __cplusplus
}
#endif
#endif