1
// SPDX-FileCopyrightText: 2019-2025 Connor McLaughlin <[email protected]> and contributors.
2
// SPDX-License-Identifier: CC-BY-NC-ND-4.0
3

4
#include "analog_controller.h"
5
#include "host.h"
6
#include "settings.h"
7
#include "system.h"
8

9
#include "util/imgui_manager.h"
10
#include "util/input_manager.h"
11
#include "util/state_wrapper.h"
12

13
#include "common/bitutils.h"
14
#include "common/log.h"
15
#include "common/string_util.h"
16

17
#include "IconsFontAwesome6.h"
18
#include "IconsPromptFont.h"
19
#include "fmt/format.h"
20

21
#include <cmath>
22

23
LOG_CHANNEL(Controller);
24

25
AnalogController::AnalogController(u32 index) : Controller(index)
26
{
27
  m_status_byte = 0x5A;
28
  m_axis_state.fill(0x80);
29
  m_rumble_config.fill(0xFF);
30
}
31

32
AnalogController::~AnalogController() = default;
33

34
ControllerType AnalogController::GetType() const
35
{
36
  return ControllerType::AnalogController;
37
}
38

39
void AnalogController::Reset()
40
{
41
  m_command = Command::Idle;
42
  m_command_step = 0;
43
  m_rx_buffer.fill(0x00);
44
  m_tx_buffer.fill(0x00);
45
  m_analog_mode = false;
46
  m_configuration_mode = false;
47

48
  for (u32 i = 0; i < NUM_MOTORS; i++)
49
  {
50
    if (m_motor_state[i] != 0)
51
      SetMotorState(i, 0);
52
  }
53

54
  m_dualshock_enabled = false;
55
  ResetRumbleConfig();
56

57
  m_status_byte = 0x5A;
58

59
  if (m_force_analog_on_reset)
60
  {
61
    if (CanStartInAnalogMode(ControllerType::AnalogController))
62
      SetAnalogMode(true, false);
63
  }
64
}
65

66
bool AnalogController::DoState(StateWrapper& sw, bool apply_input_state)
67
{
68
  if (!Controller::DoState(sw, apply_input_state))
69
    return false;
70

71
  const bool old_analog_mode = m_analog_mode;
72
  MotorState motor_state = m_motor_state;
73

74
  if (sw.GetVersion() < 76) [[unlikely]]
75
  {
76
    u8 unused_command_param = 0;
77
    bool unused_legacy_rumble_unlocked = false;
78

79
    sw.Do(&m_analog_mode);
80
    sw.Do(&m_dualshock_enabled);
81
    sw.DoEx(&unused_legacy_rumble_unlocked, 44, false);
82
    sw.Do(&m_configuration_mode);
83
    sw.Do(&unused_command_param);
84
    sw.DoEx(&m_status_byte, 55, static_cast<u8>(0x5A));
85

86
    u16 button_state = m_button_state;
87
    sw.DoEx(&button_state, 44, static_cast<u16>(0xFFFF));
88
    if (apply_input_state)
89
      m_button_state = button_state;
90

91
    sw.Do(&m_command);
92

93
    int unused_rumble_config_large_motor_index = -1;
94
    int unused_rumble_config_small_motor_index = -1;
95

96
    sw.DoEx(&m_rumble_config, 45, {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF});
97
    sw.DoEx(&unused_rumble_config_large_motor_index, 45, -1);
98
    sw.DoEx(&unused_rumble_config_small_motor_index, 45, -1);
99
    sw.DoEx(&m_analog_toggle_queued, 45, false);
100

101
    sw.Do(&motor_state);
102
  }
103
  else
104
  {
105
    sw.Do(&m_command);
106
    sw.Do(&m_command_step);
107
    sw.Do(&m_response_length);
108
    sw.DoBytes(m_rx_buffer.data(), m_rx_buffer.size());
109
    sw.DoBytes(m_tx_buffer.data(), m_tx_buffer.size());
110
    sw.Do(&m_analog_mode);
111
    sw.Do(&m_analog_locked);
112
    sw.Do(&m_dualshock_enabled);
113
    sw.Do(&m_configuration_mode);
114
    sw.DoBytes(m_rumble_config.data(), m_rumble_config.size());
115
    sw.Do(&m_status_byte);
116
    // sw.Do(&m_digital_mode_extra_halfwords); // always zero
117

118
    auto axis_state = m_axis_state;
119
    u16 button_state = m_button_state;
120
    sw.DoBytes(axis_state.data(), axis_state.size());
121
    sw.Do(&button_state);
122
    sw.Do(&motor_state);
123

124
    if (apply_input_state)
125
    {
126
      m_axis_state = axis_state;
127
      m_button_state = button_state;
128
    }
129
  }
130

131
  if (sw.IsReading())
132
  {
133
    for (u8 i = 0; i < NUM_MOTORS; i++)
134
      SetMotorState(i, motor_state[i]);
135

136
    if (old_analog_mode != m_analog_mode)
137
    {
138
      Host::AddIconOSDMessage(fmt::format("Controller{}AnalogMode", m_index), ICON_FA_GAMEPAD,
139
                              fmt::format(m_analog_mode ?
140
                                            TRANSLATE_FS("AnalogController", "Controller {} switched to analog mode.") :
141
                                            TRANSLATE_FS("AnalogController", "Controller {} switched to digital mode."),
142
                                          m_index + 1u),
143
                              5.0f);
144
    }
145
  }
146
  return true;
147
}
148

