mmpkt.h

/*
 * Copyright 2022-2024 Morse Micro
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#pragma once
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#include "mmosal.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
#ifndef MM_FAST_ROUND_UP
#define MM_FAST_ROUND_UP(x, m) ((((x)-1) | ((m)-1)) + 1)
#endif
 
#if defined(MMPKT_DEBUG) && MMPKT_DEBUG
#define MMPKT_DEBUG_MAGIC_OPENED    (0x08254759)
#define MMPKT_DEBUG_MAGIC_CLOSED    (0xdeaddead)
#define MMPKT_DEBUG_MAGIC_RELEASED  (0x0bad0bad)
#endif
 
struct mmdrv_cmd_metadata;
struct mmdrv_tx_metadata;
struct mmdrv_rx_metadata;
struct mmpkt_ops;
 
union mmpkt_metadata_ptr {
    void *opaque;
    struct mmdrv_tx_metadata *tx;
    struct mmdrv_rx_metadata *rx;
    struct mmdrv_cmd_metadata *cmd;
};
 
struct mmpkt
{
    uint8_t *buf;
    uint32_t buf_len;
    uint32_t start_offset;
    uint32_t data_len;
    union mmpkt_metadata_ptr metadata;
    const struct mmpkt_ops *ops;
    struct mmpkt *volatile next;
#if defined(MMPKT_DEBUG) && MMPKT_DEBUG
    uint32_t debug_magic;
#endif
};
 
struct mmpkt_ops
{
    void (*free_mmpkt)(void *mmpkt);
};
 
struct mmpktview;
 
static inline void mmpkt_init(struct mmpkt *mmpkt, uint8_t *buf, uint32_t buf_len,
                              uint32_t data_start_offset, const struct mmpkt_ops *ops)
{
    memset(mmpkt, 0, sizeof(*mmpkt));
    mmpkt->buf = buf;
    mmpkt->buf_len = buf_len;
    mmpkt->start_offset = data_start_offset;
    mmpkt->ops = ops;
#if defined(MMPKT_DEBUG) && MMPKT_DEBUG
    mmpkt->debug_magic = MMPKT_DEBUG_MAGIC_CLOSED;
#endif
}
 
static inline struct mmpkt *mmpkt_init_buf(uint8_t *buf, uint32_t buf_len,
                                           uint32_t space_at_start, uint32_t space_at_end,
                                           uint32_t metadata_size, const struct mmpkt_ops *ops)
{
    struct mmpkt *mmpkt = (struct mmpkt *)buf;
 
    uint8_t *data_start;
    uint32_t header_size = MM_FAST_ROUND_UP(sizeof(*mmpkt), 4);
    uint32_t data_len;
    metadata_size = MM_FAST_ROUND_UP(metadata_size, 4);
 
    if (space_at_end != UINT32_MAX)
    {
        data_len = MM_FAST_ROUND_UP(space_at_start + space_at_end, 4);
    }
    else
    {
        /* Special case: if space_at_end is UINT32_MAX then use the entire buffer.
         * Note that we round down to ensure that the metadata is word aligned. */
        data_len = (buf_len - header_size - metadata_size) & ~0x03ul;
        /* Signed comparison in case buf_len was less than (header_size + metadata_size).
         * Note that we do not expect to allocate an mmpkt with length > INT32_MAX, so we
         * can safely treat these as signed integers. */
        if ((int32_t)data_len < (int32_t)space_at_start)
        {
            return NULL;
        }
    }
 
    if (header_size + data_len + metadata_size > buf_len)
    {
        return NULL;
    }
 
    data_start  = ((uint8_t *)mmpkt) + header_size;
 
    mmpkt_init(mmpkt, data_start, data_len, space_at_start, ops);
 
    if (metadata_size != 0)
    {
        mmpkt->metadata.opaque = data_start + data_len;
        memset(mmpkt->metadata.opaque, 0, metadata_size);
    }
 
    return mmpkt;
}
 
 
struct mmpkt *mmpkt_alloc_on_heap(uint32_t space_at_start, uint32_t space_at_end,
                                  uint32_t metadata_size);
 
