brintos / linux-shallow public Read only

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