149
float AnalogController::GetBindState(u32 index) const
150
{
151
  if (index >= LED_BIND_START_INDEX)
152
    return BoolToFloat(index == LED_BIND_START_INDEX && m_analog_mode);
153
  else if (index >= MOTOR_BIND_START_INDEX)
154
    return GetMotorStrength(index - MOTOR_BIND_START_INDEX);
155
  else if (index >= HALFAXIS_BIND_START_INDEX)
156
    return static_cast<float>(m_half_axis_state[index - HALFAXIS_BIND_START_INDEX]) * (1.0f / 255.0f);
157
  else if (index < static_cast<u32>(Button::Analog))
158
    return static_cast<float>(((m_button_state >> index) & 1u) ^ 1u);
159
  else
160
    return 0.0f;
161
}
162

163
void AnalogController::SetBindState(u32 index, float value)
164
{
165
  if (index == static_cast<s32>(Button::Analog))
166
  {
167
    // analog toggle
168
    if (value >= m_button_deadzone)
169
    {
170
      if (m_command == Command::Idle)
171
        ProcessAnalogModeToggle();
172
      else
173
        m_analog_toggle_queued = true;
174
    }
175

176
    return;
177
  }
178
  else if (index >= static_cast<u32>(Button::Count))
179
  {
180
    const u32 sub_index = index - static_cast<u32>(Button::Count);
181
    if (sub_index >= static_cast<u32>(m_half_axis_state.size()))
182
      return;
183

184
    const u8 u8_value = static_cast<u8>(std::clamp(value * m_analog_sensitivity * 255.0f, 0.0f, 255.0f));
185
    if (u8_value == m_half_axis_state[sub_index])
186
      return;
187

188
    m_half_axis_state[sub_index] = u8_value;
189

190
#define MERGE(pos, neg)                                                                                                \
191
  ((m_half_axis_state[static_cast<u32>(pos)] != 0) ? (127u + ((m_half_axis_state[static_cast<u32>(pos)] + 1u) / 2u)) : \
192
                                                     (127u - (m_half_axis_state[static_cast<u32>(neg)] / 2u)))
193

194
    const auto prev_axis_state = m_axis_state;
195

196
    switch (static_cast<HalfAxis>(sub_index))
197
    {
198
      case HalfAxis::LLeft:
199
      case HalfAxis::LRight:
200
        m_axis_state[static_cast<u8>(Axis::LeftX)] = ((m_invert_left_stick & 1u) != 0u) ?
201
                                                       MERGE(HalfAxis::LLeft, HalfAxis::LRight) :
202
                                                       MERGE(HalfAxis::LRight, HalfAxis::LLeft);
203
        break;
204

205
      case HalfAxis::LDown:
206
      case HalfAxis::LUp:
207
        m_axis_state[static_cast<u8>(Axis::LeftY)] = ((m_invert_left_stick & 2u) != 0u) ?
208
                                                       MERGE(HalfAxis::LUp, HalfAxis::LDown) :
209
                                                       MERGE(HalfAxis::LDown, HalfAxis::LUp);
210
        break;
211

212
      case HalfAxis::RLeft:
213
      case HalfAxis::RRight:
214
        m_axis_state[static_cast<u8>(Axis::RightX)] = ((m_invert_right_stick & 1u) != 0u) ?
215
                                                        MERGE(HalfAxis::RLeft, HalfAxis::RRight) :
216
                                                        MERGE(HalfAxis::RRight, HalfAxis::RLeft);
217
        break;
218

219
      case HalfAxis::RDown:
220
      case HalfAxis::RUp:
221
        m_axis_state[static_cast<u8>(Axis::RightY)] = ((m_invert_right_stick & 2u) != 0u) ?
222
                                                        MERGE(HalfAxis::RUp, HalfAxis::RDown) :
223
                                                        MERGE(HalfAxis::RDown, HalfAxis::RUp);
224
        break;
225

226
      default:
227
        break;
228
    }
229

230
    if (m_analog_deadzone > 0.0f)
231
    {
232
#define MERGE_F(pos, neg)                                                                                              \
233
  ((m_half_axis_state[static_cast<u32>(pos)] != 0) ?                                                                   \
234
     (static_cast<float>(m_half_axis_state[static_cast<u32>(pos)]) / 255.0f) :                                         \
235
     (static_cast<float>(m_half_axis_state[static_cast<u32>(neg)]) / -255.0f))
236

237
      float pos_x, pos_y;
238
      if (static_cast<HalfAxis>(sub_index) < HalfAxis::RLeft)
239
      {
240
        pos_x = ((m_invert_left_stick & 1u) != 0u) ? MERGE_F(HalfAxis::LLeft, HalfAxis::LRight) :
241
                                                     MERGE_F(HalfAxis::LRight, HalfAxis::LLeft);
242
        pos_y = ((m_invert_left_stick & 2u) != 0u) ? MERGE_F(HalfAxis::LUp, HalfAxis::LDown) :
243
                                                     MERGE_F(HalfAxis::LDown, HalfAxis::LUp);
244
      }
245
      else
246
      {
247
        pos_x = ((m_invert_right_stick & 1u) != 0u) ? MERGE_F(HalfAxis::RLeft, HalfAxis::RRight) :
248
                                                      MERGE_F(HalfAxis::RRight, HalfAxis::RLeft);
249
        pos_y = ((m_invert_right_stick & 2u) != 0u) ? MERGE_F(HalfAxis::RUp, HalfAxis::RDown) :
250
                                                      MERGE_F(HalfAxis::RDown, HalfAxis::RUp);
251
      }
252

253
      if (InCircularDeadzone(m_analog_deadzone, pos_x, pos_y))
254
      {
255
        // Set to 127 (center).
256
        if (static_cast<HalfAxis>(sub_index) < HalfAxis::RLeft)
257
          m_axis_state[static_cast<u8>(Axis::LeftX)] = m_axis_state[static_cast<u8>(Axis::LeftY)] = 127;
258
        else
259
          m_axis_state[static_cast<u8>(Axis::RightX)] = m_axis_state[static_cast<u8>(Axis::RightY)] = 127;
260
      }
261
#undef MERGE_F
262
    }
263

264
    if (std::memcmp(m_axis_state.data(), prev_axis_state.data(), m_axis_state.size()) != 0)
265
      System::SetRunaheadReplayFlag(true);
266

267
#undef MERGE
268

269
    return;
270
  }
271

272
  const u16 bit = u16(1) << static_cast<u8>(index);
273

274
  if (value >= m_button_deadzone)
275
  {
276
    if (m_button_state & bit)
277
      System::SetRunaheadReplayFlag(false);
278

279
    m_button_state &= ~(bit);
280
  }
281
  else
282
  {
283
    if (!(m_button_state & bit))
284
      System::SetRunaheadReplayFlag(false);
285

286
    m_button_state |= bit;
287
  }
288
}
289

