Commit | Line | Data |
---|---|---|
2af16c1f DO |
1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* | |
3 | * HID driver for Nintendo Switch Joy-Cons and Pro Controllers | |
4 | * | |
e93363f7 | 5 | * Copyright (c) 2019-2021 Daniel J. Ogorchock <djogorchock@gmail.com> |
94f18bb1 RM |
6 | * Portions Copyright (c) 2020 Nadia Holmquist Pedersen <nadia@nhp.sh> |
7 | * Copyright (c) 2022 Emily Strickland <linux@emily.st> | |
8 | * Copyright (c) 2023 Ryan McClelland <rymcclel@gmail.com> | |
2af16c1f DO |
9 | * |
10 | * The following resources/projects were referenced for this driver: | |
11 | * https://github.com/dekuNukem/Nintendo_Switch_Reverse_Engineering | |
12 | * https://gitlab.com/pjranki/joycon-linux-kernel (Peter Rankin) | |
13 | * https://github.com/FrotBot/SwitchProConLinuxUSB | |
14 | * https://github.com/MTCKC/ProconXInput | |
c4eae84f | 15 | * https://github.com/Davidobot/BetterJoyForCemu |
2af16c1f DO |
16 | * hid-wiimote kernel hid driver |
17 | * hid-logitech-hidpp driver | |
08ebba5c | 18 | * hid-sony driver |
2af16c1f DO |
19 | * |
20 | * This driver supports the Nintendo Switch Joy-Cons and Pro Controllers. The | |
21 | * Pro Controllers can either be used over USB or Bluetooth. | |
22 | * | |
94f18bb1 RM |
23 | * This driver also incorporates support for Nintendo Switch Online controllers |
24 | * for the NES, SNES, Sega Genesis, and N64. | |
25 | * | |
2af16c1f DO |
26 | * The driver will retrieve the factory calibration info from the controllers, |
27 | * so little to no user calibration should be required. | |
28 | * | |
29 | */ | |
30 | ||
31 | #include "hid-ids.h" | |
83d640c4 | 32 | #include <asm/unaligned.h> |
2af16c1f DO |
33 | #include <linux/delay.h> |
34 | #include <linux/device.h> | |
4ff5b108 | 35 | #include <linux/kernel.h> |
2af16c1f DO |
36 | #include <linux/hid.h> |
37 | #include <linux/input.h> | |
c4eae84f | 38 | #include <linux/jiffies.h> |
c5e62676 | 39 | #include <linux/leds.h> |
2af16c1f | 40 | #include <linux/module.h> |
08ebba5c | 41 | #include <linux/power_supply.h> |
2af16c1f DO |
42 | #include <linux/spinlock.h> |
43 | ||
44 | /* | |
45 | * Reference the url below for the following HID report defines: | |
46 | * https://github.com/dekuNukem/Nintendo_Switch_Reverse_Engineering | |
47 | */ | |
48 | ||
49 | /* Output Reports */ | |
daf11ca2 JK |
50 | #define JC_OUTPUT_RUMBLE_AND_SUBCMD 0x01 |
51 | #define JC_OUTPUT_FW_UPDATE_PKT 0x03 | |
52 | #define JC_OUTPUT_RUMBLE_ONLY 0x10 | |
53 | #define JC_OUTPUT_MCU_DATA 0x11 | |
54 | #define JC_OUTPUT_USB_CMD 0x80 | |
2af16c1f DO |
55 | |
56 | /* Subcommand IDs */ | |
daf11ca2 JK |
57 | #define JC_SUBCMD_STATE 0x00 |
58 | #define JC_SUBCMD_MANUAL_BT_PAIRING 0x01 | |
59 | #define JC_SUBCMD_REQ_DEV_INFO 0x02 | |
60 | #define JC_SUBCMD_SET_REPORT_MODE 0x03 | |
61 | #define JC_SUBCMD_TRIGGERS_ELAPSED 0x04 | |
62 | #define JC_SUBCMD_GET_PAGE_LIST_STATE 0x05 | |
63 | #define JC_SUBCMD_SET_HCI_STATE 0x06 | |
64 | #define JC_SUBCMD_RESET_PAIRING_INFO 0x07 | |
65 | #define JC_SUBCMD_LOW_POWER_MODE 0x08 | |
66 | #define JC_SUBCMD_SPI_FLASH_READ 0x10 | |
67 | #define JC_SUBCMD_SPI_FLASH_WRITE 0x11 | |
68 | #define JC_SUBCMD_RESET_MCU 0x20 | |
69 | #define JC_SUBCMD_SET_MCU_CONFIG 0x21 | |
70 | #define JC_SUBCMD_SET_MCU_STATE 0x22 | |
71 | #define JC_SUBCMD_SET_PLAYER_LIGHTS 0x30 | |
72 | #define JC_SUBCMD_GET_PLAYER_LIGHTS 0x31 | |
73 | #define JC_SUBCMD_SET_HOME_LIGHT 0x38 | |
74 | #define JC_SUBCMD_ENABLE_IMU 0x40 | |
75 | #define JC_SUBCMD_SET_IMU_SENSITIVITY 0x41 | |
76 | #define JC_SUBCMD_WRITE_IMU_REG 0x42 | |
77 | #define JC_SUBCMD_READ_IMU_REG 0x43 | |
78 | #define JC_SUBCMD_ENABLE_VIBRATION 0x48 | |
79 | #define JC_SUBCMD_GET_REGULATED_VOLTAGE 0x50 | |
2af16c1f DO |
80 | |
81 | /* Input Reports */ | |
daf11ca2 JK |
82 | #define JC_INPUT_BUTTON_EVENT 0x3F |
83 | #define JC_INPUT_SUBCMD_REPLY 0x21 | |
84 | #define JC_INPUT_IMU_DATA 0x30 | |
85 | #define JC_INPUT_MCU_DATA 0x31 | |
86 | #define JC_INPUT_USB_RESPONSE 0x81 | |
2af16c1f DO |
87 | |
88 | /* Feature Reports */ | |
daf11ca2 JK |
89 | #define JC_FEATURE_LAST_SUBCMD 0x02 |
90 | #define JC_FEATURE_OTA_FW_UPGRADE 0x70 | |
91 | #define JC_FEATURE_SETUP_MEM_READ 0x71 | |
92 | #define JC_FEATURE_MEM_READ 0x72 | |
93 | #define JC_FEATURE_ERASE_MEM_SECTOR 0x73 | |
94 | #define JC_FEATURE_MEM_WRITE 0x74 | |
95 | #define JC_FEATURE_LAUNCH 0x75 | |
2af16c1f DO |
96 | |
97 | /* USB Commands */ | |
daf11ca2 JK |
98 | #define JC_USB_CMD_CONN_STATUS 0x01 |
99 | #define JC_USB_CMD_HANDSHAKE 0x02 | |
100 | #define JC_USB_CMD_BAUDRATE_3M 0x03 | |
101 | #define JC_USB_CMD_NO_TIMEOUT 0x04 | |
102 | #define JC_USB_CMD_EN_TIMEOUT 0x05 | |
103 | #define JC_USB_RESET 0x06 | |
104 | #define JC_USB_PRE_HANDSHAKE 0x91 | |
105 | #define JC_USB_SEND_UART 0x92 | |
2af16c1f | 106 | |
83d640c4 | 107 | /* Magic value denoting presence of user calibration */ |
daf11ca2 JK |
108 | #define JC_CAL_USR_MAGIC_0 0xB2 |
109 | #define JC_CAL_USR_MAGIC_1 0xA1 | |
110 | #define JC_CAL_USR_MAGIC_SIZE 2 | |
83d640c4 DO |
111 | |
112 | /* SPI storage addresses of user calibration data */ | |
daf11ca2 JK |
113 | #define JC_CAL_USR_LEFT_MAGIC_ADDR 0x8010 |
114 | #define JC_CAL_USR_LEFT_DATA_ADDR 0x8012 | |
115 | #define JC_CAL_USR_LEFT_DATA_END 0x801A | |
116 | #define JC_CAL_USR_RIGHT_MAGIC_ADDR 0x801B | |
117 | #define JC_CAL_USR_RIGHT_DATA_ADDR 0x801D | |
83d640c4 DO |
118 | #define JC_CAL_STICK_DATA_SIZE \ |
119 | (JC_CAL_USR_LEFT_DATA_END - JC_CAL_USR_LEFT_DATA_ADDR + 1) | |
2af16c1f | 120 | |
83d640c4 | 121 | /* SPI storage addresses of factory calibration data */ |
daf11ca2 JK |
122 | #define JC_CAL_FCT_DATA_LEFT_ADDR 0x603d |
123 | #define JC_CAL_FCT_DATA_RIGHT_ADDR 0x6046 | |
2af16c1f | 124 | |
4ff5b108 | 125 | /* SPI storage addresses of IMU factory calibration data */ |
daf11ca2 JK |
126 | #define JC_IMU_CAL_FCT_DATA_ADDR 0x6020 |
127 | #define JC_IMU_CAL_FCT_DATA_END 0x6037 | |
4ff5b108 DO |
128 | #define JC_IMU_CAL_DATA_SIZE \ |
129 | (JC_IMU_CAL_FCT_DATA_END - JC_IMU_CAL_FCT_DATA_ADDR + 1) | |
130 | /* SPI storage addresses of IMU user calibration data */ | |
daf11ca2 JK |
131 | #define JC_IMU_CAL_USR_MAGIC_ADDR 0x8026 |
132 | #define JC_IMU_CAL_USR_DATA_ADDR 0x8028 | |
4ff5b108 | 133 | |
2af16c1f | 134 | /* The raw analog joystick values will be mapped in terms of this magnitude */ |
daf11ca2 JK |
135 | #define JC_MAX_STICK_MAG 32767 |
136 | #define JC_STICK_FUZZ 250 | |
137 | #define JC_STICK_FLAT 500 | |
2af16c1f DO |
138 | |
139 | /* Hat values for pro controller's d-pad */ | |
daf11ca2 JK |
140 | #define JC_MAX_DPAD_MAG 1 |
141 | #define JC_DPAD_FUZZ 0 | |
142 | #define JC_DPAD_FLAT 0 | |
2af16c1f | 143 | |
4ff5b108 | 144 | /* Under most circumstances IMU reports are pushed every 15ms; use as default */ |
daf11ca2 | 145 | #define JC_IMU_DFLT_AVG_DELTA_MS 15 |
4ff5b108 | 146 | /* How many samples to sum before calculating average IMU report delta */ |
daf11ca2 | 147 | #define JC_IMU_SAMPLES_PER_DELTA_AVG 300 |
4ff5b108 | 148 | /* Controls how many dropped IMU packets at once trigger a warning message */ |
daf11ca2 | 149 | #define JC_IMU_DROPPED_PKT_WARNING 3 |
4ff5b108 DO |
150 | |
151 | /* | |
152 | * The controller's accelerometer has a sensor resolution of 16bits and is | |
153 | * configured with a range of +-8000 milliGs. Therefore, the resolution can be | |
154 | * calculated thus: (2^16-1)/(8000 * 2) = 4.096 digits per milliG | |
155 | * Resolution per G (rather than per millliG): 4.096 * 1000 = 4096 digits per G | |
156 | * Alternatively: 1/4096 = .0002441 Gs per digit | |
157 | */ | |
daf11ca2 JK |
158 | #define JC_IMU_MAX_ACCEL_MAG 32767 |
159 | #define JC_IMU_ACCEL_RES_PER_G 4096 | |
160 | #define JC_IMU_ACCEL_FUZZ 10 | |
161 | #define JC_IMU_ACCEL_FLAT 0 | |
4ff5b108 DO |
162 | |
163 | /* | |
164 | * The controller's gyroscope has a sensor resolution of 16bits and is | |
165 | * configured with a range of +-2000 degrees/second. | |
166 | * Digits per dps: (2^16 -1)/(2000*2) = 16.38375 | |
167 | * dps per digit: 16.38375E-1 = .0610 | |
168 | * | |
169 | * STMicro recommends in the datasheet to add 15% to the dps/digit. This allows | |
170 | * the full sensitivity range to be saturated without clipping. This yields more | |
171 | * accurate results, so it's the technique this driver uses. | |
172 | * dps per digit (corrected): .0610 * 1.15 = .0702 | |
173 | * digits per dps (corrected): .0702E-1 = 14.247 | |
174 | * | |
175 | * Now, 14.247 truncating to 14 loses a lot of precision, so we rescale the | |
176 | * min/max range by 1000. | |
177 | */ | |
daf11ca2 | 178 | #define JC_IMU_PREC_RANGE_SCALE 1000 |
4ff5b108 | 179 | /* Note: change mag and res_per_dps if prec_range_scale is ever altered */ |
daf11ca2 JK |
180 | #define JC_IMU_MAX_GYRO_MAG 32767000 /* (2^16-1)*1000 */ |
181 | #define JC_IMU_GYRO_RES_PER_DPS 14247 /* (14.247*1000) */ | |
182 | #define JC_IMU_GYRO_FUZZ 10 | |
183 | #define JC_IMU_GYRO_FLAT 0 | |
4ff5b108 | 184 | |
c4eae84f DO |
185 | /* frequency/amplitude tables for rumble */ |
186 | struct joycon_rumble_freq_data { | |
187 | u16 high; | |
188 | u8 low; | |
189 | u16 freq; /* Hz*/ | |
190 | }; | |
191 | ||
192 | struct joycon_rumble_amp_data { | |
193 | u8 high; | |
194 | u16 low; | |
195 | u16 amp; | |
196 | }; | |
197 | ||
f61e0639 | 198 | #if IS_ENABLED(CONFIG_NINTENDO_FF) |
c4eae84f DO |
199 | /* |
200 | * These tables are from | |
201 | * https://github.com/dekuNukem/Nintendo_Switch_Reverse_Engineering/blob/master/rumble_data_table.md | |
202 | */ | |
203 | static const struct joycon_rumble_freq_data joycon_rumble_frequencies[] = { | |
204 | /* high, low, freq */ | |
205 | { 0x0000, 0x01, 41 }, { 0x0000, 0x02, 42 }, { 0x0000, 0x03, 43 }, | |
206 | { 0x0000, 0x04, 44 }, { 0x0000, 0x05, 45 }, { 0x0000, 0x06, 46 }, | |
207 | { 0x0000, 0x07, 47 }, { 0x0000, 0x08, 48 }, { 0x0000, 0x09, 49 }, | |
208 | { 0x0000, 0x0A, 50 }, { 0x0000, 0x0B, 51 }, { 0x0000, 0x0C, 52 }, | |
209 | { 0x0000, 0x0D, 53 }, { 0x0000, 0x0E, 54 }, { 0x0000, 0x0F, 55 }, | |
210 | { 0x0000, 0x10, 57 }, { 0x0000, 0x11, 58 }, { 0x0000, 0x12, 59 }, | |
211 | { 0x0000, 0x13, 60 }, { 0x0000, 0x14, 62 }, { 0x0000, 0x15, 63 }, | |
212 | { 0x0000, 0x16, 64 }, { 0x0000, 0x17, 66 }, { 0x0000, 0x18, 67 }, | |
213 | { 0x0000, 0x19, 69 }, { 0x0000, 0x1A, 70 }, { 0x0000, 0x1B, 72 }, | |
214 | { 0x0000, 0x1C, 73 }, { 0x0000, 0x1D, 75 }, { 0x0000, 0x1e, 77 }, | |
215 | { 0x0000, 0x1f, 78 }, { 0x0000, 0x20, 80 }, { 0x0400, 0x21, 82 }, | |
216 | { 0x0800, 0x22, 84 }, { 0x0c00, 0x23, 85 }, { 0x1000, 0x24, 87 }, | |
217 | { 0x1400, 0x25, 89 }, { 0x1800, 0x26, 91 }, { 0x1c00, 0x27, 93 }, | |
218 | { 0x2000, 0x28, 95 }, { 0x2400, 0x29, 97 }, { 0x2800, 0x2a, 99 }, | |
219 | { 0x2c00, 0x2b, 102 }, { 0x3000, 0x2c, 104 }, { 0x3400, 0x2d, 106 }, | |
220 | { 0x3800, 0x2e, 108 }, { 0x3c00, 0x2f, 111 }, { 0x4000, 0x30, 113 }, | |
221 | { 0x4400, 0x31, 116 }, { 0x4800, 0x32, 118 }, { 0x4c00, 0x33, 121 }, | |
222 | { 0x5000, 0x34, 123 }, { 0x5400, 0x35, 126 }, { 0x5800, 0x36, 129 }, | |
223 | { 0x5c00, 0x37, 132 }, { 0x6000, 0x38, 135 }, { 0x6400, 0x39, 137 }, | |
224 | { 0x6800, 0x3a, 141 }, { 0x6c00, 0x3b, 144 }, { 0x7000, 0x3c, 147 }, | |
225 | { 0x7400, 0x3d, 150 }, { 0x7800, 0x3e, 153 }, { 0x7c00, 0x3f, 157 }, | |
226 | { 0x8000, 0x40, 160 }, { 0x8400, 0x41, 164 }, { 0x8800, 0x42, 167 }, | |
227 | { 0x8c00, 0x43, 171 }, { 0x9000, 0x44, 174 }, { 0x9400, 0x45, 178 }, | |
228 | { 0x9800, 0x46, 182 }, { 0x9c00, 0x47, 186 }, { 0xa000, 0x48, 190 }, | |
229 | { 0xa400, 0x49, 194 }, { 0xa800, 0x4a, 199 }, { 0xac00, 0x4b, 203 }, | |
230 | { 0xb000, 0x4c, 207 }, { 0xb400, 0x4d, 212 }, { 0xb800, 0x4e, 217 }, | |
231 | { 0xbc00, 0x4f, 221 }, { 0xc000, 0x50, 226 }, { 0xc400, 0x51, 231 }, | |
232 | { 0xc800, 0x52, 236 }, { 0xcc00, 0x53, 241 }, { 0xd000, 0x54, 247 }, | |
233 | { 0xd400, 0x55, 252 }, { 0xd800, 0x56, 258 }, { 0xdc00, 0x57, 263 }, | |
234 | { 0xe000, 0x58, 269 }, { 0xe400, 0x59, 275 }, { 0xe800, 0x5a, 281 }, | |
235 | { 0xec00, 0x5b, 287 }, { 0xf000, 0x5c, 293 }, { 0xf400, 0x5d, 300 }, | |
236 | { 0xf800, 0x5e, 306 }, { 0xfc00, 0x5f, 313 }, { 0x0001, 0x60, 320 }, | |
237 | { 0x0401, 0x61, 327 }, { 0x0801, 0x62, 334 }, { 0x0c01, 0x63, 341 }, | |
238 | { 0x1001, 0x64, 349 }, { 0x1401, 0x65, 357 }, { 0x1801, 0x66, 364 }, | |
239 | { 0x1c01, 0x67, 372 }, { 0x2001, 0x68, 381 }, { 0x2401, 0x69, 389 }, | |
240 | { 0x2801, 0x6a, 397 }, { 0x2c01, 0x6b, 406 }, { 0x3001, 0x6c, 415 }, | |
241 | { 0x3401, 0x6d, 424 }, { 0x3801, 0x6e, 433 }, { 0x3c01, 0x6f, 443 }, | |
242 | { 0x4001, 0x70, 453 }, { 0x4401, 0x71, 462 }, { 0x4801, 0x72, 473 }, | |
243 | { 0x4c01, 0x73, 483 }, { 0x5001, 0x74, 494 }, { 0x5401, 0x75, 504 }, | |
244 | { 0x5801, 0x76, 515 }, { 0x5c01, 0x77, 527 }, { 0x6001, 0x78, 538 }, | |
245 | { 0x6401, 0x79, 550 }, { 0x6801, 0x7a, 562 }, { 0x6c01, 0x7b, 574 }, | |
246 | { 0x7001, 0x7c, 587 }, { 0x7401, 0x7d, 600 }, { 0x7801, 0x7e, 613 }, | |
247 | { 0x7c01, 0x7f, 626 }, { 0x8001, 0x00, 640 }, { 0x8401, 0x00, 654 }, | |
248 | { 0x8801, 0x00, 668 }, { 0x8c01, 0x00, 683 }, { 0x9001, 0x00, 698 }, | |
249 | { 0x9401, 0x00, 713 }, { 0x9801, 0x00, 729 }, { 0x9c01, 0x00, 745 }, | |
250 | { 0xa001, 0x00, 761 }, { 0xa401, 0x00, 778 }, { 0xa801, 0x00, 795 }, | |
251 | { 0xac01, 0x00, 812 }, { 0xb001, 0x00, 830 }, { 0xb401, 0x00, 848 }, | |
252 | { 0xb801, 0x00, 867 }, { 0xbc01, 0x00, 886 }, { 0xc001, 0x00, 905 }, | |
253 | { 0xc401, 0x00, 925 }, { 0xc801, 0x00, 945 }, { 0xcc01, 0x00, 966 }, | |
254 | { 0xd001, 0x00, 987 }, { 0xd401, 0x00, 1009 }, { 0xd801, 0x00, 1031 }, | |
255 | { 0xdc01, 0x00, 1053 }, { 0xe001, 0x00, 1076 }, { 0xe401, 0x00, 1100 }, | |
256 | { 0xe801, 0x00, 1124 }, { 0xec01, 0x00, 1149 }, { 0xf001, 0x00, 1174 }, | |
257 | { 0xf401, 0x00, 1199 }, { 0xf801, 0x00, 1226 }, { 0xfc01, 0x00, 1253 } | |
258 | }; | |
259 | ||
260 | #define joycon_max_rumble_amp (1003) | |
261 | static const struct joycon_rumble_amp_data joycon_rumble_amplitudes[] = { | |
262 | /* high, low, amp */ | |
263 | { 0x00, 0x0040, 0 }, | |
264 | { 0x02, 0x8040, 10 }, { 0x04, 0x0041, 12 }, { 0x06, 0x8041, 14 }, | |
265 | { 0x08, 0x0042, 17 }, { 0x0a, 0x8042, 20 }, { 0x0c, 0x0043, 24 }, | |
266 | { 0x0e, 0x8043, 28 }, { 0x10, 0x0044, 33 }, { 0x12, 0x8044, 40 }, | |
267 | { 0x14, 0x0045, 47 }, { 0x16, 0x8045, 56 }, { 0x18, 0x0046, 67 }, | |
268 | { 0x1a, 0x8046, 80 }, { 0x1c, 0x0047, 95 }, { 0x1e, 0x8047, 112 }, | |
269 | { 0x20, 0x0048, 117 }, { 0x22, 0x8048, 123 }, { 0x24, 0x0049, 128 }, | |
270 | { 0x26, 0x8049, 134 }, { 0x28, 0x004a, 140 }, { 0x2a, 0x804a, 146 }, | |
271 | { 0x2c, 0x004b, 152 }, { 0x2e, 0x804b, 159 }, { 0x30, 0x004c, 166 }, | |
272 | { 0x32, 0x804c, 173 }, { 0x34, 0x004d, 181 }, { 0x36, 0x804d, 189 }, | |
273 | { 0x38, 0x004e, 198 }, { 0x3a, 0x804e, 206 }, { 0x3c, 0x004f, 215 }, | |
274 | { 0x3e, 0x804f, 225 }, { 0x40, 0x0050, 230 }, { 0x42, 0x8050, 235 }, | |
275 | { 0x44, 0x0051, 240 }, { 0x46, 0x8051, 245 }, { 0x48, 0x0052, 251 }, | |
276 | { 0x4a, 0x8052, 256 }, { 0x4c, 0x0053, 262 }, { 0x4e, 0x8053, 268 }, | |
277 | { 0x50, 0x0054, 273 }, { 0x52, 0x8054, 279 }, { 0x54, 0x0055, 286 }, | |
278 | { 0x56, 0x8055, 292 }, { 0x58, 0x0056, 298 }, { 0x5a, 0x8056, 305 }, | |
279 | { 0x5c, 0x0057, 311 }, { 0x5e, 0x8057, 318 }, { 0x60, 0x0058, 325 }, | |
280 | { 0x62, 0x8058, 332 }, { 0x64, 0x0059, 340 }, { 0x66, 0x8059, 347 }, | |
281 | { 0x68, 0x005a, 355 }, { 0x6a, 0x805a, 362 }, { 0x6c, 0x005b, 370 }, | |
282 | { 0x6e, 0x805b, 378 }, { 0x70, 0x005c, 387 }, { 0x72, 0x805c, 395 }, | |
283 | { 0x74, 0x005d, 404 }, { 0x76, 0x805d, 413 }, { 0x78, 0x005e, 422 }, | |
284 | { 0x7a, 0x805e, 431 }, { 0x7c, 0x005f, 440 }, { 0x7e, 0x805f, 450 }, | |
285 | { 0x80, 0x0060, 460 }, { 0x82, 0x8060, 470 }, { 0x84, 0x0061, 480 }, | |
286 | { 0x86, 0x8061, 491 }, { 0x88, 0x0062, 501 }, { 0x8a, 0x8062, 512 }, | |
287 | { 0x8c, 0x0063, 524 }, { 0x8e, 0x8063, 535 }, { 0x90, 0x0064, 547 }, | |
288 | { 0x92, 0x8064, 559 }, { 0x94, 0x0065, 571 }, { 0x96, 0x8065, 584 }, | |
289 | { 0x98, 0x0066, 596 }, { 0x9a, 0x8066, 609 }, { 0x9c, 0x0067, 623 }, | |
290 | { 0x9e, 0x8067, 636 }, { 0xa0, 0x0068, 650 }, { 0xa2, 0x8068, 665 }, | |
291 | { 0xa4, 0x0069, 679 }, { 0xa6, 0x8069, 694 }, { 0xa8, 0x006a, 709 }, | |
292 | { 0xaa, 0x806a, 725 }, { 0xac, 0x006b, 741 }, { 0xae, 0x806b, 757 }, | |
293 | { 0xb0, 0x006c, 773 }, { 0xb2, 0x806c, 790 }, { 0xb4, 0x006d, 808 }, | |
294 | { 0xb6, 0x806d, 825 }, { 0xb8, 0x006e, 843 }, { 0xba, 0x806e, 862 }, | |
295 | { 0xbc, 0x006f, 881 }, { 0xbe, 0x806f, 900 }, { 0xc0, 0x0070, 920 }, | |
296 | { 0xc2, 0x8070, 940 }, { 0xc4, 0x0071, 960 }, { 0xc6, 0x8071, 981 }, | |
297 | { 0xc8, 0x0072, joycon_max_rumble_amp } | |
298 | }; | |
f61e0639 JK |
299 | static const u16 JC_RUMBLE_DFLT_LOW_FREQ = 160; |
300 | static const u16 JC_RUMBLE_DFLT_HIGH_FREQ = 320; | |
92cdfba4 | 301 | static const unsigned short JC_RUMBLE_ZERO_AMP_PKT_CNT = 5; |
f61e0639 JK |
302 | #endif /* IS_ENABLED(CONFIG_NINTENDO_FF) */ |
303 | static const u16 JC_RUMBLE_PERIOD_MS = 50; | |
c4eae84f | 304 | |
2af16c1f DO |
305 | /* States for controller state machine */ |
306 | enum joycon_ctlr_state { | |
307 | JOYCON_CTLR_STATE_INIT, | |
308 | JOYCON_CTLR_STATE_READ, | |
012bd52c | 309 | JOYCON_CTLR_STATE_REMOVED, |
2af16c1f DO |
310 | }; |
311 | ||
294a8287 DO |
312 | /* Controller type received as part of device info */ |
313 | enum joycon_ctlr_type { | |
94f18bb1 RM |
314 | JOYCON_CTLR_TYPE_JCL = 0x01, |
315 | JOYCON_CTLR_TYPE_JCR = 0x02, | |
316 | JOYCON_CTLR_TYPE_PRO = 0x03, | |
317 | JOYCON_CTLR_TYPE_NESL = 0x09, | |
318 | JOYCON_CTLR_TYPE_NESR = 0x0A, | |
319 | JOYCON_CTLR_TYPE_SNES = 0x0B, | |
320 | JOYCON_CTLR_TYPE_GEN = 0x0D, | |
321 | JOYCON_CTLR_TYPE_N64 = 0x0C, | |
294a8287 DO |
322 | }; |
323 | ||
2af16c1f DO |
324 | struct joycon_stick_cal { |
325 | s32 max; | |
326 | s32 min; | |
327 | s32 center; | |
328 | }; | |
329 | ||
4ff5b108 DO |
330 | struct joycon_imu_cal { |
331 | s16 offset[3]; | |
332 | s16 scale[3]; | |
333 | }; | |
334 | ||
2af16c1f DO |
335 | /* |
336 | * All the controller's button values are stored in a u32. | |
337 | * They can be accessed with bitwise ANDs. | |
338 | */ | |
0b7dd38c RM |
339 | #define JC_BTN_Y BIT(0) |
340 | #define JC_BTN_X BIT(1) | |
341 | #define JC_BTN_B BIT(2) | |
342 | #define JC_BTN_A BIT(3) | |
343 | #define JC_BTN_SR_R BIT(4) | |
344 | #define JC_BTN_SL_R BIT(5) | |
345 | #define JC_BTN_R BIT(6) | |
346 | #define JC_BTN_ZR BIT(7) | |
347 | #define JC_BTN_MINUS BIT(8) | |
348 | #define JC_BTN_PLUS BIT(9) | |
349 | #define JC_BTN_RSTICK BIT(10) | |
350 | #define JC_BTN_LSTICK BIT(11) | |
351 | #define JC_BTN_HOME BIT(12) | |
352 | #define JC_BTN_CAP BIT(13) /* capture button */ | |
353 | #define JC_BTN_DOWN BIT(16) | |
354 | #define JC_BTN_UP BIT(17) | |
355 | #define JC_BTN_RIGHT BIT(18) | |
356 | #define JC_BTN_LEFT BIT(19) | |
357 | #define JC_BTN_SR_L BIT(20) | |
358 | #define JC_BTN_SL_L BIT(21) | |
359 | #define JC_BTN_L BIT(22) | |
360 | #define JC_BTN_ZL BIT(23) | |
2af16c1f | 361 | |
94f18bb1 RM |
362 | struct joycon_ctlr_button_mapping { |
363 | u32 code; | |
364 | u32 bit; | |
365 | }; | |
366 | ||
367 | /* | |
368 | * D-pad is configured as buttons for the left Joy-Con only! | |
369 | */ | |
370 | static const struct joycon_ctlr_button_mapping left_joycon_button_mappings[] = { | |
371 | { BTN_TL, JC_BTN_L, }, | |
372 | { BTN_TL2, JC_BTN_ZL, }, | |
373 | { BTN_SELECT, JC_BTN_MINUS, }, | |
374 | { BTN_THUMBL, JC_BTN_LSTICK, }, | |
375 | { BTN_DPAD_UP, JC_BTN_UP, }, | |
376 | { BTN_DPAD_DOWN, JC_BTN_DOWN, }, | |
377 | { BTN_DPAD_LEFT, JC_BTN_LEFT, }, | |
378 | { BTN_DPAD_RIGHT, JC_BTN_RIGHT, }, | |
379 | { BTN_Z, JC_BTN_CAP, }, | |
380 | { /* sentinel */ }, | |
381 | }; | |
382 | ||
383 | /* | |
384 | * The unused *right*-side triggers become the SL/SR triggers for the *left* | |
385 | * Joy-Con, if and only if we're not using a charging grip. | |
386 | */ | |
387 | static const struct joycon_ctlr_button_mapping left_joycon_s_button_mappings[] = { | |
388 | { BTN_TR, JC_BTN_SL_L, }, | |
389 | { BTN_TR2, JC_BTN_SR_L, }, | |
390 | { /* sentinel */ }, | |
391 | }; | |
392 | ||
393 | static const struct joycon_ctlr_button_mapping right_joycon_button_mappings[] = { | |
394 | { BTN_EAST, JC_BTN_A, }, | |
395 | { BTN_SOUTH, JC_BTN_B, }, | |
396 | { BTN_NORTH, JC_BTN_X, }, | |
397 | { BTN_WEST, JC_BTN_Y, }, | |
398 | { BTN_TR, JC_BTN_R, }, | |
399 | { BTN_TR2, JC_BTN_ZR, }, | |
400 | { BTN_START, JC_BTN_PLUS, }, | |
401 | { BTN_THUMBR, JC_BTN_RSTICK, }, | |
402 | { BTN_MODE, JC_BTN_HOME, }, | |
403 | { /* sentinel */ }, | |
404 | }; | |
405 | ||
406 | /* | |
407 | * The unused *left*-side triggers become the SL/SR triggers for the *right* | |
408 | * Joy-Con, if and only if we're not using a charging grip. | |
409 | */ | |
410 | static const struct joycon_ctlr_button_mapping right_joycon_s_button_mappings[] = { | |
411 | { BTN_TL, JC_BTN_SL_R, }, | |
412 | { BTN_TL2, JC_BTN_SR_R, }, | |
413 | { /* sentinel */ }, | |
414 | }; | |
415 | ||
416 | static const struct joycon_ctlr_button_mapping procon_button_mappings[] = { | |
417 | { BTN_EAST, JC_BTN_A, }, | |
418 | { BTN_SOUTH, JC_BTN_B, }, | |
419 | { BTN_NORTH, JC_BTN_X, }, | |
420 | { BTN_WEST, JC_BTN_Y, }, | |
421 | { BTN_TL, JC_BTN_L, }, | |
422 | { BTN_TR, JC_BTN_R, }, | |
423 | { BTN_TL2, JC_BTN_ZL, }, | |
424 | { BTN_TR2, JC_BTN_ZR, }, | |
425 | { BTN_SELECT, JC_BTN_MINUS, }, | |
426 | { BTN_START, JC_BTN_PLUS, }, | |
427 | { BTN_THUMBL, JC_BTN_LSTICK, }, | |
428 | { BTN_THUMBR, JC_BTN_RSTICK, }, | |
429 | { BTN_MODE, JC_BTN_HOME, }, | |
430 | { BTN_Z, JC_BTN_CAP, }, | |
431 | { /* sentinel */ }, | |
432 | }; | |
433 | ||
434 | static const struct joycon_ctlr_button_mapping nescon_button_mappings[] = { | |
435 | { BTN_SOUTH, JC_BTN_A, }, | |
436 | { BTN_EAST, JC_BTN_B, }, | |
437 | { BTN_TL, JC_BTN_L, }, | |
438 | { BTN_TR, JC_BTN_R, }, | |
439 | { BTN_SELECT, JC_BTN_MINUS, }, | |
440 | { BTN_START, JC_BTN_PLUS, }, | |
441 | { /* sentinel */ }, | |
442 | }; | |
443 | ||
444 | static const struct joycon_ctlr_button_mapping snescon_button_mappings[] = { | |
445 | { BTN_EAST, JC_BTN_A, }, | |
446 | { BTN_SOUTH, JC_BTN_B, }, | |
447 | { BTN_NORTH, JC_BTN_X, }, | |
448 | { BTN_WEST, JC_BTN_Y, }, | |
449 | { BTN_TL, JC_BTN_L, }, | |
450 | { BTN_TR, JC_BTN_R, }, | |
451 | { BTN_TL2, JC_BTN_ZL, }, | |
452 | { BTN_TR2, JC_BTN_ZR, }, | |
453 | { BTN_SELECT, JC_BTN_MINUS, }, | |
454 | { BTN_START, JC_BTN_PLUS, }, | |
455 | { /* sentinel */ }, | |
456 | }; | |
457 | ||
458 | /* | |
459 | * "A", "B", and "C" are mapped positionally, rather than by label (e.g., "A" | |
460 | * gets assigned to BTN_EAST instead of BTN_A). | |
461 | */ | |
462 | static const struct joycon_ctlr_button_mapping gencon_button_mappings[] = { | |
463 | { BTN_SOUTH, JC_BTN_A, }, | |
464 | { BTN_EAST, JC_BTN_B, }, | |
465 | { BTN_WEST, JC_BTN_R, }, | |
466 | { BTN_SELECT, JC_BTN_ZR, }, | |
467 | { BTN_START, JC_BTN_PLUS, }, | |
468 | { BTN_MODE, JC_BTN_HOME, }, | |
469 | { BTN_Z, JC_BTN_CAP, }, | |
470 | { /* sentinel */ }, | |
471 | }; | |
472 | ||
473 | /* | |
474 | * N64's C buttons get assigned to d-pad directions and registered as buttons. | |
475 | */ | |
476 | static const struct joycon_ctlr_button_mapping n64con_button_mappings[] = { | |
477 | { BTN_A, JC_BTN_A, }, | |
478 | { BTN_B, JC_BTN_B, }, | |
479 | { BTN_TL2, JC_BTN_ZL, }, /* Z */ | |
480 | { BTN_TL, JC_BTN_L, }, | |
481 | { BTN_TR, JC_BTN_R, }, | |
482 | { BTN_TR2, JC_BTN_LSTICK, }, /* ZR */ | |
483 | { BTN_START, JC_BTN_PLUS, }, | |
484 | { BTN_FORWARD, JC_BTN_Y, }, /* C UP */ | |
485 | { BTN_BACK, JC_BTN_ZR, }, /* C DOWN */ | |
486 | { BTN_LEFT, JC_BTN_X, }, /* C LEFT */ | |
487 | { BTN_RIGHT, JC_BTN_MINUS, }, /* C RIGHT */ | |
488 | { BTN_MODE, JC_BTN_HOME, }, | |
489 | { BTN_Z, JC_BTN_CAP, }, | |
490 | { /* sentinel */ }, | |
491 | }; | |
492 | ||
2af16c1f DO |
493 | enum joycon_msg_type { |
494 | JOYCON_MSG_TYPE_NONE, | |
495 | JOYCON_MSG_TYPE_USB, | |
496 | JOYCON_MSG_TYPE_SUBCMD, | |
497 | }; | |
498 | ||
4c048f6b DO |
499 | struct joycon_rumble_output { |
500 | u8 output_id; | |
501 | u8 packet_num; | |
502 | u8 rumble_data[8]; | |
503 | } __packed; | |
504 | ||
2af16c1f DO |
505 | struct joycon_subcmd_request { |
506 | u8 output_id; /* must be 0x01 for subcommand, 0x10 for rumble only */ | |
507 | u8 packet_num; /* incremented every send */ | |
508 | u8 rumble_data[8]; | |
509 | u8 subcmd_id; | |
510 | u8 data[]; /* length depends on the subcommand */ | |
511 | } __packed; | |
512 | ||
513 | struct joycon_subcmd_reply { | |
514 | u8 ack; /* MSB 1 for ACK, 0 for NACK */ | |
515 | u8 id; /* id of requested subcmd */ | |
516 | u8 data[]; /* will be at most 35 bytes */ | |
517 | } __packed; | |
518 | ||
4ff5b108 DO |
519 | struct joycon_imu_data { |
520 | s16 accel_x; | |
521 | s16 accel_y; | |
522 | s16 accel_z; | |
523 | s16 gyro_x; | |
524 | s16 gyro_y; | |
525 | s16 gyro_z; | |
526 | } __packed; | |
527 | ||
2af16c1f DO |
528 | struct joycon_input_report { |
529 | u8 id; | |
530 | u8 timer; | |
531 | u8 bat_con; /* battery and connection info */ | |
532 | u8 button_status[3]; | |
533 | u8 left_stick[3]; | |
534 | u8 right_stick[3]; | |
535 | u8 vibrator_report; | |
536 | ||
4ff5b108 DO |
537 | union { |
538 | struct joycon_subcmd_reply subcmd_reply; | |
539 | /* IMU input reports contain 3 samples */ | |
540 | u8 imu_raw_bytes[sizeof(struct joycon_imu_data) * 3]; | |
541 | }; | |
2af16c1f DO |
542 | } __packed; |
543 | ||
544 | #define JC_MAX_RESP_SIZE (sizeof(struct joycon_input_report) + 35) | |
c4eae84f DO |
545 | #define JC_RUMBLE_DATA_SIZE 8 |
546 | #define JC_RUMBLE_QUEUE_SIZE 8 | |
547 | ||
c5e62676 DO |
548 | static const char * const joycon_player_led_names[] = { |
549 | LED_FUNCTION_PLAYER1, | |
550 | LED_FUNCTION_PLAYER2, | |
551 | LED_FUNCTION_PLAYER3, | |
552 | LED_FUNCTION_PLAYER4, | |
553 | }; | |
554 | #define JC_NUM_LEDS ARRAY_SIZE(joycon_player_led_names) | |
92827607 MF |
555 | #define JC_NUM_LED_PATTERNS 8 |
556 | /* Taken from https://www.nintendo.com/my/support/qa/detail/33822 */ | |
557 | static const enum led_brightness joycon_player_led_patterns[JC_NUM_LED_PATTERNS][JC_NUM_LEDS] = { | |
558 | { 1, 0, 0, 0 }, | |
559 | { 1, 1, 0, 0 }, | |
560 | { 1, 1, 1, 0 }, | |
561 | { 1, 1, 1, 1 }, | |
562 | { 1, 0, 0, 1 }, | |
563 | { 1, 0, 1, 0 }, | |
564 | { 1, 0, 1, 1 }, | |
565 | { 0, 1, 1, 0 }, | |
566 | }; | |
c5e62676 | 567 | |
2af16c1f DO |
568 | /* Each physical controller is associated with a joycon_ctlr struct */ |
569 | struct joycon_ctlr { | |
570 | struct hid_device *hdev; | |
571 | struct input_dev *input; | |
697e5c7a DO |
572 | struct led_classdev leds[JC_NUM_LEDS]; /* player leds */ |
573 | struct led_classdev home_led; | |
2af16c1f | 574 | enum joycon_ctlr_state ctlr_state; |
08ebba5c | 575 | spinlock_t lock; |
14252473 DO |
576 | u8 mac_addr[6]; |
577 | char *mac_addr_str; | |
294a8287 | 578 | enum joycon_ctlr_type ctlr_type; |
2af16c1f DO |
579 | |
580 | /* The following members are used for synchronous sends/receives */ | |
581 | enum joycon_msg_type msg_type; | |
582 | u8 subcmd_num; | |
583 | struct mutex output_mutex; | |
584 | u8 input_buf[JC_MAX_RESP_SIZE]; | |
585 | wait_queue_head_t wait; | |
586 | bool received_resp; | |
587 | u8 usb_ack_match; | |
588 | u8 subcmd_ack_match; | |
479da173 | 589 | bool received_input_report; |
d750d148 | 590 | unsigned int last_input_report_msecs; |
e93363f7 | 591 | unsigned int last_subcmd_sent_msecs; |
d750d148 | 592 | unsigned int consecutive_valid_report_deltas; |
2af16c1f DO |
593 | |
594 | /* factory calibration data */ | |
595 | struct joycon_stick_cal left_stick_cal_x; | |
596 | struct joycon_stick_cal left_stick_cal_y; | |
597 | struct joycon_stick_cal right_stick_cal_x; | |
598 | struct joycon_stick_cal right_stick_cal_y; | |
599 | ||
4ff5b108 DO |
600 | struct joycon_imu_cal accel_cal; |
601 | struct joycon_imu_cal gyro_cal; | |
602 | ||
603 | /* prevents needlessly recalculating these divisors every sample */ | |
604 | s32 imu_cal_accel_divisor[3]; | |
605 | s32 imu_cal_gyro_divisor[3]; | |
606 | ||
08ebba5c DO |
607 | /* power supply data */ |
608 | struct power_supply *battery; | |
609 | struct power_supply_desc battery_desc; | |
610 | u8 battery_capacity; | |
611 | bool battery_charging; | |
612 | bool host_powered; | |
c4eae84f DO |
613 | |
614 | /* rumble */ | |
615 | u8 rumble_data[JC_RUMBLE_QUEUE_SIZE][JC_RUMBLE_DATA_SIZE]; | |
616 | int rumble_queue_head; | |
617 | int rumble_queue_tail; | |
618 | struct workqueue_struct *rumble_queue; | |
619 | struct work_struct rumble_worker; | |
620 | unsigned int rumble_msecs; | |
621 | u16 rumble_ll_freq; | |
622 | u16 rumble_lh_freq; | |
623 | u16 rumble_rl_freq; | |
624 | u16 rumble_rh_freq; | |
dad74e18 | 625 | unsigned short rumble_zero_countdown; |
4ff5b108 DO |
626 | |
627 | /* imu */ | |
628 | struct input_dev *imu_input; | |
629 | bool imu_first_packet_received; /* helps in initiating timestamp */ | |
630 | unsigned int imu_timestamp_us; /* timestamp we report to userspace */ | |
631 | unsigned int imu_last_pkt_ms; /* used to calc imu report delta */ | |
632 | /* the following are used to track the average imu report time delta */ | |
633 | unsigned int imu_delta_samples_count; | |
634 | unsigned int imu_delta_samples_sum; | |
635 | unsigned int imu_avg_delta_ms; | |
2af16c1f DO |
636 | }; |
637 | ||
294a8287 DO |
638 | /* Helper macros for checking controller type */ |
639 | #define jc_type_is_joycon(ctlr) \ | |
640 | (ctlr->hdev->product == USB_DEVICE_ID_NINTENDO_JOYCONL || \ | |
641 | ctlr->hdev->product == USB_DEVICE_ID_NINTENDO_JOYCONR || \ | |
642 | ctlr->hdev->product == USB_DEVICE_ID_NINTENDO_CHRGGRIP) | |
643 | #define jc_type_is_procon(ctlr) \ | |
644 | (ctlr->hdev->product == USB_DEVICE_ID_NINTENDO_PROCON) | |
645 | #define jc_type_is_chrggrip(ctlr) \ | |
646 | (ctlr->hdev->product == USB_DEVICE_ID_NINTENDO_CHRGGRIP) | |
647 | ||
648 | /* Does this controller have inputs associated with left joycon? */ | |
649 | #define jc_type_has_left(ctlr) \ | |
650 | (ctlr->ctlr_type == JOYCON_CTLR_TYPE_JCL || \ | |
94f18bb1 RM |
651 | ctlr->ctlr_type == JOYCON_CTLR_TYPE_PRO || \ |
652 | ctlr->ctlr_type == JOYCON_CTLR_TYPE_N64) | |
294a8287 DO |
653 | |
654 | /* Does this controller have inputs associated with right joycon? */ | |
655 | #define jc_type_has_right(ctlr) \ | |
656 | (ctlr->ctlr_type == JOYCON_CTLR_TYPE_JCR || \ | |
657 | ctlr->ctlr_type == JOYCON_CTLR_TYPE_PRO) | |
658 | ||
94f18bb1 RM |
659 | |
660 | /* | |
661 | * Controller device helpers | |
662 | * | |
663 | * These look at the device ID known to the HID subsystem to identify a device, | |
664 | * but take caution: some NSO devices lie about themselves (NES Joy-Cons and | |
665 | * Sega Genesis controller). See type helpers below. | |
666 | * | |
667 | * These helpers are most useful early during the HID probe or in conjunction | |
668 | * with the capability helpers below. | |
669 | */ | |
670 | static inline bool joycon_device_is_left_joycon(struct joycon_ctlr *ctlr) | |
671 | { | |
672 | return ctlr->hdev->product == USB_DEVICE_ID_NINTENDO_JOYCONL; | |
673 | } | |
674 | ||
675 | static inline bool joycon_device_is_right_joycon(struct joycon_ctlr *ctlr) | |
676 | { | |
677 | return ctlr->hdev->product == USB_DEVICE_ID_NINTENDO_JOYCONR; | |
678 | } | |
679 | ||
680 | static inline bool joycon_device_is_procon(struct joycon_ctlr *ctlr) | |
681 | { | |
682 | return ctlr->hdev->product == USB_DEVICE_ID_NINTENDO_PROCON; | |
683 | } | |
684 | ||
685 | static inline bool joycon_device_is_chrggrip(struct joycon_ctlr *ctlr) | |
686 | { | |
687 | return ctlr->hdev->product == USB_DEVICE_ID_NINTENDO_CHRGGRIP; | |
688 | } | |
689 | ||
690 | static inline bool joycon_device_is_snescon(struct joycon_ctlr *ctlr) | |
691 | { | |
692 | return ctlr->hdev->product == USB_DEVICE_ID_NINTENDO_SNESCON; | |
693 | } | |
694 | ||
695 | static inline bool joycon_device_is_gencon(struct joycon_ctlr *ctlr) | |
696 | { | |
697 | return ctlr->hdev->product == USB_DEVICE_ID_NINTENDO_GENCON; | |
698 | } | |
699 | ||
700 | static inline bool joycon_device_is_n64con(struct joycon_ctlr *ctlr) | |
701 | { | |
702 | return ctlr->hdev->product == USB_DEVICE_ID_NINTENDO_N64CON; | |
703 | } | |
704 | ||
705 | static inline bool joycon_device_has_usb(struct joycon_ctlr *ctlr) | |
706 | { | |
707 | return joycon_device_is_procon(ctlr) || | |
708 | joycon_device_is_chrggrip(ctlr) || | |
709 | joycon_device_is_snescon(ctlr) || | |
710 | joycon_device_is_gencon(ctlr) || | |
711 | joycon_device_is_n64con(ctlr); | |
712 | } | |
713 | ||
714 | /* | |
715 | * Controller type helpers | |
716 | * | |
717 | * These are slightly different than the device-ID-based helpers above. They are | |
718 | * generally more reliable, since they can distinguish between, e.g., Genesis | |
719 | * versus SNES, or NES Joy-Cons versus regular Switch Joy-Cons. They're most | |
720 | * useful for reporting available inputs. For other kinds of distinctions, see | |
721 | * the capability helpers below. | |
722 | * | |
723 | * They have two major drawbacks: (1) they're not available until after we set | |
724 | * the reporting method and then request the device info; (2) they can't | |
725 | * distinguish all controllers (like the Charging Grip from the Pro controller.) | |
726 | */ | |
727 | static inline bool joycon_type_is_left_joycon(struct joycon_ctlr *ctlr) | |
728 | { | |
729 | return ctlr->ctlr_type == JOYCON_CTLR_TYPE_JCL; | |
730 | } | |
731 | ||
732 | static inline bool joycon_type_is_right_joycon(struct joycon_ctlr *ctlr) | |
733 | { | |
734 | return ctlr->ctlr_type == JOYCON_CTLR_TYPE_JCR; | |
735 | } | |
736 | ||
737 | static inline bool joycon_type_is_procon(struct joycon_ctlr *ctlr) | |
738 | { | |
739 | return ctlr->ctlr_type == JOYCON_CTLR_TYPE_PRO; | |
740 | } | |
741 | ||
742 | static inline bool joycon_type_is_snescon(struct joycon_ctlr *ctlr) | |
743 | { | |
744 | return ctlr->ctlr_type == JOYCON_CTLR_TYPE_SNES; | |
745 | } | |
746 | ||
747 | static inline bool joycon_type_is_gencon(struct joycon_ctlr *ctlr) | |
748 | { | |
749 | return ctlr->ctlr_type == JOYCON_CTLR_TYPE_GEN; | |
750 | } | |
751 | ||
752 | static inline bool joycon_type_is_n64con(struct joycon_ctlr *ctlr) | |
753 | { | |
754 | return ctlr->ctlr_type == JOYCON_CTLR_TYPE_N64; | |
755 | } | |
756 | ||
757 | static inline bool joycon_type_is_left_nescon(struct joycon_ctlr *ctlr) | |
758 | { | |
759 | return ctlr->ctlr_type == JOYCON_CTLR_TYPE_NESL; | |
760 | } | |
761 | ||
762 | static inline bool joycon_type_is_right_nescon(struct joycon_ctlr *ctlr) | |
763 | { | |
764 | return ctlr->ctlr_type == JOYCON_CTLR_TYPE_NESR; | |
765 | } | |
766 | ||
767 | static inline bool joycon_type_has_left_controls(struct joycon_ctlr *ctlr) | |
768 | { | |
769 | return joycon_type_is_left_joycon(ctlr) || | |
770 | joycon_type_is_procon(ctlr); | |
771 | } | |
772 | ||
773 | static inline bool joycon_type_has_right_controls(struct joycon_ctlr *ctlr) | |
774 | { | |
775 | return joycon_type_is_right_joycon(ctlr) || | |
776 | joycon_type_is_procon(ctlr); | |
777 | } | |
778 | ||
779 | static inline bool joycon_type_is_any_joycon(struct joycon_ctlr *ctlr) | |
780 | { | |
781 | return joycon_type_is_left_joycon(ctlr) || | |
782 | joycon_type_is_right_joycon(ctlr) || | |
783 | joycon_device_is_chrggrip(ctlr); | |
784 | } | |
785 | ||
786 | static inline bool joycon_type_is_any_nescon(struct joycon_ctlr *ctlr) | |
787 | { | |
788 | return joycon_type_is_left_nescon(ctlr) || | |
789 | joycon_type_is_right_nescon(ctlr); | |
790 | } | |
791 | ||
792 | /* | |
793 | * Controller capability helpers | |
794 | * | |
795 | * These helpers combine the use of the helpers above to detect certain | |
796 | * capabilities during initialization. They are always accurate but (since they | |
797 | * use type helpers) cannot be used early in the HID probe. | |
798 | */ | |
799 | static inline bool joycon_has_imu(struct joycon_ctlr *ctlr) | |
800 | { | |
801 | return joycon_device_is_chrggrip(ctlr) || | |
802 | joycon_type_is_any_joycon(ctlr) || | |
803 | joycon_type_is_procon(ctlr); | |
804 | } | |
805 | ||
806 | static inline bool joycon_has_joysticks(struct joycon_ctlr *ctlr) | |
807 | { | |
808 | return joycon_device_is_chrggrip(ctlr) || | |
809 | joycon_type_is_any_joycon(ctlr) || | |
810 | joycon_type_is_procon(ctlr) || | |
811 | joycon_type_is_n64con(ctlr); | |
812 | } | |
813 | ||
814 | static inline bool joycon_has_rumble(struct joycon_ctlr *ctlr) | |
815 | { | |
816 | return joycon_device_is_chrggrip(ctlr) || | |
817 | joycon_type_is_any_joycon(ctlr) || | |
818 | joycon_type_is_procon(ctlr) || | |
819 | joycon_type_is_n64con(ctlr); | |
820 | } | |
821 | ||
822 | static inline bool joycon_using_usb(struct joycon_ctlr *ctlr) | |
823 | { | |
824 | return ctlr->hdev->bus == BUS_USB; | |
825 | } | |
826 | ||
2af16c1f DO |
827 | static int __joycon_hid_send(struct hid_device *hdev, u8 *data, size_t len) |
828 | { | |
829 | u8 *buf; | |
830 | int ret; | |
831 | ||
832 | buf = kmemdup(data, len, GFP_KERNEL); | |
833 | if (!buf) | |
834 | return -ENOMEM; | |
835 | ret = hid_hw_output_report(hdev, buf, len); | |
836 | kfree(buf); | |
837 | if (ret < 0) | |
838 | hid_dbg(hdev, "Failed to send output report ret=%d\n", ret); | |
839 | return ret; | |
840 | } | |
841 | ||
e93363f7 DO |
842 | static void joycon_wait_for_input_report(struct joycon_ctlr *ctlr) |
843 | { | |
844 | int ret; | |
845 | ||
846 | /* | |
847 | * If we are in the proper reporting mode, wait for an input | |
848 | * report prior to sending the subcommand. This improves | |
849 | * reliability considerably. | |
850 | */ | |
851 | if (ctlr->ctlr_state == JOYCON_CTLR_STATE_READ) { | |
852 | unsigned long flags; | |
853 | ||
854 | spin_lock_irqsave(&ctlr->lock, flags); | |
855 | ctlr->received_input_report = false; | |
856 | spin_unlock_irqrestore(&ctlr->lock, flags); | |
857 | ret = wait_event_timeout(ctlr->wait, | |
858 | ctlr->received_input_report, | |
859 | HZ / 4); | |
860 | /* We will still proceed, even with a timeout here */ | |
861 | if (!ret) | |
862 | hid_warn(ctlr->hdev, | |
863 | "timeout waiting for input report\n"); | |
864 | } | |
865 | } | |
866 | ||
867 | /* | |
868 | * Sending subcommands and/or rumble data at too high a rate can cause bluetooth | |
869 | * controller disconnections. | |
870 | */ | |
d750d148 DO |
871 | #define JC_INPUT_REPORT_MIN_DELTA 8 |
872 | #define JC_INPUT_REPORT_MAX_DELTA 17 | |
873 | #define JC_SUBCMD_TX_OFFSET_MS 4 | |
874 | #define JC_SUBCMD_VALID_DELTA_REQ 3 | |
875 | #define JC_SUBCMD_RATE_MAX_ATTEMPTS 500 | |
876 | #define JC_SUBCMD_RATE_LIMITER_USB_MS 20 | |
877 | #define JC_SUBCMD_RATE_LIMITER_BT_MS 60 | |
878 | #define JC_SUBCMD_RATE_LIMITER_MS(ctlr) ((ctlr)->hdev->bus == BUS_USB ? JC_SUBCMD_RATE_LIMITER_USB_MS : JC_SUBCMD_RATE_LIMITER_BT_MS) | |
e93363f7 DO |
879 | static void joycon_enforce_subcmd_rate(struct joycon_ctlr *ctlr) |
880 | { | |
d750d148 DO |
881 | unsigned int current_ms; |
882 | unsigned long subcmd_delta; | |
883 | int consecutive_valid_deltas = 0; | |
884 | int attempts = 0; | |
885 | unsigned long flags; | |
886 | ||
887 | if (unlikely(ctlr->ctlr_state != JOYCON_CTLR_STATE_READ)) | |
888 | return; | |
e93363f7 | 889 | |
d750d148 | 890 | do { |
e93363f7 DO |
891 | joycon_wait_for_input_report(ctlr); |
892 | current_ms = jiffies_to_msecs(jiffies); | |
d750d148 DO |
893 | subcmd_delta = current_ms - ctlr->last_subcmd_sent_msecs; |
894 | ||
895 | spin_lock_irqsave(&ctlr->lock, flags); | |
896 | consecutive_valid_deltas = ctlr->consecutive_valid_report_deltas; | |
897 | spin_unlock_irqrestore(&ctlr->lock, flags); | |
898 | ||
899 | attempts++; | |
900 | } while ((consecutive_valid_deltas < JC_SUBCMD_VALID_DELTA_REQ || | |
901 | subcmd_delta < JC_SUBCMD_RATE_LIMITER_MS(ctlr)) && | |
902 | ctlr->ctlr_state == JOYCON_CTLR_STATE_READ && | |
903 | attempts < JC_SUBCMD_RATE_MAX_ATTEMPTS); | |
904 | ||
905 | if (attempts >= JC_SUBCMD_RATE_MAX_ATTEMPTS) { | |
906 | hid_warn(ctlr->hdev, "%s: exceeded max attempts", __func__); | |
907 | return; | |
e93363f7 | 908 | } |
d750d148 | 909 | |
e93363f7 | 910 | ctlr->last_subcmd_sent_msecs = current_ms; |
d750d148 DO |
911 | |
912 | /* | |
913 | * Wait a short time after receiving an input report before | |
914 | * transmitting. This should reduce odds of a TX coinciding with an RX. | |
915 | * Minimizing concurrent BT traffic with the controller seems to lower | |
916 | * the rate of disconnections. | |
917 | */ | |
918 | msleep(JC_SUBCMD_TX_OFFSET_MS); | |
e93363f7 DO |
919 | } |
920 | ||
6b5dca2d DO |
921 | static int joycon_hid_send_sync(struct joycon_ctlr *ctlr, u8 *data, size_t len, |
922 | u32 timeout) | |
2af16c1f DO |
923 | { |
924 | int ret; | |
6b5dca2d | 925 | int tries = 2; |
2af16c1f | 926 | |
6b5dca2d DO |
927 | /* |
928 | * The controller occasionally seems to drop subcommands. In testing, | |
929 | * doing one retry after a timeout appears to always work. | |
930 | */ | |
931 | while (tries--) { | |
e93363f7 | 932 | joycon_enforce_subcmd_rate(ctlr); |
479da173 | 933 | |
6b5dca2d DO |
934 | ret = __joycon_hid_send(ctlr->hdev, data, len); |
935 | if (ret < 0) { | |
936 | memset(ctlr->input_buf, 0, JC_MAX_RESP_SIZE); | |
937 | return ret; | |
938 | } | |
2af16c1f | 939 | |
6b5dca2d DO |
940 | ret = wait_event_timeout(ctlr->wait, ctlr->received_resp, |
941 | timeout); | |
942 | if (!ret) { | |
943 | hid_dbg(ctlr->hdev, | |
944 | "synchronous send/receive timed out\n"); | |
945 | if (tries) { | |
946 | hid_dbg(ctlr->hdev, | |
947 | "retrying sync send after timeout\n"); | |
948 | } | |
949 | memset(ctlr->input_buf, 0, JC_MAX_RESP_SIZE); | |
950 | ret = -ETIMEDOUT; | |
951 | } else { | |
952 | ret = 0; | |
953 | break; | |
954 | } | |
2af16c1f DO |
955 | } |
956 | ||
957 | ctlr->received_resp = false; | |
6b5dca2d | 958 | return ret; |
2af16c1f DO |
959 | } |
960 | ||
6b5dca2d | 961 | static int joycon_send_usb(struct joycon_ctlr *ctlr, u8 cmd, u32 timeout) |
2af16c1f DO |
962 | { |
963 | int ret; | |
964 | u8 buf[2] = {JC_OUTPUT_USB_CMD}; | |
965 | ||
966 | buf[1] = cmd; | |
967 | ctlr->usb_ack_match = cmd; | |
968 | ctlr->msg_type = JOYCON_MSG_TYPE_USB; | |
6b5dca2d | 969 | ret = joycon_hid_send_sync(ctlr, buf, sizeof(buf), timeout); |
2af16c1f DO |
970 | if (ret) |
971 | hid_dbg(ctlr->hdev, "send usb command failed; ret=%d\n", ret); | |
972 | return ret; | |
973 | } | |
974 | ||
975 | static int joycon_send_subcmd(struct joycon_ctlr *ctlr, | |
976 | struct joycon_subcmd_request *subcmd, | |
6b5dca2d | 977 | size_t data_len, u32 timeout) |
2af16c1f DO |
978 | { |
979 | int ret; | |
c4eae84f DO |
980 | unsigned long flags; |
981 | ||
982 | spin_lock_irqsave(&ctlr->lock, flags); | |
012bd52c DO |
983 | /* |
984 | * If the controller has been removed, just return ENODEV so the LED | |
985 | * subsystem doesn't print invalid errors on removal. | |
986 | */ | |
987 | if (ctlr->ctlr_state == JOYCON_CTLR_STATE_REMOVED) { | |
988 | spin_unlock_irqrestore(&ctlr->lock, flags); | |
989 | return -ENODEV; | |
990 | } | |
c4eae84f DO |
991 | memcpy(subcmd->rumble_data, ctlr->rumble_data[ctlr->rumble_queue_tail], |
992 | JC_RUMBLE_DATA_SIZE); | |
993 | spin_unlock_irqrestore(&ctlr->lock, flags); | |
2af16c1f DO |
994 | |
995 | subcmd->output_id = JC_OUTPUT_RUMBLE_AND_SUBCMD; | |
996 | subcmd->packet_num = ctlr->subcmd_num; | |
997 | if (++ctlr->subcmd_num > 0xF) | |
998 | ctlr->subcmd_num = 0; | |
999 | ctlr->subcmd_ack_match = subcmd->subcmd_id; | |
1000 | ctlr->msg_type = JOYCON_MSG_TYPE_SUBCMD; | |
1001 | ||
1002 | ret = joycon_hid_send_sync(ctlr, (u8 *)subcmd, | |
6b5dca2d | 1003 | sizeof(*subcmd) + data_len, timeout); |
2af16c1f DO |
1004 | if (ret < 0) |
1005 | hid_dbg(ctlr->hdev, "send subcommand failed; ret=%d\n", ret); | |
1006 | else | |
1007 | ret = 0; | |
1008 | return ret; | |
1009 | } | |
1010 | ||
1011 | /* Supply nibbles for flash and on. Ones correspond to active */ | |
1012 | static int joycon_set_player_leds(struct joycon_ctlr *ctlr, u8 flash, u8 on) | |
1013 | { | |
1014 | struct joycon_subcmd_request *req; | |
1015 | u8 buffer[sizeof(*req) + 1] = { 0 }; | |
1016 | ||
1017 | req = (struct joycon_subcmd_request *)buffer; | |
1018 | req->subcmd_id = JC_SUBCMD_SET_PLAYER_LIGHTS; | |
1019 | req->data[0] = (flash << 4) | on; | |
1020 | ||
1021 | hid_dbg(ctlr->hdev, "setting player leds\n"); | |
6b5dca2d | 1022 | return joycon_send_subcmd(ctlr, req, 1, HZ/4); |
2af16c1f DO |
1023 | } |
1024 | ||
92827607 MF |
1025 | static int joycon_set_home_led(struct joycon_ctlr *ctlr, enum led_brightness brightness) |
1026 | { | |
1027 | struct joycon_subcmd_request *req; | |
1028 | u8 buffer[sizeof(*req) + 5] = { 0 }; | |
1029 | u8 *data; | |
1030 | ||
1031 | req = (struct joycon_subcmd_request *)buffer; | |
1032 | req->subcmd_id = JC_SUBCMD_SET_HOME_LIGHT; | |
1033 | data = req->data; | |
1034 | data[0] = 0x01; | |
1035 | data[1] = brightness << 4; | |
1036 | data[2] = brightness | (brightness << 4); | |
1037 | data[3] = 0x11; | |
1038 | data[4] = 0x11; | |
1039 | ||
1040 | hid_dbg(ctlr->hdev, "setting home led brightness\n"); | |
1041 | return joycon_send_subcmd(ctlr, req, 5, HZ/4); | |
1042 | } | |
1043 | ||
83d640c4 DO |
1044 | static int joycon_request_spi_flash_read(struct joycon_ctlr *ctlr, |
1045 | u32 start_addr, u8 size, u8 **reply) | |
2af16c1f DO |
1046 | { |
1047 | struct joycon_subcmd_request *req; | |
2af16c1f | 1048 | struct joycon_input_report *report; |
83d640c4 DO |
1049 | u8 buffer[sizeof(*req) + 5] = { 0 }; |
1050 | u8 *data; | |
1051 | int ret; | |
1052 | ||
1053 | if (!reply) | |
1054 | return -EINVAL; | |
1055 | ||
1056 | req = (struct joycon_subcmd_request *)buffer; | |
1057 | req->subcmd_id = JC_SUBCMD_SPI_FLASH_READ; | |
1058 | data = req->data; | |
1059 | put_unaligned_le32(start_addr, data); | |
1060 | data[4] = size; | |
1061 | ||
1062 | hid_dbg(ctlr->hdev, "requesting SPI flash data\n"); | |
1063 | ret = joycon_send_subcmd(ctlr, req, 5, HZ); | |
1064 | if (ret) { | |
1065 | hid_err(ctlr->hdev, "failed reading SPI flash; ret=%d\n", ret); | |
1066 | } else { | |
1067 | report = (struct joycon_input_report *)ctlr->input_buf; | |
1068 | /* The read data starts at the 6th byte */ | |
4ff5b108 | 1069 | *reply = &report->subcmd_reply.data[5]; |
83d640c4 DO |
1070 | } |
1071 | return ret; | |
1072 | } | |
1073 | ||
1074 | /* | |
1075 | * User calibration's presence is denoted with a magic byte preceding it. | |
1076 | * returns 0 if magic val is present, 1 if not present, < 0 on error | |
1077 | */ | |
1078 | static int joycon_check_for_cal_magic(struct joycon_ctlr *ctlr, u32 flash_addr) | |
1079 | { | |
1080 | int ret; | |
1081 | u8 *reply; | |
1082 | ||
1083 | ret = joycon_request_spi_flash_read(ctlr, flash_addr, | |
1084 | JC_CAL_USR_MAGIC_SIZE, &reply); | |
1085 | if (ret) | |
1086 | return ret; | |
1087 | ||
1088 | return reply[0] != JC_CAL_USR_MAGIC_0 || reply[1] != JC_CAL_USR_MAGIC_1; | |
1089 | } | |
1090 | ||
1091 | static int joycon_read_stick_calibration(struct joycon_ctlr *ctlr, u16 cal_addr, | |
1092 | struct joycon_stick_cal *cal_x, | |
1093 | struct joycon_stick_cal *cal_y, | |
1094 | bool left_stick) | |
1095 | { | |
2af16c1f DO |
1096 | s32 x_max_above; |
1097 | s32 x_min_below; | |
1098 | s32 y_max_above; | |
1099 | s32 y_min_below; | |
2af16c1f DO |
1100 | u8 *raw_cal; |
1101 | int ret; | |
1102 | ||
83d640c4 DO |
1103 | ret = joycon_request_spi_flash_read(ctlr, cal_addr, |
1104 | JC_CAL_STICK_DATA_SIZE, &raw_cal); | |
1105 | if (ret) | |
1106 | return ret; | |
1107 | ||
1108 | /* stick calibration parsing: note the order differs based on stick */ | |
1109 | if (left_stick) { | |
1110 | x_max_above = hid_field_extract(ctlr->hdev, (raw_cal + 0), 0, | |
1111 | 12); | |
1112 | y_max_above = hid_field_extract(ctlr->hdev, (raw_cal + 1), 4, | |
1113 | 12); | |
1114 | cal_x->center = hid_field_extract(ctlr->hdev, (raw_cal + 3), 0, | |
1115 | 12); | |
1116 | cal_y->center = hid_field_extract(ctlr->hdev, (raw_cal + 4), 4, | |
1117 | 12); | |
1118 | x_min_below = hid_field_extract(ctlr->hdev, (raw_cal + 6), 0, | |
1119 | 12); | |
1120 | y_min_below = hid_field_extract(ctlr->hdev, (raw_cal + 7), 4, | |
1121 | 12); | |
1122 | } else { | |
1123 | cal_x->center = hid_field_extract(ctlr->hdev, (raw_cal + 0), 0, | |
1124 | 12); | |
1125 | cal_y->center = hid_field_extract(ctlr->hdev, (raw_cal + 1), 4, | |
1126 | 12); | |
1127 | x_min_below = hid_field_extract(ctlr->hdev, (raw_cal + 3), 0, | |
1128 | 12); | |
1129 | y_min_below = hid_field_extract(ctlr->hdev, (raw_cal + 4), 4, | |
1130 | 12); | |
1131 | x_max_above = hid_field_extract(ctlr->hdev, (raw_cal + 6), 0, | |
1132 | 12); | |
1133 | y_max_above = hid_field_extract(ctlr->hdev, (raw_cal + 7), 4, | |
1134 | 12); | |
1135 | } | |
1136 | ||
1137 | cal_x->max = cal_x->center + x_max_above; | |
1138 | cal_x->min = cal_x->center - x_min_below; | |
1139 | cal_y->max = cal_y->center + y_max_above; | |
1140 | cal_y->min = cal_y->center - y_min_below; | |
1141 | ||
50503e36 JK |
1142 | /* check if calibration values are plausible */ |
1143 | if (cal_x->min >= cal_x->center || cal_x->center >= cal_x->max || | |
1144 | cal_y->min >= cal_y->center || cal_y->center >= cal_y->max) | |
1145 | ret = -EINVAL; | |
1146 | ||
1147 | return ret; | |
83d640c4 DO |
1148 | } |
1149 | ||
1150 | static const u16 DFLT_STICK_CAL_CEN = 2000; | |
1151 | static const u16 DFLT_STICK_CAL_MAX = 3500; | |
1152 | static const u16 DFLT_STICK_CAL_MIN = 500; | |
50503e36 JK |
1153 | static void joycon_use_default_calibration(struct hid_device *hdev, |
1154 | struct joycon_stick_cal *cal_x, | |
1155 | struct joycon_stick_cal *cal_y, | |
1156 | const char *stick, int ret) | |
1157 | { | |
1158 | hid_warn(hdev, | |
1159 | "Failed to read %s stick cal, using defaults; e=%d\n", | |
1160 | stick, ret); | |
1161 | ||
1162 | cal_x->center = cal_y->center = DFLT_STICK_CAL_CEN; | |
1163 | cal_x->max = cal_y->max = DFLT_STICK_CAL_MAX; | |
1164 | cal_x->min = cal_y->min = DFLT_STICK_CAL_MIN; | |
1165 | } | |
1166 | ||
83d640c4 DO |
1167 | static int joycon_request_calibration(struct joycon_ctlr *ctlr) |
1168 | { | |
1169 | u16 left_stick_addr = JC_CAL_FCT_DATA_LEFT_ADDR; | |
1170 | u16 right_stick_addr = JC_CAL_FCT_DATA_RIGHT_ADDR; | |
1171 | int ret; | |
2af16c1f DO |
1172 | |
1173 | hid_dbg(ctlr->hdev, "requesting cal data\n"); | |
83d640c4 DO |
1174 | |
1175 | /* check if user stick calibrations are present */ | |
1176 | if (!joycon_check_for_cal_magic(ctlr, JC_CAL_USR_LEFT_MAGIC_ADDR)) { | |
1177 | left_stick_addr = JC_CAL_USR_LEFT_DATA_ADDR; | |
1178 | hid_info(ctlr->hdev, "using user cal for left stick\n"); | |
1179 | } else { | |
1180 | hid_info(ctlr->hdev, "using factory cal for left stick\n"); | |
1181 | } | |
1182 | if (!joycon_check_for_cal_magic(ctlr, JC_CAL_USR_RIGHT_MAGIC_ADDR)) { | |
1183 | right_stick_addr = JC_CAL_USR_RIGHT_DATA_ADDR; | |
1184 | hid_info(ctlr->hdev, "using user cal for right stick\n"); | |
1185 | } else { | |
1186 | hid_info(ctlr->hdev, "using factory cal for right stick\n"); | |
1187 | } | |
1188 | ||
1189 | /* read the left stick calibration data */ | |
1190 | ret = joycon_read_stick_calibration(ctlr, left_stick_addr, | |
1191 | &ctlr->left_stick_cal_x, | |
1192 | &ctlr->left_stick_cal_y, | |
1193 | true); | |
2af16c1f | 1194 | |
50503e36 JK |
1195 | if (ret) |
1196 | joycon_use_default_calibration(ctlr->hdev, | |
1197 | &ctlr->left_stick_cal_x, | |
1198 | &ctlr->left_stick_cal_y, | |
1199 | "left", ret); | |
83d640c4 DO |
1200 | |
1201 | /* read the right stick calibration data */ | |
1202 | ret = joycon_read_stick_calibration(ctlr, right_stick_addr, | |
1203 | &ctlr->right_stick_cal_x, | |
1204 | &ctlr->right_stick_cal_y, | |
1205 | false); | |
2af16c1f | 1206 | |
50503e36 JK |
1207 | if (ret) |
1208 | joycon_use_default_calibration(ctlr->hdev, | |
1209 | &ctlr->right_stick_cal_x, | |
1210 | &ctlr->right_stick_cal_y, | |
1211 | "right", ret); | |
2af16c1f | 1212 | |
2af16c1f DO |
1213 | hid_dbg(ctlr->hdev, "calibration:\n" |
1214 | "l_x_c=%d l_x_max=%d l_x_min=%d\n" | |
1215 | "l_y_c=%d l_y_max=%d l_y_min=%d\n" | |
1216 | "r_x_c=%d r_x_max=%d r_x_min=%d\n" | |
1217 | "r_y_c=%d r_y_max=%d r_y_min=%d\n", | |
1218 | ctlr->left_stick_cal_x.center, | |
1219 | ctlr->left_stick_cal_x.max, | |
1220 | ctlr->left_stick_cal_x.min, | |
1221 | ctlr->left_stick_cal_y.center, | |
1222 | ctlr->left_stick_cal_y.max, | |
1223 | ctlr->left_stick_cal_y.min, | |
1224 | ctlr->right_stick_cal_x.center, | |
1225 | ctlr->right_stick_cal_x.max, | |
1226 | ctlr->right_stick_cal_x.min, | |
1227 | ctlr->right_stick_cal_y.center, | |
1228 | ctlr->right_stick_cal_y.max, | |
1229 | ctlr->right_stick_cal_y.min); | |
1230 | ||
1231 | return 0; | |
1232 | } | |
1233 | ||
4ff5b108 DO |
1234 | /* |
1235 | * These divisors are calculated once rather than for each sample. They are only | |
1236 | * dependent on the IMU calibration values. They are used when processing the | |
1237 | * IMU input reports. | |
1238 | */ | |
1239 | static void joycon_calc_imu_cal_divisors(struct joycon_ctlr *ctlr) | |
1240 | { | |
6eb04ca8 | 1241 | int i, divz = 0; |
4ff5b108 DO |
1242 | |
1243 | for (i = 0; i < 3; i++) { | |
1244 | ctlr->imu_cal_accel_divisor[i] = ctlr->accel_cal.scale[i] - | |
1245 | ctlr->accel_cal.offset[i]; | |
1246 | ctlr->imu_cal_gyro_divisor[i] = ctlr->gyro_cal.scale[i] - | |
1247 | ctlr->gyro_cal.offset[i]; | |
6eb04ca8 GP |
1248 | |
1249 | if (ctlr->imu_cal_accel_divisor[i] == 0) { | |
1250 | ctlr->imu_cal_accel_divisor[i] = 1; | |
1251 | divz++; | |
1252 | } | |
1253 | ||
1254 | if (ctlr->imu_cal_gyro_divisor[i] == 0) { | |
1255 | ctlr->imu_cal_gyro_divisor[i] = 1; | |
1256 | divz++; | |
1257 | } | |
4ff5b108 | 1258 | } |
6eb04ca8 GP |
1259 | |
1260 | if (divz) | |
1261 | hid_warn(ctlr->hdev, "inaccurate IMU divisors (%d)\n", divz); | |
4ff5b108 DO |
1262 | } |
1263 | ||
1264 | static const s16 DFLT_ACCEL_OFFSET /*= 0*/; | |
1265 | static const s16 DFLT_ACCEL_SCALE = 16384; | |
1266 | static const s16 DFLT_GYRO_OFFSET /*= 0*/; | |
1267 | static const s16 DFLT_GYRO_SCALE = 13371; | |
1268 | static int joycon_request_imu_calibration(struct joycon_ctlr *ctlr) | |
1269 | { | |
1270 | u16 imu_cal_addr = JC_IMU_CAL_FCT_DATA_ADDR; | |
1271 | u8 *raw_cal; | |
1272 | int ret; | |
1273 | int i; | |
1274 | ||
1275 | /* check if user calibration exists */ | |
1276 | if (!joycon_check_for_cal_magic(ctlr, JC_IMU_CAL_USR_MAGIC_ADDR)) { | |
1277 | imu_cal_addr = JC_IMU_CAL_USR_DATA_ADDR; | |
1278 | hid_info(ctlr->hdev, "using user cal for IMU\n"); | |
1279 | } else { | |
1280 | hid_info(ctlr->hdev, "using factory cal for IMU\n"); | |
1281 | } | |
1282 | ||
1283 | /* request IMU calibration data */ | |
1284 | hid_dbg(ctlr->hdev, "requesting IMU cal data\n"); | |
1285 | ret = joycon_request_spi_flash_read(ctlr, imu_cal_addr, | |
1286 | JC_IMU_CAL_DATA_SIZE, &raw_cal); | |
1287 | if (ret) { | |
1288 | hid_warn(ctlr->hdev, | |
1289 | "Failed to read IMU cal, using defaults; ret=%d\n", | |
1290 | ret); | |
1291 | ||
1292 | for (i = 0; i < 3; i++) { | |
1293 | ctlr->accel_cal.offset[i] = DFLT_ACCEL_OFFSET; | |
1294 | ctlr->accel_cal.scale[i] = DFLT_ACCEL_SCALE; | |
1295 | ctlr->gyro_cal.offset[i] = DFLT_GYRO_OFFSET; | |
1296 | ctlr->gyro_cal.scale[i] = DFLT_GYRO_SCALE; | |
1297 | } | |
1298 | joycon_calc_imu_cal_divisors(ctlr); | |
1299 | return ret; | |
1300 | } | |
1301 | ||
1302 | /* IMU calibration parsing */ | |
1303 | for (i = 0; i < 3; i++) { | |
1304 | int j = i * 2; | |
1305 | ||
1306 | ctlr->accel_cal.offset[i] = get_unaligned_le16(raw_cal + j); | |
1307 | ctlr->accel_cal.scale[i] = get_unaligned_le16(raw_cal + j + 6); | |
1308 | ctlr->gyro_cal.offset[i] = get_unaligned_le16(raw_cal + j + 12); | |
1309 | ctlr->gyro_cal.scale[i] = get_unaligned_le16(raw_cal + j + 18); | |
1310 | } | |
1311 | ||
1312 | joycon_calc_imu_cal_divisors(ctlr); | |
1313 | ||
1314 | hid_dbg(ctlr->hdev, "IMU calibration:\n" | |
1315 | "a_o[0]=%d a_o[1]=%d a_o[2]=%d\n" | |
1316 | "a_s[0]=%d a_s[1]=%d a_s[2]=%d\n" | |
1317 | "g_o[0]=%d g_o[1]=%d g_o[2]=%d\n" | |
1318 | "g_s[0]=%d g_s[1]=%d g_s[2]=%d\n", | |
1319 | ctlr->accel_cal.offset[0], | |
1320 | ctlr->accel_cal.offset[1], | |
1321 | ctlr->accel_cal.offset[2], | |
1322 | ctlr->accel_cal.scale[0], | |
1323 | ctlr->accel_cal.scale[1], | |
1324 | ctlr->accel_cal.scale[2], | |
1325 | ctlr->gyro_cal.offset[0], | |
1326 | ctlr->gyro_cal.offset[1], | |
1327 | ctlr->gyro_cal.offset[2], | |
1328 | ctlr->gyro_cal.scale[0], | |
1329 | ctlr->gyro_cal.scale[1], | |
1330 | ctlr->gyro_cal.scale[2]); | |
1331 | ||
1332 | return 0; | |
1333 | } | |
1334 | ||
2af16c1f DO |
1335 | static int joycon_set_report_mode(struct joycon_ctlr *ctlr) |
1336 | { | |
1337 | struct joycon_subcmd_request *req; | |
1338 | u8 buffer[sizeof(*req) + 1] = { 0 }; | |
1339 | ||
1340 | req = (struct joycon_subcmd_request *)buffer; | |
1341 | req->subcmd_id = JC_SUBCMD_SET_REPORT_MODE; | |
1342 | req->data[0] = 0x30; /* standard, full report mode */ | |
1343 | ||
1344 | hid_dbg(ctlr->hdev, "setting controller report mode\n"); | |
6b5dca2d | 1345 | return joycon_send_subcmd(ctlr, req, 1, HZ); |
2af16c1f DO |
1346 | } |
1347 | ||
c4eae84f DO |
1348 | static int joycon_enable_rumble(struct joycon_ctlr *ctlr) |
1349 | { | |
1350 | struct joycon_subcmd_request *req; | |
1351 | u8 buffer[sizeof(*req) + 1] = { 0 }; | |
1352 | ||
1353 | req = (struct joycon_subcmd_request *)buffer; | |
1354 | req->subcmd_id = JC_SUBCMD_ENABLE_VIBRATION; | |
1355 | req->data[0] = 0x01; /* note: 0x00 would disable */ | |
1356 | ||
1357 | hid_dbg(ctlr->hdev, "enabling rumble\n"); | |
6b5dca2d | 1358 | return joycon_send_subcmd(ctlr, req, 1, HZ/4); |
c4eae84f DO |
1359 | } |
1360 | ||
4ff5b108 DO |
1361 | static int joycon_enable_imu(struct joycon_ctlr *ctlr) |
1362 | { | |
1363 | struct joycon_subcmd_request *req; | |
1364 | u8 buffer[sizeof(*req) + 1] = { 0 }; | |
1365 | ||
1366 | req = (struct joycon_subcmd_request *)buffer; | |
1367 | req->subcmd_id = JC_SUBCMD_ENABLE_IMU; | |
1368 | req->data[0] = 0x01; /* note: 0x00 would disable */ | |
1369 | ||
1370 | hid_dbg(ctlr->hdev, "enabling IMU\n"); | |
1371 | return joycon_send_subcmd(ctlr, req, 1, HZ); | |
1372 | } | |
1373 | ||
2af16c1f DO |
1374 | static s32 joycon_map_stick_val(struct joycon_stick_cal *cal, s32 val) |
1375 | { | |
1376 | s32 center = cal->center; | |
1377 | s32 min = cal->min; | |
1378 | s32 max = cal->max; | |
1379 | s32 new_val; | |
1380 | ||
1381 | if (val > center) { | |
1382 | new_val = (val - center) * JC_MAX_STICK_MAG; | |
1383 | new_val /= (max - center); | |
1384 | } else { | |
1385 | new_val = (center - val) * -JC_MAX_STICK_MAG; | |
1386 | new_val /= (center - min); | |
1387 | } | |
1388 | new_val = clamp(new_val, (s32)-JC_MAX_STICK_MAG, (s32)JC_MAX_STICK_MAG); | |
1389 | return new_val; | |
1390 | } | |
1391 | ||
4ff5b108 DO |
1392 | static void joycon_input_report_parse_imu_data(struct joycon_ctlr *ctlr, |
1393 | struct joycon_input_report *rep, | |
1394 | struct joycon_imu_data *imu_data) | |
1395 | { | |
1396 | u8 *raw = rep->imu_raw_bytes; | |
1397 | int i; | |
1398 | ||
1399 | for (i = 0; i < 3; i++) { | |
1400 | struct joycon_imu_data *data = &imu_data[i]; | |
1401 | ||
1402 | data->accel_x = get_unaligned_le16(raw + 0); | |
1403 | data->accel_y = get_unaligned_le16(raw + 2); | |
1404 | data->accel_z = get_unaligned_le16(raw + 4); | |
1405 | data->gyro_x = get_unaligned_le16(raw + 6); | |
1406 | data->gyro_y = get_unaligned_le16(raw + 8); | |
1407 | data->gyro_z = get_unaligned_le16(raw + 10); | |
1408 | /* point to next imu sample */ | |
1409 | raw += sizeof(struct joycon_imu_data); | |
1410 | } | |
1411 | } | |
1412 | ||
1413 | static void joycon_parse_imu_report(struct joycon_ctlr *ctlr, | |
1414 | struct joycon_input_report *rep) | |
1415 | { | |
1416 | struct joycon_imu_data imu_data[3] = {0}; /* 3 reports per packet */ | |
1417 | struct input_dev *idev = ctlr->imu_input; | |
1418 | unsigned int msecs = jiffies_to_msecs(jiffies); | |
1419 | unsigned int last_msecs = ctlr->imu_last_pkt_ms; | |
1420 | int i; | |
1421 | int value[6]; | |
1422 | ||
1423 | joycon_input_report_parse_imu_data(ctlr, rep, imu_data); | |
1424 | ||
1425 | /* | |
1426 | * There are complexities surrounding how we determine the timestamps we | |
1427 | * associate with the samples we pass to userspace. The IMU input | |
1428 | * reports do not provide us with a good timestamp. There's a quickly | |
1429 | * incrementing 8-bit counter per input report, but it is not very | |
1430 | * useful for this purpose (it is not entirely clear what rate it | |
1431 | * increments at or if it varies based on packet push rate - more on | |
1432 | * the push rate below...). | |
1433 | * | |
1434 | * The reverse engineering work done on the joy-cons and pro controllers | |
1435 | * by the community seems to indicate the following: | |
1436 | * - The controller samples the IMU every 1.35ms. It then does some of | |
1437 | * its own processing, probably averaging the samples out. | |
1438 | * - Each imu input report contains 3 IMU samples, (usually 5ms apart). | |
1439 | * - In the standard reporting mode (which this driver uses exclusively) | |
1440 | * input reports are pushed from the controller as follows: | |
1441 | * * joy-con (bluetooth): every 15 ms | |
1442 | * * joy-cons (in charging grip via USB): every 15 ms | |
1443 | * * pro controller (USB): every 15 ms | |
1444 | * * pro controller (bluetooth): every 8 ms (this is the wildcard) | |
1445 | * | |
1446 | * Further complicating matters is that some bluetooth stacks are known | |
1447 | * to alter the controller's packet rate by hardcoding the bluetooth | |
1448 | * SSR for the switch controllers (android's stack currently sets the | |
1449 | * SSR to 11ms for both the joy-cons and pro controllers). | |
1450 | * | |
1451 | * In my own testing, I've discovered that my pro controller either | |
1452 | * reports IMU sample batches every 11ms or every 15ms. This rate is | |
1453 | * stable after connecting. It isn't 100% clear what determines this | |
1454 | * rate. Importantly, even when sending every 11ms, none of the samples | |
1455 | * are duplicates. This seems to indicate that the time deltas between | |
1456 | * reported samples can vary based on the input report rate. | |
1457 | * | |
1458 | * The solution employed in this driver is to keep track of the average | |
1459 | * time delta between IMU input reports. In testing, this value has | |
1460 | * proven to be stable, staying at 15ms or 11ms, though other hardware | |
1461 | * configurations and bluetooth stacks could potentially see other rates | |
1462 | * (hopefully this will become more clear as more people use the | |
1463 | * driver). | |
1464 | * | |
1465 | * Keeping track of the average report delta allows us to submit our | |
1466 | * timestamps to userspace based on that. Each report contains 3 | |
1467 | * samples, so the IMU sampling rate should be avg_time_delta/3. We can | |
1468 | * also use this average to detect events where we have dropped a | |
1469 | * packet. The userspace timestamp for the samples will be adjusted | |
1470 | * accordingly to prevent unwanted behvaior. | |
1471 | */ | |
1472 | if (!ctlr->imu_first_packet_received) { | |
1473 | ctlr->imu_timestamp_us = 0; | |
1474 | ctlr->imu_delta_samples_count = 0; | |
1475 | ctlr->imu_delta_samples_sum = 0; | |
1476 | ctlr->imu_avg_delta_ms = JC_IMU_DFLT_AVG_DELTA_MS; | |
1477 | ctlr->imu_first_packet_received = true; | |
1478 | } else { | |
1479 | unsigned int delta = msecs - last_msecs; | |
1480 | unsigned int dropped_pkts; | |
1481 | unsigned int dropped_threshold; | |
1482 | ||
1483 | /* avg imu report delta housekeeping */ | |
1484 | ctlr->imu_delta_samples_sum += delta; | |
1485 | ctlr->imu_delta_samples_count++; | |
1486 | if (ctlr->imu_delta_samples_count >= | |
1487 | JC_IMU_SAMPLES_PER_DELTA_AVG) { | |
1488 | ctlr->imu_avg_delta_ms = ctlr->imu_delta_samples_sum / | |
1489 | ctlr->imu_delta_samples_count; | |
4ff5b108 DO |
1490 | ctlr->imu_delta_samples_count = 0; |
1491 | ctlr->imu_delta_samples_sum = 0; | |
1492 | } | |
1493 | ||
6eb04ca8 GP |
1494 | /* don't ever want divide by zero shenanigans */ |
1495 | if (ctlr->imu_avg_delta_ms == 0) { | |
1496 | ctlr->imu_avg_delta_ms = 1; | |
1497 | hid_warn(ctlr->hdev, "calculated avg imu delta of 0\n"); | |
1498 | } | |
1499 | ||
4ff5b108 DO |
1500 | /* useful for debugging IMU sample rate */ |
1501 | hid_dbg(ctlr->hdev, | |
1502 | "imu_report: ms=%u last_ms=%u delta=%u avg_delta=%u\n", | |
1503 | msecs, last_msecs, delta, ctlr->imu_avg_delta_ms); | |
1504 | ||
1505 | /* check if any packets have been dropped */ | |
1506 | dropped_threshold = ctlr->imu_avg_delta_ms * 3 / 2; | |
1507 | dropped_pkts = (delta - min(delta, dropped_threshold)) / | |
1508 | ctlr->imu_avg_delta_ms; | |
1509 | ctlr->imu_timestamp_us += 1000 * ctlr->imu_avg_delta_ms; | |
1510 | if (dropped_pkts > JC_IMU_DROPPED_PKT_WARNING) { | |
1511 | hid_warn(ctlr->hdev, | |
1512 | "compensating for %u dropped IMU reports\n", | |
1513 | dropped_pkts); | |
1514 | hid_warn(ctlr->hdev, | |
1515 | "delta=%u avg_delta=%u\n", | |
1516 | delta, ctlr->imu_avg_delta_ms); | |
1517 | } | |
1518 | } | |
1519 | ctlr->imu_last_pkt_ms = msecs; | |
1520 | ||
1521 | /* Each IMU input report contains three samples */ | |
1522 | for (i = 0; i < 3; i++) { | |
1523 | input_event(idev, EV_MSC, MSC_TIMESTAMP, | |
1524 | ctlr->imu_timestamp_us); | |
1525 | ||
1526 | /* | |
1527 | * These calculations (which use the controller's calibration | |
1528 | * settings to improve the final values) are based on those | |
1529 | * found in the community's reverse-engineering repo (linked at | |
1530 | * top of driver). For hid-nintendo, we make sure that the final | |
1531 | * value given to userspace is always in terms of the axis | |
1532 | * resolution we provided. | |
1533 | * | |
1534 | * Currently only the gyro calculations subtract the calibration | |
1535 | * offsets from the raw value itself. In testing, doing the same | |
1536 | * for the accelerometer raw values decreased accuracy. | |
1537 | * | |
1538 | * Note that the gyro values are multiplied by the | |
1539 | * precision-saving scaling factor to prevent large inaccuracies | |
1540 | * due to truncation of the resolution value which would | |
1541 | * otherwise occur. To prevent overflow (without resorting to 64 | |
1542 | * bit integer math), the mult_frac macro is used. | |
1543 | */ | |
1544 | value[0] = mult_frac((JC_IMU_PREC_RANGE_SCALE * | |
1545 | (imu_data[i].gyro_x - | |
1546 | ctlr->gyro_cal.offset[0])), | |
1547 | ctlr->gyro_cal.scale[0], | |
1548 | ctlr->imu_cal_gyro_divisor[0]); | |
1549 | value[1] = mult_frac((JC_IMU_PREC_RANGE_SCALE * | |
1550 | (imu_data[i].gyro_y - | |
1551 | ctlr->gyro_cal.offset[1])), | |
1552 | ctlr->gyro_cal.scale[1], | |
1553 | ctlr->imu_cal_gyro_divisor[1]); | |
1554 | value[2] = mult_frac((JC_IMU_PREC_RANGE_SCALE * | |
1555 | (imu_data[i].gyro_z - | |
1556 | ctlr->gyro_cal.offset[2])), | |
1557 | ctlr->gyro_cal.scale[2], | |
1558 | ctlr->imu_cal_gyro_divisor[2]); | |
1559 | ||
1560 | value[3] = ((s32)imu_data[i].accel_x * | |
1561 | ctlr->accel_cal.scale[0]) / | |
1562 | ctlr->imu_cal_accel_divisor[0]; | |
1563 | value[4] = ((s32)imu_data[i].accel_y * | |
1564 | ctlr->accel_cal.scale[1]) / | |
1565 | ctlr->imu_cal_accel_divisor[1]; | |
1566 | value[5] = ((s32)imu_data[i].accel_z * | |
1567 | ctlr->accel_cal.scale[2]) / | |
1568 | ctlr->imu_cal_accel_divisor[2]; | |
1569 | ||
1570 | hid_dbg(ctlr->hdev, "raw_gyro: g_x=%d g_y=%d g_z=%d\n", | |
1571 | imu_data[i].gyro_x, imu_data[i].gyro_y, | |
1572 | imu_data[i].gyro_z); | |
1573 | hid_dbg(ctlr->hdev, "raw_accel: a_x=%d a_y=%d a_z=%d\n", | |
1574 | imu_data[i].accel_x, imu_data[i].accel_y, | |
1575 | imu_data[i].accel_z); | |
1576 | ||
1577 | /* | |
1578 | * The right joy-con has 2 axes negated, Y and Z. This is due to | |
1579 | * the orientation of the IMU in the controller. We negate those | |
1580 | * axes' values in order to be consistent with the left joy-con | |
1581 | * and the pro controller: | |
1582 | * X: positive is pointing toward the triggers | |
1583 | * Y: positive is pointing to the left | |
1584 | * Z: positive is pointing up (out of the buttons/sticks) | |
1585 | * The axes follow the right-hand rule. | |
1586 | */ | |
1587 | if (jc_type_is_joycon(ctlr) && jc_type_has_right(ctlr)) { | |
1588 | int j; | |
1589 | ||
1590 | /* negate all but x axis */ | |
1591 | for (j = 1; j < 6; ++j) { | |
1592 | if (j == 3) | |
1593 | continue; | |
1594 | value[j] *= -1; | |
1595 | } | |
1596 | } | |
1597 | ||
1598 | input_report_abs(idev, ABS_RX, value[0]); | |
1599 | input_report_abs(idev, ABS_RY, value[1]); | |
1600 | input_report_abs(idev, ABS_RZ, value[2]); | |
1601 | input_report_abs(idev, ABS_X, value[3]); | |
1602 | input_report_abs(idev, ABS_Y, value[4]); | |
1603 | input_report_abs(idev, ABS_Z, value[5]); | |
1604 | input_sync(idev); | |
1605 | /* convert to micros and divide by 3 (3 samples per report). */ | |
1606 | ctlr->imu_timestamp_us += ctlr->imu_avg_delta_ms * 1000 / 3; | |
1607 | } | |
1608 | } | |
1609 | ||
94f18bb1 | 1610 | static void joycon_handle_rumble_report(struct joycon_ctlr *ctlr, struct joycon_input_report *rep) |
2af16c1f | 1611 | { |
08ebba5c | 1612 | unsigned long flags; |
c4eae84f DO |
1613 | unsigned long msecs = jiffies_to_msecs(jiffies); |
1614 | ||
1615 | spin_lock_irqsave(&ctlr->lock, flags); | |
1616 | if (IS_ENABLED(CONFIG_NINTENDO_FF) && rep->vibrator_report && | |
1ff89e06 | 1617 | ctlr->ctlr_state != JOYCON_CTLR_STATE_REMOVED && |
dad74e18 DO |
1618 | (msecs - ctlr->rumble_msecs) >= JC_RUMBLE_PERIOD_MS && |
1619 | (ctlr->rumble_queue_head != ctlr->rumble_queue_tail || | |
1620 | ctlr->rumble_zero_countdown > 0)) { | |
1621 | /* | |
1622 | * When this value reaches 0, we know we've sent multiple | |
1623 | * packets to the controller instructing it to disable rumble. | |
1624 | * We can safely stop sending periodic rumble packets until the | |
1625 | * next ff effect. | |
1626 | */ | |
1627 | if (ctlr->rumble_zero_countdown > 0) | |
1628 | ctlr->rumble_zero_countdown--; | |
c4eae84f | 1629 | queue_work(ctlr->rumble_queue, &ctlr->rumble_worker); |
dad74e18 | 1630 | } |
2af16c1f | 1631 | |
94f18bb1 RM |
1632 | spin_unlock_irqrestore(&ctlr->lock, flags); |
1633 | } | |
1634 | ||
1635 | static void joycon_parse_battery_status(struct joycon_ctlr *ctlr, struct joycon_input_report *rep) | |
1636 | { | |
1637 | u8 tmp; | |
1638 | unsigned long flags; | |
1639 | ||
1640 | spin_lock_irqsave(&ctlr->lock, flags); | |
1641 | ||
08ebba5c | 1642 | tmp = rep->bat_con; |
08ebba5c DO |
1643 | ctlr->host_powered = tmp & BIT(0); |
1644 | ctlr->battery_charging = tmp & BIT(4); | |
1645 | tmp = tmp >> 5; | |
94f18bb1 | 1646 | |
08ebba5c DO |
1647 | switch (tmp) { |
1648 | case 0: /* empty */ | |
1649 | ctlr->battery_capacity = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL; | |
1650 | break; | |
1651 | case 1: /* low */ | |
1652 | ctlr->battery_capacity = POWER_SUPPLY_CAPACITY_LEVEL_LOW; | |
1653 | break; | |
1654 | case 2: /* medium */ | |
1655 | ctlr->battery_capacity = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL; | |
1656 | break; | |
1657 | case 3: /* high */ | |
1658 | ctlr->battery_capacity = POWER_SUPPLY_CAPACITY_LEVEL_HIGH; | |
1659 | break; | |
1660 | case 4: /* full */ | |
1661 | ctlr->battery_capacity = POWER_SUPPLY_CAPACITY_LEVEL_FULL; | |
1662 | break; | |
1663 | default: | |
1664 | ctlr->battery_capacity = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN; | |
1665 | hid_warn(ctlr->hdev, "Invalid battery status\n"); | |
1666 | break; | |
1667 | } | |
94f18bb1 | 1668 | |
08ebba5c | 1669 | spin_unlock_irqrestore(&ctlr->lock, flags); |
94f18bb1 | 1670 | } |
08ebba5c | 1671 | |
94f18bb1 RM |
1672 | static void joycon_report_left_stick(struct joycon_ctlr *ctlr, |
1673 | struct joycon_input_report *rep) | |
1674 | { | |
1675 | u16 raw_x; | |
1676 | u16 raw_y; | |
1677 | s32 x; | |
1678 | s32 y; | |
1679 | ||
1680 | raw_x = hid_field_extract(ctlr->hdev, rep->left_stick, 0, 12); | |
1681 | raw_y = hid_field_extract(ctlr->hdev, rep->left_stick + 1, 4, 12); | |
1682 | ||
1683 | x = joycon_map_stick_val(&ctlr->left_stick_cal_x, raw_x); | |
1684 | y = -joycon_map_stick_val(&ctlr->left_stick_cal_y, raw_y); | |
1685 | ||
1686 | input_report_abs(ctlr->input, ABS_X, x); | |
1687 | input_report_abs(ctlr->input, ABS_Y, y); | |
1688 | } | |
1689 | ||
1690 | static void joycon_report_right_stick(struct joycon_ctlr *ctlr, | |
1691 | struct joycon_input_report *rep) | |
1692 | { | |
1693 | u16 raw_x; | |
1694 | u16 raw_y; | |
1695 | s32 x; | |
1696 | s32 y; | |
1697 | ||
1698 | raw_x = hid_field_extract(ctlr->hdev, rep->right_stick, 0, 12); | |
1699 | raw_y = hid_field_extract(ctlr->hdev, rep->right_stick + 1, 4, 12); | |
1700 | ||
1701 | x = joycon_map_stick_val(&ctlr->right_stick_cal_x, raw_x); | |
1702 | y = -joycon_map_stick_val(&ctlr->right_stick_cal_y, raw_y); | |
1703 | ||
1704 | input_report_abs(ctlr->input, ABS_RX, x); | |
1705 | input_report_abs(ctlr->input, ABS_RY, y); | |
1706 | } | |
1707 | ||
1708 | static void joycon_report_dpad(struct joycon_ctlr *ctlr, | |
1709 | struct joycon_input_report *rep) | |
1710 | { | |
1711 | int hatx = 0; | |
1712 | int haty = 0; | |
1713 | u32 btns = hid_field_extract(ctlr->hdev, rep->button_status, 0, 24); | |
1714 | ||
1715 | if (btns & JC_BTN_LEFT) | |
1716 | hatx = -1; | |
1717 | else if (btns & JC_BTN_RIGHT) | |
1718 | hatx = 1; | |
1719 | ||
1720 | if (btns & JC_BTN_UP) | |
1721 | haty = -1; | |
1722 | else if (btns & JC_BTN_DOWN) | |
1723 | haty = 1; | |
1724 | ||
1725 | input_report_abs(ctlr->input, ABS_HAT0X, hatx); | |
1726 | input_report_abs(ctlr->input, ABS_HAT0Y, haty); | |
1727 | } | |
1728 | ||
1729 | static void joycon_report_buttons(struct joycon_ctlr *ctlr, | |
1730 | struct joycon_input_report *rep, | |
1731 | const struct joycon_ctlr_button_mapping button_mappings[]) | |
1732 | { | |
1733 | const struct joycon_ctlr_button_mapping *button; | |
1734 | u32 status = hid_field_extract(ctlr->hdev, rep->button_status, 0, 24); | |
1735 | ||
1736 | for (button = button_mappings; button->code; button++) | |
1737 | input_report_key(ctlr->input, button->code, status & button->bit); | |
1738 | } | |
1739 | ||
1740 | static void joycon_parse_report(struct joycon_ctlr *ctlr, | |
1741 | struct joycon_input_report *rep) | |
1742 | { | |
1743 | unsigned long flags; | |
1744 | unsigned long msecs = jiffies_to_msecs(jiffies); | |
1745 | unsigned long report_delta_ms = msecs - ctlr->last_input_report_msecs; | |
1746 | ||
1747 | if (joycon_has_rumble(ctlr)) | |
1748 | joycon_handle_rumble_report(ctlr, rep); | |
1749 | ||
1750 | joycon_parse_battery_status(ctlr, rep); | |
1751 | ||
1752 | if (joycon_type_is_left_joycon(ctlr)) { | |
1753 | joycon_report_left_stick(ctlr, rep); | |
1754 | joycon_report_buttons(ctlr, rep, left_joycon_button_mappings); | |
1755 | if (!joycon_device_is_chrggrip(ctlr)) | |
1756 | joycon_report_buttons(ctlr, rep, left_joycon_s_button_mappings); | |
1757 | } else if (joycon_type_is_right_joycon(ctlr)) { | |
1758 | joycon_report_right_stick(ctlr, rep); | |
1759 | joycon_report_buttons(ctlr, rep, right_joycon_button_mappings); | |
1760 | if (!joycon_device_is_chrggrip(ctlr)) | |
1761 | joycon_report_buttons(ctlr, rep, right_joycon_s_button_mappings); | |
1762 | } else if (joycon_type_is_procon(ctlr)) { | |
1763 | joycon_report_left_stick(ctlr, rep); | |
1764 | joycon_report_right_stick(ctlr, rep); | |
1765 | joycon_report_dpad(ctlr, rep); | |
1766 | joycon_report_buttons(ctlr, rep, procon_button_mappings); | |
1767 | } else if (joycon_type_is_any_nescon(ctlr)) { | |
1768 | joycon_report_dpad(ctlr, rep); | |
1769 | joycon_report_buttons(ctlr, rep, nescon_button_mappings); | |
1770 | } else if (joycon_type_is_snescon(ctlr)) { | |
1771 | joycon_report_dpad(ctlr, rep); | |
1772 | joycon_report_buttons(ctlr, rep, snescon_button_mappings); | |
1773 | } else if (joycon_type_is_gencon(ctlr)) { | |
1774 | joycon_report_dpad(ctlr, rep); | |
1775 | joycon_report_buttons(ctlr, rep, gencon_button_mappings); | |
1776 | } else if (joycon_type_is_n64con(ctlr)) { | |
1777 | joycon_report_left_stick(ctlr, rep); | |
1778 | joycon_report_dpad(ctlr, rep); | |
1779 | joycon_report_buttons(ctlr, rep, n64con_button_mappings); | |
2af16c1f DO |
1780 | } |
1781 | ||
94f18bb1 | 1782 | input_sync(ctlr->input); |
479da173 | 1783 | |
d750d148 DO |
1784 | spin_lock_irqsave(&ctlr->lock, flags); |
1785 | ctlr->last_input_report_msecs = msecs; | |
1786 | /* | |
1787 | * Was this input report a reasonable time delta compared to the prior | |
1788 | * report? We use this information to decide when a safe time is to send | |
1789 | * rumble packets or subcommand packets. | |
1790 | */ | |
1791 | if (report_delta_ms >= JC_INPUT_REPORT_MIN_DELTA && | |
1792 | report_delta_ms <= JC_INPUT_REPORT_MAX_DELTA) { | |
1793 | if (ctlr->consecutive_valid_report_deltas < JC_SUBCMD_VALID_DELTA_REQ) | |
1794 | ctlr->consecutive_valid_report_deltas++; | |
1795 | } else { | |
1796 | ctlr->consecutive_valid_report_deltas = 0; | |
1797 | } | |
1798 | /* | |
1799 | * Our consecutive valid report tracking is only relevant for | |
1800 | * bluetooth-connected controllers. For USB devices, we're beholden to | |
1801 | * USB's underlying polling rate anyway. Always set to the consecutive | |
1802 | * delta requirement. | |
1803 | */ | |
1804 | if (ctlr->hdev->bus == BUS_USB) | |
1805 | ctlr->consecutive_valid_report_deltas = JC_SUBCMD_VALID_DELTA_REQ; | |
1806 | ||
1807 | spin_unlock_irqrestore(&ctlr->lock, flags); | |
1808 | ||
479da173 DO |
1809 | /* |
1810 | * Immediately after receiving a report is the most reliable time to | |
1811 | * send a subcommand to the controller. Wake any subcommand senders | |
1812 | * waiting for a report. | |
1813 | */ | |
1814 | if (unlikely(mutex_is_locked(&ctlr->output_mutex))) { | |
1815 | spin_lock_irqsave(&ctlr->lock, flags); | |
1816 | ctlr->received_input_report = true; | |
1817 | spin_unlock_irqrestore(&ctlr->lock, flags); | |
1818 | wake_up(&ctlr->wait); | |
1819 | } | |
4ff5b108 DO |
1820 | |
1821 | /* parse IMU data if present */ | |
94f18bb1 | 1822 | if ((rep->id == JC_INPUT_IMU_DATA) && joycon_has_imu(ctlr)) |
4ff5b108 | 1823 | joycon_parse_imu_report(ctlr, rep); |
2af16c1f DO |
1824 | } |
1825 | ||
4c048f6b DO |
1826 | static int joycon_send_rumble_data(struct joycon_ctlr *ctlr) |
1827 | { | |
1828 | int ret; | |
1829 | unsigned long flags; | |
1830 | struct joycon_rumble_output rumble_output = { 0 }; | |
1831 | ||
1832 | spin_lock_irqsave(&ctlr->lock, flags); | |
1833 | /* | |
1834 | * If the controller has been removed, just return ENODEV so the LED | |
1835 | * subsystem doesn't print invalid errors on removal. | |
1836 | */ | |
1837 | if (ctlr->ctlr_state == JOYCON_CTLR_STATE_REMOVED) { | |
1838 | spin_unlock_irqrestore(&ctlr->lock, flags); | |
1839 | return -ENODEV; | |
1840 | } | |
1841 | memcpy(rumble_output.rumble_data, | |
1842 | ctlr->rumble_data[ctlr->rumble_queue_tail], | |
1843 | JC_RUMBLE_DATA_SIZE); | |
1844 | spin_unlock_irqrestore(&ctlr->lock, flags); | |
1845 | ||
1846 | rumble_output.output_id = JC_OUTPUT_RUMBLE_ONLY; | |
1847 | rumble_output.packet_num = ctlr->subcmd_num; | |
1848 | if (++ctlr->subcmd_num > 0xF) | |
1849 | ctlr->subcmd_num = 0; | |
1850 | ||
e93363f7 DO |
1851 | joycon_enforce_subcmd_rate(ctlr); |
1852 | ||
4c048f6b DO |
1853 | ret = __joycon_hid_send(ctlr->hdev, (u8 *)&rumble_output, |
1854 | sizeof(rumble_output)); | |
1855 | return ret; | |
1856 | } | |
1857 | ||
c4eae84f DO |
1858 | static void joycon_rumble_worker(struct work_struct *work) |
1859 | { | |
1860 | struct joycon_ctlr *ctlr = container_of(work, struct joycon_ctlr, | |
1861 | rumble_worker); | |
1862 | unsigned long flags; | |
1863 | bool again = true; | |
1864 | int ret; | |
1865 | ||
1866 | while (again) { | |
1867 | mutex_lock(&ctlr->output_mutex); | |
4c048f6b | 1868 | ret = joycon_send_rumble_data(ctlr); |
c4eae84f | 1869 | mutex_unlock(&ctlr->output_mutex); |
c4eae84f | 1870 | |
012bd52c | 1871 | /* -ENODEV means the controller was just unplugged */ |
c4eae84f | 1872 | spin_lock_irqsave(&ctlr->lock, flags); |
012bd52c DO |
1873 | if (ret < 0 && ret != -ENODEV && |
1874 | ctlr->ctlr_state != JOYCON_CTLR_STATE_REMOVED) | |
1875 | hid_warn(ctlr->hdev, "Failed to set rumble; e=%d", ret); | |
1876 | ||
c4eae84f DO |
1877 | ctlr->rumble_msecs = jiffies_to_msecs(jiffies); |
1878 | if (ctlr->rumble_queue_tail != ctlr->rumble_queue_head) { | |
1879 | if (++ctlr->rumble_queue_tail >= JC_RUMBLE_QUEUE_SIZE) | |
1880 | ctlr->rumble_queue_tail = 0; | |
1881 | } else { | |
1882 | again = false; | |
1883 | } | |
1884 | spin_unlock_irqrestore(&ctlr->lock, flags); | |
1885 | } | |
1886 | } | |
1887 | ||
1888 | #if IS_ENABLED(CONFIG_NINTENDO_FF) | |
1889 | static struct joycon_rumble_freq_data joycon_find_rumble_freq(u16 freq) | |
1890 | { | |
1891 | const size_t length = ARRAY_SIZE(joycon_rumble_frequencies); | |
1892 | const struct joycon_rumble_freq_data *data = joycon_rumble_frequencies; | |
1893 | int i = 0; | |
1894 | ||
1895 | if (freq > data[0].freq) { | |
1896 | for (i = 1; i < length - 1; i++) { | |
1897 | if (freq > data[i - 1].freq && freq <= data[i].freq) | |
1898 | break; | |
1899 | } | |
1900 | } | |
1901 | ||
1902 | return data[i]; | |
1903 | } | |
1904 | ||
1905 | static struct joycon_rumble_amp_data joycon_find_rumble_amp(u16 amp) | |
1906 | { | |
1907 | const size_t length = ARRAY_SIZE(joycon_rumble_amplitudes); | |
1908 | const struct joycon_rumble_amp_data *data = joycon_rumble_amplitudes; | |
1909 | int i = 0; | |
1910 | ||
1911 | if (amp > data[0].amp) { | |
1912 | for (i = 1; i < length - 1; i++) { | |
1913 | if (amp > data[i - 1].amp && amp <= data[i].amp) | |
1914 | break; | |
1915 | } | |
1916 | } | |
1917 | ||
1918 | return data[i]; | |
1919 | } | |
1920 | ||
1921 | static void joycon_encode_rumble(u8 *data, u16 freq_low, u16 freq_high, u16 amp) | |
1922 | { | |
1923 | struct joycon_rumble_freq_data freq_data_low; | |
1924 | struct joycon_rumble_freq_data freq_data_high; | |
1925 | struct joycon_rumble_amp_data amp_data; | |
1926 | ||
1927 | freq_data_low = joycon_find_rumble_freq(freq_low); | |
1928 | freq_data_high = joycon_find_rumble_freq(freq_high); | |
1929 | amp_data = joycon_find_rumble_amp(amp); | |
1930 | ||
1931 | data[0] = (freq_data_high.high >> 8) & 0xFF; | |
1932 | data[1] = (freq_data_high.high & 0xFF) + amp_data.high; | |
1933 | data[2] = freq_data_low.low + ((amp_data.low >> 8) & 0xFF); | |
1934 | data[3] = amp_data.low & 0xFF; | |
1935 | } | |
1936 | ||
1937 | static const u16 JOYCON_MAX_RUMBLE_HIGH_FREQ = 1253; | |
1938 | static const u16 JOYCON_MIN_RUMBLE_HIGH_FREQ = 82; | |
1939 | static const u16 JOYCON_MAX_RUMBLE_LOW_FREQ = 626; | |
1940 | static const u16 JOYCON_MIN_RUMBLE_LOW_FREQ = 41; | |
1941 | ||
1942 | static void joycon_clamp_rumble_freqs(struct joycon_ctlr *ctlr) | |
1943 | { | |
1944 | unsigned long flags; | |
1945 | ||
1946 | spin_lock_irqsave(&ctlr->lock, flags); | |
1947 | ctlr->rumble_ll_freq = clamp(ctlr->rumble_ll_freq, | |
1948 | JOYCON_MIN_RUMBLE_LOW_FREQ, | |
1949 | JOYCON_MAX_RUMBLE_LOW_FREQ); | |
1950 | ctlr->rumble_lh_freq = clamp(ctlr->rumble_lh_freq, | |
1951 | JOYCON_MIN_RUMBLE_HIGH_FREQ, | |
1952 | JOYCON_MAX_RUMBLE_HIGH_FREQ); | |
1953 | ctlr->rumble_rl_freq = clamp(ctlr->rumble_rl_freq, | |
1954 | JOYCON_MIN_RUMBLE_LOW_FREQ, | |
1955 | JOYCON_MAX_RUMBLE_LOW_FREQ); | |
1956 | ctlr->rumble_rh_freq = clamp(ctlr->rumble_rh_freq, | |
1957 | JOYCON_MIN_RUMBLE_HIGH_FREQ, | |
1958 | JOYCON_MAX_RUMBLE_HIGH_FREQ); | |
1959 | spin_unlock_irqrestore(&ctlr->lock, flags); | |
1960 | } | |
1961 | ||
1962 | static int joycon_set_rumble(struct joycon_ctlr *ctlr, u16 amp_r, u16 amp_l, | |
1963 | bool schedule_now) | |
1964 | { | |
1965 | u8 data[JC_RUMBLE_DATA_SIZE]; | |
1966 | u16 amp; | |
1967 | u16 freq_r_low; | |
1968 | u16 freq_r_high; | |
1969 | u16 freq_l_low; | |
1970 | u16 freq_l_high; | |
1971 | unsigned long flags; | |
bcba9f32 | 1972 | int next_rq_head; |
c4eae84f DO |
1973 | |
1974 | spin_lock_irqsave(&ctlr->lock, flags); | |
1975 | freq_r_low = ctlr->rumble_rl_freq; | |
1976 | freq_r_high = ctlr->rumble_rh_freq; | |
1977 | freq_l_low = ctlr->rumble_ll_freq; | |
1978 | freq_l_high = ctlr->rumble_lh_freq; | |
dad74e18 DO |
1979 | /* limit number of silent rumble packets to reduce traffic */ |
1980 | if (amp_l != 0 || amp_r != 0) | |
1981 | ctlr->rumble_zero_countdown = JC_RUMBLE_ZERO_AMP_PKT_CNT; | |
c4eae84f DO |
1982 | spin_unlock_irqrestore(&ctlr->lock, flags); |
1983 | ||
1984 | /* right joy-con */ | |
1985 | amp = amp_r * (u32)joycon_max_rumble_amp / 65535; | |
1986 | joycon_encode_rumble(data + 4, freq_r_low, freq_r_high, amp); | |
1987 | ||
1988 | /* left joy-con */ | |
1989 | amp = amp_l * (u32)joycon_max_rumble_amp / 65535; | |
1990 | joycon_encode_rumble(data, freq_l_low, freq_l_high, amp); | |
1991 | ||
1992 | spin_lock_irqsave(&ctlr->lock, flags); | |
bcba9f32 DO |
1993 | |
1994 | next_rq_head = ctlr->rumble_queue_head + 1; | |
1995 | if (next_rq_head >= JC_RUMBLE_QUEUE_SIZE) | |
1996 | next_rq_head = 0; | |
1997 | ||
1998 | /* Did we overrun the circular buffer? | |
1999 | * If so, be sure we keep the latest intended rumble state. | |
2000 | */ | |
2001 | if (next_rq_head == ctlr->rumble_queue_tail) { | |
2002 | hid_dbg(ctlr->hdev, "rumble queue is full"); | |
2003 | /* overwrite the prior value at the end of the circular buf */ | |
2004 | next_rq_head = ctlr->rumble_queue_head; | |
2005 | } | |
2006 | ||
2007 | ctlr->rumble_queue_head = next_rq_head; | |
c4eae84f DO |
2008 | memcpy(ctlr->rumble_data[ctlr->rumble_queue_head], data, |
2009 | JC_RUMBLE_DATA_SIZE); | |
c4eae84f DO |
2010 | |
2011 | /* don't wait for the periodic send (reduces latency) */ | |
1ff89e06 | 2012 | if (schedule_now && ctlr->ctlr_state != JOYCON_CTLR_STATE_REMOVED) |
c4eae84f DO |
2013 | queue_work(ctlr->rumble_queue, &ctlr->rumble_worker); |
2014 | ||
1ff89e06 DO |
2015 | spin_unlock_irqrestore(&ctlr->lock, flags); |
2016 | ||
c4eae84f DO |
2017 | return 0; |
2018 | } | |
2019 | ||
2020 | static int joycon_play_effect(struct input_dev *dev, void *data, | |
2021 | struct ff_effect *effect) | |
2022 | { | |
2023 | struct joycon_ctlr *ctlr = input_get_drvdata(dev); | |
2024 | ||
2025 | if (effect->type != FF_RUMBLE) | |
2026 | return 0; | |
2027 | ||
2028 | return joycon_set_rumble(ctlr, | |
2029 | effect->u.rumble.weak_magnitude, | |
2030 | effect->u.rumble.strong_magnitude, | |
2031 | true); | |
2032 | } | |
2033 | #endif /* IS_ENABLED(CONFIG_NINTENDO_FF) */ | |
2af16c1f | 2034 | |
94f18bb1 | 2035 | static void joycon_config_left_stick(struct input_dev *idev) |
2af16c1f | 2036 | { |
94f18bb1 RM |
2037 | input_set_abs_params(idev, |
2038 | ABS_X, | |
2039 | -JC_MAX_STICK_MAG, | |
2040 | JC_MAX_STICK_MAG, | |
2041 | JC_STICK_FUZZ, | |
2042 | JC_STICK_FLAT); | |
2043 | input_set_abs_params(idev, | |
2044 | ABS_Y, | |
2045 | -JC_MAX_STICK_MAG, | |
2046 | JC_MAX_STICK_MAG, | |
2047 | JC_STICK_FUZZ, | |
2048 | JC_STICK_FLAT); | |
2049 | } | |
2af16c1f | 2050 | |
94f18bb1 RM |
2051 | static void joycon_config_right_stick(struct input_dev *idev) |
2052 | { | |
2053 | input_set_abs_params(idev, | |
2054 | ABS_RX, | |
2055 | -JC_MAX_STICK_MAG, | |
2056 | JC_MAX_STICK_MAG, | |
2057 | JC_STICK_FUZZ, | |
2058 | JC_STICK_FLAT); | |
2059 | input_set_abs_params(idev, | |
2060 | ABS_RY, | |
2061 | -JC_MAX_STICK_MAG, | |
2062 | JC_MAX_STICK_MAG, | |
2063 | JC_STICK_FUZZ, | |
2064 | JC_STICK_FLAT); | |
2065 | } | |
2af16c1f | 2066 | |
94f18bb1 RM |
2067 | static void joycon_config_dpad(struct input_dev *idev) |
2068 | { | |
2069 | input_set_abs_params(idev, | |
2070 | ABS_HAT0X, | |
2071 | -JC_MAX_DPAD_MAG, | |
2072 | JC_MAX_DPAD_MAG, | |
2073 | JC_DPAD_FUZZ, | |
2074 | JC_DPAD_FLAT); | |
2075 | input_set_abs_params(idev, | |
2076 | ABS_HAT0Y, | |
2077 | -JC_MAX_DPAD_MAG, | |
2078 | JC_MAX_DPAD_MAG, | |
2079 | JC_DPAD_FUZZ, | |
2080 | JC_DPAD_FLAT); | |
2081 | } | |
2af16c1f | 2082 | |
94f18bb1 RM |
2083 | static void joycon_config_buttons(struct input_dev *idev, |
2084 | const struct joycon_ctlr_button_mapping button_mappings[]) | |
2085 | { | |
2086 | const struct joycon_ctlr_button_mapping *button; | |
2af16c1f | 2087 | |
94f18bb1 RM |
2088 | for (button = button_mappings; button->code; button++) |
2089 | input_set_capability(idev, EV_KEY, button->code); | |
2090 | } | |
2af16c1f | 2091 | |
94f18bb1 RM |
2092 | static void joycon_config_rumble(struct joycon_ctlr *ctlr) |
2093 | { | |
c4eae84f DO |
2094 | #if IS_ENABLED(CONFIG_NINTENDO_FF) |
2095 | /* set up rumble */ | |
2096 | input_set_capability(ctlr->input, EV_FF, FF_RUMBLE); | |
2097 | input_ff_create_memless(ctlr->input, NULL, joycon_play_effect); | |
2098 | ctlr->rumble_ll_freq = JC_RUMBLE_DFLT_LOW_FREQ; | |
2099 | ctlr->rumble_lh_freq = JC_RUMBLE_DFLT_HIGH_FREQ; | |
2100 | ctlr->rumble_rl_freq = JC_RUMBLE_DFLT_LOW_FREQ; | |
2101 | ctlr->rumble_rh_freq = JC_RUMBLE_DFLT_HIGH_FREQ; | |
2102 | joycon_clamp_rumble_freqs(ctlr); | |
2103 | joycon_set_rumble(ctlr, 0, 0, false); | |
2104 | ctlr->rumble_msecs = jiffies_to_msecs(jiffies); | |
2105 | #endif | |
94f18bb1 | 2106 | } |
c4eae84f | 2107 | |
94f18bb1 RM |
2108 | static int joycon_imu_input_create(struct joycon_ctlr *ctlr) |
2109 | { | |
2110 | struct hid_device *hdev; | |
2111 | const char *imu_name; | |
2112 | int ret; | |
2113 | ||
2114 | hdev = ctlr->hdev; | |
2af16c1f | 2115 | |
4ff5b108 DO |
2116 | /* configure the imu input device */ |
2117 | ctlr->imu_input = devm_input_allocate_device(&hdev->dev); | |
2118 | if (!ctlr->imu_input) | |
2119 | return -ENOMEM; | |
2120 | ||
2121 | ctlr->imu_input->id.bustype = hdev->bus; | |
2122 | ctlr->imu_input->id.vendor = hdev->vendor; | |
2123 | ctlr->imu_input->id.product = hdev->product; | |
2124 | ctlr->imu_input->id.version = hdev->version; | |
2125 | ctlr->imu_input->uniq = ctlr->mac_addr_str; | |
842fec05 | 2126 | ctlr->imu_input->phys = hdev->phys; |
94f18bb1 RM |
2127 | |
2128 | imu_name = devm_kasprintf(&hdev->dev, GFP_KERNEL, "%s (IMU)", ctlr->input->name); | |
2129 | if (!imu_name) | |
2130 | return -ENOMEM; | |
2131 | ||
2132 | ctlr->imu_input->name = imu_name; | |
2133 | ||
4ff5b108 DO |
2134 | input_set_drvdata(ctlr->imu_input, ctlr); |
2135 | ||
2136 | /* configure imu axes */ | |
2137 | input_set_abs_params(ctlr->imu_input, ABS_X, | |
2138 | -JC_IMU_MAX_ACCEL_MAG, JC_IMU_MAX_ACCEL_MAG, | |
2139 | JC_IMU_ACCEL_FUZZ, JC_IMU_ACCEL_FLAT); | |
2140 | input_set_abs_params(ctlr->imu_input, ABS_Y, | |
2141 | -JC_IMU_MAX_ACCEL_MAG, JC_IMU_MAX_ACCEL_MAG, | |
2142 | JC_IMU_ACCEL_FUZZ, JC_IMU_ACCEL_FLAT); | |
2143 | input_set_abs_params(ctlr->imu_input, ABS_Z, | |
2144 | -JC_IMU_MAX_ACCEL_MAG, JC_IMU_MAX_ACCEL_MAG, | |
2145 | JC_IMU_ACCEL_FUZZ, JC_IMU_ACCEL_FLAT); | |
2146 | input_abs_set_res(ctlr->imu_input, ABS_X, JC_IMU_ACCEL_RES_PER_G); | |
2147 | input_abs_set_res(ctlr->imu_input, ABS_Y, JC_IMU_ACCEL_RES_PER_G); | |
2148 | input_abs_set_res(ctlr->imu_input, ABS_Z, JC_IMU_ACCEL_RES_PER_G); | |
2149 | ||
2150 | input_set_abs_params(ctlr->imu_input, ABS_RX, | |
2151 | -JC_IMU_MAX_GYRO_MAG, JC_IMU_MAX_GYRO_MAG, | |
2152 | JC_IMU_GYRO_FUZZ, JC_IMU_GYRO_FLAT); | |
2153 | input_set_abs_params(ctlr->imu_input, ABS_RY, | |
2154 | -JC_IMU_MAX_GYRO_MAG, JC_IMU_MAX_GYRO_MAG, | |
2155 | JC_IMU_GYRO_FUZZ, JC_IMU_GYRO_FLAT); | |
2156 | input_set_abs_params(ctlr->imu_input, ABS_RZ, | |
2157 | -JC_IMU_MAX_GYRO_MAG, JC_IMU_MAX_GYRO_MAG, | |
2158 | JC_IMU_GYRO_FUZZ, JC_IMU_GYRO_FLAT); | |
2159 | ||
2160 | input_abs_set_res(ctlr->imu_input, ABS_RX, JC_IMU_GYRO_RES_PER_DPS); | |
2161 | input_abs_set_res(ctlr->imu_input, ABS_RY, JC_IMU_GYRO_RES_PER_DPS); | |
2162 | input_abs_set_res(ctlr->imu_input, ABS_RZ, JC_IMU_GYRO_RES_PER_DPS); | |
2163 | ||
2164 | __set_bit(EV_MSC, ctlr->imu_input->evbit); | |
2165 | __set_bit(MSC_TIMESTAMP, ctlr->imu_input->mscbit); | |
2166 | __set_bit(INPUT_PROP_ACCELEROMETER, ctlr->imu_input->propbit); | |
2167 | ||
2168 | ret = input_register_device(ctlr->imu_input); | |
2169 | if (ret) | |
2170 | return ret; | |
2171 | ||
c5e62676 DO |
2172 | return 0; |
2173 | } | |
2174 | ||
94f18bb1 RM |
2175 | static int joycon_input_create(struct joycon_ctlr *ctlr) |
2176 | { | |
2177 | struct hid_device *hdev; | |
2178 | int ret; | |
2179 | ||
2180 | hdev = ctlr->hdev; | |
2181 | ||
2182 | ctlr->input = devm_input_allocate_device(&hdev->dev); | |
2183 | if (!ctlr->input) | |
2184 | return -ENOMEM; | |
2185 | ctlr->input->id.bustype = hdev->bus; | |
2186 | ctlr->input->id.vendor = hdev->vendor; | |
2187 | ctlr->input->id.product = hdev->product; | |
2188 | ctlr->input->id.version = hdev->version; | |
2189 | ctlr->input->uniq = ctlr->mac_addr_str; | |
2190 | ctlr->input->name = hdev->name; | |
2191 | ctlr->input->phys = hdev->phys; | |
2192 | input_set_drvdata(ctlr->input, ctlr); | |
2193 | ||
2194 | ret = input_register_device(ctlr->input); | |
2195 | if (ret) | |
2196 | return ret; | |
2197 | ||
2198 | if (joycon_type_is_right_joycon(ctlr)) { | |
2199 | joycon_config_right_stick(ctlr->input); | |
2200 | joycon_config_buttons(ctlr->input, right_joycon_button_mappings); | |
2201 | if (!joycon_device_is_chrggrip(ctlr)) | |
2202 | joycon_config_buttons(ctlr->input, right_joycon_s_button_mappings); | |
2203 | } else if (joycon_type_is_left_joycon(ctlr)) { | |
2204 | joycon_config_left_stick(ctlr->input); | |
2205 | joycon_config_buttons(ctlr->input, left_joycon_button_mappings); | |
2206 | if (!joycon_device_is_chrggrip(ctlr)) | |
2207 | joycon_config_buttons(ctlr->input, left_joycon_s_button_mappings); | |
2208 | } else if (joycon_type_is_procon(ctlr)) { | |
2209 | joycon_config_left_stick(ctlr->input); | |
2210 | joycon_config_right_stick(ctlr->input); | |
2211 | joycon_config_dpad(ctlr->input); | |
2212 | joycon_config_buttons(ctlr->input, procon_button_mappings); | |
2213 | } else if (joycon_type_is_any_nescon(ctlr)) { | |
2214 | joycon_config_dpad(ctlr->input); | |
2215 | joycon_config_buttons(ctlr->input, nescon_button_mappings); | |
2216 | } else if (joycon_type_is_snescon(ctlr)) { | |
2217 | joycon_config_dpad(ctlr->input); | |
2218 | joycon_config_buttons(ctlr->input, snescon_button_mappings); | |
2219 | } else if (joycon_type_is_gencon(ctlr)) { | |
2220 | joycon_config_dpad(ctlr->input); | |
2221 | joycon_config_buttons(ctlr->input, gencon_button_mappings); | |
2222 | } else if (joycon_type_is_n64con(ctlr)) { | |
2223 | joycon_config_dpad(ctlr->input); | |
2224 | joycon_config_left_stick(ctlr->input); | |
2225 | joycon_config_buttons(ctlr->input, n64con_button_mappings); | |
2226 | } | |
2227 | ||
2228 | if (joycon_has_imu(ctlr)) { | |
2229 | ret = joycon_imu_input_create(ctlr); | |
2230 | if (ret) | |
2231 | return ret; | |
2232 | } | |
2233 | ||
2234 | if (joycon_has_rumble(ctlr)) | |
2235 | joycon_config_rumble(ctlr); | |
2236 | ||
2237 | return 0; | |
2238 | } | |
2239 | ||
92827607 | 2240 | /* Because the subcommand sets all the leds at once, the brightness argument is ignored */ |
c5e62676 DO |
2241 | static int joycon_player_led_brightness_set(struct led_classdev *led, |
2242 | enum led_brightness brightness) | |
2243 | { | |
2244 | struct device *dev = led->dev->parent; | |
2245 | struct hid_device *hdev = to_hid_device(dev); | |
2246 | struct joycon_ctlr *ctlr; | |
2247 | int val = 0; | |
2248 | int i; | |
2249 | int ret; | |
c5e62676 DO |
2250 | |
2251 | ctlr = hid_get_drvdata(hdev); | |
2252 | if (!ctlr) { | |
2253 | hid_err(hdev, "No controller data\n"); | |
2254 | return -ENODEV; | |
2255 | } | |
2256 | ||
92827607 MF |
2257 | for (i = 0; i < JC_NUM_LEDS; i++) |
2258 | val |= ctlr->leds[i].brightness << i; | |
c5e62676 DO |
2259 | |
2260 | mutex_lock(&ctlr->output_mutex); | |
c5e62676 DO |
2261 | ret = joycon_set_player_leds(ctlr, 0, val); |
2262 | mutex_unlock(&ctlr->output_mutex); | |
2263 | ||
2264 | return ret; | |
2265 | } | |
2266 | ||
697e5c7a DO |
2267 | static int joycon_home_led_brightness_set(struct led_classdev *led, |
2268 | enum led_brightness brightness) | |
2269 | { | |
2270 | struct device *dev = led->dev->parent; | |
2271 | struct hid_device *hdev = to_hid_device(dev); | |
2272 | struct joycon_ctlr *ctlr; | |
697e5c7a DO |
2273 | int ret; |
2274 | ||
2275 | ctlr = hid_get_drvdata(hdev); | |
2276 | if (!ctlr) { | |
2277 | hid_err(hdev, "No controller data\n"); | |
2278 | return -ENODEV; | |
2279 | } | |
697e5c7a | 2280 | mutex_lock(&ctlr->output_mutex); |
92827607 | 2281 | ret = joycon_set_home_led(ctlr, brightness); |
697e5c7a | 2282 | mutex_unlock(&ctlr->output_mutex); |
697e5c7a DO |
2283 | return ret; |
2284 | } | |
2285 | ||
92827607 | 2286 | static DEFINE_SPINLOCK(joycon_input_num_spinlock); |
697e5c7a | 2287 | static int joycon_leds_create(struct joycon_ctlr *ctlr) |
c5e62676 DO |
2288 | { |
2289 | struct hid_device *hdev = ctlr->hdev; | |
2290 | struct device *dev = &hdev->dev; | |
2291 | const char *d_name = dev_name(dev); | |
2292 | struct led_classdev *led; | |
92827607 | 2293 | int led_val = 0; |
c5e62676 | 2294 | char *name; |
92827607 | 2295 | int ret; |
c5e62676 | 2296 | int i; |
92827607 MF |
2297 | unsigned long flags; |
2298 | int player_led_pattern; | |
2299 | static int input_num; | |
c5e62676 | 2300 | |
92827607 MF |
2301 | /* |
2302 | * Set the player leds based on controller number | |
2303 | * Because there is no standard concept of "player number", the pattern | |
2304 | * number will simply increase by 1 every time a controller is connected. | |
2305 | */ | |
2306 | spin_lock_irqsave(&joycon_input_num_spinlock, flags); | |
2307 | player_led_pattern = input_num++ % JC_NUM_LED_PATTERNS; | |
2308 | spin_unlock_irqrestore(&joycon_input_num_spinlock, flags); | |
c5e62676 DO |
2309 | |
2310 | /* configure the player LEDs */ | |
2311 | for (i = 0; i < JC_NUM_LEDS; i++) { | |
2312 | name = devm_kasprintf(dev, GFP_KERNEL, "%s:%s:%s", | |
2313 | d_name, | |
2314 | "green", | |
2315 | joycon_player_led_names[i]); | |
92827607 | 2316 | if (!name) |
c5e62676 DO |
2317 | return -ENOMEM; |
2318 | ||
2319 | led = &ctlr->leds[i]; | |
2320 | led->name = name; | |
92827607 | 2321 | led->brightness = joycon_player_led_patterns[player_led_pattern][i]; |
c5e62676 DO |
2322 | led->max_brightness = 1; |
2323 | led->brightness_set_blocking = | |
2324 | joycon_player_led_brightness_set; | |
2325 | led->flags = LED_CORE_SUSPENDRESUME | LED_HW_PLUGGABLE; | |
2326 | ||
92827607 MF |
2327 | led_val |= joycon_player_led_patterns[player_led_pattern][i] << i; |
2328 | } | |
2329 | mutex_lock(&ctlr->output_mutex); | |
2330 | ret = joycon_set_player_leds(ctlr, 0, led_val); | |
2331 | mutex_unlock(&ctlr->output_mutex); | |
2332 | if (ret) { | |
2333 | hid_warn(hdev, "Failed to set players LEDs, skipping registration; ret=%d\n", ret); | |
2334 | goto home_led; | |
2335 | } | |
2336 | ||
2337 | for (i = 0; i < JC_NUM_LEDS; i++) { | |
2338 | led = &ctlr->leds[i]; | |
c5e62676 DO |
2339 | ret = devm_led_classdev_register(&hdev->dev, led); |
2340 | if (ret) { | |
92827607 | 2341 | hid_err(hdev, "Failed to register player %d LED; ret=%d\n", i + 1, ret); |
697e5c7a | 2342 | return ret; |
c5e62676 DO |
2343 | } |
2344 | } | |
2345 | ||
92827607 | 2346 | home_led: |
697e5c7a | 2347 | /* configure the home LED */ |
294a8287 | 2348 | if (jc_type_has_right(ctlr)) { |
697e5c7a DO |
2349 | name = devm_kasprintf(dev, GFP_KERNEL, "%s:%s:%s", |
2350 | d_name, | |
2351 | "blue", | |
2352 | LED_FUNCTION_PLAYER5); | |
2353 | if (!name) | |
2354 | return -ENOMEM; | |
2355 | ||
2356 | led = &ctlr->home_led; | |
2357 | led->name = name; | |
2358 | led->brightness = 0; | |
2359 | led->max_brightness = 0xF; | |
2360 | led->brightness_set_blocking = joycon_home_led_brightness_set; | |
2361 | led->flags = LED_CORE_SUSPENDRESUME | LED_HW_PLUGGABLE; | |
92827607 MF |
2362 | |
2363 | /* Set the home LED to 0 as default state */ | |
2364 | mutex_lock(&ctlr->output_mutex); | |
2365 | ret = joycon_set_home_led(ctlr, 0); | |
2366 | mutex_unlock(&ctlr->output_mutex); | |
697e5c7a | 2367 | if (ret) { |
92827607 MF |
2368 | hid_warn(hdev, "Failed to set home LED, skipping registration; ret=%d\n", ret); |
2369 | return 0; | |
697e5c7a | 2370 | } |
92827607 MF |
2371 | |
2372 | ret = devm_led_classdev_register(&hdev->dev, led); | |
697e5c7a | 2373 | if (ret) { |
92827607 MF |
2374 | hid_err(hdev, "Failed to register home LED; ret=%d\n", ret); |
2375 | return ret; | |
697e5c7a DO |
2376 | } |
2377 | } | |
2378 | ||
2af16c1f DO |
2379 | return 0; |
2380 | } | |
2381 | ||
08ebba5c DO |
2382 | static int joycon_battery_get_property(struct power_supply *supply, |
2383 | enum power_supply_property prop, | |
2384 | union power_supply_propval *val) | |
2385 | { | |
2386 | struct joycon_ctlr *ctlr = power_supply_get_drvdata(supply); | |
2387 | unsigned long flags; | |
2388 | int ret = 0; | |
2389 | u8 capacity; | |
2390 | bool charging; | |
2391 | bool powered; | |
2392 | ||
2393 | spin_lock_irqsave(&ctlr->lock, flags); | |
2394 | capacity = ctlr->battery_capacity; | |
2395 | charging = ctlr->battery_charging; | |
2396 | powered = ctlr->host_powered; | |
2397 | spin_unlock_irqrestore(&ctlr->lock, flags); | |
2398 | ||
2399 | switch (prop) { | |
2400 | case POWER_SUPPLY_PROP_PRESENT: | |
2401 | val->intval = 1; | |
2402 | break; | |
2403 | case POWER_SUPPLY_PROP_SCOPE: | |
2404 | val->intval = POWER_SUPPLY_SCOPE_DEVICE; | |
2405 | break; | |
2406 | case POWER_SUPPLY_PROP_CAPACITY_LEVEL: | |
2407 | val->intval = capacity; | |
2408 | break; | |
2409 | case POWER_SUPPLY_PROP_STATUS: | |
2410 | if (charging) | |
2411 | val->intval = POWER_SUPPLY_STATUS_CHARGING; | |
2412 | else if (capacity == POWER_SUPPLY_CAPACITY_LEVEL_FULL && | |
2413 | powered) | |
2414 | val->intval = POWER_SUPPLY_STATUS_FULL; | |
2415 | else | |
2416 | val->intval = POWER_SUPPLY_STATUS_DISCHARGING; | |
2417 | break; | |
2418 | default: | |
2419 | ret = -EINVAL; | |
2420 | break; | |
2421 | } | |
2422 | return ret; | |
2423 | } | |
2424 | ||
2425 | static enum power_supply_property joycon_battery_props[] = { | |
2426 | POWER_SUPPLY_PROP_PRESENT, | |
2427 | POWER_SUPPLY_PROP_CAPACITY_LEVEL, | |
2428 | POWER_SUPPLY_PROP_SCOPE, | |
2429 | POWER_SUPPLY_PROP_STATUS, | |
2430 | }; | |
2431 | ||
2432 | static int joycon_power_supply_create(struct joycon_ctlr *ctlr) | |
2433 | { | |
2434 | struct hid_device *hdev = ctlr->hdev; | |
2435 | struct power_supply_config supply_config = { .drv_data = ctlr, }; | |
2436 | const char * const name_fmt = "nintendo_switch_controller_battery_%s"; | |
2437 | int ret = 0; | |
2438 | ||
2439 | /* Set initially to unknown before receiving first input report */ | |
2440 | ctlr->battery_capacity = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN; | |
2441 | ||
2442 | /* Configure the battery's description */ | |
2443 | ctlr->battery_desc.properties = joycon_battery_props; | |
2444 | ctlr->battery_desc.num_properties = | |
2445 | ARRAY_SIZE(joycon_battery_props); | |
2446 | ctlr->battery_desc.get_property = joycon_battery_get_property; | |
2447 | ctlr->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY; | |
2448 | ctlr->battery_desc.use_for_apm = 0; | |
2449 | ctlr->battery_desc.name = devm_kasprintf(&hdev->dev, GFP_KERNEL, | |
2450 | name_fmt, | |
2451 | dev_name(&hdev->dev)); | |
2452 | if (!ctlr->battery_desc.name) | |
2453 | return -ENOMEM; | |
2454 | ||
2455 | ctlr->battery = devm_power_supply_register(&hdev->dev, | |
2456 | &ctlr->battery_desc, | |
2457 | &supply_config); | |
2458 | if (IS_ERR(ctlr->battery)) { | |
2459 | ret = PTR_ERR(ctlr->battery); | |
2460 | hid_err(hdev, "Failed to register battery; ret=%d\n", ret); | |
2461 | return ret; | |
2462 | } | |
2463 | ||
2464 | return power_supply_powers(ctlr->battery, &hdev->dev); | |
2465 | } | |
2466 | ||
294a8287 | 2467 | static int joycon_read_info(struct joycon_ctlr *ctlr) |
14252473 DO |
2468 | { |
2469 | int ret; | |
2470 | int i; | |
2471 | int j; | |
2472 | struct joycon_subcmd_request req = { 0 }; | |
2473 | struct joycon_input_report *report; | |
2474 | ||
2475 | req.subcmd_id = JC_SUBCMD_REQ_DEV_INFO; | |
2476 | ret = joycon_send_subcmd(ctlr, &req, 0, HZ); | |
2477 | if (ret) { | |
2478 | hid_err(ctlr->hdev, "Failed to get joycon info; ret=%d\n", ret); | |
2479 | return ret; | |
2480 | } | |
2481 | ||
2482 | report = (struct joycon_input_report *)ctlr->input_buf; | |
2483 | ||
2484 | for (i = 4, j = 0; j < 6; i++, j++) | |
4ff5b108 | 2485 | ctlr->mac_addr[j] = report->subcmd_reply.data[i]; |
14252473 DO |
2486 | |
2487 | ctlr->mac_addr_str = devm_kasprintf(&ctlr->hdev->dev, GFP_KERNEL, | |
2488 | "%02X:%02X:%02X:%02X:%02X:%02X", | |
2489 | ctlr->mac_addr[0], | |
2490 | ctlr->mac_addr[1], | |
2491 | ctlr->mac_addr[2], | |
2492 | ctlr->mac_addr[3], | |
2493 | ctlr->mac_addr[4], | |
2494 | ctlr->mac_addr[5]); | |
2495 | if (!ctlr->mac_addr_str) | |
2496 | return -ENOMEM; | |
2497 | hid_info(ctlr->hdev, "controller MAC = %s\n", ctlr->mac_addr_str); | |
2498 | ||
94f18bb1 RM |
2499 | /* |
2500 | * Retrieve the type so we can distinguish the controller type | |
2501 | * Unfortantly the hdev->product can't always be used due to a ?bug? | |
2502 | * with the NSO Genesis controller. Over USB, it will report the | |
2503 | * PID as 0x201E, but over bluetooth it will report the PID as 0x2017 | |
2504 | * which is the same as the NSO SNES controller. This is different from | |
2505 | * the rest of the controllers which will report the same PID over USB | |
2506 | * and bluetooth. | |
2507 | */ | |
4ff5b108 | 2508 | ctlr->ctlr_type = report->subcmd_reply.data[2]; |
94f18bb1 | 2509 | hid_dbg(ctlr->hdev, "controller type = 0x%02X\n", ctlr->ctlr_type); |
294a8287 | 2510 | |
14252473 DO |
2511 | return 0; |
2512 | } | |
2513 | ||
95ea4d9f MF |
2514 | static int joycon_init(struct hid_device *hdev) |
2515 | { | |
2516 | struct joycon_ctlr *ctlr = hid_get_drvdata(hdev); | |
2517 | int ret = 0; | |
2518 | ||
2519 | mutex_lock(&ctlr->output_mutex); | |
2520 | /* if handshake command fails, assume ble pro controller */ | |
94f18bb1 | 2521 | if (joycon_using_usb(ctlr) && !joycon_send_usb(ctlr, JC_USB_CMD_HANDSHAKE, HZ)) { |
95ea4d9f MF |
2522 | hid_dbg(hdev, "detected USB controller\n"); |
2523 | /* set baudrate for improved latency */ | |
2524 | ret = joycon_send_usb(ctlr, JC_USB_CMD_BAUDRATE_3M, HZ); | |
2525 | if (ret) { | |
2526 | hid_err(hdev, "Failed to set baudrate; ret=%d\n", ret); | |
2527 | goto out_unlock; | |
2528 | } | |
2529 | /* handshake */ | |
2530 | ret = joycon_send_usb(ctlr, JC_USB_CMD_HANDSHAKE, HZ); | |
2531 | if (ret) { | |
2532 | hid_err(hdev, "Failed handshake; ret=%d\n", ret); | |
2533 | goto out_unlock; | |
2534 | } | |
2535 | /* | |
2536 | * Set no timeout (to keep controller in USB mode). | |
2537 | * This doesn't send a response, so ignore the timeout. | |
2538 | */ | |
2539 | joycon_send_usb(ctlr, JC_USB_CMD_NO_TIMEOUT, HZ/10); | |
2540 | } else if (jc_type_is_chrggrip(ctlr)) { | |
2541 | hid_err(hdev, "Failed charging grip handshake\n"); | |
2542 | ret = -ETIMEDOUT; | |
2543 | goto out_unlock; | |
2544 | } | |
2545 | ||
94f18bb1 RM |
2546 | /* needed to retrieve the controller type */ |
2547 | ret = joycon_read_info(ctlr); | |
95ea4d9f | 2548 | if (ret) { |
94f18bb1 RM |
2549 | hid_err(hdev, "Failed to retrieve controller info; ret=%d\n", |
2550 | ret); | |
2551 | goto out_unlock; | |
95ea4d9f MF |
2552 | } |
2553 | ||
94f18bb1 RM |
2554 | if (joycon_has_joysticks(ctlr)) { |
2555 | /* get controller calibration data, and parse it */ | |
2556 | ret = joycon_request_calibration(ctlr); | |
2557 | if (ret) { | |
2558 | /* | |
2559 | * We can function with default calibration, but it may be | |
2560 | * inaccurate. Provide a warning, and continue on. | |
2561 | */ | |
2562 | hid_warn(hdev, "Analog stick positions may be inaccurate\n"); | |
2563 | } | |
2564 | } | |
2565 | ||
2566 | if (joycon_has_imu(ctlr)) { | |
2567 | /* get IMU calibration data, and parse it */ | |
2568 | ret = joycon_request_imu_calibration(ctlr); | |
2569 | if (ret) { | |
2570 | /* | |
2571 | * We can function with default calibration, but it may be | |
2572 | * inaccurate. Provide a warning, and continue on. | |
2573 | */ | |
2574 | hid_warn(hdev, "Unable to read IMU calibration data\n"); | |
2575 | } | |
2576 | ||
2577 | /* Enable the IMU */ | |
2578 | ret = joycon_enable_imu(ctlr); | |
2579 | if (ret) { | |
2580 | hid_err(hdev, "Failed to enable the IMU; ret=%d\n", ret); | |
2581 | goto out_unlock; | |
2582 | } | |
95ea4d9f MF |
2583 | } |
2584 | ||
2585 | /* Set the reporting mode to 0x30, which is the full report mode */ | |
2586 | ret = joycon_set_report_mode(ctlr); | |
2587 | if (ret) { | |
2588 | hid_err(hdev, "Failed to set report mode; ret=%d\n", ret); | |
2589 | goto out_unlock; | |
2590 | } | |
2591 | ||
94f18bb1 RM |
2592 | if (joycon_has_rumble(ctlr)) { |
2593 | /* Enable rumble */ | |
2594 | ret = joycon_enable_rumble(ctlr); | |
2595 | if (ret) { | |
2596 | hid_err(hdev, "Failed to enable rumble; ret=%d\n", ret); | |
2597 | goto out_unlock; | |
2598 | } | |
95ea4d9f MF |
2599 | } |
2600 | ||
2601 | out_unlock: | |
2602 | mutex_unlock(&ctlr->output_mutex); | |
2603 | return ret; | |
2604 | } | |
2605 | ||
2af16c1f DO |
2606 | /* Common handler for parsing inputs */ |
2607 | static int joycon_ctlr_read_handler(struct joycon_ctlr *ctlr, u8 *data, | |
2608 | int size) | |
2609 | { | |
2610 | if (data[0] == JC_INPUT_SUBCMD_REPLY || data[0] == JC_INPUT_IMU_DATA || | |
2611 | data[0] == JC_INPUT_MCU_DATA) { | |
2612 | if (size >= 12) /* make sure it contains the input report */ | |
2613 | joycon_parse_report(ctlr, | |
2614 | (struct joycon_input_report *)data); | |
2615 | } | |
2616 | ||
2617 | return 0; | |
2618 | } | |
2619 | ||
2620 | static int joycon_ctlr_handle_event(struct joycon_ctlr *ctlr, u8 *data, | |
2621 | int size) | |
2622 | { | |
2623 | int ret = 0; | |
2624 | bool match = false; | |
2625 | struct joycon_input_report *report; | |
2626 | ||
2627 | if (unlikely(mutex_is_locked(&ctlr->output_mutex)) && | |
2628 | ctlr->msg_type != JOYCON_MSG_TYPE_NONE) { | |
2629 | switch (ctlr->msg_type) { | |
2630 | case JOYCON_MSG_TYPE_USB: | |
2631 | if (size < 2) | |
2632 | break; | |
2633 | if (data[0] == JC_INPUT_USB_RESPONSE && | |
2634 | data[1] == ctlr->usb_ack_match) | |
2635 | match = true; | |
2636 | break; | |
2637 | case JOYCON_MSG_TYPE_SUBCMD: | |
2638 | if (size < sizeof(struct joycon_input_report) || | |
2639 | data[0] != JC_INPUT_SUBCMD_REPLY) | |
2640 | break; | |
2641 | report = (struct joycon_input_report *)data; | |
4ff5b108 | 2642 | if (report->subcmd_reply.id == ctlr->subcmd_ack_match) |
2af16c1f DO |
2643 | match = true; |
2644 | break; | |
2645 | default: | |
2646 | break; | |
2647 | } | |
2648 | ||
2649 | if (match) { | |
2650 | memcpy(ctlr->input_buf, data, | |
2651 | min(size, (int)JC_MAX_RESP_SIZE)); | |
2652 | ctlr->msg_type = JOYCON_MSG_TYPE_NONE; | |
2653 | ctlr->received_resp = true; | |
2654 | wake_up(&ctlr->wait); | |
2655 | ||
2656 | /* This message has been handled */ | |
2657 | return 1; | |
2658 | } | |
2659 | } | |
2660 | ||
2661 | if (ctlr->ctlr_state == JOYCON_CTLR_STATE_READ) | |
2662 | ret = joycon_ctlr_read_handler(ctlr, data, size); | |
2663 | ||
2664 | return ret; | |
2665 | } | |
2666 | ||
2667 | static int nintendo_hid_event(struct hid_device *hdev, | |
2668 | struct hid_report *report, u8 *raw_data, int size) | |
2669 | { | |
2670 | struct joycon_ctlr *ctlr = hid_get_drvdata(hdev); | |
2671 | ||
2672 | if (size < 1) | |
2673 | return -EINVAL; | |
2674 | ||
2675 | return joycon_ctlr_handle_event(ctlr, raw_data, size); | |
2676 | } | |
2677 | ||
2678 | static int nintendo_hid_probe(struct hid_device *hdev, | |
2679 | const struct hid_device_id *id) | |
2680 | { | |
2681 | int ret; | |
2682 | struct joycon_ctlr *ctlr; | |
2683 | ||
2684 | hid_dbg(hdev, "probe - start\n"); | |
2685 | ||
2686 | ctlr = devm_kzalloc(&hdev->dev, sizeof(*ctlr), GFP_KERNEL); | |
2687 | if (!ctlr) { | |
2688 | ret = -ENOMEM; | |
2689 | goto err; | |
2690 | } | |
2691 | ||
2692 | ctlr->hdev = hdev; | |
2693 | ctlr->ctlr_state = JOYCON_CTLR_STATE_INIT; | |
bcba9f32 | 2694 | ctlr->rumble_queue_head = 0; |
c4eae84f | 2695 | ctlr->rumble_queue_tail = 0; |
2af16c1f DO |
2696 | hid_set_drvdata(hdev, ctlr); |
2697 | mutex_init(&ctlr->output_mutex); | |
2698 | init_waitqueue_head(&ctlr->wait); | |
08ebba5c | 2699 | spin_lock_init(&ctlr->lock); |
c4eae84f DO |
2700 | ctlr->rumble_queue = alloc_workqueue("hid-nintendo-rumble_wq", |
2701 | WQ_FREEZABLE | WQ_MEM_RECLAIM, 0); | |
fe23b6bb JJB |
2702 | if (!ctlr->rumble_queue) { |
2703 | ret = -ENOMEM; | |
2704 | goto err; | |
2705 | } | |
c4eae84f | 2706 | INIT_WORK(&ctlr->rumble_worker, joycon_rumble_worker); |
2af16c1f DO |
2707 | |
2708 | ret = hid_parse(hdev); | |
2709 | if (ret) { | |
2710 | hid_err(hdev, "HID parse failed\n"); | |
c4eae84f | 2711 | goto err_wq; |
2af16c1f DO |
2712 | } |
2713 | ||
c7d0d636 DO |
2714 | /* |
2715 | * Patch the hw version of pro controller/joycons, so applications can | |
2716 | * distinguish between the default HID mappings and the mappings defined | |
2717 | * by the Linux game controller spec. This is important for the SDL2 | |
2718 | * library, which has a game controller database, which uses device ids | |
2719 | * in combination with version as a key. | |
2720 | */ | |
2721 | hdev->version |= 0x8000; | |
2722 | ||
2af16c1f DO |
2723 | ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW); |
2724 | if (ret) { | |
2725 | hid_err(hdev, "HW start failed\n"); | |
c4eae84f | 2726 | goto err_wq; |
2af16c1f DO |
2727 | } |
2728 | ||
2729 | ret = hid_hw_open(hdev); | |
2730 | if (ret) { | |
2731 | hid_err(hdev, "cannot start hardware I/O\n"); | |
2732 | goto err_stop; | |
2733 | } | |
2734 | ||
2735 | hid_device_io_start(hdev); | |
2736 | ||
95ea4d9f | 2737 | ret = joycon_init(hdev); |
2af16c1f | 2738 | if (ret) { |
95ea4d9f MF |
2739 | hid_err(hdev, "Failed to initialize controller; ret=%d\n", ret); |
2740 | goto err_close; | |
4ff5b108 DO |
2741 | } |
2742 | ||
c5e62676 | 2743 | /* Initialize the leds */ |
697e5c7a | 2744 | ret = joycon_leds_create(ctlr); |
c5e62676 DO |
2745 | if (ret) { |
2746 | hid_err(hdev, "Failed to create leds; ret=%d\n", ret); | |
2747 | goto err_close; | |
2748 | } | |
2749 | ||
08ebba5c DO |
2750 | /* Initialize the battery power supply */ |
2751 | ret = joycon_power_supply_create(ctlr); | |
2752 | if (ret) { | |
2753 | hid_err(hdev, "Failed to create power_supply; ret=%d\n", ret); | |
2754 | goto err_close; | |
2755 | } | |
2756 | ||
2af16c1f DO |
2757 | ret = joycon_input_create(ctlr); |
2758 | if (ret) { | |
2759 | hid_err(hdev, "Failed to create input device; ret=%d\n", ret); | |
2760 | goto err_close; | |
2761 | } | |
2762 | ||
2763 | ctlr->ctlr_state = JOYCON_CTLR_STATE_READ; | |
2764 | ||
2765 | hid_dbg(hdev, "probe - success\n"); | |
2766 | return 0; | |
2767 | ||
2af16c1f DO |
2768 | err_close: |
2769 | hid_hw_close(hdev); | |
2770 | err_stop: | |
2771 | hid_hw_stop(hdev); | |
c4eae84f DO |
2772 | err_wq: |
2773 | destroy_workqueue(ctlr->rumble_queue); | |
2af16c1f DO |
2774 | err: |
2775 | hid_err(hdev, "probe - fail = %d\n", ret); | |
2776 | return ret; | |
2777 | } | |
2778 | ||
2779 | static void nintendo_hid_remove(struct hid_device *hdev) | |
2780 | { | |
c4eae84f | 2781 | struct joycon_ctlr *ctlr = hid_get_drvdata(hdev); |
012bd52c | 2782 | unsigned long flags; |
c4eae84f | 2783 | |
2af16c1f | 2784 | hid_dbg(hdev, "remove\n"); |
012bd52c DO |
2785 | |
2786 | /* Prevent further attempts at sending subcommands. */ | |
2787 | spin_lock_irqsave(&ctlr->lock, flags); | |
2788 | ctlr->ctlr_state = JOYCON_CTLR_STATE_REMOVED; | |
2789 | spin_unlock_irqrestore(&ctlr->lock, flags); | |
2790 | ||
c4eae84f | 2791 | destroy_workqueue(ctlr->rumble_queue); |
012bd52c | 2792 | |
2af16c1f DO |
2793 | hid_hw_close(hdev); |
2794 | hid_hw_stop(hdev); | |
2795 | } | |
2796 | ||
95ea4d9f MF |
2797 | #ifdef CONFIG_PM |
2798 | ||
2799 | static int nintendo_hid_resume(struct hid_device *hdev) | |
2800 | { | |
2801 | int ret = joycon_init(hdev); | |
2802 | ||
2803 | if (ret) | |
2804 | hid_err(hdev, "Failed to restore controller after resume"); | |
2805 | ||
2806 | return ret; | |
2807 | } | |
2808 | ||
2809 | #endif | |
2810 | ||
2af16c1f DO |
2811 | static const struct hid_device_id nintendo_hid_devices[] = { |
2812 | { HID_USB_DEVICE(USB_VENDOR_ID_NINTENDO, | |
2813 | USB_DEVICE_ID_NINTENDO_PROCON) }, | |
94f18bb1 RM |
2814 | { HID_USB_DEVICE(USB_VENDOR_ID_NINTENDO, |
2815 | USB_DEVICE_ID_NINTENDO_SNESCON) }, | |
2816 | { HID_USB_DEVICE(USB_VENDOR_ID_NINTENDO, | |
2817 | USB_DEVICE_ID_NINTENDO_GENCON) }, | |
2818 | { HID_USB_DEVICE(USB_VENDOR_ID_NINTENDO, | |
2819 | USB_DEVICE_ID_NINTENDO_N64CON) }, | |
2af16c1f DO |
2820 | { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, |
2821 | USB_DEVICE_ID_NINTENDO_PROCON) }, | |
294a8287 DO |
2822 | { HID_USB_DEVICE(USB_VENDOR_ID_NINTENDO, |
2823 | USB_DEVICE_ID_NINTENDO_CHRGGRIP) }, | |
2af16c1f DO |
2824 | { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, |
2825 | USB_DEVICE_ID_NINTENDO_JOYCONL) }, | |
2826 | { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, | |
2827 | USB_DEVICE_ID_NINTENDO_JOYCONR) }, | |
94f18bb1 RM |
2828 | { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, |
2829 | USB_DEVICE_ID_NINTENDO_SNESCON) }, | |
2830 | { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, | |
2831 | USB_DEVICE_ID_NINTENDO_GENCON) }, | |
2832 | { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, | |
2833 | USB_DEVICE_ID_NINTENDO_N64CON) }, | |
2af16c1f DO |
2834 | { } |
2835 | }; | |
2836 | MODULE_DEVICE_TABLE(hid, nintendo_hid_devices); | |
2837 | ||
2838 | static struct hid_driver nintendo_hid_driver = { | |
2839 | .name = "nintendo", | |
2840 | .id_table = nintendo_hid_devices, | |
2841 | .probe = nintendo_hid_probe, | |
2842 | .remove = nintendo_hid_remove, | |
2843 | .raw_event = nintendo_hid_event, | |
95ea4d9f MF |
2844 | |
2845 | #ifdef CONFIG_PM | |
2846 | .resume = nintendo_hid_resume, | |
2847 | #endif | |
2af16c1f DO |
2848 | }; |
2849 | module_hid_driver(nintendo_hid_driver); | |
2850 | ||
2851 | MODULE_LICENSE("GPL"); | |
94f18bb1 RM |
2852 | MODULE_AUTHOR("Ryan McClelland <rymcclel@gmail.com>"); |
2853 | MODULE_AUTHOR("Emily Strickland <linux@emily.st>"); | |
2af16c1f DO |
2854 | MODULE_AUTHOR("Daniel J. Ogorchock <djogorchock@gmail.com>"); |
2855 | MODULE_DESCRIPTION("Driver for Nintendo Switch Controllers"); |