diff mbox series

[v2,1/1] HID: shield: Initial driver implementation with Thunderstrike support

Message ID 20230410170840.16119-2-rrameshbabu@nvidia.com (mailing list archive)
State Superseded
Headers show
Series HID: shield | expand

Commit Message

Rahul Rameshbabu April 10, 2023, 5:08 p.m. UTC 
Supports the Thunderstrike (SHIELD 2017) controller. Implements support for
the Thunderstrike HOSTCMD firmware interface. Adds sysfs attributes about a
SHIELD device and introduces haptics support for controllers.

Signed-off-by: Rahul Rameshbabu <rrameshbabu@nvidia.com>
---
 MAINTAINERS              |   6 +
 drivers/hid/Kconfig      |  18 ++
 drivers/hid/Makefile     |   1 +
 drivers/hid/hid-ids.h    |   3 +
 drivers/hid/hid-shield.c | 587 +++++++++++++++++++++++++++++++++++++++
 5 files changed, 615 insertions(+)
 create mode 100644 drivers/hid/hid-shield.c

Comments

Jiri Kosina April 13, 2023, 3:07 p.m. UTC | #1 
On Mon, 10 Apr 2023, Rahul Rameshbabu wrote:

> Supports the Thunderstrike (SHIELD 2017) controller. Implements support for
> the Thunderstrike HOSTCMD firmware interface. Adds sysfs attributes about a
> SHIELD device and introduces haptics support for controllers.
> 
> Signed-off-by: Rahul Rameshbabu <rrameshbabu@nvidia.com>

Thanks a lot for submitting the driver. I have one minor question:

