cdc.c

Go to the documentation of this file.

 
#include "bsp/cdc.h"
 
#include <string.h>
 
#ifndef HOST_TEST
 
#include "usbd_cdc_if.h"
#include "icarus/icarus.h"   /* task_active_sleep */
 
bool CDC_Write(const uint8_t *data, uint16_t len) {
    if (len == 0u) {
        return true;
    }
    if (data == NULL) {
        return false;
    }
 
    /* CDC_Transmit_FS takes a non-const buffer; it does not modify the
     * payload but its prototype is loose. Casting away const here is
     * safe — we own the call site contract. */
    uint8_t *buf = (uint8_t *)(uintptr_t)data;
 
    uint8_t  result  = CDC_Transmit_FS(buf, len);
    uint16_t retries = 0u;
    while (result == USBD_BUSY && retries < CDC_WRITE_MAX_RETRIES) {
        task_active_sleep(1u);
        result = CDC_Transmit_FS(buf, len);
        retries++;
    }
    return (result == USBD_OK);
}
 
#else /* HOST_TEST — in-memory sink */
 
#define CDC_HOST_SINK_SIZE  256u
 
static uint8_t  g_cdc_sink[CDC_HOST_SINK_SIZE];
static uint16_t g_cdc_sink_len;
static uint32_t g_cdc_call_count;
static bool     g_cdc_force_fail;
 
bool CDC_Write(const uint8_t *data, uint16_t len) {
    g_cdc_call_count++;
    if (g_cdc_force_fail) {
        return false;
    }
    if (len == 0u) {
        return true;
    }
    if (data == NULL) {
        return false;
    }
    uint16_t write_len = len;
    if (write_len > (uint16_t)CDC_HOST_SINK_SIZE) {
        write_len = (uint16_t)CDC_HOST_SINK_SIZE;
    }
    (void)memcpy(g_cdc_sink, data, write_len);
    g_cdc_sink_len = write_len;
    return true;
}
 
/* ---- Test-only host hooks ---------------------------------------------- */
 
const uint8_t *__cdc_host_sink(void) {
    return g_cdc_sink;
}
 
uint16_t __cdc_host_sink_len(void) {
    return g_cdc_sink_len;
}
 
uint32_t __cdc_host_call_count(void) {
    return g_cdc_call_count;
}
 
void __cdc_host_set_fail(bool fail) {
    g_cdc_force_fail = fail;
}
 
void __cdc_host_reset_state(void) {
    (void)memset(g_cdc_sink, 0, sizeof(g_cdc_sink));
    g_cdc_sink_len   = 0u;
    g_cdc_call_count = 0u;
    g_cdc_force_fail = false;
}
 
#endif /* HOST_TEST */
 
bool CDC_WriteString(const char *s) {
    if (s == NULL) {
        return true;
    }
    return CDC_Write((const uint8_t *)s, (uint16_t)strlen(s));
}