void mmpkt_release(struct mmpkt *mmpkt);
 
static inline struct mmpktview *mmpkt_open(struct mmpkt *mmpkt)
{
#if defined(MMPKT_DEBUG) && MMPKT_DEBUG
    MMOSAL_ASSERT(mmpkt->debug_magic == MMPKT_DEBUG_MAGIC_CLOSED);
    mmpkt->debug_magic = MMPKT_DEBUG_MAGIC_OPENED;
#endif
    return (struct mmpktview *)mmpkt;
}
 
static inline void mmpkt_close(struct mmpktview **view)
{
    MMOSAL_ASSERT(view != NULL);
#if defined(MMPKT_DEBUG) && MMPKT_DEBUG
    struct mmpkt *mmpkt = (struct mmpkt *)(*view);
    if (mmpkt != NULL)
    {
        MMOSAL_ASSERT(mmpkt->debug_magic == MMPKT_DEBUG_MAGIC_OPENED);
        mmpkt->debug_magic = MMPKT_DEBUG_MAGIC_CLOSED;
    }
#endif
    *view = NULL;
}
 
static inline struct mmpkt *mmpkt_from_view(struct mmpktview *view)
{
    return (struct mmpkt *)view;
}
 
static inline uint8_t *mmpkt_get_data_start(struct mmpktview *view)
{
    struct mmpkt *mmpkt = (struct mmpkt *)view;
#if defined(MMPKT_DEBUG) && MMPKT_DEBUG
    MMOSAL_ASSERT(mmpkt->debug_magic == MMPKT_DEBUG_MAGIC_OPENED);
#endif
    return mmpkt->buf + mmpkt->start_offset;
}
 
static inline uint8_t *mmpkt_get_data_end(struct mmpktview *view)
{
    struct mmpkt *mmpkt = (struct mmpkt *)view;
#if defined(MMPKT_DEBUG) && MMPKT_DEBUG
    MMOSAL_ASSERT(mmpkt->debug_magic == MMPKT_DEBUG_MAGIC_OPENED);
#endif
    return mmpkt->buf + mmpkt->start_offset + mmpkt->data_len;
}
 
static inline uint32_t mmpkt_peek_data_length(const struct mmpkt *mmpkt)
{
    return mmpkt->data_len;
}
 
static inline uint32_t mmpkt_get_data_length(struct mmpktview *view)
{
    struct mmpkt *mmpkt = (struct mmpkt *)view;
#if defined(MMPKT_DEBUG) && MMPKT_DEBUG
    MMOSAL_ASSERT(mmpkt->debug_magic == MMPKT_DEBUG_MAGIC_OPENED);
#endif
    return mmpkt->data_len;
}
 
static inline uint32_t mmpkt_available_space_at_start(struct mmpktview *view)
{
    struct mmpkt *mmpkt = (struct mmpkt *)view;
#if defined(MMPKT_DEBUG) && MMPKT_DEBUG
    MMOSAL_ASSERT(mmpkt->debug_magic == MMPKT_DEBUG_MAGIC_OPENED);
#endif
    return mmpkt->start_offset;
}
 
static inline uint32_t mmpkt_available_space_at_end(struct mmpktview *view)
{
    struct mmpkt *mmpkt = (struct mmpkt *)view;
#if defined(MMPKT_DEBUG) && MMPKT_DEBUG
    MMOSAL_ASSERT(mmpkt->debug_magic == MMPKT_DEBUG_MAGIC_OPENED);
#endif
    return mmpkt->buf_len - (mmpkt->start_offset + mmpkt->data_len);
}
 
static inline uint8_t *mmpkt_prepend(struct mmpktview *view, uint32_t len)
{
    struct mmpkt *mmpkt = (struct mmpkt *)view;
#if defined(MMPKT_DEBUG) && MMPKT_DEBUG
    MMOSAL_ASSERT(mmpkt->debug_magic == MMPKT_DEBUG_MAGIC_OPENED);
#endif
    MMOSAL_ASSERT(len <= mmpkt_available_space_at_start(view));
    mmpkt->start_offset -= len;
    mmpkt->data_len += len;
    return mmpkt->buf + mmpkt->start_offset;
}
 
