usb: implement transfer cancellation

benedekkupper · benedekkupper · commit 29a37000c65c · 2026-07-10T15:02:45.000+02:00
Signed-off-by: Benedek Kupper &lt;kupper.benedek@gmail.com&gt;
diff --git a/c2usb/port/nxp/mcux_mac.cpp b/c2usb/port/nxp/mcux_mac.cpp
@@ -231,7 +231,6 @@ usb::result mcux_mac::ep_cancel(ep_handle eph)
 {
     auto addr = ep_handle_to_address(eph);
     auto status = driver_.deviceCancel(handle(), addr);
-    busy_flags_.clear(addr);
     return (status == kStatus_USB_Success) ? usb::result::ok : usb::result::not_connected;
 }
 
@@ -269,10 +268,6 @@ void mcux_mac::process_ep_notification(const _usb_device_callback_message_struct
     {
         // wrong mapping
     }
-    else if (message.length == UINT32_MAX)
-    {
-        // callback due to ep_cancel()
-    }
     else if (addr.number() == 0)
     {
         transfer t{};
@@ -328,11 +323,13 @@ void mcux_mac::process_ep_notification(const _usb_device_callback_message_struct
                    (t.size() == 0)); // work around bug in NXP code
         }
     }
-    else
+    else // other endpoints
     {
         busy_flags_.clear(addr);
-        ep_transfer_complete(addr, create_ep_handle(addr),
-                             transfer(message.buffer, message.length));
+
+        bool success = (message.length != USB_CANCELLED_TRANSFER_LENGTH);
+        ep_transfer_complete(addr, transfer(message.buffer, message.length * success, success,
+                                            ep_address_to_handle(addr)));
     }
 }
 
diff --git a/c2usb/port/nxp/mcux_mac.hpp b/c2usb/port/nxp/mcux_mac.hpp
@@ -92,7 +92,7 @@ class mcux_mac : public df::address_handle_mac
     usb::result ep_send(usb::df::ep_handle eph, const std::span<const uint8_t>& data) override;
     usb::result ep_receive(usb::df::ep_handle eph, const std::span<uint8_t>& data) override;
     usb::result ep_close(usb::df::ep_handle eph) override;
-    usb::result ep_cancel(usb::df::ep_handle eph);
+    usb::result ep_cancel(usb::df::ep_handle eph) override;
 
     bool ep_is_stalled(usb::df::ep_handle eph) const override;
     usb::result ep_change_stall(usb::df::ep_handle eph, bool stall) override;
diff --git a/c2usb/port/zephyr/udc_mac.cpp b/c2usb/port/zephyr/udc_mac.cpp
@@ -739,22 +739,19 @@ void udc_mac::process_ep_event(net_buf* buf)
     {
         busy_flags_.clear(addr);
 
-        if (info.err == 0)
+        if (info.err != 0)
         {
-            for (uint8_t i = 0; i < ep_bufs_.size(); ++i)
-            {
-                if (ep_bufs_[i] == buf)
-                {
-                    return ep_transfer_complete(addr, create_ep_handle(i + 1),
-                                                transfer(buf->data, buf->len));
-                }
-            }
-            assert(ep_bufs_.size() == 0); // a net_buf was issued out of c2usb scope
+            LOG_ERR("EP %x error:%d", info.ep, info.err);
         }
-        else
+        for (uint8_t i = 0; i < ep_bufs_.size(); ++i)
         {
-            LOG_ERR("EP %x error:%d", info.ep, info.err);
+            if (ep_bufs_[i] == buf)
+            {
+                return ep_transfer_complete(
+                    addr, transfer(buf->data, buf->len, info.err == 0, create_ep_handle(i + 1)));
+            }
         }
+        assert(ep_bufs_.size() == 0); // a net_buf was issued out of c2usb scope
     }
 }
 
@@ -913,7 +910,7 @@ usb::result udc_mac::ep_close(usb::df::ep_handle eph)
         return usb::result(ret);
     }
     k_yield();
