fork/GramFirmware

git clone https://git.julia.blue/fork/GramFirmware

CarVacrebase to configurator818d962

gram
8.5 KiB252 linesraw
1#include "comms/backend_init.hpp"
2
3#include "comms/B0XXInputViewer.hpp"
4#include "comms/ConfiguratorBackend.hpp"
5#include "comms/DInputBackend.hpp"
6#include "comms/GamecubeBackend.hpp"
7#include "comms/N64Backend.hpp"
8#include "comms/NesBackend.hpp"
9#include "comms/NintendoSwitchBackend.hpp"
10#include "comms/SnesBackend.hpp"
11#include "comms/XInputBackend.hpp"
12#include "core/CommunicationBackend.hpp"
13#include "core/config_utils.hpp"
14#include "core/mode_selection.hpp"
15#include "core/pinout.hpp"
16
17#include <TUGamepad.hpp>
18#include <TUKeyboard.hpp>
19#include <config.pb.h>
20
21size_t initialize_backends(
22    CommunicationBackend **&backends,
23    InputState &inputs,
24    InputSource **input_sources,
25    size_t input_source_count,
26    Config &config,
27    const Pinout &pinout,
28    backend_config_selector_t get_backend_config,
29    usb_backend_getter_t get_usb_backend_config,
30    detect_console_t detect_console,
31    secondary_backend_initializer_t init_secondary_backends,
32    primary_backend_initializer_t init_primary_backend
33) {
34    // Make sure required function pointers are not null.
35    if (get_backend_config == nullptr || get_usb_backend_config == nullptr ||
36        init_primary_backend == nullptr || detect_console == nullptr) {
37        return 0;
38    }
39
40    CommunicationBackendConfig backend_config = CommunicationBackendConfig_init_zero;
41    get_backend_config(backend_config, inputs, config);
42
43    CommunicationBackend *primary_backend = nullptr;
44
45    /* If no match found for button hold, use console/USB detection to select backend instead. */
46    if (backend_config.backend_id == COMMS_BACKEND_UNSPECIFIED) {
47        /* Must check default USB backend here and initialize it before console detection, so that
48         * we can respond correctly to device descriptor requests from host. */
49        CommunicationBackendConfig usb_backend_config;
50        get_usb_backend_config(usb_backend_config, config);
51        init_primary_backend(
52            primary_backend,
53            usb_backend_config.backend_id,
54            inputs,
55            input_sources,
56            input_source_count,
57            config,
58            pinout
59        );
60        CommunicationBackendId detected_backend_id = COMMS_BACKEND_UNSPECIFIED;
61        detected_backend_id = detect_console(pinout);
62        if (detected_backend_id == COMMS_BACKEND_XINPUT) {
63            backend_config = usb_backend_config;
64        } else {
65            backend_config = backend_config_from_id(
66                detected_backend_id,
67                config.communication_backend_configs,
68                config.communication_backend_configs_count
69            );
70        }
71    }
72    if (backend_config.backend_id == COMMS_BACKEND_UNSPECIFIED &&
73        config.default_backend_config > 0) {
74        backend_config = config.communication_backend_configs[config.default_backend_config - 1];
75    }
76
77    init_primary_backend(
78        primary_backend,
79        backend_config.backend_id,
80        inputs,
81        input_sources,
82        input_source_count,
83        config,
84        pinout
85    );
86
87    size_t backend_count = 1;
88    if (init_secondary_backends != nullptr) {
89        backend_count = init_secondary_backends(
90            backends,
91            primary_backend,
92            backend_config.backend_id,
93            inputs,
94            input_sources,
95            input_source_count,
96            config,
97            pinout
98        );
99    }
100
101    if (backend_config.default_mode_config > 0) {
102        GameModeConfig &mode_config =
103            config.game_mode_configs[backend_config.default_mode_config - 1];
104        for (size_t i = 0; i < backend_count; i++) {
105            set_mode(backends[i], mode_config, config);
106        }
107    }
108
109    return backend_count;
110}
111
112void init_primary_backend(
113    CommunicationBackend *&primary_backend,
114    CommunicationBackendId backend_id,
115    InputState &inputs,
116    InputSource **input_sources,
117    size_t input_source_count,
118    Config &config,
119    const Pinout &pinout
120) {
121    switch (backend_id) {
122        case COMMS_BACKEND_DINPUT:
123            if (primary_backend == nullptr) {
124                TUGamepad::registerDescriptor();
125                TUKeyboard::registerDescriptor();
126                primary_backend = new DInputBackend(inputs, input_sources, input_source_count);
127            }
128            break;
129        case COMMS_BACKEND_NINTENDO_SWITCH:
130            if (primary_backend == nullptr) {
131                NintendoSwitchBackend::RegisterDescriptor();
132                primary_backend =
133                    new NintendoSwitchBackend(inputs, input_sources, input_source_count);
134            }
135            break;
136        case COMMS_BACKEND_XINPUT:
137            if (primary_backend == nullptr) {
138                primary_backend = new XInputBackend(inputs, input_sources, input_source_count);
139            }
140            break;
141        case COMMS_BACKEND_GAMECUBE:
142            delete primary_backend;
143            primary_backend =
144                new GamecubeBackend(inputs, input_sources, input_source_count, pinout.joybus_data);
145            break;
146        case COMMS_BACKEND_N64:
147            delete primary_backend;
148            primary_backend =
149                new N64Backend(inputs, input_sources, input_source_count, pinout.joybus_data);
150            break;
151        case COMMS_BACKEND_NES:
152            delete primary_backend;
153            primary_backend = new NesBackend(
154                inputs,
155                input_sources,
156                input_source_count,
157                pinout.nes_data,
158                pinout.nes_clock,
159                pinout.nes_latch
160            );
161            break;
162        case COMMS_BACKEND_SNES:
163            delete primary_backend;
164            primary_backend = new SnesBackend(
165                inputs,
166                input_sources,
167                input_source_count,
168                pinout.nes_data,
169                pinout.nes_clock,
170                pinout.nes_latch
171            );
172            break;
173        case COMMS_BACKEND_UNSPECIFIED: // Fall back to configurator if invalid backend selected.
174        case COMMS_BACKEND_CONFIGURATOR:
175        default:
176            delete primary_backend;
177            Serial.begin(115200);
178            primary_backend =
179                new ConfiguratorBackend(inputs, input_sources, input_source_count, config, Serial);
180    }
181}
182
183size_t init_secondary_backends(
184    CommunicationBackend **&backends,
185    CommunicationBackend *&primary_backend,
186    CommunicationBackendId backend_id,
187    InputState &inputs,
188    InputSource **input_sources,
189    size_t input_source_count,
190    Config &config,
191    const Pinout &pinout
192) {
193    size_t backend_count = 0;
194
195    switch (backend_id) {
196        case COMMS_BACKEND_DINPUT:
197        case COMMS_BACKEND_XINPUT:
198            backend_count = 2;
199            backends = new CommunicationBackend *[backend_count] {
200                primary_backend, new B0XXInputViewer(inputs, input_sources, input_source_count)
201            };
202            break;
203        default:
204            backend_count = 1;
205            backends = new CommunicationBackend *[backend_count] { primary_backend };
206    }
207
208    return backend_count;
209}
210
211// clang-format off
212
213/* Default is to first check button holds for a matching comms backend config. */
214backend_config_selector_t get_backend_config_default = [](
215    CommunicationBackendConfig &backend_config,
216    const InputState &inputs,
217    Config &config
218) {
219    if (watchdog_caused_reboot()) {
220        // Check watchdog SCRATCH0 register for temporarily set backend config index.
221        uint8_t temp_backend_index = watchdog_hw->scratch[0];
222        if (temp_backend_index > 0 &&
223            temp_backend_index <= config.communication_backend_configs_count) {
224            backend_config = config.communication_backend_configs[temp_backend_index - 1];
225            config.default_usb_backend_config = temp_backend_index;
226            return;
227        }
228    }
229
230    backend_config = backend_config_from_buttons(
231        inputs,
232        config.communication_backend_configs,
233        config.communication_backend_configs_count
234    );
235};
236
237/* Default is to get default USB backend from config. */
238usb_backend_getter_t get_usb_backend_config_default = [](
239    CommunicationBackendConfig &backend_config,
240    const Config &config
241) {
242    if (config.default_usb_backend_config > 0 &&
243        config.default_usb_backend_config <= config.communication_backend_configs_count) {
244        backend_config =
245            config.communication_backend_configs[config.default_usb_backend_config - 1];
246    }
247};
248
249// clang-format on
250
251primary_backend_initializer_t init_primary_backend_default = &init_primary_backend;
252secondary_backend_initializer_t init_secondary_backends_default = &init_secondary_backends;