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() {
@@ -216,6 +221,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

@@ -55,6 +55,7 @@ class Device {
 
     // technically private, but difficult to enforce properly
     void asyncCallback() {}
+    void asyncCloseCallback() { m_asyncClosed = true; }
 
   private:
     bool m_locked = false;
@@ -72,6 +73,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 +98,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/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;