-    return usb::result::OK;
+    return usb::result::ok;
 }
 
 usb::result udc_mac::ep_cancel(usb::df::ep_handle eph)
diff --git a/c2usb/port/zephyr/udc_mac.hpp b/c2usb/port/zephyr/udc_mac.hpp
@@ -82,7 +82,7 @@ class udc_mac : public df::mac
     usb::result ep_send(usb::df::ep_handle eph, const std::span<const uint8_t>& data) override;
     usb::result ep_receive(usb::df::ep_handle eph, const std::span<uint8_t>& data) override;
     usb::result ep_close(usb::df::ep_handle eph) override;
-    usb::result ep_cancel(usb::df::ep_handle eph);
+    usb::result ep_cancel(usb::df::ep_handle eph) override;
     bool ep_is_stalled(usb::df::ep_handle eph) const override;
     usb::result ep_change_stall(usb::df::ep_handle eph, bool stall) override;
 };
diff --git a/c2usb/usb/df/class/cdc_acm.cpp b/c2usb/usb/df/class/cdc_acm.cpp
@@ -130,36 +130,16 @@ void function::disable(const config::interface& iface)
     cdc::function::disable(iface);
 }
 
-void function::transfer_complete(ep_handle eph, const transfer& t)
+void function::ep_callback(const transfer& t)
 {
-    if (eph == ep_out_handle())
+    if (t.endpoint() == ep_out_handle())
     {
-        return data_received(t);
+        return data_received(std::span<uint8_t>(t.data(), t.size() * t.success()));
     }
-    if (eph == ep_in_handle())
+    if (t.endpoint() == ep_in_handle())
     {
-#if 0
-        auto len = t.size();
-        if (len == 0)
-        {
-            if (tx_len_ > 0)
-            {
-                // if ZLP is finished, substitute original length
-                len = tx_len_;
-                tx_len_ = 0;
-            }
-        }
-        else if ((len % in_ep_mps_) == 0)
-        {
-            // if length mod MPS == 0, split the transfer by sending ZLP
-            tx_len_ = len;
-            send_ep(eph, {});
-            return;
-        }
-        return data_sent({const_cast<const uint8_t*>(t.data()), len});
-#endif
         bool needs_zlp = t.size() and (t.size() % in_ep_mps_) == 0;
-        return data_sent(t, needs_zlp);
+        return data_sent(std::span<const uint8_t>(t.data(), t.size() * t.success()), needs_zlp);
     }
     // notification sent
 }
diff --git a/c2usb/usb/df/class/cdc_acm.hpp b/c2usb/usb/df/class/cdc_acm.hpp
@@ -76,7 +76,7 @@ class function : public cdc::function
     void control_data_complete(message& msg, const config::interface& iface) override;
     void enable(const config::interface& iface, uint8_t alt_sel) override;
     void disable(const config::interface& iface) override;
-    void transfer_complete(ep_handle eph, const transfer& t) override;
+    void ep_callback(const transfer& t) override;
 
     auto& line_coding() const
     {
diff --git a/c2usb/usb/df/class/hid.cpp b/c2usb/usb/df/class/hid.cpp
@@ -84,15 +84,16 @@ usb::result app_base_function::receive_report(const std::span<uint8_t>& data, re
     }
 }
 
-void app_base_function::transfer_complete(ep_handle eph, const transfer& t)
+void app_base_function::ep_callback(const transfer& t)
 {
-    if (eph == ep_in_handle())
+    if (t.endpoint() == ep_in_handle())
     {
-        app_.in_report_sent(t);
+        return app_.in_report_sent(std::span<const uint8_t>(t.data(), t.size() * t.success()));
     }
-    else
+    if (t.endpoint() == ep_out_handle())
     {
-        app_.set_report(report::type::OUTPUT, t);
+        return app_.set_report(report::type::OUTPUT,
+                               std::span<const uint8_t>(t.data(), t.size() * t.success()));
     }
 }
 
