MPG/src/GamepadDescriptors.cpp at 8e12bb893a75d4550e20e98466f6cb03ff2af838 · OpenStickFoundation/MPG · GitHub

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
#include "GamepadDescriptors.h"

static uint16_t getConfigurationDescriptor(const uint8_t *buffer, InputMode mode)
{
	switch (mode)
	{
		case INPUT_MODE_XINPUT:
			buffer = xinput_configuration_descriptor;
			return sizeof(xinput_configuration_descriptor);

		case INPUT_MODE_SWITCH:
			buffer = switch_configuration_descriptor;
			return sizeof(switch_configuration_descriptor);

		case INPUT_MODE_MDMINI:
			buffer = mdmini_configuration_descriptor;
			return sizeof(mdmini_configuration_descriptor);

		default:
			buffer = hid_configuration_descriptor;
			return sizeof(hid_configuration_descriptor);
	}
}

static uint16_t getDeviceDescriptor(const uint8_t *buffer, InputMode mode)
{
	switch (mode)
	{
		case INPUT_MODE_XINPUT:
			buffer = xinput_device_descriptor;
			return sizeof(xinput_device_descriptor);

		case INPUT_MODE_SWITCH:
			buffer = switch_device_descriptor;
			return sizeof(switch_device_descriptor);

		case INPUT_MODE_MDMINI:
			buffer = mdmini_device_descriptor;
			return sizeof(mdmini_device_descriptor);

		default:
			buffer = hid_device_descriptor;
			return sizeof(hid_device_descriptor);
	}
}

static uint16_t getHIDDescriptor(const uint8_t *buffer, InputMode mode)
{
	switch (mode)
	{
		case INPUT_MODE_SWITCH:
			buffer = switch_hid_descriptor;
			return sizeof(switch_hid_descriptor);

		case INPUT_MODE_MDMINI:
			buffer = mdmini_hid_descriptor;
			return sizeof(mdmini_hid_descriptor);

		default:
			buffer = hid_hid_descriptor;
			return sizeof(hid_hid_descriptor);
	}
}

static uint16_t getHIDReport(const uint8_t *buffer, InputMode mode)
{
	switch (mode)
	{
		case INPUT_MODE_SWITCH:
			buffer = switch_report_descriptor;
			return sizeof(switch_report_descriptor);

		case INPUT_MODE_MDMINI:
			buffer = mdmini_report_descriptor;
			return sizeof(mdmini_report_descriptor);

		default:
			buffer = hid_report_descriptor;
			return sizeof(hid_report_descriptor);
	}
}

static uint16_t getStringDescriptor(const uint16_t *buffer, InputMode mode, uint8_t index)
{
	static uint8_t descriptorStringBuffer[64]; // Max 64 bytes

	const char *value;
	uint16_t size;
	uint8_t charCount;

	switch (mode)
	{
		case INPUT_MODE_XINPUT:
			value = (const char *)xinput_string_descriptors[index];
			size = sizeof(xinput_string_descriptors[index]);
			break;

		case INPUT_MODE_SWITCH:
			value = (const char *)switch_string_descriptors[index];
			size = sizeof(switch_string_descriptors[index]);
			break;

		case INPUT_MODE_MDMINI:
			value = (const char *)mdmini_string_descriptors[index];
			size = sizeof(mdmini_string_descriptors[index]);
			break;

		default:
			value = (const char *)hid_string_descriptors[index];
			size = sizeof(hid_string_descriptors[index]);
			break;
	}

	// Cap at max char
	charCount = strlen(value);
	if (charCount > 31)
		charCount = 31;

	for (uint8_t i = 0; i < charCount; i++)
		descriptorStringBuffer[1 + i] = value[i];


	// first byte is length (including header), second byte is string type
	descriptorStringBuffer[0] = (2 * charCount + 2);
	descriptorStringBuffer[1] = 0x03;

	// Cast temp buffer to final result
	buffer = (uint16_t *)descriptorStringBuffer;

	return size;
}