diff --git a/MAINTAINERS b/MAINTAINERS
index 39e75bbefc3d..9fc55efd63bc 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -14572,6 +14572,12 @@ F:	kernel/dma/swiotlb.c
 F:	arch/*/kernel/pci-swiotlb.c
 F:	include/linux/swiotlb.h
 
+SWITCHCON HID DRIVER
+M:	Daniel J. Ogorchock <djogorchock@gmail.com>
+L:	linux-input@vger.kernel.org
+S:	Maintained
+F:	drivers/hid/hid-switchcon*
+
 SWITCHDEV
 M:	Jiri Pirko <jiri@resnulli.us>
 M:	Ivan Vecera <ivecera@redhat.com>
diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
index 41e9935fc584..3360267eb5b0 100644
--- a/drivers/hid/Kconfig
+++ b/drivers/hid/Kconfig
@@ -943,6 +943,19 @@ config SMARTJOYPLUS_FF
 	Say Y here if you have a SmartJoy PLUS PS2/USB adapter and want to
 	enable force feedback support for it.
 
+config HID_SWITCHCON
+	tristate "Nintendo Joy-Con and Pro Controller support"
+	depends on HID
+	depends on USB_HID
+	depends on BT_HIDP
+	help
+	Adds support for the Nintendo Switch Joy-Cons and Pro Controller.
+	All controllers support bluetooth, and the Pro Controller also supports
+	its USB mode.
+
+	To compile this driver as a module, choose M here: the
+	module will be called hid-switchcon.
+
 config HID_TIVO
 	tristate "TiVo Slide Bluetooth remote control support"
 	depends on HID
diff --git a/drivers/hid/Makefile b/drivers/hid/Makefile
index 896a51ce7ce0..e708e682c4b8 100644
--- a/drivers/hid/Makefile
+++ b/drivers/hid/Makefile
@@ -103,6 +103,7 @@ obj-$(CONFIG_HID_SPEEDLINK)	+= hid-speedlink.o
 obj-$(CONFIG_HID_STEAM)		+= hid-steam.o
 obj-$(CONFIG_HID_STEELSERIES)	+= hid-steelseries.o
 obj-$(CONFIG_HID_SUNPLUS)	+= hid-sunplus.o
+obj-$(CONFIG_HID_SWITCHCON)	+= hid-switchcon.o
 obj-$(CONFIG_HID_GREENASIA)	+= hid-gaff.o
 obj-$(CONFIG_HID_THRUSTMASTER)	+= hid-tmff.o
 obj-$(CONFIG_HID_TIVO)		+= hid-tivo.o
diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
index 518fa76414f5..cd41e971801e 100644
--- a/drivers/hid/hid-ids.h
+++ b/drivers/hid/hid-ids.h
@@ -848,6 +848,9 @@
 #define USB_VENDOR_ID_NINTENDO		0x057e
 #define USB_DEVICE_ID_NINTENDO_WIIMOTE	0x0306
 #define USB_DEVICE_ID_NINTENDO_WIIMOTE2	0x0330
+#define USB_DEVICE_ID_NINTENDO_JOYCONL	0x2006
+#define USB_DEVICE_ID_NINTENDO_JOYCONR  0x2007
+#define USB_DEVICE_ID_NINTENDO_PROCON   0x2009
 
 #define USB_VENDOR_ID_NOVATEK		0x0603
 #define USB_DEVICE_ID_NOVATEK_PCT	0x0600
diff --git a/drivers/hid/hid-quirks.c b/drivers/hid/hid-quirks.c
index 94088c0ed68a..c22adffa1233 100644
--- a/drivers/hid/hid-quirks.c
+++ b/drivers/hid/hid-quirks.c
@@ -512,6 +512,12 @@ static const struct hid_device_id hid_have_special_driver[] = {
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, USB_DEVICE_ID_NINTENDO_WIIMOTE) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, USB_DEVICE_ID_NINTENDO_WIIMOTE2) },
 #endif
+#if IS_ENABLED(CONFIG_HID_SWITCHCON)
+	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, USB_DEVICE_ID_NINTENDO_JOYCONL) },
+	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, USB_DEVICE_ID_NINTENDO_JOYCONR) },
+	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, USB_DEVICE_ID_NINTENDO_PROCON) },
+	{ HID_USB_DEVICE(USB_VENDOR_ID_NINTENDO, USB_DEVICE_ID_NINTENDO_PROCON) },
+#endif
 #if IS_ENABLED(CONFIG_HID_NTI)
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTI, USB_DEVICE_ID_USB_SUN) },
 #endif
diff --git a/drivers/hid/hid-switchcon.c b/drivers/hid/hid-switchcon.c
new file mode 100644
index 000000000000..126f3b39cbfe
--- /dev/null
+++ b/drivers/hid/hid-switchcon.c
@@ -0,0 +1,1156 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * HID driver for Nintendo Switch Joy-Cons and Pro Controllers
+ *
+ * Copyright (c) 2019 Daniel J. Ogorchock <djogorchock@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * The following resources/projects were referenced for this driver:
+ *   https://github.com/dekuNukem/Nintendo_Switch_Reverse_Engineering
+ *   https://gitlab.com/pjranki/joycon-linux-kernel (Peter Rankin)
+ *   https://github.com/FrotBot/SwitchProConLinuxUSB
+ *   https://github.com/MTCKC/ProconXInput
+ *   hid-wiimote kernel hid driver
+ *
+ * This driver supports the Nintendo Switch Joy-Cons and Pro Controllers. The
+ * Pro Controllers can either be used over USB or Bluetooth. The Joy-Cons can
+ * be used either as a pair or individually in their horizontal mode.
+ *
+ * When a Joy-Con is paired, its LEDs will begin flashing to signal that it is
+ * in its "searching" mode. By holding the triggers of two Joy-Cons at the same
+ * time, they will be combined into one input. To use a Joy-Con alone in its
+ * horizontal mode, hold SL and SR at the same time while it is in the
+ * "searching" mode.
+ *
+ * The driver will retrieve the factory calibration info from the controllers,
+ * so little to no user calibration should be required.
+ *
+ */
+
+#include "hid-ids.h"
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/hid.h>
+#include <linux/input.h>
+#include <linux/module.h>
+#include <linux/spinlock.h>
+
+/* Reference the url below for the following HID report defines:
+ * https://github.com/dekuNukem/Nintendo_Switch_Reverse_Engineering
+ */
+
+/* Output Reports */
+#define SC_OUTPUT_RUMBLE_AND_SUBCMD	0x01
+#define SC_OUTPUT_FW_UPDATE_PKT		0x03
+#define	SC_OUTPUT_RUMBLE_ONLY		0x10
+#define SC_OUTPUT_MCU_DATA		0x11
+#define SC_OUTPUT_USB_CMD		0x80
+
+/* Subcommand IDs */
+#define SC_SUBCMD_STATE			0x00
+#define SC_SUBCMD_MANUAL_BT_PAIRING	0x01
+#define SC_SUBCMD_REQ_DEV_INFO		0x02
+#define SC_SUBCMD_SET_REPORT_MODE	0x03
+#define SC_SUBCMD_TRIGGERS_ELAPSED	0x04
+#define SC_SUBCMD_GET_PAGE_LIST_STATE	0x05
+#define SC_SUBCMD_SET_HCI_STATE		0x06
+#define SC_SUBCMD_RESET_PAIRING_INFO	0x07
+#define SC_SUBCMD_LOW_POWER_MODE	0x08
+#define SC_SUBCMD_SPI_FLASH_READ	0x10
+#define SC_SUBCMD_SPI_FLASH_WRITE	0x11
+#define SC_SUBCMD_RESET_MCU		0x20
+#define SC_SUBCMD_SET_MCU_CONFIG	0x21
+#define SC_SUBCMD_SET_MCU_STATE		0x22
+#define SC_SUBCMD_SET_PLAYER_LIGHTS	0x30
+#define SC_SUBCMD_GET_PLAYER_LIGHTS	0x31
+#define SC_SUBCMD_SET_HOME_LIGHT	0x38
+#define SC_SUBCMD_ENABLE_IMU		0x40
+#define SC_SUBCMD_SET_IMU_SENSITIVITY	0x41
+#define SC_SUBCMD_WRITE_IMU_REG		0x42
+#define SC_SUBCMD_READ_IMU_REG		0x43
+#define SC_SUBCMD_ENABLE_VIBRATION	0x48
+#define SC_SUBCMD_GET_REGULATED_VOLTAGE	0x50
+
+/* Input Reports */
+#define SC_INPUT_BUTTON_EVENT		0x3F
+#define SC_INPUT_SUBCMD_REPLY		0x21
+#define SC_INPUT_IMU_DATA		0x30
+#define SC_INPUT_MCU_DATA		0x31
+#define SC_INPUT_USB_RESPONSE		0x81
+
+/* Feature Reports */
+#define SC_FEATURE_LAST_SUBCMD		0x02
+#define SC_FEATURE_OTA_FW_UPGRADE	0x70
+#define SC_FEATURE_SETUP_MEM_READ	0x71
+#define SC_FEATURE_MEM_READ		0x72
+#define SC_FEATURE_ERASE_MEM_SECTOR	0x73
+#define SC_FEATURE_MEM_WRITE		0x74
+#define SC_FEATURE_LAUNCH		0x75
+
+/* USB Commands */
+#define SC_USB_CMD_CONN_STATUS		0x01
+#define SC_USB_CMD_HANDSHAKE		0x02
+#define SC_USB_CMD_BAUDRATE_3M		0x03
+#define SC_USB_CMD_NO_TIMEOUT		0x04
+#define SC_USB_CMD_EN_TIMEOUT		0x05
+#define SC_USB_RESET			0x06
+#define SC_USB_PRE_HANDSHAKE		0x91
+#define SC_USB_SEND_UART		0x92
+
+/* SPI storage addresses of factory calibration data */
+#define	SC_CAL_DATA_START		0x603d
+#define	SC_CAL_DATA_END			0x604e
+#define SC_CAL_DATA_SIZE	(SC_CAL_DATA_END - SC_CAL_DATA_START + 1)
+
+
+/* The raw analog joystick values will be mapped in terms of this magnitude */
+#define SC_MAX_STICK_MAG	32767
+#define SC_STICK_FUZZ		250
+#define SC_STICK_FLAT		500
+
+struct switchcon_ctlr;
+struct switchcon_input;
+
+/* States for controller state machine */
+enum switchcon_ctlr_state {
+	SWITCHCON_CTLR_STATE_INIT,
+	SWITCHCON_CTLR_STATE_USB_SET_BAUD,
+	SWITCHCON_CTLR_STATE_USB_HANDSHAKE,
+	SWITCHCON_CTLR_STATE_CALIBRATION,
+	SWITCHCON_CTLR_STATE_POST_CALIBRATION,
+	SWITCHCON_CTLR_STATE_SEARCH,
+	SWITCHCON_CTLR_STATE_READ,
+};
+
+/* Function pointers will differ based on controller type */
+struct switchcon_impl {
+	int (*init)(struct switchcon_ctlr *ctlr);
+	void (*deinit)(struct switchcon_ctlr *ctlr);
+	int (*handle_event)(struct switchcon_ctlr *ctlr, u8 *data, int size);
+};
+
+struct switchcon_output {
+	u8	*data;
+	u8	size;
+};
+
+struct switchcon_stick_cal {
+	s32	x_max;
+	s32	x_min;
+	s32	x_center;
+	s32	y_max;
+	s32	y_min;
+	s32	y_center;
+};
+
+#define SC_OUTPUT_BUF_SIZE	50
+/* Each physical controller is associated with a switchcon_ctlr struct */
+struct switchcon_ctlr {
+	struct hid_device		*hdev;
+	struct switchcon_input		*switchcon_in;
+	const struct switchcon_impl	*impl;
+	bool				is_right_joycon;
+	bool				searching;
+	enum switchcon_ctlr_state	ctlr_state;
+	u8				subcmd_num;
+	struct switchcon_output		output_buf[SC_OUTPUT_BUF_SIZE];
+	u8				output_head;
+	u8				output_tail;
+	spinlock_t			output_lock;
+	struct work_struct		output_worker;
+	struct work_struct		create_input_worker;
+	struct work_struct		detect_pair_worker;
+	struct work_struct		create_horiz_worker;
+	struct mutex			mutex;
+
+	/* factory calibration data */
+	struct switchcon_stick_cal	left_stick_cal;
+	struct switchcon_stick_cal	right_stick_cal;
+
+	/* buttons/sticks */
+	u16	left_stick_x;
+	u16	left_stick_y;
+	u16	right_stick_x;
+	u16	right_stick_y;
+	bool	but_y;
+	bool	but_x;
+	bool	but_b;
+	bool	but_a;
+	bool	but_sr_right_jc;
+	bool	but_sl_right_jc;
+	bool	but_r;
+	bool	but_zr;
+	bool	but_l;
+	bool	but_zl;
+	bool	but_minus;
+	bool	but_plus;
+	bool	but_rstick;
+	bool	but_lstick;
+	bool	but_home;
+	bool	but_capture;
+	bool	but_down;
+	bool	but_up;
+	bool	but_right;
+	bool	but_left;
+	bool	but_sr_left_jc;
+	bool	but_sl_left_jc;
+
+};
+
+enum switchcon_input_type {
+	SWITCHCON_INPUT_TYPE_PROCON,
+	SWITCHCON_INPUT_TYPE_JOYCONS,
+	SWITCHCON_INPUT_TYPE_JOYCON_H,
+};
+
+static const char * const switchcon_input_names[] = {
+	"Nintendo Switch Pro Controller",
+	"Nintendo Switch Joy-Cons",
+	"Nintendo Switch Joy-Con Horizontal",
+};
+
+/* Each linux input device is associated with a switchcon_input */
+struct switchcon_input {
+	enum switchcon_input_type	type;
+	struct input_dev	*input;
+	struct switchcon_ctlr	*ctlr_left; /* left joycon or pro controller */
+	struct switchcon_ctlr	*ctlr_right; /* only used for joycons */
+	struct mutex		mutex;
+	struct work_struct	input_worker;
+};
+
+static int switchcon_ctlr_init(struct switchcon_ctlr *ctlr)
+{
+	if (ctlr->impl && ctlr->impl->init)
+		return ctlr->impl->init(ctlr);
+	else
+		return -EINVAL;
+}
+
+static void switchcon_ctlr_deinit(struct switchcon_ctlr *ctlr)
+{
+	if (ctlr->impl && ctlr->impl->deinit)
+		ctlr->impl->deinit(ctlr);
+}
+
+static int switchcon_ctlr_handle_event(struct switchcon_ctlr *ctlr, u8 *data,
+								    int size)
+{
+	if (ctlr->impl && ctlr->impl->handle_event)
+		return ctlr->impl->handle_event(ctlr, data, size);
+	else
+		return -EINVAL;
+}
+
+static int switchcon_hid_queue_send(struct switchcon_ctlr *ctlr,
+				    const u8 *buffer, size_t count)
+{
+	struct switchcon_output output;
+
+	output.size = count;
+	output.data = kmemdup(buffer, count, GFP_ATOMIC);
+	if (!output.data)
+		return -ENOMEM;
+
+	spin_lock(&ctlr->output_lock);
+
+	ctlr->output_buf[ctlr->output_head++] = output;
+	if (ctlr->output_head == SC_OUTPUT_BUF_SIZE)
+		ctlr->output_head = 0;
+	schedule_work(&ctlr->output_worker);
+
+	spin_unlock(&ctlr->output_lock);
+	return 0;
+}
+
+static int switchcon_queue_subcommand(struct switchcon_ctlr *ctlr,
+				      const u8 *buffer, size_t count)
+{
+	/* header including packet number and empty rumble data */
+	u8 header[10] = {SC_OUTPUT_RUMBLE_AND_SUBCMD, ctlr->subcmd_num};
+	struct switchcon_output output;
+	u8 *buf;
+
+	/* the packet number loops after 0xF */
+	ctlr->subcmd_num++;
+	if (ctlr->subcmd_num > 0xF)
+		ctlr->subcmd_num = 0;
+
+	buf = kzalloc(sizeof(header) + count, GFP_KERNEL);
+	if (!buf)
+		return -ENOMEM;
+
+	memcpy(buf, header, sizeof(header));
+	memcpy(buf + sizeof(header), buffer, count);
+	output.data = buf;
+	output.size = count + sizeof(header);
+
+	spin_lock(&ctlr->output_lock);
+
+	ctlr->output_buf[ctlr->output_head++] = output;
+	if (ctlr->output_head == SC_OUTPUT_BUF_SIZE)
+		ctlr->output_head = 0;
+	schedule_work(&ctlr->output_worker);
+
+	spin_unlock(&ctlr->output_lock);
+	return 0;
+}
+
+static void switchcon_set_player_leds(struct switchcon_ctlr *ctlr,
+				      u8 flash, u8 on)
+{
+	u8 buffer[] = {SC_SUBCMD_SET_PLAYER_LIGHTS, (flash << 4) | on};
+
+	switchcon_queue_subcommand(ctlr, buffer, sizeof(buffer));
+}
+
+static void switchcon_request_calibration(struct switchcon_ctlr *ctlr)
+{
+	u8 cal_subcmd[]		= {SC_SUBCMD_SPI_FLASH_READ,
+				   0xFF & SC_CAL_DATA_START,
+				   0xFF & (SC_CAL_DATA_START >> 8),
+				   0, 0, SC_CAL_DATA_SIZE};
+
+	switchcon_queue_subcommand(ctlr, cal_subcmd, sizeof(cal_subcmd));
+	hid_dbg(ctlr->hdev, "requested cal data\n");
+}
+
+static void switchcon_request_report_mode(struct switchcon_ctlr *ctlr)
+{
+	u8 inputmode_subcmd[]	= {SC_SUBCMD_SET_REPORT_MODE, 0x30};
+
+	switchcon_queue_subcommand(ctlr, inputmode_subcmd,
+				   sizeof(inputmode_subcmd));
+	hid_dbg(ctlr->hdev, "requested 0x30 report mode\n");
+}
+
+static int switchcon_map_x_stick_val(struct switchcon_stick_cal *cal, s32 val)
+{
+	s32 center	= cal->x_center;
+	s32 min		= cal->x_min;
+	s32 max		= cal->x_max;
+	s64 newVal;
+
+	if (val > center) {
+		newVal = (val - center) * SC_MAX_STICK_MAG;
+		do_div(newVal, max - center);
+	} else {
+		newVal = (center - val) * SC_MAX_STICK_MAG;
+		do_div(newVal, center - min);
+		newVal *= -1;
+	}
+	if (newVal > SC_MAX_STICK_MAG)
+		newVal = SC_MAX_STICK_MAG;
+	if (newVal < -SC_MAX_STICK_MAG)
+		newVal = -SC_MAX_STICK_MAG;
+	return (int)newVal;
+}
+
+static int switchcon_map_y_stick_val(struct switchcon_stick_cal *cal, s32 val)
+{
+	s32 center	= cal->y_center;
+	s32 min		= cal->y_min;
+	s32 max		= cal->y_max;
+	s64 newVal;
+
+	if (val > center) {
+		newVal = (val - center) * SC_MAX_STICK_MAG;
+		do_div(newVal, max - center);
+	} else {
+		newVal = (center - val) * SC_MAX_STICK_MAG;
+		do_div(newVal, center - min);
+		newVal *= -1;
+	}
+	if (newVal > SC_MAX_STICK_MAG)
+		newVal = SC_MAX_STICK_MAG;
+	if (newVal < -SC_MAX_STICK_MAG)
+		newVal = -SC_MAX_STICK_MAG;
+	return (int)newVal;
+}
+
+static void switchcon_update_input_handler(struct work_struct *ws)
+{
+	struct switchcon_input *sc_input = container_of(ws,
+					struct switchcon_input, input_worker);
+	struct input_dev *dev = sc_input->input;
+	struct switchcon_ctlr *ctlr_l = sc_input->ctlr_left;
+	struct switchcon_ctlr *ctlr_r = sc_input->ctlr_right;
+	int s_l_x;
+	int s_l_y;
+	int s_r_x;
+	int s_r_y;
+
+	if (!ctlr_r)
+		ctlr_r = ctlr_l;
+
+	mutex_lock(&sc_input->mutex);
+	mutex_lock(&ctlr_l->mutex);
+	if (sc_input->ctlr_right)
+		mutex_lock(&sc_input->ctlr_right->mutex);
+
+	/* map the stick values */
+	s_l_x = switchcon_map_x_stick_val(&ctlr_l->left_stick_cal,
+					  ctlr_l->left_stick_x);
+	s_l_y = switchcon_map_y_stick_val(&ctlr_l->left_stick_cal,
+					  ctlr_l->left_stick_y);
+	s_r_x = switchcon_map_x_stick_val(&ctlr_r->right_stick_cal,
+					  ctlr_r->right_stick_x);
+	s_r_y = switchcon_map_y_stick_val(&ctlr_r->right_stick_cal,
+					  ctlr_r->right_stick_y);
+
+	if (sc_input->type == SWITCHCON_INPUT_TYPE_JOYCON_H) {
+		if (ctlr_l->is_right_joycon) {
+			/* report stick */
+			input_report_abs(dev, ABS_X, s_r_y);
+			input_report_abs(dev, ABS_Y, -s_r_x);
+
+			/* report buttons */
+			input_report_key(dev, BTN_WEST,	  ctlr_r->but_b);
+			input_report_key(dev, BTN_NORTH,  ctlr_r->but_y);
+			input_report_key(dev, BTN_EAST,	  ctlr_r->but_x);
+			input_report_key(dev, BTN_SOUTH,  ctlr_r->but_a);
+			input_report_key(dev, BTN_THUMBL, ctlr_r->but_rstick);
+			input_report_key(dev, BTN_START,  ctlr_r->but_plus);
+			input_report_key(dev, BTN_MODE,	  ctlr_r->but_home);
+			input_report_key(dev, BTN_TR,
+					 ctlr_r->but_sr_right_jc);
+			input_report_key(dev, BTN_TL,
+					 ctlr_r->but_sl_right_jc);
+		} else {
+			/* report stick */
+			input_report_abs(dev, ABS_X, -s_l_y);
+			input_report_abs(dev, ABS_Y, s_l_x);
+
+			/* report buttons */
+			input_report_key(dev, BTN_WEST,	  ctlr_l->but_up);
+			input_report_key(dev, BTN_NORTH,  ctlr_l->but_right);
+			input_report_key(dev, BTN_EAST,	  ctlr_l->but_down);
+			input_report_key(dev, BTN_SOUTH,  ctlr_l->but_left);
+			input_report_key(dev, BTN_THUMBL, ctlr_l->but_lstick);
+			input_report_key(dev, BTN_START,  ctlr_l->but_minus);
+			input_report_key(dev, BTN_MODE,	  ctlr_l->but_capture);
+			input_report_key(dev, BTN_TR,
+					 ctlr_l->but_sr_left_jc);
+			input_report_key(dev, BTN_TL,
+					 ctlr_l->but_sl_left_jc);
+		}
+	} else {
+		/* report sticks */
+		input_report_abs(dev, ABS_X, s_l_x);
+		input_report_abs(dev, ABS_Y, s_l_y);
+		input_report_abs(dev, ABS_RX, s_r_x);
+		input_report_abs(dev, ABS_RY, s_r_y);
+
+		/* report buttons */
+		input_report_key(dev, BTN_WEST,		ctlr_r->but_y);
+		input_report_key(dev, BTN_NORTH,	ctlr_r->but_x);
+		input_report_key(dev, BTN_EAST,		ctlr_r->but_a);
+		input_report_key(dev, BTN_SOUTH,	ctlr_r->but_b);
+		input_report_key(dev, BTN_TR,		ctlr_r->but_r);
+		input_report_key(dev, BTN_TR2,		ctlr_r->but_zr);
+		input_report_key(dev, BTN_TL,		ctlr_l->but_l);
+		input_report_key(dev, BTN_TL2,		ctlr_l->but_zl);
+		input_report_key(dev, BTN_SELECT,	ctlr_l->but_minus);
+		input_report_key(dev, BTN_START,	ctlr_r->but_plus);
+		input_report_key(dev, BTN_THUMBL,	ctlr_l->but_lstick);
+		input_report_key(dev, BTN_THUMBR,	ctlr_r->but_rstick);
+		input_report_key(dev, BTN_MODE,		ctlr_r->but_home);
+		input_report_key(dev, BTN_Z,		ctlr_l->but_capture);
+		input_report_key(dev, BTN_DPAD_DOWN,	ctlr_l->but_down);
+		input_report_key(dev, BTN_DPAD_UP,	ctlr_l->but_up);
+		input_report_key(dev, BTN_DPAD_RIGHT,	ctlr_l->but_right);
+		input_report_key(dev, BTN_DPAD_LEFT,	ctlr_l->but_left);
+	}
+
+	input_sync(dev);
+
+	mutex_unlock(&ctlr_l->mutex);
+	if (sc_input->ctlr_right)
+		mutex_unlock(&sc_input->ctlr_right->mutex);
+	mutex_unlock(&sc_input->mutex);
+}
+
+static void switchcon_input_destroy(struct switchcon_input *sc_input)
+{
+	hid_dbg(sc_input->ctlr_left->hdev, "destroying input\n");
+	mutex_lock(&sc_input->mutex);
+
+	sc_input->ctlr_left->switchcon_in = NULL;
+	mutex_lock(&sc_input->ctlr_left->mutex);
+	if (sc_input->ctlr_right) {
+		mutex_lock(&sc_input->ctlr_right->mutex);
+		sc_input->ctlr_right->switchcon_in = NULL;
+	}
+	/* set the joycon states to searching */
+	sc_input->ctlr_left->ctlr_state = SWITCHCON_CTLR_STATE_POST_CALIBRATION;
+	if (sc_input->ctlr_right)
+		sc_input->ctlr_right->ctlr_state =
+					  SWITCHCON_CTLR_STATE_POST_CALIBRATION;
+
+	input_unregister_device(sc_input->input);
+
+	mutex_unlock(&sc_input->ctlr_left->mutex);
+	if (sc_input->ctlr_right)
+		mutex_unlock(&sc_input->ctlr_right->mutex);
+	mutex_unlock(&sc_input->mutex);
+	mutex_destroy(&sc_input->mutex);
+	kfree(sc_input);
+}
+
+static const unsigned int switchcon_button_inputs[] = {
+	BTN_SOUTH, BTN_EAST, BTN_NORTH, BTN_WEST,
+	BTN_TL, BTN_TR, BTN_START, BTN_MODE, BTN_THUMBL,
+	/* the following buttons do not apply to a single, horizontal joycon */
+	BTN_TL2, BTN_TR2, BTN_SELECT, BTN_Z, BTN_THUMBR,
+	BTN_DPAD_UP, BTN_DPAD_DOWN, BTN_DPAD_LEFT, BTN_DPAD_RIGHT,
+	0 /* 0 signals end of array */
+};
+
+DEFINE_MUTEX(switchcon_input_num_mutex);
+static struct switchcon_input *switchcon_input_create(
+					enum switchcon_input_type type,
+					struct switchcon_ctlr *ctlr_l,
+					struct switchcon_ctlr *ctlr_r)
+{
+	struct switchcon_input *sc_input;
+	struct hid_device *hdev;
+	static int input_num = 1;
+	int i;
+	int ret;
+
+	if (!ctlr_l)
+		return ERR_PTR(-EINVAL);
+	hdev = ctlr_l->hdev;
+	sc_input = kzalloc(sizeof(*sc_input), GFP_KERNEL);
+	if (!sc_input)
+		return ERR_PTR(-ENOMEM);
+
+	sc_input->type		= type;
+	sc_input->ctlr_left	= ctlr_l;
+	sc_input->ctlr_right	= ctlr_r;
+	if (!ctlr_r)
+		ctlr_r = ctlr_l;
+
+	sc_input->input = input_allocate_device();
+	if (!sc_input->input) {
+		ret = -ENOMEM;
+		goto err;
+	}
+	sc_input->input->dev.parent	= &hdev->dev;
+	sc_input->input->id.bustype	= hdev->bus;
+	sc_input->input->id.vendor	= hdev->vendor;
+	sc_input->input->id.product	= hdev->product;
+	sc_input->input->id.version	= hdev->version;
+	sc_input->input->name = switchcon_input_names[sc_input->type];
+	input_set_drvdata(sc_input->input, sc_input);
+
+	/* set up button inputs */
+	for (i = 0; switchcon_button_inputs[i] > 0; i++) {
+		input_set_capability(sc_input->input, EV_KEY,
+				     switchcon_button_inputs[i]);
+		if (switchcon_button_inputs[i] == BTN_THUMBL
+		 && sc_input->type == SWITCHCON_INPUT_TYPE_JOYCON_H)
+			break;
+	}
+
+	/* set up sticks */
+	input_set_abs_params(sc_input->input, ABS_X,
+			     -SC_MAX_STICK_MAG, SC_MAX_STICK_MAG,
+			     SC_STICK_FUZZ, SC_STICK_FLAT);
+	input_set_abs_params(sc_input->input, ABS_Y,
+			     -SC_MAX_STICK_MAG, SC_MAX_STICK_MAG,
+			     SC_STICK_FUZZ, SC_STICK_FLAT);
+	/* set up right stick if necessary for controller type */
+	if (sc_input->type != SWITCHCON_INPUT_TYPE_JOYCON_H) {
+		input_set_abs_params(sc_input->input, ABS_RX,
+				     -SC_MAX_STICK_MAG, SC_MAX_STICK_MAG,
+				     SC_STICK_FUZZ, SC_STICK_FLAT);
+		input_set_abs_params(sc_input->input, ABS_RY,
+				     -SC_MAX_STICK_MAG, SC_MAX_STICK_MAG,
+				     SC_STICK_FUZZ, SC_STICK_FLAT);
+	}
+
+	ret = input_register_device(sc_input->input);
+	if (ret)
+		goto err_input;
+
+	mutex_init(&sc_input->mutex);
+	INIT_WORK(&sc_input->input_worker, switchcon_update_input_handler);
+
+	/* Set the controller player leds based on input number */
+	mutex_lock(&switchcon_input_num_mutex);
+	/* Need to send multiple times to make sure it's not ignored */
+	for (i = 0; i < 5; i++) {
+		switchcon_set_player_leds(ctlr_l, 0, 0xF >> (4 - input_num));
+		switchcon_set_player_leds(ctlr_r, 0, 0xF >> (4 - input_num));
+	}
+	if (++input_num > 4)
+		input_num = 1;
+	mutex_unlock(&switchcon_input_num_mutex);
+
+	return sc_input;
+err_input:
+	input_free_device(sc_input->input);
+err:
+	kfree(sc_input);
+	return ERR_PTR(ret);
+}
+
+static void switchcon_create_procon_input_handler(struct work_struct *ws)
+{
+	struct switchcon_ctlr *ctlr = container_of(ws, struct switchcon_ctlr,
+							create_input_worker);
+	hid_dbg(ctlr->hdev, "create_procon_input_handler\n");
+
+	mutex_lock(&ctlr->mutex);
+
+	ctlr->switchcon_in = switchcon_input_create(SWITCHCON_INPUT_TYPE_PROCON,
+								    ctlr, NULL);
+	if (IS_ERR(ctlr->switchcon_in)) {
+		hid_err(ctlr->hdev, "failed to create input\n");
+		ctlr->switchcon_in = NULL;
+	}
+
+	mutex_unlock(&ctlr->mutex);
+}
+
+DEFINE_MUTEX(switchcon_detect_pair_mutex);
+static void switchcon_detect_pair_handler(struct work_struct *ws)
+{
+	struct switchcon_ctlr *ctlr = container_of(ws, struct switchcon_ctlr,
+							detect_pair_worker);
+	static struct switchcon_ctlr *ctlr_l;
+	static struct switchcon_ctlr *ctlr_r;
+
+	mutex_lock(&switchcon_detect_pair_mutex);
+	mutex_lock(&ctlr->mutex);
+	/* Check if this is a controller no longer searching for partner */
+	if (!ctlr->searching) {
+		if (ctlr == ctlr_l)
+			ctlr_l = NULL;
+		if (ctlr == ctlr_r)
+			ctlr_r = NULL;
+	} else {
+		if (!ctlr->is_right_joycon && ctlr_l == NULL)
+			ctlr_l = ctlr;
+		if (ctlr->is_right_joycon && ctlr_r == NULL)
+			ctlr_r = ctlr;
+
+		/* see if there's a pair */
+		if (ctlr_l && ctlr_r) {
+			if (ctlr == ctlr_l)
+				mutex_lock(&ctlr_r->mutex);
+			else
+				mutex_lock(&ctlr_l->mutex);
+			hid_info(ctlr->hdev, "Joy-Con pair found\n");
+
+			ctlr_l->switchcon_in = switchcon_input_create(
+						   SWITCHCON_INPUT_TYPE_JOYCONS,
+						   ctlr_l, ctlr_r);
+			ctlr_r->switchcon_in = ctlr_l->switchcon_in;
+			ctlr_l->ctlr_state = SWITCHCON_CTLR_STATE_READ;
+			ctlr_r->ctlr_state = SWITCHCON_CTLR_STATE_READ;
+
+			if (IS_ERR(ctlr_l->switchcon_in)) {
+				hid_err(ctlr->hdev, "Failed creating input\n");
+				ctlr_l->switchcon_in = NULL;
+				ctlr_r->switchcon_in = NULL;
+			}
+
+			if (ctlr == ctlr_l)
+				mutex_unlock(&ctlr_r->mutex);
+			else
+				mutex_unlock(&ctlr_l->mutex);
+			ctlr_l = NULL;
+			ctlr_r = NULL;
+		}
+	}
+
+	mutex_unlock(&ctlr->mutex);
+	mutex_unlock(&switchcon_detect_pair_mutex);
+}
+
+static void switchcon_create_horiz_handler(struct work_struct *ws)
+{
+	struct switchcon_ctlr *ctlr = container_of(ws, struct switchcon_ctlr,
+							create_horiz_worker);
+
+	mutex_lock(&ctlr->mutex);
+
+	ctlr->switchcon_in = switchcon_input_create(
+				SWITCHCON_INPUT_TYPE_JOYCON_H, ctlr, NULL);
+	if (IS_ERR(ctlr->switchcon_in)) {
+		hid_err(ctlr->hdev, "failed to create input\n");
+		ctlr->switchcon_in = NULL;
+	}
+
+	mutex_unlock(&ctlr->mutex);
+}
+
+static void switchcon_send_work_handler(struct work_struct *ws)
+{
+	struct switchcon_ctlr *ctlr = container_of(ws, struct switchcon_ctlr,
+								output_worker);
+	struct switchcon_output output;
+	struct hid_device *hdev = ctlr->hdev;
+	int ret;
+
+	spin_lock(&ctlr->output_lock);
+	while (ctlr->output_tail != ctlr->output_head) {
+		output = ctlr->output_buf[ctlr->output_tail];
+		ctlr->output_buf[ctlr->output_tail].data = NULL;
+		ctlr->output_tail++;
+		if (ctlr->output_tail == SC_OUTPUT_BUF_SIZE)
+			ctlr->output_tail = 0;
+		spin_unlock(&ctlr->output_lock);
+		if (!output.data) {
+			hid_warn(ctlr->hdev, "invalid output in buffer\n");
+		} else {
+			ret = hid_hw_output_report(hdev, output.data,
+							 output.size);
+			if (ret < 0)
+				hid_warn(hdev, "failed output report ret=%d",
+									ret);
+			kfree(output.data);
+
+		}
+		spin_lock(&ctlr->output_lock);
+	}
+	spin_unlock(&ctlr->output_lock);
+}
+
+static int switchcon_hid_event(struct hid_device *hdev,
+			struct hid_report *report, u8 *raw_data, int size)
+{
+	struct switchcon_ctlr *ctlr = hid_get_drvdata(hdev);
+
+	if (size < 1)
+		return -EINVAL;
+
+	return switchcon_ctlr_handle_event(ctlr, raw_data, size);
+}
+
+/* data input must have at least 9 bytes */
+static void switchcon_parse_lstick_calibration(u8 *data,
+					       struct switchcon_stick_cal *cal)
+{
+	s32 x_max_above;
+	s32 x_min_below;
+	s32 y_max_above;
+	s32 y_min_below;
+
+	x_max_above	= ((data[1] << 8) & 0xF00) | data[0];
+	y_max_above	= (data[2] << 4) | (data[1] >> 4);
+	x_min_below	= ((data[7] << 8) & 0xF00) | data[6];
+	y_min_below	= (data[8] << 4) | (data[7] >> 4);
+	cal->x_center	= ((data[4] << 8) & 0xF00) | data[3];
+	cal->y_center	= (data[5] << 4) | (data[4] >> 4);
+	cal->x_max	= cal->x_center + x_max_above;
+	cal->x_min	= cal->x_center - x_min_below;
+	cal->y_max	= cal->y_center + y_max_above;
+	cal->y_min	= cal->y_center - y_min_below;
+}
+
+/* data input must have at least 9 bytes */
+static void switchcon_parse_rstick_calibration(u8 *data,
+					       struct switchcon_stick_cal *cal)
+{
+	s32 x_max_above;
+	s32 x_min_below;
+	s32 y_max_above;
+	s32 y_min_below;
+
+	cal->x_center	= ((data[1] << 8) & 0xF00) | data[0];
+	cal->y_center	= (data[2] << 4) | (data[1] >> 4);
+	x_max_above	= ((data[7] << 8) & 0xF00) | data[6];
+	y_max_above	= (data[8] << 4) | (data[7] >> 4);
+	x_min_below	= ((data[4] << 8) & 0xF00) | data[3];
+	y_min_below	= (data[5] << 4) | (data[4] >> 4);
+	cal->x_max	= cal->x_center + x_max_above;
+	cal->x_min	= cal->x_center - x_min_below;
+	cal->y_max	= cal->y_center + y_max_above;
+	cal->y_min	= cal->y_center - y_min_below;
+}
+
+/* Common handler for parsing inputs */
+static int switchcon_ctlr_read_handler(struct switchcon_ctlr *ctlr,
+						u8 *data, int size)
+{
+	int ret = 0;
+
+	switch (data[0]) {
+	case SC_INPUT_SUBCMD_REPLY:
+	case SC_INPUT_IMU_DATA:
+	case SC_INPUT_MCU_DATA:
+		if (size < 12) /* make sure it contains the input report */
+			break;
+
+		/* Parse analog sticks */
+		ctlr->left_stick_x	= data[6] | ((data[7] & 0xF) << 8);
+		ctlr->left_stick_y	= (data[7] >> 4) | (data[8] << 4);
+		ctlr->right_stick_x	= data[9] | ((data[10] & 0xF) << 8);
+		ctlr->right_stick_y	= (data[10] >> 4) | (data[11] << 4);
+
+		/* Parse digital buttons */
+		ctlr->but_y		= 0x01 & data[3];
+		ctlr->but_x		= 0x02 & data[3];
+		ctlr->but_b		= 0x04 & data[3];
+		ctlr->but_a		= 0x08 & data[3];
+		ctlr->but_sr_right_jc	= 0x10 & data[3];
+		ctlr->but_sl_right_jc	= 0x20 & data[3];
+		ctlr->but_r		= 0x40 & data[3];
+		ctlr->but_zr		= 0x80 & data[3];
+		ctlr->but_l		= 0x40 & data[5];
+		ctlr->but_zl		= 0x80 & data[5];
+		ctlr->but_minus		= 0x01 & data[4];
+		ctlr->but_plus		= 0x02 & data[4];
+		ctlr->but_rstick	= 0x04 & data[4];
+		ctlr->but_lstick	= 0x08 & data[4];
+		ctlr->but_home		= 0x10 & data[4];
+		ctlr->but_capture	= 0x20 & data[4];
+		ctlr->but_down		= 0x01 & data[5];
+		ctlr->but_up		= 0x02 & data[5];
+		ctlr->but_right		= 0x04 & data[5];
+		ctlr->but_left		= 0x08 & data[5];
+		ctlr->but_sr_left_jc	= 0x10 & data[5];
+		ctlr->but_sl_left_jc	= 0x20 & data[5];
+
+		break;
+	case SC_INPUT_BUTTON_EVENT:
+		/* the controller is in wrong request mode */
+		switchcon_request_report_mode(ctlr);
+		break;
+	default:
+		ret = -EINVAL;
+		break;
+	}
+
+	return ret;
+}
+
+static int switchcon_ctlr_procon_init(struct switchcon_ctlr *ctlr)
+{
+	int ret;
+	u8 baud_cmd[] = {SC_OUTPUT_USB_CMD, SC_USB_CMD_BAUDRATE_3M};
+
+	mutex_lock(&ctlr->mutex);
+	ctlr->ctlr_state = SWITCHCON_CTLR_STATE_USB_SET_BAUD;
+	ret = switchcon_hid_queue_send(ctlr, baud_cmd, sizeof(baud_cmd));
+	mutex_unlock(&ctlr->mutex);
+	return ret;
+}
+
+static int switchcon_ctlr_joyconl_init(struct switchcon_ctlr *ctlr)
+{
+	mutex_lock(&ctlr->mutex);
+	switchcon_request_calibration(ctlr);
+	ctlr->ctlr_state = SWITCHCON_CTLR_STATE_CALIBRATION;
+	ctlr->is_right_joycon = false;
+	mutex_unlock(&ctlr->mutex);
+	return 0;
+}
+
+static int switchcon_ctlr_joyconr_init(struct switchcon_ctlr *ctlr)
+{
+	mutex_lock(&ctlr->mutex);
+	switchcon_request_calibration(ctlr);
+	ctlr->ctlr_state = SWITCHCON_CTLR_STATE_CALIBRATION;
+	ctlr->is_right_joycon = true;
+	switchcon_request_calibration(ctlr);
+	mutex_unlock(&ctlr->mutex);
+	return 0;
+}
+
+void switchcon_ctlr_general_deinit(struct switchcon_ctlr *ctlr)
+{
+	if (ctlr->switchcon_in)
+		switchcon_input_destroy(ctlr->switchcon_in);
+	mutex_lock(&ctlr->mutex);
+	flush_work(&ctlr->output_worker);
+	mutex_unlock(&ctlr->mutex);
+	mutex_destroy(&ctlr->mutex);
+}
+
+static int switchcon_ctlr_general_handle_event(struct switchcon_ctlr *ctlr,
+							u8 *data, int size)
+{
+	mutex_lock(&ctlr->mutex);
+	switch (ctlr->ctlr_state) {
+	case SWITCHCON_CTLR_STATE_CALIBRATION:
+		if (data[0] != SC_INPUT_SUBCMD_REPLY || size < 38
+		 || data[13] != 0x90 || data[14] != 0x10) {
+			/* resend request if it wasn't received */
+			switchcon_request_calibration(ctlr);
+			break;
+		}
+		switchcon_parse_lstick_calibration(data + 20,
+						  &ctlr->left_stick_cal);
+		switchcon_parse_rstick_calibration(data + 29,
+						  &ctlr->right_stick_cal);
+
+		hid_info(ctlr->hdev, "l_x_c=%d l_x_max=%d l_x_min=%d\n",
+						ctlr->left_stick_cal.x_center,
+						ctlr->left_stick_cal.x_max,
+						ctlr->left_stick_cal.x_min);
+		hid_info(ctlr->hdev, "l_y_c=%d l_y_max=%d l_y_min=%d\n",
+						ctlr->left_stick_cal.y_center,
+						ctlr->left_stick_cal.y_max,
+						ctlr->left_stick_cal.y_min);
+		hid_info(ctlr->hdev, "r_x_c=%d r_x_max=%d r_x_min=%d\n",
+						ctlr->right_stick_cal.x_center,
+						ctlr->right_stick_cal.x_max,
+						ctlr->right_stick_cal.x_min);
+		hid_info(ctlr->hdev, "r_y_c=%d r_y_max=%d r_y_min=%d\n",
+						ctlr->right_stick_cal.y_center,
+						ctlr->right_stick_cal.y_max,
+						ctlr->right_stick_cal.y_min);
+		ctlr->ctlr_state = SWITCHCON_CTLR_STATE_POST_CALIBRATION;
+		switchcon_request_report_mode(ctlr);
+		break;
+	case SWITCHCON_CTLR_STATE_READ:
+		switchcon_ctlr_read_handler(ctlr, data, size);
+		if (ctlr->switchcon_in)
+			schedule_work(&ctlr->switchcon_in->input_worker);
+		break;
+	default:
+		break;
+	}
+	mutex_unlock(&ctlr->mutex);
+
+	return 0;
+}
+
+static int switchcon_ctlr_procon_handle_event(struct switchcon_ctlr *ctlr,
+							u8 *data, int size)
+{
+	int ret;
+	u8 handshake_cmd[]	= {SC_OUTPUT_USB_CMD, SC_USB_CMD_HANDSHAKE};
+	u8 timeout_cmd[]	= {SC_OUTPUT_USB_CMD, SC_USB_CMD_NO_TIMEOUT};
+
+	mutex_lock(&ctlr->mutex);
+	switch (ctlr->ctlr_state) {
+	case SWITCHCON_CTLR_STATE_USB_SET_BAUD:
+		if (size < 2 || data[0] != SC_INPUT_USB_RESPONSE
+		    || data[1] != SC_USB_CMD_BAUDRATE_3M) {
+			hid_dbg(ctlr->hdev, "No usb response, assume ble\n");
+			ctlr->ctlr_state = SWITCHCON_CTLR_STATE_CALIBRATION;
+			switchcon_request_calibration(ctlr);
+			break;
+		}
+
+		ret = switchcon_hid_queue_send(ctlr, handshake_cmd,
+						sizeof(handshake_cmd));
+		if (!ret) {
+			ctlr->ctlr_state = SWITCHCON_CTLR_STATE_USB_HANDSHAKE;
+			hid_dbg(ctlr->hdev, "sent handshake\n");
+		}
+		break;
+	case SWITCHCON_CTLR_STATE_USB_HANDSHAKE:
+		if (size < 2 || data[0] != SC_INPUT_USB_RESPONSE
+		    || data[1] != SC_USB_CMD_HANDSHAKE)
+			break;
+		ret = switchcon_hid_queue_send(ctlr, timeout_cmd,
+						sizeof(timeout_cmd));
+		if (!ret) {
+			hid_dbg(ctlr->hdev, "sent timeout disable\n");
+			ctlr->ctlr_state = SWITCHCON_CTLR_STATE_CALIBRATION;
+			switchcon_request_calibration(ctlr);
+		}
+		break;
+	case SWITCHCON_CTLR_STATE_POST_CALIBRATION:
+		schedule_work(&ctlr->create_input_worker);
+		ctlr->ctlr_state = SWITCHCON_CTLR_STATE_READ;
+		break;
+	default:
+		mutex_unlock(&ctlr->mutex);
+		return switchcon_ctlr_general_handle_event(ctlr, data, size);
+	}
+	mutex_unlock(&ctlr->mutex);
+	return 0;
+}
+
+static int switchcon_ctlr_joycon_handle_event(struct switchcon_ctlr *ctlr,
+							u8 *data, int size)
+{
+	bool last_searching;
+	int i;
+
+	mutex_lock(&ctlr->mutex);
+	switch (ctlr->ctlr_state) {
+	case SWITCHCON_CTLR_STATE_POST_CALIBRATION:
+		ctlr->ctlr_state = SWITCHCON_CTLR_STATE_SEARCH;
+		/* flashing leds to indicate searching */
+		for (i = 0; i < 10; i++)
+			/* command multiple times to ensure it works */
+			switchcon_set_player_leds(ctlr, 0b1111, 0);
+		/* intentional fall-through */
+	case SWITCHCON_CTLR_STATE_SEARCH:
+		last_searching = ctlr->searching;
+		switchcon_ctlr_read_handler(ctlr, data, size);
+		ctlr->searching =  ctlr->but_r || ctlr->but_zr
+				|| ctlr->but_l || ctlr->but_zl;
+		if (ctlr->searching != last_searching) {
+			schedule_work(&ctlr->detect_pair_worker);
+		} else if ((ctlr->but_sr_left_jc && ctlr->but_sl_left_jc)
+			|| (ctlr->but_sr_right_jc && ctlr->but_sl_right_jc)) {
+			schedule_work(&ctlr->create_horiz_worker);
+			ctlr->ctlr_state = SWITCHCON_CTLR_STATE_READ;
+		}
+		break;
+	default:
+		mutex_unlock(&ctlr->mutex);
+		return switchcon_ctlr_general_handle_event(ctlr, data, size);
+	}
+	mutex_unlock(&ctlr->mutex);
+	return 0;
+}
+
+/* Implementations for each supported controller type */
+static const struct switchcon_impl switchcon_impl_procon = {
+	.init		= switchcon_ctlr_procon_init,
+	.deinit		= switchcon_ctlr_general_deinit,
+	.handle_event	= switchcon_ctlr_procon_handle_event,
+};
+
+static const struct switchcon_impl switchcon_impl_joycon_l = {
+	.init		= switchcon_ctlr_joyconl_init,
+	.deinit		= switchcon_ctlr_general_deinit,
+	.handle_event	= switchcon_ctlr_joycon_handle_event,
+};
+
+static const struct switchcon_impl switchcon_impl_joycon_r = {
+	.init		= switchcon_ctlr_joyconr_init,
+	.deinit		= switchcon_ctlr_general_deinit,
+	.handle_event	= switchcon_ctlr_joycon_handle_event,
+};
+
+static struct switchcon_ctlr *switchcon_ctlr_create(struct hid_device *hdev)
+{
+	struct switchcon_ctlr *ctlr;
+
+	ctlr = devm_kzalloc(&hdev->dev, sizeof(*ctlr), GFP_KERNEL);
+	if (!ctlr)
+		return ERR_PTR(-ENOMEM);
+
+	switch (hdev->product) {
+	case USB_DEVICE_ID_NINTENDO_PROCON:
+		hid_info(hdev, "detected pro controller\n");
+		ctlr->impl = &switchcon_impl_procon;
+		break;
+	case USB_DEVICE_ID_NINTENDO_JOYCONL:
+		hid_info(hdev, "detected left joy-con\n");
+		ctlr->impl = &switchcon_impl_joycon_l;
+		break;
+	case USB_DEVICE_ID_NINTENDO_JOYCONR:
+		hid_info(hdev, "detected right joy-con\n");
+		ctlr->impl = &switchcon_impl_joycon_r;
+		break;
+	default:
+		hid_err(hdev, "unknown product id\n");
+		return ERR_PTR(-EINVAL);
+	}
+	ctlr->hdev = hdev;
+	ctlr->ctlr_state = SWITCHCON_CTLR_STATE_INIT;
+	hid_set_drvdata(hdev, ctlr);
+	spin_lock_init(&ctlr->output_lock);
+	mutex_init(&ctlr->mutex);
+	INIT_WORK(&ctlr->output_worker, switchcon_send_work_handler);
+	INIT_WORK(&ctlr->create_input_worker,
+		  switchcon_create_procon_input_handler);
+	INIT_WORK(&ctlr->detect_pair_worker, switchcon_detect_pair_handler);
+	INIT_WORK(&ctlr->create_horiz_worker, switchcon_create_horiz_handler);
+	return ctlr;
+}
+
+static int switchcon_hid_probe(struct hid_device *hdev,
+			       const struct hid_device_id *id)
+{
+	int ret;
+	struct switchcon_ctlr *ctlr;
+
+	hid_dbg(hdev, "probe - start\n");
+	hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS;
+
+	ctlr = switchcon_ctlr_create(hdev);
+	if (IS_ERR(ctlr)) {
+		hid_err(hdev, "Failed to create new controller\n");
+		ret = PTR_ERR(ctlr);
+		goto err;
+	}
+
+	ret = hid_parse(hdev);
+	if (ret) {
+		hid_err(hdev, "HID parse failed\n");
+		goto err;
+	}
+
+	ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
+	if (ret) {
+		hid_err(hdev, "HW start failed\n");
+		goto err;
+	}
+
+	ret = hid_hw_open(hdev);
+	if (ret) {
+		hid_err(hdev, "cannot start hardware I/O\n");
+		goto err_stop;
+	}
+
+	ret = switchcon_ctlr_init(ctlr);
+	if (ret) {
+		hid_err(hdev, "failed to initialize ctlr\n");
+		goto err_close;
+	}
+
+	hid_dbg(hdev, "probe - success\n");
+	return 0;
+
+err_close:
+	switchcon_ctlr_deinit(ctlr);
+	hid_hw_close(hdev);
+err_stop:
+	hid_hw_stop(hdev);
+err:
+	hid_err(hdev, "probe - fail = %d\n", ret);
+	return ret;
+}
+
+static void switchcon_hid_remove(struct hid_device *hdev)
+{
+	struct switchcon_ctlr *ctlr = hid_get_drvdata(hdev);
+
+	hid_dbg(hdev, "remove\n");
+	hid_hw_close(hdev);
+	hid_hw_stop(hdev);
+	switchcon_ctlr_deinit(ctlr);
+}
+
+static const struct hid_device_id switchcon_hid_devices[] = {
+	{ HID_USB_DEVICE(USB_VENDOR_ID_NINTENDO,
+			 USB_DEVICE_ID_NINTENDO_PROCON) },
+	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO,
+			 USB_DEVICE_ID_NINTENDO_PROCON) },
+	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO,
+			 USB_DEVICE_ID_NINTENDO_JOYCONL) },
+	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO,
+			 USB_DEVICE_ID_NINTENDO_JOYCONR) },
+	{ }
+};
+MODULE_DEVICE_TABLE(hid, switchcon_hid_devices);
+
+static struct hid_driver switchcon_hid_driver = {
+	.name		= "switchcon",
+	.id_table	= switchcon_hid_devices,
+	.probe		= switchcon_hid_probe,
+	.remove		= switchcon_hid_remove,
+	.raw_event	= switchcon_hid_event,
+};
+module_hid_driver(switchcon_hid_driver);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Daniel J. Ogorchock <djogorchock@gmail.com>");
+MODULE_DESCRIPTION("Driver for Nintendo Switch Controllers");
