Bit more proper closing sequence.

Author: nicolasnoble

src/ftdi/abstract-ftd2xx-win32.cc

@@ -67,7 +67,10 @@ static void asyncCallbackTrampoline(uv_async_t* handle) {
     device->asyncCallback();
 }
 
-static void asyncCloseCallback(uv_handle_t* handle) {}
+static void asyncCloseCallbackTrampoline(uv_handle_t* handle) {
+    PCSX::FTDI::Device* device = reinterpret_cast<PCSX::FTDI::Device*>(handle->data);
+    device->asyncCloseCallback();
+}
 
 PCSX::FTDI::Device::Device() {
     uv_async_init(s_gui->loop(), &m_async, asyncCallbackTrampoline);
@@ -79,7 +82,9 @@ PCSX::FTDI::Device::~Device() {
     assert(!m_private->m_event);
     assert(!m_private->m_handle);
     delete m_private;
-    uv_close(reinterpret_cast<uv_handle_t*>(&m_async), asyncCloseCallback);
+    uv_loop_t* loop = m_async.loop;
+    uv_close(reinterpret_cast<uv_handle_t*>(&m_async), asyncCloseCallbackTrampoline);
+    while (!m_asyncClosed) uv_run(loop, UV_RUN_ONCE);
 }
 
 void PCSX::FTDI::Device::open() {
@@ -95,6 +100,10 @@ void PCSX::FTDI::Device::close() {
     SetEvent(s_kickEvent);
 }
 bool PCSX::FTDI::Device::isOpened() const { return m_private->m_state == Private::DeviceData::STATE_OPENED; }
+bool PCSX::FTDI::Device::isBusy() const {
+    return m_private->m_state == Private::DeviceData::STATE_CLOSE_PENDING ||
+           m_private->m_state == Private::DeviceData::STATE_OPEN_PENDING;
+}
 
 void PCSX::FTDI::Devices::scan() {
     FT_STATUS status;
@@ -185,6 +194,7 @@ void PCSX::FTDI::Devices::threadProc() {
             if (!device) continue;
             DWORD events;
             FT_GetEventStatus(device->m_private->m_handle, &events);
+            printf("%i", events);
         } while (idx != WAIT_OBJECT_0);
     }
     CloseHandle(s_kickEvent);
@@ -216,6 +226,31 @@ void PCSX::FTDI::Devices::stopThread() {
 
 bool PCSX::FTDI::Devices::isThreadRunning() { return s_threadRunning; }
 
+void PCSX::FTDI::Devices::shutdown() {
+    if (!isThreadRunning()) startThread();
+    {
+        bool run = true;
+        while (run) {
+            run = false;
+            std::unique_lock<std::shared_mutex> guard(s_listLock);
+            for (unsigned i = 0; i < s_numDevs; i++) {
+                auto& device = s_devices[i];
+                switch (device.m_private->m_state) {
+                    case Private::DeviceData::STATE_OPENED:
+                        device.close();
+                    case Private::DeviceData::STATE_CLOSE_PENDING:
+                    case Private::DeviceData::STATE_OPEN_PENDING:
+                        run = true;
+                        break;
+                }
+            }
+        }
+    }
+    stopThread();
+    delete[] s_devices;
+    s_numDevs = 0;
+}
+
 void PCSX::FTDI::Devices::setGUI(GUI* gui) { s_gui = gui; }
 
 #endif

src/ftdi/abstract.h

@@ -49,12 +49,14 @@ class Device {
     const std::string& getDescription() const { return m_description; }
 
     bool isOpened() const;
+    bool isBusy() const;
 
     void open();
     void close();
 
     // technically private, but difficult to enforce properly
     void asyncCallback() {}
+    void asyncCloseCallback() { m_asyncClosed = true; }
 
   private:
     bool m_locked = false;
@@ -72,6 +74,7 @@ class Device {
     std::atomic_uint16_t m_slicesIndexes = 0;
 
     uv_async_t m_async;
+    bool m_asyncClosed = false;
 
     unsigned usedSlices() {
         uint16_t indexes = m_slicesIndexes.load();
@@ -96,6 +99,7 @@ class Device {
 class Devices {
   public:
     static void scan();
+    static void shutdown();
     static void iterate(std::function<bool(Device&)>);
     static bool isThreadRunning();
     static void startThread();

src/gui/widgets/ftdi.cc

@@ -43,17 +43,33 @@ void PCSX::Widgets::FTDI::draw(const char* title) {
 
     ImGui::Text((std::to_string(count) + " devices detected").c_str());
     ImGui::Separator();
-    ::PCSX::FTDI::Devices::iterate([](::PCSX::FTDI::Device& d) {
+    ::PCSX::FTDI::Device* devToClose = nullptr;
+    ::PCSX::FTDI::Device* devToOpen = nullptr;
+    ::PCSX::FTDI::Devices::iterate([&](::PCSX::FTDI::Device& d) mutable {
         ImGui::Text("Vendor Id: %04x", d.getVendorID());
         ImGui::Text("Device Id: %04x", d.getDeviceID());
         ImGui::Text("Type: %i", d.getType());
         ImGui::Text("Serial: %s", d.getSerial().c_str());
         ImGui::Text("Description: %s", d.getDescription().c_str());
         ImGui::Text("Locked: %s", d.isLocked() ? "true" : "false");
         ImGui::Text("High Speed: %s", d.isHighSpeed() ? "true" : "false");
+        ImGui::Text("Opened: %s", d.isOpened() ? "true" : "false");
+        if (d.isOpened() && !d.isBusy()) {
+            if (ImGui::Button("Close")) {
+                devToClose = &d;
+            }
+        } else if (!d.isBusy()) {
+            if (ImGui::Button("Open")) {
+                devToOpen = &d;
+            }
+        } else {
+            ImGui::Text("Device is busy");
+        }
         ImGui::Separator();
         return true;
     });
-
     ImGui::End();
+
+    if (devToClose) devToClose->close();
+    if (devToOpen) devToOpen->open();
 }

src/main/main.cc

@@ -227,6 +227,8 @@ int main(int argc, char **argv) {
     PCSX::g_emulator.m_gpu->shutdown();
     PCSX::g_emulator.m_cdrom->m_iso.shutdown();
 
+    PCSX::FTDI::Devices::shutdown();
+
     s_gui->close();
 
     delete s_gui;