divider.h

Go to the documentation of this file.

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

#ifndef _HARDWARE_DIVIDER_H
#define _HARDWARE_DIVIDER_H

#include "pico.h"
#include "hardware/structs/sio.h"

#ifdef __cplusplus
extern "C" {
#endif

typedef uint64_t divmod_result_t;

static inline void hw_divider_divmod_s32_start(int32_t a, int32_t b) {
    check_hw_layout( sio_hw_t, div_sdividend, SIO_DIV_SDIVIDEND_OFFSET);
    sio_hw->div_sdividend = (uint32_t)a;
    sio_hw->div_sdivisor = (uint32_t)b;
}

static inline void hw_divider_divmod_u32_start(uint32_t a, uint32_t b) {
    check_hw_layout(
            sio_hw_t, div_udividend, SIO_DIV_UDIVIDEND_OFFSET);
    sio_hw->div_udividend = a;
    sio_hw->div_udivisor = b;
}

static inline void hw_divider_wait_ready(void) {
    // this is #1 in lsr below
    static_assert(SIO_DIV_CSR_READY_BITS == 1, "");

    // we use one less register and instruction than gcc which uses a TST instruction

    uint32_t tmp; // allow compiler to pick scratch register
    asm volatile (
    "hw_divider_result_loop_%=:"
    "ldr %0, [%1, %2]\n\t"
    "lsr %0, #1\n\t"
    "bcc hw_divider_result_loop_%=\n\t"
    : "=&l" (tmp)
    : "l" (sio_hw), "I" (SIO_DIV_CSR_OFFSET)
    :
    );
}

static inline divmod_result_t hw_divider_result_nowait(void) {
    // as ugly as this looks it is actually quite efficient
    divmod_result_t rc = (((divmod_result_t) sio_hw->div_remainder) << 32u) | sio_hw->div_quotient;
    return rc;
}

static inline divmod_result_t hw_divider_result_wait(void) {
    hw_divider_wait_ready();
    return hw_divider_result_nowait();
}

static inline uint32_t hw_divider_u32_quotient_wait(void) {
    hw_divider_wait_ready();
    return sio_hw->div_quotient;
}

static inline int32_t hw_divider_s32_quotient_wait(void) {
    hw_divider_wait_ready();
    return (int32_t)sio_hw->div_quotient;
}

static inline uint32_t hw_divider_u32_remainder_wait(void) {
    hw_divider_wait_ready();
    uint32_t rc = sio_hw->div_remainder;
    sio_hw->div_quotient; // must read quotient to cooperate with other SDK code
    return rc;
}

static inline int32_t hw_divider_s32_remainder_wait(void) {
    hw_divider_wait_ready();
    int32_t rc = (int32_t)sio_hw->div_remainder;
    sio_hw->div_quotient; // must read quotient to cooperate with other SDK code
    return rc;
}

divmod_result_t hw_divider_divmod_s32(int32_t a, int32_t b);

divmod_result_t hw_divider_divmod_u32(uint32_t a, uint32_t b);

inline static uint32_t to_quotient_u32(divmod_result_t r) {
    return (uint32_t) r;
}

inline static int32_t to_quotient_s32(divmod_result_t r) {
    return (int32_t)(uint32_t)r;
}

inline static uint32_t to_remainder_u32(divmod_result_t r) {
    return (uint32_t)(r >> 32u);
}

inline static int32_t to_remainder_s32(divmod_result_t r) {
    return (int32_t)(r >> 32u);
}

static inline uint32_t hw_divider_u32_quotient(uint32_t a, uint32_t b) {
    return to_quotient_u32(hw_divider_divmod_u32(a, b));
}

static inline uint32_t hw_divider_u32_remainder(uint32_t a, uint32_t b) {
    return to_remainder_u32(hw_divider_divmod_u32(a, b));
}

static inline int32_t hw_divider_quotient_s32(int32_t a, int32_t b) {
    return to_quotient_s32(hw_divider_divmod_s32(a, b));
}

static inline int32_t hw_divider_remainder_s32(int32_t a, int32_t b) {
    return to_remainder_s32(hw_divider_divmod_s32(a, b));
}

static inline void hw_divider_pause(void) {
    asm volatile (
    "b _1_%=\n"
    "_1_%=:\n"
    "b _2_%=\n"
    "_2_%=:\n"
    "b _3_%=\n"
    "_3_%=:\n"
    "b _4_%=\n"
    "_4_%=:\n"
    :: : );
}

static inline uint32_t hw_divider_u32_quotient_inlined(uint32_t a, uint32_t b) {
    hw_divider_divmod_u32_start(a, b);
    hw_divider_pause();
    return sio_hw->div_quotient;
}

static inline uint32_t hw_divider_u32_remainder_inlined(uint32_t a, uint32_t b) {
    hw_divider_divmod_u32_start(a, b);
    hw_divider_pause();
    uint32_t rc = sio_hw->div_remainder;
    sio_hw->div_quotient; // must read quotient to cooperate with other SDK code
    return rc;
}

static inline int32_t hw_divider_s32_quotient_inlined(int32_t a, int32_t b) {
    hw_divider_divmod_s32_start(a, b);
    hw_divider_pause();
    return (int32_t)sio_hw->div_quotient;
}

static inline int32_t hw_divider_s32_remainder_inlined(int32_t a, int32_t b) {
    hw_divider_divmod_s32_start(a, b);
    hw_divider_pause();
    int32_t rc = (int32_t)sio_hw->div_remainder;
    sio_hw->div_quotient; // must read quotient to cooperate with other SDK code
    return rc;
}

typedef struct {
    uint32_t values[4];
} hw_divider_state_t;

void hw_divider_save_state(hw_divider_state_t *dest);

void hw_divider_restore_state(hw_divider_state_t *src);

#ifdef __cplusplus
}
#endif

#endif // _HARDWARE_DIVIDER_H