290
u32 AnalogController::GetButtonStateBits() const
291
{
292
  // flip bits, native data is active low
293
  return m_button_state ^ 0xFFFF;
294
}
295

296
std::optional<u32> AnalogController::GetAnalogInputBytes() const
297
{
298
  return m_axis_state[static_cast<size_t>(Axis::LeftY)] << 24 | m_axis_state[static_cast<size_t>(Axis::LeftX)] << 16 |
299
         m_axis_state[static_cast<size_t>(Axis::RightY)] << 8 | m_axis_state[static_cast<size_t>(Axis::RightX)];
300
}
301

302
void AnalogController::ResetTransferState()
303
{
304
  if (m_analog_toggle_queued)
305
  {
306
    ProcessAnalogModeToggle();
307
    m_analog_toggle_queued = false;
308
  }
309

310
  m_command = Command::Idle;
311
  m_command_step = 0;
312
}
313

314
void AnalogController::SetAnalogMode(bool enabled, bool show_message)
315
{
316
  if (m_analog_mode == enabled)
317
    return;
318

319
  m_analog_mode = enabled;
320

321
  InputManager::SetPadLEDState(m_index, BoolToFloat(enabled));
322

323
  INFO_LOG("Controller {} switched to {} mode.", m_index + 1u, m_analog_mode ? "analog" : "digital");
324
  if (show_message)
325
  {
326
    Host::AddIconOSDMessage(
327
      fmt::format("Controller{}AnalogMode", m_index), ICON_PF_GAMEPAD_ALT,
328
      m_analog_mode ? fmt::format(TRANSLATE_FS("Controller", "Controller {} switched to analog mode."), m_index + 1u) :
329
                      fmt::format(TRANSLATE_FS("Controller", "Controller {} switched to digital mode."), m_index + 1u),
330
      Host::OSD_QUICK_DURATION);
331
  }
332
}
333

334
void AnalogController::ProcessAnalogModeToggle()
335
{
336
  if (m_analog_locked)
337
  {
338
    Host::AddIconOSDMessage(
339
      fmt::format("Controller{}AnalogMode", m_index), ICON_PF_GAMEPAD_ALT,
340
      fmt::format(m_analog_mode ?
341
                    TRANSLATE_FS("AnalogController", "Controller {} is locked to analog mode by the game.") :
342
                    TRANSLATE_FS("AnalogController", "Controller {} is locked to digital mode by the game."),
343
                  m_index + 1u),
344
      Host::OSD_QUICK_DURATION);
345
  }
346
  else
347
  {
348
    SetAnalogMode(!m_analog_mode, true);
349
    ResetRumbleConfig();
350

351
    // Set status byte to 0 if we were previously in configuration mode, so that the game knows about the mode change.
352
    if (m_dualshock_enabled)
353
    {
354
      // However, the problem with doing this unconditionally is that games like Tomb Raider have the loader menu
355
      // put the pad into configuration mode, but not analog mode. So if the user toggles analog mode, the status
356
      // byte ends up stuck at 0x00. As a workaround, clear out config/dualshock mode when the game isn't flagged
357
      // as supporting the dualshock.
358
      if (!m_analog_mode && !CanStartInAnalogMode(ControllerType::AnalogController))
359
      {
360
        WARNING_LOG("Resetting pad on digital->analog switch.");
361
        m_configuration_mode = false;
362
        m_dualshock_enabled = false;
363
        m_status_byte = 0x5A;
364
      }
365
      else
366
      {
367
        m_status_byte = 0x00;
368
      }
369
    }
370
  }
371
}
372

373
void AnalogController::SetMotorState(u32 motor, u8 value)
374
{
375
  DebugAssert(motor < NUM_MOTORS);
376
  if (m_motor_state[motor] != value)
377
  {
378
    m_motor_state[motor] = value;
379

380
    const float hvalue = GetMotorStrength(motor);
381
    DEV_LOG("Set {} motor to {} (raw {})", (motor == LargeMotor) ? "large" : "small", hvalue, m_motor_state[motor]);
382
    InputManager::SetPadVibrationIntensity(m_index, MOTOR_BIND_START_INDEX + motor, hvalue);
383
  }
384
}
385

386
float AnalogController::GetMotorStrength(u32 motor) const
387
{
388
  // Small motor is only 0/1.
389
  const u8 state =
390
    (motor == SmallMotor) ? (((m_motor_state[SmallMotor] & 0x01) != 0x00) ? 255 : 0) : m_motor_state[LargeMotor];
391

392
  // Curve from https://github.com/KrossX/Pokopom/blob/master/Pokopom/Input_XInput.cpp#L210
393
  const double x = static_cast<double>(std::clamp<s32>(static_cast<s32>(state) + m_vibration_bias[motor], 0, 255));
394
  const double strength = 0.006474549734772402 * std::pow(x, 3.0) - 1.258165252213538 * std::pow(x, 2.0) +
395
                          156.82454281087692 * x + 3.637978807091713e-11;
396

397
  return (state != 0) ? static_cast<float>(strength / 65535.0) : 0.0f;
398
}
399

