writeImpl()

WriteResult fl::spi::MultiLaneDevice::writeImpl ( fl::span< const fl::span< const u8 > > lane_data )

private

Internal implementation - write all lanes atomically.

Parameters

lane_data

Span of spans containing lane data

Note

Waits for previous transmission, writes all lanes, then flushes

Returns

WriteResult with ok=true on success, or ok=false with error message

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

                                                                               {
    if (!isReady()) {
        FL_WARN("MultiLaneDevice: Not ready for write");
        return WriteResult("Device not ready");
    }
 
    if (lane_data.size() > pImpl->lanes.size()) {
        FL_WARN("MultiLaneDevice: Too many lanes provided (" << lane_data.size()
                << " > " << pImpl->lanes.size() << ")");
        return WriteResult("Too many lanes provided");
    }
 
    // Validate that all lanes have the same size (required for reliable transposition)
    if (lane_data.size() > 1) {
        size_t first_size = lane_data[0].size();
        for (size_t i = 1; i < lane_data.size(); i++) {
            if (lane_data[i].size() != first_size) {
                FL_WARN("MultiLaneDevice: Lane size mismatch - lane 0 has " << first_size
                        << " bytes, lane " << i << " has " << lane_data[i].size() << " bytes");
                return WriteResult("Lane size mismatch: all lanes must have identical sizes");
            }
        }
    }
 
    // Wait for previous transmission to complete
    waitComplete();
 
    // Write all lane data (can be optimized later with batch operations)
    for (size_t i = 0; i < lane_data.size(); i++) {
        pImpl->lanes[i].write(lane_data[i].data(), lane_data[i].size());
    }
 
    // Start hardware transmission (async)
    auto flush_result = flush();
    if (!flush_result.ok()) {
        FL_WARN("MultiLaneDevice: Flush failed");
        return WriteResult("Flush failed");
    }
 
    FL_DBG("MultiLaneDevice: Wrote " << lane_data.size() << " lanes atomically (async)");
 
    // Return success - use device->wait() to block until complete
    return WriteResult();
}

References FL_DBG, FL_WARN, flush(), isReady(), pImpl, and waitComplete().

Referenced by write().

Here is the call graph for this function:

Here is the caller graph for this function: