From patchwork Thu Feb 9 21:15:02 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Armin Wolf X-Patchwork-Id: 13135060 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 7ABC5C64EC4 for ; Thu, 9 Feb 2023 21:15:45 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230265AbjBIVPo (ORCPT ); Thu, 9 Feb 2023 16:15:44 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57326 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230224AbjBIVPn (ORCPT ); Thu, 9 Feb 2023 16:15:43 -0500 Received: from mout.gmx.net (mout.gmx.net [212.227.15.18]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 2E22E582BC; Thu, 9 Feb 2023 13:15:41 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=gmx.de; s=s31663417; t=1675977318; bh=GNxykkxGAhySVeYly7uHb9QEH3yNQiiCepBYLqD22mg=; h=X-UI-Sender-Class:From:To:Cc:Subject:Date:In-Reply-To:References; b=Q/MVvIN2rOuPNSmh10xJfvP2FFqZH5tK/PJq/9mE+4oVKRQwhikfHlw38OjyOd7kt agmQU+ZwDBUINugZH0RAsr4CQdUAv+fay0fPL5J0vdDkRFs/uzgYCitdwIDyor9FCK hAeUGKCk01au/uC8g5ys5fmUTBFGLzevyrudOrHYvJApTN6/qPU+DiXLr4Vb+Kf8GC hXkfpEMt1C43TsbEVym8JRULefveIV0s9BaXkZZsmyU5n5wdAvVVTZ6sGn16sbbggI 1/WS11oGwNBBg4PQndj4VAdYGhiGQ4kPc+U1jFwMV7BihnMaeK6bPxIjsFKttaFa99 rPGlpWshdDZkg== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from esprimo-mx.users.agdsn.de ([141.30.226.129]) by mail.gmx.net (mrgmx005 [212.227.17.190]) with ESMTPSA (Nemesis) id 1MSKyI-1p1w4c02tE-00Semp; Thu, 09 Feb 2023 22:15:18 +0100 From: Armin Wolf To: hdegoede@redhat.com, markgross@kernel.org Cc: jdelvare@suse.com, linux@roeck-us.net, platform-driver-x86@vger.kernel.org, linux-hwmon@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH v3 1/2] platform/x86: dell-ddv: Add hwmon support Date: Thu, 9 Feb 2023 22:15:02 +0100 Message-Id: <20230209211503.2739-2-W_Armin@gmx.de> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20230209211503.2739-1-W_Armin@gmx.de> References: <20230209211503.2739-1-W_Armin@gmx.de> MIME-Version: 1.0 X-Provags-ID: V03:K1:8e7c4GPu4QCyNzdd51l6V1d56lA8mtym4nnXoRsCNYhTLubKaY4 Nyw0LcUiW3IAlPsLGbJc+1CRqIjR0ohzCPOIz3D9w7YRxzJmYT1aIOPESV9ZgDXn6xhaLbm j3HNstYLNk11fugDsqnZikmQ3E/Z50Mjo0U7yYnkZ626nEr9xLA1PVxtBtxTSS24taqVge3 FbdqWtvl5Ws9eyatMG6Bg== UI-OutboundReport: notjunk:1;M01:P0:kzw1LQeoswg=;WknbIb4+gyL07g29JtYjUzQGZP2 jExowRq4yGn6pxzYZV22/l4VEAULE0oAUswTcGYbu0+2m81+g1mjLQJhDSD3Yaj/6g5sKVyrO R41LT7N9xpMybhhbF0WZAe1YyvId4cnuUXiIdV2fv5S03ZjUOefUQoSfjRkznFfLf6FTECjqL gLbEi8spKx0mYCkobY/stsj76eXLo8UBFb/vBLHNv2+joDomiB+UbnkVM9TdsK0m7lblxWt6B 6oExXGsYH+JaIxkGHT9I3acQfBkt87J1a7v7KA9c7oKFrqzL93BkmMKymLHXlB6lIlS9PjvcU kTX4IjI830ageJOItS7Am57acJhdphv74SPjFyxstMezbifF1cU3CQyyRyEXzyHtBvmioAvqL tJ+Jrbki58KIFM9H22rpTbsBCfH6HjFI634PyyKv+2O17k1jWVU4rcBwBgcNjFyElgk2M06Qf 8PaRm6VSVTEPyokj+O3hxSHWY8GWaEjoYIWJajPwLI1IgSrzx2oS64j3yDJR4lj9/BWnOQ1vo ep4t6AFkPQIU5bk6zz0sI+xka7u99aJkyzOxUsDacqHSFpUB+tCS8G64TxQ300jJxjixU83K/ 5+T+tk6dY9B0RRMliF45sI6R8XQV37q/gUek07GEajqFC/3eeCHEhJbEyA7j5DyhpDxnJHPKu 7hI7Yc2g2lJuS5XT/O0Rm+oJFtODQR2+leI/0FrvCoJ90t47xAK+Ww5J+U/eO3DLGevelfBxU 01H5mckHcTCQaO8YyZNYKZZQDQesNGEkePochGnUNK/mwxGJEeRuyoFdhYtcHw/sYGREPagnq BZITwIevee2LRMpMp8yjCHPetXjZgnL8Vmh2fgpwXF9ahZlKNq4wCKZ/F589Ivz4c96xhCTKP IWPKlgtSH97U36vAGUeg3+e/po+yShN8oXzXzAIhxLvf16SUEMhlDAmw00TH2z3biHnCW1piV YuWvIuMDi/BU74Pn/w8xRgjWTkE= Precedence: bulk List-ID: X-Mailing-List: linux-hwmon@vger.kernel.org Thanks to bugreport 216655 on bugzilla triggered by the dell-smm-hwmon driver, the contents of the sensor buffers could be almost completely decoded. Add an hwmon interface for exposing the fan and thermal sensor values. Since the WMI interface can be quite slow on some machines, the sensor buffers are cached for 1 second to lessen the performance impact. The debugfs interface remains in place to aid in reverse-engineering of unknown sensor types and the thermal buffer. Tested-by: Antonín Skala Tested-by: Gustavo Walbon Signed-off-by: Armin Wolf Reviewed-by: Guenter Roeck --- drivers/platform/x86/dell/Kconfig | 8 +- drivers/platform/x86/dell/dell-wmi-ddv.c | 490 ++++++++++++++++++++++- 2 files changed, 493 insertions(+), 5 deletions(-) -- 2.30.2 diff --git a/drivers/platform/x86/dell/Kconfig b/drivers/platform/x86/dell/Kconfig index d319de8f2132..bdd78076b1d7 100644 --- a/drivers/platform/x86/dell/Kconfig +++ b/drivers/platform/x86/dell/Kconfig @@ -192,12 +192,12 @@ config DELL_WMI_DESCRIPTOR config DELL_WMI_DDV tristate "Dell WMI sensors Support" default m - depends on ACPI_BATTERY depends on ACPI_WMI + depends on ACPI_BATTERY || HWMON help - This option adds support for WMI-based sensors like - battery temperature sensors found on some Dell notebooks. - It also supports reading of the battery ePPID. + This option adds support for WMI-based fan and thermal sensors + found on some Dell notebooks. It also supports various WMI-based battery + extras like reading of the battery temperature and ePPID. To compile this drivers as a module, choose M here: the module will be called dell-wmi-ddv. diff --git a/drivers/platform/x86/dell/dell-wmi-ddv.c b/drivers/platform/x86/dell/dell-wmi-ddv.c index 9695bf493ea6..d81dc4dd93e3 100644 --- a/drivers/platform/x86/dell/dell-wmi-ddv.c +++ b/drivers/platform/x86/dell/dell-wmi-ddv.c @@ -12,19 +12,27 @@ #include #include #include +#include #include +#include #include #include +#include #include +#include #include +#include #include #include #include #include +#include #include #include +#include + #define DRIVER_NAME "dell-wmi-ddv" #define DELL_DDV_SUPPORTED_VERSION_MIN 2 @@ -63,13 +71,63 @@ enum dell_ddv_method { DELL_DDV_THERMAL_SENSOR_INFORMATION = 0x22, }; +struct fan_sensor_entry { + u8 type; + __le16 rpm; +} __packed; + +struct thermal_sensor_entry { + u8 type; + s8 now; + s8 min; + s8 max; + u8 unknown; +} __packed; + +struct combined_channel_info { + struct hwmon_channel_info info; + u32 config[]; +}; + +struct combined_chip_info { + struct hwmon_chip_info chip; + const struct hwmon_channel_info *info[]; +}; + +struct dell_wmi_ddv_sensors { + struct mutex lock; /* protect caching */ + unsigned long timestamp; + union acpi_object *obj; + u64 entries; +}; + struct dell_wmi_ddv_data { struct acpi_battery_hook hook; struct device_attribute temp_attr; struct device_attribute eppid_attr; + struct dell_wmi_ddv_sensors fans; + struct dell_wmi_ddv_sensors temps; struct wmi_device *wdev; }; +static const char * const fan_labels[] = { + "CPU Fan", + "Chassis Motherboard Fan", + "Video Fan", + "Power Supply Fan", + "Chipset Fan", + "Memory Fan", + "PCI Fan", + "HDD Fan", +}; + +static const char * const fan_dock_labels[] = { + "Docking Chassis/Motherboard Fan", + "Docking Video Fan", + "Docking Power Supply Fan", + "Docking Chipset Fan", +}; + static int dell_wmi_ddv_query_type(struct wmi_device *wdev, enum dell_ddv_method method, u32 arg, union acpi_object **result, acpi_object_type type) { @@ -171,6 +229,410 @@ static int dell_wmi_ddv_query_string(struct wmi_device *wdev, enum dell_ddv_meth return dell_wmi_ddv_query_type(wdev, method, arg, result, ACPI_TYPE_STRING); } +/* + * Needs to be called with lock held, except during initialization. + */ +static int dell_wmi_ddv_update_sensors(struct wmi_device *wdev, enum dell_ddv_method method, + struct dell_wmi_ddv_sensors *sensors, size_t entry_size) +{ + u64 buffer_size, rem, entries; + union acpi_object *obj; + u8 *buffer; + int ret; + + if (sensors->obj) { + if (time_before(jiffies, sensors->timestamp + HZ)) + return 0; + + kfree(sensors->obj); + sensors->obj = NULL; + } + + ret = dell_wmi_ddv_query_buffer(wdev, method, 0, &obj); + if (ret < 0) + return ret; + + /* buffer format sanity check */ + buffer_size = obj->package.elements[0].integer.value; + buffer = obj->package.elements[1].buffer.pointer; + entries = div64_u64_rem(buffer_size, entry_size, &rem); + if (rem != 1 || buffer[buffer_size - 1] != 0xff) { + ret = -ENOMSG; + goto err_free; + } + + if (!entries) { + ret = -ENODATA; + goto err_free; + } + + sensors->obj = obj; + sensors->entries = entries; + sensors->timestamp = jiffies; + + return 0; + +err_free: + kfree(obj); + + return ret; +} + +static umode_t dell_wmi_ddv_is_visible(const void *drvdata, enum hwmon_sensor_types type, u32 attr, + int channel) +{ + return 0444; +} + +static int dell_wmi_ddv_fan_read_channel(struct dell_wmi_ddv_data *data, u32 attr, int channel, + long *val) +{ + struct fan_sensor_entry *entry; + int ret; + + ret = dell_wmi_ddv_update_sensors(data->wdev, DELL_DDV_FAN_SENSOR_INFORMATION, + &data->fans, sizeof(*entry)); + if (ret < 0) + return ret; + + if (channel >= data->fans.entries) + return -ENXIO; + + entry = (struct fan_sensor_entry *)data->fans.obj->package.elements[1].buffer.pointer; + switch (attr) { + case hwmon_fan_input: + *val = get_unaligned_le16(&entry[channel].rpm); + return 0; + default: + break; + } + + return -EOPNOTSUPP; +} + +static int dell_wmi_ddv_temp_read_channel(struct dell_wmi_ddv_data *data, u32 attr, int channel, + long *val) +{ + struct thermal_sensor_entry *entry; + int ret; + + ret = dell_wmi_ddv_update_sensors(data->wdev, DELL_DDV_THERMAL_SENSOR_INFORMATION, + &data->temps, sizeof(*entry)); + if (ret < 0) + return ret; + + if (channel >= data->temps.entries) + return -ENXIO; + + entry = (struct thermal_sensor_entry *)data->temps.obj->package.elements[1].buffer.pointer; + switch (attr) { + case hwmon_temp_input: + *val = entry[channel].now * 1000; + return 0; + case hwmon_temp_min: + *val = entry[channel].min * 1000; + return 0; + case hwmon_temp_max: + *val = entry[channel].max * 1000; + return 0; + default: + break; + } + + return -EOPNOTSUPP; +} + +static int dell_wmi_ddv_read(struct device *dev, enum hwmon_sensor_types type, u32 attr, + int channel, long *val) +{ + struct dell_wmi_ddv_data *data = dev_get_drvdata(dev); + int ret; + + switch (type) { + case hwmon_fan: + mutex_lock(&data->fans.lock); + ret = dell_wmi_ddv_fan_read_channel(data, attr, channel, val); + mutex_unlock(&data->fans.lock); + return ret; + case hwmon_temp: + mutex_lock(&data->temps.lock); + ret = dell_wmi_ddv_temp_read_channel(data, attr, channel, val); + mutex_unlock(&data->temps.lock); + return ret; + default: + break; + } + + return -EOPNOTSUPP; +} + +static int dell_wmi_ddv_fan_read_string(struct dell_wmi_ddv_data *data, int channel, + const char **str) +{ + struct fan_sensor_entry *entry; + int ret; + u8 type; + + ret = dell_wmi_ddv_update_sensors(data->wdev, DELL_DDV_FAN_SENSOR_INFORMATION, + &data->fans, sizeof(*entry)); + if (ret < 0) + return ret; + + if (channel >= data->fans.entries) + return -ENXIO; + + entry = (struct fan_sensor_entry *)data->fans.obj->package.elements[1].buffer.pointer; + type = entry[channel].type; + switch (type) { + case 0x00 ... 0x07: + *str = fan_labels[type]; + break; + case 0x11 ... 0x14: + *str = fan_dock_labels[type - 0x11]; + break; + default: + *str = "Unknown Fan"; + break; + } + + return 0; +} + +static int dell_wmi_ddv_temp_read_string(struct dell_wmi_ddv_data *data, int channel, + const char **str) +{ + struct thermal_sensor_entry *entry; + int ret; + + ret = dell_wmi_ddv_update_sensors(data->wdev, DELL_DDV_THERMAL_SENSOR_INFORMATION, + &data->temps, sizeof(*entry)); + if (ret < 0) + return ret; + + if (channel >= data->temps.entries) + return -ENXIO; + + entry = (struct thermal_sensor_entry *)data->temps.obj->package.elements[1].buffer.pointer; + switch (entry[channel].type) { + case 0x00: + *str = "CPU"; + break; + case 0x11: + *str = "Video"; + break; + case 0x22: + *str = "Memory"; /* sometimes called DIMM */ + break; + case 0x33: + *str = "Other"; + break; + case 0x44: + *str = "Ambient"; /* sometimes called SKIN */ + break; + case 0x52: + *str = "SODIMM"; + break; + case 0x55: + *str = "HDD"; + break; + case 0x62: + *str = "SODIMM 2"; + break; + case 0x73: + *str = "NB"; + break; + case 0x83: + *str = "Charger"; + break; + case 0xbb: + *str = "Memory 3"; + break; + default: + *str = "Unknown"; + break; + } + + return 0; +} + +static int dell_wmi_ddv_read_string(struct device *dev, enum hwmon_sensor_types type, u32 attr, + int channel, const char **str) +{ + struct dell_wmi_ddv_data *data = dev_get_drvdata(dev); + int ret; + + switch (type) { + case hwmon_fan: + switch (attr) { + case hwmon_fan_label: + mutex_lock(&data->fans.lock); + ret = dell_wmi_ddv_fan_read_string(data, channel, str); + mutex_unlock(&data->fans.lock); + return ret; + default: + break; + } + break; + case hwmon_temp: + switch (attr) { + case hwmon_temp_label: + mutex_lock(&data->temps.lock); + ret = dell_wmi_ddv_temp_read_string(data, channel, str); + mutex_unlock(&data->temps.lock); + return ret; + default: + break; + } + break; + default: + break; + } + + return -EOPNOTSUPP; +} + +static const struct hwmon_ops dell_wmi_ddv_ops = { + .is_visible = dell_wmi_ddv_is_visible, + .read = dell_wmi_ddv_read, + .read_string = dell_wmi_ddv_read_string, +}; + +static struct hwmon_channel_info *dell_wmi_ddv_channel_create(struct device *dev, u64 count, + enum hwmon_sensor_types type, + u32 config) +{ + struct combined_channel_info *cinfo; + int i; + + cinfo = devm_kzalloc(dev, struct_size(cinfo, config, count + 1), GFP_KERNEL); + if (!cinfo) + return ERR_PTR(-ENOMEM); + + cinfo->info.type = type; + cinfo->info.config = cinfo->config; + + for (i = 0; i < count; i++) + cinfo->config[i] = config; + + return &cinfo->info; +} + +static void dell_wmi_ddv_hwmon_cache_invalidate(struct dell_wmi_ddv_sensors *sensors) +{ + mutex_lock(&sensors->lock); + kfree(sensors->obj); + sensors->obj = NULL; + mutex_unlock(&sensors->lock); +} + +static void dell_wmi_ddv_hwmon_cache_destroy(void *data) +{ + struct dell_wmi_ddv_sensors *sensors = data; + + mutex_destroy(&sensors->lock); + kfree(sensors->obj); +} + +static struct hwmon_channel_info *dell_wmi_ddv_channel_init(struct wmi_device *wdev, + enum dell_ddv_method method, + struct dell_wmi_ddv_sensors *sensors, + size_t entry_size, + enum hwmon_sensor_types type, + u32 config) +{ + struct hwmon_channel_info *info; + int ret; + + ret = dell_wmi_ddv_update_sensors(wdev, method, sensors, entry_size); + if (ret < 0) + return ERR_PTR(ret); + + mutex_init(&sensors->lock); + + ret = devm_add_action_or_reset(&wdev->dev, dell_wmi_ddv_hwmon_cache_destroy, sensors); + if (ret < 0) + return ERR_PTR(ret); + + info = dell_wmi_ddv_channel_create(&wdev->dev, sensors->entries, type, config); + if (IS_ERR(info)) + devm_release_action(&wdev->dev, dell_wmi_ddv_hwmon_cache_destroy, sensors); + + return info; +} + +static int dell_wmi_ddv_hwmon_add(struct dell_wmi_ddv_data *data) +{ + struct wmi_device *wdev = data->wdev; + struct combined_chip_info *cinfo; + struct hwmon_channel_info *info; + struct device *hdev; + int index = 0; + int ret; + + if (!devres_open_group(&wdev->dev, dell_wmi_ddv_hwmon_add, GFP_KERNEL)) + return -ENOMEM; + + cinfo = devm_kzalloc(&wdev->dev, struct_size(cinfo, info, 4), GFP_KERNEL); + if (!cinfo) { + ret = -ENOMEM; + + goto err_release; + } + + cinfo->chip.ops = &dell_wmi_ddv_ops; + cinfo->chip.info = cinfo->info; + + info = dell_wmi_ddv_channel_create(&wdev->dev, 1, hwmon_chip, HWMON_C_REGISTER_TZ); + if (IS_ERR(info)) { + ret = PTR_ERR(info); + + goto err_release; + } + + cinfo->info[index] = info; + index++; + + info = dell_wmi_ddv_channel_init(wdev, DELL_DDV_FAN_SENSOR_INFORMATION, &data->fans, + sizeof(struct fan_sensor_entry), hwmon_fan, + (HWMON_F_INPUT | HWMON_F_LABEL)); + if (!IS_ERR(info)) { + cinfo->info[index] = info; + index++; + } + + info = dell_wmi_ddv_channel_init(wdev, DELL_DDV_THERMAL_SENSOR_INFORMATION, &data->temps, + sizeof(struct thermal_sensor_entry), hwmon_temp, + (HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | + HWMON_T_LABEL)); + if (!IS_ERR(info)) { + cinfo->info[index] = info; + index++; + } + + if (index < 2) { + ret = -ENODEV; + + goto err_release; + } + + hdev = devm_hwmon_device_register_with_info(&wdev->dev, "dell_ddv", data, &cinfo->chip, + NULL); + if (IS_ERR(hdev)) { + ret = PTR_ERR(hdev); + + goto err_release; + } + + devres_close_group(&wdev->dev, dell_wmi_ddv_hwmon_add); + + return 0; + +err_release: + devres_release_group(&wdev->dev, dell_wmi_ddv_hwmon_add); + + return ret; +} + static int dell_wmi_ddv_battery_index(struct acpi_device *acpi_dev, u32 *index) { const char *uid_str; @@ -370,9 +832,34 @@ static int dell_wmi_ddv_probe(struct wmi_device *wdev, const void *context) dell_wmi_ddv_debugfs_init(wdev); - return dell_wmi_ddv_battery_add(data); + if (IS_REACHABLE(CONFIG_ACPI_BATTERY)) { + ret = dell_wmi_ddv_battery_add(data); + if (ret < 0 && ret != -ENODEV) + dev_warn(&wdev->dev, "Unable to register ACPI battery hook: %d\n", ret); + } + + if (IS_REACHABLE(CONFIG_HWMON)) { + ret = dell_wmi_ddv_hwmon_add(data); + if (ret < 0 && ret != -ENODEV) + dev_warn(&wdev->dev, "Unable to register hwmon interface: %d\n", ret); + } + + return 0; } +static int dell_wmi_ddv_resume(struct device *dev) +{ + struct dell_wmi_ddv_data *data = dev_get_drvdata(dev); + + /* Force re-reading of all sensors */ + dell_wmi_ddv_hwmon_cache_invalidate(&data->fans); + dell_wmi_ddv_hwmon_cache_invalidate(&data->temps); + + return 0; +} + +static DEFINE_SIMPLE_DEV_PM_OPS(dell_wmi_ddv_dev_pm_ops, NULL, dell_wmi_ddv_resume); + static const struct wmi_device_id dell_wmi_ddv_id_table[] = { { DELL_DDV_GUID, NULL }, { } @@ -382,6 +869,7 @@ MODULE_DEVICE_TABLE(wmi, dell_wmi_ddv_id_table); static struct wmi_driver dell_wmi_ddv_driver = { .driver = { .name = DRIVER_NAME, + .pm = pm_sleep_ptr(&dell_wmi_ddv_dev_pm_ops), }, .id_table = dell_wmi_ddv_id_table, .probe = dell_wmi_ddv_probe, From patchwork Thu Feb 9 21:15:03 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Armin Wolf X-Patchwork-Id: 13135059 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id A8658C64EC5 for ; Thu, 9 Feb 2023 21:15:46 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229642AbjBIVPp (ORCPT ); Thu, 9 Feb 2023 16:15:45 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57332 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230264AbjBIVPo (ORCPT ); Thu, 9 Feb 2023 16:15:44 -0500 Received: from mout.gmx.net (mout.gmx.net [212.227.15.19]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 9D2A55777E; Thu, 9 Feb 2023 13:15:42 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=gmx.de; s=s31663417; t=1675977320; bh=Uh5RIMNU60mWcaditU9sALzJk63hb5rbJhhp4Sndz7E=; h=X-UI-Sender-Class:From:To:Cc:Subject:Date:In-Reply-To:References; b=My54Ye3S6lZwzlGKqHvfN78JsrV4+iDjsgNaxF1PVUhBQYfrMIbIgGFU1FJv3wXJ7 x6HRcf9hwNh+00X+fihbB/RPyIz9yT/WWoRRtdunfHIL4EISpI1eMszk0vvJi3hvl4 GyJHPHaLVWlBjo6qQ3OkAJOoz/4ZdscZxssRBrHYj3KhWh7dI7ACawkqMMdI7LsO1M 5oAcybRRCkMjV+js7wlf79egJaLcVjyJQa8QnDlBlvYBzQT4n0KXInbqaUp2Kll5ir ZvxaT7WGZuoBV9qD1JGIbTNcoKtz0QLUvtqNlc5qDh2D1cdCurcBsXurkvHTIQc9gC RlQzsH16HWcJA== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from esprimo-mx.users.agdsn.de ([141.30.226.129]) by mail.gmx.net (mrgmx005 [212.227.17.190]) with ESMTPSA (Nemesis) id 1N33Ed-1oRVSU3L2r-013Jgd; Thu, 09 Feb 2023 22:15:19 +0100 From: Armin Wolf To: hdegoede@redhat.com, markgross@kernel.org Cc: jdelvare@suse.com, linux@roeck-us.net, platform-driver-x86@vger.kernel.org, linux-hwmon@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH v3 2/2] platform/x86: dell-ddv: Prefer asynchronous probing Date: Thu, 9 Feb 2023 22:15:03 +0100 Message-Id: <20230209211503.2739-3-W_Armin@gmx.de> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20230209211503.2739-1-W_Armin@gmx.de> References: <20230209211503.2739-1-W_Armin@gmx.de> MIME-Version: 1.0 X-Provags-ID: V03:K1:qL+iwF8GTblNMRbnwYaDj8zDBobMGfK0qdsc8QVEoGD1dpKlD/7 C9Cxxr6EcEOSC0+1AfXpvxMWrxi5AelnMkHjL+V7T5GUR6ZA3U+oCWD195j5rN8b5AWgefq Qcp5OtfYtwVE0bo4bk3yW1VfFjYr3q4SbifAwJoZM1FwRoSKeYgkmejNBvNFy0jjLvl0vRD NWmQmad6kxs1jtEd+2YWw== UI-OutboundReport: notjunk:1;M01:P0:532347kHmx0=;oOKJTev7VB7Bp+Mx+ZTQm9Dv7KQ JgECFeY2jvPJP8C9VtI0KORLF++WKcxki8UyJwZmAP5Wvc0KqixYUh0x0w1BOAToMeB6LHZsj auHp7SLNmg9nyPLwXvhphgZziz0AoeqioSvC3jIYqCHv+HwvBUcbPES1q5uUW0j6Fs0Fs05qK itb7mAkgfLaKy4k7MtqEMl4f+335MUajgDjJ8A4gC5crx33aRsAQrYCp3tEKryS6s5sM0LCha ivmzsjVGgDKfh/ADprko44sswwx7fAL3UwXMh0PSDpyxv00Mafgr+ricOlCp3GMvMKVr1egB1 +tJtjUiypOv/wEWVvhGS61JqZHLwNMfQXA9ObyzYdr7dfncgn4PZx/dbo1+AJ+m3DQfXxMTtp cvd4tRqhPsnbSoThqiSC5O4s+2ugcRFPM4KK9cY81IzANTkO436cgjYkKEliPOBP5t/t8R6It hvaoq+PkxuY/f+v/2JIxFZ14pi5918LiyfnVu7THZfRC7irnL2pJjoLMu3N3B1ifljOj0UhjO BgNASR8WaLgyWLEGSwrL0CfDYj7YEuxbsJkIm78Em42mVtkkiCs6O4MT5yKmiK5DdHEDNs90G 7Irst69/9B2uFpCM7isMMqXdOIjl5Vl+4z1diB490LWfBrgBuOEWOLpXUIZBXpSs3NmXWVoIH awc+SzuaNNq6us9SlKA2XZ7F76VtJhAV14SEzS/bCpAHf/n5yz/wEbybzuZ5FkLjWtDzyXiQs 9F7webXNJNdzYDi15KS7WOm4RuhpfPpr91au9nvWYAlnXJGfiEWUvKrVhc1ussJIeCSiNtQ7z U8mlFp/8ZMQ31ZoAZ255Wo3zMXb7e8ORNkFakF77MdcSeSd2U2XinYJ06SApiNQ/KXLwTg5AG QEZ6L8shuJJP4I6NHoMuMcgxuXn+HJ193xoO6PB6sYSUxpZGdlz5hjwbuoHsmNRKNqoufDZ4B WBwiXBehlCuNOhYFO0KRkIlSumA= Precedence: bulk List-ID: X-Mailing-List: linux-hwmon@vger.kernel.org During probe, both sensor buffers need to be queried to initialize the hwmon channels. This might be slow on some machines, causing a unnecessary delay during boot. Mark the driver with PROBE_PREFER_ASYNCHRONOUS so that it can be probed asynchronously. Signed-off-by: Armin Wolf --- drivers/platform/x86/dell/dell-wmi-ddv.c | 2 ++ 1 file changed, 2 insertions(+) -- 2.30.2 diff --git a/drivers/platform/x86/dell/dell-wmi-ddv.c b/drivers/platform/x86/dell/dell-wmi-ddv.c index d81dc4dd93e3..d547c9d09725 100644 --- a/drivers/platform/x86/dell/dell-wmi-ddv.c +++ b/drivers/platform/x86/dell/dell-wmi-ddv.c @@ -10,6 +10,7 @@ #include #include #include +#include #include #include #include @@ -869,6 +870,7 @@ MODULE_DEVICE_TABLE(wmi, dell_wmi_ddv_id_table); static struct wmi_driver dell_wmi_ddv_driver = { .driver = { .name = DRIVER_NAME, + .probe_type = PROBE_PREFER_ASYNCHRONOUS, .pm = pm_sleep_ptr(&dell_wmi_ddv_dev_pm_ops), }, .id_table = dell_wmi_ddv_id_table,