400
u16 AnalogController::GetExtraButtonMask() const
401
{
402
  u16 mask = 0xFFFF;
403

404
  static constexpr u8 NEG_THRESHOLD = static_cast<u8>(128.0f - (127.0 * 0.5f));
405
  static constexpr u8 POS_THRESHOLD = static_cast<u8>(128.0f + (127.0 * 0.5f));
406

407
  if (m_analog_dpad_in_digital_mode && !m_analog_mode && !m_configuration_mode)
408
  {
409
    const bool left = (m_axis_state[static_cast<u8>(Axis::LeftX)] <= NEG_THRESHOLD);
410
    const bool right = (m_axis_state[static_cast<u8>(Axis::LeftX)] >= POS_THRESHOLD);
411
    const bool up = (m_axis_state[static_cast<u8>(Axis::LeftY)] <= NEG_THRESHOLD);
412
    const bool down = (m_axis_state[static_cast<u8>(Axis::LeftY)] >= POS_THRESHOLD);
413

414
    mask = ~((static_cast<u16>(left) << static_cast<u8>(Button::Left)) |
415
             (static_cast<u16>(right) << static_cast<u8>(Button::Right)) |
416
             (static_cast<u16>(up) << static_cast<u8>(Button::Up)) |
417
             (static_cast<u16>(down) << static_cast<u8>(Button::Down)));
418
  }
419

420
  if (m_analog_shoulder_buttons == 2 || (m_analog_shoulder_buttons == 1 && !m_analog_mode && !m_configuration_mode))
421
  {
422
    const bool left = (m_axis_state[static_cast<u8>(Axis::RightX)] <= NEG_THRESHOLD);
423
    const bool right = (m_axis_state[static_cast<u8>(Axis::RightX)] >= POS_THRESHOLD);
424

425
    mask &= ~((static_cast<u16>(left) << static_cast<u8>(Button::L1)) |
426
              (static_cast<u16>(right) << static_cast<u8>(Button::R1)));
427
  }
428

429
  return mask;
430
}
431

432
void AnalogController::ResetRumbleConfig()
433
{
434
  m_rumble_config.fill(0xFF);
435
  SetMotorState(SmallMotor, 0);
436
  SetMotorState(LargeMotor, 0);
437
}
438

439
u8 AnalogController::GetResponseNumHalfwords() const
440
{
441
  if (m_configuration_mode || m_analog_mode)
442
    return 0x3;
443

444
  return (0x1 + m_digital_mode_extra_halfwords);
445
}
446

447
u8 AnalogController::GetModeID() const
448
{
449
  if (m_configuration_mode)
450
    return 0xF;
451

452
  if (m_analog_mode)
453
    return 0x7;
454

455
  return 0x4;
456
}
457

458
u8 AnalogController::GetIDByte() const
459
{
460
  return Truncate8((GetModeID() << 4) | GetResponseNumHalfwords());
461
}
462

463
void AnalogController::Poll()
464
{
465
  // m_tx_buffer = {GetIDByte(), m_status_byte, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
466
  m_tx_buffer[0] = GetIDByte();
467
  m_tx_buffer[1] = m_status_byte;
468

469
  const u16 button_state = m_button_state & GetExtraButtonMask();
470
  m_tx_buffer[2] = Truncate8(button_state);
471
  m_tx_buffer[3] = Truncate8(button_state >> 8);
472

473
  if (m_analog_mode || m_configuration_mode)
474
  {
475
    m_tx_buffer[4] = m_axis_state[static_cast<u8>(Axis::RightX)];
476
    m_tx_buffer[5] = m_axis_state[static_cast<u8>(Axis::RightY)];
477
    m_tx_buffer[6] = m_axis_state[static_cast<u8>(Axis::LeftX)];
478
    m_tx_buffer[7] = m_axis_state[static_cast<u8>(Axis::LeftY)];
479
  }
480
  else
481
  {
482
    m_tx_buffer[4] = 0;
483
    m_tx_buffer[5] = 0;
484
    m_tx_buffer[6] = 0;
485
    m_tx_buffer[7] = 0;
486
  }
487
}
488

