* [PATCH v2 1/7] thermal: int340x: processor_thermal: Move mailbox code to common module
2023-07-17 19:53 [PATCH v2 0/7] thermal: processor_thermal: Suport workload hint Srinivas Pandruvada
@ 2023-07-17 19:53 ` Srinivas Pandruvada
2023-07-17 19:54 ` [PATCH v2 2/7] thermal: int340x: processor_thermal: Add interrupt configuration Srinivas Pandruvada
` (5 subsequent siblings)
6 siblings, 0 replies; 11+ messages in thread
From: Srinivas Pandruvada @ 2023-07-17 19:53 UTC (permalink / raw)
To: daniel.lezcano, rafael, rui.zhang
Cc: linux-pm, linux-kernel, Srinivas Pandruvada
The processor thermal mailbox is used for workload type request and
also in the processor thermal RFIM module. So, move the workload type
request code to its own module from the current processor thermal
mailbox module.
processor_thermal_mailbox.c contains only mailbox read/write related
source code. The source related to workload_types requests is moved to
a module processor_thermal_wlt_req.c.
In addition
-Rename PROC_THERMAL_FEATURE_MBOX to PROC_THERMAL_FEATURE_WLT_REQ.
- proc_thermal_mbox_add(), which adds workload type sysfs attribute group
is renamed to proc_thermal_wlt_req_add().
-proc_thermal_mbox_remove() is renamed to proc_thermal_wlt_req_remove().
While here, resolve check patch warnings for 100 columns for only modified
lines.
No functional changes are expected.
Signed-off-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
Reviewed-by: Zhang Rui <rui.zhang@intel.com>
---
v2:
Removed extra blank line at the end of proc_thermal_wlt_req_remove()
.../thermal/intel/int340x_thermal/Makefile | 1 +
.../processor_thermal_device.c | 8 +-
.../processor_thermal_device.h | 12 +-
.../processor_thermal_device_pci.c | 10 +-
.../processor_thermal_device_pci_legacy.c | 3 +-
.../int340x_thermal/processor_thermal_mbox.c | 130 -----------------
.../processor_thermal_wlt_req.c | 136 ++++++++++++++++++
7 files changed, 159 insertions(+), 141 deletions(-)
create mode 100644 drivers/thermal/intel/int340x_thermal/processor_thermal_wlt_req.c
diff --git a/drivers/thermal/intel/int340x_thermal/Makefile b/drivers/thermal/intel/int340x_thermal/Makefile
index 4e852ce4a5d5..76e053e541f0 100644
--- a/drivers/thermal/intel/int340x_thermal/Makefile
+++ b/drivers/thermal/intel/int340x_thermal/Makefile
@@ -10,5 +10,6 @@ obj-$(CONFIG_INT340X_THERMAL) += processor_thermal_device_pci.o
obj-$(CONFIG_PROC_THERMAL_MMIO_RAPL) += processor_thermal_rapl.o
obj-$(CONFIG_INT340X_THERMAL) += processor_thermal_rfim.o
obj-$(CONFIG_INT340X_THERMAL) += processor_thermal_mbox.o
+obj-$(CONFIG_INT340X_THERMAL) += processor_thermal_wlt_req.o
obj-$(CONFIG_INT3406_THERMAL) += int3406_thermal.o
obj-$(CONFIG_ACPI_THERMAL_REL) += acpi_thermal_rel.o
diff --git a/drivers/thermal/intel/int340x_thermal/processor_thermal_device.c b/drivers/thermal/intel/int340x_thermal/processor_thermal_device.c
index 3ca0a2f5937f..48f6c72b05f6 100644
--- a/drivers/thermal/intel/int340x_thermal/processor_thermal_device.c
+++ b/drivers/thermal/intel/int340x_thermal/processor_thermal_device.c
@@ -346,8 +346,8 @@ int proc_thermal_mmio_add(struct pci_dev *pdev,
}
}
- if (feature_mask & PROC_THERMAL_FEATURE_MBOX) {
- ret = proc_thermal_mbox_add(pdev, proc_priv);
+ if (feature_mask & PROC_THERMAL_FEATURE_WLT_REQ) {
+ ret = proc_thermal_wlt_req_add(pdev, proc_priv);
if (ret) {
dev_err(&pdev->dev, "failed to add MBOX interface\n");
goto err_rem_rfim;
@@ -374,8 +374,8 @@ void proc_thermal_mmio_remove(struct pci_dev *pdev, struct proc_thermal_device *
proc_priv->mmio_feature_mask & PROC_THERMAL_FEATURE_DVFS)
proc_thermal_rfim_remove(pdev);
- if (proc_priv->mmio_feature_mask & PROC_THERMAL_FEATURE_MBOX)
- proc_thermal_mbox_remove(pdev);
+ if (proc_priv->mmio_feature_mask & PROC_THERMAL_FEATURE_WLT_REQ)
+ proc_thermal_wlt_req_remove(pdev);
}
EXPORT_SYMBOL_GPL(proc_thermal_mmio_remove);
diff --git a/drivers/thermal/intel/int340x_thermal/processor_thermal_device.h b/drivers/thermal/intel/int340x_thermal/processor_thermal_device.h
index 7acaa8f1b896..7cdeca2edc21 100644
--- a/drivers/thermal/intel/int340x_thermal/processor_thermal_device.h
+++ b/drivers/thermal/intel/int340x_thermal/processor_thermal_device.h
@@ -59,7 +59,7 @@ struct rapl_mmio_regs {
#define PROC_THERMAL_FEATURE_RAPL 0x01
#define PROC_THERMAL_FEATURE_FIVR 0x02
#define PROC_THERMAL_FEATURE_DVFS 0x04
-#define PROC_THERMAL_FEATURE_MBOX 0x08
+#define PROC_THERMAL_FEATURE_WLT_REQ 0x08
#define PROC_THERMAL_FEATURE_DLVR 0x10
#if IS_ENABLED(CONFIG_PROC_THERMAL_MMIO_RAPL)
@@ -80,8 +80,14 @@ static void __maybe_unused proc_thermal_rapl_remove(void)
int proc_thermal_rfim_add(struct pci_dev *pdev, struct proc_thermal_device *proc_priv);
void proc_thermal_rfim_remove(struct pci_dev *pdev);
-int proc_thermal_mbox_add(struct pci_dev *pdev, struct proc_thermal_device *proc_priv);
-void proc_thermal_mbox_remove(struct pci_dev *pdev);
+int proc_thermal_wlt_req_add(struct pci_dev *pdev, struct proc_thermal_device *proc_priv);
+void proc_thermal_wlt_req_remove(struct pci_dev *pdev);
+
+#define MBOX_CMD_WORKLOAD_TYPE_READ 0x0E
+#define MBOX_CMD_WORKLOAD_TYPE_WRITE 0x0F
+
+#define MBOX_DATA_BIT_AC_DC 30
+#define MBOX_DATA_BIT_VALID 31
int processor_thermal_send_mbox_read_cmd(struct pci_dev *pdev, u16 id, u64 *resp);
int processor_thermal_send_mbox_write_cmd(struct pci_dev *pdev, u16 id, u32 data);
diff --git a/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c b/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c
index 0d1e98007270..5a2bcfff0a68 100644
--- a/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c
+++ b/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c
@@ -350,9 +350,13 @@ static SIMPLE_DEV_PM_OPS(proc_thermal_pci_pm, proc_thermal_pci_suspend,
proc_thermal_pci_resume);
static const struct pci_device_id proc_thermal_pci_ids[] = {
- { PCI_DEVICE_DATA(INTEL, ADL_THERMAL, PROC_THERMAL_FEATURE_RAPL | PROC_THERMAL_FEATURE_FIVR | PROC_THERMAL_FEATURE_DVFS | PROC_THERMAL_FEATURE_MBOX) },
- { PCI_DEVICE_DATA(INTEL, MTLP_THERMAL, PROC_THERMAL_FEATURE_RAPL | PROC_THERMAL_FEATURE_FIVR | PROC_THERMAL_FEATURE_DVFS | PROC_THERMAL_FEATURE_MBOX | PROC_THERMAL_FEATURE_DLVR) },
- { PCI_DEVICE_DATA(INTEL, RPL_THERMAL, PROC_THERMAL_FEATURE_RAPL | PROC_THERMAL_FEATURE_FIVR | PROC_THERMAL_FEATURE_DVFS | PROC_THERMAL_FEATURE_MBOX) },
+ { PCI_DEVICE_DATA(INTEL, ADL_THERMAL, PROC_THERMAL_FEATURE_RAPL |
+ PROC_THERMAL_FEATURE_FIVR | PROC_THERMAL_FEATURE_DVFS | PROC_THERMAL_FEATURE_WLT_REQ) },
+ { PCI_DEVICE_DATA(INTEL, MTLP_THERMAL, PROC_THERMAL_FEATURE_RAPL |
+ PROC_THERMAL_FEATURE_FIVR | PROC_THERMAL_FEATURE_DVFS | PROC_THERMAL_FEATURE_WLT_REQ |
+ PROC_THERMAL_FEATURE_DLVR) },
+ { PCI_DEVICE_DATA(INTEL, RPL_THERMAL, PROC_THERMAL_FEATURE_RAPL |
+ PROC_THERMAL_FEATURE_FIVR | PROC_THERMAL_FEATURE_DVFS | PROC_THERMAL_FEATURE_WLT_REQ) },
{ },
};
diff --git a/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci_legacy.c b/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci_legacy.c
index 09e032f822f3..b8c58a44fb93 100644
--- a/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci_legacy.c
+++ b/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci_legacy.c
@@ -137,7 +137,8 @@ static const struct pci_device_id proc_thermal_pci_ids[] = {
{ PCI_DEVICE_DATA(INTEL, ICL_THERMAL, PROC_THERMAL_FEATURE_RAPL) },
{ PCI_DEVICE_DATA(INTEL, JSL_THERMAL, 0) },
{ PCI_DEVICE_DATA(INTEL, SKL_THERMAL, PROC_THERMAL_FEATURE_RAPL) },
- { PCI_DEVICE_DATA(INTEL, TGL_THERMAL, PROC_THERMAL_FEATURE_RAPL | PROC_THERMAL_FEATURE_FIVR | PROC_THERMAL_FEATURE_MBOX) },
+ { PCI_DEVICE_DATA(INTEL, TGL_THERMAL, PROC_THERMAL_FEATURE_RAPL |
+ PROC_THERMAL_FEATURE_FIVR | PROC_THERMAL_FEATURE_WLT_REQ) },
{ },
};
diff --git a/drivers/thermal/intel/int340x_thermal/processor_thermal_mbox.c b/drivers/thermal/intel/int340x_thermal/processor_thermal_mbox.c
index 0b89a4340ff4..ec766c5615b7 100644
--- a/drivers/thermal/intel/int340x_thermal/processor_thermal_mbox.c
+++ b/drivers/thermal/intel/int340x_thermal/processor_thermal_mbox.c
@@ -10,18 +10,12 @@
#include <linux/io-64-nonatomic-lo-hi.h>
#include "processor_thermal_device.h"
-#define MBOX_CMD_WORKLOAD_TYPE_READ 0x0E
-#define MBOX_CMD_WORKLOAD_TYPE_WRITE 0x0F
-
#define MBOX_OFFSET_DATA 0x5810
#define MBOX_OFFSET_INTERFACE 0x5818
#define MBOX_BUSY_BIT 31
#define MBOX_RETRY_COUNT 100
-#define MBOX_DATA_BIT_VALID 31
-#define MBOX_DATA_BIT_AC_DC 30
-
static DEFINE_MUTEX(mbox_lock);
static int wait_for_mbox_ready(struct proc_thermal_device *proc_priv)
@@ -114,128 +108,4 @@ int processor_thermal_send_mbox_write_cmd(struct pci_dev *pdev, u16 id, u32 data
}
EXPORT_SYMBOL_NS_GPL(processor_thermal_send_mbox_write_cmd, INT340X_THERMAL);
-/* List of workload types */
-static const char * const workload_types[] = {
- "none",
- "idle",
- "semi_active",
- "bursty",
- "sustained",
- "battery_life",
- NULL
-};
-
-static ssize_t workload_available_types_show(struct device *dev,
- struct device_attribute *attr,
- char *buf)
-{
- int i = 0;
- int ret = 0;
-
- while (workload_types[i] != NULL)
- ret += sprintf(&buf[ret], "%s ", workload_types[i++]);
-
- ret += sprintf(&buf[ret], "\n");
-
- return ret;
-}
-
-static DEVICE_ATTR_RO(workload_available_types);
-
-static ssize_t workload_type_store(struct device *dev,
- struct device_attribute *attr,
- const char *buf, size_t count)
-{
- struct pci_dev *pdev = to_pci_dev(dev);
- char str_preference[15];
- u32 data = 0;
- ssize_t ret;
-
- ret = sscanf(buf, "%14s", str_preference);
- if (ret != 1)
- return -EINVAL;
-
- ret = match_string(workload_types, -1, str_preference);
- if (ret < 0)
- return ret;
-
- ret &= 0xff;
-
- if (ret)
- data = BIT(MBOX_DATA_BIT_VALID) | BIT(MBOX_DATA_BIT_AC_DC);
-
- data |= ret;
-
- ret = send_mbox_write_cmd(pdev, MBOX_CMD_WORKLOAD_TYPE_WRITE, data);
- if (ret)
- return false;
-
- return count;
-}
-
-static ssize_t workload_type_show(struct device *dev,
- struct device_attribute *attr,
- char *buf)
-{
- struct pci_dev *pdev = to_pci_dev(dev);
- u64 cmd_resp;
- int ret;
-
- ret = send_mbox_read_cmd(pdev, MBOX_CMD_WORKLOAD_TYPE_READ, &cmd_resp);
- if (ret)
- return false;
-
- cmd_resp &= 0xff;
-
- if (cmd_resp > ARRAY_SIZE(workload_types) - 1)
- return -EINVAL;
-
- return sprintf(buf, "%s\n", workload_types[cmd_resp]);
-}
-
-static DEVICE_ATTR_RW(workload_type);
-
-static struct attribute *workload_req_attrs[] = {
- &dev_attr_workload_available_types.attr,
- &dev_attr_workload_type.attr,
- NULL
-};
-
-static const struct attribute_group workload_req_attribute_group = {
- .attrs = workload_req_attrs,
- .name = "workload_request"
-};
-
-static bool workload_req_created;
-
-int proc_thermal_mbox_add(struct pci_dev *pdev, struct proc_thermal_device *proc_priv)
-{
- u64 cmd_resp;
- int ret;
-
- /* Check if there is a mailbox support, if fails return success */
- ret = send_mbox_read_cmd(pdev, MBOX_CMD_WORKLOAD_TYPE_READ, &cmd_resp);
- if (ret)
- return 0;
-
- ret = sysfs_create_group(&pdev->dev.kobj, &workload_req_attribute_group);
- if (ret)
- return ret;
-
- workload_req_created = true;
-
- return 0;
-}
-EXPORT_SYMBOL_GPL(proc_thermal_mbox_add);
-
-void proc_thermal_mbox_remove(struct pci_dev *pdev)
-{
- if (workload_req_created)
- sysfs_remove_group(&pdev->dev.kobj, &workload_req_attribute_group);
-
- workload_req_created = false;
-
-}
-EXPORT_SYMBOL_GPL(proc_thermal_mbox_remove);
-
MODULE_LICENSE("GPL v2");
diff --git a/drivers/thermal/intel/int340x_thermal/processor_thermal_wlt_req.c b/drivers/thermal/intel/int340x_thermal/processor_thermal_wlt_req.c
new file mode 100644
index 000000000000..0bee49c945c1
--- /dev/null
+++ b/drivers/thermal/intel/int340x_thermal/processor_thermal_wlt_req.c
@@ -0,0 +1,136 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * processor thermal device for Workload type hints
+ * update from user space
+ *
+ * Copyright (c) 2020-2023, Intel Corporation.
+ */
+
+#include <linux/pci.h>
+#include "processor_thermal_device.h"
+
+/* List of workload types */
+static const char * const workload_types[] = {
+ "none",
+ "idle",
+ "semi_active",
+ "bursty",
+ "sustained",
+ "battery_life",
+ NULL
+};
+
+static ssize_t workload_available_types_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ int i = 0;
+ int ret = 0;
+
+ while (workload_types[i] != NULL)
+ ret += sprintf(&buf[ret], "%s ", workload_types[i++]);
+
+ ret += sprintf(&buf[ret], "\n");
+
+ return ret;
+}
+
+static DEVICE_ATTR_RO(workload_available_types);
+
+static ssize_t workload_type_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct pci_dev *pdev = to_pci_dev(dev);
+ char str_preference[15];
+ u32 data = 0;
+ ssize_t ret;
+
+ ret = sscanf(buf, "%14s", str_preference);
+ if (ret != 1)
+ return -EINVAL;
+
+ ret = match_string(workload_types, -1, str_preference);
+ if (ret < 0)
+ return ret;
+
+ ret &= 0xff;
+
+ if (ret)
+ data = BIT(MBOX_DATA_BIT_VALID) | BIT(MBOX_DATA_BIT_AC_DC);
+
+ data |= ret;
+
+ ret = processor_thermal_send_mbox_write_cmd(pdev, MBOX_CMD_WORKLOAD_TYPE_WRITE, data);
+ if (ret)
+ return false;
+
+ return count;
+}
+
+static ssize_t workload_type_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct pci_dev *pdev = to_pci_dev(dev);
+ u64 cmd_resp;
+ int ret;
+
+ ret = processor_thermal_send_mbox_read_cmd(pdev, MBOX_CMD_WORKLOAD_TYPE_READ, &cmd_resp);
+ if (ret)
+ return false;
+
+ cmd_resp &= 0xff;
+
+ if (cmd_resp > ARRAY_SIZE(workload_types) - 1)
+ return -EINVAL;
+
+ return sprintf(buf, "%s\n", workload_types[cmd_resp]);
+}
+
+static DEVICE_ATTR_RW(workload_type);
+
+static struct attribute *workload_req_attrs[] = {
+ &dev_attr_workload_available_types.attr,
+ &dev_attr_workload_type.attr,
+ NULL
+};
+
+static const struct attribute_group workload_req_attribute_group = {
+ .attrs = workload_req_attrs,
+ .name = "workload_request"
+};
+
+static bool workload_req_created;
+
+int proc_thermal_wlt_req_add(struct pci_dev *pdev, struct proc_thermal_device *proc_priv)
+{
+ u64 cmd_resp;
+ int ret;
+
+ /* Check if there is a mailbox support, if fails return success */
+ ret = processor_thermal_send_mbox_read_cmd(pdev, MBOX_CMD_WORKLOAD_TYPE_READ, &cmd_resp);
+ if (ret)
+ return 0;
+
+ ret = sysfs_create_group(&pdev->dev.kobj, &workload_req_attribute_group);
+ if (ret)
+ return ret;
+
+ workload_req_created = true;
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(proc_thermal_wlt_req_add);
+
+void proc_thermal_wlt_req_remove(struct pci_dev *pdev)
+{
+ if (workload_req_created)
+ sysfs_remove_group(&pdev->dev.kobj, &workload_req_attribute_group);
+
+ workload_req_created = false;
+}
+EXPORT_SYMBOL_GPL(proc_thermal_wlt_req_remove);
+
+MODULE_IMPORT_NS(INT340X_THERMAL);
+MODULE_LICENSE("GPL");
--
2.38.1
^ permalink raw reply related [flat|nested] 11+ messages in thread* [PATCH v2 2/7] thermal: int340x: processor_thermal: Add interrupt configuration
2023-07-17 19:53 [PATCH v2 0/7] thermal: processor_thermal: Suport workload hint Srinivas Pandruvada
2023-07-17 19:53 ` [PATCH v2 1/7] thermal: int340x: processor_thermal: Move mailbox code to common module Srinivas Pandruvada
@ 2023-07-17 19:54 ` Srinivas Pandruvada
2023-07-17 19:54 ` [PATCH v2 3/7] thermal: int340x: processor_thermal: Use non MSI interrupts Srinivas Pandruvada
` (4 subsequent siblings)
6 siblings, 0 replies; 11+ messages in thread
From: Srinivas Pandruvada @ 2023-07-17 19:54 UTC (permalink / raw)
To: daniel.lezcano, rafael, rui.zhang
Cc: linux-pm, linux-kernel, Srinivas Pandruvada
Some features like workload type prediction and power floor events
require interrupt support to avoid polling. Here interrupts are enabled
and disabled via sending mailbox commands. The mailbox command ID is
0x1E for read and 0x1F for write.
The interrupt configuration will require mutex protection as it involves
read-modify-write operation. Since mutex are already used in the mailbox
read/write functions: send_mbox_write_cmd() and send_mbox_read_cmd(),
there will be double locking. But, this can be avoided by moving mutexes
from mailbox read/write processing functions to the callers:
processor_thermal_send_mbox_[read|write]_cmd().
Signed-off-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
---
v2
Added additional comment in the commit log for the interrupt bit
.../processor_thermal_device.h | 2 +
.../int340x_thermal/processor_thermal_mbox.c | 85 ++++++++++++++-----
2 files changed, 68 insertions(+), 19 deletions(-)
diff --git a/drivers/thermal/intel/int340x_thermal/processor_thermal_device.h b/drivers/thermal/intel/int340x_thermal/processor_thermal_device.h
index 7cdeca2edc21..defc919cb020 100644
--- a/drivers/thermal/intel/int340x_thermal/processor_thermal_device.h
+++ b/drivers/thermal/intel/int340x_thermal/processor_thermal_device.h
@@ -91,6 +91,8 @@ void proc_thermal_wlt_req_remove(struct pci_dev *pdev);
int processor_thermal_send_mbox_read_cmd(struct pci_dev *pdev, u16 id, u64 *resp);
int processor_thermal_send_mbox_write_cmd(struct pci_dev *pdev, u16 id, u32 data);
+int processor_thermal_mbox_interrupt_config(struct pci_dev *pdev, bool enable, int enable_bit,
+ int time_window);
int proc_thermal_add(struct device *dev, struct proc_thermal_device *priv);
void proc_thermal_remove(struct proc_thermal_device *proc_priv);
int proc_thermal_suspend(struct device *dev);
diff --git a/drivers/thermal/intel/int340x_thermal/processor_thermal_mbox.c b/drivers/thermal/intel/int340x_thermal/processor_thermal_mbox.c
index ec766c5615b7..7ef0af3f5bef 100644
--- a/drivers/thermal/intel/int340x_thermal/processor_thermal_mbox.c
+++ b/drivers/thermal/intel/int340x_thermal/processor_thermal_mbox.c
@@ -45,23 +45,16 @@ static int send_mbox_write_cmd(struct pci_dev *pdev, u16 id, u32 data)
int ret;
proc_priv = pci_get_drvdata(pdev);
-
- mutex_lock(&mbox_lock);
-
ret = wait_for_mbox_ready(proc_priv);
if (ret)
- goto unlock_mbox;
+ return ret;
writel(data, (proc_priv->mmio_base + MBOX_OFFSET_DATA));
/* Write command register */
reg_data = BIT_ULL(MBOX_BUSY_BIT) | id;
writel(reg_data, (proc_priv->mmio_base + MBOX_OFFSET_INTERFACE));
- ret = wait_for_mbox_ready(proc_priv);
-
-unlock_mbox:
- mutex_unlock(&mbox_lock);
- return ret;
+ return wait_for_mbox_ready(proc_priv);
}
static int send_mbox_read_cmd(struct pci_dev *pdev, u16 id, u64 *resp)
@@ -71,12 +64,9 @@ static int send_mbox_read_cmd(struct pci_dev *pdev, u16 id, u64 *resp)
int ret;
proc_priv = pci_get_drvdata(pdev);
-
- mutex_lock(&mbox_lock);
-
ret = wait_for_mbox_ready(proc_priv);
if (ret)
- goto unlock_mbox;
+ return ret;
/* Write command register */
reg_data = BIT_ULL(MBOX_BUSY_BIT) | id;
@@ -84,28 +74,85 @@ static int send_mbox_read_cmd(struct pci_dev *pdev, u16 id, u64 *resp)
ret = wait_for_mbox_ready(proc_priv);
if (ret)
- goto unlock_mbox;
+ return ret;
if (id == MBOX_CMD_WORKLOAD_TYPE_READ)
*resp = readl(proc_priv->mmio_base + MBOX_OFFSET_DATA);
else
*resp = readq(proc_priv->mmio_base + MBOX_OFFSET_DATA);
-unlock_mbox:
- mutex_unlock(&mbox_lock);
- return ret;
+ return 0;
}
int processor_thermal_send_mbox_read_cmd(struct pci_dev *pdev, u16 id, u64 *resp)
{
- return send_mbox_read_cmd(pdev, id, resp);
+ int ret;
+
+ mutex_lock(&mbox_lock);
+ ret = send_mbox_read_cmd(pdev, id, resp);
+ mutex_unlock(&mbox_lock);
+
+ return ret;
}
EXPORT_SYMBOL_NS_GPL(processor_thermal_send_mbox_read_cmd, INT340X_THERMAL);
int processor_thermal_send_mbox_write_cmd(struct pci_dev *pdev, u16 id, u32 data)
{
- return send_mbox_write_cmd(pdev, id, data);
+ int ret;
+
+ mutex_lock(&mbox_lock);
+ ret = send_mbox_write_cmd(pdev, id, data);
+ mutex_unlock(&mbox_lock);
+
+ return ret;
}
EXPORT_SYMBOL_NS_GPL(processor_thermal_send_mbox_write_cmd, INT340X_THERMAL);
+#define MBOX_CAMARILLO_RD_INTR_CONFIG 0x1E
+#define MBOX_CAMARILLO_WR_INTR_CONFIG 0x1F
+#define WLT_TW_MASK GENMASK_ULL(30, 24)
+#define SOC_PREDICTION_TW_SHIFT 24
+
+int processor_thermal_mbox_interrupt_config(struct pci_dev *pdev, bool enable,
+ int enable_bit, int time_window)
+{
+ u64 data;
+ int ret;
+
+ if (!pdev)
+ return -ENODEV;
+
+ mutex_lock(&mbox_lock);
+
+ /* Do read modify write for MBOX_CAMARILLO_RD_INTR_CONFIG */
+
+ ret = send_mbox_read_cmd(pdev, MBOX_CAMARILLO_RD_INTR_CONFIG, &data);
+ if (ret) {
+ dev_err(&pdev->dev, "MBOX_CAMARILLO_RD_INTR_CONFIG failed\n");
+ goto unlock;
+ }
+
+ if (time_window >= 0) {
+ data &= ~WLT_TW_MASK;
+
+ /* Program notification delay */
+ data |= (time_window << SOC_PREDICTION_TW_SHIFT);
+ }
+
+ if (enable)
+ data |= BIT(enable_bit);
+ else
+ data &= ~BIT(enable_bit);
+
+ ret = send_mbox_write_cmd(pdev, MBOX_CAMARILLO_WR_INTR_CONFIG, data);
+ if (ret)
+ dev_err(&pdev->dev, "MBOX_CAMARILLO_WR_INTR_CONFIG failed\n");
+
+unlock:
+ mutex_unlock(&mbox_lock);
+
+ return ret;
+}
+EXPORT_SYMBOL_NS_GPL(processor_thermal_mbox_interrupt_config, INT340X_THERMAL);
+
MODULE_LICENSE("GPL v2");
--
2.38.1
^ permalink raw reply related [flat|nested] 11+ messages in thread* [PATCH v2 3/7] thermal: int340x: processor_thermal: Use non MSI interrupts
2023-07-17 19:53 [PATCH v2 0/7] thermal: processor_thermal: Suport workload hint Srinivas Pandruvada
2023-07-17 19:53 ` [PATCH v2 1/7] thermal: int340x: processor_thermal: Move mailbox code to common module Srinivas Pandruvada
2023-07-17 19:54 ` [PATCH v2 2/7] thermal: int340x: processor_thermal: Add interrupt configuration Srinivas Pandruvada
@ 2023-07-17 19:54 ` Srinivas Pandruvada
2023-08-17 20:08 ` Rafael J. Wysocki
2023-07-17 19:54 ` [PATCH v2 4/7] thermal/drivers/int340x: Remove PROC_THERMAL_FEATURE_WLT_REQ for Meteor Lake Srinivas Pandruvada
` (3 subsequent siblings)
6 siblings, 1 reply; 11+ messages in thread
From: Srinivas Pandruvada @ 2023-07-17 19:54 UTC (permalink / raw)
To: daniel.lezcano, rafael, rui.zhang
Cc: linux-pm, linux-kernel, Srinivas Pandruvada
There are issues in using MSI interrupts for processor thermal device.
The support is not consistent across generations. But the legacy PCI
interrupts work on all current generations.
Hence always use legacy PCI interrupts by default, instead of MSI.
Add a module param to use of MSI, so that MSI can be still used.
Signed-off-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
---
v2:
Changed msi_enabled to type bool
.../processor_thermal_device_pci.c | 33 ++++++++++++-------
1 file changed, 22 insertions(+), 11 deletions(-)
diff --git a/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c b/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c
index 5a2bcfff0a68..2be9b7f660d1 100644
--- a/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c
+++ b/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c
@@ -15,6 +15,11 @@
#define DRV_NAME "proc_thermal_pci"
+static bool msi_enabled;
+module_param(msi_enabled, bool, 0644);
+MODULE_PARM_DESC(msi_enabled,
+ "Use PCI MSI based interrupts for processor thermal device.");
+
struct proc_thermal_pci {
struct pci_dev *pdev;
struct proc_thermal_device *proc_priv;
@@ -219,8 +224,6 @@ static int proc_thermal_pci_probe(struct pci_dev *pdev, const struct pci_device_
return ret;
}
- pci_set_master(pdev);
-
INIT_DELAYED_WORK(&pci_info->work, proc_thermal_threshold_work_fn);
ret = proc_thermal_add(&pdev->dev, proc_priv);
@@ -248,16 +251,23 @@ static int proc_thermal_pci_probe(struct pci_dev *pdev, const struct pci_device_
goto err_ret_mmio;
}
- /* request and enable interrupt */
- ret = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_ALL_TYPES);
- if (ret < 0) {
- dev_err(&pdev->dev, "Failed to allocate vectors!\n");
- goto err_ret_tzone;
- }
- if (!pdev->msi_enabled && !pdev->msix_enabled)
+ if (msi_enabled) {
+ pci_set_master(pdev);
+ /* request and enable interrupt */
+ ret = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_ALL_TYPES);
+ if (ret < 0) {
+ dev_err(&pdev->dev, "Failed to allocate vectors!\n");
+ goto err_ret_tzone;
+ }
+ if (!pdev->msi_enabled && !pdev->msix_enabled)
+ irq_flag = IRQF_SHARED;
+
+ irq = pci_irq_vector(pdev, 0);
+ } else {
irq_flag = IRQF_SHARED;
+ irq = pdev->irq;
+ }
- irq = pci_irq_vector(pdev, 0);
ret = devm_request_threaded_irq(&pdev->dev, irq,
proc_thermal_irq_handler, NULL,
irq_flag, KBUILD_MODNAME, pci_info);
@@ -273,7 +283,8 @@ static int proc_thermal_pci_probe(struct pci_dev *pdev, const struct pci_device_
return 0;
err_free_vectors:
- pci_free_irq_vectors(pdev);
+ if (msi_enabled)
+ pci_free_irq_vectors(pdev);
err_ret_tzone:
thermal_zone_device_unregister(pci_info->tzone);
err_ret_mmio:
--
2.38.1
^ permalink raw reply related [flat|nested] 11+ messages in thread* Re: [PATCH v2 3/7] thermal: int340x: processor_thermal: Use non MSI interrupts
2023-07-17 19:54 ` [PATCH v2 3/7] thermal: int340x: processor_thermal: Use non MSI interrupts Srinivas Pandruvada
@ 2023-08-17 20:08 ` Rafael J. Wysocki
0 siblings, 0 replies; 11+ messages in thread
From: Rafael J. Wysocki @ 2023-08-17 20:08 UTC (permalink / raw)
To: Srinivas Pandruvada
Cc: daniel.lezcano, rafael, rui.zhang, linux-pm, linux-kernel
On Mon, Jul 17, 2023 at 9:54 PM Srinivas Pandruvada
<srinivas.pandruvada@linux.intel.com> wrote:
>
> There are issues in using MSI interrupts for processor thermal device.
> The support is not consistent across generations. But the legacy PCI
> interrupts work on all current generations.
>
> Hence always use legacy PCI interrupts by default, instead of MSI.
> Add a module param to use of MSI, so that MSI can be still used.
So I would prefer the subject of this patch to say "Use non-MSI
interrupts by default". Otherwise it suggests that it won't be
possible to use MSIs at all.
> Signed-off-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
> ---
> v2:
> Changed msi_enabled to type bool
>
> .../processor_thermal_device_pci.c | 33 ++++++++++++-------
> 1 file changed, 22 insertions(+), 11 deletions(-)
>
> diff --git a/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c b/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c
> index 5a2bcfff0a68..2be9b7f660d1 100644
> --- a/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c
> +++ b/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c
> @@ -15,6 +15,11 @@
>
> #define DRV_NAME "proc_thermal_pci"
>
> +static bool msi_enabled;
> +module_param(msi_enabled, bool, 0644);
> +MODULE_PARM_DESC(msi_enabled,
> + "Use PCI MSI based interrupts for processor thermal device.");
I think that "use_msi" would be a better name for this switch.
> +
> struct proc_thermal_pci {
> struct pci_dev *pdev;
> struct proc_thermal_device *proc_priv;
> @@ -219,8 +224,6 @@ static int proc_thermal_pci_probe(struct pci_dev *pdev, const struct pci_device_
> return ret;
> }
>
> - pci_set_master(pdev);
> -
How is this change related to the rest of the patch?
> INIT_DELAYED_WORK(&pci_info->work, proc_thermal_threshold_work_fn);
>
> ret = proc_thermal_add(&pdev->dev, proc_priv);
> @@ -248,16 +251,23 @@ static int proc_thermal_pci_probe(struct pci_dev *pdev, const struct pci_device_
> goto err_ret_mmio;
> }
>
> - /* request and enable interrupt */
> - ret = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_ALL_TYPES);
> - if (ret < 0) {
> - dev_err(&pdev->dev, "Failed to allocate vectors!\n");
> - goto err_ret_tzone;
> - }
> - if (!pdev->msi_enabled && !pdev->msix_enabled)
> + if (msi_enabled) {
Shouldn't this still check the pdev MSI flags?
> + pci_set_master(pdev);
> + /* request and enable interrupt */
> + ret = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_ALL_TYPES);
> + if (ret < 0) {
> + dev_err(&pdev->dev, "Failed to allocate vectors!\n");
> + goto err_ret_tzone;
> + }
> + if (!pdev->msi_enabled && !pdev->msix_enabled)
> + irq_flag = IRQF_SHARED;
> +
> + irq = pci_irq_vector(pdev, 0);
> + } else {
> irq_flag = IRQF_SHARED;
> + irq = pdev->irq;
> + }
>
> - irq = pci_irq_vector(pdev, 0);
> ret = devm_request_threaded_irq(&pdev->dev, irq,
> proc_thermal_irq_handler, NULL,
> irq_flag, KBUILD_MODNAME, pci_info);
> @@ -273,7 +283,8 @@ static int proc_thermal_pci_probe(struct pci_dev *pdev, const struct pci_device_
> return 0;
>
> err_free_vectors:
> - pci_free_irq_vectors(pdev);
> + if (msi_enabled)
> + pci_free_irq_vectors(pdev);
> err_ret_tzone:
> thermal_zone_device_unregister(pci_info->tzone);
> err_ret_mmio:
> --
^ permalink raw reply [flat|nested] 11+ messages in thread
* [PATCH v2 4/7] thermal/drivers/int340x: Remove PROC_THERMAL_FEATURE_WLT_REQ for Meteor Lake
2023-07-17 19:53 [PATCH v2 0/7] thermal: processor_thermal: Suport workload hint Srinivas Pandruvada
` (2 preceding siblings ...)
2023-07-17 19:54 ` [PATCH v2 3/7] thermal: int340x: processor_thermal: Use non MSI interrupts Srinivas Pandruvada
@ 2023-07-17 19:54 ` Srinivas Pandruvada
2023-07-17 19:54 ` [PATCH v2 5/7] thermal: int340x: processor_thermal: Add workload type hint Srinivas Pandruvada
` (2 subsequent siblings)
6 siblings, 0 replies; 11+ messages in thread
From: Srinivas Pandruvada @ 2023-07-17 19:54 UTC (permalink / raw)
To: daniel.lezcano, rafael, rui.zhang
Cc: linux-pm, linux-kernel, Srinivas Pandruvada
Meteor Lake processor supports firmware hints for predicting workload
type. So, remove support for passing workload hints to the firmware.
Signed-off-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
Reviewed-by: Zhang Rui <rui.zhang@intel.com>
---
v2:
No change
.../intel/int340x_thermal/processor_thermal_device_pci.c | 3 +--
1 file changed, 1 insertion(+), 2 deletions(-)
diff --git a/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c b/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c
index 2be9b7f660d1..1061d1d8f38d 100644
--- a/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c
+++ b/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c
@@ -364,8 +364,7 @@ static const struct pci_device_id proc_thermal_pci_ids[] = {
{ PCI_DEVICE_DATA(INTEL, ADL_THERMAL, PROC_THERMAL_FEATURE_RAPL |
PROC_THERMAL_FEATURE_FIVR | PROC_THERMAL_FEATURE_DVFS | PROC_THERMAL_FEATURE_WLT_REQ) },
{ PCI_DEVICE_DATA(INTEL, MTLP_THERMAL, PROC_THERMAL_FEATURE_RAPL |
- PROC_THERMAL_FEATURE_FIVR | PROC_THERMAL_FEATURE_DVFS | PROC_THERMAL_FEATURE_WLT_REQ |
- PROC_THERMAL_FEATURE_DLVR) },
+ PROC_THERMAL_FEATURE_FIVR | PROC_THERMAL_FEATURE_DVFS | PROC_THERMAL_FEATURE_DLVR) },
{ PCI_DEVICE_DATA(INTEL, RPL_THERMAL, PROC_THERMAL_FEATURE_RAPL |
PROC_THERMAL_FEATURE_FIVR | PROC_THERMAL_FEATURE_DVFS | PROC_THERMAL_FEATURE_WLT_REQ) },
{ },
--
2.38.1
^ permalink raw reply related [flat|nested] 11+ messages in thread* [PATCH v2 5/7] thermal: int340x: processor_thermal: Add workload type hint
2023-07-17 19:53 [PATCH v2 0/7] thermal: processor_thermal: Suport workload hint Srinivas Pandruvada
` (3 preceding siblings ...)
2023-07-17 19:54 ` [PATCH v2 4/7] thermal/drivers/int340x: Remove PROC_THERMAL_FEATURE_WLT_REQ for Meteor Lake Srinivas Pandruvada
@ 2023-07-17 19:54 ` Srinivas Pandruvada
2023-08-18 19:34 ` Rafael J. Wysocki
2023-07-17 19:54 ` [PATCH v2 6/7] thermal/drivers/int340x: Support workload hint interrupts Srinivas Pandruvada
2023-07-17 19:54 ` [PATCH v2 7/7] selftests/thermel/intel: Add test to read workload hint Srinivas Pandruvada
6 siblings, 1 reply; 11+ messages in thread
From: Srinivas Pandruvada @ 2023-07-17 19:54 UTC (permalink / raw)
To: daniel.lezcano, rafael, rui.zhang
Cc: linux-pm, linux-kernel, Srinivas Pandruvada
Prior to Meteor Lake processor generation, user space can pass workload
type request to the firmware. Then firmware can optimize power based on
workload type. User space also uses workload type request to implement
its own heuristics.
The firmware in Meteor Lake processor generation is capable of predicting
workload type without user space. To avoid duplicate processing, the user
space can read the same workload type hint from the firmware instead of
implementing its own prediction.
This workload hint is passed from the firmware via a MMIO offset 0x5B18.
Before receiving the hint, firmware needs to be configured via a mailbox
command. This mailbox command enables interrupt and notification delay.
This notification delay can be changed from user space.
This workload hint is passed via sysfs attribute group "workload_hint".
This attribute group contains following attributes:
workload_type_enable: Enables/disables workload type hints from the
firmware.
notification_delay_ms: Notification delay in milli seconds.
workload_type_index: The current workload type index predicted by the
firmware. Refer to the documentation for meaning of each index value.
Signed-off-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
---
v2:
Update comments only
.../driver-api/thermal/intel_dptf.rst | 38 +++
.../thermal/intel/int340x_thermal/Makefile | 1 +
.../processor_thermal_device.c | 9 +
.../processor_thermal_device.h | 7 +
.../processor_thermal_device_pci.c | 3 +-
.../processor_thermal_wlt_hint.c | 238 ++++++++++++++++++
6 files changed, 295 insertions(+), 1 deletion(-)
create mode 100644 drivers/thermal/intel/int340x_thermal/processor_thermal_wlt_hint.c
diff --git a/Documentation/driver-api/thermal/intel_dptf.rst b/Documentation/driver-api/thermal/intel_dptf.rst
index 9ab4316322a1..5cba02c4c308 100644
--- a/Documentation/driver-api/thermal/intel_dptf.rst
+++ b/Documentation/driver-api/thermal/intel_dptf.rst
@@ -315,3 +315,41 @@ DPTF Fan Control
----------------------------------------
Refer to Documentation/admin-guide/acpi/fan_performance_states.rst
+
+Workload Type Hints
+----------------------------------------
+
+The firmware in Meteor Lake processor generation is capable of predicting
+workload type and pass hints to OS. These hints can be enabled and read
+from user space. User space can poll attribute "workload_type_index" for
+the current hint or can get notification when this attribute is changed.
+
+file:`/sys/bus/pci/devices/0000:00:04.0/workload_hint/`
+
+``workload_hint_enable`` (RW)
+ Enable firmware to send workload type hints from user space.
+
+``notification_delay_ms`` (RW)
+ Minimum delay in milli seconds before firmware will notify OS.
+
+``workload_type_index`` (RO)
+ Predicted workload type index.
+ The index and description on Meteor Lake processor:
+
+ 0 - Idle: System performs no tasks, power and residency are consistently
+ low for long periods of time.
+
+ 1 – Battery Life: Power is relatively low, but the processor may still be
+ actively performing a task, such as video playback for a long period of
+ time.
+
+ 2 – Sustained: Power level that is relatively high for a long period
+ of time, with very few to no periods of idleness, which will eventually
+ exhaust RAPL Power Limit 1 and 2.
+
+ 3 – Bursty: Consumes a relatively constant average amount of power,
+ however, bursts of activity interrupt periods of relative idleness.
+ The bursts are relatively short and spaced with relative idleness
+ which typically do not exhaust RAPL Power Limit 1.
+
+ 4 – Unknown: Can't classify.
diff --git a/drivers/thermal/intel/int340x_thermal/Makefile b/drivers/thermal/intel/int340x_thermal/Makefile
index 76e053e541f0..ccd0fdd23161 100644
--- a/drivers/thermal/intel/int340x_thermal/Makefile
+++ b/drivers/thermal/intel/int340x_thermal/Makefile
@@ -11,5 +11,6 @@ obj-$(CONFIG_PROC_THERMAL_MMIO_RAPL) += processor_thermal_rapl.o
obj-$(CONFIG_INT340X_THERMAL) += processor_thermal_rfim.o
obj-$(CONFIG_INT340X_THERMAL) += processor_thermal_mbox.o
obj-$(CONFIG_INT340X_THERMAL) += processor_thermal_wlt_req.o
+obj-$(CONFIG_INT340X_THERMAL) += processor_thermal_wlt_hint.o
obj-$(CONFIG_INT3406_THERMAL) += int3406_thermal.o
obj-$(CONFIG_ACPI_THERMAL_REL) += acpi_thermal_rel.o
diff --git a/drivers/thermal/intel/int340x_thermal/processor_thermal_device.c b/drivers/thermal/intel/int340x_thermal/processor_thermal_device.c
index 48f6c72b05f6..127deefbb633 100644
--- a/drivers/thermal/intel/int340x_thermal/processor_thermal_device.c
+++ b/drivers/thermal/intel/int340x_thermal/processor_thermal_device.c
@@ -352,6 +352,12 @@ int proc_thermal_mmio_add(struct pci_dev *pdev,
dev_err(&pdev->dev, "failed to add MBOX interface\n");
goto err_rem_rfim;
}
+ } else if (feature_mask & PROC_THERMAL_FEATURE_WLT_HINT) {
+ ret = proc_thermal_wlt_hint_add(pdev, proc_priv);
+ if (ret) {
+ dev_err(&pdev->dev, "failed to add WLT Hint\n");
+ goto err_rem_rfim;
+ }
}
return 0;
@@ -376,10 +382,13 @@ void proc_thermal_mmio_remove(struct pci_dev *pdev, struct proc_thermal_device *
if (proc_priv->mmio_feature_mask & PROC_THERMAL_FEATURE_WLT_REQ)
proc_thermal_wlt_req_remove(pdev);
+ else if (proc_priv->mmio_feature_mask & PROC_THERMAL_FEATURE_WLT_HINT)
+ proc_thermal_wlt_hint_remove(pdev);
}
EXPORT_SYMBOL_GPL(proc_thermal_mmio_remove);
MODULE_IMPORT_NS(INTEL_TCC);
+MODULE_IMPORT_NS(INT340X_THERMAL);
MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
MODULE_DESCRIPTION("Processor Thermal Reporting Device Driver");
MODULE_LICENSE("GPL v2");
diff --git a/drivers/thermal/intel/int340x_thermal/processor_thermal_device.h b/drivers/thermal/intel/int340x_thermal/processor_thermal_device.h
index defc919cb020..bc056712f728 100644
--- a/drivers/thermal/intel/int340x_thermal/processor_thermal_device.h
+++ b/drivers/thermal/intel/int340x_thermal/processor_thermal_device.h
@@ -61,6 +61,7 @@ struct rapl_mmio_regs {
#define PROC_THERMAL_FEATURE_DVFS 0x04
#define PROC_THERMAL_FEATURE_WLT_REQ 0x08
#define PROC_THERMAL_FEATURE_DLVR 0x10
+#define PROC_THERMAL_FEATURE_WLT_HINT 0x20
#if IS_ENABLED(CONFIG_PROC_THERMAL_MMIO_RAPL)
int proc_thermal_rapl_add(struct pci_dev *pdev, struct proc_thermal_device *proc_priv);
@@ -95,6 +96,12 @@ int processor_thermal_mbox_interrupt_config(struct pci_dev *pdev, bool enable, i
int time_window);
int proc_thermal_add(struct device *dev, struct proc_thermal_device *priv);
void proc_thermal_remove(struct proc_thermal_device *proc_priv);
+
+int proc_thermal_wlt_hint_add(struct pci_dev *pdev, struct proc_thermal_device *proc_priv);
+void proc_thermal_wlt_hint_remove(struct pci_dev *pdev);
+void proc_thermal_wlt_intr_callback(struct pci_dev *pdev, struct proc_thermal_device *proc_priv);
+bool proc_thermal_check_wlt_intr(struct proc_thermal_device *proc_priv);
+
int proc_thermal_suspend(struct device *dev);
int proc_thermal_resume(struct device *dev);
int proc_thermal_mmio_add(struct pci_dev *pdev,
diff --git a/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c b/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c
index 1061d1d8f38d..ee5a4c227d96 100644
--- a/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c
+++ b/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c
@@ -364,7 +364,8 @@ static const struct pci_device_id proc_thermal_pci_ids[] = {
{ PCI_DEVICE_DATA(INTEL, ADL_THERMAL, PROC_THERMAL_FEATURE_RAPL |
PROC_THERMAL_FEATURE_FIVR | PROC_THERMAL_FEATURE_DVFS | PROC_THERMAL_FEATURE_WLT_REQ) },
{ PCI_DEVICE_DATA(INTEL, MTLP_THERMAL, PROC_THERMAL_FEATURE_RAPL |
- PROC_THERMAL_FEATURE_FIVR | PROC_THERMAL_FEATURE_DVFS | PROC_THERMAL_FEATURE_DLVR) },
+ PROC_THERMAL_FEATURE_FIVR | PROC_THERMAL_FEATURE_DVFS | PROC_THERMAL_FEATURE_DLVR |
+ PROC_THERMAL_FEATURE_WLT_HINT) },
{ PCI_DEVICE_DATA(INTEL, RPL_THERMAL, PROC_THERMAL_FEATURE_RAPL |
PROC_THERMAL_FEATURE_FIVR | PROC_THERMAL_FEATURE_DVFS | PROC_THERMAL_FEATURE_WLT_REQ) },
{ },
diff --git a/drivers/thermal/intel/int340x_thermal/processor_thermal_wlt_hint.c b/drivers/thermal/intel/int340x_thermal/processor_thermal_wlt_hint.c
new file mode 100644
index 000000000000..09bd02cf2f7d
--- /dev/null
+++ b/drivers/thermal/intel/int340x_thermal/processor_thermal_wlt_hint.c
@@ -0,0 +1,238 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * processor thermal device for reading Workload type hints
+ * from the user space. The hints are provided by the firmware.
+ *
+ * Operation:
+ * When user space enables workload type prediction:
+ * - Use mailbox to configure:
+ * Configure notification delay
+ * Enable processor thermal device interrupt
+ * - The predicted workload type can be read from MMIO:
+ * Offset 0x5B18 shows if there was an interrupt
+ * active for change in workload type and also
+ * predicted workload type.
+ *
+ * Two interface functions are provided to call when there is a
+ * thermal device interrupt:
+ * - proc_thermal_check_wlt_intr(): Check if the interrupt is for
+ * change in workload type. Called from the interrupt context.
+ * - proc_thermal_wlt_intr_callback(): Callback for interrupt processing
+ * under thread context. This involves sending notification to user
+ * space that there is a change in the workload type.
+ *
+ * Copyright (c) 2023, Intel Corporation.
+ */
+
+#include <linux/bitfield.h>
+#include <linux/pci.h>
+#include "processor_thermal_device.h"
+
+#define SOC_WLT_RES_INT_STATUS_OFF 0x5B18
+#define SOC_WLT GENMASK_ULL(47, 40)
+
+#define SOC_WLT_PREDICTION_INT_ENABLE_BIT 23
+
+#define SOC_WLT_PREDICTION_INT_ACTIVE BIT(2)
+
+/*
+ * Closest possible to 1 Second is 1024 ms with programmed time delay
+ * of 0x0A.
+ */
+static u8 notify_delay = 0x0A;
+static u16 notify_delay_ms = 1024;
+
+/* Show current predicted workload type index */
+static ssize_t workload_type_index_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct proc_thermal_device *proc_priv;
+ struct pci_dev *pdev = to_pci_dev(dev);
+ u64 status = 0;
+ int wlt;
+
+ proc_priv = pci_get_drvdata(pdev);
+
+ status = readq(proc_priv->mmio_base + SOC_WLT_RES_INT_STATUS_OFF);
+ wlt = FIELD_GET(SOC_WLT, status);
+
+ return sysfs_emit(buf, "%d\n", wlt);
+}
+
+static DEVICE_ATTR_RO(workload_type_index);
+
+static u8 wlt_enable;
+
+static ssize_t workload_hint_enable_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ return sysfs_emit(buf, "%d\n", wlt_enable);
+}
+
+/*
+ * Enable workload type prediction by writing 1 to enable, 0 to
+ * disable
+ */
+static ssize_t workload_hint_enable_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t size)
+{
+ struct pci_dev *pdev = to_pci_dev(dev);
+ u8 mode;
+
+ if (kstrtou8(buf, 10, &mode) || mode > 1)
+ return -EINVAL;
+
+ if (mode) {
+ int ret;
+
+ ret = processor_thermal_mbox_interrupt_config(pdev, true,
+ SOC_WLT_PREDICTION_INT_ENABLE_BIT,
+ notify_delay);
+ if (ret)
+ return ret;
+ } else {
+ processor_thermal_mbox_interrupt_config(pdev, false,
+ SOC_WLT_PREDICTION_INT_ENABLE_BIT, 0);
+ }
+
+ wlt_enable = mode;
+
+ return size;
+}
+
+static DEVICE_ATTR_RW(workload_hint_enable);
+
+static ssize_t notification_delay_ms_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ return sysfs_emit(buf, "%u\n", notify_delay_ms);
+}
+
+static ssize_t notification_delay_ms_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t size)
+{
+ struct pci_dev *pdev = to_pci_dev(dev);
+ u16 new_tw;
+ int ret;
+
+ /*
+ * Time window register value:
+ * Formula: (1 + x/4) * power(2,y)
+ * x = 2 msbs, that is [30:29] y = 5 [28:24]
+ * in INTR_CONFIG register.
+ * The result will be in milli seconds.
+ * Here, just keep x = 0, and just change y.
+ * First round up the user value to power of 2 and
+ * then take log2, to get "y" value to program.
+ */
+ ret = kstrtou16(buf, 10, &new_tw);
+ if (ret)
+ return ret;
+
+ if (new_tw) {
+ u8 tm;
+
+ new_tw = roundup_pow_of_two(new_tw);
+ tm = ilog2(new_tw);
+ if (tm > 31)
+ return -EINVAL;
+
+ ret = processor_thermal_mbox_interrupt_config(pdev, true,
+ SOC_WLT_PREDICTION_INT_ENABLE_BIT,
+ tm);
+ if (ret)
+ return ret;
+
+ notify_delay = tm;
+ notify_delay_ms = new_tw;
+ } else {
+ ret = processor_thermal_mbox_interrupt_config(pdev, false,
+ SOC_WLT_PREDICTION_INT_ENABLE_BIT,
+ notify_delay);
+ if (ret)
+ return ret;
+ }
+
+ return size;
+}
+
+static DEVICE_ATTR_RW(notification_delay_ms);
+
+static struct attribute *workload_hint_attrs[] = {
+ &dev_attr_workload_type_index.attr,
+ &dev_attr_workload_hint_enable.attr,
+ &dev_attr_notification_delay_ms.attr,
+ NULL
+};
+
+static const struct attribute_group workload_hint_attribute_group = {
+ .attrs = workload_hint_attrs,
+ .name = "workload_hint"
+};
+
+/*
+ * Callback to check if the interrupt for prediction is active.
+ * Caution: Called from the interrupt context.
+ */
+bool proc_thermal_check_wlt_intr(struct proc_thermal_device *proc_priv)
+{
+ u64 int_status;
+
+ int_status = readq(proc_priv->mmio_base + SOC_WLT_RES_INT_STATUS_OFF);
+ if (int_status & SOC_WLT_PREDICTION_INT_ACTIVE)
+ return true;
+
+ return false;
+}
+EXPORT_SYMBOL_NS_GPL(proc_thermal_check_wlt_intr, INT340X_THERMAL);
+
+/* Callback to notify user space */
+void proc_thermal_wlt_intr_callback(struct pci_dev *pdev, struct proc_thermal_device *proc_priv)
+{
+ u64 status;
+
+ status = readq(proc_priv->mmio_base + SOC_WLT_RES_INT_STATUS_OFF);
+ if (status & SOC_WLT_PREDICTION_INT_ACTIVE) {
+ writeq(status & ~SOC_WLT_PREDICTION_INT_ACTIVE,
+ proc_priv->mmio_base + SOC_WLT_RES_INT_STATUS_OFF);
+ sysfs_notify(&pdev->dev.kobj, "workload_hint", "workload_type_index");
+ }
+}
+EXPORT_SYMBOL_NS_GPL(proc_thermal_wlt_intr_callback, INT340X_THERMAL);
+
+static bool workload_hint_created;
+
+int proc_thermal_wlt_hint_add(struct pci_dev *pdev, struct proc_thermal_device *proc_priv)
+{
+ int ret;
+
+ ret = sysfs_create_group(&pdev->dev.kobj, &workload_hint_attribute_group);
+ if (ret)
+ return ret;
+
+ workload_hint_created = true;
+
+ return 0;
+}
+EXPORT_SYMBOL_NS_GPL(proc_thermal_wlt_hint_add, INT340X_THERMAL);
+
+void proc_thermal_wlt_hint_remove(struct pci_dev *pdev)
+{
+ processor_thermal_mbox_interrupt_config(pdev, false,
+ SOC_WLT_PREDICTION_INT_ENABLE_BIT,
+ notify_delay);
+
+ if (workload_hint_created)
+ sysfs_remove_group(&pdev->dev.kobj, &workload_hint_attribute_group);
+
+ workload_hint_created = false;
+}
+EXPORT_SYMBOL_NS_GPL(proc_thermal_wlt_hint_remove, INT340X_THERMAL);
+
+MODULE_IMPORT_NS(INT340X_THERMAL);
+MODULE_LICENSE("GPL");
--
2.38.1
^ permalink raw reply related [flat|nested] 11+ messages in thread* Re: [PATCH v2 5/7] thermal: int340x: processor_thermal: Add workload type hint
2023-07-17 19:54 ` [PATCH v2 5/7] thermal: int340x: processor_thermal: Add workload type hint Srinivas Pandruvada
@ 2023-08-18 19:34 ` Rafael J. Wysocki
0 siblings, 0 replies; 11+ messages in thread
From: Rafael J. Wysocki @ 2023-08-18 19:34 UTC (permalink / raw)
To: Srinivas Pandruvada
Cc: daniel.lezcano, rafael, rui.zhang, linux-pm, linux-kernel
First, I would prefer the subject to be something like "thermal:
int340x: processor_thermal: Add workload type hint interface".
On Mon, Jul 17, 2023 at 9:54 PM Srinivas Pandruvada
<srinivas.pandruvada@linux.intel.com> wrote:
>
> Prior to Meteor Lake processor generation, user space can pass workload
> type request to the firmware. Then firmware can optimize power based on
> workload type. User space also uses workload type request to implement
> its own heuristics.
>
> The firmware in Meteor Lake processor generation is capable of predicting
> workload type without user space.
I would say "without user space help".
> To avoid duplicate processing, the user
> space can read the same workload type hint from the firmware instead of
> implementing its own prediction.
I think that the above is supposed to mean something like "To avoid
duplicate processing, add a sysfs interface allowing user space to
obtain the workload hint from the firmware instead of trying to
predict the workload type by itself."
> This workload hint is passed from the firmware via a MMIO offset 0x5B18.
MMIO offset in which MMIO region?
> Before receiving the hint, firmware needs to be configured via a mailbox
> command.
This is unclear. I think that the meaning of it is something like
"Before workload hints can be produced by the firmware, it needs to be
configured via a mailbox command."
> This mailbox command enables interrupt and notification delay.
"This mailbox command turns the workload hint interrupt on and causes
the firmware to take the notification delay value into account."
> This notification delay can be changed from user space.
"... from user space via sysfs."
> This workload hint is passed via sysfs attribute group "workload_hint".
"Attribute group 'workload_hint' in sysfs is used for implementing the
workload hints interface between user space and the kernel."
>
> This attribute group contains following attributes:
"it contains the following attributes:"
>
> workload_type_enable: Enables/disables workload type hints from the
> firmware.
>
> notification_delay_ms: Notification delay in milli seconds.
>
> workload_type_index: The current workload type index predicted by the
> firmware. Refer to the documentation for meaning of each index value.
"... firmware (see the documentation changes below for supported index
values and their meaning)."
> Signed-off-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
> ---
> v2:
> Update comments only
>
> .../driver-api/thermal/intel_dptf.rst | 38 +++
> .../thermal/intel/int340x_thermal/Makefile | 1 +
> .../processor_thermal_device.c | 9 +
> .../processor_thermal_device.h | 7 +
> .../processor_thermal_device_pci.c | 3 +-
> .../processor_thermal_wlt_hint.c | 238 ++++++++++++++++++
> 6 files changed, 295 insertions(+), 1 deletion(-)
> create mode 100644 drivers/thermal/intel/int340x_thermal/processor_thermal_wlt_hint.c
>
> diff --git a/Documentation/driver-api/thermal/intel_dptf.rst b/Documentation/driver-api/thermal/intel_dptf.rst
> index 9ab4316322a1..5cba02c4c308 100644
> --- a/Documentation/driver-api/thermal/intel_dptf.rst
> +++ b/Documentation/driver-api/thermal/intel_dptf.rst
> @@ -315,3 +315,41 @@ DPTF Fan Control
> ----------------------------------------
>
> Refer to Documentation/admin-guide/acpi/fan_performance_states.rst
> +
> +Workload Type Hints
> +----------------------------------------
> +
> +The firmware in Meteor Lake processor generation is capable of predicting
> +workload type and pass hints to OS. These hints can be enabled and read
"... and passing hints regarding it to the OS. A special sysfs
interface is provided to allow user space to obtain workload type
hints from the firmware and control the rate at which they are
provided."
> +from user space. User space can poll attribute "workload_type_index" for
> +the current hint or can get notification when this attribute is changed.
".. or can receive a notification whenever the value of this attribute
is updated."
> +
> +file:`/sys/bus/pci/devices/0000:00:04.0/workload_hint/`
This is important. User space needs to be able to find the PCI device
holding the workload type hints interface, so how does it do that?
> +
> +``workload_hint_enable`` (RW)
> + Enable firmware to send workload type hints from user space.
> +
> +``notification_delay_ms`` (RW)
> + Minimum delay in milli seconds before firmware will notify OS.
"milliseconds" (no space)
Also the meaning of "before firmware will notify OS" is unclear. I
think that this is about the delay between changing the workload type
prediction in the firmware and notifying the OS about the change (in
case the prediction changes again shortly, possibly back to the
previous value).
> +
> +``workload_type_index`` (RO)
> + Predicted workload type index.
> + The index and description on Meteor Lake processor:
"The supported index values and their meaning for the Meteor Lake
processor generation are as follows:"
> +
> + 0 - Idle: System performs no tasks, power and residency are consistently
What does "residency" mean here?
> + low for long periods of time.
> +
> + 1 – Battery Life: Power is relatively low, but the processor may still be
> + actively performing a task, such as video playback for a long period of
> + time.
> +
> + 2 – Sustained: Power level that is relatively high for a long period
> + of time, with very few to no periods of idleness, which will eventually
> + exhaust RAPL Power Limit 1 and 2.
> +
> + 3 – Bursty: Consumes a relatively constant average amount of power,
> + however, bursts of activity interrupt periods of relative idleness.
"but periods of relative idleness are interrupted by bursts of activity."
> + The bursts are relatively short and spaced with relative idleness
"... and the periods of relative idleness between them typically
prevent RAPL Power Limit 1 from being exhausted."
> + which typically do not exhaust RAPL Power Limit 1.
> +
> + 4 – Unknown: Can't classify.
> diff --git a/drivers/thermal/intel/int340x_thermal/Makefile b/drivers/thermal/intel/int340x_thermal/Makefile
> index 76e053e541f0..ccd0fdd23161 100644
> --- a/drivers/thermal/intel/int340x_thermal/Makefile
> +++ b/drivers/thermal/intel/int340x_thermal/Makefile
> @@ -11,5 +11,6 @@ obj-$(CONFIG_PROC_THERMAL_MMIO_RAPL) += processor_thermal_rapl.o
> obj-$(CONFIG_INT340X_THERMAL) += processor_thermal_rfim.o
> obj-$(CONFIG_INT340X_THERMAL) += processor_thermal_mbox.o
> obj-$(CONFIG_INT340X_THERMAL) += processor_thermal_wlt_req.o
> +obj-$(CONFIG_INT340X_THERMAL) += processor_thermal_wlt_hint.o
> obj-$(CONFIG_INT3406_THERMAL) += int3406_thermal.o
> obj-$(CONFIG_ACPI_THERMAL_REL) += acpi_thermal_rel.o
> diff --git a/drivers/thermal/intel/int340x_thermal/processor_thermal_device.c b/drivers/thermal/intel/int340x_thermal/processor_thermal_device.c
> index 48f6c72b05f6..127deefbb633 100644
> --- a/drivers/thermal/intel/int340x_thermal/processor_thermal_device.c
> +++ b/drivers/thermal/intel/int340x_thermal/processor_thermal_device.c
> @@ -352,6 +352,12 @@ int proc_thermal_mmio_add(struct pci_dev *pdev,
> dev_err(&pdev->dev, "failed to add MBOX interface\n");
> goto err_rem_rfim;
> }
> + } else if (feature_mask & PROC_THERMAL_FEATURE_WLT_HINT) {
General remark: I'm not sure about the value of the 'L' in 'WLT'. It
seems that 'WT' without the 'L' would work just fine.
> + ret = proc_thermal_wlt_hint_add(pdev, proc_priv);
> + if (ret) {
> + dev_err(&pdev->dev, "failed to add WLT Hint\n");
> + goto err_rem_rfim;
> + }
> }
>
> return 0;
> @@ -376,10 +382,13 @@ void proc_thermal_mmio_remove(struct pci_dev *pdev, struct proc_thermal_device *
>
> if (proc_priv->mmio_feature_mask & PROC_THERMAL_FEATURE_WLT_REQ)
> proc_thermal_wlt_req_remove(pdev);
> + else if (proc_priv->mmio_feature_mask & PROC_THERMAL_FEATURE_WLT_HINT)
> + proc_thermal_wlt_hint_remove(pdev);
> }
> EXPORT_SYMBOL_GPL(proc_thermal_mmio_remove);
>
> MODULE_IMPORT_NS(INTEL_TCC);
> +MODULE_IMPORT_NS(INT340X_THERMAL);
> MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
> MODULE_DESCRIPTION("Processor Thermal Reporting Device Driver");
> MODULE_LICENSE("GPL v2");
> diff --git a/drivers/thermal/intel/int340x_thermal/processor_thermal_device.h b/drivers/thermal/intel/int340x_thermal/processor_thermal_device.h
> index defc919cb020..bc056712f728 100644
> --- a/drivers/thermal/intel/int340x_thermal/processor_thermal_device.h
> +++ b/drivers/thermal/intel/int340x_thermal/processor_thermal_device.h
> @@ -61,6 +61,7 @@ struct rapl_mmio_regs {
> #define PROC_THERMAL_FEATURE_DVFS 0x04
> #define PROC_THERMAL_FEATURE_WLT_REQ 0x08
> #define PROC_THERMAL_FEATURE_DLVR 0x10
> +#define PROC_THERMAL_FEATURE_WLT_HINT 0x20
>
> #if IS_ENABLED(CONFIG_PROC_THERMAL_MMIO_RAPL)
> int proc_thermal_rapl_add(struct pci_dev *pdev, struct proc_thermal_device *proc_priv);
> @@ -95,6 +96,12 @@ int processor_thermal_mbox_interrupt_config(struct pci_dev *pdev, bool enable, i
> int time_window);
> int proc_thermal_add(struct device *dev, struct proc_thermal_device *priv);
> void proc_thermal_remove(struct proc_thermal_device *proc_priv);
> +
> +int proc_thermal_wlt_hint_add(struct pci_dev *pdev, struct proc_thermal_device *proc_priv);
> +void proc_thermal_wlt_hint_remove(struct pci_dev *pdev);
> +void proc_thermal_wlt_intr_callback(struct pci_dev *pdev, struct proc_thermal_device *proc_priv);
> +bool proc_thermal_check_wlt_intr(struct proc_thermal_device *proc_priv);
> +
> int proc_thermal_suspend(struct device *dev);
> int proc_thermal_resume(struct device *dev);
> int proc_thermal_mmio_add(struct pci_dev *pdev,
> diff --git a/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c b/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c
> index 1061d1d8f38d..ee5a4c227d96 100644
> --- a/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c
> +++ b/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c
> @@ -364,7 +364,8 @@ static const struct pci_device_id proc_thermal_pci_ids[] = {
> { PCI_DEVICE_DATA(INTEL, ADL_THERMAL, PROC_THERMAL_FEATURE_RAPL |
> PROC_THERMAL_FEATURE_FIVR | PROC_THERMAL_FEATURE_DVFS | PROC_THERMAL_FEATURE_WLT_REQ) },
> { PCI_DEVICE_DATA(INTEL, MTLP_THERMAL, PROC_THERMAL_FEATURE_RAPL |
> - PROC_THERMAL_FEATURE_FIVR | PROC_THERMAL_FEATURE_DVFS | PROC_THERMAL_FEATURE_DLVR) },
> + PROC_THERMAL_FEATURE_FIVR | PROC_THERMAL_FEATURE_DVFS | PROC_THERMAL_FEATURE_DLVR |
> + PROC_THERMAL_FEATURE_WLT_HINT) },
> { PCI_DEVICE_DATA(INTEL, RPL_THERMAL, PROC_THERMAL_FEATURE_RAPL |
> PROC_THERMAL_FEATURE_FIVR | PROC_THERMAL_FEATURE_DVFS | PROC_THERMAL_FEATURE_WLT_REQ) },
> { },
> diff --git a/drivers/thermal/intel/int340x_thermal/processor_thermal_wlt_hint.c b/drivers/thermal/intel/int340x_thermal/processor_thermal_wlt_hint.c
> new file mode 100644
> index 000000000000..09bd02cf2f7d
> --- /dev/null
> +++ b/drivers/thermal/intel/int340x_thermal/processor_thermal_wlt_hint.c
> @@ -0,0 +1,238 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +/*
> + * processor thermal device for reading Workload type hints
I would say "Processor thermal device interface ..." for more clarity.
> + * from the user space. The hints are provided by the firmware.
> + *
> + * Operation:
> + * When user space enables workload type prediction:
> + * - Use mailbox to configure:
> + * Configure notification delay
> + * Enable processor thermal device interrupt
> + * - The predicted workload type can be read from MMIO:
> + * Offset 0x5B18 shows if there was an interrupt
> + * active for change in workload type and also
> + * predicted workload type.
> + *
> + * Two interface functions are provided to call when there is a
> + * thermal device interrupt:
> + * - proc_thermal_check_wlt_intr(): Check if the interrupt is for
> + * change in workload type. Called from the interrupt context.
> + * - proc_thermal_wlt_intr_callback(): Callback for interrupt processing
> + * under thread context. This involves sending notification to user
> + * space that there is a change in the workload type.
> + *
> + * Copyright (c) 2023, Intel Corporation.
> + */
> +
> +#include <linux/bitfield.h>
> +#include <linux/pci.h>
> +#include "processor_thermal_device.h"
> +
> +#define SOC_WLT_RES_INT_STATUS_OFF 0x5B18
> +#define SOC_WLT GENMASK_ULL(47, 40)
> +
> +#define SOC_WLT_PREDICTION_INT_ENABLE_BIT 23
> +
> +#define SOC_WLT_PREDICTION_INT_ACTIVE BIT(2)
> +
> +/*
> + * Closest possible to 1 Second is 1024 ms with programmed time delay
> + * of 0x0A.
> + */
> +static u8 notify_delay = 0x0A;
> +static u16 notify_delay_ms = 1024;
> +
> +/* Show current predicted workload type index */
> +static ssize_t workload_type_index_show(struct device *dev,
> + struct device_attribute *attr,
> + char *buf)
> +{
> + struct proc_thermal_device *proc_priv;
> + struct pci_dev *pdev = to_pci_dev(dev);
> + u64 status = 0;
> + int wlt;
> +
> + proc_priv = pci_get_drvdata(pdev);
> +
> + status = readq(proc_priv->mmio_base + SOC_WLT_RES_INT_STATUS_OFF);
The "OFF" part is a bit confusing. I would just use the full word
"OFFSET" (3 characters more don't really matter here IMO).
> + wlt = FIELD_GET(SOC_WLT, status);
> +
> + return sysfs_emit(buf, "%d\n", wlt);
> +}
> +
> +static DEVICE_ATTR_RO(workload_type_index);
> +
> +static u8 wlt_enable;
> +
> +static ssize_t workload_hint_enable_show(struct device *dev,
> + struct device_attribute *attr,
> + char *buf)
> +{
> + return sysfs_emit(buf, "%d\n", wlt_enable);
> +}
> +
> +/*
> + * Enable workload type prediction by writing 1 to enable, 0 to
> + * disable
> + */
I'm not sure if the comment above is particularly useful. This
information should be present in the interface documentation.
> +static ssize_t workload_hint_enable_store(struct device *dev,
> + struct device_attribute *attr,
> + const char *buf, size_t size)
> +{
> + struct pci_dev *pdev = to_pci_dev(dev);
> + u8 mode;
> +
> + if (kstrtou8(buf, 10, &mode) || mode > 1)
> + return -EINVAL;
> +
> + if (mode) {
> + int ret;
> +
> + ret = processor_thermal_mbox_interrupt_config(pdev, true,
> + SOC_WLT_PREDICTION_INT_ENABLE_BIT,
> + notify_delay);
> + if (ret)
> + return ret;
> + } else {
> + processor_thermal_mbox_interrupt_config(pdev, false,
> + SOC_WLT_PREDICTION_INT_ENABLE_BIT, 0);
> + }
> +
> + wlt_enable = mode;
> +
> + return size;
> +}
> +
> +static DEVICE_ATTR_RW(workload_hint_enable);
> +
> +static ssize_t notification_delay_ms_show(struct device *dev,
> + struct device_attribute *attr,
> + char *buf)
> +{
> + return sysfs_emit(buf, "%u\n", notify_delay_ms);
> +}
> +
> +static ssize_t notification_delay_ms_store(struct device *dev,
> + struct device_attribute *attr,
> + const char *buf, size_t size)
> +{
> + struct pci_dev *pdev = to_pci_dev(dev);
> + u16 new_tw;
> + int ret;
> +
> + /*
> + * Time window register value:
> + * Formula: (1 + x/4) * power(2,y)
> + * x = 2 msbs, that is [30:29] y = 5 [28:24]
> + * in INTR_CONFIG register.
> + * The result will be in milli seconds.
> + * Here, just keep x = 0, and just change y.
> + * First round up the user value to power of 2 and
> + * then take log2, to get "y" value to program.
> + */
> + ret = kstrtou16(buf, 10, &new_tw);
> + if (ret)
> + return ret;
> +
> + if (new_tw) {
> + u8 tm;
> +
> + new_tw = roundup_pow_of_two(new_tw);
> + tm = ilog2(new_tw);
> + if (tm > 31)
> + return -EINVAL;
> +
> + ret = processor_thermal_mbox_interrupt_config(pdev, true,
> + SOC_WLT_PREDICTION_INT_ENABLE_BIT,
> + tm);
> + if (ret)
> + return ret;
IIUC this means that writing a valid number to this attribute will
enable workload hints even if they were not previously enabled through
the "enable" attribute. I wouldn't design it this way.
IMO the notify_delay value should always be updated, but the firmware
should be reconfigured only if the hints have been enabled already.
> +
> + notify_delay = tm;
> + notify_delay_ms = new_tw;
> + } else {
> + ret = processor_thermal_mbox_interrupt_config(pdev, false,
> + SOC_WLT_PREDICTION_INT_ENABLE_BIT,
> + notify_delay);
Hmm, what does this do? It looks like it disables the hints
altogether, but why is the old notify_delay value used here instead of
0? And why isn't notify_delay updated?
Also, is this really a good idea to allow user space to write 0 to
this attribute? Should there be a notify_delay limit?
> + if (ret)
> + return ret;
> + }
> +
> + return size;
> +}
> +
> +static DEVICE_ATTR_RW(notification_delay_ms);
> +
> +static struct attribute *workload_hint_attrs[] = {
> + &dev_attr_workload_type_index.attr,
> + &dev_attr_workload_hint_enable.attr,
> + &dev_attr_notification_delay_ms.attr,
> + NULL
> +};
> +
> +static const struct attribute_group workload_hint_attribute_group = {
> + .attrs = workload_hint_attrs,
> + .name = "workload_hint"
> +};
> +
> +/*
> + * Callback to check if the interrupt for prediction is active.
> + * Caution: Called from the interrupt context.
> + */
> +bool proc_thermal_check_wlt_intr(struct proc_thermal_device *proc_priv)
> +{
> + u64 int_status;
> +
> + int_status = readq(proc_priv->mmio_base + SOC_WLT_RES_INT_STATUS_OFF);
> + if (int_status & SOC_WLT_PREDICTION_INT_ACTIVE)
> + return true;
> +
> + return false;
> +}
> +EXPORT_SYMBOL_NS_GPL(proc_thermal_check_wlt_intr, INT340X_THERMAL);
> +
> +/* Callback to notify user space */
> +void proc_thermal_wlt_intr_callback(struct pci_dev *pdev, struct proc_thermal_device *proc_priv)
> +{
> + u64 status;
> +
> + status = readq(proc_priv->mmio_base + SOC_WLT_RES_INT_STATUS_OFF);
> + if (status & SOC_WLT_PREDICTION_INT_ACTIVE) {
I would return early if the status doesn't include the active bit, that is:
if (!(status & SOC_WLT_PREDICTION_INT_ACTIVE))
return;
> + writeq(status & ~SOC_WLT_PREDICTION_INT_ACTIVE,
> + proc_priv->mmio_base + SOC_WLT_RES_INT_STATUS_OFF);
> + sysfs_notify(&pdev->dev.kobj, "workload_hint", "workload_type_index");
> + }
> +}
> +EXPORT_SYMBOL_NS_GPL(proc_thermal_wlt_intr_callback, INT340X_THERMAL);
> +
> +static bool workload_hint_created;
> +
> +int proc_thermal_wlt_hint_add(struct pci_dev *pdev, struct proc_thermal_device *proc_priv)
> +{
> + int ret;
> +
> + ret = sysfs_create_group(&pdev->dev.kobj, &workload_hint_attribute_group);
> + if (ret)
> + return ret;
> +
> + workload_hint_created = true;
> +
> + return 0;
> +}
> +EXPORT_SYMBOL_NS_GPL(proc_thermal_wlt_hint_add, INT340X_THERMAL);
> +
> +void proc_thermal_wlt_hint_remove(struct pci_dev *pdev)
> +{
> + processor_thermal_mbox_interrupt_config(pdev, false,
> + SOC_WLT_PREDICTION_INT_ENABLE_BIT,
> + notify_delay);
This is a bit inconsistent with workload_hint_enable_store() where 0
is passed as the last argument when disabling the workload hints.
> +
> + if (workload_hint_created)
> + sysfs_remove_group(&pdev->dev.kobj, &workload_hint_attribute_group);
> +
> + workload_hint_created = false;
> +}
> +EXPORT_SYMBOL_NS_GPL(proc_thermal_wlt_hint_remove, INT340X_THERMAL);
> +
> +MODULE_IMPORT_NS(INT340X_THERMAL);
> +MODULE_LICENSE("GPL");
> --
^ permalink raw reply [flat|nested] 11+ messages in thread
* [PATCH v2 6/7] thermal/drivers/int340x: Support workload hint interrupts
2023-07-17 19:53 [PATCH v2 0/7] thermal: processor_thermal: Suport workload hint Srinivas Pandruvada
` (4 preceding siblings ...)
2023-07-17 19:54 ` [PATCH v2 5/7] thermal: int340x: processor_thermal: Add workload type hint Srinivas Pandruvada
@ 2023-07-17 19:54 ` Srinivas Pandruvada
2023-08-17 20:13 ` Rafael J. Wysocki
2023-07-17 19:54 ` [PATCH v2 7/7] selftests/thermel/intel: Add test to read workload hint Srinivas Pandruvada
6 siblings, 1 reply; 11+ messages in thread
From: Srinivas Pandruvada @ 2023-07-17 19:54 UTC (permalink / raw)
To: daniel.lezcano, rafael, rui.zhang
Cc: linux-pm, linux-kernel, Srinivas Pandruvada
On thermal device interrupt, if the interrupt is generated for passing
workload hint, call the callback to pass notification to the user
space.
First call proc_thermal_check_wlt_intr() to check interrupt, if this
callback returns true, wake IRQ thread. Call
proc_thermal_wlt_intr_callback() to notify user space.
While here remove function pkg_thermal_schedule_work() and move the
processing to the caller. The function pkg_thermal_schedule_work() just
called schedule_delayed_work().
Signed-off-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
---
v2:
No change
.../processor_thermal_device_pci.c | 33 ++++++++++++++-----
1 file changed, 24 insertions(+), 9 deletions(-)
diff --git a/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c b/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c
index ee5a4c227d96..83177ed9db49 100644
--- a/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c
+++ b/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c
@@ -115,27 +115,40 @@ static void proc_thermal_threshold_work_fn(struct work_struct *work)
proc_thermal_mmio_write(pci_info, PROC_THERMAL_MMIO_INT_ENABLE_0, 1);
}
-static void pkg_thermal_schedule_work(struct delayed_work *work)
+static irqreturn_t proc_thermal_irq_thread_handler(int irq, void *devid)
{
- unsigned long ms = msecs_to_jiffies(notify_delay_ms);
+ struct proc_thermal_pci *pci_info = devid;
+
+ proc_thermal_wlt_intr_callback(pci_info->pdev, pci_info->proc_priv);
- schedule_delayed_work(work, ms);
+ return IRQ_HANDLED;
}
static irqreturn_t proc_thermal_irq_handler(int irq, void *devid)
{
struct proc_thermal_pci *pci_info = devid;
+ struct proc_thermal_device *proc_priv;
+ int ret = IRQ_HANDLED;
u32 status;
+ proc_priv = pci_info->proc_priv;
+
+ if (proc_priv->mmio_feature_mask & PROC_THERMAL_FEATURE_WLT_HINT) {
+ if (proc_thermal_check_wlt_intr(pci_info->proc_priv))
+ ret = IRQ_WAKE_THREAD;
+ }
+
proc_thermal_mmio_read(pci_info, PROC_THERMAL_MMIO_INT_STATUS_0, &status);
+ if (status) {
+ unsigned long ms = msecs_to_jiffies(notify_delay_ms);
- /* Disable enable interrupt flag */
- proc_thermal_mmio_write(pci_info, PROC_THERMAL_MMIO_INT_ENABLE_0, 0);
+ /* Disable enable interrupt flag */
+ proc_thermal_mmio_write(pci_info, PROC_THERMAL_MMIO_INT_ENABLE_0, 0);
+ schedule_delayed_work(&pci_info->work, ms);
+ }
pci_write_config_byte(pci_info->pdev, 0xdc, 0x01);
- pkg_thermal_schedule_work(&pci_info->work);
-
- return IRQ_HANDLED;
+ return ret;
}
static int sys_get_curr_temp(struct thermal_zone_device *tzd, int *temp)
@@ -269,7 +282,7 @@ static int proc_thermal_pci_probe(struct pci_dev *pdev, const struct pci_device_
}
ret = devm_request_threaded_irq(&pdev->dev, irq,
- proc_thermal_irq_handler, NULL,
+ proc_thermal_irq_handler, proc_thermal_irq_thread_handler,
irq_flag, KBUILD_MODNAME, pci_info);
if (ret) {
dev_err(&pdev->dev, "Request IRQ %d failed\n", pdev->irq);
@@ -383,6 +396,8 @@ static struct pci_driver proc_thermal_pci_driver = {
module_pci_driver(proc_thermal_pci_driver);
+MODULE_IMPORT_NS(INT340X_THERMAL);
+
MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
MODULE_DESCRIPTION("Processor Thermal Reporting Device Driver");
MODULE_LICENSE("GPL v2");
--
2.38.1
^ permalink raw reply related [flat|nested] 11+ messages in thread* Re: [PATCH v2 6/7] thermal/drivers/int340x: Support workload hint interrupts
2023-07-17 19:54 ` [PATCH v2 6/7] thermal/drivers/int340x: Support workload hint interrupts Srinivas Pandruvada
@ 2023-08-17 20:13 ` Rafael J. Wysocki
0 siblings, 0 replies; 11+ messages in thread
From: Rafael J. Wysocki @ 2023-08-17 20:13 UTC (permalink / raw)
To: Srinivas Pandruvada
Cc: daniel.lezcano, rafael, rui.zhang, linux-pm, linux-kernel
On Mon, Jul 17, 2023 at 9:54 PM Srinivas Pandruvada
<srinivas.pandruvada@linux.intel.com> wrote:
>
> On thermal device interrupt, if the interrupt is generated for passing
> workload hint, call the callback to pass notification to the user
> space.
>
> First call proc_thermal_check_wlt_intr() to check interrupt, if this
> callback returns true, wake IRQ thread. Call
> proc_thermal_wlt_intr_callback() to notify user space.
>
> While here remove function pkg_thermal_schedule_work() and move the
> processing to the caller. The function pkg_thermal_schedule_work() just
> called schedule_delayed_work().
This extra change is somewhat confusing. I would move it to a separate patch.
> Signed-off-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
> ---
> v2:
> No change
>
> .../processor_thermal_device_pci.c | 33 ++++++++++++++-----
> 1 file changed, 24 insertions(+), 9 deletions(-)
>
> diff --git a/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c b/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c
> index ee5a4c227d96..83177ed9db49 100644
> --- a/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c
> +++ b/drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c
> @@ -115,27 +115,40 @@ static void proc_thermal_threshold_work_fn(struct work_struct *work)
> proc_thermal_mmio_write(pci_info, PROC_THERMAL_MMIO_INT_ENABLE_0, 1);
> }
>
> -static void pkg_thermal_schedule_work(struct delayed_work *work)
> +static irqreturn_t proc_thermal_irq_thread_handler(int irq, void *devid)
> {
> - unsigned long ms = msecs_to_jiffies(notify_delay_ms);
> + struct proc_thermal_pci *pci_info = devid;
> +
> + proc_thermal_wlt_intr_callback(pci_info->pdev, pci_info->proc_priv);
>
> - schedule_delayed_work(work, ms);
> + return IRQ_HANDLED;
> }
>
> static irqreturn_t proc_thermal_irq_handler(int irq, void *devid)
> {
> struct proc_thermal_pci *pci_info = devid;
> + struct proc_thermal_device *proc_priv;
> + int ret = IRQ_HANDLED;
> u32 status;
>
> + proc_priv = pci_info->proc_priv;
> +
> + if (proc_priv->mmio_feature_mask & PROC_THERMAL_FEATURE_WLT_HINT) {
> + if (proc_thermal_check_wlt_intr(pci_info->proc_priv))
> + ret = IRQ_WAKE_THREAD;
> + }
> +
> proc_thermal_mmio_read(pci_info, PROC_THERMAL_MMIO_INT_STATUS_0, &status);
> + if (status) {
> + unsigned long ms = msecs_to_jiffies(notify_delay_ms);
>
> - /* Disable enable interrupt flag */
> - proc_thermal_mmio_write(pci_info, PROC_THERMAL_MMIO_INT_ENABLE_0, 0);
> + /* Disable enable interrupt flag */
> + proc_thermal_mmio_write(pci_info, PROC_THERMAL_MMIO_INT_ENABLE_0, 0);
> + schedule_delayed_work(&pci_info->work, ms);
> + }
> pci_write_config_byte(pci_info->pdev, 0xdc, 0x01);
>
> - pkg_thermal_schedule_work(&pci_info->work);
> -
> - return IRQ_HANDLED;
> + return ret;
> }
>
> static int sys_get_curr_temp(struct thermal_zone_device *tzd, int *temp)
> @@ -269,7 +282,7 @@ static int proc_thermal_pci_probe(struct pci_dev *pdev, const struct pci_device_
> }
>
> ret = devm_request_threaded_irq(&pdev->dev, irq,
> - proc_thermal_irq_handler, NULL,
> + proc_thermal_irq_handler, proc_thermal_irq_thread_handler,
> irq_flag, KBUILD_MODNAME, pci_info);
> if (ret) {
> dev_err(&pdev->dev, "Request IRQ %d failed\n", pdev->irq);
> @@ -383,6 +396,8 @@ static struct pci_driver proc_thermal_pci_driver = {
>
> module_pci_driver(proc_thermal_pci_driver);
>
> +MODULE_IMPORT_NS(INT340X_THERMAL);
> +
> MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
> MODULE_DESCRIPTION("Processor Thermal Reporting Device Driver");
> MODULE_LICENSE("GPL v2");
> --
> 2.38.1
>
^ permalink raw reply [flat|nested] 11+ messages in thread
* [PATCH v2 7/7] selftests/thermel/intel: Add test to read workload hint
2023-07-17 19:53 [PATCH v2 0/7] thermal: processor_thermal: Suport workload hint Srinivas Pandruvada
` (5 preceding siblings ...)
2023-07-17 19:54 ` [PATCH v2 6/7] thermal/drivers/int340x: Support workload hint interrupts Srinivas Pandruvada
@ 2023-07-17 19:54 ` Srinivas Pandruvada
6 siblings, 0 replies; 11+ messages in thread
From: Srinivas Pandruvada @ 2023-07-17 19:54 UTC (permalink / raw)
To: daniel.lezcano, rafael, rui.zhang
Cc: linux-pm, linux-kernel, Srinivas Pandruvada
Some SoCs have in built firmware support to classify current running
workload and pass to OS for making power management decisions.
This test program waits for notification of workload type change
and prints. This program can be used to test this feature and also
allows other user space programs to use as a reference.
Signed-off-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
---
v2:
Add a signal handler for interrupting poll and exit
Also moved inside intel/workload_type_hint foler
Update Makefile
tools/testing/selftests/Makefile | 1 +
.../thermal/intel/workload_hint/Makefile | 12 ++
.../intel/workload_hint/workload_hint_test.c | 157 ++++++++++++++++++
3 files changed, 170 insertions(+)
create mode 100644 tools/testing/selftests/thermal/intel/workload_hint/Makefile
create mode 100644 tools/testing/selftests/thermal/intel/workload_hint/workload_hint_test.c
diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Makefile
index 666b56f22a41..eb0228965266 100644
--- a/tools/testing/selftests/Makefile
+++ b/tools/testing/selftests/Makefile
@@ -81,6 +81,7 @@ TARGETS += syscall_user_dispatch
TARGETS += sysctl
TARGETS += tc-testing
TARGETS += tdx
+TARGETS += thermal/intel/workload_hint
TARGETS += timens
ifneq (1, $(quicktest))
TARGETS += timers
diff --git a/tools/testing/selftests/thermal/intel/workload_hint/Makefile b/tools/testing/selftests/thermal/intel/workload_hint/Makefile
new file mode 100644
index 000000000000..37ff3286283b
--- /dev/null
+++ b/tools/testing/selftests/thermal/intel/workload_hint/Makefile
@@ -0,0 +1,12 @@
+# SPDX-License-Identifier: GPL-2.0
+ifndef CROSS_COMPILE
+uname_M := $(shell uname -m 2>/dev/null || echo not)
+ARCH ?= $(shell echo $(uname_M) | sed -e s/i.86/x86/ -e s/x86_64/x86/)
+
+ifeq ($(ARCH),x86)
+TEST_GEN_PROGS := workload_hint_test
+
+include ../../../lib.mk
+
+endif
+endif
diff --git a/tools/testing/selftests/thermal/intel/workload_hint/workload_hint_test.c b/tools/testing/selftests/thermal/intel/workload_hint/workload_hint_test.c
new file mode 100644
index 000000000000..217c3a641c53
--- /dev/null
+++ b/tools/testing/selftests/thermal/intel/workload_hint/workload_hint_test.c
@@ -0,0 +1,157 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#define _GNU_SOURCE
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <signal.h>
+
+#define WORKLOAD_NOTIFICATION_DELAY_ATTRIBUTE "/sys/bus/pci/devices/0000:00:04.0/workload_hint/notification_delay_ms"
+#define WORKLOAD_ENABLE_ATTRIBUTE "/sys/bus/pci/devices/0000:00:04.0/workload_hint/workload_hint_enable"
+#define WORKLOAD_TYPE_INDEX_ATTRIBUTE "/sys/bus/pci/devices/0000:00:04.0/workload_hint/workload_type_index"
+
+static const char * const workload_types[] = {
+ "idle",
+ "battery_life",
+ "sustained",
+ "bursty",
+ NULL
+};
+
+#define WORKLOAD_TYPE_MAX_INDEX 3
+
+void workload_hint_exit(int signum)
+{
+ int fd;
+
+ /* Disable feature via sysfs knob */
+
+ fd = open(WORKLOAD_ENABLE_ATTRIBUTE, O_RDWR);
+ if (fd < 0) {
+ perror("Unable to open workload type feature enable file\n");
+ exit(1);
+ }
+
+ if (write(fd, "0\n", 2) < 0) {
+ perror("Can' disable workload hints\n");
+ exit(1);
+ }
+
+ printf("Disabled workload type prediction\n");
+
+ close(fd);
+}
+
+int main(int argc, char **argv)
+{
+ struct pollfd ufd;
+ char index_str[4];
+ int fd, ret, index;
+ char delay_str[64];
+ int delay = 0;
+
+ printf("Usage: workload_hint_test [notification delay in milli seconds]\n");
+
+ if (argc > 1) {
+ ret = sscanf(argv[1], "%d", &delay);
+ if (ret < 0) {
+ printf("Invalid delay\n");
+ exit(1);
+ }
+
+ printf("Setting notification delay to %d ms\n", delay);
+ if (delay < 0)
+ exit(1);
+
+ sprintf(delay_str, "%s\n", argv[1]);
+
+ sprintf(delay_str, "%s\n", argv[1]);
+ fd = open(WORKLOAD_NOTIFICATION_DELAY_ATTRIBUTE, O_RDWR);
+ if (fd < 0) {
+ perror("Unable to open workload notification delay\n");
+ exit(1);
+ }
+
+ if (write(fd, delay_str, strlen(delay_str)) < 0) {
+ perror("Can't set delay\n");
+ exit(1);
+ }
+
+ close(fd);
+ }
+
+ if (signal(SIGINT, workload_hint_exit) == SIG_IGN)
+ signal(SIGINT, SIG_IGN);
+ if (signal(SIGHUP, workload_hint_exit) == SIG_IGN)
+ signal(SIGHUP, SIG_IGN);
+ if (signal(SIGTERM, workload_hint_exit) == SIG_IGN)
+ signal(SIGTERM, SIG_IGN);
+
+ /* Enable feature via sysfs knob */
+ fd = open(WORKLOAD_ENABLE_ATTRIBUTE, O_RDWR);
+ if (fd < 0) {
+ perror("Unable to open workload type feature enable file\n");
+ exit(1);
+ }
+
+ if (write(fd, "1\n", 2) < 0) {
+ perror("Can' enable workload hints\n");
+ exit(1);
+ }
+
+ close(fd);
+
+ printf("Enabled workload type prediction\n");
+
+ while (1) {
+ fd = open(WORKLOAD_TYPE_INDEX_ATTRIBUTE, O_RDONLY);
+ if (fd < 0) {
+ perror("Unable to open workload type file\n");
+ exit(1);
+ }
+
+ if ((lseek(fd, 0L, SEEK_SET)) < 0) {
+ fprintf(stderr, "Failed to set pointer to beginning\n");
+ exit(1);
+ }
+
+ if (read(fd, index_str, sizeof(index_str)) < 0) {
+ fprintf(stderr, "Failed to read from:%s\n",
+ WORKLOAD_TYPE_INDEX_ATTRIBUTE);
+ exit(1);
+ }
+
+ ufd.fd = fd;
+ ufd.events = POLLPRI;
+
+ ret = poll(&ufd, 1, -1);
+ if (ret < 0) {
+ perror("poll error");
+ exit(1);
+ } else if (ret == 0) {
+ printf("Poll Timeout\n");
+ } else {
+ if ((lseek(fd, 0L, SEEK_SET)) < 0) {
+ fprintf(stderr, "Failed to set pointer to beginning\n");
+ exit(1);
+ }
+
+ if (read(fd, index_str, sizeof(index_str)) < 0)
+ exit(0);
+
+ ret = sscanf(index_str, "%d", &index);
+ if (ret < 0)
+ break;
+ if (index > WORKLOAD_TYPE_MAX_INDEX)
+ printf("Invalid workload type index\n");
+ else
+ printf("workload type:%s\n", workload_types[index]);
+ }
+
+ close(fd);
+ }
+}
--
2.38.1
^ permalink raw reply related [flat|nested] 11+ messages in thread