multi_lane_device.h

Go to the documentation of this file.

#pragma once

 
#include "fl/stl/stdint.h"
#include "fl/stl/vector.h"
#include "fl/stl/unique_ptr.h"
#include "fl/stl/optional.h"
#include "fl/task/promise.h"  // for fl::task::Error
#include "fl/channels/spi/config.h"
#include "fl/channels/spi/transaction.h"
#include "fl/channels/spi/write_result.h"
// IWYU pragma: begin_keep
#include "platforms/shared/spi_types.h"  // ok platform headers
#include "fl/stl/noexcept.h"
// IWYU pragma: end_keep  // ok platform headers
 
namespace fl {
namespace spi {
 
// ============================================================================
// MultiLaneDevice - 1-8 independent data streams (HW transposed)
// ============================================================================

class MultiLaneDevice {
public:
    struct Config {
        u8 clock_pin;              
        fl::vector<u8> data_pins;  
        u32 clock_speed_hz;        
        u8 mode;                   
 
        Config() FL_NOEXCEPT : clock_pin(0xFF), clock_speed_hz(0xffffffff), mode(0) {}
    };

    explicit MultiLaneDevice(const Config& config);

    ~MultiLaneDevice() FL_NOEXCEPT;
 
    // Disable copy/move
    MultiLaneDevice(const MultiLaneDevice&) FL_NOEXCEPT = delete;
    MultiLaneDevice& operator=(const MultiLaneDevice&) FL_NOEXCEPT = delete;
    MultiLaneDevice(MultiLaneDevice&&) FL_NOEXCEPT = delete;
    MultiLaneDevice& operator=(MultiLaneDevice&&) FL_NOEXCEPT = delete;
 
    // ========== Initialization ==========

    fl::optional<fl::task::Error> begin();

    void end();

    bool isReady() const;
 
    // ========== Lane Access ==========

    Lane& lane(size_t lane_id);

    size_t numLanes() const;
 
    // ========== Transmission ==========

    Result<void> flush();

    bool waitComplete(u32 timeout_ms = (fl::numeric_limits<u32>::max)());

    bool wait() { return waitComplete(); }

    bool isBusy() const;
 
    // ========== High-Level Write API ==========
    // This method provides a simple, type-safe way to write to multiple lanes
    // simultaneously. Each lane can have a different buffer size.
    //
    // Usage: auto result = spi->write(lane0, lane1, lane2, lane3);
    //
    // Accepts fl::span<const uint8_t> or any type convertible to it (arrays, vectors, etc.)
    //
    // This method automatically:
    // 1. Waits for any previous transmission to complete (waitComplete)
    // 2. Writes all lane data atomically (single call to writeImpl)
    // 3. Flushes to start the transmission **asynchronously**
    //
    // Transmission happens in the background. Call wait() to block until complete.

    template<typename... Spans>
    WriteResult write(Spans&&... lanes) {
        // Unpack variadic template into stack-allocated FixedVector
        fl::span<const u8> lane_spans[] = {fl::forward<Spans>(lanes)...};
        fl::FixedVector<fl::span<const u8>, MAX_SPI_LANES> lane_vec;
 
        // Copy spans into vector
        for (size_t i = 0; i < sizeof...(lanes); i++) {
            lane_vec.push_back(lane_spans[i]);
        }
 
        // Single atomic write operation
        return writeImpl(lane_vec);
    }
 
    // ========== Configuration ==========

    const Config& getConfig() const;
 
private:
    WriteResult writeImpl(fl::span<const fl::span<const u8>> lane_data);
 
    struct Impl;
    fl::unique_ptr<Impl> pImpl;
};
 
} // namespace spi
} // namespace fl