@@ -242,7 +243,7 @@ void function::control_data_complete(message& msg, [[maybe_unused]] const config
     {
         auto type = static_cast<report::type>(msg.request().wValue.high_byte());
         rx_buffers_[type] = {};
-        app_.set_report(type, msg.data());
+        app_.set_report(type, msg.data().to_span());
         break;
     }
     default:
diff --git a/c2usb/usb/df/class/hid.hpp b/c2usb/usb/df/class/hid.hpp
@@ -38,7 +38,7 @@ class app_base_function : public df::named_function, public ::hid::transport
     result receive_report(const std::span<uint8_t>& data, ::hid::report::type type) override;
     ::hid::transport::type transport_type() const override { return ::hid::transport::type::USB; }
 
-    void transfer_complete(ep_handle eph, const transfer& t) override;
+    void ep_callback(const transfer& t) override;
 
     ::hid::application& app_;
     ::hid::reports_receiver rx_buffers_{};
diff --git a/c2usb/usb/df/function.cpp b/c2usb/usb/df/function.cpp
@@ -211,6 +211,18 @@ usb::result function::stall_ep(ep_handle eph, bool stall)
     }
 }
 
+usb::result function::cancel_ep(ep_handle eph)
+{
+    if ((mac_ != nullptr) and eph.valid())
+    {
+        return mac_->ep_cancel(eph);
+    }
+    else
+    {
+        return usb::result::connection_reset;
+    }
+}
+
 message* function::pending_message()
 {
     if (mac_ != nullptr)
diff --git a/c2usb/usb/df/function.hpp b/c2usb/usb/df/function.hpp
@@ -51,9 +51,7 @@ class function : public polymorphic
 
     virtual std::string_view ms_compatible_id() const { return {}; }
 
-    virtual void transfer_complete([[maybe_unused]] ep_handle eph,
-                                   [[maybe_unused]] const transfer& t)
-    {}
+    virtual void ep_callback([[maybe_unused]] const transfer& t) {}
 
   protected:
     ep_handle open_ep(const config::endpoint& ep);
@@ -80,6 +78,7 @@ class function : public polymorphic
     result send_ep(ep_handle eph, const std::span<const uint8_t>& data);
     result receive_ep(ep_handle eph, const std::span<uint8_t>& data);
     result stall_ep(ep_handle eph, bool stall);
+    result cancel_ep(ep_handle eph);
 
     message* pending_message();
 
diff --git a/c2usb/usb/df/mac.cpp b/c2usb/usb/df/mac.cpp
@@ -128,10 +128,10 @@ bool mac::control_ep_data(direction ep_dir, const transfer& t)
     return true;
 }
 
-void mac::ep_transfer_complete(endpoint::address addr, ep_handle eph, const transfer& t)
+void mac::ep_transfer_complete(endpoint::address addr, const transfer& t)
 {
     assert(configured());
-    ep_address_to_config(addr).interface().function().transfer_complete(eph, t);
+    ep_address_to_config(addr).interface().function().ep_callback(t);
 }
 
 const config::endpoint& mac::ep_address_to_config(endpoint::address addr) const
diff --git a/c2usb/usb/df/mac.hpp b/c2usb/usb/df/mac.hpp
@@ -71,6 +71,7 @@ class mac : public polymorphic
     {
         return result::not_supported;
     }
+    virtual result ep_cancel([[maybe_unused]] ep_handle eph) { return result::not_supported; }
     virtual result ep_close([[maybe_unused]] ep_handle eph) { return result::not_supported; }
 
     virtual bool ep_is_stalled([[maybe_unused]] ep_handle eph) const { return false; }
@@ -113,7 +114,7 @@ class mac : public polymorphic
     auto control_stage() const { return ctrl_msg_.stage(); }
     transfer control_ep_setup();
     bool control_ep_data(direction ep_dir, const transfer& t);
-    void ep_transfer_complete(endpoint::address addr, ep_handle eph, const transfer& t);
+    void ep_transfer_complete(endpoint::address addr, const transfer& t);
     virtual void init([[maybe_unused]] const usb::speeds& speeds) {}
     virtual void deinit() {}
     virtual bool set_attached(bool attached) { return attached; }
