flush()

Result< void > fl::spi::MultiLaneDevice::flush

(

)

Flush all lanes (transpose and transmit)

Returns

Result indicating success or error (Result<void>)

Note

Transposes all lane buffers and transmits via hardware DMA

Clears all lane buffers after transmission starts

All non-empty lanes MUST have identical sizes - operation fails with error if sizes differ

Zero-padding is NOT performed - size validation prevents unreliable chipset-specific padding issues

Transaction API not yet implemented - call waitComplete() manually after flush()

Definition at line 301 of file multi_lane_device.cpp.hpp.

                                    {
    if (!isReady()) {
        return Result<void>::failure(SPIError::NOT_INITIALIZED,
            "Device not initialized");
    }
 
    // Find lane sizes and validate all non-empty lanes have the same size
    size_t expected_size = 0;
    bool found_first = false;
 
    for (size_t i = 0; i < pImpl->lanes.size(); i++) {
        size_t lane_size = pImpl->lanes[i].bufferSize();
 
        if (lane_size > 0) {
            if (!found_first) {
                // First non-empty lane sets the expected size
                expected_size = lane_size;
                found_first = true;
            } else if (lane_size != expected_size) {
                // Size mismatch detected
                FL_WARN("MultiLaneDevice: Lane size mismatch - expected " << expected_size
                        << " bytes (lane 0), but lane " << i << " has " << lane_size << " bytes");
                return Result<void>::failure(SPIError::INVALID_PARAMETER,
                    "Lane size mismatch: all lanes must have identical sizes");
            }
        }
    }
 
    if (expected_size == 0) {
        FL_WARN("MultiLaneDevice: No data to flush (all lanes empty)");
        return Result<void>::failure(SPIError::ALLOCATION_FAILED,
            "No data to transmit");
    }
 
    // Use expected_size for DMA buffer allocation (all lanes now guaranteed same size)
    size_t max_size = expected_size;
 
    // Acquire DMA buffer from hardware backend - use polymorphic interface
    DMABuffer dma_buffer = pImpl->backend->acquireDMABuffer(max_size);
 
    if (!dma_buffer.ok()) {
        FL_WARN("MultiLaneDevice: Failed to acquire DMA buffer");
        return Result<void>::failure(dma_buffer.error(),
            "Failed to acquire DMA buffer");
    }
 
    // Transpose lanes into DMA buffer (or copy for single lane)
    const char* error = nullptr;
    bool transpose_ok = false;
 
    if (pImpl->backend_type == 1) {
        // Single lane - no transposition needed, just copy data directly
        if (pImpl->lanes.size() > 0) {
            fl::span<const u8> lane_data = pImpl->lanes[0].data();
            fl::span<u8> dma_data = dma_buffer.data();
 
            // Verify sizes match (DMA buffer should be exactly the size we requested)
            if (lane_data.size() != dma_data.size()) {
                FL_WARN("MultiLaneDevice: DMA buffer size mismatch - expected " << lane_data.size()
                        << " bytes, got " << dma_data.size() << " bytes");
                error = "DMA buffer size mismatch";
                transpose_ok = false;
            } else {
                // Copy lane data to DMA buffer
                for (size_t i = 0; i < lane_data.size(); i++) {
                    dma_data[i] = lane_data[i];
                }
                transpose_ok = true;
            }
        } else {
            error = "No lanes configured";
            transpose_ok = false;
        }
 
    } else if (pImpl->backend_type == 2) {
        // Dual-SPI transposition
        fl::optional<SPITransposer::LaneData> lane0, lane1;
        if (pImpl->lanes.size() > 0) {
            lane0 = SPITransposer::LaneData{
                pImpl->lanes[0].data(),
                fl::span<const u8>()  // No padding
            };
        }
        if (pImpl->lanes.size() > 1) {
            lane1 = SPITransposer::LaneData{
                pImpl->lanes[1].data(),
                fl::span<const u8>()  // No padding
            };
        }
 
        transpose_ok = SPITransposer::transpose2(lane0, lane1, dma_buffer.data(), &error);
 
    } else if (pImpl->backend_type == 4) {
        // Quad-SPI transposition
        fl::optional<SPITransposer::LaneData> lanes[4];
        for (size_t i = 0; i < pImpl->lanes.size() && i < 4; i++) {
            lanes[i] = SPITransposer::LaneData{
                pImpl->lanes[i].data(),
                fl::span<const u8>()  // No padding
            };
        }
 
        transpose_ok = SPITransposer::transpose4(lanes[0], lanes[1], lanes[2], lanes[3],
                                                  dma_buffer.data(), &error);
 
    } else if (pImpl->backend_type == 8) {
        // Octal-SPI transposition
        fl::optional<SPITransposer::LaneData> lanes[8];
        for (size_t i = 0; i < pImpl->lanes.size() && i < 8; i++) {
            lanes[i] = SPITransposer::LaneData{
                pImpl->lanes[i].data(),
                fl::span<const u8>()  // No padding
            };
        }
 
        transpose_ok = SPITransposer::transpose8(lanes, dma_buffer.data(), &error);
    }
 
    if (!transpose_ok) {
        FL_WARN("MultiLaneDevice: Transposition failed - " << (error ? error : "unknown error"));
        return Result<void>::failure(SPIError::ALLOCATION_FAILED,
            error ? error : "Transposition failed");
    }
 
    // Transmit via hardware backend - use polymorphic interface
    bool transmit_ok = pImpl->backend->transmit(TransmitMode::ASYNC);
 
    if (!transmit_ok) {
        FL_WARN("MultiLaneDevice: Hardware transmit failed");
        return Result<void>::failure(SPIError::BUSY,
            "Hardware transmit failed");
    }
 
    // Clear lane buffers after starting transmission
    for (auto& lane : pImpl->lanes) {
        lane.clear();
    }
 
    FL_DBG("MultiLaneDevice: Flushed " << pImpl->lanes.size() << " lanes ("
           << max_size << " bytes per lane)");
 
    // Success - transmission started asynchronously
    // User must call waitComplete() manually to block until transmission completes
    return Result<void>::success();
}

References fl::span< T, Extent >::data(), fl::expected< T, E >::failure(), FL_DBG, FL_WARN, isReady(), lane(), pImpl, fl::span< T, Extent >::size(), fl::expected< T, E >::success(), fl::SPITransposer::transpose2(), fl::SPITransposer::transpose4(), and fl::SPITransposer::transpose8().

Referenced by operator=(), and writeImpl().

Here is the call graph for this function:

Here is the caller graph for this function: