diff --git a/debian.master/config/annotations b/debian.master/config/annotations index caabb5c4d5d860..658454607c31ea 100644 --- a/debian.master/config/annotations +++ b/debian.master/config/annotations @@ -11321,6 +11321,7 @@ CONFIG_SENSORS_SPARX5 policy<{'arm64': 'm'}> CONFIG_SENSORS_STPDDC60 policy<{'amd64': 'm', 'arm64': 'm', 'armhf': 'm', 'ppc64el': 'm', 'riscv64': 'm'}> CONFIG_SENSORS_STTS751 policy<{'amd64': 'm', 'arm64': 'm', 'armhf': 'm', 'ppc64el': 'm', 'riscv64': 'm', 's390x': '-'}> CONFIG_SENSORS_SY7636A policy<{'amd64': 'm', 'arm64': 'm', 'armhf': 'm', 'ppc64el': 'm', 'riscv64': 'm'}> +CONFIG_SENSORS_SYSTEM76_THELIO_IO policy<{'amd64': 'm', 'arm64': 'm', 'armhf': 'm', 'ppc64el': 'm', 'riscv64': 'm', 's390x': '-'}> CONFIG_SENSORS_TC654 policy<{'amd64': 'm', 'arm64': 'm', 'armhf': 'm', 'ppc64el': 'm', 'riscv64': 'm', 's390x': '-'}> CONFIG_SENSORS_TC74 policy<{'amd64': 'm', 'arm64': 'm', 'armhf': 'm', 'ppc64el': 'm', 'riscv64': 'm', 's390x': '-'}> CONFIG_SENSORS_THMC50 policy<{'amd64': 'm', 'arm64': 'm', 'armhf': 'm', 'ppc64el': 'm', 'riscv64': 'm', 's390x': '-'}> diff --git a/debian.master/config/config.common.ubuntu b/debian.master/config/config.common.ubuntu index f17f30533dce71..5e8619662bf93f 100644 --- a/debian.master/config/config.common.ubuntu +++ b/debian.master/config/config.common.ubuntu @@ -10047,6 +10047,7 @@ CONFIG_SENSORS_SPARX5=m CONFIG_SENSORS_STPDDC60=m CONFIG_SENSORS_STTS751=m CONFIG_SENSORS_SY7636A=m +CONFIG_SENSORS_SYSTEM76_THELIO_IO=m CONFIG_SENSORS_TC654=m CONFIG_SENSORS_TC74=m CONFIG_SENSORS_THMC50=m diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig index 300ce8115ce4f7..406a9e8b22ff0a 100644 --- a/drivers/hwmon/Kconfig +++ b/drivers/hwmon/Kconfig @@ -2400,6 +2400,16 @@ config SENSORS_ASUS_EC This driver can also be built as a module. If so, the module will be called asus_ec_sensors. +config SENSORS_SYSTEM76_THELIO_IO + tristate "System76 Thelio Io controller" + depends on HID + help + If you say yes here you get support for the System76 Thelio Io + controller. + + This driver can also be built as a module. If so, the module + will be called system76-thelio-io. + endif # ACPI endif # HWMON diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile index e2e4e87b282f53..de14ebb47efdca 100644 --- a/drivers/hwmon/Makefile +++ b/drivers/hwmon/Makefile @@ -195,6 +195,7 @@ obj-$(CONFIG_SENSORS_SMSC47M192)+= smsc47m192.o obj-$(CONFIG_SENSORS_SPARX5) += sparx5-temp.o obj-$(CONFIG_SENSORS_STTS751) += stts751.o obj-$(CONFIG_SENSORS_SY7636A) += sy7636a-hwmon.o +obj-$(CONFIG_SENSORS_SYSTEM76_THELIO_IO) += system76-thelio-io.o obj-$(CONFIG_SENSORS_AMC6821) += amc6821.o obj-$(CONFIG_SENSORS_TC74) += tc74.o obj-$(CONFIG_SENSORS_THMC50) += thmc50.o diff --git a/drivers/hwmon/system76-thelio-io.c b/drivers/hwmon/system76-thelio-io.c new file mode 100644 index 00000000000000..f3a224dbc0d0c5 --- /dev/null +++ b/drivers/hwmon/system76-thelio-io.c @@ -0,0 +1,419 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * + * system76-thelio-io.c - Linux driver for System76 Thelio Io + * Copyright (C) 2023 System76 + * + * Based on: + * corsair-cpro.c - Linux driver for Corsair Commander Pro + * Copyright (C) 2020 Marius Zachmann + * + * This driver uses hid reports to communicate with the device to allow hidraw userspace drivers + * still being used. The device does not use report ids. When using hidraw and this driver + * simultaniously, reports could be switched. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define BUFFER_SIZE 32 +#define REQ_TIMEOUT 300 + +#define HID_CMD 0 +#define HID_RES 1 +#define HID_DATA 2 + +#define CMD_FAN_GET 7 +#define CMD_FAN_SET 8 +#define CMD_FAN_TACH 22 + +struct thelio_io_device { + struct hid_device *hdev; + struct device *hwmon_dev; + struct completion wait_input_report; + struct mutex mutex; /* whenever buffer is used, lock before send_usb_cmd */ + u8 *buffer; +}; + +/* converts response error in buffer to errno */ +static int thelio_io_get_errno(struct thelio_io_device *thelio_io) +{ + switch (thelio_io->buffer[HID_RES]) { + case 0x00: /* success */ + return 0; + default: + hid_err(thelio_io->hdev, "unknown device response error: %d", thelio_io->buffer[HID_RES]); + return -EIO; + } +} + +/* send command, check for error in response, response in thelio_io->buffer */ +static int send_usb_cmd(struct thelio_io_device *thelio_io, u8 command, u8 byte1, u8 byte2) +{ + unsigned long t; + int ret; + + memset(thelio_io->buffer, 0x00, BUFFER_SIZE); + thelio_io->buffer[HID_CMD] = command; + thelio_io->buffer[HID_DATA] = byte1; + thelio_io->buffer[HID_DATA + 1] = byte2; + + reinit_completion(&thelio_io->wait_input_report); + + ret = hid_hw_output_report(thelio_io->hdev, thelio_io->buffer, BUFFER_SIZE); + if (ret < 0) + return ret; + + t = wait_for_completion_timeout(&thelio_io->wait_input_report, msecs_to_jiffies(REQ_TIMEOUT)); + if (!t) + return -ETIMEDOUT; + + return thelio_io_get_errno(thelio_io); +} + +static int thelio_io_raw_event(struct hid_device *hdev, struct hid_report *report, u8 *data, int size) +{ + struct thelio_io_device *thelio_io = hid_get_drvdata(hdev); + + /* only copy buffer when requested */ + if (completion_done(&thelio_io->wait_input_report)) + return 0; + + memcpy(thelio_io->buffer, data, min(BUFFER_SIZE, size)); + complete(&thelio_io->wait_input_report); + + return 0; +} + +/* requests and returns single data values depending on channel */ +static int get_data(struct thelio_io_device *thelio_io, int command, int channel, bool two_byte_data) +{ + int ret; + + mutex_lock(&thelio_io->mutex); + + ret = send_usb_cmd(thelio_io, command, channel, 0); + if (ret) + goto out_unlock; + + ret = (int)thelio_io->buffer[HID_DATA + 1]; + if (two_byte_data) + ret |= (((int)thelio_io->buffer[HID_DATA + 2]) << 8); + +out_unlock: + mutex_unlock(&thelio_io->mutex); + return ret; +} + +static int set_pwm(struct thelio_io_device *thelio_io, int channel, long val) +{ + int ret; + + if (val < 0 || val > 255) + return -EINVAL; + + mutex_lock(&thelio_io->mutex); + + ret = send_usb_cmd(thelio_io, CMD_FAN_SET, channel, val); + + mutex_unlock(&thelio_io->mutex); + return ret; +} + +static int thelio_io_read_string(struct device *dev, enum hwmon_sensor_types type, + u32 attr, int channel, const char **str) +{ + switch (type) { + case hwmon_fan: + switch (attr) { + case hwmon_fan_label: + switch (channel) { + case 0: + *str = "CPU Fan"; + return 0; + case 1: + *str = "Intake Fan"; + return 0; + case 2: + *str = "GPU Fan"; + return 0; + case 3: + *str = "Aux Fan"; + return 0; + default: + break; + } + default: + break; + } + break; + default: + break; + } + + return -EOPNOTSUPP; +} + +static int thelio_io_read(struct device *dev, enum hwmon_sensor_types type, + u32 attr, int channel, long *val) +{ + struct thelio_io_device *thelio_io = dev_get_drvdata(dev); + int ret; + + switch (type) { + case hwmon_fan: + switch (attr) { + case hwmon_fan_input: + ret = get_data(thelio_io, CMD_FAN_TACH, channel, true); + if (ret < 0) + return ret; + *val = ret; + return 0; + default: + break; + } + break; + case hwmon_pwm: + switch (attr) { + case hwmon_pwm_input: + ret = get_data(thelio_io, CMD_FAN_GET, channel, false); + if (ret < 0) + return ret; + *val = ret; + return 0; + default: + break; + } + break; + default: + break; + } + + return -EOPNOTSUPP; +}; + +static int thelio_io_write(struct device *dev, enum hwmon_sensor_types type, + u32 attr, int channel, long val) +{ + struct thelio_io_device *thelio_io = dev_get_drvdata(dev); + + switch (type) { + case hwmon_pwm: + switch (attr) { + case hwmon_pwm_input: + return set_pwm(thelio_io, channel, val); + default: + break; + } + break; + default: + break; + } + + return -EOPNOTSUPP; +}; + +static umode_t thelio_io_is_visible(const void *data, enum hwmon_sensor_types type, + u32 attr, int channel) +{ + switch (type) { + case hwmon_fan: + switch (attr) { + case hwmon_fan_input: + return 0444; + case hwmon_fan_label: + return 0444; + default: + break; + } + break; + case hwmon_pwm: + switch (attr) { + case hwmon_pwm_input: + return 0644; + default: + break; + } + break; + default: + break; + } + + return 0; +}; + +static const struct hwmon_ops thelio_io_hwmon_ops = { + .is_visible = thelio_io_is_visible, + .read = thelio_io_read, + .read_string = thelio_io_read_string, + .write = thelio_io_write, +}; + +static const struct hwmon_channel_info *thelio_io_info[] = { + HWMON_CHANNEL_INFO(chip, + HWMON_C_REGISTER_TZ), + HWMON_CHANNEL_INFO(fan, + HWMON_F_INPUT | HWMON_F_LABEL, + HWMON_F_INPUT | HWMON_F_LABEL, + HWMON_F_INPUT | HWMON_F_LABEL, + HWMON_F_INPUT | HWMON_F_LABEL + ), + HWMON_CHANNEL_INFO(pwm, + HWMON_PWM_INPUT, + HWMON_PWM_INPUT, + HWMON_PWM_INPUT, + HWMON_PWM_INPUT + ), + NULL +}; + +static const struct hwmon_chip_info thelio_io_chip_info = { + .ops = &thelio_io_hwmon_ops, + .info = thelio_io_info, +}; + +static int thelio_io_probe_cmd_dev(struct hid_device *hdev) +{ + struct thelio_io_device *thelio_io; + int ret; + + thelio_io = devm_kzalloc(&hdev->dev, sizeof(*thelio_io), GFP_KERNEL); + if (!thelio_io) + return -ENOMEM; + + thelio_io->buffer = devm_kmalloc(&hdev->dev, BUFFER_SIZE, GFP_KERNEL); + if (!thelio_io->buffer) + return -ENOMEM; + + ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); + if (ret) + return ret; + + ret = hid_hw_open(hdev); + if (ret) + goto out_hw_stop; + + thelio_io->hdev = hdev; + hid_set_drvdata(hdev, thelio_io); + mutex_init(&thelio_io->mutex); + init_completion(&thelio_io->wait_input_report); + + hid_device_io_start(hdev); + + thelio_io->hwmon_dev = hwmon_device_register_with_info(&hdev->dev, "system76_thelio_io", + thelio_io, &thelio_io_chip_info, 0); + if (IS_ERR(thelio_io->hwmon_dev)) { + ret = PTR_ERR(thelio_io->hwmon_dev); + goto out_hw_close; + } + + return 0; + +out_hw_close: + hid_hw_close(hdev); +out_hw_stop: + hid_hw_stop(hdev); + return ret; +} + +static int thelio_io_probe(struct hid_device *hdev, const struct hid_device_id *id) +{ + struct thelio_io_device *thelio_io; + int ret; + + thelio_io = devm_kzalloc(&hdev->dev, sizeof(*thelio_io), GFP_KERNEL); + if (!thelio_io) + return -ENOMEM; + + thelio_io->buffer = devm_kmalloc(&hdev->dev, BUFFER_SIZE, GFP_KERNEL); + if (!thelio_io->buffer) + return -ENOMEM; + + ret = hid_parse(hdev); + if (ret) + return ret; + + ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); + if (ret) + return ret; + + ret = hid_hw_open(hdev); + if (ret) + goto out_hw_stop; + + thelio_io->hdev = hdev; + hid_set_drvdata(hdev, thelio_io); + mutex_init(&thelio_io->mutex); + init_completion(&thelio_io->wait_input_report); + + hid_device_io_start(hdev); + + if (hdev->maxcollection == 1 && hdev->collection[0].usage == 0xFF600061) { + hid_info(hdev, "found command device\n"); + thelio_io->hwmon_dev = hwmon_device_register_with_info(&hdev->dev, "system76_thelio_io", + thelio_io, &thelio_io_chip_info, 0); + if (IS_ERR(thelio_io->hwmon_dev)) { + ret = PTR_ERR(thelio_io->hwmon_dev); + goto out_hw_close; + } + } + + return 0; + +out_hw_close: + hid_hw_close(hdev); +out_hw_stop: + hid_hw_stop(hdev); + return ret; +} + +static void thelio_io_remove(struct hid_device *hdev) +{ + struct thelio_io_device *thelio_io = hid_get_drvdata(hdev); + + if (thelio_io->hwmon_dev) { + hwmon_device_unregister(thelio_io->hwmon_dev); + } + hid_hw_close(hdev); + hid_hw_stop(hdev); +} + +static const struct hid_device_id thelio_io_devices[] = { + { HID_USB_DEVICE(0x3384, 0x000B) }, // thelio_io_2 + { } +}; + +static struct hid_driver thelio_io_driver = { + .name = "system76-thelio-io", + .id_table = thelio_io_devices, + .probe = thelio_io_probe, + .remove = thelio_io_remove, + .raw_event = thelio_io_raw_event, +}; + +MODULE_DEVICE_TABLE(hid, thelio_io_devices); +MODULE_LICENSE("GPL"); + +static int __init thelio_io_init(void) +{ + return hid_register_driver(&thelio_io_driver); +} + +static void __exit thelio_io_exit(void) +{ + hid_unregister_driver(&thelio_io_driver); +} + +/* + * When compiling this driver as built-in, hwmon initcalls will get called before the + * hid driver and this driver would fail to register. late_initcall solves this. + */ +late_initcall(thelio_io_init); +module_exit(thelio_io_exit);