summaryrefslogtreecommitdiffstats
path: root/src/input_common/gcadapter/gc_adapter.h
blob: 7aed0b4809f400250a503cee20288f2c9c79e650 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
// Copyright 2014 Dolphin Emulator Project
// Licensed under GPLv2+
// Refer to the license.txt file included.

#pragma once
#include <algorithm>
#include <functional>
#include <mutex>
#include <thread>
#include <libusb.h>
#include "common/common_types.h"
#include "common/threadsafe_queue.h"

namespace GCAdapter {

enum {
    PAD_USE_ORIGIN = 0x0080,
    PAD_GET_ORIGIN = 0x2000,
    PAD_ERR_STATUS = 0x8000,
};

enum PadButton {
    PAD_BUTTON_LEFT = 0x0001,
    PAD_BUTTON_RIGHT = 0x0002,
    PAD_BUTTON_DOWN = 0x0004,
    PAD_BUTTON_UP = 0x0008,
    PAD_TRIGGER_Z = 0x0010,
    PAD_TRIGGER_R = 0x0020,
    PAD_TRIGGER_L = 0x0040,
    PAD_BUTTON_A = 0x0100,
    PAD_BUTTON_B = 0x0200,
    PAD_BUTTON_X = 0x0400,
    PAD_BUTTON_Y = 0x0800,
    PAD_BUTTON_START = 0x1000,
    // Below is for compatibility with "AxisButton" type
    PAD_STICK = 0x2000,

};

enum class PadAxes : u8 {
    StickX,
    StickY,
    SubstickX,
    SubstickY,
    TriggerLeft,
    TriggerRight,
    Undefined,
};

struct GCPadStatus {
    u16 button;       // Or-ed PAD_BUTTON_* and PAD_TRIGGER_* bits
    u8 stick_x;       // 0 <= stick_x       <= 255
    u8 stick_y;       // 0 <= stick_y       <= 255
    u8 substick_x;    // 0 <= substick_x    <= 255
    u8 substick_y;    // 0 <= substick_y    <= 255
    u8 trigger_left;  // 0 <= trigger_left  <= 255
    u8 trigger_right; // 0 <= trigger_right <= 255

    static constexpr u8 MAIN_STICK_CENTER_X = 0x80;
    static constexpr u8 MAIN_STICK_CENTER_Y = 0x80;
    static constexpr u8 MAIN_STICK_RADIUS = 0x7f;
    static constexpr u8 C_STICK_CENTER_X = 0x80;
    static constexpr u8 C_STICK_CENTER_Y = 0x80;
    static constexpr u8 C_STICK_RADIUS = 0x7f;
    static constexpr u8 TRIGGER_CENTER = 20;
    static constexpr u8 THRESHOLD = 10;

    u8 port;
    PadAxes axis = PadAxes::Undefined;
    u8 axis_value = 255;
};

struct GCState {
    std::unordered_map<int, bool> buttons;
    std::unordered_map<int, u16> axes;
};

enum class ControllerTypes { None, Wired, Wireless };

enum {
    NO_ADAPTER_DETECTED = 0,
    ADAPTER_DETECTED = 1,
};

class Adapter {
public:
    /// Initialize the GC Adapter capture and read sequence
    Adapter();

    /// Close the adapter read thread and release the adapter
    ~Adapter();
    /// Used for polling
    void BeginConfiguration();
    void EndConfiguration();

    std::array<Common::SPSCQueue<GCPadStatus>, 4>& GetPadQueue();
    const std::array<Common::SPSCQueue<GCPadStatus>, 4>& GetPadQueue() const;

    std::array<GCState, 4>& GetPadState();
    const std::array<GCState, 4>& GetPadState() const;

private:
    GCPadStatus CheckStatus(int port, const std::array<u8, 37>& adapter_payload);

    void PadToState(const GCPadStatus& pad, GCState& state);

    void Read();
    void ScanThreadFunc();
    /// Begin scanning for the GC Adapter.
    void StartScanThread();

    /// Stop scanning for the adapter
    void StopScanThread();

    /// Returns true if there is a device connected to port
    bool DeviceConnected(int port);

    /// Resets status of device connected to port
    void ResetDeviceType(int port);

    /// Returns true if we successfully gain access to GC Adapter
    bool CheckDeviceAccess(libusb_device* device);

    /// Captures GC Adapter endpoint address,
    void GetGCEndpoint(libusb_device* device);

    /// For shutting down, clear all data, join all threads, release usb
    void Reset();

    /// For use in initialization, querying devices to find the adapter
    void Setup();

    int current_status = NO_ADAPTER_DETECTED;
    libusb_device_handle* usb_adapter_handle = nullptr;
    std::array<ControllerTypes, 4> adapter_controllers_status{};

    std::mutex s_mutex;

    std::thread adapter_input_thread;
    bool adapter_thread_running;

    std::mutex initialization_mutex;
    std::thread detect_thread;
    bool detect_thread_running = false;

    libusb_context* libusb_ctx;

    u8 input_endpoint = 0;

    bool configuring = false;

    std::array<Common::SPSCQueue<GCPadStatus>, 4> pad_queue;
    std::array<GCState, 4> state;
};

} // namespace GCAdapter