usb: implement transfer cancellation

Signed-off-by: Benedek Kupper <kupper.benedek@gmail.com>

Author: benedekkupper

c2usb/port/nxp/mcux_mac.cpp

@@ -101,6 +101,29 @@ static IRQn_Type usb_irqn(int index)
 extern "C" usb_status_t _USB_DeviceNotificationTrigger(void* handle, void* msg);
 #endif
 
+static constexpr c2usb::result to_result(usb_status_t status)
+{
+    switch (status)
+    {
+    case kStatus_USB_Success:
+        return c2usb::result::ok;
+    case kStatus_USB_Error:
+        return std::errc::io_error;
+    case kStatus_USB_Busy:
+        return std::errc::device_or_resource_busy;
+    case kStatus_USB_InvalidHandle:
+        return std::errc::no_such_device;
+    case kStatus_USB_ControllerNotFound:
+        return std::errc::no_such_device_or_address;
+    case kStatus_USB_InvalidParameter:
+        return std::errc::invalid_argument;
+    case kStatus_USB_InvalidRequest:
+        return std::errc::operation_not_supported;
+    default:
+        return std::errc::function_not_supported;
+    }
+}
+
 void mcux_mac::init(const speeds& speeds)
 {
 #if CONFIG_C2USB_MCUX_USB_COEXISTENCE
@@ -123,32 +146,29 @@ void mcux_mac::deinit()
 
 bool mcux_mac::set_attached(bool attached)
 {
-    driver_.device_control(handle(), attached ? kUSB_DeviceControlRun : kUSB_DeviceControlStop);
+    [[maybe_unused]] auto status =
+        driver_.device_control(handle(), attached ? kUSB_DeviceControlRun : kUSB_DeviceControlStop);
+    assert(status == kStatus_USB_Success);
     return attached;
 }
 
 usb::result mcux_mac::signal_remote_wakeup()
 {
-    auto status = driver_.device_control(handle(), kUSB_DeviceControlResume);
-    switch (status)
-    {
-    case kStatus_USB_Success:
-        return usb::result::ok;
-    default:
-        return usb::result::io_error;
-    }
+    return to_result(driver_.device_control(handle(), kUSB_DeviceControlResume));
 }
 
 void mcux_mac::set_address_early()
 {
-    driver_.device_control(handle(), kUSB_DeviceControlPreSetDeviceAddress,
-                           &request().wValue.low_byte());
+    [[maybe_unused]] auto status = driver_.device_control(
+        handle(), kUSB_DeviceControlPreSetDeviceAddress, &request().wValue.low_byte());
+    assert(status == kStatus_USB_Success);
 }
 
 void mcux_mac::set_address_timely()
 {
-    driver_.device_control(handle(), kUSB_DeviceControlSetDeviceAddress,
-                           &request().wValue.low_byte());
+    [[maybe_unused]] auto status = driver_.device_control(
+        handle(), kUSB_DeviceControlSetDeviceAddress, &request().wValue.low_byte());
+    assert(status == kStatus_USB_Success);
 }
 
 usb::speed mcux_mac::speed() const
@@ -178,7 +198,9 @@ void mcux_mac::control_ep_open()
 void mcux_mac::control_ep_stall()
 {
     auto addr = endpoint::address::control_out();
-    driver_.device_control(handle(), kUSB_DeviceControlEndpointStall, &addr);
+    [[maybe_unused]] auto status =
+        driver_.device_control(handle(), kUSB_DeviceControlEndpointStall, &addr);
+    assert(status == kStatus_USB_Success);
 }
 
 bool mcux_mac::ep_init(usb::endpoint::address addr, usb::endpoint::type type, uint16_t mps,
@@ -211,9 +233,8 @@ usb::result mcux_mac::ep_send(ep_handle eph, const std::span<const uint8_t>& dat
     {
         return usb::result::device_or_resource_busy;
     }
-    auto status =
-        driver_.deviceSend(handle(), addr, const_cast<uint8_t*>(data.data()), data.size());
-    return (status == kStatus_USB_Success) ? usb::result::ok : usb::result::not_connected;
+    return to_result(
+        driver_.deviceSend(handle(), addr, const_cast<uint8_t*>(data.data()), data.size()));
 }
 
 usb::result mcux_mac::ep_receive(ep_handle eph, const std::span<uint8_t>& data)
@@ -223,24 +244,23 @@ usb::result mcux_mac::ep_receive(ep_handle eph, const std::span<uint8_t>& data)
     {
         return usb::result::device_or_resource_busy;
     }
-    auto status = driver_.deviceRecv(handle(), addr, data.data(), data.size());
-    return (status == kStatus_USB_Success) ? usb::result::ok : usb::result::not_connected;
+    return to_result(driver_.deviceRecv(handle(), addr, data.data(), data.size()));
 }
 
 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;
+    return to_result(driver_.deviceCancel(handle(), addr));
 }
 
-usb::result mcux_mac::ep_close(ep_handle eph)
+usb::result mcux_mac::ep_close(ep_handle& eph)
 {
     auto addr = ep_handle_to_address(eph);
-    auto status = driver_.device_control(handle(), kUSB_DeviceControlEndpointDeinit, &addr);
-    busy_flags_.clear(addr);
-    return (status == kStatus_USB_Success) ? usb::result::ok : usb::result::not_connected;
+    eph = {};
+    auto result =
+        to_result(driver_.device_control(handle(), kUSB_DeviceControlEndpointDeinit, &addr));
+    // busy flag is cleared in cancel callback
+    return result;
 }
 
 bool mcux_mac::ep_is_stalled(ep_handle eph) const
@@ -269,10 +289,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 +344,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)));
     }
 }
 

c2usb/port/nxp/mcux_mac.hpp

@@ -91,8 +91,8 @@ class mcux_mac : public df::address_handle_mac
     usb::df::ep_handle ep_open(const usb::df::config::endpoint& ep) override;
     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_close(usb::df::ep_handle& eph) override;
+    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;

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
     }
 }
 
@@ -896,7 +893,7 @@ usb::result udc_mac::ep_receive(usb::df::ep_handle eph, const std::span<uint8_t>
     return ep_transfer(eph, data, direction::OUT);
 }
 
-usb::result udc_mac::ep_close(usb::df::ep_handle eph)
+usb::result udc_mac::ep_close(usb::df::ep_handle& eph)
 {
     auto& info = *udc_get_buf_info(ep_handle_to_buf(eph));
     auto addr = endpoint::address(info.ep);
@@ -907,13 +904,14 @@ usb::result udc_mac::ep_close(usb::df::ep_handle eph)
     {
         return usb::result(ret);
     }
+    eph = {};
     ret = udc_ep_dequeue(dev_, addr);
     if (ret != 0)
     {
         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)

c2usb/port/zephyr/udc_mac.hpp

@@ -81,8 +81,8 @@ class udc_mac : public df::mac
     usb::df::ep_handle ep_open(const usb::df::config::endpoint& ep) override;
     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_close(usb::df::ep_handle& eph) override;
+    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;
 };

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
 }

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
     {

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:

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_{};

c2usb/usb/df/function.cpp

@@ -172,7 +172,6 @@ void function::close_ep(ep_handle& eph)
     {
         mac_->ep_close(eph);
     }
-    eph = {};
 }
 
 usb::result function::send_ep(ep_handle eph, const std::span<const uint8_t>& data)
@@ -211,6 +210,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)

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();