brintos / linux-shallow public Read only

1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 *  HID driver for Sony DualSense(TM) controller.4 *5 *  Copyright (c) 2020-2022 Sony Interactive Entertainment6 */7 8#include <linux/bits.h>9#include <linux/crc32.h>10#include <linux/device.h>11#include <linux/hid.h>12#include <linux/idr.h>13#include <linux/input/mt.h>14#include <linux/leds.h>15#include <linux/led-class-multicolor.h>16#include <linux/module.h>17 18#include <linux/unaligned.h>19 20#include "hid-ids.h"21 22/* List of connected playstation devices. */23static DEFINE_MUTEX(ps_devices_lock);24static LIST_HEAD(ps_devices_list);25 26static DEFINE_IDA(ps_player_id_allocator);27 28#define HID_PLAYSTATION_VERSION_PATCH 0x800029 30enum PS_TYPE {31	PS_TYPE_PS4_DUALSHOCK4,32	PS_TYPE_PS5_DUALSENSE,33};34 35/* Base class for playstation devices. */36struct ps_device {37	struct list_head list;38	struct hid_device *hdev;39	spinlock_t lock;40 41	uint32_t player_id;42 43	struct power_supply_desc battery_desc;44	struct power_supply *battery;45	uint8_t battery_capacity;46	int battery_status;47 48	const char *input_dev_name; /* Name of primary input device. */49	uint8_t mac_address[6]; /* Note: stored in little endian order. */50	uint32_t hw_version;51	uint32_t fw_version;52 53	int (*parse_report)(struct ps_device *dev, struct hid_report *report, u8 *data, int size);54	void (*remove)(struct ps_device *dev);55};56 57/* Calibration data for playstation motion sensors. */58struct ps_calibration_data {59	int abs_code;60	short bias;61	int sens_numer;62	int sens_denom;63};64 65struct ps_led_info {66	const char *name;67	const char *color;68	int max_brightness;69	enum led_brightness (*brightness_get)(struct led_classdev *cdev);70	int (*brightness_set)(struct led_classdev *cdev, enum led_brightness);71	int (*blink_set)(struct led_classdev *led, unsigned long *on, unsigned long *off);72};73 74/* Seed values for DualShock4 / DualSense CRC32 for different report types. */75#define PS_INPUT_CRC32_SEED	0xA176#define PS_OUTPUT_CRC32_SEED	0xA277#define PS_FEATURE_CRC32_SEED	0xA378 79#define DS_INPUT_REPORT_USB			0x0180#define DS_INPUT_REPORT_USB_SIZE		6481#define DS_INPUT_REPORT_BT			0x3182#define DS_INPUT_REPORT_BT_SIZE			7883#define DS_OUTPUT_REPORT_USB			0x0284#define DS_OUTPUT_REPORT_USB_SIZE		6385#define DS_OUTPUT_REPORT_BT			0x3186#define DS_OUTPUT_REPORT_BT_SIZE		7887 88#define DS_FEATURE_REPORT_CALIBRATION		0x0589#define DS_FEATURE_REPORT_CALIBRATION_SIZE	4190#define DS_FEATURE_REPORT_PAIRING_INFO		0x0991#define DS_FEATURE_REPORT_PAIRING_INFO_SIZE	2092#define DS_FEATURE_REPORT_FIRMWARE_INFO		0x2093#define DS_FEATURE_REPORT_FIRMWARE_INFO_SIZE	6494 95/* Button masks for DualSense input report. */96#define DS_BUTTONS0_HAT_SWITCH	GENMASK(3, 0)97#define DS_BUTTONS0_SQUARE	BIT(4)98#define DS_BUTTONS0_CROSS	BIT(5)99#define DS_BUTTONS0_CIRCLE	BIT(6)100#define DS_BUTTONS0_TRIANGLE	BIT(7)101#define DS_BUTTONS1_L1		BIT(0)102#define DS_BUTTONS1_R1		BIT(1)103#define DS_BUTTONS1_L2		BIT(2)104#define DS_BUTTONS1_R2		BIT(3)105#define DS_BUTTONS1_CREATE	BIT(4)106#define DS_BUTTONS1_OPTIONS	BIT(5)107#define DS_BUTTONS1_L3		BIT(6)108#define DS_BUTTONS1_R3		BIT(7)109#define DS_BUTTONS2_PS_HOME	BIT(0)110#define DS_BUTTONS2_TOUCHPAD	BIT(1)111#define DS_BUTTONS2_MIC_MUTE	BIT(2)112 113/* Status field of DualSense input report. */114#define DS_STATUS_BATTERY_CAPACITY	GENMASK(3, 0)115#define DS_STATUS_CHARGING		GENMASK(7, 4)116#define DS_STATUS_CHARGING_SHIFT	4117 118/* Feature version from DualSense Firmware Info report. */119#define DS_FEATURE_VERSION(major, minor) ((major & 0xff) << 8 | (minor & 0xff))120 121/*122 * Status of a DualSense touch point contact.123 * Contact IDs, with highest bit set are 'inactive'124 * and any associated data is then invalid.125 */126#define DS_TOUCH_POINT_INACTIVE BIT(7)127 128 /* Magic value required in tag field of Bluetooth output report. */129#define DS_OUTPUT_TAG 0x10130/* Flags for DualSense output report. */131#define DS_OUTPUT_VALID_FLAG0_COMPATIBLE_VIBRATION BIT(0)132#define DS_OUTPUT_VALID_FLAG0_HAPTICS_SELECT BIT(1)133#define DS_OUTPUT_VALID_FLAG1_MIC_MUTE_LED_CONTROL_ENABLE BIT(0)134#define DS_OUTPUT_VALID_FLAG1_POWER_SAVE_CONTROL_ENABLE BIT(1)135#define DS_OUTPUT_VALID_FLAG1_LIGHTBAR_CONTROL_ENABLE BIT(2)136#define DS_OUTPUT_VALID_FLAG1_RELEASE_LEDS BIT(3)137#define DS_OUTPUT_VALID_FLAG1_PLAYER_INDICATOR_CONTROL_ENABLE BIT(4)138#define DS_OUTPUT_VALID_FLAG2_LIGHTBAR_SETUP_CONTROL_ENABLE BIT(1)139#define DS_OUTPUT_VALID_FLAG2_COMPATIBLE_VIBRATION2 BIT(2)140#define DS_OUTPUT_POWER_SAVE_CONTROL_MIC_MUTE BIT(4)141#define DS_OUTPUT_LIGHTBAR_SETUP_LIGHT_OUT BIT(1)142 143/* DualSense hardware limits */144#define DS_ACC_RES_PER_G	8192145#define DS_ACC_RANGE		(4*DS_ACC_RES_PER_G)146#define DS_GYRO_RES_PER_DEG_S	1024147#define DS_GYRO_RANGE		(2048*DS_GYRO_RES_PER_DEG_S)148#define DS_TOUCHPAD_WIDTH	1920149#define DS_TOUCHPAD_HEIGHT	1080150 151struct dualsense {152	struct ps_device base;153	struct input_dev *gamepad;154	struct input_dev *sensors;155	struct input_dev *touchpad;156 157	/* Update version is used as a feature/capability version. */158	uint16_t update_version;159 160	/* Calibration data for accelerometer and gyroscope. */161	struct ps_calibration_data accel_calib_data[3];162	struct ps_calibration_data gyro_calib_data[3];163 164	/* Timestamp for sensor data */165	bool sensor_timestamp_initialized;166	uint32_t prev_sensor_timestamp;167	uint32_t sensor_timestamp_us;168 169	/* Compatible rumble state */170	bool use_vibration_v2;171	bool update_rumble;172	uint8_t motor_left;173	uint8_t motor_right;174 175	/* RGB lightbar */176	struct led_classdev_mc lightbar;177	bool update_lightbar;178	uint8_t lightbar_red;179	uint8_t lightbar_green;180	uint8_t lightbar_blue;181 182	/* Microphone */183	bool update_mic_mute;184	bool mic_muted;185	bool last_btn_mic_state;186 187	/* Player leds */188	bool update_player_leds;189	uint8_t player_leds_state;190	struct led_classdev player_leds[5];191 192	struct work_struct output_worker;193	bool output_worker_initialized;194	void *output_report_dmabuf;195	uint8_t output_seq; /* Sequence number for output report. */196};197 198struct dualsense_touch_point {199	uint8_t contact;200	uint8_t x_lo;201	uint8_t x_hi:4, y_lo:4;202	uint8_t y_hi;203} __packed;204static_assert(sizeof(struct dualsense_touch_point) == 4);205 206/* Main DualSense input report excluding any BT/USB specific headers. */207struct dualsense_input_report {208	uint8_t x, y;209	uint8_t rx, ry;210	uint8_t z, rz;211	uint8_t seq_number;212	uint8_t buttons[4];213	uint8_t reserved[4];214 215	/* Motion sensors */216	__le16 gyro[3]; /* x, y, z */217	__le16 accel[3]; /* x, y, z */218	__le32 sensor_timestamp;219	uint8_t reserved2;220 221	/* Touchpad */222	struct dualsense_touch_point points[2];223 224	uint8_t reserved3[12];225	uint8_t status;226	uint8_t reserved4[10];227} __packed;228/* Common input report size shared equals the size of the USB report minus 1 byte for ReportID. */229static_assert(sizeof(struct dualsense_input_report) == DS_INPUT_REPORT_USB_SIZE - 1);230 231/* Common data between DualSense BT/USB main output report. */232struct dualsense_output_report_common {233	uint8_t valid_flag0;234	uint8_t valid_flag1;235 236	/* For DualShock 4 compatibility mode. */237	uint8_t motor_right;238	uint8_t motor_left;239 240	/* Audio controls */241	uint8_t reserved[4];242	uint8_t mute_button_led;243 244	uint8_t power_save_control;245	uint8_t reserved2[28];246 247	/* LEDs and lightbar */248	uint8_t valid_flag2;249	uint8_t reserved3[2];250	uint8_t lightbar_setup;251	uint8_t led_brightness;252	uint8_t player_leds;253	uint8_t lightbar_red;254	uint8_t lightbar_green;255	uint8_t lightbar_blue;256} __packed;257static_assert(sizeof(struct dualsense_output_report_common) == 47);258 259struct dualsense_output_report_bt {260	uint8_t report_id; /* 0x31 */261	uint8_t seq_tag;262	uint8_t tag;263	struct dualsense_output_report_common common;264	uint8_t reserved[24];265	__le32 crc32;266} __packed;267static_assert(sizeof(struct dualsense_output_report_bt) == DS_OUTPUT_REPORT_BT_SIZE);268 269struct dualsense_output_report_usb {270	uint8_t report_id; /* 0x02 */271	struct dualsense_output_report_common common;272	uint8_t reserved[15];273} __packed;274static_assert(sizeof(struct dualsense_output_report_usb) == DS_OUTPUT_REPORT_USB_SIZE);275 276/*277 * The DualSense has a main output report used to control most features. It is278 * largely the same between Bluetooth and USB except for different headers and CRC.279 * This structure hide the differences between the two to simplify sending output reports.280 */281struct dualsense_output_report {282	uint8_t *data; /* Start of data */283	uint8_t len; /* Size of output report */284 285	/* Points to Bluetooth data payload in case for a Bluetooth report else NULL. */286	struct dualsense_output_report_bt *bt;287	/* Points to USB data payload in case for a USB report else NULL. */288	struct dualsense_output_report_usb *usb;289	/* Points to common section of report, so past any headers. */290	struct dualsense_output_report_common *common;291};292 293#define DS4_INPUT_REPORT_USB			0x01294#define DS4_INPUT_REPORT_USB_SIZE		64295#define DS4_INPUT_REPORT_BT_MINIMAL		0x01296#define DS4_INPUT_REPORT_BT_MINIMAL_SIZE	10297#define DS4_INPUT_REPORT_BT			0x11298#define DS4_INPUT_REPORT_BT_SIZE		78299#define DS4_OUTPUT_REPORT_USB			0x05300#define DS4_OUTPUT_REPORT_USB_SIZE		32301#define DS4_OUTPUT_REPORT_BT			0x11302#define DS4_OUTPUT_REPORT_BT_SIZE		78303 304#define DS4_FEATURE_REPORT_CALIBRATION		0x02305#define DS4_FEATURE_REPORT_CALIBRATION_SIZE	37306#define DS4_FEATURE_REPORT_CALIBRATION_BT	0x05307#define DS4_FEATURE_REPORT_CALIBRATION_BT_SIZE	41308#define DS4_FEATURE_REPORT_FIRMWARE_INFO	0xa3309#define DS4_FEATURE_REPORT_FIRMWARE_INFO_SIZE	49310#define DS4_FEATURE_REPORT_PAIRING_INFO		0x12311#define DS4_FEATURE_REPORT_PAIRING_INFO_SIZE	16312 313/*314 * Status of a DualShock4 touch point contact.315 * Contact IDs, with highest bit set are 'inactive'316 * and any associated data is then invalid.317 */318#define DS4_TOUCH_POINT_INACTIVE BIT(7)319 320/* Status field of DualShock4 input report. */321#define DS4_STATUS0_BATTERY_CAPACITY	GENMASK(3, 0)322#define DS4_STATUS0_CABLE_STATE		BIT(4)323/* Battery status within batery_status field. */324#define DS4_BATTERY_STATUS_FULL		11325/* Status1 bit2 contains dongle connection state:326 * 0 = connectd327 * 1 = disconnected328 */329#define DS4_STATUS1_DONGLE_STATE	BIT(2)330 331/* The lower 6 bits of hw_control of the Bluetooth main output report332 * control the interval at which Dualshock 4 reports data:333 * 0x00 - 1ms334 * 0x01 - 1ms335 * 0x02 - 2ms336 * 0x3E - 62ms337 * 0x3F - disabled338 */339#define DS4_OUTPUT_HWCTL_BT_POLL_MASK	0x3F340/* Default to 4ms poll interval, which is same as USB (not adjustable). */341#define DS4_BT_DEFAULT_POLL_INTERVAL_MS	4342#define DS4_OUTPUT_HWCTL_CRC32		0x40343#define DS4_OUTPUT_HWCTL_HID		0x80344 345/* Flags for DualShock4 output report. */346#define DS4_OUTPUT_VALID_FLAG0_MOTOR		0x01347#define DS4_OUTPUT_VALID_FLAG0_LED		0x02348#define DS4_OUTPUT_VALID_FLAG0_LED_BLINK	0x04349 350/* DualShock4 hardware limits */351#define DS4_ACC_RES_PER_G	8192352#define DS4_ACC_RANGE		(4*DS_ACC_RES_PER_G)353#define DS4_GYRO_RES_PER_DEG_S	1024354#define DS4_GYRO_RANGE		(2048*DS_GYRO_RES_PER_DEG_S)355#define DS4_LIGHTBAR_MAX_BLINK	255 /* 255 centiseconds */356#define DS4_TOUCHPAD_WIDTH	1920357#define DS4_TOUCHPAD_HEIGHT	942358 359enum dualshock4_dongle_state {360	DONGLE_DISCONNECTED,361	DONGLE_CALIBRATING,362	DONGLE_CONNECTED,363	DONGLE_DISABLED364};365 366struct dualshock4 {367	struct ps_device base;368	struct input_dev *gamepad;369	struct input_dev *sensors;370	struct input_dev *touchpad;371 372	/* Calibration data for accelerometer and gyroscope. */373	struct ps_calibration_data accel_calib_data[3];374	struct ps_calibration_data gyro_calib_data[3];375 376	/* Only used on dongle to track state transitions. */377	enum dualshock4_dongle_state dongle_state;378	/* Used during calibration. */379	struct work_struct dongle_hotplug_worker;380 381	/* Timestamp for sensor data */382	bool sensor_timestamp_initialized;383	uint32_t prev_sensor_timestamp;384	uint32_t sensor_timestamp_us;385 386	/* Bluetooth poll interval */387	bool update_bt_poll_interval;388	uint8_t bt_poll_interval;389 390	bool update_rumble;391	uint8_t motor_left;392	uint8_t motor_right;393 394	/* Lightbar leds */395	bool update_lightbar;396	bool update_lightbar_blink;397	bool lightbar_enabled; /* For use by global LED control. */398	uint8_t lightbar_red;399	uint8_t lightbar_green;400	uint8_t lightbar_blue;401	uint8_t lightbar_blink_on; /* In increments of 10ms. */402	uint8_t lightbar_blink_off; /* In increments of 10ms. */403	struct led_classdev lightbar_leds[4];404 405	struct work_struct output_worker;406	bool output_worker_initialized;407	void *output_report_dmabuf;408};409 410struct dualshock4_touch_point {411	uint8_t contact;412	uint8_t x_lo;413	uint8_t x_hi:4, y_lo:4;414	uint8_t y_hi;415} __packed;416static_assert(sizeof(struct dualshock4_touch_point) == 4);417 418struct dualshock4_touch_report {419	uint8_t timestamp;420	struct dualshock4_touch_point points[2];421} __packed;422static_assert(sizeof(struct dualshock4_touch_report) == 9);423 424/* Main DualShock4 input report excluding any BT/USB specific headers. */425struct dualshock4_input_report_common {426	uint8_t x, y;427	uint8_t rx, ry;428	uint8_t buttons[3];429	uint8_t z, rz;430 431	/* Motion sensors */432	__le16 sensor_timestamp;433	uint8_t sensor_temperature;434	__le16 gyro[3]; /* x, y, z */435	__le16 accel[3]; /* x, y, z */436	uint8_t reserved2[5];437 438	uint8_t status[2];439	uint8_t reserved3;440} __packed;441static_assert(sizeof(struct dualshock4_input_report_common) == 32);442 443struct dualshock4_input_report_usb {444	uint8_t report_id; /* 0x01 */445	struct dualshock4_input_report_common common;446	uint8_t num_touch_reports;447	struct dualshock4_touch_report touch_reports[3];448	uint8_t reserved[3];449} __packed;450static_assert(sizeof(struct dualshock4_input_report_usb) == DS4_INPUT_REPORT_USB_SIZE);451 452struct dualshock4_input_report_bt {453	uint8_t report_id; /* 0x11 */454	uint8_t reserved[2];455	struct dualshock4_input_report_common common;456	uint8_t num_touch_reports;457	struct dualshock4_touch_report touch_reports[4]; /* BT has 4 compared to 3 for USB */458	uint8_t reserved2[2];459	__le32 crc32;460} __packed;461static_assert(sizeof(struct dualshock4_input_report_bt) == DS4_INPUT_REPORT_BT_SIZE);462 463/* Common data between Bluetooth and USB DualShock4 output reports. */464struct dualshock4_output_report_common {465	uint8_t valid_flag0;466	uint8_t valid_flag1;467 468	uint8_t reserved;469 470	uint8_t motor_right;471	uint8_t motor_left;472 473	uint8_t lightbar_red;474	uint8_t lightbar_green;475	uint8_t lightbar_blue;476	uint8_t lightbar_blink_on;477	uint8_t lightbar_blink_off;478} __packed;479 480struct dualshock4_output_report_usb {481	uint8_t report_id; /* 0x5 */482	struct dualshock4_output_report_common common;483	uint8_t reserved[21];484} __packed;485static_assert(sizeof(struct dualshock4_output_report_usb) == DS4_OUTPUT_REPORT_USB_SIZE);486 487struct dualshock4_output_report_bt {488	uint8_t report_id; /* 0x11 */489	uint8_t hw_control;490	uint8_t audio_control;491	struct dualshock4_output_report_common common;492	uint8_t reserved[61];493	__le32 crc32;494} __packed;495static_assert(sizeof(struct dualshock4_output_report_bt) == DS4_OUTPUT_REPORT_BT_SIZE);496 497/*498 * The DualShock4 has a main output report used to control most features. It is499 * largely the same between Bluetooth and USB except for different headers and CRC.500 * This structure hide the differences between the two to simplify sending output reports.501 */502struct dualshock4_output_report {503	uint8_t *data; /* Start of data */504	uint8_t len; /* Size of output report */505 506	/* Points to Bluetooth data payload in case for a Bluetooth report else NULL. */507	struct dualshock4_output_report_bt *bt;508	/* Points to USB data payload in case for a USB report else NULL. */509	struct dualshock4_output_report_usb *usb;510	/* Points to common section of report, so past any headers. */511	struct dualshock4_output_report_common *common;512};513 514/*515 * Common gamepad buttons across DualShock 3 / 4 and DualSense.516 * Note: for device with a touchpad, touchpad button is not included517 *        as it will be part of the touchpad device.518 */519static const int ps_gamepad_buttons[] = {520	BTN_WEST, /* Square */521	BTN_NORTH, /* Triangle */522	BTN_EAST, /* Circle */523	BTN_SOUTH, /* Cross */524	BTN_TL, /* L1 */525	BTN_TR, /* R1 */526	BTN_TL2, /* L2 */527	BTN_TR2, /* R2 */528	BTN_SELECT, /* Create (PS5) / Share (PS4) */529	BTN_START, /* Option */530	BTN_THUMBL, /* L3 */531	BTN_THUMBR, /* R3 */532	BTN_MODE, /* PS Home */533};534 535static const struct {int x; int y; } ps_gamepad_hat_mapping[] = {536	{0, -1}, {1, -1}, {1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1},537	{0, 0},538};539 540static int dualshock4_get_calibration_data(struct dualshock4 *ds4);541static inline void dualsense_schedule_work(struct dualsense *ds);542static inline void dualshock4_schedule_work(struct dualshock4 *ds4);543static void dualsense_set_lightbar(struct dualsense *ds, uint8_t red, uint8_t green, uint8_t blue);544static void dualshock4_set_default_lightbar_colors(struct dualshock4 *ds4);545 546/*547 * Add a new ps_device to ps_devices if it doesn't exist.548 * Return error on duplicate device, which can happen if the same549 * device is connected using both Bluetooth and USB.550 */551static int ps_devices_list_add(struct ps_device *dev)552{553	struct ps_device *entry;554 555	mutex_lock(&ps_devices_lock);556	list_for_each_entry(entry, &ps_devices_list, list) {557		if (!memcmp(entry->mac_address, dev->mac_address, sizeof(dev->mac_address))) {558			hid_err(dev->hdev, "Duplicate device found for MAC address %pMR.\n",559					dev->mac_address);560			mutex_unlock(&ps_devices_lock);561			return -EEXIST;562		}563	}564 565	list_add_tail(&dev->list, &ps_devices_list);566	mutex_unlock(&ps_devices_lock);567	return 0;568}569 570static int ps_devices_list_remove(struct ps_device *dev)571{572	mutex_lock(&ps_devices_lock);573	list_del(&dev->list);574	mutex_unlock(&ps_devices_lock);575	return 0;576}577 578static int ps_device_set_player_id(struct ps_device *dev)579{580	int ret = ida_alloc(&ps_player_id_allocator, GFP_KERNEL);581 582	if (ret < 0)583		return ret;584 585	dev->player_id = ret;586	return 0;587}588 589static void ps_device_release_player_id(struct ps_device *dev)590{591	ida_free(&ps_player_id_allocator, dev->player_id);592 593	dev->player_id = U32_MAX;594}595 596static struct input_dev *ps_allocate_input_dev(struct hid_device *hdev, const char *name_suffix)597{598	struct input_dev *input_dev;599 600	input_dev = devm_input_allocate_device(&hdev->dev);601	if (!input_dev)602		return ERR_PTR(-ENOMEM);603 604	input_dev->id.bustype = hdev->bus;605	input_dev->id.vendor = hdev->vendor;606	input_dev->id.product = hdev->product;607	input_dev->id.version = hdev->version;608	input_dev->uniq = hdev->uniq;609 610	if (name_suffix) {611		input_dev->name = devm_kasprintf(&hdev->dev, GFP_KERNEL, "%s %s", hdev->name,612				name_suffix);613		if (!input_dev->name)614			return ERR_PTR(-ENOMEM);615	} else {616		input_dev->name = hdev->name;617	}618 619	input_set_drvdata(input_dev, hdev);620 621	return input_dev;622}623 624static enum power_supply_property ps_power_supply_props[] = {625	POWER_SUPPLY_PROP_STATUS,626	POWER_SUPPLY_PROP_PRESENT,627	POWER_SUPPLY_PROP_CAPACITY,628	POWER_SUPPLY_PROP_SCOPE,629};630 631static int ps_battery_get_property(struct power_supply *psy,632		enum power_supply_property psp,633		union power_supply_propval *val)634{635	struct ps_device *dev = power_supply_get_drvdata(psy);636	uint8_t battery_capacity;637	int battery_status;638	unsigned long flags;639	int ret = 0;640 641	spin_lock_irqsave(&dev->lock, flags);642	battery_capacity = dev->battery_capacity;643	battery_status = dev->battery_status;644	spin_unlock_irqrestore(&dev->lock, flags);645 646	switch (psp) {647	case POWER_SUPPLY_PROP_STATUS:648		val->intval = battery_status;649		break;650	case POWER_SUPPLY_PROP_PRESENT:651		val->intval = 1;652		break;653	case POWER_SUPPLY_PROP_CAPACITY:654		val->intval = battery_capacity;655		break;656	case POWER_SUPPLY_PROP_SCOPE:657		val->intval = POWER_SUPPLY_SCOPE_DEVICE;658		break;659	default:660		ret = -EINVAL;661		break;662	}663 664	return ret;665}666 667static int ps_device_register_battery(struct ps_device *dev)668{669	struct power_supply *battery;670	struct power_supply_config battery_cfg = { .drv_data = dev };671	int ret;672 673	dev->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;674	dev->battery_desc.properties = ps_power_supply_props;675	dev->battery_desc.num_properties = ARRAY_SIZE(ps_power_supply_props);676	dev->battery_desc.get_property = ps_battery_get_property;677	dev->battery_desc.name = devm_kasprintf(&dev->hdev->dev, GFP_KERNEL,678			"ps-controller-battery-%pMR", dev->mac_address);679	if (!dev->battery_desc.name)680		return -ENOMEM;681 682	battery = devm_power_supply_register(&dev->hdev->dev, &dev->battery_desc, &battery_cfg);683	if (IS_ERR(battery)) {684		ret = PTR_ERR(battery);685		hid_err(dev->hdev, "Unable to register battery device: %d\n", ret);686		return ret;687	}688	dev->battery = battery;689 690	ret = power_supply_powers(dev->battery, &dev->hdev->dev);691	if (ret) {692		hid_err(dev->hdev, "Unable to activate battery device: %d\n", ret);693		return ret;694	}695 696	return 0;697}698 699/* Compute crc32 of HID data and compare against expected CRC. */700static bool ps_check_crc32(uint8_t seed, uint8_t *data, size_t len, uint32_t report_crc)701{702	uint32_t crc;703 704	crc = crc32_le(0xFFFFFFFF, &seed, 1);705	crc = ~crc32_le(crc, data, len);706 707	return crc == report_crc;708}709 710static struct input_dev *ps_gamepad_create(struct hid_device *hdev,711		int (*play_effect)(struct input_dev *, void *, struct ff_effect *))712{713	struct input_dev *gamepad;714	unsigned int i;715	int ret;716 717	gamepad = ps_allocate_input_dev(hdev, NULL);718	if (IS_ERR(gamepad))719		return ERR_CAST(gamepad);720 721	input_set_abs_params(gamepad, ABS_X, 0, 255, 0, 0);722	input_set_abs_params(gamepad, ABS_Y, 0, 255, 0, 0);723	input_set_abs_params(gamepad, ABS_Z, 0, 255, 0, 0);724	input_set_abs_params(gamepad, ABS_RX, 0, 255, 0, 0);725	input_set_abs_params(gamepad, ABS_RY, 0, 255, 0, 0);726	input_set_abs_params(gamepad, ABS_RZ, 0, 255, 0, 0);727 728	input_set_abs_params(gamepad, ABS_HAT0X, -1, 1, 0, 0);729	input_set_abs_params(gamepad, ABS_HAT0Y, -1, 1, 0, 0);730 731	for (i = 0; i < ARRAY_SIZE(ps_gamepad_buttons); i++)732		input_set_capability(gamepad, EV_KEY, ps_gamepad_buttons[i]);733 734#if IS_ENABLED(CONFIG_PLAYSTATION_FF)735	if (play_effect) {736		input_set_capability(gamepad, EV_FF, FF_RUMBLE);737		input_ff_create_memless(gamepad, NULL, play_effect);738	}739#endif740 741	ret = input_register_device(gamepad);742	if (ret)743		return ERR_PTR(ret);744 745	return gamepad;746}747 748static int ps_get_report(struct hid_device *hdev, uint8_t report_id, uint8_t *buf, size_t size,749		bool check_crc)750{751	int ret;752 753	ret = hid_hw_raw_request(hdev, report_id, buf, size, HID_FEATURE_REPORT,754				 HID_REQ_GET_REPORT);755	if (ret < 0) {756		hid_err(hdev, "Failed to retrieve feature with reportID %d: %d\n", report_id, ret);757		return ret;758	}759 760	if (ret != size) {761		hid_err(hdev, "Invalid byte count transferred, expected %zu got %d\n", size, ret);762		return -EINVAL;763	}764 765	if (buf[0] != report_id) {766		hid_err(hdev, "Invalid reportID received, expected %d got %d\n", report_id, buf[0]);767		return -EINVAL;768	}769 770	if (hdev->bus == BUS_BLUETOOTH && check_crc) {771		/* Last 4 bytes contains crc32. */772		uint8_t crc_offset = size - 4;773		uint32_t report_crc = get_unaligned_le32(&buf[crc_offset]);774 775		if (!ps_check_crc32(PS_FEATURE_CRC32_SEED, buf, crc_offset, report_crc)) {776			hid_err(hdev, "CRC check failed for reportID=%d\n", report_id);777			return -EILSEQ;778		}779	}780 781	return 0;782}783 784static int ps_led_register(struct ps_device *ps_dev, struct led_classdev *led,785		const struct ps_led_info *led_info)786{787	int ret;788 789	if (led_info->name) {790		led->name = devm_kasprintf(&ps_dev->hdev->dev, GFP_KERNEL,791				"%s:%s:%s", ps_dev->input_dev_name, led_info->color, led_info->name);792	} else {793		/* Backwards compatible mode for hid-sony, but not compliant with LED class spec. */794		led->name = devm_kasprintf(&ps_dev->hdev->dev, GFP_KERNEL,795				"%s:%s", ps_dev->input_dev_name, led_info->color);796	}797 798	if (!led->name)799		return -ENOMEM;800 801	led->brightness = 0;802	led->max_brightness = led_info->max_brightness;803	led->flags = LED_CORE_SUSPENDRESUME;804	led->brightness_get = led_info->brightness_get;805	led->brightness_set_blocking = led_info->brightness_set;806	led->blink_set = led_info->blink_set;807 808	ret = devm_led_classdev_register(&ps_dev->hdev->dev, led);809	if (ret) {810		hid_err(ps_dev->hdev, "Failed to register LED %s: %d\n", led_info->name, ret);811		return ret;812	}813 814	return 0;815}816 817/* Register a DualSense/DualShock4 RGB lightbar represented by a multicolor LED. */818static int ps_lightbar_register(struct ps_device *ps_dev, struct led_classdev_mc *lightbar_mc_dev,819	int (*brightness_set)(struct led_classdev *, enum led_brightness))820{821	struct hid_device *hdev = ps_dev->hdev;822	struct mc_subled *mc_led_info;823	struct led_classdev *led_cdev;824	int ret;825 826	mc_led_info = devm_kmalloc_array(&hdev->dev, 3, sizeof(*mc_led_info),827					 GFP_KERNEL | __GFP_ZERO);828	if (!mc_led_info)829		return -ENOMEM;830 831	mc_led_info[0].color_index = LED_COLOR_ID_RED;832	mc_led_info[1].color_index = LED_COLOR_ID_GREEN;833	mc_led_info[2].color_index = LED_COLOR_ID_BLUE;834 835	lightbar_mc_dev->subled_info = mc_led_info;836	lightbar_mc_dev->num_colors = 3;837 838	led_cdev = &lightbar_mc_dev->led_cdev;839	led_cdev->name = devm_kasprintf(&hdev->dev, GFP_KERNEL, "%s:rgb:indicator",840			ps_dev->input_dev_name);841	if (!led_cdev->name)842		return -ENOMEM;843	led_cdev->brightness = 255;844	led_cdev->max_brightness = 255;845	led_cdev->brightness_set_blocking = brightness_set;846 847	ret = devm_led_classdev_multicolor_register(&hdev->dev, lightbar_mc_dev);848	if (ret < 0) {849		hid_err(hdev, "Cannot register multicolor LED device\n");850		return ret;851	}852 853	return 0;854}855 856static struct input_dev *ps_sensors_create(struct hid_device *hdev, int accel_range, int accel_res,857		int gyro_range, int gyro_res)858{859	struct input_dev *sensors;860	int ret;861 862	sensors = ps_allocate_input_dev(hdev, "Motion Sensors");863	if (IS_ERR(sensors))864		return ERR_CAST(sensors);865 866	__set_bit(INPUT_PROP_ACCELEROMETER, sensors->propbit);867	__set_bit(EV_MSC, sensors->evbit);868	__set_bit(MSC_TIMESTAMP, sensors->mscbit);869 870	/* Accelerometer */871	input_set_abs_params(sensors, ABS_X, -accel_range, accel_range, 16, 0);872	input_set_abs_params(sensors, ABS_Y, -accel_range, accel_range, 16, 0);873	input_set_abs_params(sensors, ABS_Z, -accel_range, accel_range, 16, 0);874	input_abs_set_res(sensors, ABS_X, accel_res);875	input_abs_set_res(sensors, ABS_Y, accel_res);876	input_abs_set_res(sensors, ABS_Z, accel_res);877 878	/* Gyroscope */879	input_set_abs_params(sensors, ABS_RX, -gyro_range, gyro_range, 16, 0);880	input_set_abs_params(sensors, ABS_RY, -gyro_range, gyro_range, 16, 0);881	input_set_abs_params(sensors, ABS_RZ, -gyro_range, gyro_range, 16, 0);882	input_abs_set_res(sensors, ABS_RX, gyro_res);883	input_abs_set_res(sensors, ABS_RY, gyro_res);884	input_abs_set_res(sensors, ABS_RZ, gyro_res);885 886	ret = input_register_device(sensors);887	if (ret)888		return ERR_PTR(ret);889 890	return sensors;891}892 893static struct input_dev *ps_touchpad_create(struct hid_device *hdev, int width, int height,894		unsigned int num_contacts)895{896	struct input_dev *touchpad;897	int ret;898 899	touchpad = ps_allocate_input_dev(hdev, "Touchpad");900	if (IS_ERR(touchpad))901		return ERR_CAST(touchpad);902 903	/* Map button underneath touchpad to BTN_LEFT. */904	input_set_capability(touchpad, EV_KEY, BTN_LEFT);905	__set_bit(INPUT_PROP_BUTTONPAD, touchpad->propbit);906 907	input_set_abs_params(touchpad, ABS_MT_POSITION_X, 0, width - 1, 0, 0);908	input_set_abs_params(touchpad, ABS_MT_POSITION_Y, 0, height - 1, 0, 0);909 910	ret = input_mt_init_slots(touchpad, num_contacts, INPUT_MT_POINTER);911	if (ret)912		return ERR_PTR(ret);913 914	ret = input_register_device(touchpad);915	if (ret)916		return ERR_PTR(ret);917 918	return touchpad;919}920 921static ssize_t firmware_version_show(struct device *dev,922				struct device_attribute923				*attr, char *buf)924{925	struct hid_device *hdev = to_hid_device(dev);926	struct ps_device *ps_dev = hid_get_drvdata(hdev);927 928	return sysfs_emit(buf, "0x%08x\n", ps_dev->fw_version);929}930 931static DEVICE_ATTR_RO(firmware_version);932 933static ssize_t hardware_version_show(struct device *dev,934				struct device_attribute935				*attr, char *buf)936{937	struct hid_device *hdev = to_hid_device(dev);938	struct ps_device *ps_dev = hid_get_drvdata(hdev);939 940	return sysfs_emit(buf, "0x%08x\n", ps_dev->hw_version);941}942 943static DEVICE_ATTR_RO(hardware_version);944 945static struct attribute *ps_device_attrs[] = {946	&dev_attr_firmware_version.attr,947	&dev_attr_hardware_version.attr,948	NULL949};950ATTRIBUTE_GROUPS(ps_device);951 952static int dualsense_get_calibration_data(struct dualsense *ds)953{954	struct hid_device *hdev = ds->base.hdev;955	short gyro_pitch_bias, gyro_pitch_plus, gyro_pitch_minus;956	short gyro_yaw_bias, gyro_yaw_plus, gyro_yaw_minus;957	short gyro_roll_bias, gyro_roll_plus, gyro_roll_minus;958	short gyro_speed_plus, gyro_speed_minus;959	short acc_x_plus, acc_x_minus;960	short acc_y_plus, acc_y_minus;961	short acc_z_plus, acc_z_minus;962	int speed_2x;963	int range_2g;964	int ret = 0;965	int i;966	uint8_t *buf;967 968	buf = kzalloc(DS_FEATURE_REPORT_CALIBRATION_SIZE, GFP_KERNEL);969	if (!buf)970		return -ENOMEM;971 972	ret = ps_get_report(ds->base.hdev, DS_FEATURE_REPORT_CALIBRATION, buf,973			DS_FEATURE_REPORT_CALIBRATION_SIZE, true);974	if (ret) {975		hid_err(ds->base.hdev, "Failed to retrieve DualSense calibration info: %d\n", ret);976		goto err_free;977	}978 979	gyro_pitch_bias  = get_unaligned_le16(&buf[1]);980	gyro_yaw_bias    = get_unaligned_le16(&buf[3]);981	gyro_roll_bias   = get_unaligned_le16(&buf[5]);982	gyro_pitch_plus  = get_unaligned_le16(&buf[7]);983	gyro_pitch_minus = get_unaligned_le16(&buf[9]);984	gyro_yaw_plus    = get_unaligned_le16(&buf[11]);985	gyro_yaw_minus   = get_unaligned_le16(&buf[13]);986	gyro_roll_plus   = get_unaligned_le16(&buf[15]);987	gyro_roll_minus  = get_unaligned_le16(&buf[17]);988	gyro_speed_plus  = get_unaligned_le16(&buf[19]);989	gyro_speed_minus = get_unaligned_le16(&buf[21]);990	acc_x_plus       = get_unaligned_le16(&buf[23]);991	acc_x_minus      = get_unaligned_le16(&buf[25]);992	acc_y_plus       = get_unaligned_le16(&buf[27]);993	acc_y_minus      = get_unaligned_le16(&buf[29]);994	acc_z_plus       = get_unaligned_le16(&buf[31]);995	acc_z_minus      = get_unaligned_le16(&buf[33]);996 997	/*998	 * Set gyroscope calibration and normalization parameters.999	 * Data values will be normalized to 1/DS_GYRO_RES_PER_DEG_S degree/s.1000	 */1001	speed_2x = (gyro_speed_plus + gyro_speed_minus);1002	ds->gyro_calib_data[0].abs_code = ABS_RX;1003	ds->gyro_calib_data[0].bias = 0;1004	ds->gyro_calib_data[0].sens_numer = speed_2x*DS_GYRO_RES_PER_DEG_S;1005	ds->gyro_calib_data[0].sens_denom = abs(gyro_pitch_plus - gyro_pitch_bias) +1006			abs(gyro_pitch_minus - gyro_pitch_bias);1007 1008	ds->gyro_calib_data[1].abs_code = ABS_RY;1009	ds->gyro_calib_data[1].bias = 0;1010	ds->gyro_calib_data[1].sens_numer = speed_2x*DS_GYRO_RES_PER_DEG_S;1011	ds->gyro_calib_data[1].sens_denom = abs(gyro_yaw_plus - gyro_yaw_bias) +1012			abs(gyro_yaw_minus - gyro_yaw_bias);1013 1014	ds->gyro_calib_data[2].abs_code = ABS_RZ;1015	ds->gyro_calib_data[2].bias = 0;1016	ds->gyro_calib_data[2].sens_numer = speed_2x*DS_GYRO_RES_PER_DEG_S;1017	ds->gyro_calib_data[2].sens_denom = abs(gyro_roll_plus - gyro_roll_bias) +1018			abs(gyro_roll_minus - gyro_roll_bias);1019 1020	/*1021	 * Sanity check gyro calibration data. This is needed to prevent crashes1022	 * during report handling of virtual, clone or broken devices not implementing1023	 * calibration data properly.1024	 */1025	for (i = 0; i < ARRAY_SIZE(ds->gyro_calib_data); i++) {1026		if (ds->gyro_calib_data[i].sens_denom == 0) {1027			hid_warn(hdev, "Invalid gyro calibration data for axis (%d), disabling calibration.",1028					ds->gyro_calib_data[i].abs_code);1029			ds->gyro_calib_data[i].bias = 0;1030			ds->gyro_calib_data[i].sens_numer = DS_GYRO_RANGE;1031			ds->gyro_calib_data[i].sens_denom = S16_MAX;1032		}1033	}1034 1035	/*1036	 * Set accelerometer calibration and normalization parameters.1037	 * Data values will be normalized to 1/DS_ACC_RES_PER_G g.1038	 */1039	range_2g = acc_x_plus - acc_x_minus;1040	ds->accel_calib_data[0].abs_code = ABS_X;1041	ds->accel_calib_data[0].bias = acc_x_plus - range_2g / 2;1042	ds->accel_calib_data[0].sens_numer = 2*DS_ACC_RES_PER_G;1043	ds->accel_calib_data[0].sens_denom = range_2g;1044 1045	range_2g = acc_y_plus - acc_y_minus;1046	ds->accel_calib_data[1].abs_code = ABS_Y;1047	ds->accel_calib_data[1].bias = acc_y_plus - range_2g / 2;1048	ds->accel_calib_data[1].sens_numer = 2*DS_ACC_RES_PER_G;1049	ds->accel_calib_data[1].sens_denom = range_2g;1050 1051	range_2g = acc_z_plus - acc_z_minus;1052	ds->accel_calib_data[2].abs_code = ABS_Z;1053	ds->accel_calib_data[2].bias = acc_z_plus - range_2g / 2;1054	ds->accel_calib_data[2].sens_numer = 2*DS_ACC_RES_PER_G;1055	ds->accel_calib_data[2].sens_denom = range_2g;1056 1057	/*1058	 * Sanity check accelerometer calibration data. This is needed to prevent crashes1059	 * during report handling of virtual, clone or broken devices not implementing calibration1060	 * data properly.1061	 */1062	for (i = 0; i < ARRAY_SIZE(ds->accel_calib_data); i++) {1063		if (ds->accel_calib_data[i].sens_denom == 0) {1064			hid_warn(hdev, "Invalid accelerometer calibration data for axis (%d), disabling calibration.",1065					ds->accel_calib_data[i].abs_code);1066			ds->accel_calib_data[i].bias = 0;1067			ds->accel_calib_data[i].sens_numer = DS_ACC_RANGE;1068			ds->accel_calib_data[i].sens_denom = S16_MAX;1069		}1070	}1071 1072err_free:1073	kfree(buf);1074	return ret;1075}1076 1077 1078static int dualsense_get_firmware_info(struct dualsense *ds)1079{1080	uint8_t *buf;1081	int ret;1082 1083	buf = kzalloc(DS_FEATURE_REPORT_FIRMWARE_INFO_SIZE, GFP_KERNEL);1084	if (!buf)1085		return -ENOMEM;1086 1087	ret = ps_get_report(ds->base.hdev, DS_FEATURE_REPORT_FIRMWARE_INFO, buf,1088			DS_FEATURE_REPORT_FIRMWARE_INFO_SIZE, true);1089	if (ret) {1090		hid_err(ds->base.hdev, "Failed to retrieve DualSense firmware info: %d\n", ret);1091		goto err_free;1092	}1093 1094	ds->base.hw_version = get_unaligned_le32(&buf[24]);1095	ds->base.fw_version = get_unaligned_le32(&buf[28]);1096 1097	/* Update version is some kind of feature version. It is distinct from1098	 * the firmware version as there can be many different variations of a1099	 * controller over time with the same physical shell, but with different1100	 * PCBs and other internal changes. The update version (internal name) is1101	 * used as a means to detect what features are available and change behavior.1102	 * Note: the version is different between DualSense and DualSense Edge.1103	 */1104	ds->update_version = get_unaligned_le16(&buf[44]);1105 1106err_free:1107	kfree(buf);1108	return ret;1109}1110 1111static int dualsense_get_mac_address(struct dualsense *ds)1112{1113	uint8_t *buf;1114	int ret = 0;1115 1116	buf = kzalloc(DS_FEATURE_REPORT_PAIRING_INFO_SIZE, GFP_KERNEL);1117	if (!buf)1118		return -ENOMEM;1119 1120	ret = ps_get_report(ds->base.hdev, DS_FEATURE_REPORT_PAIRING_INFO, buf,1121			DS_FEATURE_REPORT_PAIRING_INFO_SIZE, true);1122	if (ret) {1123		hid_err(ds->base.hdev, "Failed to retrieve DualSense pairing info: %d\n", ret);1124		goto err_free;1125	}1126 1127	memcpy(ds->base.mac_address, &buf[1], sizeof(ds->base.mac_address));1128 1129err_free:1130	kfree(buf);1131	return ret;1132}1133 1134static int dualsense_lightbar_set_brightness(struct led_classdev *cdev,1135	enum led_brightness brightness)1136{1137	struct led_classdev_mc *mc_cdev = lcdev_to_mccdev(cdev);1138	struct dualsense *ds = container_of(mc_cdev, struct dualsense, lightbar);1139	uint8_t red, green, blue;1140 1141	led_mc_calc_color_components(mc_cdev, brightness);1142	red = mc_cdev->subled_info[0].brightness;1143	green = mc_cdev->subled_info[1].brightness;1144	blue = mc_cdev->subled_info[2].brightness;1145 1146	dualsense_set_lightbar(ds, red, green, blue);1147	return 0;1148}1149 1150static enum led_brightness dualsense_player_led_get_brightness(struct led_classdev *led)1151{1152	struct hid_device *hdev = to_hid_device(led->dev->parent);1153	struct dualsense *ds = hid_get_drvdata(hdev);1154 1155	return !!(ds->player_leds_state & BIT(led - ds->player_leds));1156}1157 1158static int dualsense_player_led_set_brightness(struct led_classdev *led, enum led_brightness value)1159{1160	struct hid_device *hdev = to_hid_device(led->dev->parent);1161	struct dualsense *ds = hid_get_drvdata(hdev);1162	unsigned long flags;1163	unsigned int led_index;1164 1165	spin_lock_irqsave(&ds->base.lock, flags);1166 1167	led_index = led - ds->player_leds;1168	if (value == LED_OFF)1169		ds->player_leds_state &= ~BIT(led_index);1170	else1171		ds->player_leds_state |= BIT(led_index);1172 1173	ds->update_player_leds = true;1174	spin_unlock_irqrestore(&ds->base.lock, flags);1175 1176	dualsense_schedule_work(ds);1177 1178	return 0;1179}1180 1181static void dualsense_init_output_report(struct dualsense *ds, struct dualsense_output_report *rp,1182		void *buf)1183{1184	struct hid_device *hdev = ds->base.hdev;1185 1186	if (hdev->bus == BUS_BLUETOOTH) {1187		struct dualsense_output_report_bt *bt = buf;1188 1189		memset(bt, 0, sizeof(*bt));1190		bt->report_id = DS_OUTPUT_REPORT_BT;1191		bt->tag = DS_OUTPUT_TAG; /* Tag must be set. Exact meaning is unclear. */1192 1193		/*1194		 * Highest 4-bit is a sequence number, which needs to be increased1195		 * every report. Lowest 4-bit is tag and can be zero for now.1196		 */1197		bt->seq_tag = (ds->output_seq << 4) | 0x0;1198		if (++ds->output_seq == 16)1199			ds->output_seq = 0;1200 1201		rp->data = buf;1202		rp->len = sizeof(*bt);1203		rp->bt = bt;1204		rp->usb = NULL;1205		rp->common = &bt->common;1206	} else { /* USB */1207		struct dualsense_output_report_usb *usb = buf;1208 1209		memset(usb, 0, sizeof(*usb));1210		usb->report_id = DS_OUTPUT_REPORT_USB;1211 1212		rp->data = buf;1213		rp->len = sizeof(*usb);1214		rp->bt = NULL;1215		rp->usb = usb;1216		rp->common = &usb->common;1217	}1218}1219 1220static inline void dualsense_schedule_work(struct dualsense *ds)1221{1222	unsigned long flags;1223 1224	spin_lock_irqsave(&ds->base.lock, flags);1225	if (ds->output_worker_initialized)1226		schedule_work(&ds->output_worker);1227	spin_unlock_irqrestore(&ds->base.lock, flags);1228}1229 1230/*1231 * Helper function to send DualSense output reports. Applies a CRC at the end of a report1232 * for Bluetooth reports.1233 */1234static void dualsense_send_output_report(struct dualsense *ds,1235		struct dualsense_output_report *report)1236{1237	struct hid_device *hdev = ds->base.hdev;1238 1239	/* Bluetooth packets need to be signed with a CRC in the last 4 bytes. */1240	if (report->bt) {1241		uint32_t crc;1242		uint8_t seed = PS_OUTPUT_CRC32_SEED;1243 1244		crc = crc32_le(0xFFFFFFFF, &seed, 1);1245		crc = ~crc32_le(crc, report->data, report->len - 4);1246 1247		report->bt->crc32 = cpu_to_le32(crc);1248	}1249 1250	hid_hw_output_report(hdev, report->data, report->len);1251}1252 1253static void dualsense_output_worker(struct work_struct *work)1254{1255	struct dualsense *ds = container_of(work, struct dualsense, output_worker);1256	struct dualsense_output_report report;1257	struct dualsense_output_report_common *common;1258	unsigned long flags;1259 1260	dualsense_init_output_report(ds, &report, ds->output_report_dmabuf);1261	common = report.common;1262 1263	spin_lock_irqsave(&ds->base.lock, flags);1264 1265	if (ds->update_rumble) {1266		/* Select classic rumble style haptics and enable it. */1267		common->valid_flag0 |= DS_OUTPUT_VALID_FLAG0_HAPTICS_SELECT;1268		if (ds->use_vibration_v2)1269			common->valid_flag2 |= DS_OUTPUT_VALID_FLAG2_COMPATIBLE_VIBRATION2;1270		else1271			common->valid_flag0 |= DS_OUTPUT_VALID_FLAG0_COMPATIBLE_VIBRATION;1272		common->motor_left = ds->motor_left;1273		common->motor_right = ds->motor_right;1274		ds->update_rumble = false;1275	}1276 1277	if (ds->update_lightbar) {1278		common->valid_flag1 |= DS_OUTPUT_VALID_FLAG1_LIGHTBAR_CONTROL_ENABLE;1279		common->lightbar_red = ds->lightbar_red;1280		common->lightbar_green = ds->lightbar_green;1281		common->lightbar_blue = ds->lightbar_blue;1282 1283		ds->update_lightbar = false;1284	}1285 1286	if (ds->update_player_leds) {1287		common->valid_flag1 |= DS_OUTPUT_VALID_FLAG1_PLAYER_INDICATOR_CONTROL_ENABLE;1288		common->player_leds = ds->player_leds_state;1289 1290		ds->update_player_leds = false;1291	}1292 1293	if (ds->update_mic_mute) {1294		common->valid_flag1 |= DS_OUTPUT_VALID_FLAG1_MIC_MUTE_LED_CONTROL_ENABLE;1295		common->mute_button_led = ds->mic_muted;1296 1297		if (ds->mic_muted) {1298			/* Disable microphone */1299			common->valid_flag1 |= DS_OUTPUT_VALID_FLAG1_POWER_SAVE_CONTROL_ENABLE;1300			common->power_save_control |= DS_OUTPUT_POWER_SAVE_CONTROL_MIC_MUTE;1301		} else {1302			/* Enable microphone */1303			common->valid_flag1 |= DS_OUTPUT_VALID_FLAG1_POWER_SAVE_CONTROL_ENABLE;1304			common->power_save_control &= ~DS_OUTPUT_POWER_SAVE_CONTROL_MIC_MUTE;1305		}1306 1307		ds->update_mic_mute = false;1308	}1309 1310	spin_unlock_irqrestore(&ds->base.lock, flags);1311 1312	dualsense_send_output_report(ds, &report);1313}1314 1315static int dualsense_parse_report(struct ps_device *ps_dev, struct hid_report *report,1316		u8 *data, int size)1317{1318	struct hid_device *hdev = ps_dev->hdev;1319	struct dualsense *ds = container_of(ps_dev, struct dualsense, base);1320	struct dualsense_input_report *ds_report;1321	uint8_t battery_data, battery_capacity, charging_status, value;1322	int battery_status;1323	uint32_t sensor_timestamp;1324	bool btn_mic_state;1325	unsigned long flags;1326	int i;1327 1328	/*1329	 * DualSense in USB uses the full HID report for reportID 1, but1330	 * Bluetooth uses a minimal HID report for reportID 1 and reports1331	 * the full report using reportID 49.1332	 */1333	if (hdev->bus == BUS_USB && report->id == DS_INPUT_REPORT_USB &&1334			size == DS_INPUT_REPORT_USB_SIZE) {1335		ds_report = (struct dualsense_input_report *)&data[1];1336	} else if (hdev->bus == BUS_BLUETOOTH && report->id == DS_INPUT_REPORT_BT &&1337			size == DS_INPUT_REPORT_BT_SIZE) {1338		/* Last 4 bytes of input report contain crc32 */1339		uint32_t report_crc = get_unaligned_le32(&data[size - 4]);1340 1341		if (!ps_check_crc32(PS_INPUT_CRC32_SEED, data, size - 4, report_crc)) {1342			hid_err(hdev, "DualSense input CRC's check failed\n");1343			return -EILSEQ;1344		}1345 1346		ds_report = (struct dualsense_input_report *)&data[2];1347	} else {1348		hid_err(hdev, "Unhandled reportID=%d\n", report->id);1349		return -1;1350	}1351 1352	input_report_abs(ds->gamepad, ABS_X,  ds_report->x);1353	input_report_abs(ds->gamepad, ABS_Y,  ds_report->y);1354	input_report_abs(ds->gamepad, ABS_RX, ds_report->rx);1355	input_report_abs(ds->gamepad, ABS_RY, ds_report->ry);1356	input_report_abs(ds->gamepad, ABS_Z,  ds_report->z);1357	input_report_abs(ds->gamepad, ABS_RZ, ds_report->rz);1358 1359	value = ds_report->buttons[0] & DS_BUTTONS0_HAT_SWITCH;1360	if (value >= ARRAY_SIZE(ps_gamepad_hat_mapping))1361		value = 8; /* center */1362	input_report_abs(ds->gamepad, ABS_HAT0X, ps_gamepad_hat_mapping[value].x);1363	input_report_abs(ds->gamepad, ABS_HAT0Y, ps_gamepad_hat_mapping[value].y);1364 1365	input_report_key(ds->gamepad, BTN_WEST,   ds_report->buttons[0] & DS_BUTTONS0_SQUARE);1366	input_report_key(ds->gamepad, BTN_SOUTH,  ds_report->buttons[0] & DS_BUTTONS0_CROSS);1367	input_report_key(ds->gamepad, BTN_EAST,   ds_report->buttons[0] & DS_BUTTONS0_CIRCLE);1368	input_report_key(ds->gamepad, BTN_NORTH,  ds_report->buttons[0] & DS_BUTTONS0_TRIANGLE);1369	input_report_key(ds->gamepad, BTN_TL,     ds_report->buttons[1] & DS_BUTTONS1_L1);1370	input_report_key(ds->gamepad, BTN_TR,     ds_report->buttons[1] & DS_BUTTONS1_R1);1371	input_report_key(ds->gamepad, BTN_TL2,    ds_report->buttons[1] & DS_BUTTONS1_L2);1372	input_report_key(ds->gamepad, BTN_TR2,    ds_report->buttons[1] & DS_BUTTONS1_R2);1373	input_report_key(ds->gamepad, BTN_SELECT, ds_report->buttons[1] & DS_BUTTONS1_CREATE);1374	input_report_key(ds->gamepad, BTN_START,  ds_report->buttons[1] & DS_BUTTONS1_OPTIONS);1375	input_report_key(ds->gamepad, BTN_THUMBL, ds_report->buttons[1] & DS_BUTTONS1_L3);1376	input_report_key(ds->gamepad, BTN_THUMBR, ds_report->buttons[1] & DS_BUTTONS1_R3);1377	input_report_key(ds->gamepad, BTN_MODE,   ds_report->buttons[2] & DS_BUTTONS2_PS_HOME);1378	input_sync(ds->gamepad);1379 1380	/*1381	 * The DualSense has an internal microphone, which can be muted through a mute button1382	 * on the device. The driver is expected to read the button state and program the device1383	 * to mute/unmute audio at the hardware level.1384	 */1385	btn_mic_state = !!(ds_report->buttons[2] & DS_BUTTONS2_MIC_MUTE);1386	if (btn_mic_state && !ds->last_btn_mic_state) {1387		spin_lock_irqsave(&ps_dev->lock, flags);1388		ds->update_mic_mute = true;1389		ds->mic_muted = !ds->mic_muted; /* toggle */1390		spin_unlock_irqrestore(&ps_dev->lock, flags);1391 1392		/* Schedule updating of microphone state at hardware level. */1393		dualsense_schedule_work(ds);1394	}1395	ds->last_btn_mic_state = btn_mic_state;1396 1397	/* Parse and calibrate gyroscope data. */1398	for (i = 0; i < ARRAY_SIZE(ds_report->gyro); i++) {1399		int raw_data = (short)le16_to_cpu(ds_report->gyro[i]);1400		int calib_data = mult_frac(ds->gyro_calib_data[i].sens_numer,1401					   raw_data, ds->gyro_calib_data[i].sens_denom);1402 1403		input_report_abs(ds->sensors, ds->gyro_calib_data[i].abs_code, calib_data);1404	}1405 1406	/* Parse and calibrate accelerometer data. */1407	for (i = 0; i < ARRAY_SIZE(ds_report->accel); i++) {1408		int raw_data = (short)le16_to_cpu(ds_report->accel[i]);1409		int calib_data = mult_frac(ds->accel_calib_data[i].sens_numer,1410					   raw_data - ds->accel_calib_data[i].bias,1411					   ds->accel_calib_data[i].sens_denom);1412 1413		input_report_abs(ds->sensors, ds->accel_calib_data[i].abs_code, calib_data);1414	}1415 1416	/* Convert timestamp (in 0.33us unit) to timestamp_us */1417	sensor_timestamp = le32_to_cpu(ds_report->sensor_timestamp);1418	if (!ds->sensor_timestamp_initialized) {1419		ds->sensor_timestamp_us = DIV_ROUND_CLOSEST(sensor_timestamp, 3);1420		ds->sensor_timestamp_initialized = true;1421	} else {1422		uint32_t delta;1423 1424		if (ds->prev_sensor_timestamp > sensor_timestamp)1425			delta = (U32_MAX - ds->prev_sensor_timestamp + sensor_timestamp + 1);1426		else1427			delta = sensor_timestamp - ds->prev_sensor_timestamp;1428		ds->sensor_timestamp_us += DIV_ROUND_CLOSEST(delta, 3);1429	}1430	ds->prev_sensor_timestamp = sensor_timestamp;1431	input_event(ds->sensors, EV_MSC, MSC_TIMESTAMP, ds->sensor_timestamp_us);1432	input_sync(ds->sensors);1433 1434	for (i = 0; i < ARRAY_SIZE(ds_report->points); i++) {1435		struct dualsense_touch_point *point = &ds_report->points[i];1436		bool active = (point->contact & DS_TOUCH_POINT_INACTIVE) ? false : true;1437 1438		input_mt_slot(ds->touchpad, i);1439		input_mt_report_slot_state(ds->touchpad, MT_TOOL_FINGER, active);1440 1441		if (active) {1442			int x = (point->x_hi << 8) | point->x_lo;1443			int y = (point->y_hi << 4) | point->y_lo;1444 1445			input_report_abs(ds->touchpad, ABS_MT_POSITION_X, x);1446			input_report_abs(ds->touchpad, ABS_MT_POSITION_Y, y);1447		}1448	}1449	input_mt_sync_frame(ds->touchpad);1450	input_report_key(ds->touchpad, BTN_LEFT, ds_report->buttons[2] & DS_BUTTONS2_TOUCHPAD);1451	input_sync(ds->touchpad);1452 1453	battery_data = ds_report->status & DS_STATUS_BATTERY_CAPACITY;1454	charging_status = (ds_report->status & DS_STATUS_CHARGING) >> DS_STATUS_CHARGING_SHIFT;1455 1456	switch (charging_status) {1457	case 0x0:1458		/*1459		 * Each unit of battery data corresponds to 10%1460		 * 0 = 0-9%, 1 = 10-19%, .. and 10 = 100%1461		 */1462		battery_capacity = min(battery_data * 10 + 5, 100);1463		battery_status = POWER_SUPPLY_STATUS_DISCHARGING;1464		break;1465	case 0x1:1466		battery_capacity = min(battery_data * 10 + 5, 100);1467		battery_status = POWER_SUPPLY_STATUS_CHARGING;1468		break;1469	case 0x2:1470		battery_capacity = 100;1471		battery_status = POWER_SUPPLY_STATUS_FULL;1472		break;1473	case 0xa: /* voltage or temperature out of range */1474	case 0xb: /* temperature error */1475		battery_capacity = 0;1476		battery_status = POWER_SUPPLY_STATUS_NOT_CHARGING;1477		break;1478	case 0xf: /* charging error */1479	default:1480		battery_capacity = 0;1481		battery_status = POWER_SUPPLY_STATUS_UNKNOWN;1482	}1483 1484	spin_lock_irqsave(&ps_dev->lock, flags);1485	ps_dev->battery_capacity = battery_capacity;1486	ps_dev->battery_status = battery_status;1487	spin_unlock_irqrestore(&ps_dev->lock, flags);1488 1489	return 0;1490}1491 1492static int dualsense_play_effect(struct input_dev *dev, void *data, struct ff_effect *effect)1493{1494	struct hid_device *hdev = input_get_drvdata(dev);1495	struct dualsense *ds = hid_get_drvdata(hdev);1496	unsigned long flags;1497 1498	if (effect->type != FF_RUMBLE)1499		return 0;1500 1501	spin_lock_irqsave(&ds->base.lock, flags);1502	ds->update_rumble = true;1503	ds->motor_left = effect->u.rumble.strong_magnitude / 256;1504	ds->motor_right = effect->u.rumble.weak_magnitude / 256;1505	spin_unlock_irqrestore(&ds->base.lock, flags);1506 1507	dualsense_schedule_work(ds);1508	return 0;1509}1510 1511static void dualsense_remove(struct ps_device *ps_dev)1512{1513	struct dualsense *ds = container_of(ps_dev, struct dualsense, base);1514	unsigned long flags;1515 1516	spin_lock_irqsave(&ds->base.lock, flags);1517	ds->output_worker_initialized = false;1518	spin_unlock_irqrestore(&ds->base.lock, flags);1519 1520	cancel_work_sync(&ds->output_worker);1521}1522 1523static int dualsense_reset_leds(struct dualsense *ds)1524{1525	struct dualsense_output_report report;1526	uint8_t *buf;1527 1528	buf = kzalloc(sizeof(struct dualsense_output_report_bt), GFP_KERNEL);1529	if (!buf)1530		return -ENOMEM;1531 1532	dualsense_init_output_report(ds, &report, buf);1533	/*1534	 * On Bluetooth the DualSense outputs an animation on the lightbar1535	 * during startup and maintains a color afterwards. We need to explicitly1536	 * reconfigure the lightbar before we can do any programming later on.1537	 * In USB the lightbar is not on by default, but redoing the setup there1538	 * doesn't hurt.1539	 */1540	report.common->valid_flag2 = DS_OUTPUT_VALID_FLAG2_LIGHTBAR_SETUP_CONTROL_ENABLE;1541	report.common->lightbar_setup = DS_OUTPUT_LIGHTBAR_SETUP_LIGHT_OUT; /* Fade light out. */1542	dualsense_send_output_report(ds, &report);1543 1544	kfree(buf);1545	return 0;1546}1547 1548static void dualsense_set_lightbar(struct dualsense *ds, uint8_t red, uint8_t green, uint8_t blue)1549{1550	unsigned long flags;1551 1552	spin_lock_irqsave(&ds->base.lock, flags);1553	ds->update_lightbar = true;1554	ds->lightbar_red = red;1555	ds->lightbar_green = green;1556	ds->lightbar_blue = blue;1557	spin_unlock_irqrestore(&ds->base.lock, flags);1558 1559	dualsense_schedule_work(ds);1560}1561 1562static void dualsense_set_player_leds(struct dualsense *ds)1563{1564	/*1565	 * The DualSense controller has a row of 5 LEDs used for player ids.1566	 * Behavior on the PlayStation 5 console is to center the player id1567	 * across the LEDs, so e.g. player 1 would be "--x--" with x being 'on'.1568	 * Follow a similar mapping here.1569	 */1570	static const int player_ids[5] = {1571		BIT(2),1572		BIT(3) | BIT(1),1573		BIT(4) | BIT(2) | BIT(0),1574		BIT(4) | BIT(3) | BIT(1) | BIT(0),1575		BIT(4) | BIT(3) | BIT(2) | BIT(1) | BIT(0)1576	};1577 1578	uint8_t player_id = ds->base.player_id % ARRAY_SIZE(player_ids);1579 1580	ds->update_player_leds = true;1581	ds->player_leds_state = player_ids[player_id];1582	dualsense_schedule_work(ds);1583}1584 1585static struct ps_device *dualsense_create(struct hid_device *hdev)1586{1587	struct dualsense *ds;1588	struct ps_device *ps_dev;1589	uint8_t max_output_report_size;1590	int i, ret;1591 1592	static const struct ps_led_info player_leds_info[] = {1593		{ LED_FUNCTION_PLAYER1, "white", 1, dualsense_player_led_get_brightness,1594				dualsense_player_led_set_brightness },1595		{ LED_FUNCTION_PLAYER2, "white", 1, dualsense_player_led_get_brightness,1596				dualsense_player_led_set_brightness },1597		{ LED_FUNCTION_PLAYER3, "white", 1, dualsense_player_led_get_brightness,1598				dualsense_player_led_set_brightness },1599		{ LED_FUNCTION_PLAYER4, "white", 1, dualsense_player_led_get_brightness,1600				dualsense_player_led_set_brightness },1601		{ LED_FUNCTION_PLAYER5, "white", 1, dualsense_player_led_get_brightness,1602				dualsense_player_led_set_brightness }1603	};1604 1605	ds = devm_kzalloc(&hdev->dev, sizeof(*ds), GFP_KERNEL);1606	if (!ds)1607		return ERR_PTR(-ENOMEM);1608 1609	/*1610	 * Patch version to allow userspace to distinguish between1611	 * hid-generic vs hid-playstation axis and button mapping.1612	 */1613	hdev->version |= HID_PLAYSTATION_VERSION_PATCH;1614 1615	ps_dev = &ds->base;1616	ps_dev->hdev = hdev;1617	spin_lock_init(&ps_dev->lock);1618	ps_dev->battery_capacity = 100; /* initial value until parse_report. */1619	ps_dev->battery_status = POWER_SUPPLY_STATUS_UNKNOWN;1620	ps_dev->parse_report = dualsense_parse_report;1621	ps_dev->remove = dualsense_remove;1622	INIT_WORK(&ds->output_worker, dualsense_output_worker);1623	ds->output_worker_initialized = true;1624	hid_set_drvdata(hdev, ds);1625 1626	max_output_report_size = sizeof(struct dualsense_output_report_bt);1627	ds->output_report_dmabuf = devm_kzalloc(&hdev->dev, max_output_report_size, GFP_KERNEL);1628	if (!ds->output_report_dmabuf)1629		return ERR_PTR(-ENOMEM);1630 1631	ret = dualsense_get_mac_address(ds);1632	if (ret) {1633		hid_err(hdev, "Failed to get MAC address from DualSense\n");1634		return ERR_PTR(ret);1635	}1636	snprintf(hdev->uniq, sizeof(hdev->uniq), "%pMR", ds->base.mac_address);1637 1638	ret = dualsense_get_firmware_info(ds);1639	if (ret) {1640		hid_err(hdev, "Failed to get firmware info from DualSense\n");1641		return ERR_PTR(ret);1642	}1643 1644	/* Original DualSense firmware simulated classic controller rumble through1645	 * its new haptics hardware. It felt different from classic rumble users1646	 * were used to. Since then new firmwares were introduced to change behavior1647	 * and make this new 'v2' behavior default on PlayStation and other platforms.1648	 * The original DualSense requires a new enough firmware as bundled with PS51649	 * software released in 2021. DualSense edge supports it out of the box.1650	 * Both devices also support the old mode, but it is not really used.1651	 */1652	if (hdev->product == USB_DEVICE_ID_SONY_PS5_CONTROLLER) {1653		/* Feature version 2.21 introduced new vibration method. */1654		ds->use_vibration_v2 = ds->update_version >= DS_FEATURE_VERSION(2, 21);1655	} else if (hdev->product == USB_DEVICE_ID_SONY_PS5_CONTROLLER_2) {1656		ds->use_vibration_v2 = true;1657	}1658 1659	ret = ps_devices_list_add(ps_dev);1660	if (ret)1661		return ERR_PTR(ret);1662 1663	ret = dualsense_get_calibration_data(ds);1664	if (ret) {1665		hid_err(hdev, "Failed to get calibration data from DualSense\n");1666		goto err;1667	}1668 1669	ds->gamepad = ps_gamepad_create(hdev, dualsense_play_effect);1670	if (IS_ERR(ds->gamepad)) {1671		ret = PTR_ERR(ds->gamepad);1672		goto err;1673	}1674	/* Use gamepad input device name as primary device name for e.g. LEDs */1675	ps_dev->input_dev_name = dev_name(&ds->gamepad->dev);1676 1677	ds->sensors = ps_sensors_create(hdev, DS_ACC_RANGE, DS_ACC_RES_PER_G,1678			DS_GYRO_RANGE, DS_GYRO_RES_PER_DEG_S);1679	if (IS_ERR(ds->sensors)) {1680		ret = PTR_ERR(ds->sensors);1681		goto err;1682	}1683 1684	ds->touchpad = ps_touchpad_create(hdev, DS_TOUCHPAD_WIDTH, DS_TOUCHPAD_HEIGHT, 2);1685	if (IS_ERR(ds->touchpad)) {1686		ret = PTR_ERR(ds->touchpad);1687		goto err;1688	}1689 1690	ret = ps_device_register_battery(ps_dev);1691	if (ret)1692		goto err;1693 1694	/*1695	 * The hardware may have control over the LEDs (e.g. in Bluetooth on startup).1696	 * Reset the LEDs (lightbar, mute, player leds), so we can control them1697	 * from software.1698	 */1699	ret = dualsense_reset_leds(ds);1700	if (ret)1701		goto err;1702 1703	ret = ps_lightbar_register(ps_dev, &ds->lightbar, dualsense_lightbar_set_brightness);1704	if (ret)1705		goto err;1706 1707	/* Set default lightbar color. */1708	dualsense_set_lightbar(ds, 0, 0, 128); /* blue */1709 1710	for (i = 0; i < ARRAY_SIZE(player_leds_info); i++) {1711		const struct ps_led_info *led_info = &player_leds_info[i];1712 1713		ret = ps_led_register(ps_dev, &ds->player_leds[i], led_info);1714		if (ret < 0)1715			goto err;1716	}1717 1718	ret = ps_device_set_player_id(ps_dev);1719	if (ret) {1720		hid_err(hdev, "Failed to assign player id for DualSense: %d\n", ret);1721		goto err;1722	}1723 1724	/* Set player LEDs to our player id. */1725	dualsense_set_player_leds(ds);1726 1727	/*1728	 * Reporting hardware and firmware is important as there are frequent updates, which1729	 * can change behavior.1730	 */1731	hid_info(hdev, "Registered DualSense controller hw_version=0x%08x fw_version=0x%08x\n",1732			ds->base.hw_version, ds->base.fw_version);1733 1734	return &ds->base;1735 1736err:1737	ps_devices_list_remove(ps_dev);1738	return ERR_PTR(ret);1739}1740 1741static void dualshock4_dongle_calibration_work(struct work_struct *work)1742{1743	struct dualshock4 *ds4 = container_of(work, struct dualshock4, dongle_hotplug_worker);1744	unsigned long flags;1745	enum dualshock4_dongle_state dongle_state;1746	int ret;1747 1748	ret = dualshock4_get_calibration_data(ds4);1749	if (ret < 0) {1750		/* This call is very unlikely to fail for the dongle. When it1751		 * fails we are probably in a very bad state, so mark the1752		 * dongle as disabled. We will re-enable the dongle if a new1753		 * DS4 hotplug is detect from sony_raw_event as any issues1754		 * are likely resolved then (the dongle is quite stupid).1755		 */1756		hid_err(ds4->base.hdev, "DualShock 4 USB dongle: calibration failed, disabling device\n");1757		dongle_state = DONGLE_DISABLED;1758	} else {1759		hid_info(ds4->base.hdev, "DualShock 4 USB dongle: calibration completed\n");1760		dongle_state = DONGLE_CONNECTED;1761	}1762 1763	spin_lock_irqsave(&ds4->base.lock, flags);1764	ds4->dongle_state = dongle_state;1765	spin_unlock_irqrestore(&ds4->base.lock, flags);1766}1767 1768static int dualshock4_get_calibration_data(struct dualshock4 *ds4)1769{1770	struct hid_device *hdev = ds4->base.hdev;1771	short gyro_pitch_bias, gyro_pitch_plus, gyro_pitch_minus;1772	short gyro_yaw_bias, gyro_yaw_plus, gyro_yaw_minus;1773	short gyro_roll_bias, gyro_roll_plus, gyro_roll_minus;1774	short gyro_speed_plus, gyro_speed_minus;1775	short acc_x_plus, acc_x_minus;1776	short acc_y_plus, acc_y_minus;1777	short acc_z_plus, acc_z_minus;1778	int speed_2x;1779	int range_2g;1780	int ret = 0;1781	int i;1782	uint8_t *buf;1783 1784	if (ds4->base.hdev->bus == BUS_USB) {1785		int retries;1786 1787		buf = kzalloc(DS4_FEATURE_REPORT_CALIBRATION_SIZE, GFP_KERNEL);1788		if (!buf) {1789			ret = -ENOMEM;1790			goto transfer_failed;1791		}1792 1793		/* We should normally receive the feature report data we asked1794		 * for, but hidraw applications such as Steam can issue feature1795		 * reports as well. In particular for Dongle reconnects, Steam1796		 * and this function are competing resulting in often receiving1797		 * data for a different HID report, so retry a few times.1798		 */1799		for (retries = 0; retries < 3; retries++) {1800			ret = ps_get_report(hdev, DS4_FEATURE_REPORT_CALIBRATION, buf,1801					DS4_FEATURE_REPORT_CALIBRATION_SIZE, true);1802			if (ret) {1803				if (retries < 2) {1804					hid_warn(hdev, "Retrying DualShock 4 get calibration report (0x02) request\n");1805					continue;1806				}1807 1808				hid_warn(hdev, "Failed to retrieve DualShock4 calibration info: %d\n", ret);1809				ret = -EILSEQ;1810				goto transfer_failed;1811			} else {1812				break;1813			}1814		}1815	} else { /* Bluetooth */1816		buf = kzalloc(DS4_FEATURE_REPORT_CALIBRATION_BT_SIZE, GFP_KERNEL);1817		if (!buf) {1818			ret = -ENOMEM;1819			goto transfer_failed;1820		}1821 1822		ret = ps_get_report(hdev, DS4_FEATURE_REPORT_CALIBRATION_BT, buf,1823				DS4_FEATURE_REPORT_CALIBRATION_BT_SIZE, true);1824 1825		if (ret) {1826			hid_warn(hdev, "Failed to retrieve DualShock4 calibration info: %d\n", ret);1827			goto transfer_failed;1828		}1829	}1830 1831	/* Transfer succeeded - parse the calibration data received. */1832	gyro_pitch_bias  = get_unaligned_le16(&buf[1]);1833	gyro_yaw_bias    = get_unaligned_le16(&buf[3]);1834	gyro_roll_bias   = get_unaligned_le16(&buf[5]);1835	if (ds4->base.hdev->bus == BUS_USB) {1836		gyro_pitch_plus  = get_unaligned_le16(&buf[7]);1837		gyro_pitch_minus = get_unaligned_le16(&buf[9]);1838		gyro_yaw_plus    = get_unaligned_le16(&buf[11]);1839		gyro_yaw_minus   = get_unaligned_le16(&buf[13]);1840		gyro_roll_plus   = get_unaligned_le16(&buf[15]);1841		gyro_roll_minus  = get_unaligned_le16(&buf[17]);1842	} else {1843		/* BT + Dongle */1844		gyro_pitch_plus  = get_unaligned_le16(&buf[7]);1845		gyro_yaw_plus    = get_unaligned_le16(&buf[9]);1846		gyro_roll_plus   = get_unaligned_le16(&buf[11]);1847		gyro_pitch_minus = get_unaligned_le16(&buf[13]);1848		gyro_yaw_minus   = get_unaligned_le16(&buf[15]);1849		gyro_roll_minus  = get_unaligned_le16(&buf[17]);1850	}1851	gyro_speed_plus  = get_unaligned_le16(&buf[19]);1852	gyro_speed_minus = get_unaligned_le16(&buf[21]);1853	acc_x_plus       = get_unaligned_le16(&buf[23]);1854	acc_x_minus      = get_unaligned_le16(&buf[25]);1855	acc_y_plus       = get_unaligned_le16(&buf[27]);1856	acc_y_minus      = get_unaligned_le16(&buf[29]);1857	acc_z_plus       = get_unaligned_le16(&buf[31]);1858	acc_z_minus      = get_unaligned_le16(&buf[33]);1859 1860	/* Done parsing the buffer, so let's free it. */1861	kfree(buf);1862 1863	/*1864	 * Set gyroscope calibration and normalization parameters.1865	 * Data values will be normalized to 1/DS4_GYRO_RES_PER_DEG_S degree/s.1866	 */1867	speed_2x = (gyro_speed_plus + gyro_speed_minus);1868	ds4->gyro_calib_data[0].abs_code = ABS_RX;1869	ds4->gyro_calib_data[0].bias = 0;1870	ds4->gyro_calib_data[0].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;1871	ds4->gyro_calib_data[0].sens_denom = abs(gyro_pitch_plus - gyro_pitch_bias) +1872			abs(gyro_pitch_minus - gyro_pitch_bias);1873 1874	ds4->gyro_calib_data[1].abs_code = ABS_RY;1875	ds4->gyro_calib_data[1].bias = 0;1876	ds4->gyro_calib_data[1].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;1877	ds4->gyro_calib_data[1].sens_denom = abs(gyro_yaw_plus - gyro_yaw_bias) +1878			abs(gyro_yaw_minus - gyro_yaw_bias);1879 1880	ds4->gyro_calib_data[2].abs_code = ABS_RZ;1881	ds4->gyro_calib_data[2].bias = 0;1882	ds4->gyro_calib_data[2].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;1883	ds4->gyro_calib_data[2].sens_denom = abs(gyro_roll_plus - gyro_roll_bias) +1884			abs(gyro_roll_minus - gyro_roll_bias);1885 1886	/*1887	 * Set accelerometer calibration and normalization parameters.1888	 * Data values will be normalized to 1/DS4_ACC_RES_PER_G g.1889	 */1890	range_2g = acc_x_plus - acc_x_minus;1891	ds4->accel_calib_data[0].abs_code = ABS_X;1892	ds4->accel_calib_data[0].bias = acc_x_plus - range_2g / 2;1893	ds4->accel_calib_data[0].sens_numer = 2*DS4_ACC_RES_PER_G;1894	ds4->accel_calib_data[0].sens_denom = range_2g;1895 1896	range_2g = acc_y_plus - acc_y_minus;1897	ds4->accel_calib_data[1].abs_code = ABS_Y;1898	ds4->accel_calib_data[1].bias = acc_y_plus - range_2g / 2;1899	ds4->accel_calib_data[1].sens_numer = 2*DS4_ACC_RES_PER_G;1900	ds4->accel_calib_data[1].sens_denom = range_2g;1901 1902	range_2g = acc_z_plus - acc_z_minus;1903	ds4->accel_calib_data[2].abs_code = ABS_Z;1904	ds4->accel_calib_data[2].bias = acc_z_plus - range_2g / 2;1905	ds4->accel_calib_data[2].sens_numer = 2*DS4_ACC_RES_PER_G;1906	ds4->accel_calib_data[2].sens_denom = range_2g;1907 1908transfer_failed:1909	/*1910	 * Sanity check gyro calibration data. This is needed to prevent crashes1911	 * during report handling of virtual, clone or broken devices not implementing1912	 * calibration data properly.1913	 */1914	for (i = 0; i < ARRAY_SIZE(ds4->gyro_calib_data); i++) {1915		if (ds4->gyro_calib_data[i].sens_denom == 0) {1916			ds4->gyro_calib_data[i].abs_code = ABS_RX + i;1917			hid_warn(hdev, "Invalid gyro calibration data for axis (%d), disabling calibration.",1918					ds4->gyro_calib_data[i].abs_code);1919			ds4->gyro_calib_data[i].bias = 0;1920			ds4->gyro_calib_data[i].sens_numer = DS4_GYRO_RANGE;1921			ds4->gyro_calib_data[i].sens_denom = S16_MAX;1922		}1923	}1924 1925	/*1926	 * Sanity check accelerometer calibration data. This is needed to prevent crashes1927	 * during report handling of virtual, clone or broken devices not implementing calibration1928	 * data properly.1929	 */1930	for (i = 0; i < ARRAY_SIZE(ds4->accel_calib_data); i++) {1931		if (ds4->accel_calib_data[i].sens_denom == 0) {1932			ds4->accel_calib_data[i].abs_code = ABS_X + i;1933			hid_warn(hdev, "Invalid accelerometer calibration data for axis (%d), disabling calibration.",1934					ds4->accel_calib_data[i].abs_code);1935			ds4->accel_calib_data[i].bias = 0;1936			ds4->accel_calib_data[i].sens_numer = DS4_ACC_RANGE;1937			ds4->accel_calib_data[i].sens_denom = S16_MAX;1938		}1939	}1940 1941	return ret;1942}1943 1944static int dualshock4_get_firmware_info(struct dualshock4 *ds4)1945{1946	uint8_t *buf;1947	int ret;1948 1949	buf = kzalloc(DS4_FEATURE_REPORT_FIRMWARE_INFO_SIZE, GFP_KERNEL);1950	if (!buf)1951		return -ENOMEM;1952 1953	/* Note USB and BT support the same feature report, but this report1954	 * lacks CRC support, so must be disabled in ps_get_report.1955	 */1956	ret = ps_get_report(ds4->base.hdev, DS4_FEATURE_REPORT_FIRMWARE_INFO, buf,1957			DS4_FEATURE_REPORT_FIRMWARE_INFO_SIZE, false);1958	if (ret) {1959		hid_err(ds4->base.hdev, "Failed to retrieve DualShock4 firmware info: %d\n", ret);1960		goto err_free;1961	}1962 1963	ds4->base.hw_version = get_unaligned_le16(&buf[35]);1964	ds4->base.fw_version = get_unaligned_le16(&buf[41]);1965 1966err_free:1967	kfree(buf);1968	return ret;1969}1970 1971static int dualshock4_get_mac_address(struct dualshock4 *ds4)1972{1973	struct hid_device *hdev = ds4->base.hdev;1974	uint8_t *buf;1975	int ret = 0;1976 1977	if (hdev->bus == BUS_USB) {1978		buf = kzalloc(DS4_FEATURE_REPORT_PAIRING_INFO_SIZE, GFP_KERNEL);1979		if (!buf)1980			return -ENOMEM;1981 1982		ret = ps_get_report(hdev, DS4_FEATURE_REPORT_PAIRING_INFO, buf,1983				DS4_FEATURE_REPORT_PAIRING_INFO_SIZE, false);1984		if (ret) {1985			hid_err(hdev, "Failed to retrieve DualShock4 pairing info: %d\n", ret);1986			goto err_free;1987		}1988 1989		memcpy(ds4->base.mac_address, &buf[1], sizeof(ds4->base.mac_address));1990	} else {1991		/* Rely on HIDP for Bluetooth */1992		if (strlen(hdev->uniq) != 17)1993			return -EINVAL;1994 1995		ret = sscanf(hdev->uniq, "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",1996				&ds4->base.mac_address[5], &ds4->base.mac_address[4],1997				&ds4->base.mac_address[3], &ds4->base.mac_address[2],1998				&ds4->base.mac_address[1], &ds4->base.mac_address[0]);1999 2000		if (ret != sizeof(ds4->base.mac_address))2001			return -EINVAL;2002 2003		return 0;2004	}2005 2006err_free:2007	kfree(buf);2008	return ret;2009}2010 2011static enum led_brightness dualshock4_led_get_brightness(struct led_classdev *led)2012{2013	struct hid_device *hdev = to_hid_device(led->dev->parent);2014	struct dualshock4 *ds4 = hid_get_drvdata(hdev);2015	unsigned int led_index;2016 2017	led_index = led - ds4->lightbar_leds;2018	switch (led_index) {2019	case 0:2020		return ds4->lightbar_red;2021	case 1:2022		return ds4->lightbar_green;2023	case 2:2024		return ds4->lightbar_blue;2025	case 3:2026		return ds4->lightbar_enabled;2027	}2028 2029	return -1;2030}2031 2032static int dualshock4_led_set_blink(struct led_classdev *led, unsigned long *delay_on,2033		unsigned long *delay_off)2034{2035	struct hid_device *hdev = to_hid_device(led->dev->parent);2036	struct dualshock4 *ds4 = hid_get_drvdata(hdev);2037	unsigned long flags;2038 2039	spin_lock_irqsave(&ds4->base.lock, flags);2040 2041	if (!*delay_on && !*delay_off) {2042		/* Default to 1 Hz (50 centiseconds on, 50 centiseconds off). */2043		ds4->lightbar_blink_on = 50;2044		ds4->lightbar_blink_off = 50;2045	} else {2046		/* Blink delays in centiseconds. */2047		ds4->lightbar_blink_on = min_t(unsigned long, *delay_on/10, DS4_LIGHTBAR_MAX_BLINK);2048		ds4->lightbar_blink_off = min_t(unsigned long, *delay_off/10, DS4_LIGHTBAR_MAX_BLINK);2049	}2050 2051	ds4->update_lightbar_blink = true;2052 2053	spin_unlock_irqrestore(&ds4->base.lock, flags);2054 2055	dualshock4_schedule_work(ds4);2056 2057	/* Report scaled values back to LED subsystem */2058	*delay_on = ds4->lightbar_blink_on * 10;2059	*delay_off = ds4->lightbar_blink_off * 10;2060 2061	return 0;2062}2063 2064static int dualshock4_led_set_brightness(struct led_classdev *led, enum led_brightness value)2065{2066	struct hid_device *hdev = to_hid_device(led->dev->parent);2067	struct dualshock4 *ds4 = hid_get_drvdata(hdev);2068	unsigned long flags;2069	unsigned int led_index;2070 2071	spin_lock_irqsave(&ds4->base.lock, flags);2072 2073	led_index = led - ds4->lightbar_leds;2074	switch (led_index) {2075	case 0:2076		ds4->lightbar_red = value;2077		break;2078	case 1:2079		ds4->lightbar_green = value;2080		break;2081	case 2:2082		ds4->lightbar_blue = value;2083		break;2084	case 3:2085		ds4->lightbar_enabled = !!value;2086 2087		/* brightness = 0 also cancels blinking in Linux. */2088		if (!ds4->lightbar_enabled) {2089			ds4->lightbar_blink_off = 0;2090			ds4->lightbar_blink_on = 0;2091			ds4->update_lightbar_blink = true;2092		}2093	}2094 2095	ds4->update_lightbar = true;2096 2097	spin_unlock_irqrestore(&ds4->base.lock, flags);2098 2099	dualshock4_schedule_work(ds4);2100 2101	return 0;2102}2103 2104static void dualshock4_init_output_report(struct dualshock4 *ds4,2105		struct dualshock4_output_report *rp, void *buf)2106{2107	struct hid_device *hdev = ds4->base.hdev;2108 2109	if (hdev->bus == BUS_BLUETOOTH) {2110		struct dualshock4_output_report_bt *bt = buf;2111 2112		memset(bt, 0, sizeof(*bt));2113		bt->report_id = DS4_OUTPUT_REPORT_BT;2114 2115		rp->data = buf;2116		rp->len = sizeof(*bt);2117		rp->bt = bt;2118		rp->usb = NULL;2119		rp->common = &bt->common;2120	} else { /* USB */2121		struct dualshock4_output_report_usb *usb = buf;2122 2123		memset(usb, 0, sizeof(*usb));2124		usb->report_id = DS4_OUTPUT_REPORT_USB;2125 2126		rp->data = buf;2127		rp->len = sizeof(*usb);2128		rp->bt = NULL;2129		rp->usb = usb;2130		rp->common = &usb->common;2131	}2132}2133 2134static void dualshock4_output_worker(struct work_struct *work)2135{2136	struct dualshock4 *ds4 = container_of(work, struct dualshock4, output_worker);2137	struct dualshock4_output_report report;2138	struct dualshock4_output_report_common *common;2139	unsigned long flags;2140 2141	dualshock4_init_output_report(ds4, &report, ds4->output_report_dmabuf);2142	common = report.common;2143 2144	spin_lock_irqsave(&ds4->base.lock, flags);2145 2146	/*2147	 * Some 3rd party gamepads expect updates to rumble and lightbar2148	 * together, and setting one may cancel the other.2149	 *2150	 * Let's maximise compatibility by always sending rumble and lightbar2151	 * updates together, even when only one has been scheduled, resulting2152	 * in:2153	 *2154	 *   ds4->valid_flag0 >= 0x032155	 *2156	 * Hopefully this will maximise compatibility with third-party pads.2157	 *2158	 * Any further update bits, such as 0x04 for lightbar blinking, will2159	 * be or'd on top of this like before.2160	 */2161	if (ds4->update_rumble || ds4->update_lightbar) {2162		ds4->update_rumble = true; /* 0x01 */2163		ds4->update_lightbar = true; /* 0x02 */2164	}2165 2166	if (ds4->update_rumble) {2167		/* Select classic rumble style haptics and enable it. */2168		common->valid_flag0 |= DS4_OUTPUT_VALID_FLAG0_MOTOR;2169		common->motor_left = ds4->motor_left;2170		common->motor_right = ds4->motor_right;2171		ds4->update_rumble = false;2172	}2173 2174	if (ds4->update_lightbar) {2175		common->valid_flag0 |= DS4_OUTPUT_VALID_FLAG0_LED;2176		/* Comptabile behavior with hid-sony, which used a dummy global LED to2177		 * allow enabling/disabling the lightbar. The global LED maps to2178		 * lightbar_enabled.2179		 */2180		common->lightbar_red = ds4->lightbar_enabled ? ds4->lightbar_red : 0;2181		common->lightbar_green = ds4->lightbar_enabled ? ds4->lightbar_green : 0;2182		common->lightbar_blue = ds4->lightbar_enabled ? ds4->lightbar_blue : 0;2183		ds4->update_lightbar = false;2184	}2185 2186	if (ds4->update_lightbar_blink) {2187		common->valid_flag0 |= DS4_OUTPUT_VALID_FLAG0_LED_BLINK;2188		common->lightbar_blink_on = ds4->lightbar_blink_on;2189		common->lightbar_blink_off = ds4->lightbar_blink_off;2190		ds4->update_lightbar_blink = false;2191	}2192 2193	spin_unlock_irqrestore(&ds4->base.lock, flags);2194 2195	/* Bluetooth packets need additional flags as well as a CRC in the last 4 bytes. */2196	if (report.bt) {2197		uint32_t crc;2198		uint8_t seed = PS_OUTPUT_CRC32_SEED;2199 2200		/* Hardware control flags need to set to let the device know2201		 * there is HID data as well as CRC.2202		 */2203		report.bt->hw_control = DS4_OUTPUT_HWCTL_HID | DS4_OUTPUT_HWCTL_CRC32;2204 2205		if (ds4->update_bt_poll_interval) {2206			report.bt->hw_control |= ds4->bt_poll_interval;2207			ds4->update_bt_poll_interval = false;2208		}2209 2210		crc = crc32_le(0xFFFFFFFF, &seed, 1);2211		crc = ~crc32_le(crc, report.data, report.len - 4);2212 2213		report.bt->crc32 = cpu_to_le32(crc);2214	}2215 2216	hid_hw_output_report(ds4->base.hdev, report.data, report.len);2217}2218 2219static int dualshock4_parse_report(struct ps_device *ps_dev, struct hid_report *report,2220		u8 *data, int size)2221{2222	struct hid_device *hdev = ps_dev->hdev;2223	struct dualshock4 *ds4 = container_of(ps_dev, struct dualshock4, base);2224	struct dualshock4_input_report_common *ds4_report;2225	struct dualshock4_touch_report *touch_reports;2226	uint8_t battery_capacity, num_touch_reports, value;2227	int battery_status, i, j;2228	uint16_t sensor_timestamp;2229	unsigned long flags;2230	bool is_minimal = false;2231 2232	/*2233	 * DualShock4 in USB uses the full HID report for reportID 1, but2234	 * Bluetooth uses a minimal HID report for reportID 1 and reports2235	 * the full report using reportID 17.2236	 */2237	if (hdev->bus == BUS_USB && report->id == DS4_INPUT_REPORT_USB &&2238			size == DS4_INPUT_REPORT_USB_SIZE) {2239		struct dualshock4_input_report_usb *usb = (struct dualshock4_input_report_usb *)data;2240 2241		ds4_report = &usb->common;2242		num_touch_reports = usb->num_touch_reports;2243		touch_reports = usb->touch_reports;2244	} else if (hdev->bus == BUS_BLUETOOTH && report->id == DS4_INPUT_REPORT_BT &&2245			size == DS4_INPUT_REPORT_BT_SIZE) {2246		struct dualshock4_input_report_bt *bt = (struct dualshock4_input_report_bt *)data;2247		uint32_t report_crc = get_unaligned_le32(&bt->crc32);2248 2249		/* Last 4 bytes of input report contains CRC. */2250		if (!ps_check_crc32(PS_INPUT_CRC32_SEED, data, size - 4, report_crc)) {2251			hid_err(hdev, "DualShock4 input CRC's check failed\n");2252			return -EILSEQ;2253		}2254 2255		ds4_report = &bt->common;2256		num_touch_reports = bt->num_touch_reports;2257		touch_reports = bt->touch_reports;2258	} else if (hdev->bus == BUS_BLUETOOTH &&2259		   report->id == DS4_INPUT_REPORT_BT_MINIMAL &&2260			 size == DS4_INPUT_REPORT_BT_MINIMAL_SIZE) {2261		/* Some third-party pads never switch to the full 0x11 report.2262		 * The short 0x01 report is 10 bytes long:2263		 *   u8 report_id == 0x012264		 *   u8 first_bytes_of_full_report[9]2265		 * So let's reuse the full report parser, and stop it after2266		 * parsing the buttons.2267		 */2268		ds4_report = (struct dualshock4_input_report_common *)&data[1];2269		is_minimal = true;2270	} else {2271		hid_err(hdev, "Unhandled reportID=%d\n", report->id);2272		return -1;2273	}2274 2275	input_report_abs(ds4->gamepad, ABS_X,  ds4_report->x);2276	input_report_abs(ds4->gamepad, ABS_Y,  ds4_report->y);2277	input_report_abs(ds4->gamepad, ABS_RX, ds4_report->rx);2278	input_report_abs(ds4->gamepad, ABS_RY, ds4_report->ry);2279	input_report_abs(ds4->gamepad, ABS_Z,  ds4_report->z);2280	input_report_abs(ds4->gamepad, ABS_RZ, ds4_report->rz);2281 2282	value = ds4_report->buttons[0] & DS_BUTTONS0_HAT_SWITCH;2283	if (value >= ARRAY_SIZE(ps_gamepad_hat_mapping))2284		value = 8; /* center */2285	input_report_abs(ds4->gamepad, ABS_HAT0X, ps_gamepad_hat_mapping[value].x);2286	input_report_abs(ds4->gamepad, ABS_HAT0Y, ps_gamepad_hat_mapping[value].y);2287 2288	input_report_key(ds4->gamepad, BTN_WEST,   ds4_report->buttons[0] & DS_BUTTONS0_SQUARE);2289	input_report_key(ds4->gamepad, BTN_SOUTH,  ds4_report->buttons[0] & DS_BUTTONS0_CROSS);2290	input_report_key(ds4->gamepad, BTN_EAST,   ds4_report->buttons[0] & DS_BUTTONS0_CIRCLE);2291	input_report_key(ds4->gamepad, BTN_NORTH,  ds4_report->buttons[0] & DS_BUTTONS0_TRIANGLE);2292	input_report_key(ds4->gamepad, BTN_TL,     ds4_report->buttons[1] & DS_BUTTONS1_L1);2293	input_report_key(ds4->gamepad, BTN_TR,     ds4_report->buttons[1] & DS_BUTTONS1_R1);2294	input_report_key(ds4->gamepad, BTN_TL2,    ds4_report->buttons[1] & DS_BUTTONS1_L2);2295	input_report_key(ds4->gamepad, BTN_TR2,    ds4_report->buttons[1] & DS_BUTTONS1_R2);2296	input_report_key(ds4->gamepad, BTN_SELECT, ds4_report->buttons[1] & DS_BUTTONS1_CREATE);2297	input_report_key(ds4->gamepad, BTN_START,  ds4_report->buttons[1] & DS_BUTTONS1_OPTIONS);2298	input_report_key(ds4->gamepad, BTN_THUMBL, ds4_report->buttons[1] & DS_BUTTONS1_L3);2299	input_report_key(ds4->gamepad, BTN_THUMBR, ds4_report->buttons[1] & DS_BUTTONS1_R3);2300	input_report_key(ds4->gamepad, BTN_MODE,   ds4_report->buttons[2] & DS_BUTTONS2_PS_HOME);2301	input_sync(ds4->gamepad);2302 2303	if (is_minimal)2304		return 0;2305 2306	/* Parse and calibrate gyroscope data. */2307	for (i = 0; i < ARRAY_SIZE(ds4_report->gyro); i++) {2308		int raw_data = (short)le16_to_cpu(ds4_report->gyro[i]);2309		int calib_data = mult_frac(ds4->gyro_calib_data[i].sens_numer,2310					   raw_data, ds4->gyro_calib_data[i].sens_denom);2311 2312		input_report_abs(ds4->sensors, ds4->gyro_calib_data[i].abs_code, calib_data);2313	}2314 2315	/* Parse and calibrate accelerometer data. */2316	for (i = 0; i < ARRAY_SIZE(ds4_report->accel); i++) {2317		int raw_data = (short)le16_to_cpu(ds4_report->accel[i]);2318		int calib_data = mult_frac(ds4->accel_calib_data[i].sens_numer,2319					   raw_data - ds4->accel_calib_data[i].bias,2320					   ds4->accel_calib_data[i].sens_denom);2321 2322		input_report_abs(ds4->sensors, ds4->accel_calib_data[i].abs_code, calib_data);2323	}2324 2325	/* Convert timestamp (in 5.33us unit) to timestamp_us */2326	sensor_timestamp = le16_to_cpu(ds4_report->sensor_timestamp);2327	if (!ds4->sensor_timestamp_initialized) {2328		ds4->sensor_timestamp_us = DIV_ROUND_CLOSEST(sensor_timestamp*16, 3);2329		ds4->sensor_timestamp_initialized = true;2330	} else {2331		uint16_t delta;2332 2333		if (ds4->prev_sensor_timestamp > sensor_timestamp)2334			delta = (U16_MAX - ds4->prev_sensor_timestamp + sensor_timestamp + 1);2335		else2336			delta = sensor_timestamp - ds4->prev_sensor_timestamp;2337		ds4->sensor_timestamp_us += DIV_ROUND_CLOSEST(delta*16, 3);2338	}2339	ds4->prev_sensor_timestamp = sensor_timestamp;2340	input_event(ds4->sensors, EV_MSC, MSC_TIMESTAMP, ds4->sensor_timestamp_us);2341	input_sync(ds4->sensors);2342 2343	for (i = 0; i < num_touch_reports; i++) {2344		struct dualshock4_touch_report *touch_report = &touch_reports[i];2345 2346		for (j = 0; j < ARRAY_SIZE(touch_report->points); j++) {2347			struct dualshock4_touch_point *point = &touch_report->points[j];2348			bool active = (point->contact & DS4_TOUCH_POINT_INACTIVE) ? false : true;2349 2350			input_mt_slot(ds4->touchpad, j);2351			input_mt_report_slot_state(ds4->touchpad, MT_TOOL_FINGER, active);2352 2353			if (active) {2354				int x = (point->x_hi << 8) | point->x_lo;2355				int y = (point->y_hi << 4) | point->y_lo;2356 2357				input_report_abs(ds4->touchpad, ABS_MT_POSITION_X, x);2358				input_report_abs(ds4->touchpad, ABS_MT_POSITION_Y, y);2359			}2360		}2361		input_mt_sync_frame(ds4->touchpad);2362		input_sync(ds4->touchpad);2363	}2364	input_report_key(ds4->touchpad, BTN_LEFT, ds4_report->buttons[2] & DS_BUTTONS2_TOUCHPAD);2365 2366	/*2367	 * Interpretation of the battery_capacity data depends on the cable state.2368	 * When no cable is connected (bit4 is 0):2369	 * - 0:10: percentage in units of 10%.2370	 * When a cable is plugged in:2371	 * - 0-10: percentage in units of 10%.2372	 * - 11: battery is full2373	 * - 14: not charging due to Voltage or temperature error2374	 * - 15: charge error2375	 */2376	if (ds4_report->status[0] & DS4_STATUS0_CABLE_STATE) {2377		uint8_t battery_data = ds4_report->status[0] & DS4_STATUS0_BATTERY_CAPACITY;2378 2379		if (battery_data < 10) {2380			/* Take the mid-point for each battery capacity value,2381			 * because on the hardware side 0 = 0-9%, 1=10-19%, etc.2382			 * This matches official platform behavior, which does2383			 * the same.2384			 */2385			battery_capacity = battery_data * 10 + 5;2386			battery_status = POWER_SUPPLY_STATUS_CHARGING;2387		} else if (battery_data == 10) {2388			battery_capacity = 100;2389			battery_status = POWER_SUPPLY_STATUS_CHARGING;2390		} else if (battery_data == DS4_BATTERY_STATUS_FULL) {2391			battery_capacity = 100;2392			battery_status = POWER_SUPPLY_STATUS_FULL;2393		} else { /* 14, 15 and undefined values */2394			battery_capacity = 0;2395			battery_status = POWER_SUPPLY_STATUS_UNKNOWN;2396		}2397	} else {2398		uint8_t battery_data = ds4_report->status[0] & DS4_STATUS0_BATTERY_CAPACITY;2399 2400		if (battery_data < 10)2401			battery_capacity = battery_data * 10 + 5;2402		else /* 10 */2403			battery_capacity = 100;2404 2405		battery_status = POWER_SUPPLY_STATUS_DISCHARGING;2406	}2407 2408	spin_lock_irqsave(&ps_dev->lock, flags);2409	ps_dev->battery_capacity = battery_capacity;2410	ps_dev->battery_status = battery_status;2411	spin_unlock_irqrestore(&ps_dev->lock, flags);2412 2413	return 0;2414}2415 2416static int dualshock4_dongle_parse_report(struct ps_device *ps_dev, struct hid_report *report,2417		u8 *data, int size)2418{2419	struct dualshock4 *ds4 = container_of(ps_dev, struct dualshock4, base);2420	bool connected = false;2421 2422	/* The dongle reports data using the main USB report (0x1) no matter whether a controller2423	 * is connected with mostly zeros. The report does contain dongle status, which we use to2424	 * determine if a controller is connected and if so we forward to the regular DualShock42425	 * parsing code.2426	 */2427	if (data[0] == DS4_INPUT_REPORT_USB && size == DS4_INPUT_REPORT_USB_SIZE) {2428		struct dualshock4_input_report_common *ds4_report = (struct dualshock4_input_report_common *)&data[1];2429		unsigned long flags;2430 2431		connected = ds4_report->status[1] & DS4_STATUS1_DONGLE_STATE ? false : true;2432 2433		if (ds4->dongle_state == DONGLE_DISCONNECTED && connected) {2434			hid_info(ps_dev->hdev, "DualShock 4 USB dongle: controller connected\n");2435 2436			dualshock4_set_default_lightbar_colors(ds4);2437 2438			spin_lock_irqsave(&ps_dev->lock, flags);2439			ds4->dongle_state = DONGLE_CALIBRATING;2440			spin_unlock_irqrestore(&ps_dev->lock, flags);2441 2442			schedule_work(&ds4->dongle_hotplug_worker);2443 2444			/* Don't process the report since we don't have2445			 * calibration data, but let hidraw have it anyway.2446			 */2447			return 0;2448		} else if ((ds4->dongle_state == DONGLE_CONNECTED ||2449			    ds4->dongle_state == DONGLE_DISABLED) && !connected) {2450			hid_info(ps_dev->hdev, "DualShock 4 USB dongle: controller disconnected\n");2451 2452			spin_lock_irqsave(&ps_dev->lock, flags);2453			ds4->dongle_state = DONGLE_DISCONNECTED;2454			spin_unlock_irqrestore(&ps_dev->lock, flags);2455 2456			/* Return 0, so hidraw can get the report. */2457			return 0;2458		} else if (ds4->dongle_state == DONGLE_CALIBRATING ||2459			   ds4->dongle_state == DONGLE_DISABLED ||2460			   ds4->dongle_state == DONGLE_DISCONNECTED) {2461			/* Return 0, so hidraw can get the report. */2462			return 0;2463		}2464	}2465 2466	if (connected)2467		return dualshock4_parse_report(ps_dev, report, data, size);2468 2469	return 0;2470}2471 2472static int dualshock4_play_effect(struct input_dev *dev, void *data, struct ff_effect *effect)2473{2474	struct hid_device *hdev = input_get_drvdata(dev);2475	struct dualshock4 *ds4 = hid_get_drvdata(hdev);2476	unsigned long flags;2477 2478	if (effect->type != FF_RUMBLE)2479		return 0;2480 2481	spin_lock_irqsave(&ds4->base.lock, flags);2482	ds4->update_rumble = true;2483	ds4->motor_left = effect->u.rumble.strong_magnitude / 256;2484	ds4->motor_right = effect->u.rumble.weak_magnitude / 256;2485	spin_unlock_irqrestore(&ds4->base.lock, flags);2486 2487	dualshock4_schedule_work(ds4);2488	return 0;2489}2490 2491static void dualshock4_remove(struct ps_device *ps_dev)2492{2493	struct dualshock4 *ds4 = container_of(ps_dev, struct dualshock4, base);2494	unsigned long flags;2495 2496	spin_lock_irqsave(&ds4->base.lock, flags);2497	ds4->output_worker_initialized = false;2498	spin_unlock_irqrestore(&ds4->base.lock, flags);2499 2500	cancel_work_sync(&ds4->output_worker);2501 2502	if (ps_dev->hdev->product == USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE)2503		cancel_work_sync(&ds4->dongle_hotplug_worker);2504}2505 2506static inline void dualshock4_schedule_work(struct dualshock4 *ds4)2507{2508	unsigned long flags;2509 2510	spin_lock_irqsave(&ds4->base.lock, flags);2511	if (ds4->output_worker_initialized)2512		schedule_work(&ds4->output_worker);2513	spin_unlock_irqrestore(&ds4->base.lock, flags);2514}2515 2516static void dualshock4_set_bt_poll_interval(struct dualshock4 *ds4, uint8_t interval)2517{2518	ds4->bt_poll_interval = interval;2519	ds4->update_bt_poll_interval = true;2520	dualshock4_schedule_work(ds4);2521}2522 2523/* Set default lightbar color based on player. */2524static void dualshock4_set_default_lightbar_colors(struct dualshock4 *ds4)2525{2526	/* Use same player colors as PlayStation 4.2527	 * Array of colors is in RGB.2528	 */2529	static const int player_colors[4][3] = {2530		{ 0x00, 0x00, 0x40 }, /* Blue */2531		{ 0x40, 0x00, 0x00 }, /* Red */2532		{ 0x00, 0x40, 0x00 }, /* Green */2533		{ 0x20, 0x00, 0x20 }  /* Pink */2534	};2535 2536	uint8_t player_id = ds4->base.player_id % ARRAY_SIZE(player_colors);2537 2538	ds4->lightbar_enabled = true;2539	ds4->lightbar_red = player_colors[player_id][0];2540	ds4->lightbar_green = player_colors[player_id][1];2541	ds4->lightbar_blue = player_colors[player_id][2];2542 2543	ds4->update_lightbar = true;2544	dualshock4_schedule_work(ds4);2545}2546 2547static struct ps_device *dualshock4_create(struct hid_device *hdev)2548{2549	struct dualshock4 *ds4;2550	struct ps_device *ps_dev;2551	uint8_t max_output_report_size;2552	int i, ret;2553 2554	/* The DualShock4 has an RGB lightbar, which the original hid-sony driver2555	 * exposed as a set of 4 LEDs for the 3 color channels and a global control.2556	 * Ideally this should have used the multi-color LED class, which didn't exist2557	 * yet. In addition the driver used a naming scheme not compliant with the LED2558	 * naming spec by using "<mac_address>:<color>", which contained many colons.2559	 * We use a more compliant by using "<device_name>:<color>" name now. Ideally2560	 * would have been "<device_name>:<color>:indicator", but that would break2561	 * existing applications (e.g. Android). Nothing matches against MAC address.2562	 */2563	static const struct ps_led_info lightbar_leds_info[] = {2564		{ NULL, "red", 255, dualshock4_led_get_brightness, dualshock4_led_set_brightness },2565		{ NULL, "green", 255, dualshock4_led_get_brightness, dualshock4_led_set_brightness },2566		{ NULL, "blue", 255, dualshock4_led_get_brightness, dualshock4_led_set_brightness },2567		{ NULL, "global", 1, dualshock4_led_get_brightness, dualshock4_led_set_brightness,2568				dualshock4_led_set_blink },2569	};2570 2571	ds4 = devm_kzalloc(&hdev->dev, sizeof(*ds4), GFP_KERNEL);2572	if (!ds4)2573		return ERR_PTR(-ENOMEM);2574 2575	/*2576	 * Patch version to allow userspace to distinguish between2577	 * hid-generic vs hid-playstation axis and button mapping.2578	 */2579	hdev->version |= HID_PLAYSTATION_VERSION_PATCH;2580 2581	ps_dev = &ds4->base;2582	ps_dev->hdev = hdev;2583	spin_lock_init(&ps_dev->lock);2584	ps_dev->battery_capacity = 100; /* initial value until parse_report. */2585	ps_dev->battery_status = POWER_SUPPLY_STATUS_UNKNOWN;2586	ps_dev->parse_report = dualshock4_parse_report;2587	ps_dev->remove = dualshock4_remove;2588	INIT_WORK(&ds4->output_worker, dualshock4_output_worker);2589	ds4->output_worker_initialized = true;2590	hid_set_drvdata(hdev, ds4);2591 2592	max_output_report_size = sizeof(struct dualshock4_output_report_bt);2593	ds4->output_report_dmabuf = devm_kzalloc(&hdev->dev, max_output_report_size, GFP_KERNEL);2594	if (!ds4->output_report_dmabuf)2595		return ERR_PTR(-ENOMEM);2596 2597	if (hdev->product == USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE) {2598		ds4->dongle_state = DONGLE_DISCONNECTED;2599		INIT_WORK(&ds4->dongle_hotplug_worker, dualshock4_dongle_calibration_work);2600 2601		/* Override parse report for dongle specific hotplug handling. */2602		ps_dev->parse_report = dualshock4_dongle_parse_report;2603	}2604 2605	ret = dualshock4_get_mac_address(ds4);2606	if (ret) {2607		hid_err(hdev, "Failed to get MAC address from DualShock4\n");2608		return ERR_PTR(ret);2609	}2610	snprintf(hdev->uniq, sizeof(hdev->uniq), "%pMR", ds4->base.mac_address);2611 2612	ret = dualshock4_get_firmware_info(ds4);2613	if (ret) {2614		hid_warn(hdev, "Failed to get firmware info from DualShock4\n");2615		hid_warn(hdev, "HW/FW version data in sysfs will be invalid.\n");2616	}2617 2618	ret = ps_devices_list_add(ps_dev);2619	if (ret)2620		return ERR_PTR(ret);2621 2622	ret = dualshock4_get_calibration_data(ds4);2623	if (ret) {2624		hid_warn(hdev, "Failed to get calibration data from DualShock4\n");2625		hid_warn(hdev, "Gyroscope and accelerometer will be inaccurate.\n");2626	}2627 2628	ds4->gamepad = ps_gamepad_create(hdev, dualshock4_play_effect);2629	if (IS_ERR(ds4->gamepad)) {2630		ret = PTR_ERR(ds4->gamepad);2631		goto err;2632	}2633 2634	/* Use gamepad input device name as primary device name for e.g. LEDs */2635	ps_dev->input_dev_name = dev_name(&ds4->gamepad->dev);2636 2637	ds4->sensors = ps_sensors_create(hdev, DS4_ACC_RANGE, DS4_ACC_RES_PER_G,2638			DS4_GYRO_RANGE, DS4_GYRO_RES_PER_DEG_S);2639	if (IS_ERR(ds4->sensors)) {2640		ret = PTR_ERR(ds4->sensors);2641		goto err;2642	}2643 2644	ds4->touchpad = ps_touchpad_create(hdev, DS4_TOUCHPAD_WIDTH, DS4_TOUCHPAD_HEIGHT, 2);2645	if (IS_ERR(ds4->touchpad)) {2646		ret = PTR_ERR(ds4->touchpad);2647		goto err;2648	}2649 2650	ret = ps_device_register_battery(ps_dev);2651	if (ret)2652		goto err;2653 2654	for (i = 0; i < ARRAY_SIZE(lightbar_leds_info); i++) {2655		const struct ps_led_info *led_info = &lightbar_leds_info[i];2656 2657		ret = ps_led_register(ps_dev, &ds4->lightbar_leds[i], led_info);2658		if (ret < 0)2659			goto err;2660	}2661 2662	dualshock4_set_bt_poll_interval(ds4, DS4_BT_DEFAULT_POLL_INTERVAL_MS);2663 2664	ret = ps_device_set_player_id(ps_dev);2665	if (ret) {2666		hid_err(hdev, "Failed to assign player id for DualShock4: %d\n", ret);2667		goto err;2668	}2669 2670	dualshock4_set_default_lightbar_colors(ds4);2671 2672	/*2673	 * Reporting hardware and firmware is important as there are frequent updates, which2674	 * can change behavior.2675	 */2676	hid_info(hdev, "Registered DualShock4 controller hw_version=0x%08x fw_version=0x%08x\n",2677			ds4->base.hw_version, ds4->base.fw_version);2678	return &ds4->base;2679 2680err:2681	ps_devices_list_remove(ps_dev);2682	return ERR_PTR(ret);2683}2684 2685static int ps_raw_event(struct hid_device *hdev, struct hid_report *report,2686		u8 *data, int size)2687{2688	struct ps_device *dev = hid_get_drvdata(hdev);2689 2690	if (dev && dev->parse_report)2691		return dev->parse_report(dev, report, data, size);2692 2693	return 0;2694}2695 2696static int ps_probe(struct hid_device *hdev, const struct hid_device_id *id)2697{2698	struct ps_device *dev;2699	int ret;2700 2701	ret = hid_parse(hdev);2702	if (ret) {2703		hid_err(hdev, "Parse failed\n");2704		return ret;2705	}2706 2707	ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);2708	if (ret) {2709		hid_err(hdev, "Failed to start HID device\n");2710		return ret;2711	}2712 2713	ret = hid_hw_open(hdev);2714	if (ret) {2715		hid_err(hdev, "Failed to open HID device\n");2716		goto err_stop;2717	}2718 2719	if (id->driver_data == PS_TYPE_PS4_DUALSHOCK4) {2720		dev = dualshock4_create(hdev);2721		if (IS_ERR(dev)) {2722			hid_err(hdev, "Failed to create dualshock4.\n");2723			ret = PTR_ERR(dev);2724			goto err_close;2725		}2726	} else if (id->driver_data == PS_TYPE_PS5_DUALSENSE) {2727		dev = dualsense_create(hdev);2728		if (IS_ERR(dev)) {2729			hid_err(hdev, "Failed to create dualsense.\n");2730			ret = PTR_ERR(dev);2731			goto err_close;2732		}2733	}2734 2735	return ret;2736 2737err_close:2738	hid_hw_close(hdev);2739err_stop:2740	hid_hw_stop(hdev);2741	return ret;2742}2743 2744static void ps_remove(struct hid_device *hdev)2745{2746	struct ps_device *dev = hid_get_drvdata(hdev);2747 2748	ps_devices_list_remove(dev);2749	ps_device_release_player_id(dev);2750 2751	if (dev->remove)2752		dev->remove(dev);2753 2754	hid_hw_close(hdev);2755	hid_hw_stop(hdev);2756}2757 2758static const struct hid_device_id ps_devices[] = {2759	/* Sony DualShock 4 controllers for PS4 */2760	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),2761		.driver_data = PS_TYPE_PS4_DUALSHOCK4 },2762	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),2763		.driver_data = PS_TYPE_PS4_DUALSHOCK4 },2764	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),2765		.driver_data = PS_TYPE_PS4_DUALSHOCK4 },2766	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),2767		.driver_data = PS_TYPE_PS4_DUALSHOCK4 },2768	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE),2769		.driver_data = PS_TYPE_PS4_DUALSHOCK4 },2770 2771	/* Sony DualSense controllers for PS5 */2772	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS5_CONTROLLER),2773		.driver_data = PS_TYPE_PS5_DUALSENSE },2774	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS5_CONTROLLER),2775		.driver_data = PS_TYPE_PS5_DUALSENSE },2776	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS5_CONTROLLER_2),2777		.driver_data = PS_TYPE_PS5_DUALSENSE },2778	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS5_CONTROLLER_2),2779		.driver_data = PS_TYPE_PS5_DUALSENSE },2780	{ }2781};2782MODULE_DEVICE_TABLE(hid, ps_devices);2783 2784static struct hid_driver ps_driver = {2785	.name		= "playstation",2786	.id_table	= ps_devices,2787	.probe		= ps_probe,2788	.remove		= ps_remove,2789	.raw_event	= ps_raw_event,2790	.driver = {2791		.dev_groups = ps_device_groups,2792	},2793};2794 2795static int __init ps_init(void)2796{2797	return hid_register_driver(&ps_driver);2798}2799 2800static void __exit ps_exit(void)2801{2802	hid_unregister_driver(&ps_driver);2803	ida_destroy(&ps_player_id_allocator);2804}2805 2806module_init(ps_init);2807module_exit(ps_exit);2808 2809MODULE_AUTHOR("Sony Interactive Entertainment");2810MODULE_DESCRIPTION("HID Driver for PlayStation peripherals.");2811MODULE_LICENSE("GPL");2812