File syn_port_stubs.c

File List > port_stubs > syn_port_stubs.c

Go to the documentation of this file

#include "../common/syn_compiler.h"
#include "../common/syn_defs.h"
#include "../util/syn_assert.h"

/* ── Assert handler default ─────────────────────────────────────────────── */

SYN_WEAK SYN_NORETURN void syn_assert_failed(const char *file, int line)
{
    (void)file;
    (void)line;
    /* Default: spin forever. Override to log, blink LED, enter debugger. */
    for (;;) {
    }
}

/* ── GPIO stubs ─────────────────────────────────────────────────────────── */

SYN_WEAK SYN_Status syn_port_gpio_init(SYN_GPIO_Pin pin, SYN_GPIO_Mode mode)
{
    (void)pin;
    (void)mode;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED; /* unreachable */
}

SYN_WEAK SYN_Status syn_port_gpio_deinit(SYN_GPIO_Pin pin)
{
    (void)pin;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK SYN_Status syn_port_gpio_write(SYN_GPIO_Pin pin, SYN_GPIO_State state)
{
    (void)pin;
    (void)state;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK SYN_GPIO_State syn_port_gpio_read(SYN_GPIO_Pin pin)
{
    (void)pin;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_GPIO_LOW;
}

SYN_WEAK SYN_Status syn_port_gpio_toggle(SYN_GPIO_Pin pin)
{
    (void)pin;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

/* ── UART stubs ─────────────────────────────────────────────────────────── */

SYN_WEAK SYN_Status syn_port_uart_init(SYN_UARTInstance instance, uint32_t baudrate)
{
    (void)instance;
    (void)baudrate;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK SYN_Status syn_port_uart_deinit(SYN_UARTInstance instance)
{
    (void)instance;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK SYN_Status syn_port_uart_transmit(SYN_UARTInstance instance, const uint8_t *data,
                                           size_t len, uint32_t timeout_ms)
{
    (void)instance;
    (void)data;
    (void)len;
    (void)timeout_ms;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK SYN_Status syn_port_uart_receive(SYN_UARTInstance instance, uint8_t *data, size_t len,
                                          size_t *received, uint32_t timeout_ms)
{
    (void)instance;
    (void)data;
    (void)len;
    (void)received;
    (void)timeout_ms;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK SYN_Status syn_port_uart_transmit_byte(SYN_UARTInstance instance, uint8_t byte)
{
    (void)instance;
    (void)byte;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK SYN_Status syn_port_uart_receive_byte(SYN_UARTInstance instance, uint8_t *byte,
                                               uint32_t timeout_ms)
{
    (void)instance;
    (void)byte;
    (void)timeout_ms;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

/* ── System stubs ───────────────────────────────────────────────────────── */

SYN_WEAK void syn_port_enter_critical(void)
{
    syn_assert_failed(__FILE__, __LINE__);
}

SYN_WEAK void syn_port_exit_critical(void)
{
    syn_assert_failed(__FILE__, __LINE__);
}

SYN_WEAK uint32_t syn_port_get_tick_ms(void)
{
    syn_assert_failed(__FILE__, __LINE__);
    return 0;
}

SYN_WEAK uint32_t syn_port_get_tick_us(void)
{
    /* Default weak fallback: ms * 1000U */
    return syn_port_get_tick_ms() * 1000U;
}

SYN_WEAK void syn_port_delay_ms(uint32_t ms)
{
    (void)ms;
    syn_assert_failed(__FILE__, __LINE__);
}

SYN_WEAK SYN_NORETURN void syn_port_system_reset(void)
{
    syn_assert_failed(__FILE__, __LINE__);
    for (;;) {
    } /* satisfy noreturn */
}

/* ── I2C stubs ──────────────────────────────────────────────────────────── */

#include "../port/syn_port_i2c.h"

SYN_WEAK SYN_Status syn_port_i2c_init(uint8_t i2c_id, uint32_t clock_speed_hz, uint8_t role,
                                      uint16_t own_addr)
{
    (void)i2c_id;
    (void)clock_speed_hz;
    (void)role;
    (void)own_addr;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK SYN_Status syn_port_i2c_deinit(uint8_t i2c_id)
{
    (void)i2c_id;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK SYN_Status syn_port_i2c_transfer(uint8_t i2c_id, uint16_t addr, const uint8_t *tx,
                                          size_t tx_len, uint8_t *rx, size_t rx_len)
{
    (void)i2c_id;
    (void)addr;
    (void)tx;
    (void)tx_len;
    (void)rx;
    (void)rx_len;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

/* ── SPI stubs ──────────────────────────────────────────────────────────── */

#include "../port/syn_port_spi.h"

SYN_WEAK SYN_Status syn_port_spi_init(uint8_t spi_id, uint32_t baudrate_hz, uint8_t mode,
                                      uint8_t role)
{
    (void)spi_id;
    (void)baudrate_hz;
    (void)mode;
    (void)role;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK SYN_Status syn_port_spi_deinit(uint8_t spi_id)
{
    (void)spi_id;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK SYN_Status syn_port_spi_transfer(uint8_t spi_id, const uint8_t *tx, uint8_t *rx,
                                          size_t len)
{
    (void)spi_id;
    (void)tx;
    (void)rx;
    (void)len;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK SYN_Status syn_port_i2c_read(uint8_t bus, uint8_t addr, uint8_t *data, size_t len)
{
    (void)bus;
    (void)addr;
    (void)data;
    (void)len;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK SYN_Status syn_port_i2c_write_read(uint8_t bus, uint8_t addr, const uint8_t *tx_data,
                                            size_t tx_len, uint8_t *rx_data, size_t rx_len)
{
    (void)bus;
    (void)addr;
    (void)tx_data;
    (void)tx_len;
    (void)rx_data;
    (void)rx_len;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

/* ── Flash stubs ────────────────────────────────────────────────────────── */

#include "../port/syn_port_flash.h"

SYN_WEAK SYN_Status syn_port_flash_erase(uint32_t addr)
{
    (void)addr;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK SYN_Status syn_port_flash_read(uint32_t addr, void *buf, size_t len)
{
    (void)addr;
    (void)buf;
    (void)len;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK SYN_Status syn_port_flash_write(uint32_t addr, const void *buf, size_t len)
{
    (void)addr;
    (void)buf;
    (void)len;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK uint32_t syn_port_flash_sector_size(uint32_t addr)
{
    (void)addr;
    syn_assert_failed(__FILE__, __LINE__);
    return 0;
}

/* ── ADC stubs ──────────────────────────────────────────────────────────── */

#include "../port/syn_port_adc.h"

SYN_WEAK SYN_Status syn_port_adc_init(uint8_t adc_id, uint32_t channel_mask)
{
    (void)adc_id;
    (void)channel_mask;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK SYN_Status syn_port_adc_deinit(uint8_t adc_id)
{
    (void)adc_id;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK uint16_t syn_port_adc_read_channel(uint8_t adc_id, uint8_t channel)
{
    (void)adc_id;
    (void)channel;
    syn_assert_failed(__FILE__, __LINE__);
    return 0;
}

SYN_WEAK SYN_Status syn_port_adc_start_dma_scan(uint8_t adc_id, uint16_t *dest, size_t num_channels)
{
    (void)adc_id;
    (void)dest;
    (void)num_channels;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

/* ── PWM stubs ──────────────────────────────────────────────────────────── */

#include "../port/syn_port_pwm.h"

SYN_WEAK SYN_Status syn_port_pwm_init(uint8_t channel, uint32_t freq_hz)
{
    (void)channel;
    (void)freq_hz;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK void syn_port_pwm_set_duty(uint8_t channel, uint8_t duty_pct)
{
    (void)channel;
    (void)duty_pct;
    syn_assert_failed(__FILE__, __LINE__);
}

SYN_WEAK void syn_port_pwm_set_duty_raw(uint8_t channel, uint16_t duty_u16)
{
    (void)channel;
    (void)duty_u16;
    syn_assert_failed(__FILE__, __LINE__);
}

SYN_WEAK void syn_port_pwm_enable(uint8_t channel, bool enable)
{
    (void)channel;
    (void)enable;
    syn_assert_failed(__FILE__, __LINE__);
}

SYN_WEAK void syn_port_pwm_set_freq(uint8_t channel, uint32_t freq_hz)
{
    (void)channel;
    (void)freq_hz;
    syn_assert_failed(__FILE__, __LINE__);
}

/* ── Sleep stub ─────────────────────────────────────────────────────────── */

#include "../system/syn_sleep.h"

SYN_WEAK void syn_port_sleep(SYN_SleepMode mode)
{
    (void)mode;
    /* Default: no-op (busy wait) */
}

SYN_WEAK void syn_port_sleep_until(uint32_t wake_tick_ms)
{
    (void)wake_tick_ms;
    /* Default: fall back to light sleep */
    syn_port_sleep(SYN_SLEEP_LIGHT);
}

/* ── EXTI stubs ─────────────────────────────────────────────────────────── */

#include "../port/syn_port_exti.h"

SYN_WEAK SYN_Status syn_port_exti_configure(SYN_GPIO_Pin pin, SYN_EXTI_Edge edge)
{
    (void)pin;
    (void)edge;
    return SYN_OK;
}

SYN_WEAK void syn_port_exti_enable(SYN_GPIO_Pin pin)
{
    (void)pin;
}

SYN_WEAK void syn_port_exti_disable(SYN_GPIO_Pin pin)
{
    (void)pin;
}

SYN_WEAK void syn_port_exti_clear_pending(SYN_GPIO_Pin pin)
{
    (void)pin;
}

/* ── CAN stubs ──────────────────────────────────────────────────────────── */

#include "../port/syn_port_can.h"

SYN_WEAK bool syn_port_can_init(uint8_t port, uint32_t bitrate)
{
    (void)port;
    (void)bitrate;
    return true;
}

SYN_WEAK bool syn_port_can_send(uint8_t port, uint32_t id, bool extended, const uint8_t *data,
                                uint8_t dlc)
{
    (void)port;
    (void)id;
    (void)extended;
    (void)data;
    (void)dlc;
    return true;
}

SYN_WEAK bool syn_port_can_receive(uint8_t port, uint32_t *id, bool *extended, uint8_t *data,
                                   uint8_t *dlc)
{
    (void)port;
    (void)id;
    (void)extended;
    (void)data;
    (void)dlc;
    return false; /* no frame available */
}

SYN_WEAK void syn_port_can_set_filter(uint8_t port, uint32_t id, uint32_t mask)
{
    (void)port;
    (void)id;
    (void)mask;
}

/* ── DMA stubs ──────────────────────────────────────────────────────────── */

#include "../port/syn_port_dma.h"

#if defined(SYN_USE_DMA) && SYN_USE_DMA

SYN_WEAK SYN_Status syn_port_dma_start(const SYN_PortDmaTransfer *xfer)
{
    (void)xfer;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK SYN_Status syn_port_dma_stop(uint8_t channel_id)
{
    (void)channel_id;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK bool syn_port_dma_is_busy(uint8_t channel_id)
{
    (void)channel_id;
    syn_assert_failed(__FILE__, __LINE__);
    return false;
}

SYN_WEAK uint32_t syn_port_dma_get_counter(uint8_t channel_id)
{
    (void)channel_id;
    syn_assert_failed(__FILE__, __LINE__);
    return 0;
}

#endif /* SYN_USE_DMA */

/* ── Async I2C stubs ────────────────────────────────────────────────────── */

#include "../port/syn_port_i2c_async.h"

#if defined(SYN_USE_I2C_ASYNC) && SYN_USE_I2C_ASYNC

SYN_WEAK SYN_Status syn_port_i2c_xfer_async(const SYN_I2C_Xfer *xfer)
{
    (void)xfer;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK SYN_Status syn_port_i2c_cancel(uint8_t bus)
{
    (void)bus;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

#endif /* SYN_USE_I2C_ASYNC */

/* ── Async SPI stubs ────────────────────────────────────────────────────── */

#include "../port/syn_port_spi_async.h"

#if defined(SYN_USE_SPI_ASYNC) && SYN_USE_SPI_ASYNC

SYN_WEAK SYN_Status syn_port_spi_xfer_async(const SYN_SPI_Xfer *xfer)
{
    (void)xfer;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK SYN_Status syn_port_spi_cancel(uint8_t bus)
{
    (void)bus;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

#endif /* SYN_USE_SPI_ASYNC */

/* ── Multicore stubs ───────────────────────────────────────────────────── */

#include "../common/syn_barrier.h"

#if defined(SYN_USE_MULTICORE) && SYN_USE_MULTICORE

#include "../port/syn_port_spinlock.h"

SYN_WEAK void syn_port_memory_barrier(void)
{
    /* Fallback: compiler barrier only. Safe on single-core, but a real
     * multicore port MUST override this with a hardware fence. */
    SYN_COMPILER_BARRIER();
}

SYN_WEAK void syn_port_spinlock_acquire(uint8_t id)
{
    (void)id;
    syn_assert_failed(__FILE__, __LINE__);
}

SYN_WEAK void syn_port_spinlock_release(uint8_t id)
{
    (void)id;
    syn_assert_failed(__FILE__, __LINE__);
}

SYN_WEAK bool syn_port_spinlock_try_acquire(uint8_t id)
{
    (void)id;
    syn_assert_failed(__FILE__, __LINE__);
    return false;
}

SYN_WEAK uint8_t syn_port_core_id(void)
{
    return 0;
}

SYN_WEAK void syn_port_ipc_notify(void)
{
    /* No-op: consumer core polls at next scheduler tick. */
}

#else  /* !SYN_USE_MULTICORE */

/* Memory barrier stub when multicore is off — never actually called
 * because syn_barrier.h inlines plain volatile access, but some
 * toolchains may still emit a reference. */
SYN_WEAK void syn_port_memory_barrier(void)
{
    SYN_COMPILER_BARRIER();
}
#endif /* SYN_USE_MULTICORE */

/* ── Socket stubs ───────────────────────────────────────────────────────── */

#include "../port/syn_port_socket.h"

SYN_WEAK SYN_Socket syn_port_udp_open(uint16_t port)
{
    (void)port;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_SOCKET_INVALID;
}

SYN_WEAK int syn_port_udp_sendto(SYN_Socket sock, const void *data, size_t len,
                                 const SYN_SockAddr *to)
{
    (void)sock;
    (void)data;
    (void)len;
    (void)to;
    syn_assert_failed(__FILE__, __LINE__);
    return -1;
}

SYN_WEAK int syn_port_udp_recvfrom(SYN_Socket sock, void *buf, size_t max_len, SYN_SockAddr *from,
                                   uint32_t timeout_ms)
{
    (void)sock;
    (void)buf;
    (void)max_len;
    (void)from;
    (void)timeout_ms;
    syn_assert_failed(__FILE__, __LINE__);
    return -1;
}

SYN_WEAK SYN_Status syn_port_udp_join_multicast(SYN_Socket sock, const char *multicast_ip)
{
    (void)sock;
    (void)multicast_ip;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK void syn_port_sock_close(SYN_Socket sock)
{
    (void)sock;
    syn_assert_failed(__FILE__, __LINE__);
}

SYN_WEAK SYN_Socket syn_port_sock_connect(const SYN_SockAddr *addr)
{
    (void)addr;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_SOCKET_INVALID;
}

SYN_WEAK SYN_Socket syn_port_sock_connect_host(const char *host, uint16_t port)
{
    (void)host;
    (void)port;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_SOCKET_INVALID;
}

SYN_WEAK int syn_port_sock_send(SYN_Socket sock, const void *data, size_t len)
{
    (void)sock;
    (void)data;
    (void)len;
    syn_assert_failed(__FILE__, __LINE__);
    return -1;
}

SYN_WEAK int syn_port_sock_send_all(SYN_Socket sock, const void *data, size_t len)
{
    (void)sock;
    (void)data;
    (void)len;
    syn_assert_failed(__FILE__, __LINE__);
    return -1;
}

SYN_WEAK int syn_port_sock_recv(SYN_Socket sock, void *buf, size_t max_len, uint32_t timeout_ms)
{
    (void)sock;
    (void)buf;
    (void)max_len;
    (void)timeout_ms;
    syn_assert_failed(__FILE__, __LINE__);
    return -1;
}

SYN_WEAK SYN_Socket syn_port_sock_listen(uint16_t port, int backlog)
{
    (void)port;
    (void)backlog;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_SOCKET_INVALID;
}

SYN_WEAK SYN_Socket syn_port_sock_accept(SYN_Socket listener, uint32_t timeout_ms)
{
    (void)listener;
    (void)timeout_ms;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_SOCKET_INVALID;
}

/* ── Console serial stubs ───────────────────────────────────────────────── */

#include "../port/syn_port_serial.h"

SYN_WEAK SYN_Status syn_port_serial_init(uint32_t baudrate)
{
    (void)baudrate;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK int syn_port_serial_write(const uint8_t *data, size_t len)
{
    (void)data;
    (void)len;
    syn_assert_failed(__FILE__, __LINE__);
    return -1;
}

SYN_WEAK int syn_port_serial_read(uint8_t *buf, size_t max_len)
{
    (void)buf;
    (void)max_len;
    syn_assert_failed(__FILE__, __LINE__);
    return -1;
}

/* ── HPClock stubs ─────────────────────────────────────────────────────── */

SYN_WEAK volatile uint32_t *syn_port_hpclock_lsb_ptr(void)
{
    syn_assert_failed(__FILE__, __LINE__);
    return (volatile uint32_t *)0; /* unreachable */
}

SYN_WEAK uint32_t syn_port_hpclock_freq_hz(void)
{
    syn_assert_failed(__FILE__, __LINE__);
    return 0; /* unreachable */
}

/* ── BLE HCI stubs ──────────────────────────────────────────────────────── */

SYN_WEAK SYN_Status syn_port_ble_hci_tx(const uint8_t *data, uint16_t len)
{
    (void)data;
    (void)len;
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK SYN_Status syn_port_ble_hci_reset(void)
{
    syn_assert_failed(__FILE__, __LINE__);
    return SYN_NOT_IMPLEMENTED;
}

/* ── AES / Crypto Accelerator stubs ─────────────────────────────────────── */

SYN_WEAK SYN_Status syn_port_aes_init(void)
{
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK SYN_Status syn_port_aes_encrypt_block(const uint8_t *round_keys, uint8_t nr,
                                               const uint8_t in[16], uint8_t out[16])
{
    (void)round_keys;
    (void)nr;
    (void)in;
    (void)out;
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK SYN_Status syn_port_aes_decrypt_block(const uint8_t *round_keys, uint8_t nr,
                                               const uint8_t in[16], uint8_t out[16])
{
    (void)round_keys;
    (void)nr;
    (void)in;
    (void)out;
    return SYN_NOT_IMPLEMENTED;
}

SYN_WEAK SYN_Status syn_port_ghash_mult(const uint8_t x[16], const uint8_t h[16], uint8_t out[16])
{
    (void)x;
    (void)h;
    (void)out;
    return SYN_NOT_IMPLEMENTED;
}