489
bool AnalogController::Transfer(const u8 data_in, u8* data_out)
490
{
491
  bool ack;
492
  m_rx_buffer[m_command_step] = data_in;
493

494
  switch (m_command)
495
  {
496
    case Command::Idle:
497
    {
498
      *data_out = 0xFF;
499

500
      if (data_in == 0x01)
501
      {
502
        DEBUG_LOG("ACK controller access");
503
        m_command = Command::Ready;
504
        return true;
505
      }
506

507
      DEV_LOG("Unknown data_in = 0x{:02X}", data_in);
508
      return false;
509
    }
510
    break;
511

512
    case Command::Ready:
513
    {
514
      if (data_in == 0x42)
515
      {
516
        Assert(m_command_step == 0);
517
        m_response_length = (GetResponseNumHalfwords() + 1) * 2;
518
        m_command = Command::ReadPad;
519
        Poll();
520
      }
521
      else if (data_in == 0x43)
522
      {
523
        Assert(m_command_step == 0);
524
        m_response_length = (GetResponseNumHalfwords() + 1) * 2;
525
        m_command = Command::ConfigModeSetMode;
526
        if (!m_configuration_mode)
527
          Poll();
528
        else
529
          m_tx_buffer = {GetIDByte(), m_status_byte, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
530
      }
531
      else if (m_configuration_mode && data_in == 0x44)
532
      {
533
        Assert(m_command_step == 0);
534
        m_response_length = (GetResponseNumHalfwords() + 1) * 2;
535
        m_command = Command::SetAnalogMode;
536
        m_tx_buffer = {GetIDByte(), m_status_byte, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
537

538
        ResetRumbleConfig();
539
      }
540
      else if (m_configuration_mode && data_in == 0x45)
541
      {
542
        Assert(m_command_step == 0);
543
        m_response_length = (GetResponseNumHalfwords() + 1) * 2;
544
        m_command = Command::GetAnalogMode;
545
        m_tx_buffer = {GetIDByte(), m_status_byte, 0x01, 0x02, BoolToUInt8(m_analog_mode), 0x02, 0x01, 0x00};
546
      }
547
      else if (m_configuration_mode && data_in == 0x46)
548
      {
549
        Assert(m_command_step == 0);
550
        m_response_length = (GetResponseNumHalfwords() + 1) * 2;
551
        m_command = Command::Command46;
552
        m_tx_buffer = {GetIDByte(), m_status_byte, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
553
      }
554
      else if (m_configuration_mode && data_in == 0x47)
555
      {
556
        Assert(m_command_step == 0);
557
        m_response_length = (GetResponseNumHalfwords() + 1) * 2;
558
        m_command = Command::Command47;
559
        m_tx_buffer = {GetIDByte(), m_status_byte, 0x00, 0x00, 0x02, 0x00, 0x01, 0x00};
560
      }
561
      else if (m_configuration_mode && data_in == 0x4C)
562
      {
563
        Assert(m_command_step == 0);
564
        m_response_length = (GetResponseNumHalfwords() + 1) * 2;
565
        m_command = Command::Command4C;
566
        m_tx_buffer = {GetIDByte(), m_status_byte, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
567
      }
568
      else if (m_configuration_mode && data_in == 0x4D)
569
      {
570
        Assert(m_command_step == 0);
571
        m_response_length = (GetResponseNumHalfwords() + 1) * 2;
572
        m_command = Command::GetSetRumble;
573
        m_tx_buffer = {GetIDByte(), m_status_byte, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
574
      }
575
      else
576
      {
577
        if (m_configuration_mode)
578
          ERROR_LOG("Unimplemented config mode command 0x{:02X}", data_in);
579

580
        *data_out = 0xFF;
581
        return false;
582
      }
583
    }
584
    break;
585

586
    case Command::ReadPad:
587
    {
588
      if (m_dualshock_enabled)
589
      {
590
        if (m_command_step >= 2 && m_command_step < 7)
591
        {
592
          const u8 motor_to_set = m_rumble_config[m_command_step - 2];
593
          if (motor_to_set <= LargeMotor)
594
            SetMotorState(motor_to_set, data_in);
595
        }
596
      }
597
      else if (m_command_step == 3)
598
      {
599
        const bool legacy_rumble_on = (m_rx_buffer[2] & 0xC0) == 0x40 && (m_rx_buffer[3] & 0x01) != 0;
600
        SetMotorState(SmallMotor, legacy_rumble_on ? 255 : 0);
601
      }
602
    }
603
    break;
604

605
    case Command::ConfigModeSetMode:
606
    {
607
      if (m_command_step == (static_cast<s32>(m_response_length) - 1))
608
      {
609
        m_configuration_mode = (m_rx_buffer[2] == 1);
610

611
        if (m_configuration_mode)
612
        {
613
          m_dualshock_enabled = true;
614
          m_status_byte = 0x5A;
615
        }
616

617
        DEBUG_LOG("0x{:02x}({}) config mode", m_rx_buffer[2], m_configuration_mode ? "enter" : "leave");
618
      }
619
    }
620
    break;
621

622
    case Command::SetAnalogMode:
623
    {
624
      if (m_command_step == 2)
625
      {
626
        DEV_LOG("analog mode val 0x{:02x}", data_in);
627

628
        if (data_in == 0x00 || data_in == 0x01)
629
          SetAnalogMode((data_in == 0x01), true);
630
      }
631
      else if (m_command_step == 3)
632
      {
633
        DEV_LOG("analog mode lock 0x{:02x}", data_in);
634

635
        if (data_in == 0x02 || data_in == 0x03)
636
          m_analog_locked = (data_in == 0x03);
637
      }
638
    }
639
    break;
640

641
    case Command::GetAnalogMode:
642
    {
643
      // Intentionally empty, analog mode byte is set in reply buffer when command is first received
644
    }
645
    break;
646

647
    case Command::Command46:
648
    {
649
      if (m_command_step == 2)
650
      {
651
        if (data_in == 0x00)
652
        {
653
          m_tx_buffer[4] = 0x01;
654
          m_tx_buffer[5] = 0x02;
655
          m_tx_buffer[6] = 0x00;
656
          m_tx_buffer[7] = 0x0A;
657
        }
658
        else if (data_in == 0x01)
659
        {
660
          m_tx_buffer[4] = 0x01;
661
          m_tx_buffer[5] = 0x01;
662
          m_tx_buffer[6] = 0x01;
663
          m_tx_buffer[7] = 0x14;
664
        }
665
      }
666
    }
667
    break;
668

669
    case Command::Command47:
670
    {
671
      if (m_command_step == 2 && data_in != 0x00)
672
      {
673
        m_tx_buffer[4] = 0x00;
674
        m_tx_buffer[5] = 0x00;
675
        m_tx_buffer[6] = 0x00;
676
        m_tx_buffer[7] = 0x00;
677
      }
678
    }
679
    break;
680

681
    case Command::Command4C:
682
    {
683
      if (m_command_step == 2)
684
      {
685
        if (data_in == 0x00)
686
          m_tx_buffer[5] = 0x04;
687
        else if (data_in == 0x01)
688
          m_tx_buffer[5] = 0x07;
689
      }
690
    }
691
    break;
692

693
    case Command::GetSetRumble:
694
    {
695
      if (m_command_step >= 2 && m_command_step < 7)
696
      {
697
        const u8 index = m_command_step - 2;
698
        m_tx_buffer[m_command_step] = m_rumble_config[index];
699
        m_rumble_config[index] = data_in;
700

701
        if (data_in == LargeMotor)
702
          DEBUG_LOG("Large motor mapped to byte index {}", index);
703
        else if (data_in == SmallMotor)
704
          DEBUG_LOG("Small motor mapped to byte index {}", index);
705
      }
706
      else if (m_command_step == 7)
707
      {
708
        // reset motor value if we're no longer mapping it
709
        bool has_small = false;
710
        bool has_large = false;
711
        for (size_t i = 0; i < m_rumble_config.size(); i++)
712
        {
713
          has_small |= (m_rumble_config[i] == SmallMotor);
714
          has_large |= (m_rumble_config[i] == LargeMotor);
715
        }
716
        if (!has_small)
717
          SetMotorState(SmallMotor, 0);
718
        if (!has_large)
719
          SetMotorState(LargeMotor, 0);
720
      }
721
    }
722
    break;
723

724
      DefaultCaseIsUnreachable();
725
  }
726

727
  *data_out = m_tx_buffer[m_command_step];
728

729
  m_command_step = (m_command_step + 1) % m_response_length;
730
  ack = (m_command_step == 0) ? false : true;
731

732
  if (m_command_step == 0)
733
  {
734
    m_command = Command::Idle;
735

736
    DEBUG_LOG("Rx: {:02x} {:02x} {:02x} {:02x} {:02x} {:02x} {:02x} {:02x}", m_rx_buffer[0], m_rx_buffer[1],
737
              m_rx_buffer[2], m_rx_buffer[3], m_rx_buffer[4], m_rx_buffer[5], m_rx_buffer[6], m_rx_buffer[7]);
738
    DEBUG_LOG("Tx: {:02x} {:02x} {:02x} {:02x} {:02x} {:02x} {:02x} {:02x}", m_tx_buffer[0], m_tx_buffer[1],
739
              m_tx_buffer[2], m_tx_buffer[3], m_tx_buffer[4], m_tx_buffer[5], m_tx_buffer[6], m_tx_buffer[7]);
740

741
    m_rx_buffer.fill(0x00);
742
    m_tx_buffer.fill(0x00);
743
  }
744

745
  return ack;
746
}
747

748
std::unique_ptr<AnalogController> AnalogController::Create(u32 index)
749
{
750
  return std::make_unique<AnalogController>(index);
751
}
752

753
constinit const Controller::ControllerBindingInfo AnalogController::s_binding_info[] = {
754
#define BUTTON(name, display_name, icon_name, button, genb)                                                            \
755
  {name, display_name, icon_name, static_cast<u32>(button), InputBindingInfo::Type::Button, genb}
756
#define AXIS(name, display_name, icon_name, halfaxis, genb)                                                            \
757
  {name,                                                                                                               \
758
   display_name,                                                                                                       \
759
   icon_name,                                                                                                          \
760
   HALFAXIS_BIND_START_INDEX + static_cast<u32>(halfaxis),                                                             \
761
   InputBindingInfo::Type::HalfAxis,                                                                                   \
762
   genb}
763
#define MOTOR(name, display_name, icon_name, index, genb)                                                              \
764
  {name, display_name, icon_name, MOTOR_BIND_START_INDEX + index, InputBindingInfo::Type::Motor, genb}
765
#define MODE_LED(name, display_name, icon_name, index, genb)                                                           \
766
  {name, display_name, icon_name, LED_BIND_START_INDEX + index, InputBindingInfo::Type::LED, genb}
767

768
  // clang-format off
769
  BUTTON("Up", TRANSLATE_NOOP("AnalogController", "D-Pad Up"), ICON_PF_DPAD_UP, AnalogController::Button::Up, GenericInputBinding::DPadUp),
770
  BUTTON("Right", TRANSLATE_NOOP("AnalogController", "D-Pad Right"), ICON_PF_DPAD_RIGHT, AnalogController::Button::Right, GenericInputBinding::DPadRight),
771
  BUTTON("Down", TRANSLATE_NOOP("AnalogController", "D-Pad Down"), ICON_PF_DPAD_DOWN, AnalogController::Button::Down, GenericInputBinding::DPadDown),
772
  BUTTON("Left", TRANSLATE_NOOP("AnalogController", "D-Pad Left"), ICON_PF_DPAD_LEFT, AnalogController::Button::Left, GenericInputBinding::DPadLeft),
773
  BUTTON("Triangle", TRANSLATE_NOOP("AnalogController", "Triangle"), ICON_PF_BUTTON_TRIANGLE, AnalogController::Button::Triangle, GenericInputBinding::Triangle),
774
  BUTTON("Circle", TRANSLATE_NOOP("AnalogController", "Circle"), ICON_PF_BUTTON_CIRCLE, AnalogController::Button::Circle, GenericInputBinding::Circle),
775
  BUTTON("Cross", TRANSLATE_NOOP("AnalogController", "Cross"), ICON_PF_BUTTON_CROSS, AnalogController::Button::Cross, GenericInputBinding::Cross),
776
  BUTTON("Square", TRANSLATE_NOOP("AnalogController", "Square"), ICON_PF_BUTTON_SQUARE, AnalogController::Button::Square, GenericInputBinding::Square),
777
  BUTTON("Select", TRANSLATE_NOOP("AnalogController", "Select"), ICON_PF_SELECT_SHARE, AnalogController::Button::Select, GenericInputBinding::Select),
778
  BUTTON("Start", TRANSLATE_NOOP("AnalogController", "Start"),ICON_PF_START, AnalogController::Button::Start, GenericInputBinding::Start),
779
  BUTTON("Analog", TRANSLATE_NOOP("AnalogController", "Analog Toggle"), ICON_PF_ANALOG_LEFT_RIGHT, AnalogController::Button::Analog, GenericInputBinding::System),
780
  BUTTON("L1", TRANSLATE_NOOP("AnalogController", "L1"), ICON_PF_LEFT_SHOULDER_L1, AnalogController::Button::L1, GenericInputBinding::L1),
781
  BUTTON("R1", TRANSLATE_NOOP("AnalogController", "R1"), ICON_PF_RIGHT_SHOULDER_R1, AnalogController::Button::R1, GenericInputBinding::R1),
782
  BUTTON("L2", TRANSLATE_NOOP("AnalogController", "L2"), ICON_PF_LEFT_TRIGGER_L2, AnalogController::Button::L2, GenericInputBinding::L2),
783
  BUTTON("R2", TRANSLATE_NOOP("AnalogController", "R2"), ICON_PF_RIGHT_TRIGGER_R2, AnalogController::Button::R2, GenericInputBinding::R2),
784
  BUTTON("L3", TRANSLATE_NOOP("AnalogController", "L3"), ICON_PF_LEFT_ANALOG_CLICK, AnalogController::Button::L3, GenericInputBinding::L3),
785
  BUTTON("R3", TRANSLATE_NOOP("AnalogController", "R3"), ICON_PF_RIGHT_ANALOG_CLICK, AnalogController::Button::R3, GenericInputBinding::R3),
786

787
  AXIS("LLeft", TRANSLATE_NOOP("AnalogController", "Left Stick Left"), ICON_PF_LEFT_ANALOG_LEFT, AnalogController::HalfAxis::LLeft, GenericInputBinding::LeftStickLeft),
788
  AXIS("LRight", TRANSLATE_NOOP("AnalogController", "Left Stick Right"), ICON_PF_LEFT_ANALOG_RIGHT, AnalogController::HalfAxis::LRight, GenericInputBinding::LeftStickRight),
789
  AXIS("LDown", TRANSLATE_NOOP("AnalogController", "Left Stick Down"), ICON_PF_LEFT_ANALOG_DOWN, AnalogController::HalfAxis::LDown, GenericInputBinding::LeftStickDown),
790
  AXIS("LUp", TRANSLATE_NOOP("AnalogController", "Left Stick Up"), ICON_PF_LEFT_ANALOG_UP, AnalogController::HalfAxis::LUp, GenericInputBinding::LeftStickUp),
791
  AXIS("RLeft", TRANSLATE_NOOP("AnalogController", "Right Stick Left"), ICON_PF_RIGHT_ANALOG_LEFT, AnalogController::HalfAxis::RLeft, GenericInputBinding::RightStickLeft),
792
  AXIS("RRight", TRANSLATE_NOOP("AnalogController", "Right Stick Right"), ICON_PF_RIGHT_ANALOG_RIGHT, AnalogController::HalfAxis::RRight, GenericInputBinding::RightStickRight),
793
  AXIS("RDown", TRANSLATE_NOOP("AnalogController", "Right Stick Down"), ICON_PF_RIGHT_ANALOG_DOWN, AnalogController::HalfAxis::RDown, GenericInputBinding::RightStickDown),
794
  AXIS("RUp", TRANSLATE_NOOP("AnalogController", "Right Stick Up"), ICON_PF_RIGHT_ANALOG_UP, AnalogController::HalfAxis::RUp, GenericInputBinding::RightStickUp),
795

796
  MOTOR("LargeMotor", TRANSLATE_NOOP("AnalogController", "Large Motor"), ICON_PF_VIBRATION_L, LargeMotor, GenericInputBinding::LargeMotor),
797
  MOTOR("SmallMotor", TRANSLATE_NOOP("AnalogController", "Small Motor"), ICON_PF_VIBRATION, SmallMotor, GenericInputBinding::SmallMotor),
798

799
  MODE_LED("AnalogLED", TRANSLATE_NOOP("AnalogController", "Analog LED"), ICON_PF_ANALOG_LEFT_RIGHT, 0, GenericInputBinding::ModeLED),
800

801
// clang-format on
802

803
#undef MOTOR
804
#undef AXIS
805
#undef BUTTON
806
#undef MODE_LED
807
};
808

809
static constexpr const char* s_invert_settings[] = {
810
  TRANSLATE_NOOP("AnalogController", "Not Inverted"), TRANSLATE_NOOP("AnalogController", "Invert Left/Right"),
811
  TRANSLATE_NOOP("AnalogController", "Invert Up/Down"),
812
  TRANSLATE_NOOP("AnalogController", "Invert Left/Right + Up/Down"), nullptr};
813

814
static constexpr const char* s_shoulder_settings[] = {
815
  TRANSLATE_NOOP("AnalogController", "Never"), TRANSLATE_NOOP("AnalogController", "Digital Mode Only"),
816
  TRANSLATE_NOOP("AnalogController", "Analog and Digital Modes"), nullptr};
817

818
static const SettingInfo s_settings[] = {
819
  {SettingInfo::Type::Boolean, "ForceAnalogOnReset", TRANSLATE_NOOP("AnalogController", "Force Analog Mode on Reset"),
820
   TRANSLATE_NOOP("AnalogController", "Forces the controller to analog mode when the console is reset/powered on."),
821
   "true", nullptr, nullptr, nullptr, nullptr, nullptr, 0.0f},
822
  {SettingInfo::Type::Boolean, "AnalogDPadInDigitalMode",
823
   TRANSLATE_NOOP("AnalogController", "Use Left Analog for D-Pad in Digital Mode"),
824
   TRANSLATE_NOOP(
825
     "AnalogController",
826
     "Allows you to use the left analog stick to control the d-pad in digital mode, as well as the buttons."),
827
   "true", nullptr, nullptr, nullptr, nullptr, nullptr, 0.0f},
828
  {SettingInfo::Type::IntegerList, "AnalogShoulderButtons",
829
   TRANSLATE_NOOP("AnalogController", "Use Right Analog for Shoulder Buttons"),
830
   TRANSLATE_NOOP("AnalogController",
831
                  "Allows you to use the right analog stick to control the shoulder buttons, as well as the buttons."),
832
   "0", "0", "2", nullptr, nullptr, s_shoulder_settings, 0.0f},
833
  {SettingInfo::Type::Float, "AnalogDeadzone", TRANSLATE_NOOP("AnalogController", "Analog Deadzone"),
834
   TRANSLATE_NOOP("AnalogController",
835
                  "Sets the analog stick deadzone, i.e. the fraction of the stick movement which will be ignored."),
836
   "0", "0", "1", "0.01", "%.0f%%", nullptr, 100.0f},
837
  {SettingInfo::Type::Float, "AnalogSensitivity", TRANSLATE_NOOP("AnalogController", "Analog Sensitivity"),
838
   TRANSLATE_NOOP(
839
     "AnalogController",
840
     "Sets the analog stick axis scaling factor. A value between 130% and 140% is recommended when using recent "
841
     "controllers, e.g. DualShock 4, Xbox One Controller."),
842
   "1.33", "0.01", "2", "0.01", "%.0f%%", nullptr, 100.0f},
843
  {SettingInfo::Type::Float, "ButtonDeadzone", TRANSLATE_NOOP("AnalogController", "Button/Trigger Deadzone"),
844
   TRANSLATE_NOOP("AnalogController", "Sets the deadzone for activating buttons/triggers, "
845
                                      "i.e. the fraction of the trigger which will be ignored."),
846
   "0.25", "0.01", "1", "0.01", "%.0f%%", nullptr, 100.0f},
847
  {SettingInfo::Type::Integer, "LargeMotorVibrationBias",
848
   TRANSLATE_NOOP("AnalogController", "Large Motor Vibration Bias"),
849
   TRANSLATE_NOOP("AnalogController",
850
                  "Sets the bias value for the large vibration motor. If vibration in some games is too weak or not "
851
                  "functioning, try increasing this value. Negative values will decrease the intensity of vibration."),
852
   "8", "-255", "255", "1", "%d", nullptr, 1.0f},
853
  {SettingInfo::Type::Integer, "SmallMotorVibrationBias",
854
   TRANSLATE_NOOP("AnalogController", "Small Motor Vibration Bias"),
855
   TRANSLATE_NOOP("AnalogController",
856
                  "Sets the bias value for the small vibration motor. If vibration in some games is too weak or not "
857
                  "functioning, try increasing this value. Negative values will decrease the intensity of vibration."),
858
   "8", "-255", "255", "1", "%d", nullptr, 1.0f},
859
  {SettingInfo::Type::IntegerList, "InvertLeftStick", TRANSLATE_NOOP("AnalogController", "Invert Left Stick"),
860
   TRANSLATE_NOOP("AnalogController", "Inverts the direction of the left analog stick."), "0", "0", "3", nullptr,
861
   nullptr, s_invert_settings, 0.0f},
862
  {SettingInfo::Type::IntegerList, "InvertRightStick", TRANSLATE_NOOP("AnalogController", "Invert Right Stick"),
863
   TRANSLATE_NOOP("AnalogController", "Inverts the direction of the right analog stick."), "0", "0", "3", nullptr,
864
   nullptr, s_invert_settings, 0.0f},
865
};
866

867
const Controller::ControllerInfo AnalogController::INFO = {ControllerType::AnalogController,
868
                                                           "AnalogController",
869
                                                           TRANSLATE_NOOP("ControllerType", "Analog Controller"),
870
                                                           ICON_PF_GAMEPAD_ALT,
871
                                                           s_binding_info,
872
                                                           s_settings};
873

874
void AnalogController::LoadSettings(const SettingsInterface& si, const char* section, bool initial)
875
{
876
  Controller::LoadSettings(si, section, initial);
877
  m_force_analog_on_reset = si.GetBoolValue(section, "ForceAnalogOnReset", true);
878
  m_analog_dpad_in_digital_mode = si.GetBoolValue(section, "AnalogDPadInDigitalMode", true);
879
  m_analog_shoulder_buttons = static_cast<u8>(si.GetUIntValue(section, "AnalogShoulderButtons", 0u));
880
  m_analog_deadzone = std::clamp(si.GetFloatValue(section, "AnalogDeadzone", DEFAULT_STICK_DEADZONE), 0.0f, 1.0f);
881
  m_analog_sensitivity =
882
    std::clamp(si.GetFloatValue(section, "AnalogSensitivity", DEFAULT_STICK_SENSITIVITY), 0.01f, 3.0f);
883
  m_button_deadzone = std::clamp(si.GetFloatValue(section, "ButtonDeadzone", DEFAULT_BUTTON_DEADZONE), 0.01f, 1.0f);
884
  m_vibration_bias[0] = static_cast<s16>(
885
    std::clamp(si.GetIntValue(section, "LargeMotorVibrationBias", DEFAULT_LARGE_MOTOR_VIBRATION_BIAS), -255, 255));
886
  m_vibration_bias[1] = static_cast<s16>(
887
    std::clamp(si.GetIntValue(section, "SmallMotorVibrationBias", DEFAULT_SMALL_MOTOR_VIBRATION_BIAS), -255, 255));
888
  m_invert_left_stick = static_cast<u8>(si.GetUIntValue(section, "InvertLeftStick", 0u));
889
  m_invert_right_stick = static_cast<u8>(si.GetUIntValue(section, "InvertRightStick", 0u));
890
}
891

892