[ ... snip ... ]
> +thunderstrike_update_haptics(struct thunderstrike *ts,
> +			     struct thunderstrike_hostcmd_haptics *motors)
> +{
> +	unsigned long flags;
> +
> +	spin_lock_irqsave(&ts->haptics_update_lock, flags);
> +	ts->haptics_val = *motors;
> +	spin_unlock_irqrestore(&ts->haptics_update_lock, flags);

Do we really have to disable interrupts when taking haptics_update_lock? 
Is it ever being taken from interrupt context?

Thanks,
Benjamin Tissoires April 13, 2023, 3:16 p.m. UTC | #2 
Hi,

On Apr 10 2023, Rahul Rameshbabu wrote:
> Supports the Thunderstrike (SHIELD 2017) controller. Implements support for
> the Thunderstrike HOSTCMD firmware interface. Adds sysfs attributes about a
> SHIELD device and introduces haptics support for controllers.
> 
> Signed-off-by: Rahul Rameshbabu <rrameshbabu@nvidia.com>
> ---
>  MAINTAINERS              |   6 +
>  drivers/hid/Kconfig      |  18 ++
>  drivers/hid/Makefile     |   1 +
>  drivers/hid/hid-ids.h    |   3 +
>  drivers/hid/hid-shield.c | 587 +++++++++++++++++++++++++++++++++++++++

In addition to what Jiri said, would you mind changing the name to
hid-nvidia-shield.c or just hid-nvidia.c?
The "normal" naming scheme in the hid tree is to group devices by
vendors, and TBH, knowing that the "shield" is from Nvidia is not
necessarily obvious.

Cheers,
Benjamin

>  5 files changed, 615 insertions(+)
>  create mode 100644 drivers/hid/hid-shield.c
> 
> diff --git a/MAINTAINERS b/MAINTAINERS
> index 2b073facf399..4fa673401bc7 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -9122,6 +9122,12 @@ F:	drivers/hid/hid-sensor-*
>  F:	drivers/iio/*/hid-*
>  F:	include/linux/hid-sensor-*
>  
> +HID SHIELD DRIVER
> +M:	Rahul Rameshbabu <rrameshbabu@nvidia.com>
> +L:	linux-input@vger.kernel.org
> +S:	Maintained
> +F:	drivers/hid/hid-shield.c
> +
>  HID VRC-2 CAR CONTROLLER DRIVER
>  M:	Marcus Folkesson <marcus.folkesson@gmail.com>
>  L:	linux-input@vger.kernel.org
> diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
> index 82f64fb31fda..eb19debaa1f5 100644
> --- a/drivers/hid/Kconfig
> +++ b/drivers/hid/Kconfig
> @@ -990,6 +990,24 @@ config HID_SEMITEK
>  	- Woo-dy
>  	- X-Bows Nature/Knight
>  
> +config HID_SHIELD
> +	tristate "SHIELD HID Driver"
> +	depends on USB_HID
> +	depends on BT_HIDP
> +	help
> +	Support for NVIDIA SHIELD accessories.
> +
> +	Supported devices:
> +	- Thunderstrike (NVIDIA SHIELD Controller 2017)
> +
> +config SHIELD_FF
> +	bool "SHIELD force feedback support"
> +	depends on HID_SHIELD
> +	select INPUT_FF_MEMLESS
> +	help
> +	Say Y here if you would like to enable force feedback support for
> +	NVIDIA SHIELD accessories with haptics capabilities.
> +
>  config HID_SIGMAMICRO
>  	tristate "SiGma Micro-based keyboards"
>  	depends on USB_HID
> diff --git a/drivers/hid/Makefile b/drivers/hid/Makefile
> index 5d37cacbde33..a2ed1db9ed9d 100644
> --- a/drivers/hid/Makefile
> +++ b/drivers/hid/Makefile
> @@ -116,6 +116,7 @@ obj-$(CONFIG_HID_RMI)		+= hid-rmi.o
>  obj-$(CONFIG_HID_SAITEK)	+= hid-saitek.o
>  obj-$(CONFIG_HID_SAMSUNG)	+= hid-samsung.o
>  obj-$(CONFIG_HID_SEMITEK)	+= hid-semitek.o
> +obj-$(CONFIG_HID_SHIELD)	+= hid-shield.o
>  obj-$(CONFIG_HID_SIGMAMICRO)	+= hid-sigmamicro.o
>  obj-$(CONFIG_HID_SMARTJOYPLUS)	+= hid-sjoy.o
>  obj-$(CONFIG_HID_SONY)		+= hid-sony.o
> diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
> index 63545cd307e5..4000d53b1bac 100644
> --- a/drivers/hid/hid-ids.h
> +++ b/drivers/hid/hid-ids.h
> @@ -993,6 +993,9 @@
>  #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18   0x0014
>  #define USB_DEVICE_ID_NTRIG_DUOSENSE 0x1500
>  
> +#define USB_VENDOR_ID_NVIDIA				0x0955
> +#define USB_DEVICE_ID_NVIDIA_THUNDERSTRIKE_CONTROLLER	0x7214
> +
>  #define USB_VENDOR_ID_ONTRAK		0x0a07
>  #define USB_DEVICE_ID_ONTRAK_ADU100	0x0064
>  
> diff --git a/drivers/hid/hid-shield.c b/drivers/hid/hid-shield.c
> new file mode 100644
> index 000000000000..3befa8f133c7
> --- /dev/null
> +++ b/drivers/hid/hid-shield.c
> @@ -0,0 +1,587 @@
> +// SPDX-License-Identifier: GPL-2.0-or-later
> +/*
> + *  Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES.  All rights reserved.
> + *
> + *  HID driver for NVIDIA SHIELD peripherals.
> + */
> +
> +#include <linux/hid.h>
> +#include <linux/input-event-codes.h>
> +#include <linux/input.h>
> +#include <linux/module.h>
> +#include <linux/spinlock.h>
> +#include <linux/workqueue.h>
> +
> +#include "hid-ids.h"
> +
> +#define NOT_INIT_STR "NOT INITIALIZED"
> +
> +enum {
> +	SHIELD_FW_VERSION_INITIALIZED = 0,
> +	SHIELD_BOARD_INFO_INITIALIZED,
> +};
> +
> +enum {
> +	THUNDERSTRIKE_FW_VERSION_UPDATE = 0,
> +	THUNDERSTRIKE_BOARD_INFO_UPDATE,
> +	THUNDERSTRIKE_HAPTICS_UPDATE,
> +};
> +
> +enum {
> +	THUNDERSTRIKE_HOSTCMD_REPORT_SIZE = 33,
> +	THUNDERSTRIKE_HOSTCMD_REQ_REPORT_ID = 0x4,
> +	THUNDERSTRIKE_HOSTCMD_RESP_REPORT_ID = 0x3,
> +};
> +
> +enum {
> +	THUNDERSTRIKE_HOSTCMD_ID_FW_VERSION = 1,
> +	THUNDERSTRIKE_HOSTCMD_ID_BOARD_INFO = 16,
> +	THUNDERSTRIKE_HOSTCMD_ID_USB_INIT = 53,
> +	THUNDERSTRIKE_HOSTCMD_ID_HAPTICS = 57,
> +	THUNDERSTRIKE_HOSTCMD_ID_BLUETOOTH_INIT = 58,
> +};
> +
> +struct thunderstrike_hostcmd_board_info {
> +	__le16 revision;
> +	__le16 serial[7];
> +};
> +
> +struct thunderstrike_hostcmd_haptics {
> +	u8 motor_left;
> +	u8 motor_right;
> +};
> +
> +struct thunderstrike_hostcmd_resp_report {
> +	u8 report_id; /* THUNDERSTRIKE_HOSTCMD_RESP_REPORT_ID */
> +	u8 cmd_id;
> +	u8 reserved_at_10;
> +
> +	union {
> +		struct thunderstrike_hostcmd_board_info board_info;
> +		struct thunderstrike_hostcmd_haptics motors;
> +		__le16 fw_version;
> +		u8 payload[30];
> +	};
> +} __packed;
> +static_assert(sizeof(struct thunderstrike_hostcmd_resp_report) ==
> +	      THUNDERSTRIKE_HOSTCMD_REPORT_SIZE);
> +
> +struct thunderstrike_hostcmd_req_report {
> +	u8 report_id; /* THUNDERSTRIKE_HOSTCMD_REQ_REPORT_ID */
> +	u8 cmd_id;
> +	u8 reserved_at_10;
> +
> +	struct {
> +		u8 update;
> +		struct thunderstrike_hostcmd_haptics motors;
> +	} haptics;
> +	u8 reserved_at_30[27];
> +} __packed;
> +static_assert(sizeof(struct thunderstrike_hostcmd_req_report) ==
> +	      THUNDERSTRIKE_HOSTCMD_REPORT_SIZE);
> +
> +/* Common struct for shield accessories. */
> +struct shield_device {
> +	struct hid_device *hdev;
> +
> +	unsigned long initialized_flags;
> +	const char *codename;
> +	u16 fw_version;
> +	struct {
> +		u16 revision;
> +		char serial_number[15];
> +	} board_info;
> +};
> +
> +struct thunderstrike {
> +	struct shield_device base;
> +
> +	/* Sub-devices */
> +	struct input_dev *haptics_dev;
> +
> +	/* Resources */
> +	void *req_report_dmabuf;
> +	unsigned long update_flags;
> +	struct thunderstrike_hostcmd_haptics haptics_val;
> +	spinlock_t haptics_update_lock;
> +	struct work_struct hostcmd_req_work;
> +};
> +
> +static inline void thunderstrike_hostcmd_req_report_init(
> +	struct thunderstrike_hostcmd_req_report *report, u8 cmd_id)
> +{
> +	memset(report, 0, sizeof(*report));
> +	report->report_id = THUNDERSTRIKE_HOSTCMD_REQ_REPORT_ID;
> +	report->cmd_id = cmd_id;
> +}
> +
> +static inline void shield_strrev(char *dest, size_t len, u16 rev)
> +{
> +	dest[0] = ('A' - 1) + (rev >> 8);
> +	snprintf(&dest[1], len - 1, "%02X", 0xff & rev);
> +}
> +
> +static struct input_dev *shield_allocate_input_dev(struct hid_device *hdev,
> +						   const char *name_suffix)
> +{
> +	struct input_dev *idev;
> +
> +	idev = input_allocate_device();
> +	if (!idev)
> +		goto err_device;
> +
> +	idev->id.bustype = hdev->bus;
> +	idev->id.vendor = hdev->vendor;
> +	idev->id.product = hdev->product;
> +	idev->id.version = hdev->version;
> +	idev->uniq = hdev->uniq;
> +	idev->name = devm_kasprintf(&idev->dev, GFP_KERNEL, "%s %s", hdev->name,
> +				    name_suffix);
> +	if (!idev->name)
> +		goto err_name;
> +
> +	input_set_drvdata(idev, hdev);
> +
> +	return idev;
> +
> +err_name:
> +	input_free_device(idev);
> +err_device:
> +	return ERR_PTR(-ENOMEM);
> +}
> +
> +static struct input_dev *shield_haptics_create(
> +	struct shield_device *dev,
> +	int (*play_effect)(struct input_dev *, void *, struct ff_effect *))
> +{
> +	struct input_dev *haptics;
> +	int ret;
> +
> +	if (!IS_ENABLED(CONFIG_SHIELD_FF))
> +		return NULL;
> +
> +	haptics = shield_allocate_input_dev(dev->hdev, "Haptics");
> +	if (IS_ERR(haptics))
> +		return haptics;
> +
> +	input_set_capability(haptics, EV_FF, FF_RUMBLE);
> +	input_ff_create_memless(haptics, NULL, play_effect);
> +
> +	ret = input_register_device(haptics);
> +	if (ret)
> +		goto err;
> +
> +	return haptics;
> +
> + err:
> +	input_free_device(haptics);
> +	return ERR_PTR(ret);
> +}
> +
> +static inline void thunderstrike_send_hostcmd_request(struct thunderstrike *ts)
> +{
> +	struct thunderstrike_hostcmd_req_report *report = ts->req_report_dmabuf;
> +	struct shield_device *shield_dev = &ts->base;
> +	int ret;
> +
> +	ret = hid_hw_raw_request(shield_dev->hdev, report->report_id,
> +				 ts->req_report_dmabuf,
> +				 THUNDERSTRIKE_HOSTCMD_REPORT_SIZE,
> +				 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
> +
> +	if (ret < 0) {
> +		hid_err(shield_dev->hdev,
> +			"Failed to output Thunderstrike HOSTCMD request HID report due to %pe\n",
> +			ERR_PTR(ret));
> +	}
> +}
> +
> +static void thunderstrike_hostcmd_req_work_handler(struct work_struct *work)
> +{
> +	struct thunderstrike *ts =
> +		container_of(work, struct thunderstrike, hostcmd_req_work);
> +	struct thunderstrike_hostcmd_req_report *report;
> +	unsigned long flags;
> +
> +	report = ts->req_report_dmabuf;
> +
> +	if (test_and_clear_bit(THUNDERSTRIKE_FW_VERSION_UPDATE, &ts->update_flags)) {
> +		thunderstrike_hostcmd_req_report_init(
> +			report, THUNDERSTRIKE_HOSTCMD_ID_FW_VERSION);
> +		thunderstrike_send_hostcmd_request(ts);
> +	}
> +
> +	if (test_and_clear_bit(THUNDERSTRIKE_BOARD_INFO_UPDATE, &ts->update_flags)) {
> +		thunderstrike_hostcmd_req_report_init(
> +			report, THUNDERSTRIKE_HOSTCMD_ID_BOARD_INFO);
> +		thunderstrike_send_hostcmd_request(ts);
> +	}
> +
> +	if (test_and_clear_bit(THUNDERSTRIKE_HAPTICS_UPDATE, &ts->update_flags)) {
> +		thunderstrike_hostcmd_req_report_init(
> +			report, THUNDERSTRIKE_HOSTCMD_ID_HAPTICS);
> +
> +		report->haptics.update = 1;
> +		spin_lock_irqsave(&ts->haptics_update_lock, flags);
> +		report->haptics.motors = ts->haptics_val;
> +		spin_unlock_irqrestore(&ts->haptics_update_lock, flags);
> +
> +		thunderstrike_send_hostcmd_request(ts);
> +	}
> +}
> +
> +static inline void thunderstrike_request_firmware_version(struct thunderstrike *ts)
> +{
> +	set_bit(THUNDERSTRIKE_FW_VERSION_UPDATE, &ts->update_flags);
> +	schedule_work(&ts->hostcmd_req_work);
> +}
> +
> +static inline void thunderstrike_request_board_info(struct thunderstrike *ts)
> +{
> +	set_bit(THUNDERSTRIKE_BOARD_INFO_UPDATE, &ts->update_flags);
> +	schedule_work(&ts->hostcmd_req_work);
> +}
> +
> +static inline int
> +thunderstrike_update_haptics(struct thunderstrike *ts,
> +			     struct thunderstrike_hostcmd_haptics *motors)
> +{
> +	unsigned long flags;
> +
> +	spin_lock_irqsave(&ts->haptics_update_lock, flags);
> +	ts->haptics_val = *motors;
> +	spin_unlock_irqrestore(&ts->haptics_update_lock, flags);
> +
> +	set_bit(THUNDERSTRIKE_HAPTICS_UPDATE, &ts->update_flags);
> +	schedule_work(&ts->hostcmd_req_work);
> +
> +	return 0;
> +}
> +
> +static int thunderstrike_play_effect(struct input_dev *idev, void *data,
> +				     struct ff_effect *effect)
> +{
> +	struct hid_device *hdev = input_get_drvdata(idev);
> +	struct thunderstrike_hostcmd_haptics motors;
> +	struct shield_device *shield_dev;
> +	struct thunderstrike *ts;
> +
> +	if (effect->type != FF_RUMBLE)
> +		return 0;
> +
> +	shield_dev = hid_get_drvdata(hdev);
> +	ts = container_of(shield_dev, struct thunderstrike, base);
> +
> +	/* Thunderstrike motor values range from 0 to 32 inclusively */
> +	motors.motor_left = effect->u.rumble.strong_magnitude / 2047;
> +	motors.motor_right = effect->u.rumble.weak_magnitude / 2047;
> +
> +	hid_dbg(hdev, "Thunderstrike FF_RUMBLE request, left: %u right: %u\n",
> +		motors.motor_left, motors.motor_right);
> +
> +	return thunderstrike_update_haptics(ts, &motors);
> +}
> +
> +static void
> +thunderstrike_parse_fw_version_payload(struct shield_device *shield_dev,
> +				       __le16 fw_version)
> +{
> +	shield_dev->fw_version = le16_to_cpu(fw_version);
> +
> +	set_bit(SHIELD_FW_VERSION_INITIALIZED, &shield_dev->initialized_flags);
> +
> +	hid_dbg(shield_dev->hdev, "Thunderstrike firmware version 0x%04X\n",
> +		shield_dev->fw_version);
> +}
> +
> +static void
> +thunderstrike_parse_board_info_payload(struct shield_device *shield_dev,
> +				       struct thunderstrike_hostcmd_board_info *board_info)
> +{
> +	char board_revision_str[4];
> +	int i;
> +
> +	shield_dev->board_info.revision = le16_to_cpu(board_info->revision);
> +	for (i = 0; i < 7; ++i) {
> +		u16 val = le16_to_cpu(board_info->serial[i]);
> +
> +		shield_dev->board_info.serial_number[2 * i] = val & 0xFF;
> +		shield_dev->board_info.serial_number[2 * i + 1] = val >> 8;
> +	}
> +	shield_dev->board_info.serial_number[14] = '\0';
> +
> +	set_bit(SHIELD_BOARD_INFO_INITIALIZED, &shield_dev->initialized_flags);
> +
> +	shield_strrev(board_revision_str, 4, shield_dev->board_info.revision);
> +	hid_dbg(shield_dev->hdev,
> +		"Thunderstrike BOARD_REVISION_%s (0x%04X) S/N: %s\n",
> +		board_revision_str, shield_dev->board_info.revision,
> +		shield_dev->board_info.serial_number);
> +}
> +
> +static inline void
> +thunderstrike_parse_haptics_payload(struct shield_device *shield_dev,
> +				    struct thunderstrike_hostcmd_haptics *haptics)
> +{
> +	hid_dbg(shield_dev->hdev,
> +		"Thunderstrike haptics HOSTCMD response, left: %u right: %u\n",
> +		haptics->motor_left, haptics->motor_right);
> +}
> +
> +static int thunderstrike_parse_report(struct shield_device *shield_dev,
> +				      struct hid_report *report, u8 *data,
> +				      int size)
> +{
> +	struct thunderstrike_hostcmd_resp_report *hostcmd_resp_report;
> +	struct thunderstrike *ts =
> +		container_of(shield_dev, struct thunderstrike, base);
> +	struct hid_device *hdev = shield_dev->hdev;
> +
> +	switch (report->id) {
> +	case THUNDERSTRIKE_HOSTCMD_RESP_REPORT_ID:
> +		if (size != THUNDERSTRIKE_HOSTCMD_REPORT_SIZE) {
> +			hid_err(hdev,
> +				"Encountered Thunderstrike HOSTCMD HID report with unexpected size %d\n",
> +				size);
> +			return -EINVAL;
> +		}
> +
> +		hostcmd_resp_report =
> +			(struct thunderstrike_hostcmd_resp_report *)data;
> +
> +		switch (hostcmd_resp_report->cmd_id) {
> +		case THUNDERSTRIKE_HOSTCMD_ID_FW_VERSION:
> +			thunderstrike_parse_fw_version_payload(
> +				shield_dev, hostcmd_resp_report->fw_version);
> +			break;
> +		case THUNDERSTRIKE_HOSTCMD_ID_BOARD_INFO:
> +			thunderstrike_parse_board_info_payload(
> +				shield_dev, &hostcmd_resp_report->board_info);
> +			break;
> +		case THUNDERSTRIKE_HOSTCMD_ID_HAPTICS:
> +			thunderstrike_parse_haptics_payload(
> +				shield_dev, &hostcmd_resp_report->motors);
> +			break;
> +
> +		case THUNDERSTRIKE_HOSTCMD_ID_USB_INIT:
> +		case THUNDERSTRIKE_HOSTCMD_ID_BLUETOOTH_INIT:
> +			/* May block HOSTCMD requests till received initially */
> +			thunderstrike_request_firmware_version(ts);
> +			thunderstrike_request_board_info(ts);
> +			/* Only HOSTCMD that can be triggered without a request */
> +			return 0;
> +		default:
> +			hid_warn(hdev,
> +				 "Unhandled Thunderstrike HOSTCMD id %d\n",
> +				 hostcmd_resp_report->cmd_id);
> +			return -ENOENT;
> +		}
> +
> +		break;
> +	default:
> +		return 0;
> +	}
> +
> +	return 0;
> +}
> +
> +static struct shield_device *thunderstrike_create(struct hid_device *hdev)
> +{
> +	struct shield_device *shield_dev;
> +	struct thunderstrike *ts;
> +
> +	ts = devm_kzalloc(&hdev->dev, sizeof(*ts), GFP_KERNEL);
> +	if (!ts)
> +		return ERR_PTR(-ENOMEM);
> +
> +	ts->req_report_dmabuf = devm_kzalloc(
> +		&hdev->dev, THUNDERSTRIKE_HOSTCMD_REPORT_SIZE, GFP_KERNEL);
> +	if (!ts->req_report_dmabuf)
> +		return ERR_PTR(-ENOMEM);
> +
> +	shield_dev = &ts->base;
> +	shield_dev->hdev = hdev;
> +	shield_dev->codename = "Thunderstrike";
> +
> +	spin_lock_init(&ts->haptics_update_lock);
> +	INIT_WORK(&ts->hostcmd_req_work, thunderstrike_hostcmd_req_work_handler);
> +
> +	hid_set_drvdata(hdev, shield_dev);
> +
> +	ts->haptics_dev = shield_haptics_create(shield_dev, thunderstrike_play_effect);
> +	if (IS_ERR(ts->haptics_dev))
> +		return ERR_CAST(ts->haptics_dev);
> +
> +	hid_info(hdev, "Registered Thunderstrike controller\n");
> +	return shield_dev;
> +}
> +
> +static ssize_t firmware_version_show(struct device *dev,
> +				     struct device_attribute *attr, char *buf)
> +{
> +	struct hid_device *hdev = to_hid_device(dev);
> +	struct shield_device *shield_dev;
> +	int ret;
> +
> +	shield_dev = hid_get_drvdata(hdev);
> +
> +	if (test_bit(SHIELD_FW_VERSION_INITIALIZED, &shield_dev->initialized_flags))
> +		ret = sysfs_emit(buf, "0x%04X\n", shield_dev->fw_version);
> +	else
> +		ret = sysfs_emit(buf, NOT_INIT_STR "\n");
> +
> +	return ret;
> +}
> +
> +static DEVICE_ATTR_RO(firmware_version);
> +
> +static ssize_t hardware_version_show(struct device *dev,
> +				     struct device_attribute *attr, char *buf)
> +{
> +	struct hid_device *hdev = to_hid_device(dev);
> +	struct shield_device *shield_dev;
> +	char board_revision_str[4];
> +	int ret;
> +
> +	shield_dev = hid_get_drvdata(hdev);
> +
> +	if (test_bit(SHIELD_BOARD_INFO_INITIALIZED, &shield_dev->initialized_flags)) {
> +		shield_strrev(board_revision_str, 4, shield_dev->board_info.revision);
> +		ret = sysfs_emit(buf, "%s BOARD_REVISION_%s (0x%04X)\n",
> +				 shield_dev->codename, board_revision_str,
> +				 shield_dev->board_info.revision);
> +	} else
> +		ret = sysfs_emit(buf, NOT_INIT_STR "\n");
> +
> +	return ret;
> +}
> +
> +static DEVICE_ATTR_RO(hardware_version);
> +
> +static ssize_t serial_number_show(struct device *dev,
> +				  struct device_attribute *attr, char *buf)
> +{
> +	struct hid_device *hdev = to_hid_device(dev);
> +	struct shield_device *shield_dev;
> +	int ret;
> +
> +	shield_dev = hid_get_drvdata(hdev);
> +
> +	if (test_bit(SHIELD_BOARD_INFO_INITIALIZED, &shield_dev->initialized_flags))
> +		ret = sysfs_emit(buf, "%s\n", shield_dev->board_info.serial_number);
> +	else
> +		ret = sysfs_emit(buf, NOT_INIT_STR "\n");
> +
> +	return ret;
> +}
> +
> +static DEVICE_ATTR_RO(serial_number);
> +
> +static struct attribute *shield_device_attrs[] = {
> +	&dev_attr_firmware_version.attr,
> +	&dev_attr_hardware_version.attr,
> +	&dev_attr_serial_number.attr,
> +	NULL,
> +};
> +ATTRIBUTE_GROUPS(shield_device);
> +
> +static int shield_raw_event(struct hid_device *hdev, struct hid_report *report,
> +			    u8 *data, int size)
> +{
> +	struct shield_device *dev = hid_get_drvdata(hdev);
> +
> +	return thunderstrike_parse_report(dev, report, data, size);
> +}
> +
> +static int shield_probe(struct hid_device *hdev, const struct hid_device_id *id)
> +{
> +	struct shield_device *shield_dev = NULL;
> +	struct thunderstrike *ts;
> +	int ret;
> +
> +	ret = hid_parse(hdev);
> +	if (ret) {
> +		hid_err(hdev, "Parse failed\n");
> +		return ret;
> +	}
> +
> +	switch (id->product) {
> +	case USB_DEVICE_ID_NVIDIA_THUNDERSTRIKE_CONTROLLER:
> +		shield_dev = thunderstrike_create(hdev);
> +		break;
> +	}
> +
> +	if (unlikely(!shield_dev)) {
> +		hid_err(hdev, "Failed to identify SHIELD device\n");
> +		return -ENODEV;
> +	}
> +	if (IS_ERR(shield_dev)) {
> +		hid_err(hdev, "Failed to create SHIELD device\n");
> +		return PTR_ERR(shield_dev);
> +	}
> +
> +	ts = container_of(shield_dev, struct thunderstrike, base);
> +
> +	ret = hid_hw_start(hdev, HID_CONNECT_HIDINPUT);
> +	if (ret) {
> +		hid_err(hdev, "Failed to start HID device\n");
> +		goto err_haptics;
> +	}
> +
> +	ret = hid_hw_open(hdev);
> +	if (ret) {
> +		hid_err(hdev, "Failed to open HID device\n");
> +		goto err_stop;
> +	}
> +
> +	thunderstrike_request_firmware_version(ts);
> +	thunderstrike_request_board_info(ts);
> +
> +	return ret;
> +
> +err_stop:
> +	hid_hw_stop(hdev);
> +err_haptics:
> +	if (ts->haptics_dev)
> +		input_unregister_device(ts->haptics_dev);
> +	return ret;
> +}
> +
> +static void shield_remove(struct hid_device *hdev)
> +{
> +	struct shield_device *dev = hid_get_drvdata(hdev);
> +	struct thunderstrike *ts;
> +
> +	ts = container_of(dev, struct thunderstrike, base);
> +
> +	hid_hw_close(hdev);
> +	if (ts->haptics_dev)
> +		input_unregister_device(ts->haptics_dev);
> +	cancel_work_sync(&ts->hostcmd_req_work);
> +	hid_hw_stop(hdev);
> +}
> +
> +static const struct hid_device_id shield_devices[] = {
> +	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NVIDIA,
> +			       USB_DEVICE_ID_NVIDIA_THUNDERSTRIKE_CONTROLLER) },
> +	{ HID_USB_DEVICE(USB_VENDOR_ID_NVIDIA,
> +			 USB_DEVICE_ID_NVIDIA_THUNDERSTRIKE_CONTROLLER) },
> +	{}
> +};
> +MODULE_DEVICE_TABLE(hid, shield_devices);
> +
> +static struct hid_driver shield_driver = {
> +	.name         = "shield",
> +	.id_table     = shield_devices,
> +	.probe        = shield_probe,
> +	.remove       = shield_remove,
> +	.raw_event    = shield_raw_event,
> +	.driver = {
> +		.dev_groups = shield_device_groups,
> +	},
> +};
> +module_hid_driver(shield_driver);
> +
> +MODULE_AUTHOR("Rahul Rameshbabu <rrameshbabu@nvidia.com>");
> +MODULE_DESCRIPTION("HID Driver for NVIDIA SHIELD peripherals.");
> +MODULE_LICENSE("GPL");
> -- 
> 2.38.4
>
Rahul Rameshbabu April 14, 2023, 6:47 a.m. UTC | #3 
On Thu, 13 Apr, 2023 17:16:21 +0200 Benjamin Tissoires <benjamin.tissoires@redhat.com> wrote:
> Hi,
>
> On Apr 10 2023, Rahul Rameshbabu wrote:
>> Supports the Thunderstrike (SHIELD 2017) controller. Implements support for
>> the Thunderstrike HOSTCMD firmware interface. Adds sysfs attributes about a
>> SHIELD device and introduces haptics support for controllers.
>> 
>> Signed-off-by: Rahul Rameshbabu <rrameshbabu@nvidia.com>
>> ---
>>  MAINTAINERS              |   6 +
>>  drivers/hid/Kconfig      |  18 ++
>>  drivers/hid/Makefile     |   1 +
>>  drivers/hid/hid-ids.h    |   3 +
>>  drivers/hid/hid-shield.c | 587 +++++++++++++++++++++++++++++++++++++++
>
> In addition to what Jiri said, would you mind changing the name to
> hid-nvidia-shield.c or just hid-nvidia.c?
> The "normal" naming scheme in the hid tree is to group devices by
> vendors, and TBH, knowing that the "shield" is from Nvidia is not
> necessarily obvious.