static inline void mmpkt_prepend_data(struct mmpktview *view, const uint8_t * data, uint32_t len)
{
    uint8_t *dest = mmpkt_prepend(view, len);
    memcpy(dest, data, len);
}
 
static inline uint8_t *mmpkt_append(struct mmpktview *view, uint32_t len)
{
    struct mmpkt *mmpkt = (struct mmpkt *)view;
#if defined(MMPKT_DEBUG) && MMPKT_DEBUG
    MMOSAL_ASSERT(mmpkt->debug_magic == MMPKT_DEBUG_MAGIC_OPENED);
#endif
    uint8_t *ret = mmpkt_get_data_end(view);
    MMOSAL_ASSERT(len <= mmpkt_available_space_at_end(view));
    mmpkt->data_len += len;
    return ret;
}
 
static inline void mmpkt_append_data(struct mmpktview *view, const uint8_t *data, uint32_t len)
{
    uint8_t *dest = mmpkt_append(view, len);
    memcpy(dest, data, len);
}
 
static inline union mmpkt_metadata_ptr mmpkt_get_metadata(struct mmpkt *mmpkt)
{
    return mmpkt->metadata;
}
 
static inline void mmpkt_adjust_start_offset(struct mmpkt *mmpkt, int32_t delta)
{
    MMOSAL_ASSERT(mmpkt->data_len == 0);
    mmpkt->start_offset += delta;
    MMOSAL_ASSERT(mmpkt->start_offset <= mmpkt->buf_len);
}
 
static inline uint8_t *mmpkt_remove_from_start(struct mmpktview *view, uint32_t len)
{
    struct mmpkt *mmpkt = (struct mmpkt *)view;
#if defined(MMPKT_DEBUG) && MMPKT_DEBUG
    MMOSAL_ASSERT(mmpkt->debug_magic == MMPKT_DEBUG_MAGIC_OPENED);
#endif
    uint8_t *ret;
 
    if (mmpkt_get_data_length(view) < len)
    {
        return NULL;
    }
 
    ret = mmpkt_get_data_start(view);
 
    mmpkt->start_offset += len;
    mmpkt->data_len -= len;
 
    return ret;
}
 
static inline uint8_t *mmpkt_remove_from_end(struct mmpktview *view, uint32_t len)
{
    struct mmpkt *mmpkt = (struct mmpkt *)view;
#if defined(MMPKT_DEBUG) && MMPKT_DEBUG
    MMOSAL_ASSERT(mmpkt->debug_magic == MMPKT_DEBUG_MAGIC_OPENED);
#endif
 
    if (mmpkt_get_data_length(view) < len)
    {
        return NULL;
    }
 
    uint8_t *ret = mmpkt_get_data_end(view) - len;
 
    mmpkt->data_len -= len;
 
    return ret;
}
 
static inline void mmpkt_truncate(struct mmpkt *mmpkt, uint32_t len)
{
    MMOSAL_ASSERT(len <= mmpkt->data_len);
    mmpkt->data_len = len;
}
 
static inline struct mmpkt *mmpkt_get_next(struct mmpkt *mmpkt)
{
    return mmpkt->next;
}
 
static inline void mmpkt_set_next(struct mmpkt *mmpkt, struct mmpkt *next)
{
    mmpkt->next = next;
}
 
static inline bool mmpkt_contains_ptr(struct mmpktview *view, const void *ptr)
{
    struct mmpkt *mmpkt = (struct mmpkt *)view;
#if defined(MMPKT_DEBUG) && MMPKT_DEBUG
    MMOSAL_ASSERT(mmpkt->debug_magic == MMPKT_DEBUG_MAGIC_OPENED);
#endif
    return ((const uint8_t *)ptr >= &mmpkt->buf[0]
            && (const uint8_t *)ptr < &mmpkt->buf[mmpkt->buf_len]);
}
 
#ifdef __cplusplus
}
#endif