diff --git a/c2usb/usb/df/message.cpp b/c2usb/usb/df/message.cpp
@@ -47,7 +47,9 @@ void string_message::set_reply(const transfer& t)
 
 void string_message::reject()
 {
-    set_reply(transfer::stall());
+    assert(pending_);
+    pending_ = false;
+    data_ = transfer::stall();
 }
 
 void string_message::send_buffer()
@@ -102,7 +104,14 @@ void message::confirm()
 
 void message::set_reply(bool accept)
 {
-    string_message::set_reply(accept ? transfer() : transfer::stall());
+    if (accept)
+    {
+        confirm();
+    }
+    else
+    {
+        reject();
+    }
 }
 
 void message::send_data(const std::span<const uint8_t>& data)
diff --git a/c2usb/usb/df/transfer.hpp b/c2usb/usb/df/transfer.hpp
@@ -15,15 +15,46 @@
 
 namespace usb::df
 {
+/// @brief  The ep_handle class provides an abstract value that the functions can use to interact
+///         with endpoints.
+class ep_handle
+{
+  public:
+    constexpr ep_handle() {}
+    constexpr operator auto() const { return id_; }
+    constexpr bool valid() const { return id_ != 0; }
+    constexpr auto operator<=>(const ep_handle& rhs) const = default;
+
+  private:
+    friend class mac;
+    constexpr ep_handle(uint8_t i)
+        : id_(i)
+    {}
+    uint8_t id_{};
+};
+
 /// @brief  The transfer class stores information of a single USB transfer.
 class transfer
 {
   public:
+    enum struct outcome : uint8_t
+    {
+        SUCCESS,
+        STALL,
+        CANCELLED,
+    };
     using size_type = uint16_t;
 
     constexpr transfer() = default;
-    constexpr transfer(const uint8_t* data, size_type size)
-        : data_(const_cast<uint8_t*>(data)), size_(size)
+    constexpr transfer(const uint8_t* data, size_type size, outcome result = outcome::SUCCESS,
+                       ep_handle eph = {})
+        : data_(const_cast<uint8_t*>(data)), size_(size), result_(result), eph_(eph)
+    {}
+    constexpr transfer(const uint8_t* data, size_type size, bool success, ep_handle eph = {})
+        : data_(const_cast<uint8_t*>(data)),
+          size_(size),
+          result_(success ? outcome::SUCCESS : outcome::CANCELLED),
+          eph_(eph)
     {}
     template <typename T>
     transfer(T begin, T end)
@@ -36,43 +67,31 @@ class transfer
         : transfer(view.begin(), view.end())
     {}
     constexpr uint8_t* data() const { return data_; }
+    const uint8_t* const_data() const { return const_cast<const uint8_t*>(data_); }
     constexpr size_type size() const { return size_; }
     constexpr bool empty() const { return size() == 0; }
+    constexpr ep_handle endpoint() const { return eph_; }
+    bool stalled() const { return result_ == outcome::STALL; }
+    bool cancelled() const { return result_ == outcome::CANCELLED; }
+    bool success() const { return result_ == outcome::SUCCESS; }
 
     static const transfer& stall()
     {
-        static const transfer t{reinterpret_cast<uint8_t*>(UINTPTR_MAX), 0};
+        static const transfer t{nullptr, 0, outcome::STALL};
         return t;
     }
-    bool stalled() const { return data() == stall().data(); }
 
-    operator std::span<uint8_t>() const { return {data(), size()}; }
-    operator std::span<const uint8_t>() const
+    std::span<uint8_t> to_span() const { return {data(), size()}; }
+    std::span<const uint8_t> to_const_span() const
     {
         return {const_cast<const uint8_t*>(data()), size()};
     }
 
   private:
     uint8_t* data_{};
     size_type size_{};
-};
-
-/// @brief  The ep_handle class provides an abstract value that the functions can use to interact
-///         with endpoints.
-class ep_handle
-{
-  public:
-    constexpr ep_handle() {}
-    constexpr operator auto() const { return id_; }
-    constexpr bool valid() const { return id_ != 0; }
-    constexpr auto operator<=>(const ep_handle& rhs) const = default;
-
-  private:
-    friend class mac;
-    constexpr ep_handle(uint8_t i)
-        : id_(i)
-    {}
-    uint8_t id_{};
+    outcome result_{outcome::SUCCESS};
+    ep_handle eph_{};
 };
 
 // TODO: create packed ep-transfer class

Original file line number	Diff line number	Diff line change
`@@ -231,7 +231,6 @@ usb::result mcux_mac::ep_cancel(ep_handle eph)`
`231`	`231`	`{`
`232`	`232`	`auto addr = ep_handle_to_address(eph);`
`233`	`233`	`auto status = driver_.deviceCancel(handle(), addr);`
`234`		`- busy_flags_.clear(addr);`
`235`	`234`	`return (status == kStatus_USB_Success) ? usb::result::ok : usb::result::not_connected;`
`236`	`235`	`}`
`237`	`236`
`@@ -269,10 +268,6 @@ void mcux_mac::process_ep_notification(const _usb_device_callback_message_struct`
`269`	`268`	`{`
`270`	`269`	`// wrong mapping`
`271`	`270`	`}`
`272`		`- else if (message.length == UINT32_MAX)`
`273`		`- {`
`274`		`- // callback due to ep_cancel()`
`275`		`- }`
`276`	`271`	`else if (addr.number() == 0)`
`277`	`272`	`{`
`278`	`273`	`transfer t{};`
`@@ -328,11 +323,13 @@ void mcux_mac::process_ep_notification(const _usb_device_callback_message_struct`
`328`	`323`	`(t.size() == 0)); // work around bug in NXP code`
`329`	`324`	`}`
`330`	`325`	`}`
`331`		`- else`
	`326`	`+ else // other endpoints`
`332`	`327`	`{`
`333`	`328`	`busy_flags_.clear(addr);`
`334`		`- ep_transfer_complete(addr, create_ep_handle(addr),`
`335`		`- transfer(message.buffer, message.length));`
	`329`	`+`
	`330`	`+ bool success = (message.length != USB_CANCELLED_TRANSFER_LENGTH);`
	`331`	`+ ep_transfer_complete(addr, transfer(message.buffer, message.length * success, success,`
	`332`	`+ ep_address_to_handle(addr)));`
`336`	`333`	`}`
`337`	`334`	`}`
`338`	`335`
Original file line number	Diff line number	Diff line change
`@@ -739,22 +739,19 @@ void udc_mac::process_ep_event(net_buf* buf)`
`739`	`739`	`{`
`740`	`740`	`busy_flags_.clear(addr);`
`741`	`741`
`742`		`- if (info.err == 0)`
	`742`	`+ if (info.err != 0)`
`743`	`743`	`{`
`744`		`- for (uint8_t i = 0; i < ep_bufs_.size(); ++i)`
`745`		`- {`
`746`		`- if (ep_bufs_[i] == buf)`
`747`		`- {`
`748`		`- return ep_transfer_complete(addr, create_ep_handle(i + 1),`
`749`		`- transfer(buf->data, buf->len));`
`750`		`- }`
`751`		`- }`
`752`		`- assert(ep_bufs_.size() == 0); // a net_buf was issued out of c2usb scope`
	`744`	`+ LOG_ERR("EP %x error:%d", info.ep, info.err);`
`753`	`745`	`}`
`754`		`- else`
	`746`	`+ for (uint8_t i = 0; i < ep_bufs_.size(); ++i)`
`755`	`747`	`{`
`756`		`- LOG_ERR("EP %x error:%d", info.ep, info.err);`
	`748`	`+ if (ep_bufs_[i] == buf)`
	`749`	`+ {`
	`750`	`+ return ep_transfer_complete(`
	`751`	`+ addr, transfer(buf->data, buf->len, info.err == 0, create_ep_handle(i + 1)));`
	`752`	`+ }`
`757`	`753`	`}`
	`754`	`+ assert(ep_bufs_.size() == 0); // a net_buf was issued out of c2usb scope`
`758`	`755`	`}`
`759`	`756`	`}`
`760`	`757`
`@@ -913,7 +910,7 @@ usb::result udc_mac::ep_close(usb::df::ep_handle eph)`
`913`	`910`	`return usb::result(ret);`
`914`	`911`	`}`
`915`	`912`	`k_yield();`
`916`		`- return usb::result::OK;`
	`913`	`+ return usb::result::ok;`
`917`	`914`	`}`
`918`	`915`
`919`	`916`	`usb::result udc_mac::ep_cancel(usb::df::ep_handle eph)`
Original file line number	Diff line number	Diff line change
`@@ -76,7 +76,7 @@ class function : public cdc::function`
`76`	`76`	`void control_data_complete(message& msg, const config::interface& iface) override;`
`77`	`77`	`void enable(const config::interface& iface, uint8_t alt_sel) override;`
`78`	`78`	`void disable(const config::interface& iface) override;`
`79`		`- void transfer_complete(ep_handle eph, const transfer& t) override;`
	`79`	`+ void ep_callback(const transfer& t) override;`
`80`	`80`
`81`	`81`	`auto& line_coding() const`
`82`	`82`	`{`
Original file line number	Diff line number	Diff line change
`@@ -84,15 +84,16 @@ usb::result app_base_function::receive_report(const std::span<uint8_t>& data, re`
`84`	`84`	`}`
`85`	`85`	`}`
`86`	`86`
`87`		`-void app_base_function::transfer_complete(ep_handle eph, const transfer& t)`
	`87`	`+void app_base_function::ep_callback(const transfer& t)`
`88`	`88`	`{`
`89`		`- if (eph == ep_in_handle())`
	`89`	`+ if (t.endpoint() == ep_in_handle())`
`90`	`90`	`{`
`91`		`- app_.in_report_sent(t);`
	`91`	`+ return app_.in_report_sent(std::span<const uint8_t>(t.data(), t.size() * t.success()));`
`92`	`92`	`}`
`93`		`- else`
	`93`	`+ if (t.endpoint() == ep_out_handle())`
`94`	`94`	`{`
`95`		`- app_.set_report(report::type::OUTPUT, t);`
	`95`	`+ return app_.set_report(report::type::OUTPUT,`
	`96`	`+ std::span<const uint8_t>(t.data(), t.size() * t.success()));`
`96`	`97`	`}`
`97`	`98`	`}`
`98`	`99`
`@@ -242,7 +243,7 @@ void function::control_data_complete(message& msg, [[maybe_unused]] const config`
`242`	`243`	`{`
`243`	`244`	`auto type = static_cast<report::type>(msg.request().wValue.high_byte());`
`244`	`245`	`rx_buffers_[type] = {};`
`245`		`- app_.set_report(type, msg.data());`
	`246`	`+ app_.set_report(type, msg.data().to_span());`
`246`	`247`	`break;`
`247`	`248`	`}`
`248`	`249`	`default:`
Original file line number	Diff line number	Diff line change
`@@ -211,6 +211,18 @@ usb::result function::stall_ep(ep_handle eph, bool stall)`
`211`	`211`	`}`
`212`	`212`	`}`
`213`	`213`
	`214`	`+usb::result function::cancel_ep(ep_handle eph)`
	`215`	`+{`
	`216`	`+ if ((mac_ != nullptr) and eph.valid())`
	`217`	`+ {`
	`218`	`+ return mac_->ep_cancel(eph);`
	`219`	`+ }`
	`220`	`+ else`
	`221`	`+ {`
	`222`	`+ return usb::result::connection_reset;`
	`223`	`+ }`
	`224`	`+}`
	`225`	`+`
`214`	`226`	`message* function::pending_message()`
`215`	`227`	`{`
`216`	`228`	`if (mac_ != nullptr)`