feat(sbp2): add session registry and command flow

ASFWDriver/ASFWDriver.cpp

@@ -35,8 +35,6 @@
 #include "Async/AsyncSubsystem.hpp"
 #include "Async/DMAMemoryImpl.hpp"
 #include "Async/Interfaces/IFireWireBus.hpp"
-#include "Async/PacketHelpers.hpp"
-#include "Async/ResponseCode.hpp"
 #include "Audio/AudioCoordinator.hpp"
 #include "Bus/SelfIDCapture.hpp"
 #include "Common/DriverKitOwnership.hpp"
@@ -224,32 +222,6 @@ kern_return_t IMPL(ASFWDriver, Start) {
         ASFW_LOG(Controller, "✅ FCPResponseRouter initialized");
     }
 
-    if (ctx.deps.fcpResponseRouter && ctx.deps.asyncSubsystem) {
-        if (auto* router = ctx.deps.asyncSubsystem->GetPacketRouter()) {
-            router->RegisterRequestHandler(
-                0x1, // tCode for Block Write Request
-                [fcpRouter =
-                     ctx.deps.fcpResponseRouter.get()](const ASFW::Async::ARPacketView& packet) {
-                    if (fcpRouter) {
-                        const ASFW::Protocols::Ports::BlockWriteRequestView request{
-                            .sourceID = packet.sourceID,
-                            .destOffset = ASFW::Async::ExtractDestOffset(packet.header),
-                            .payload = packet.payload,
-                        };
-
-                        const auto disposition = fcpRouter->RouteBlockWrite(request);
-                        if (disposition ==
-                            ASFW::Protocols::Ports::BlockWriteDisposition::kAddressError) {
-                            return ASFW::Async::ResponseCode::AddressError;
-                        }
-                        return ASFW::Async::ResponseCode::Complete;
-                    }
-                    return ASFW::Async::ResponseCode::NoResponse;
-                });
-            ASFW_LOG(Controller, "✅ FCPResponseRouter wired to PacketRouter (tCode 0x1)");
-        }
-    }
-
     DriverWiring::EnsureSbp2Deps(ctx);
 
     if (ctx.deps.speedPolicy) {

ASFWDriver/Async/AsyncSubsystemInterrupts.cpp

@@ -2,6 +2,7 @@
 
 #include "Contexts/ATRequestContext.hpp"
 #include "Contexts/ATResponseContext.hpp"
+#include "Tx/ResponseSender.hpp"
 
 #include "../Logging/Logging.hpp"
 #include "../Shared/Memory/DMAMemoryManager.hpp"
@@ -22,6 +23,9 @@ uint32_t AsyncSubsystem::DrainTxCompletions(const char* reason) {
             return;
         }
         while (auto completion = ctx->ScanCompletion()) {
+            if (completion->isResponseContext && responseSender_) {
+                responseSender_->OnTxCompletion(*completion);
+            }
             tracking_->OnTxCompletion(*completion);
             ++drained;
         }

ASFWDriver/Async/AsyncSubsystemLifecycle.cpp

@@ -563,7 +563,10 @@ void AsyncSubsystem::Teardown(bool disableHardware) {
         txnMgr_.reset();
     }
 
-    responseSender_.reset();
+    if (responseSender_) {
+        responseSender_->ClearOutstandingResponses();
+        responseSender_.reset();
+    }
     descriptorBuilder_ = nullptr;
     descriptorBuilderResponse_ = nullptr;
     packetBuilder_.reset();

ASFWDriver/Async/Tx/ResponseSender.cpp

@@ -2,6 +2,7 @@
 
 #include "../Engine/ContextManager.hpp"
 #include "../Contexts/ATResponseContext.hpp"
+#include "../Track/TxCompletion.hpp"
 #include "../Tx/DescriptorBuilder.hpp"
 #include "../Tx/Submitter.hpp"
 #include "../../Bus/GenerationTracker.hpp"
@@ -50,7 +51,8 @@ void ResponseSender::SendResponse(const ARPacketView& request,
                                   const uint32_t* header,
                                   std::size_t headerBytes,
                                   uint64_t payloadDeviceAddress,
-                                  std::size_t payloadLength) noexcept {
+                                  std::size_t payloadLength,
+                                  std::shared_ptr<void> payloadLease) noexcept {
     // Per IEEE 1394, broadcast requests (destID=0xFFFF) do not get responses.
     if (request.destID == 0xFFFF) {
         ASFW_LOG_V3(Async, "ResponseSender: skip response for broadcast destID=0xFFFF");
@@ -78,8 +80,16 @@ void ResponseSender::SendResponse(const ARPacketView& request,
         return;
     }
 
+    const auto* leaseKey = chain.last;
+    if (payloadLease && leaseKey) {
+        responsePayloadLeases_[leaseKey] = std::move(payloadLease);
+    }
+
     const auto submitRes = submitter_.submit_tx_chain(atRspCtx, std::move(chain));
     if (submitRes.kr != kIOReturnSuccess) {
+        if (leaseKey) {
+            responsePayloadLeases_.erase(leaseKey);
+        }
         ASFW_LOG_ERROR(
             Async,
             "ResponseSender: submit_tx_chain failed (tCode=0x%x kr=0x%x)",
@@ -147,7 +157,8 @@ void ResponseSender::SendReadQuadletResponse(const ARPacketView& request,
 void ResponseSender::SendReadBlockResponse(const ARPacketView& request,
                                            ResponseCode rcode,
                                            uint64_t payloadDeviceAddress,
-                                           uint32_t payloadLength) noexcept {
+                                           uint32_t payloadLength,
+                                           std::shared_ptr<void> payloadLease) noexcept {
     if (request.tCode != 0x5) {
         ASFW_LOG_V3(Async,
                     "ResponseSender: skip RdBlockResp for non-read-block tCode=0x%x",
@@ -177,7 +188,19 @@ void ResponseSender::SendReadBlockResponse(const ARPacketView& request,
                  header,
                  sizeof(header),
                  responsePayloadAddress,
-                 responsePayloadLen);
+                 responsePayloadLen,
+                 std::move(payloadLease));
+}
+
+void ResponseSender::OnTxCompletion(const TxCompletion& completion) noexcept {
+    if (!completion.isResponseContext || !completion.descriptor) {
+        return;
+    }
+    responsePayloadLeases_.erase(completion.descriptor);
+}
+
+void ResponseSender::ClearOutstandingResponses() noexcept {
+    responsePayloadLeases_.clear();
 }
 
 } // namespace ASFW::Async

ASFWDriver/Async/Tx/ResponseSender.hpp

@@ -2,6 +2,8 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <memory>
+#include <unordered_map>
 
 #include "../ResponseCode.hpp"
 #include "../Rx/PacketRouter.hpp"
@@ -11,9 +13,11 @@ namespace ASFW::Async {
 class DescriptorBuilder;
 class ATResponseContext;
 class IFireWireBusInfo;
+struct TxCompletion;
 namespace Bus { class GenerationTracker; }
 namespace Engine { class ContextManager; }
 namespace Tx { class Submitter; }
+namespace HW { struct OHCIDescriptor; }
 
 /// Utility to build and send Write Response (WrResp) packets for incoming AR requests.
 class ResponseSender {
@@ -36,7 +40,14 @@ class ResponseSender {
     void SendReadBlockResponse(const ARPacketView& request,
                                ResponseCode rcode,
                                uint64_t payloadDeviceAddress,
-                               uint32_t payloadLength) noexcept;
+                               uint32_t payloadLength,
+                               std::shared_ptr<void> payloadLease = {}) noexcept;
+
+    /// Release response payload leases after AT response descriptor completion.
+    void OnTxCompletion(const TxCompletion& completion) noexcept;
+
+    /// Drop any retained response payload leases during response subsystem teardown.
+    void ClearOutstandingResponses() noexcept;
 
 private:
     void SendResponse(const ARPacketView& request,
@@ -45,12 +56,14 @@ class ResponseSender {
                       const uint32_t* header,
                       std::size_t headerBytes,
                       uint64_t payloadDeviceAddress,
-                      std::size_t payloadLength) noexcept;
+                      std::size_t payloadLength,
+                      std::shared_ptr<void> payloadLease = {}) noexcept;
 
     DescriptorBuilder& builder_;
     Tx::Submitter& submitter_;
     Engine::ContextManager& ctxMgr_;
     Bus::GenerationTracker& generationTracker_;
+    std::unordered_map<const HW::OHCIDescriptor*, std::shared_ptr<void>> responsePayloadLeases_;
 };
 
 } // namespace ASFW::Async

ASFWDriver/Controller/ControllerCore.hpp

@@ -57,6 +57,7 @@ class FCPResponseRouter;
 
 namespace ASFW::Protocols::SBP2 {
 class AddressSpaceManager;
+class SBP2SessionRegistry;
 }
 
 namespace ASFW::IRM {
@@ -96,6 +97,7 @@ class ControllerCore {
         std::shared_ptr<ASFW::Protocols::AVC::AVCDiscovery> avcDiscovery;
         std::shared_ptr<ASFW::Protocols::AVC::FCPResponseRouter> fcpResponseRouter;
         std::shared_ptr<ASFW::Protocols::SBP2::AddressSpaceManager> sbp2AddressSpaceManager;
+        std::shared_ptr<ASFW::Protocols::SBP2::SBP2SessionRegistry> sbp2SessionRegistry;
 
         std::shared_ptr<ASFW::IRM::IRMClient> irmClient;
 
@@ -137,9 +139,13 @@ class ControllerCore {
     Protocols::AVC::IAVCDiscovery* GetAVCDiscovery() const;
     void SetAVCDiscovery(std::shared_ptr<Protocols::AVC::AVCDiscovery> avcDiscovery);
     void SetFCPResponseRouter(std::shared_ptr<Protocols::AVC::FCPResponseRouter> fcpResponseRouter);
+
     Protocols::SBP2::AddressSpaceManager* GetSbp2AddressSpaceManager() const;
+    Protocols::SBP2::SBP2SessionRegistry* GetSBP2SessionRegistry() const;
     void SetSbp2AddressSpaceManager(
         std::shared_ptr<Protocols::SBP2::AddressSpaceManager> sbp2AddressSpaceManager);
+    void SetSBP2SessionRegistry(
+        std::shared_ptr<Protocols::SBP2::SBP2SessionRegistry> sbp2SessionRegistry);
 
     IRM::IRMClient* GetIRMClient() const;
     void SetIRMClient(std::shared_ptr<IRM::IRMClient> client);

ASFWDriver/Controller/ControllerCoreDiscovery.cpp

@@ -30,6 +30,7 @@
 #include "../Protocols/AVC/AVCDiscovery.hpp"
 #include "../Protocols/AVC/CMP/CMPClient.hpp"
 #include "../Protocols/Audio/DeviceProtocolFactory.hpp"
+#include "../Protocols/SBP2/SBP2SessionRegistry.hpp"
 #include "../Scheduling/Scheduler.hpp"
 #include "../Version/DriverVersion.hpp"
 #include "ControllerStateMachine.hpp"
@@ -116,6 +117,18 @@ void ControllerCore::OnTopologyReady(const TopologySnapshot& snap) {
         // CMP (PCR) operations target a *specific device's* plug registers, not the IRM node.
         // Device-scoped CMP wiring is done at stream start time (IsochService).
     }
+
+    if (deps_.sbp2SessionRegistry) {
+        deps_.sbp2SessionRegistry->OnBusReset(static_cast<uint16_t>(snap.generation));
+    }
+
+    // NOTE: CSR STATE_SET CMSTR write removed. Apple IOFireWireFamily does NOT write
+    // CSR STATE_SET via async transactions — it uses the OHCI LinkControl register
+    // directly (kCycleMaster bit), which ASFWDriver already sets in kDefaultLinkControl
+    // during controller initialization. Async loopback to the local node does not work
+    // in ASFWDriver (always returns timeout), so the previous implementation was a no-op.
+    // OHCI hardware generates cycle-start packets automatically when the node is root
+    // and kCycleMaster is set in LinkControl.
 }
 
 // NOLINTNEXTLINE(readability-function-cognitive-complexity)
@@ -218,14 +231,22 @@ void ControllerCore::OnDiscoveryScanComplete(Discovery::Generation gen,
     } else if (deps_.deviceManager && zeroRomScanInconclusive) {
         ASFW_LOG(Discovery,
                  "ROM scan for gen=%u produced 0 ROMs but topology still has remote "
-                 "link-active nodes; keeping existing devices until a conclusive scan",
+                 "link-active nodes — keeping existing devices until a conclusive scan",
                  gen.value);
     }
 
     ASFW_LOG(Discovery, "═══════════════════════════════════════");
     ASFW_LOG(Discovery, "Discovery complete: %zu devices processed in gen=%u", roms.size(),
              gen.value);
     ASFW_LOG(Discovery, "═══════════════════════════════════════════════════════");
+
+    if (deps_.sbp2SessionRegistry && !zeroRomScanInconclusive) {
+        deps_.sbp2SessionRegistry->RefreshTargets(gen);
+    } else if (deps_.sbp2SessionRegistry) {
+        ASFW_LOG(Discovery,
+                 "Skipping SBP-2 target refresh for inconclusive zero-ROM scan gen=%u",
+                 gen.value);
+    }
 }
 
 } // namespace ASFW::Driver

ASFWDriver/Controller/ControllerCoreFacades.cpp

@@ -104,16 +104,25 @@ void ControllerCore::SetFCPResponseRouter(
     deps_.fcpResponseRouter = std::move(fcpResponseRouter);
 }
 
+IRM::IRMClient* ControllerCore::GetIRMClient() const { return deps_.irmClient.get(); }
+
 Protocols::SBP2::AddressSpaceManager* ControllerCore::GetSbp2AddressSpaceManager() const {
     return deps_.sbp2AddressSpaceManager.get();
 }
 
+Protocols::SBP2::SBP2SessionRegistry* ControllerCore::GetSBP2SessionRegistry() const {
+    return deps_.sbp2SessionRegistry.get();
+}
+
 void ControllerCore::SetSbp2AddressSpaceManager(
     std::shared_ptr<Protocols::SBP2::AddressSpaceManager> sbp2AddressSpaceManager) {
     deps_.sbp2AddressSpaceManager = std::move(sbp2AddressSpaceManager);
 }
 
-IRM::IRMClient* ControllerCore::GetIRMClient() const { return deps_.irmClient.get(); }
+void ControllerCore::SetSBP2SessionRegistry(
+    std::shared_ptr<Protocols::SBP2::SBP2SessionRegistry> sbp2SessionRegistry) {
+    deps_.sbp2SessionRegistry = std::move(sbp2SessionRegistry);
+}
 
 void ControllerCore::SetIRMClient(std::shared_ptr<IRM::IRMClient> client) {
     deps_.irmClient = std::move(client);

ASFWDriver/Logging/Logging.cpp

@@ -31,5 +31,6 @@ os_log_t AVC()        { static os_log_t log = MakeCategory("avc");        return
 os_log_t Isoch()      { static os_log_t log = MakeCategory("isoch");      return log; }
 os_log_t Audio()      { static os_log_t log = MakeCategory("audio");      return log; }
 os_log_t DICE()       { static os_log_t log = MakeCategory("dice");       return log; }
+os_log_t SBP2()       { static os_log_t log = MakeCategory("sbp2");       return log; }
 
 } // namespace ASFW::Driver::Logging

ASFWDriver/Logging/Logging.hpp

@@ -98,6 +98,7 @@ os_log_t AVC();
 os_log_t Isoch();
 os_log_t Audio();
 os_log_t DICE();
+os_log_t SBP2();
 } // namespace ASFW::Driver::Logging
 
 // ----- time helpers (header-only, safe in DriverKit) -----