From patchwork Sat Nov 14 15:01:00 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mark Pearson X-Patchwork-Id: 11905639 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 69122138B for ; Sat, 14 Nov 2020 15:01:28 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 56ECD206D4 for ; Sat, 14 Nov 2020 15:01:28 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726853AbgKNPB2 (ORCPT ); Sat, 14 Nov 2020 10:01:28 -0500 Received: from mail1.bemta24.messagelabs.com ([67.219.250.116]:53539 "EHLO mail1.bemta24.messagelabs.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726522AbgKNPB1 (ORCPT ); Sat, 14 Nov 2020 10:01:27 -0500 Received: from [100.112.133.178] (using TLSv1.2 with cipher DHE-RSA-AES256-GCM-SHA384 (256 bits)) by server-5.bemta.az-b.us-west-2.aws.symcld.net id D2/BF-18625-341FFAF5; Sat, 14 Nov 2020 15:01:23 +0000 X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFupnleJIrShJLcpLzFFi42JJl3vFpuv8cX2 8wcMTkhb7r0tYdC00sFh4/xSrxddvt9kt3hyfzmSxfF8/o0VTZxObxeeOySwWq/e8YLY4c/oS qwOXx6SZM5g9ds66y+7xa9saFo/NK7Q85p0M9Hi/7yqbx5ar7SwenzfJBXBEsWbmJeVXJLBmv Fs5i7Vgt3LFxZ1/2BoYN8l2MXJxCAn8Z5S4MmE+O4Tzg1HixL1m1i5GTg42AW2JLVt+sXUxcn CICMhIfFjrCVLDLNDOJLH62GM2kBphgUSJ2+vus4DUsAioSmw/yQIS5hWwkVj/Yg3YGAkBeYm Zl76zg9icQCVnuh6D1QgJqEjcf7CEDaJeUOLkzCdgcWag+uats5khbAmJgy9eMIOMlxBQkLgz oxBiZILEspd3mCcwCsxC0j0LSfcsJN0LGJlXMZolFWWmZ5TkJmbm6BoaGOgaGhrpGhob6VroJ VbpJumVFuuWpxaX6BrpJZYX6xVX5ibnpOjlpZZsYgTGU0pBC8cOxsOvP+gdYpTkYFIS5f2wen 28EF9SfkplRmJxRnxRaU5q8SFGGQ4OJQneCR+AcoJFqempFWmZOcDYhklLcPAoifCygaR5iws Sc4sz0yFSpxgVpcR520ASAiCJjNI8uDZYOrnEKCslzMvIwMAgxFOQWpSbWYIq/4pRnINRSZhX BWQKT2ZeCdz0V0CLmYAWfzBbA7K4JBEhJdXAFFR55HqwQqSdwa7cLw3LinOLZ06+wX1/zXnfi RnXXVrtVufFsbDn7pFW+bvz68+InI3PZ3m8E68qkctfwhjJd63F/8wJJ7fjpfy1s+af0Gk1Nj vg514l2vBIuNG7LdUhYZKGv/jG/2UnHuYuCXgjKvW07ca0/j2bmf9rpV++5vRu+VGZ1XMt+Z1 e3Q7b/L0hkNmicVP21qmP7to6ti3zvJAr88WLoWxDgH8CI/9z92m3eDbN5XNTev2MxUZLb+mO /28eLb1mksTZfdg4uHv//4IXtXnpwVZrYmcqnFJYZXCkKMTz9xSDkPOWa68/mB/51p/nvZtAx /nVN4sUX7odlHQ8aTQv2Nr151ob/8llSizFGYmGWsxFxYkABPbfTqIDAAA= X-Env-Sender: markpearson@lenovo.com X-Msg-Ref: server-30.tower-346.messagelabs.com!1605366080!52312!1 X-Originating-IP: [103.30.234.6] X-SYMC-ESS-Client-Auth: outbound-route-from=pass X-StarScan-Received: X-StarScan-Version: 9.60.3; banners=-,-,- X-VirusChecked: Checked Received: (qmail 768 invoked from network); 14 Nov 2020 15:01:23 -0000 Received: from unknown (HELO lenovo.com) (103.30.234.6) by server-30.tower-346.messagelabs.com with ECDHE-RSA-AES256-GCM-SHA384 encrypted SMTP; 14 Nov 2020 15:01:23 -0000 Received: from reswpmail04.lenovo.com (unknown [10.62.32.23]) (using TLSv1.2 with cipher AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by Forcepoint Email with ESMTPS id 46EE988AE034C2D8B4FC; Sat, 14 Nov 2020 23:01:18 +0800 (CST) Received: from banther-ThinkPad-X1-Carbon-Gen-8.home (10.38.56.206) by reswpmail04.lenovo.com (10.62.32.23) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.1.2044.4; Sat, 14 Nov 2020 07:01:15 -0800 From: Mark Pearson To: CC: , , , , , , , , , Subject: [PATCH v2 1/3] Documentation: Add documentation for new platform_profile sysfs attribute Date: Sat, 14 Nov 2020 10:01:00 -0500 Message-ID: <20201114150102.340618-1-markpearson@lenovo.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: References: MIME-Version: 1.0 X-Originating-IP: [10.38.56.206] X-ClientProxiedBy: reswpmail04.lenovo.com (10.62.32.23) To reswpmail04.lenovo.com (10.62.32.23) Precedence: bulk List-ID: X-Mailing-List: platform-driver-x86@vger.kernel.org On modern systems the platform performance, temperature, fan and other hardware related characteristics are often dynamically configurable. The profile is often automatically adjusted to the load by somei automatic-mechanism (which may very well live outside the kernel). These auto platform-adjustment mechanisms often can be configured with one of several 'platform-profiles', with either a bias towards low-power consumption or towards performance (and higher power consumption and thermals). Introduce a new platform_profile sysfs API which offers a generic API for selecting the performance-profile of these automatic-mechanisms. Co-developed-by: Mark Pearson Signed-off-by: Mark Pearson Signed-off-by: Hans de Goede --- Changes in v2: - updated to rst format .../ABI/testing/sysfs-platform_profile.rst | 66 +++++++++++++++++++ 1 file changed, 66 insertions(+) create mode 100644 Documentation/ABI/testing/sysfs-platform_profile.rst diff --git a/Documentation/ABI/testing/sysfs-platform_profile.rst b/Documentation/ABI/testing/sysfs-platform_profile.rst new file mode 100644 index 000000000000..5f7b2a94409b --- /dev/null +++ b/Documentation/ABI/testing/sysfs-platform_profile.rst @@ -0,0 +1,66 @@ +======================================================================= + Platform Profile Selection (e.g. /sys/firmware/acpi/platform_profile) +======================================================================= + + +On modern systems the platform performance, temperature, fan and other +hardware related characteristics are often dynamically configurable. The +profile is often automatically adjusted to the load by some +automatic mechanism (which may very well live outside the kernel). + +These auto platform adjustment mechanisms often can be configured with +one of several platform profiles, with either a bias towards low power +operation or towards performance. + +The purpose of the platform_profile attribute is to offer a generic sysfs +API for selecting the platform profile of these automatic mechanisms. + +Note that this API is only for selecting the platform profile, it is +NOT a goal of this API to allow monitoring the resulting performance +characteristics. Monitoring performance is best done with device/vendor +specific tools such as e.g. turbostat. + +Specifically when selecting a high performance profile the actual achieved +performance may be limited by various factors such as: the heat generated +by other components, room temperature, free air flow at the bottom of a +laptop, etc. It is explicitly NOT a goal of this API to let userspace know +about any sub-optimal conditions which are impeding reaching the requested +performance level. + +Since numbers on their own cannot represent the multiple variables that a +profile will adjust (power consumption, heat generation, etc) this API +uses strings to describe the various profiles. To make sure that userspace +gets a consistent experience this API document defines a fixed set of +profile names. Drivers *must* map their internal profile representation +onto this fixed set. + + +If there is no good match when mapping then a new profile name may be +added. Drivers which wish to introduce new profile names must: + + 1. Explain why the existing profile names canot be used. + 2. Add the new profile name, along with a clear description of the + expected behaviour, to the documentation. + +:What: /sys/firmware/acpi/platform_profile_choices +:Date: October 2020 +:Contact: Hans de Goede +:Description: This file contains a space-separated list of profiles supported for this device. + + Drivers must use the following standard profile-names:: + + low-power: Low power consumption + cool: Cooler operation + quiet: Quieter operation + balanced: Balance between low power consumption and performance + performance: High performance operation + + Userspace may expect drivers to offer more than one of these + standard profile names. + +:What: /sys/firmware/acpi/platform_profile +:Date: October 2020 +:Contact: Hans de Goede +:Description: Reading this file gives the current selected profile for this + device. Writing this file with one of the strings from + available_profiles changes the profile to the new value. From patchwork Sat Nov 14 15:01:01 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mark Pearson X-Patchwork-Id: 11905641 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id DD64415E6 for ; Sat, 14 Nov 2020 15:01:50 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id C96D222263 for ; Sat, 14 Nov 2020 15:01:50 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726885AbgKNPBa (ORCPT ); Sat, 14 Nov 2020 10:01:30 -0500 Received: from mail1.bemta24.messagelabs.com ([67.219.250.3]:42311 "EHLO mail1.bemta24.messagelabs.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726716AbgKNPB3 (ORCPT ); Sat, 14 Nov 2020 10:01:29 -0500 Received: from [100.112.131.148] (using TLSv1.2 with cipher DHE-RSA-AES256-GCM-SHA384 (256 bits)) by server-3.bemta.az-a.us-west-2.aws.symcld.net id 65/A6-27559-641FFAF5; Sat, 14 Nov 2020 15:01:26 +0000 X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFprAKsWRWlGSWpSXmKPExsWSLveKTdf14/p 4g4d3LSz2X5ew6FpoYLHw/ilWi6/fbrNbvDk+ncli+b5+RoumziY2i88dk1ksVu95wWxx5vQl Vgcuj0kzZzB77Jx1l93j17Y1LB6bV2h5zDsZ6PF+31U2jy1X21k8Pm+SC+CIYs3MS8qvSGDNe Pp+FWvBOqeKyR8fszcw7rXoYuTiEBL4zyjxYNd5ZgjnB6PE2YczmboYOTnYBLQltmz5xdbFyM EhIiAj8WGtJ0gNs0A7k8TqY4/ZQGqEBXwkvr35wwRSwyKgKrHqhRhImFfARqL17jqwMRIC8hI zL31nB7E5BWwlVjfuBIsLCYRJXFn0nQmiXlDi5MwnLCA2M1B989bZzBC2hMTBFy+YQcZLCChI 3JlRCDEyQWLZyzvMExgFZiHpnoWkexaS7gWMzKsYzZOKMtMzSnITM3N0DQ0MdA0NjXQNjQ10z U30Eqt0E/VKi3XLU4tLdI30EsuL9Yorc5NzUvTyUks2MQIjKqWgyWsHY9ObD3qHGCU5mJREeT +sXh8vxJeUn1KZkVicEV9UmpNafIhRhoNDSYJ3wgegnGBRanpqRVpmDjC6YdISHDxKIrxsIGn e4oLE3OLMdIjUKUZFKXHeNpCEAEgiozQPrg2WUC4xykoJ8zIyMDAI8RSkFuVmlqDKv2IU52BU EuZVAZnCk5lXAjf9FdBiJqDFH8zWgCwuSURISTUwMZZN3cZ0lSc2QTJWebUr7wrRr6dLS+qrb W7u/GXDy7f+fZjor6Opl2ZeTHftnR1ftf2QzIUTKlFyS37esjXQOZZix9e6e+N/o9kmGp/nyB 6dMD/hfP+RX9vmb3IQmnh+z0Wjp5VyFSobvFdvmMmi5Wry4on3xRUbrv+51n94/lalsxuffD2 xerf2iWPfLdQDuhTTo0rDYyucOPU4FoSWFLwxqtn/QrefnUUq/Nr2/tWWYkv3CE3ln/2hdo9M Rr/ktNwr3kv19jVcWy2kwrnWyqHgqHNd/B3hxOYe/QNS63X/ze9z8VPaEBsfFjg94ATTzM7aF oPFKguXdD1RvycgMi/zxWWzHtf83lbphP98SizFGYmGWsxFxYkAc375X6MDAAA= X-Env-Sender: markpearson@lenovo.com X-Msg-Ref: server-2.tower-326.messagelabs.com!1605366083!184611!1 X-Originating-IP: [103.30.234.6] X-SYMC-ESS-Client-Auth: outbound-route-from=pass X-StarScan-Received: X-StarScan-Version: 9.60.3; banners=-,-,- X-VirusChecked: Checked Received: (qmail 17038 invoked from network); 14 Nov 2020 15:01:25 -0000 Received: from unknown (HELO lenovo.com) (103.30.234.6) by server-2.tower-326.messagelabs.com with ECDHE-RSA-AES256-GCM-SHA384 encrypted SMTP; 14 Nov 2020 15:01:25 -0000 Received: from reswpmail04.lenovo.com (unknown [10.62.32.23]) (using TLSv1.2 with cipher AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by Forcepoint Email with ESMTPS id C0713A8BADC48DEA71EC; Sat, 14 Nov 2020 23:01:20 +0800 (CST) Received: from banther-ThinkPad-X1-Carbon-Gen-8.home (10.38.56.206) by reswpmail04.lenovo.com (10.62.32.23) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.1.2044.4; Sat, 14 Nov 2020 07:01:16 -0800 From: Mark Pearson To: CC: , , , , , , , , , Subject: [PATCH v2 2/3] ACPI: platform-profile: Add platform profile support Date: Sat, 14 Nov 2020 10:01:01 -0500 Message-ID: <20201114150102.340618-2-markpearson@lenovo.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20201114150102.340618-1-markpearson@lenovo.com> References: <20201114150102.340618-1-markpearson@lenovo.com> MIME-Version: 1.0 X-Originating-IP: [10.38.56.206] X-ClientProxiedBy: reswpmail04.lenovo.com (10.62.32.23) To reswpmail04.lenovo.com (10.62.32.23) Precedence: bulk List-ID: X-Mailing-List: platform-driver-x86@vger.kernel.org This is the initial implementation of the platform-profile feature. It provides the details discussed and outlined in the sysfs-platform_profile document. Many modern systems have the ability to modify the operating profile to control aspects like fan speed, temperature and power levels. This module provides a common sysfs interface that platform modules can register against to control their individual profile options. Signed-off-by: Mark Pearson --- Changes in v2: Address (hopefully) all recommendations from review including: - reorder includes list alphabetically - make globals statics and use const as required - change profile name scanning to use full string - clean up profile name lists to remove unwanted additions - use sysfs_emit and sysfs_emit_at appropriately (much nicer!) - improve error handling. Return errors to user in all cases and use better error codes where appropriate (ENOOPSUPP) - clean up sysfs output for better readability - formatting fixes where needed - improve structure and enum names to be clearer - remove cur_profile field from structure. It is now local to the actual platform driver file (patch 3 in series) - improve checking so if future profile options are added profile_names will be updated as well. - move CONFIG option next to ACPI_THERMAL as it seemed slightly related - removed MAINTAINERS update as not appropriate (note warning message is seen when running checkpatch) Big thank you to reviewers for all the suggestions. drivers/acpi/Kconfig | 33 ++++++ drivers/acpi/Makefile | 1 + drivers/acpi/platform_profile.c | 181 ++++++++++++++++++++++++++++++++ 3 files changed, 215 insertions(+) create mode 100644 drivers/acpi/platform_profile.c diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig index edf1558c1105..73a99af5ec2c 100644 --- a/drivers/acpi/Kconfig +++ b/drivers/acpi/Kconfig @@ -326,6 +326,20 @@ config ACPI_THERMAL To compile this driver as a module, choose M here: the module will be called thermal. +config ACPI_PLATFORM_PROFILE + tristate "ACPI Platform Profile Driver" + default y + help + This driver adds support for platform-profiles on platforms that + support it. + Platform-profiles can be used to control the platform behaviour. For + example whether to operate in a lower power mode, in a higher + power performance mode or between the two. + This driver provides the sysfs interface and is used as the registration + point for platform specific drivers. + Which profiles are supported is determined on a per-platform basis and + should be obtained from the platform specific driver. + config ACPI_CUSTOM_DSDT_FILE string "Custom DSDT Table file to include" default "" @@ -538,3 +552,22 @@ config X86_PM_TIMER You should nearly always say Y here because many modern systems require this timer. + +config ACPI_PLATFORM_PROFILE + tristate "ACPI Platform Profile Driver" + default y + help + This driver adds support for platform-profiles on platforms that + support it. + + Platform-profiles can be used to control the platform behaviour. For + example whether to operate in a lower power mode, in a higher + power performance mode or between the two. + + This driver provides the sysfs interface and is used as the registration + point for platform specific drivers. + + Which profiles are supported is determined on a per-platform basis and + should be obtained from the platform specific driver. + + diff --git a/drivers/acpi/Makefile b/drivers/acpi/Makefile index 44e412506317..c64a8af106c0 100644 --- a/drivers/acpi/Makefile +++ b/drivers/acpi/Makefile @@ -78,6 +78,7 @@ obj-$(CONFIG_ACPI_PCI_SLOT) += pci_slot.o obj-$(CONFIG_ACPI_PROCESSOR) += processor.o obj-$(CONFIG_ACPI) += container.o obj-$(CONFIG_ACPI_THERMAL) += thermal.o +obj-$(CONFIG_ACPI_PLATFORM_PROFILE) += platform_profile.o obj-$(CONFIG_ACPI_NFIT) += nfit/ obj-$(CONFIG_ACPI_NUMA) += numa/ obj-$(CONFIG_ACPI) += acpi_memhotplug.o diff --git a/drivers/acpi/platform_profile.c b/drivers/acpi/platform_profile.c new file mode 100644 index 000000000000..e4bbee48c0f8 --- /dev/null +++ b/drivers/acpi/platform_profile.c @@ -0,0 +1,181 @@ +// SPDX-License-Identifier: GPL-2.0-or-later + +/* Platform profile sysfs interface */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static struct platform_profile_handler *cur_profile; +static DEFINE_MUTEX(profile_lock); + +/* Ensure the first char of each profile is unique */ +static const char * const profile_names[] = { + [profile_low] = "low-power", + [profile_cool] = "cool", + [profile_quiet] = "quiet", + [profile_balance] = "balance", + [profile_perform] = "performance", +}; +static_assert(ARRAY_SIZE(profile_names) == profile_perform+1); + +static ssize_t platform_profile_choices_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + int len = 0; + int i; + + mutex_lock(&profile_lock); + if (!cur_profile) { + mutex_unlock(&profile_lock); + return -ENODEV; + } + + if (!cur_profile->choices) { + mutex_unlock(&profile_lock); + return sysfs_emit(buf, "\n"); + } + + for (i = profile_low; i <= profile_perform; i++) { + if (cur_profile->choices & BIT(i)) { + if (len == 0) + len += sysfs_emit_at(buf, len, "%s", profile_names[i]); + else + len += sysfs_emit_at(buf, len, " %s", profile_names[i]); + } + } + len += sysfs_emit_at(buf, len, "\n"); + mutex_unlock(&profile_lock); + + return len; +} + +static ssize_t platform_profile_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + enum platform_profile_option profile; + int err; + + mutex_lock(&profile_lock); + if (!cur_profile) { + mutex_unlock(&profile_lock); + return -EOPNOTSUPP; + } + + if (!cur_profile->profile_get) { + mutex_unlock(&profile_lock); + return -EOPNOTSUPP; + } + + err = cur_profile->profile_get(&profile); + mutex_unlock(&profile_lock); + if (err < 0) + return err; + + return sysfs_emit(buf, "%s\n", profile_names[profile]); +} + +static ssize_t platform_profile_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + int err, i; + + mutex_lock(&profile_lock); + if (!cur_profile) { + mutex_unlock(&profile_lock); + return -EOPNOTSUPP; + } + + /* Scan for a matching profile */ + i = sysfs_match_string(profile_names, buf); + if (i < 0) { + mutex_unlock(&profile_lock); + return -EINVAL; + } + + if (!cur_profile->profile_set) { + mutex_unlock(&profile_lock); + return -EOPNOTSUPP; + } + + err = cur_profile->profile_set(i); + mutex_unlock(&profile_lock); + if (err) + return err; + + return count; +} + +static DEVICE_ATTR_RO(platform_profile_choices); +static DEVICE_ATTR_RW(platform_profile); + +static struct attribute *platform_profile_attrs[] = { + &dev_attr_platform_profile_choices.attr, + &dev_attr_platform_profile.attr, + NULL +}; + +static const struct attribute_group platform_profile_group = { + .attrs = platform_profile_attrs +}; + +int platform_profile_notify(void) +{ + if (!cur_profile) + return -EOPNOTSUPP; + sysfs_notify(acpi_kobj, NULL, "platform_profile"); + return 0; +} +EXPORT_SYMBOL_GPL(platform_profile_notify); + +int platform_profile_register(struct platform_profile_handler *pprof) +{ + mutex_lock(&profile_lock); + /* We can only have one active profile */ + if (cur_profile) { + mutex_unlock(&profile_lock); + return -EEXIST; + } + + cur_profile = pprof; + mutex_unlock(&profile_lock); + return sysfs_create_group(acpi_kobj, &platform_profile_group); +} +EXPORT_SYMBOL_GPL(platform_profile_register); + +int platform_profile_unregister(void) +{ + mutex_lock(&profile_lock); + sysfs_remove_group(acpi_kobj, &platform_profile_group); + cur_profile = NULL; + mutex_unlock(&profile_lock); + return 0; +} +EXPORT_SYMBOL_GPL(platform_profile_unregister); + +static int __init platform_profile_init(void) +{ + return 0; +} +module_init(platform_profile_init); + +static void __exit platform_profile_exit(void) +{ + sysfs_remove_group(acpi_kobj, &platform_profile_group); + cur_profile = NULL; +} +module_exit(platform_profile_exit); + +MODULE_AUTHOR("Mark Pearson "); +MODULE_LICENSE("GPL"); From patchwork Sat Nov 14 15:01:02 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mark Pearson X-Patchwork-Id: 11905643 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 0195116C1 for ; Sat, 14 Nov 2020 15:01:51 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id E734F22263 for ; Sat, 14 Nov 2020 15:01:50 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726889AbgKNPBc (ORCPT ); Sat, 14 Nov 2020 10:01:32 -0500 Received: from mail1.bemta23.messagelabs.com ([67.219.246.116]:5917 "EHLO mail1.bemta23.messagelabs.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726522AbgKNPBc (ORCPT ); Sat, 14 Nov 2020 10:01:32 -0500 Received: from [100.112.5.40] (using TLSv1.2 with cipher DHE-RSA-AES256-GCM-SHA384 (256 bits)) by server-5.bemta.az-c.us-east-1.aws.symcld.net id D8/73-08509-841FFAF5; Sat, 14 Nov 2020 15:01:28 +0000 X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFprFKsWRWlGSWpSXmKPExsWSLveKTdfj4/p 4g+4zihb7r0tYdC00sFh4/xSrxddvt9kt3hyfzmSxfF8/o0VTZxObxeeOySwWq/e8YLY4c/oS qwOXx6SZM5g9ds66y+7xa9saFo/NK7Q85p0M9Hi/7yqbx5ar7SwenzfJBXBEsWbmJeVXJLBmr J5mXjApsGJRz2OWBsYJzl2MXBxCAv8ZJX7svc8E4fxglLi54QxLFyMnB5uAtsSWLb/Yuhg5OE QEZCQ+rPUEqWEWaGeSWH3sMRtIjbBAoMS1W3MYQWwWAVWJr2+ms4LYvAI2Eid2HGACsSUE5CV mXvrODmJzCthKrG7cCRYXEgiTuLLoOxNEvaDEyZlPwPYyA9U3b53NDGFLSBx88YIZ5AYJAQWJ OzMKIUYmSCx7eYd5AqPALCTds5B0z0LSvYCReRWjaVJRZnpGSW5iZo6uoYGBrqGhka6ZrpmZX mKVbrJeabFuamJxia6hXmJ5sV5xZW5yTopeXmrJJkZgNKUUsDntYLz9+oPeIUZJDiYlUd4Pq9 fHC/El5adUZiQWZ8QXleakFh9ilOHgUJLgzX0PlBMsSk1PrUjLzAFGNkxagoNHSYSX7QNQmre 4IDG3ODMdInWKUZfj5Koli5iFWPLy81KlxHmdQGYIgBRllObBjYAlmUuMslLCvIwMDAxCPAWp RbmZJajyrxjFORiVhHlVQFbxZOaVwG16BXQEE9ARH8zWgBxRkoiQkmpgikva0WO/68L7tHRza XGTAzNqdBxqyy7H8jKqr3rzRIP7rl2WV2LK/63lM3V2bPSvq7HccnpuhdTKhKAJ4od32/LwtD oy8Ajvd10iKufJr3nwQ1LnjEcOu80sJnnHpv9ZKBVR1/Lg+rHpAZOubF/vKbryNOvH6cx3FqY c4HU7tK7I9IjT3CQ9iRVeOyJjD+z/+ffxusMnI9+8Y+GfbOfGaLJIV2rRot8pKb92Xaz67+ZY Zx5WdfjsapkX85v7n7C0MF4tf3ViuzOXwAILGbP7+dLOnnvf/za/GPDOf3pATwDr7tmPjnIF5 DvMtczn39a64Iu89cmXBapPIj58m6e74b/X1fczFpsVqnI9OLPzsxJLcUaioRZzUXEiAGnwbN 2tAwAA X-Env-Sender: markpearson@lenovo.com X-Msg-Ref: server-5.tower-416.messagelabs.com!1605366085!441120!1 X-Originating-IP: [103.30.234.6] X-SYMC-ESS-Client-Auth: outbound-route-from=pass X-StarScan-Received: X-StarScan-Version: 9.60.3; banners=-,-,- X-VirusChecked: Checked Received: (qmail 27313 invoked from network); 14 Nov 2020 15:01:28 -0000 Received: from unknown (HELO lenovo.com) (103.30.234.6) by server-5.tower-416.messagelabs.com with ECDHE-RSA-AES256-GCM-SHA384 encrypted SMTP; 14 Nov 2020 15:01:28 -0000 Received: from reswpmail04.lenovo.com (unknown [10.62.32.23]) (using TLSv1.2 with cipher AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by Forcepoint Email with ESMTPS id 4530B1DA39F61AD68563; Sat, 14 Nov 2020 23:01:23 +0800 (CST) Received: from banther-ThinkPad-X1-Carbon-Gen-8.home (10.38.56.206) by reswpmail04.lenovo.com (10.62.32.23) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.1.2044.4; Sat, 14 Nov 2020 07:01:17 -0800 From: Mark Pearson To: CC: , , , , , , , , , Subject: [PATCH v2 3/3] platform/x86: thinkpad_acpi: Add platform profile support Date: Sat, 14 Nov 2020 10:01:02 -0500 Message-ID: <20201114150102.340618-3-markpearson@lenovo.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20201114150102.340618-1-markpearson@lenovo.com> References: <20201114150102.340618-1-markpearson@lenovo.com> MIME-Version: 1.0 X-Originating-IP: [10.38.56.206] X-ClientProxiedBy: reswpmail04.lenovo.com (10.62.32.23) To reswpmail04.lenovo.com (10.62.32.23) Precedence: bulk List-ID: X-Mailing-List: platform-driver-x86@vger.kernel.org Add support to thinkpad_acpi for Lenovo platforms that have DYTC version 5 support or newer to use the platform profile feature. This will allow users to determine and control the platform modes between low-power, balanced operation and performance modes. Signed-off-by: Mark Pearson --- Changes in v2: Address (hopefully) all recommendations from review including: - use IS_ENABLED instead of IS_DEFINED - update driver to work with all the fixes in platform_profile update - improve error handling for invalid inputs - move tracking of current profile mode into this driver drivers/platform/x86/thinkpad_acpi.c | 278 +++++++++++++++++++++++++-- 1 file changed, 261 insertions(+), 17 deletions(-) diff --git a/drivers/platform/x86/thinkpad_acpi.c b/drivers/platform/x86/thinkpad_acpi.c index 890dda284a00..13352ccdfdaf 100644 --- a/drivers/platform/x86/thinkpad_acpi.c +++ b/drivers/platform/x86/thinkpad_acpi.c @@ -72,6 +72,7 @@ #include #include #include +#include /* ThinkPad CMOS commands */ #define TP_CMOS_VOLUME_DOWN 0 @@ -9832,10 +9833,40 @@ static struct ibm_struct lcdshadow_driver_data = { * DYTC subdriver, for the Lenovo lapmode feature */ +#define DYTC_CMD_QUERY 0 /* To get DYTC status - enable/revision */ +#define DYTC_CMD_SET 1 /* To enable/disable IC function mode */ #define DYTC_CMD_GET 2 /* To get current IC function and mode */ #define DYTC_GET_LAPMODE_BIT 17 /* Set when in lapmode */ +#define DYTC_CMD_RESET 0x1ff /* To reset back to default */ + +#define DYTC_QUERY_ENABLE_BIT 8 /* Bit 8 - 0 = disabled, 1 = enabled */ +#define DYTC_QUERY_SUBREV_BIT 16 /* Bits 16 - 27 - sub revisision */ +#define DYTC_QUERY_REV_BIT 28 /* Bits 28 - 31 - revision */ + +#define DYTC_GET_FUNCTION_BIT 8 /* Bits 8-11 - function setting */ +#define DYTC_GET_MODE_BIT 12 /* Bits 12-15 - mode setting */ +#define DYTC_GET_LAPMODE_BIT 17 /* Bit 17 - lapmode. Set when on lap */ + +#define DYTC_SET_FUNCTION_BIT 12 /* Bits 12-15 - funct setting */ +#define DYTC_SET_MODE_BIT 16 /* Bits 16-19 - mode setting */ +#define DYTC_SET_VALID_BIT 20 /* Bit 20 - 1 = on, 0 = off */ + +#define DYTC_FUNCTION_STD 0 /* Function = 0, standard mode */ +#define DYTC_FUNCTION_CQL 1 /* Function = 1, lap mode */ +#define DYTC_FUNCTION_MMC 11 /* Function = 11, desk mode */ + +#define DYTC_MODE_PERFORM 2 /* High power mode aka performance */ +#define DYTC_MODE_QUIET 3 /* low power mode aka quiet */ +#define DYTC_MODE_BALANCE 0xF /* default mode aka balance */ + +#define DYTC_DISABLE_CQL ((DYTC_MODE_BALANCE << DYTC_SET_MODE_BIT) | \ + (DYTC_FUNCTION_CQL << DYTC_SET_FUNCTION_BIT) | \ + DYTC_CMD_SET) +#define DYTC_ENABLE_CQL (DYTC_DISABLE_CQL | (1 << DYTC_SET_VALID_BIT)) static bool dytc_lapmode; +static bool dytc_available; +static bool dytc_ignore_next_event; static void dytc_lapmode_notify_change(void) { @@ -9889,22 +9920,188 @@ static ssize_t dytc_lapmode_show(struct device *dev, static DEVICE_ATTR_RO(dytc_lapmode); -static struct attribute *dytc_attributes[] = { - &dev_attr_dytc_lapmode.attr, - NULL, -}; +#if IS_ENABLED(CONFIG_ACPI_PLATFORM_PROFILE) +static struct platform_profile_handler dytc_profile; +static enum platform_profile_option dytc_current_profile; -static const struct attribute_group dytc_attr_group = { - .attrs = dytc_attributes, -}; +static int convert_dytc_to_profile(int dytcmode, enum platform_profile_option *profile) +{ + switch (dytcmode) { + case DYTC_MODE_QUIET: + *profile = profile_low; + break; + case DYTC_MODE_BALANCE: + *profile = profile_balance; + break; + case DYTC_MODE_PERFORM: + *profile = profile_perform; + break; + default: /* Unknown mode */ + return -EINVAL; + } + return 0; +} -static int tpacpi_dytc_init(struct ibm_init_struct *iibm) +static int convert_profile_to_dytc(enum platform_profile_option profile, int *perfmode) +{ + switch (profile) { + case profile_low: + *perfmode = DYTC_MODE_QUIET; + break; + case profile_balance: + *perfmode = DYTC_MODE_BALANCE; + break; + case profile_perform: + *perfmode = DYTC_MODE_PERFORM; + break; + default: /* Unknown profile */ + return -EOPNOTSUPP; + } + return 0; +} + +static int dytc_perfmode_get(int *perfmode, int *funcmode) +{ + int output, err; + + if (!dytc_available) + return -ENODEV; + + err = dytc_command(DYTC_CMD_GET, &output); + if (err) + return err; + + *funcmode = (output >> DYTC_GET_FUNCTION_BIT) & 0xF; + if (*funcmode == DYTC_FUNCTION_CQL) { + int dummy; + /* + * We can't get the mode when in CQL mode - so we disable CQL + * mode retrieve the mode and then enable it again. + * As disabling/enabling CQL triggers an event we set a flag to + * ignore these events. This will be cleared by the event handler + */ + dytc_ignore_next_event = true; + err = dytc_command(DYTC_DISABLE_CQL, &dummy); + if (err) + return err; + err = dytc_command(DYTC_CMD_GET, &output); + if (err) + return err; + /* Again ignore this event */ + dytc_ignore_next_event = true; + err = dytc_command(DYTC_ENABLE_CQL, &dummy); + if (err) + return err; + } + *perfmode = (output >> DYTC_GET_MODE_BIT) & 0xF; + return 0; +} + +/* + * dytc_profile_get: Function to register with platform_profile + * handler. Returns current platform profile. + */ +int dytc_profile_get(enum platform_profile_option *profile) { int err; + int funcmode, perfmode; + + err = dytc_perfmode_get(&perfmode, &funcmode); + if (err) + return err; - err = dytc_lapmode_get(&dytc_lapmode); - /* If support isn't available (ENODEV) then don't return an error - * but just don't create the sysfs group + /* Convert Lenovo DYTC profile to platform_profile */ + err = convert_dytc_to_profile(perfmode, profile); + if (err) + return err; + + dytc_current_profile = *profile; + return 0; +} + +/* + * dytc_profile_set: Function to register with platform_profile + * handler. Sets current platform profile. + */ +int dytc_profile_set(enum platform_profile_option profile) +{ + int cur_perfmode, cur_funcmode; + int err, dytc_set; + int output; + + if (!dytc_available) + return -ENODEV; + + if (profile == profile_balance) { + /* To get back to balance mode we just issue a reset command */ + err = dytc_command(DYTC_CMD_RESET, &output); + if (err) + return err; + } else { + int perfmode; + int err; + + err = convert_profile_to_dytc(profile, &perfmode); + if (err) + return err; + + /* Determine if we are in CQL mode. This alters the commands we do */ + err = dytc_perfmode_get(&cur_perfmode, &cur_funcmode); + if (err) + return err; + + if (cur_funcmode == DYTC_FUNCTION_CQL) { + /* To set the mode we need to disable CQL first*/ + dytc_ignore_next_event = true; /* Ignore event */ + err = dytc_command(DYTC_DISABLE_CQL, &output); + if (err) + return err; + } + dytc_set = (1 << DYTC_SET_VALID_BIT) | + (DYTC_FUNCTION_MMC << DYTC_SET_FUNCTION_BIT) | + (perfmode << DYTC_SET_MODE_BIT) | + DYTC_CMD_SET; + err = dytc_command(dytc_set, &output); + if (err) + return err; + if (cur_funcmode == DYTC_FUNCTION_CQL) { + dytc_ignore_next_event = true; /* Ignore event */ + err = dytc_command(DYTC_ENABLE_CQL, &output); + if (err) + return err; + } + } + /* Success - update current profile */ + dytc_current_profile = profile; + return 0; +} + +static void dytc_profile_refresh(void) +{ + enum platform_profile_option profile; + int perfmode, funcmode; + int err; + + err = dytc_perfmode_get(&perfmode, &funcmode); + if (err) + return; + + err = convert_dytc_to_profile(perfmode, &profile); + if (profile != dytc_current_profile) { + dytc_current_profile = profile; + platform_profile_notify(); + } +} +#endif + +static int tpacpi_dytc_init(struct ibm_init_struct *iibm) +{ + int err, output; + + err = dytc_command(DYTC_CMD_QUERY, &output); + /* + * If support isn't available (ENODEV) then don't return an error + * and don't create the sysfs group */ if (err == -ENODEV) return 0; @@ -9912,14 +10109,54 @@ static int tpacpi_dytc_init(struct ibm_init_struct *iibm) if (err) return err; - /* Platform supports this feature - create the group */ - err = sysfs_create_group(&tpacpi_pdev->dev.kobj, &dytc_attr_group); - return err; + /* Check DYTC is enabled and supports mode setting */ + dytc_available = false; + dytc_ignore_next_event = false; + + if (output & BIT(DYTC_QUERY_ENABLE_BIT)) { + /* Only DYTC v5.0 and later has this feature. */ + int dytc_version; + + dytc_version = (output >> DYTC_QUERY_REV_BIT) & 0xF; + if (dytc_version >= 5) { + dbg_printk(TPACPI_DBG_INIT, + "DYTC version %d: thermal mode available\n", dytc_version); + dytc_available = true; +#if IS_ENABLED(CONFIG_ACPI_PLATFORM_PROFILE) + /* Create platform_profile structure and register */ + dytc_profile.choices = (1 << profile_low) | + (1 << profile_balance) | + (1 << profile_perform); + dytc_profile.profile_get = dytc_profile_get; + dytc_profile.profile_set = dytc_profile_set; + err = platform_profile_register(&dytc_profile); + /* + * If for some reason platform_profiles aren't enabled + * don't quit terminally. + */ + if (err) + return 0; +#endif + /* + * Note - this has been deprecated by the input sensor implementation, + * but can't be removed until we confirm user space is no longer using + */ + dytc_lapmode_get(&dytc_lapmode); + return device_create_file(&tpacpi_pdev->dev, &dev_attr_dytc_lapmode); + } + } + return 0; } static void dytc_exit(void) { - sysfs_remove_group(&tpacpi_pdev->dev.kobj, &dytc_attr_group); + if (dytc_available) { + device_remove_file(&tpacpi_pdev->dev, &dev_attr_dytc_lapmode); +#if IS_ENABLED(CONFIG_ACPI_PLATFORM_PROFILE) + platform_profile_unregister(); +#endif + dytc_available = false; + } } static struct ibm_struct dytc_driver_data = { @@ -10103,8 +10340,15 @@ static void tpacpi_driver_event(const unsigned int hkey_event) } if (hkey_event == TP_HKEY_EV_THM_CSM_COMPLETED) { - dytc_lapmode_refresh(); - lapsensor_refresh(); + if (dytc_ignore_next_event) + dytc_ignore_next_event = false; /*clear setting*/ + else { + dytc_lapmode_refresh(); +#if IS_ENABLED(CONFIG_ACPI_PLATFORM_PROFILE) + dytc_profile_refresh(); +#endif + lapsensor_refresh(); + } } }