Commit 995887a1 authored by Derek J. Clark's avatar Derek J. Clark Committed by Jiri Kosina
Browse files

HID: hid-lenovo-go: Add Calibration Settings 



Adds calibration enable and last calibration status indicators for the
triggers, joysticks, and handle gyros.

Reviewed-by: default avatarMark Pearson <mpearson-lenovo@squebb.ca>
Signed-off-by: default avatarDerek J. Clark <derekjohn.clark@gmail.com>
Signed-off-by: default avatarJiri Kosina <jkosina@suse.com>
parent 325262fa

drivers/hid/hid-lenovo-go.c

+283 −1
Original line number Diff line number Diff line
@@ -43,8 +43,11 @@ static struct hid_go_cfg { 
	struct mutex cfg_mutex; /*ensure single synchronous output report*/

	u8 fps_mode;

	u8 gp_left_auto_sleep_time;

	u8 gp_left_gyro_cal_status;

	u8 gp_left_joy_cal_status;

	u8 gp_left_notify_en;

	u8 gp_left_rumble_mode;

	u8 gp_left_trigg_cal_status;

	u32 gp_left_version_firmware;

	u8 gp_left_version_gen;

	u32 gp_left_version_hardware;
@@ -52,8 +55,11 @@ static struct hid_go_cfg { 
	u32 gp_left_version_protocol;

	u8 gp_mode;

	u8 gp_right_auto_sleep_time;

	u8 gp_right_gyro_cal_status;

	u8 gp_right_joy_cal_status;

	u8 gp_right_notify_en;

	u8 gp_right_rumble_mode;

	u8 gp_right_trigg_cal_status;

	u32 gp_right_version_firmware;

	u8 gp_right_version_gen;

	u32 gp_right_version_hardware;
@@ -228,6 +234,40 @@ static const char *const rumble_mode_text[] = { 
};



#define FPS_MODE_DPI		0x02

#define TRIGGER_CALIBRATE	0x04

#define JOYSTICK_CALIBRATE	0x04

#define GYRO_CALIBRATE		0x06



enum cal_device_type {

	CALDEV_GYROSCOPE = 0x01,

	CALDEV_JOYSTICK,

	CALDEV_TRIGGER,

	CALDEV_JOY_TRIGGER,

};



enum cal_enable {

	CAL_UNKNOWN,

	CAL_START,

	CAL_STOP,

};



static const char *const cal_enabled_text[] = {

	[CAL_UNKNOWN] = "unknown",

	[CAL_START] = "start",

	[CAL_STOP] = "stop",

};



enum cal_status_index {

	CAL_STAT_UNKNOWN,

	CAL_STAT_SUCCESS,

	CAL_STAT_FAILURE,

};



static const char *const cal_status_text[] = {

	[CAL_STAT_UNKNOWN] = "unknown",

	[CAL_STAT_SUCCESS] = "success",

	[CAL_STAT_FAILURE] = "failure",

};



enum rgb_config_index {

	LIGHT_CFG_ALL = 0x01,
@@ -264,6 +304,13 @@ static const char *const rgb_effect_text[] = { 
	[RGB_EFFECT_RAINBOW] = "rainbow",

};



enum device_status_index {

	GET_CAL_STATUS = 0x02,

	GET_UPGRADE_STATUS,

	GET_MACRO_REC_STATUS,

	GET_HOTKEY_TRIGG_STATUS,

};



static int hid_go_version_event(struct command_report *cmd_rep)

{

	switch (cmd_rep->sub_cmd) {
@@ -508,6 +555,44 @@ static int hid_go_light_event(struct command_report *cmd_rep) 
	}

}



static int hid_go_device_status_event(struct command_report *cmd_rep)

{

	switch (cmd_rep->device_type) {

	case LEFT_CONTROLLER:

		switch (cmd_rep->data[0]) {

		case CALDEV_GYROSCOPE:

			drvdata.gp_left_gyro_cal_status = cmd_rep->data[1];

			return 0;

		case CALDEV_JOYSTICK:

			drvdata.gp_left_joy_cal_status = cmd_rep->data[1];

			return 0;

		case CALDEV_TRIGGER:

			drvdata.gp_left_trigg_cal_status = cmd_rep->data[1];

			return 0;

		default:

			return -EINVAL;

		}

		break;

	case RIGHT_CONTROLLER:

		switch (cmd_rep->data[0]) {

		case CALDEV_GYROSCOPE:

			drvdata.gp_right_gyro_cal_status = cmd_rep->data[1];

			return 0;

		case CALDEV_JOYSTICK:

			drvdata.gp_right_joy_cal_status = cmd_rep->data[1];

			return 0;

		case CALDEV_TRIGGER:

			drvdata.gp_right_trigg_cal_status = cmd_rep->data[1];

			return 0;

		default:

			return -EINVAL;

		}

		break;

	default:

		return -EINVAL;

	}

}



static int hid_go_set_event_return(struct command_report *cmd_rep)

{

	if (cmd_rep->data[0] != 0)
@@ -564,10 +649,16 @@ static int hid_go_raw_event(struct hid_device *hdev, struct hid_report *report, 
		case GET_RGB_CFG:

			ret = hid_go_light_event(cmd_rep);

			break;

		case GET_DEVICE_STATUS:

			ret = hid_go_device_status_event(cmd_rep);

			break;

		case SET_FEATURE_STATUS:

		case SET_MOTOR_CFG:

		case SET_DPI_CFG:

		case SET_RGB_CFG:

		case SET_TRIGGER_CFG:

		case SET_JOYSTICK_CFG:

		case SET_GYRO_CFG:

			ret = hid_go_set_event_return(cmd_rep);

			break;

		default:
@@ -1157,6 +1248,101 @@ static ssize_t fps_mode_dpi_index_show(struct device *dev, 
	return sysfs_emit(buf, "500 800 1200 1800\n");

}



static ssize_t device_status_show(struct device *dev,

				  struct device_attribute *attr, char *buf,

				  enum device_status_index index,

				  enum dev_type device_type,

				  enum cal_device_type cal_type)

{

	u8 i;



	switch (index) {

	case GET_CAL_STATUS:

		switch (device_type) {

		case LEFT_CONTROLLER:

			switch (cal_type) {

			case CALDEV_GYROSCOPE:

				i = drvdata.gp_left_gyro_cal_status;

				break;

			case CALDEV_JOYSTICK:

				i = drvdata.gp_left_joy_cal_status;

				break;

			case CALDEV_TRIGGER:

				i = drvdata.gp_left_trigg_cal_status;

				break;

			default:

				return -EINVAL;

			}

			break;

		case RIGHT_CONTROLLER:

			switch (cal_type) {

			case CALDEV_GYROSCOPE:

				i = drvdata.gp_right_gyro_cal_status;

				break;

			case CALDEV_JOYSTICK:

				i = drvdata.gp_right_joy_cal_status;

				break;

			case CALDEV_TRIGGER:

				i = drvdata.gp_right_trigg_cal_status;

				break;

			default:

				return -EINVAL;

			}

			break;

		default:

			return -EINVAL;

		}

		break;

	default:

		return -EINVAL;

	};



	if (i >= ARRAY_SIZE(cal_status_text))

		return -EINVAL;



	return sysfs_emit(buf, "%s\n", cal_status_text[i]);

}



static ssize_t calibrate_config_store(struct device *dev,

				      struct device_attribute *attr,

				      const char *buf, u8 cmd, u8 sub_cmd,

				      size_t count, enum dev_type device_type)

{

	size_t size = 1;

	u8 val = 0;

	int ret;



	ret = sysfs_match_string(cal_enabled_text, buf);

	if (ret < 0)

		return ret;



	val = ret;

	if (!val)

		size = 0;



	ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, cmd, sub_cmd,

			       device_type, &val, size);

	if (ret < 0)

		return ret;



	return count;

}



static ssize_t calibrate_config_options(struct device *dev,

					struct device_attribute *attr,

					char *buf)

{

	ssize_t count = 0;

	unsigned int i;



	for (i = 1; i < ARRAY_SIZE(cal_enabled_text); i++)

		count += sysfs_emit_at(buf, count, "%s ", cal_enabled_text[i]);



	buf[count - 1] = '\n';



	return count;

}



static int rgb_cfg_call(struct hid_device *hdev, enum mcu_command_index cmd,

			enum rgb_config_index index, u8 *val, size_t size)

{
@@ -1466,6 +1652,30 @@ static void hid_go_brightness_set(struct led_classdev *led_cdev, 
	}                                                                     \

	static DEVICE_ATTR_RO_NAMED(_name, _attrname)



#define LEGO_CAL_DEVICE_ATTR(_name, _attrname, _scmd, _dtype, _rtype)         \

	static ssize_t _name##_store(struct device *dev,                      \

				     struct device_attribute *attr,           \

				     const char *buf, size_t count)           \

	{                                                                     \

		return calibrate_config_store(dev, attr, buf, _name.index,    \

					      _scmd, count, _dtype);          \

	}                                                                     \

	static ssize_t _name##_##_rtype##_show(                               \

		struct device *dev, struct device_attribute *attr, char *buf) \

	{                                                                     \

		return calibrate_config_options(dev, attr, buf);              \

	}                                                                     \

	static DEVICE_ATTR_WO_NAMED(_name, _attrname)



#define LEGO_DEVICE_STATUS_ATTR(_name, _attrname, _scmd, _dtype)              \

	static ssize_t _name##_show(struct device *dev,                       \

				    struct device_attribute *attr, char *buf) \

	{                                                                     \

		return device_status_show(dev, attr, buf, _name.index, _scmd, \

					  _dtype);                            \

	}                                                                     \

	static DEVICE_ATTR_RO_NAMED(_name, _attrname)



/* Gamepad - MCU */

static struct go_cfg_attr version_product_mcu = { PRODUCT_VERSION };

LEGO_DEVICE_ATTR_RO(version_product_mcu, "product_version", USB_MCU, version);
@@ -1603,9 +1813,45 @@ LEGO_DEVICE_ATTR_RW(rumble_notification_left, "rumble_notification", 
static DEVICE_ATTR_RO_NAMED(rumble_notification_left_index,

			    "rumble_notification_index");



static struct go_cfg_attr cal_trigg_left = { TRIGGER_CALIBRATE };

LEGO_CAL_DEVICE_ATTR(cal_trigg_left, "calibrate_trigger", SET_TRIGGER_CFG,

		     LEFT_CONTROLLER, index);

static DEVICE_ATTR_RO_NAMED(cal_trigg_left_index, "calibrate_trigger_index");



static struct go_cfg_attr cal_joy_left = { JOYSTICK_CALIBRATE };

LEGO_CAL_DEVICE_ATTR(cal_joy_left, "calibrate_joystick", SET_JOYSTICK_CFG,

		     LEFT_CONTROLLER, index);

static DEVICE_ATTR_RO_NAMED(cal_joy_left_index, "calibrate_joystick_index");



static struct go_cfg_attr cal_gyro_left = { GYRO_CALIBRATE };

LEGO_CAL_DEVICE_ATTR(cal_gyro_left, "calibrate_gyro", SET_GYRO_CFG,

		     LEFT_CONTROLLER, index);

static DEVICE_ATTR_RO_NAMED(cal_gyro_left_index, "calibrate_gyro_index");



static struct go_cfg_attr cal_trigg_left_status = { GET_CAL_STATUS };

LEGO_DEVICE_STATUS_ATTR(cal_trigg_left_status, "calibrate_trigger_status",

			LEFT_CONTROLLER, CALDEV_TRIGGER);



static struct go_cfg_attr cal_joy_left_status = { GET_CAL_STATUS };

LEGO_DEVICE_STATUS_ATTR(cal_joy_left_status, "calibrate_joystick_status",

			LEFT_CONTROLLER, CALDEV_JOYSTICK);



static struct go_cfg_attr cal_gyro_left_status = { GET_CAL_STATUS };

LEGO_DEVICE_STATUS_ATTR(cal_gyro_left_status, "calibrate_gyro_status",

			LEFT_CONTROLLER, CALDEV_GYROSCOPE);



static struct attribute *left_gamepad_attrs[] = {

	&dev_attr_auto_sleep_time_left.attr,

	&dev_attr_auto_sleep_time_left_range.attr,

	&dev_attr_cal_gyro_left.attr,

	&dev_attr_cal_gyro_left_index.attr,

	&dev_attr_cal_gyro_left_status.attr,

	&dev_attr_cal_joy_left.attr,

	&dev_attr_cal_joy_left_index.attr,

	&dev_attr_cal_joy_left_status.attr,

	&dev_attr_cal_trigg_left.attr,

	&dev_attr_cal_trigg_left_index.attr,

	&dev_attr_cal_trigg_left_status.attr,

	&dev_attr_imu_bypass_left.attr,

	&dev_attr_imu_bypass_left_index.attr,

	&dev_attr_imu_enabled_left.attr,
@@ -1674,9 +1920,45 @@ LEGO_DEVICE_ATTR_RW(rumble_notification_right, "rumble_notification", 
static DEVICE_ATTR_RO_NAMED(rumble_notification_right_index,

			    "rumble_notification_index");



static struct go_cfg_attr cal_trigg_right = { TRIGGER_CALIBRATE };

LEGO_CAL_DEVICE_ATTR(cal_trigg_right, "calibrate_trigger", SET_TRIGGER_CFG,

		     RIGHT_CONTROLLER, index);

static DEVICE_ATTR_RO_NAMED(cal_trigg_right_index, "calibrate_trigger_index");



static struct go_cfg_attr cal_joy_right = { JOYSTICK_CALIBRATE };

LEGO_CAL_DEVICE_ATTR(cal_joy_right, "calibrate_joystick", SET_JOYSTICK_CFG,

		     RIGHT_CONTROLLER, index);

static DEVICE_ATTR_RO_NAMED(cal_joy_right_index, "calibrate_joystick_index");



static struct go_cfg_attr cal_gyro_right = { GYRO_CALIBRATE };

LEGO_CAL_DEVICE_ATTR(cal_gyro_right, "calibrate_gyro", SET_GYRO_CFG,

		     RIGHT_CONTROLLER, index);

static DEVICE_ATTR_RO_NAMED(cal_gyro_right_index, "calibrate_gyro_index");



static struct go_cfg_attr cal_trigg_right_status = { GET_CAL_STATUS };

LEGO_DEVICE_STATUS_ATTR(cal_trigg_right_status, "calibrate_trigger_status",

			RIGHT_CONTROLLER, CALDEV_TRIGGER);



static struct go_cfg_attr cal_joy_right_status = { GET_CAL_STATUS };

LEGO_DEVICE_STATUS_ATTR(cal_joy_right_status, "calibrate_joystick_status",

			RIGHT_CONTROLLER, CALDEV_JOYSTICK);



static struct go_cfg_attr cal_gyro_right_status = { GET_CAL_STATUS };

LEGO_DEVICE_STATUS_ATTR(cal_gyro_right_status, "calibrate_gyro_status",

			RIGHT_CONTROLLER, CALDEV_GYROSCOPE);



static struct attribute *right_gamepad_attrs[] = {

	&dev_attr_auto_sleep_time_right.attr,

	&dev_attr_auto_sleep_time_right_range.attr,

	&dev_attr_cal_gyro_right.attr,

	&dev_attr_cal_gyro_right_index.attr,

	&dev_attr_cal_gyro_right_status.attr,

	&dev_attr_cal_joy_right.attr,

	&dev_attr_cal_joy_right_index.attr,

	&dev_attr_cal_joy_right_status.attr,

	&dev_attr_cal_trigg_right.attr,

	&dev_attr_cal_trigg_right_index.attr,

	&dev_attr_cal_trigg_right_status.attr,

	&dev_attr_imu_bypass_right.attr,

	&dev_attr_imu_bypass_right_index.attr,

	&dev_attr_imu_enabled_right.attr,