Ack. I will make the change to hid-nvidia.c in my next submission of
this patch.

>
> Cheers,
> Benjamin
>
Rahul Rameshbabu April 14, 2023, 7:09 a.m. UTC | #4 
Hi Jiri,

Thanks for the feedback.

On Thu, 13 Apr, 2023 17:07:00 +0200 Jiri Kosina <jikos@kernel.org> wrote:
> On Mon, 10 Apr 2023, Rahul Rameshbabu wrote:
>
>> Supports the Thunderstrike (SHIELD 2017) controller. Implements support for
>> the Thunderstrike HOSTCMD firmware interface. Adds sysfs attributes about a
>> SHIELD device and introduces haptics support for controllers.
>> 
>> Signed-off-by: Rahul Rameshbabu <rrameshbabu@nvidia.com>
>
> Thanks a lot for submitting the driver. I have one minor question:
>
> [ ... snip ... ]
>> +thunderstrike_update_haptics(struct thunderstrike *ts,
>> +			     struct thunderstrike_hostcmd_haptics *motors)
>> +{
>> +	unsigned long flags;
>> +
>> +	spin_lock_irqsave(&ts->haptics_update_lock, flags);
>> +	ts->haptics_val = *motors;
>> +	spin_unlock_irqrestore(&ts->haptics_update_lock, flags);
>
> Do we really have to disable interrupts when taking haptics_update_lock? 
> Is it ever being taken from interrupt context?

The reason why I disable interrupts is because I call
thunderstrike_update_haptics from the play_effect callback I pass to
input_ff_create_memless. From there, it is used in ml_effect_timer
drivers/input/ff-memless.c, which is a timer interrupt context so we
should disable interrupts when taking haptics_update_lock.

  static void ml_effect_timer(struct timer_list *t)
  {
    struct ml_device *ml = from_timer(ml, t, timer);
    struct input_dev *dev = ml->dev;
    unsigned long flags;

    pr_debug("timer: updating effects\n");

    spin_lock_irqsave(&dev->event_lock, flags);
    ml_play_effects(ml);
    spin_unlock_irqrestore(&dev->event_lock, flags);
  }

Let me know if this seems off.

>
> Thanks,

-- Rahul Rameshbabu
Jiri Kosina April 14, 2023, 2:12 p.m. UTC | #5 
On Fri, 14 Apr 2023, Rahul Rameshbabu wrote:

> The reason why I disable interrupts is because I call
> thunderstrike_update_haptics from the play_effect callback I pass to
> input_ff_create_memless. From there, it is used in ml_effect_timer
> drivers/input/ff-memless.c, which is a timer interrupt context so we
> should disable interrupts when taking haptics_update_lock.
> 
>   static void ml_effect_timer(struct timer_list *t)
>   {
>     struct ml_device *ml = from_timer(ml, t, timer);
>     struct input_dev *dev = ml->dev;
>     unsigned long flags;
> 
>     pr_debug("timer: updating effects\n");
> 
>     spin_lock_irqsave(&dev->event_lock, flags);
>     ml_play_effects(ml);
>     spin_unlock_irqrestore(&dev->event_lock, flags);
>   }

Ah, right, I missed that, it indeed runs in softirq context. Please 
disregard my comment.

Thanks,
diff mbox series

Patch

diff --git a/MAINTAINERS b/MAINTAINERS
index 2b073facf399..4fa673401bc7 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -9122,6 +9122,12 @@  F:	drivers/hid/hid-sensor-*
 F:	drivers/iio/*/hid-*
 F:	include/linux/hid-sensor-*
 
+HID SHIELD DRIVER
+M:	Rahul Rameshbabu <rrameshbabu@nvidia.com>
+L:	linux-input@vger.kernel.org
+S:	Maintained
+F:	drivers/hid/hid-shield.c
+
 HID VRC-2 CAR CONTROLLER DRIVER
 M:	Marcus Folkesson <marcus.folkesson@gmail.com>
 L:	linux-input@vger.kernel.org
diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
index 82f64fb31fda..eb19debaa1f5 100644
--- a/drivers/hid/Kconfig
+++ b/drivers/hid/Kconfig
@@ -990,6 +990,24 @@  config HID_SEMITEK
 	- Woo-dy
 	- X-Bows Nature/Knight
 
+config HID_SHIELD
+	tristate "SHIELD HID Driver"
+	depends on USB_HID
+	depends on BT_HIDP
+	help
+	Support for NVIDIA SHIELD accessories.
+
+	Supported devices:
+	- Thunderstrike (NVIDIA SHIELD Controller 2017)
+
+config SHIELD_FF
+	bool "SHIELD force feedback support"
+	depends on HID_SHIELD
+	select INPUT_FF_MEMLESS
+	help
+	Say Y here if you would like to enable force feedback support for
+	NVIDIA SHIELD accessories with haptics capabilities.
+
 config HID_SIGMAMICRO
 	tristate "SiGma Micro-based keyboards"
 	depends on USB_HID
diff --git a/drivers/hid/Makefile b/drivers/hid/Makefile
index 5d37cacbde33..a2ed1db9ed9d 100644
--- a/drivers/hid/Makefile
+++ b/drivers/hid/Makefile
@@ -116,6 +116,7 @@  obj-$(CONFIG_HID_RMI)		+= hid-rmi.o
 obj-$(CONFIG_HID_SAITEK)	+= hid-saitek.o
 obj-$(CONFIG_HID_SAMSUNG)	+= hid-samsung.o
 obj-$(CONFIG_HID_SEMITEK)	+= hid-semitek.o
+obj-$(CONFIG_HID_SHIELD)	+= hid-shield.o
 obj-$(CONFIG_HID_SIGMAMICRO)	+= hid-sigmamicro.o
 obj-$(CONFIG_HID_SMARTJOYPLUS)	+= hid-sjoy.o
 obj-$(CONFIG_HID_SONY)		+= hid-sony.o
diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
index 63545cd307e5..4000d53b1bac 100644
--- a/drivers/hid/hid-ids.h
+++ b/drivers/hid/hid-ids.h
@@ -993,6 +993,9 @@ 
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18   0x0014
 #define USB_DEVICE_ID_NTRIG_DUOSENSE 0x1500
 
+#define USB_VENDOR_ID_NVIDIA				0x0955
+#define USB_DEVICE_ID_NVIDIA_THUNDERSTRIKE_CONTROLLER	0x7214
+
 #define USB_VENDOR_ID_ONTRAK		0x0a07
 #define USB_DEVICE_ID_ONTRAK_ADU100	0x0064
 
diff --git a/drivers/hid/hid-shield.c b/drivers/hid/hid-shield.c
new file mode 100644
index 000000000000..3befa8f133c7
--- /dev/null
+++ b/drivers/hid/hid-shield.c
@@ -0,0 +1,587 @@ 
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ *  Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES.  All rights reserved.
+ *
+ *  HID driver for NVIDIA SHIELD peripherals.
+ */
+
+#include <linux/hid.h>
+#include <linux/input-event-codes.h>
+#include <linux/input.h>
+#include <linux/module.h>
+#include <linux/spinlock.h>
+#include <linux/workqueue.h>
+
+#include "hid-ids.h"
+
+#define NOT_INIT_STR "NOT INITIALIZED"
+
+enum {
+	SHIELD_FW_VERSION_INITIALIZED = 0,
+	SHIELD_BOARD_INFO_INITIALIZED,
+};
+
+enum {
+	THUNDERSTRIKE_FW_VERSION_UPDATE = 0,
+	THUNDERSTRIKE_BOARD_INFO_UPDATE,
+	THUNDERSTRIKE_HAPTICS_UPDATE,
+};
+
+enum {
+	THUNDERSTRIKE_HOSTCMD_REPORT_SIZE = 33,
+	THUNDERSTRIKE_HOSTCMD_REQ_REPORT_ID = 0x4,
+	THUNDERSTRIKE_HOSTCMD_RESP_REPORT_ID = 0x3,
+};
+
+enum {
+	THUNDERSTRIKE_HOSTCMD_ID_FW_VERSION = 1,
+	THUNDERSTRIKE_HOSTCMD_ID_BOARD_INFO = 16,
+	THUNDERSTRIKE_HOSTCMD_ID_USB_INIT = 53,
+	THUNDERSTRIKE_HOSTCMD_ID_HAPTICS = 57,
+	THUNDERSTRIKE_HOSTCMD_ID_BLUETOOTH_INIT = 58,
+};
+
+struct thunderstrike_hostcmd_board_info {
+	__le16 revision;
+	__le16 serial[7];
+};
+
+struct thunderstrike_hostcmd_haptics {
+	u8 motor_left;
+	u8 motor_right;
+};
+
+struct thunderstrike_hostcmd_resp_report {
+	u8 report_id; /* THUNDERSTRIKE_HOSTCMD_RESP_REPORT_ID */
+	u8 cmd_id;
+	u8 reserved_at_10;
+
+	union {
+		struct thunderstrike_hostcmd_board_info board_info;
+		struct thunderstrike_hostcmd_haptics motors;
+		__le16 fw_version;
+		u8 payload[30];
+	};
+} __packed;
+static_assert(sizeof(struct thunderstrike_hostcmd_resp_report) ==
+	      THUNDERSTRIKE_HOSTCMD_REPORT_SIZE);
+
+struct thunderstrike_hostcmd_req_report {
+	u8 report_id; /* THUNDERSTRIKE_HOSTCMD_REQ_REPORT_ID */
+	u8 cmd_id;
+	u8 reserved_at_10;
+
+	struct {
+		u8 update;
+		struct thunderstrike_hostcmd_haptics motors;
+	} haptics;
+	u8 reserved_at_30[27];
+} __packed;
+static_assert(sizeof(struct thunderstrike_hostcmd_req_report) ==
+	      THUNDERSTRIKE_HOSTCMD_REPORT_SIZE);
+
+/* Common struct for shield accessories. */
+struct shield_device {
+	struct hid_device *hdev;
+
+	unsigned long initialized_flags;
+	const char *codename;
+	u16 fw_version;
+	struct {
+		u16 revision;
+		char serial_number[15];
+	} board_info;
+};
+
+struct thunderstrike {
+	struct shield_device base;
+
+	/* Sub-devices */
+	struct input_dev *haptics_dev;
+
+	/* Resources */
+	void *req_report_dmabuf;
+	unsigned long update_flags;
+	struct thunderstrike_hostcmd_haptics haptics_val;
+	spinlock_t haptics_update_lock;
+	struct work_struct hostcmd_req_work;
+};
+
+static inline void thunderstrike_hostcmd_req_report_init(
+	struct thunderstrike_hostcmd_req_report *report, u8 cmd_id)
+{
+	memset(report, 0, sizeof(*report));
+	report->report_id = THUNDERSTRIKE_HOSTCMD_REQ_REPORT_ID;
+	report->cmd_id = cmd_id;
+}
+
+static inline void shield_strrev(char *dest, size_t len, u16 rev)
+{
+	dest[0] = ('A' - 1) + (rev >> 8);
+	snprintf(&dest[1], len - 1, "%02X", 0xff & rev);
+}
+
+static struct input_dev *shield_allocate_input_dev(struct hid_device *hdev,
+						   const char *name_suffix)
+{
+	struct input_dev *idev;
+
+	idev = input_allocate_device();
+	if (!idev)
+		goto err_device;
+
+	idev->id.bustype = hdev->bus;
+	idev->id.vendor = hdev->vendor;
+	idev->id.product = hdev->product;
+	idev->id.version = hdev->version;
+	idev->uniq = hdev->uniq;
+	idev->name = devm_kasprintf(&idev->dev, GFP_KERNEL, "%s %s", hdev->name,
+				    name_suffix);
+	if (!idev->name)
+		goto err_name;
+
+	input_set_drvdata(idev, hdev);
+
+	return idev;
+
+err_name:
+	input_free_device(idev);
+err_device:
+	return ERR_PTR(-ENOMEM);
+}
+
+static struct input_dev *shield_haptics_create(
+	struct shield_device *dev,
+	int (*play_effect)(struct input_dev *, void *, struct ff_effect *))
+{
+	struct input_dev *haptics;
+	int ret;
+
+	if (!IS_ENABLED(CONFIG_SHIELD_FF))
+		return NULL;
+
+	haptics = shield_allocate_input_dev(dev->hdev, "Haptics");
+	if (IS_ERR(haptics))
+		return haptics;
+
+	input_set_capability(haptics, EV_FF, FF_RUMBLE);
+	input_ff_create_memless(haptics, NULL, play_effect);
+
+	ret = input_register_device(haptics);
+	if (ret)
+		goto err;
+
+	return haptics;
+
+ err:
+	input_free_device(haptics);
+	return ERR_PTR(ret);
+}
+
+static inline void thunderstrike_send_hostcmd_request(struct thunderstrike *ts)
+{
+	struct thunderstrike_hostcmd_req_report *report = ts->req_report_dmabuf;
+	struct shield_device *shield_dev = &ts->base;
+	int ret;
+
+	ret = hid_hw_raw_request(shield_dev->hdev, report->report_id,
+				 ts->req_report_dmabuf,
+				 THUNDERSTRIKE_HOSTCMD_REPORT_SIZE,
+				 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
+
+	if (ret < 0) {
+		hid_err(shield_dev->hdev,
+			"Failed to output Thunderstrike HOSTCMD request HID report due to %pe\n",
+			ERR_PTR(ret));
+	}
+}
+
+static void thunderstrike_hostcmd_req_work_handler(struct work_struct *work)
+{
+	struct thunderstrike *ts =
+		container_of(work, struct thunderstrike, hostcmd_req_work);
+	struct thunderstrike_hostcmd_req_report *report;
+	unsigned long flags;
+
+	report = ts->req_report_dmabuf;
+
+	if (test_and_clear_bit(THUNDERSTRIKE_FW_VERSION_UPDATE, &ts->update_flags)) {
+		thunderstrike_hostcmd_req_report_init(
+			report, THUNDERSTRIKE_HOSTCMD_ID_FW_VERSION);
+		thunderstrike_send_hostcmd_request(ts);
+	}
+
+	if (test_and_clear_bit(THUNDERSTRIKE_BOARD_INFO_UPDATE, &ts->update_flags)) {
+		thunderstrike_hostcmd_req_report_init(
+			report, THUNDERSTRIKE_HOSTCMD_ID_BOARD_INFO);
+		thunderstrike_send_hostcmd_request(ts);
+	}
+
+	if (test_and_clear_bit(THUNDERSTRIKE_HAPTICS_UPDATE, &ts->update_flags)) {
+		thunderstrike_hostcmd_req_report_init(
+			report, THUNDERSTRIKE_HOSTCMD_ID_HAPTICS);
+
+		report->haptics.update = 1;
+		spin_lock_irqsave(&ts->haptics_update_lock, flags);
+		report->haptics.motors = ts->haptics_val;
+		spin_unlock_irqrestore(&ts->haptics_update_lock, flags);
+
+		thunderstrike_send_hostcmd_request(ts);
+	}
+}
+
+static inline void thunderstrike_request_firmware_version(struct thunderstrike *ts)
+{
+	set_bit(THUNDERSTRIKE_FW_VERSION_UPDATE, &ts->update_flags);
+	schedule_work(&ts->hostcmd_req_work);
+}
+
+static inline void thunderstrike_request_board_info(struct thunderstrike *ts)
+{
+	set_bit(THUNDERSTRIKE_BOARD_INFO_UPDATE, &ts->update_flags);
+	schedule_work(&ts->hostcmd_req_work);
+}
+
+static inline int
+thunderstrike_update_haptics(struct thunderstrike *ts,
+			     struct thunderstrike_hostcmd_haptics *motors)
+{
+	unsigned long flags;
+
+	spin_lock_irqsave(&ts->haptics_update_lock, flags);
+	ts->haptics_val = *motors;
+	spin_unlock_irqrestore(&ts->haptics_update_lock, flags);
+
+	set_bit(THUNDERSTRIKE_HAPTICS_UPDATE, &ts->update_flags);
+	schedule_work(&ts->hostcmd_req_work);
+
+	return 0;
+}
+
+static int thunderstrike_play_effect(struct input_dev *idev, void *data,
+				     struct ff_effect *effect)
+{
+	struct hid_device *hdev = input_get_drvdata(idev);
+	struct thunderstrike_hostcmd_haptics motors;
+	struct shield_device *shield_dev;
+	struct thunderstrike *ts;
+
+	if (effect->type != FF_RUMBLE)
+		return 0;
+
+	shield_dev = hid_get_drvdata(hdev);
+	ts = container_of(shield_dev, struct thunderstrike, base);
+
+	/* Thunderstrike motor values range from 0 to 32 inclusively */
+	motors.motor_left = effect->u.rumble.strong_magnitude / 2047;
+	motors.motor_right = effect->u.rumble.weak_magnitude / 2047;
+
+	hid_dbg(hdev, "Thunderstrike FF_RUMBLE request, left: %u right: %u\n",
+		motors.motor_left, motors.motor_right);
+
+	return thunderstrike_update_haptics(ts, &motors);
+}
+
+static void
+thunderstrike_parse_fw_version_payload(struct shield_device *shield_dev,
+				       __le16 fw_version)
+{
+	shield_dev->fw_version = le16_to_cpu(fw_version);
+
+	set_bit(SHIELD_FW_VERSION_INITIALIZED, &shield_dev->initialized_flags);
+
+	hid_dbg(shield_dev->hdev, "Thunderstrike firmware version 0x%04X\n",
+		shield_dev->fw_version);
+}
+
+static void
+thunderstrike_parse_board_info_payload(struct shield_device *shield_dev,
+				       struct thunderstrike_hostcmd_board_info *board_info)
+{
+	char board_revision_str[4];
+	int i;
+
+	shield_dev->board_info.revision = le16_to_cpu(board_info->revision);
+	for (i = 0; i < 7; ++i) {
+		u16 val = le16_to_cpu(board_info->serial[i]);
+
+		shield_dev->board_info.serial_number[2 * i] = val & 0xFF;
+		shield_dev->board_info.serial_number[2 * i + 1] = val >> 8;
+	}
+	shield_dev->board_info.serial_number[14] = '\0';
+
+	set_bit(SHIELD_BOARD_INFO_INITIALIZED, &shield_dev->initialized_flags);
+
+	shield_strrev(board_revision_str, 4, shield_dev->board_info.revision);
+	hid_dbg(shield_dev->hdev,
+		"Thunderstrike BOARD_REVISION_%s (0x%04X) S/N: %s\n",
+		board_revision_str, shield_dev->board_info.revision,
+		shield_dev->board_info.serial_number);
+}
+
+static inline void
+thunderstrike_parse_haptics_payload(struct shield_device *shield_dev,
+				    struct thunderstrike_hostcmd_haptics *haptics)
+{
+	hid_dbg(shield_dev->hdev,
+		"Thunderstrike haptics HOSTCMD response, left: %u right: %u\n",
+		haptics->motor_left, haptics->motor_right);
+}
+
+static int thunderstrike_parse_report(struct shield_device *shield_dev,
+				      struct hid_report *report, u8 *data,
+				      int size)
+{
+	struct thunderstrike_hostcmd_resp_report *hostcmd_resp_report;
+	struct thunderstrike *ts =
+		container_of(shield_dev, struct thunderstrike, base);
+	struct hid_device *hdev = shield_dev->hdev;
+
+	switch (report->id) {
+	case THUNDERSTRIKE_HOSTCMD_RESP_REPORT_ID:
+		if (size != THUNDERSTRIKE_HOSTCMD_REPORT_SIZE) {
+			hid_err(hdev,
+				"Encountered Thunderstrike HOSTCMD HID report with unexpected size %d\n",
+				size);
+			return -EINVAL;
+		}
+
+		hostcmd_resp_report =
+			(struct thunderstrike_hostcmd_resp_report *)data;
+
+		switch (hostcmd_resp_report->cmd_id) {
+		case THUNDERSTRIKE_HOSTCMD_ID_FW_VERSION:
+			thunderstrike_parse_fw_version_payload(
+				shield_dev, hostcmd_resp_report->fw_version);
+			break;
+		case THUNDERSTRIKE_HOSTCMD_ID_BOARD_INFO:
+			thunderstrike_parse_board_info_payload(
+				shield_dev, &hostcmd_resp_report->board_info);
+			break;
+		case THUNDERSTRIKE_HOSTCMD_ID_HAPTICS:
+			thunderstrike_parse_haptics_payload(
+				shield_dev, &hostcmd_resp_report->motors);
+			break;
+
+		case THUNDERSTRIKE_HOSTCMD_ID_USB_INIT:
+		case THUNDERSTRIKE_HOSTCMD_ID_BLUETOOTH_INIT:
+			/* May block HOSTCMD requests till received initially */
+			thunderstrike_request_firmware_version(ts);
+			thunderstrike_request_board_info(ts);
+			/* Only HOSTCMD that can be triggered without a request */
+			return 0;
+		default:
+			hid_warn(hdev,
+				 "Unhandled Thunderstrike HOSTCMD id %d\n",
+				 hostcmd_resp_report->cmd_id);
+			return -ENOENT;
+		}
+
+		break;
+	default:
+		return 0;
+	}
+
+	return 0;
+}
+
+static struct shield_device *thunderstrike_create(struct hid_device *hdev)
+{
+	struct shield_device *shield_dev;
+	struct thunderstrike *ts;
+
+	ts = devm_kzalloc(&hdev->dev, sizeof(*ts), GFP_KERNEL);
+	if (!ts)
+		return ERR_PTR(-ENOMEM);
+
+	ts->req_report_dmabuf = devm_kzalloc(
+		&hdev->dev, THUNDERSTRIKE_HOSTCMD_REPORT_SIZE, GFP_KERNEL);
+	if (!ts->req_report_dmabuf)
+		return ERR_PTR(-ENOMEM);
+
+	shield_dev = &ts->base;
+	shield_dev->hdev = hdev;
+	shield_dev->codename = "Thunderstrike";
+
+	spin_lock_init(&ts->haptics_update_lock);
+	INIT_WORK(&ts->hostcmd_req_work, thunderstrike_hostcmd_req_work_handler);
+
+	hid_set_drvdata(hdev, shield_dev);
+
+	ts->haptics_dev = shield_haptics_create(shield_dev, thunderstrike_play_effect);
+	if (IS_ERR(ts->haptics_dev))
+		return ERR_CAST(ts->haptics_dev);
+
+	hid_info(hdev, "Registered Thunderstrike controller\n");
+	return shield_dev;
+}
+
+static ssize_t firmware_version_show(struct device *dev,
+				     struct device_attribute *attr, char *buf)
+{
+	struct hid_device *hdev = to_hid_device(dev);
+	struct shield_device *shield_dev;
+	int ret;
+
+	shield_dev = hid_get_drvdata(hdev);
+
+	if (test_bit(SHIELD_FW_VERSION_INITIALIZED, &shield_dev->initialized_flags))
+		ret = sysfs_emit(buf, "0x%04X\n", shield_dev->fw_version);
+	else
+		ret = sysfs_emit(buf, NOT_INIT_STR "\n");
+
+	return ret;
+}
+
+static DEVICE_ATTR_RO(firmware_version);
+
+static ssize_t hardware_version_show(struct device *dev,
+				     struct device_attribute *attr, char *buf)
+{
+	struct hid_device *hdev = to_hid_device(dev);
+	struct shield_device *shield_dev;
+	char board_revision_str[4];
+	int ret;
+
+	shield_dev = hid_get_drvdata(hdev);
+
+	if (test_bit(SHIELD_BOARD_INFO_INITIALIZED, &shield_dev->initialized_flags)) {
+		shield_strrev(board_revision_str, 4, shield_dev->board_info.revision);
+		ret = sysfs_emit(buf, "%s BOARD_REVISION_%s (0x%04X)\n",
+				 shield_dev->codename, board_revision_str,
+				 shield_dev->board_info.revision);
+	} else
+		ret = sysfs_emit(buf, NOT_INIT_STR "\n");
+
+	return ret;
+}
+
+static DEVICE_ATTR_RO(hardware_version);
+
+static ssize_t serial_number_show(struct device *dev,
+				  struct device_attribute *attr, char *buf)
+{
+	struct hid_device *hdev = to_hid_device(dev);
+	struct shield_device *shield_dev;
+	int ret;
+
+	shield_dev = hid_get_drvdata(hdev);
+
+	if (test_bit(SHIELD_BOARD_INFO_INITIALIZED, &shield_dev->initialized_flags))
+		ret = sysfs_emit(buf, "%s\n", shield_dev->board_info.serial_number);
+	else
+		ret = sysfs_emit(buf, NOT_INIT_STR "\n");
+
+	return ret;
+}
+
+static DEVICE_ATTR_RO(serial_number);
+
+static struct attribute *shield_device_attrs[] = {
+	&dev_attr_firmware_version.attr,
+	&dev_attr_hardware_version.attr,
+	&dev_attr_serial_number.attr,
+	NULL,
+};
+ATTRIBUTE_GROUPS(shield_device);
+
+static int shield_raw_event(struct hid_device *hdev, struct hid_report *report,
+			    u8 *data, int size)
+{
+	struct shield_device *dev = hid_get_drvdata(hdev);
+
+	return thunderstrike_parse_report(dev, report, data, size);
+}
+
+static int shield_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+	struct shield_device *shield_dev = NULL;
+	struct thunderstrike *ts;
+	int ret;
+
+	ret = hid_parse(hdev);
+	if (ret) {
+		hid_err(hdev, "Parse failed\n");
+		return ret;
+	}
+
+	switch (id->product) {
+	case USB_DEVICE_ID_NVIDIA_THUNDERSTRIKE_CONTROLLER:
+		shield_dev = thunderstrike_create(hdev);
+		break;
+	}
+
+	if (unlikely(!shield_dev)) {
+		hid_err(hdev, "Failed to identify SHIELD device\n");
+		return -ENODEV;
+	}
+	if (IS_ERR(shield_dev)) {
+		hid_err(hdev, "Failed to create SHIELD device\n");
+		return PTR_ERR(shield_dev);
+	}
+
+	ts = container_of(shield_dev, struct thunderstrike, base);
+
+	ret = hid_hw_start(hdev, HID_CONNECT_HIDINPUT);
+	if (ret) {
+		hid_err(hdev, "Failed to start HID device\n");
+		goto err_haptics;
+	}
+
+	ret = hid_hw_open(hdev);
+	if (ret) {
+		hid_err(hdev, "Failed to open HID device\n");
+		goto err_stop;
+	}
+
+	thunderstrike_request_firmware_version(ts);
+	thunderstrike_request_board_info(ts);
+
+	return ret;
+
+err_stop:
+	hid_hw_stop(hdev);
+err_haptics:
+	if (ts->haptics_dev)
+		input_unregister_device(ts->haptics_dev);
+	return ret;
+}
+
+static void shield_remove(struct hid_device *hdev)
+{
+	struct shield_device *dev = hid_get_drvdata(hdev);
+	struct thunderstrike *ts;
+
+	ts = container_of(dev, struct thunderstrike, base);
+
+	hid_hw_close(hdev);
+	if (ts->haptics_dev)
+		input_unregister_device(ts->haptics_dev);
+	cancel_work_sync(&ts->hostcmd_req_work);
+	hid_hw_stop(hdev);
+}
+
+static const struct hid_device_id shield_devices[] = {
+	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NVIDIA,
+			       USB_DEVICE_ID_NVIDIA_THUNDERSTRIKE_CONTROLLER) },
+	{ HID_USB_DEVICE(USB_VENDOR_ID_NVIDIA,
+			 USB_DEVICE_ID_NVIDIA_THUNDERSTRIKE_CONTROLLER) },
+	{}
+};
+MODULE_DEVICE_TABLE(hid, shield_devices);
+
+static struct hid_driver shield_driver = {
+	.name         = "shield",
+	.id_table     = shield_devices,
+	.probe        = shield_probe,
+	.remove       = shield_remove,
+	.raw_event    = shield_raw_event,
+	.driver = {
+		.dev_groups = shield_device_groups,
+	},
+};
+module_hid_driver(shield_driver);
+
+MODULE_AUTHOR("Rahul Rameshbabu <rrameshbabu@nvidia.com>");
+MODULE_DESCRIPTION("HID Driver for NVIDIA SHIELD peripherals.");
+MODULE_LICENSE("GPL");