drivers/hid/hid-nintendo.c

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