9 files changed, 237 insertions, 16 deletions

diff --git a/Documentation/acpi/lpit.txt b/Documentation/acpi/lpit.txt
new file mode 100644
index 000000000000..b426398d2e97
--- /dev/null
+++ b/Documentation/acpi/lpit.txt
@@ -0,0 +1,25 @@
+To enumerate platform Low Power Idle states, Intel platforms are using
+“Low Power Idle Table” (LPIT). More details about this table can be
+downloaded from:
+http://www.uefi.org/sites/default/files/resources/Intel_ACPI_Low_Power_S0_Idle.pdf
+
+Residencies for each low power state can be read via FFH
+(Function fixed hardware) or a memory mapped interface.
+
+On platforms supporting S0ix sleep states, there can be two types of
+residencies:
+- CPU PKG C10 (Read via FFH interface)
+- Platform Controller Hub (PCH) SLP_S0 (Read via memory mapped interface)
+
+The following attributes are added dynamically to the cpuidle
+sysfs attribute group:
+        /sys/devices/system/cpu/cpuidle/low_power_idle_cpu_residency_us
+        /sys/devices/system/cpu/cpuidle/low_power_idle_system_residency_us
+
+The "low_power_idle_cpu_residency_us" attribute shows time spent
+by the CPU package in PKG C10
+
+The "low_power_idle_system_residency_us" attribute shows SLP_S0
+residency, or system time spent with the SLP_S0# signal asserted.
+This is the lowest possible system power state, achieved only when CPU is in
+PKG C10 and all functional blocks in PCH are in a low power state.
diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig
index 1ce52f84dc23..4bfef0f78cde 100644
--- a/drivers/acpi/Kconfig
+++ b/drivers/acpi/Kconfig
@@ -80,6 +80,11 @@ endif
 config ACPI_SPCR_TABLE
         bool
 
+config ACPI_LPIT
+        bool
+        depends on X86_64
+        default y
+
 config ACPI_SLEEP
         bool
         depends on SUSPEND || HIBERNATION
diff --git a/drivers/acpi/Makefile b/drivers/acpi/Makefile
index 90265ab4437a..6a19bd7aba21 100644
--- a/drivers/acpi/Makefile
+++ b/drivers/acpi/Makefile
@@ -56,6 +56,7 @@ acpi-$(CONFIG_DEBUG_FS)		+= debugfs.o
 acpi-$(CONFIG_ACPI_NUMA)        += numa.o
 acpi-$(CONFIG_ACPI_PROCFS_POWER) += cm_sbs.o
 acpi-y                          += acpi_lpat.o
+acpi-$(CONFIG_ACPI_LPIT)        += acpi_lpit.o
 acpi-$(CONFIG_ACPI_GENERIC_GSI) += irq.o
 acpi-$(CONFIG_ACPI_WATCHDOG)    += acpi_watchdog.o
 
diff --git a/drivers/acpi/acpi_lpit.c b/drivers/acpi/acpi_lpit.c
new file mode 100644
index 000000000000..e94e478dd18b
--- /dev/null
+++ b/drivers/acpi/acpi_lpit.c
@@ -0,0 +1,162 @@
+
+/*
+ * acpi_lpit.c - LPIT table processing functions
+ *
+ * Copyright (C) 2017 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License version
+ * 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/cpu.h>
+#include <linux/acpi.h>
+#include <asm/msr.h>
+#include <asm/tsc.h>
+
+struct lpit_residency_info {
+        struct acpi_generic_address gaddr;
+        u64 frequency;
+        void __iomem *iomem_addr;
+};
+
+/* Storage for an memory mapped and FFH based entries */
+static struct lpit_residency_info residency_info_mem;
+static struct lpit_residency_info residency_info_ffh;
+
+static int lpit_read_residency_counter_us(u64 *counter, bool io_mem)
+{
+        int err;
+
+        if (io_mem) {
+                u64 count = 0;
+                int error;
+
+                error = acpi_os_read_iomem(residency_info_mem.iomem_addr, &count,
+                                           residency_info_mem.gaddr.bit_width);
+                if (error)
+                        return error;
+
+                *counter = div64_u64(count * 1000000ULL, residency_info_mem.frequency);
+                return 0;
+        }
+
+        err = rdmsrl_safe(residency_info_ffh.gaddr.address, counter);
+        if (!err) {
+                u64 mask = GENMASK_ULL(residency_info_ffh.gaddr.bit_offset +
+                                       residency_info_ffh.gaddr. bit_width - 1,
+                                       residency_info_ffh.gaddr.bit_offset);
+
+                *counter &= mask;
+                *counter >>= residency_info_ffh.gaddr.bit_offset;
+                *counter = div64_u64(*counter * 1000000ULL, residency_info_ffh.frequency);
+                return 0;
+        }
+
+        return -ENODATA;
+}
+
+static ssize_t low_power_idle_system_residency_us_show(struct device *dev,
+                                                       struct device_attribute *attr,
+                                                       char *buf)
+{
+        u64 counter;
+        int ret;
+
+        ret = lpit_read_residency_counter_us(&counter, true);
+        if (ret)
+                return ret;
+
+        return sprintf(buf, "%llu\n", counter);
+}
+static DEVICE_ATTR_RO(low_power_idle_system_residency_us);
+
+static ssize_t low_power_idle_cpu_residency_us_show(struct device *dev,
+                                                    struct device_attribute *attr,
+                                                    char *buf)
+{
+        u64 counter;
+        int ret;
+
+        ret = lpit_read_residency_counter_us(&counter, false);
+        if (ret)
+                return ret;
+
+        return sprintf(buf, "%llu\n", counter);
+}
+static DEVICE_ATTR_RO(low_power_idle_cpu_residency_us);
+
+int lpit_read_residency_count_address(u64 *address)
+{
+        if (!residency_info_mem.gaddr.address)
+                return -EINVAL;
+
+        *address = residency_info_mem.gaddr.address;
+
+        return 0;
+}
+
+static void lpit_update_residency(struct lpit_residency_info *info,
+                                 struct acpi_lpit_native *lpit_native)
+{
+        info->frequency = lpit_native->counter_frequency ?
+                                lpit_native->counter_frequency : tsc_khz * 1000;
+        if (!info->frequency)
+                info->frequency = 1;
+
+        info->gaddr = lpit_native->residency_counter;
+        if (info->gaddr.space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
+                info->iomem_addr = ioremap_nocache(info->gaddr.address,
+                                                   info->gaddr.bit_width / 8);
+                if (!info->iomem_addr)
+                        return;
+
+                /* Silently fail, if cpuidle attribute group is not present */
+                sysfs_add_file_to_group(&cpu_subsys.dev_root->kobj,
+                                        &dev_attr_low_power_idle_system_residency_us.attr,
+                                        "cpuidle");
+        } else if (info->gaddr.space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) {
+                /* Silently fail, if cpuidle attribute group is not present */
+                sysfs_add_file_to_group(&cpu_subsys.dev_root->kobj,
+                                        &dev_attr_low_power_idle_cpu_residency_us.attr,
+                                        "cpuidle");
+        }
+}
+
+static void lpit_process(u64 begin, u64 end)
+{
+        while (begin + sizeof(struct acpi_lpit_native) < end) {
+                struct acpi_lpit_native *lpit_native = (struct acpi_lpit_native *)begin;
+
+                if (!lpit_native->header.type && !lpit_native->header.flags) {
+                        if (lpit_native->residency_counter.space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY &&
+                            !residency_info_mem.gaddr.address) {
+                                lpit_update_residency(&residency_info_mem, lpit_native);
+                        } else if (lpit_native->residency_counter.space_id == ACPI_ADR_SPACE_FIXED_HARDWARE &&
+                                   !residency_info_ffh.gaddr.address) {
+                                lpit_update_residency(&residency_info_ffh, lpit_native);
+                        }
+                }
+                begin += lpit_native->header.length;
+        }
+}
+
+void acpi_init_lpit(void)
+{
+        acpi_status status;
+        u64 lpit_begin;
+        struct acpi_table_lpit *lpit;
+
+        status = acpi_get_table(ACPI_SIG_LPIT, 0, (struct acpi_table_header **)&lpit);
+
+        if (ACPI_FAILURE(status))
+                return;
+
+        lpit_begin = (u64)lpit + sizeof(*lpit);
+        lpit_process(lpit_begin, lpit_begin + lpit->header.length);
+}
diff --git a/drivers/acpi/internal.h b/drivers/acpi/internal.h
index 4361c4415b4f..fc8c43e76707 100644
--- a/drivers/acpi/internal.h
+++ b/drivers/acpi/internal.h
@@ -248,4 +248,10 @@ void acpi_watchdog_init(void);
 static inline void acpi_watchdog_init(void) {}
 #endif
 
+#ifdef CONFIG_ACPI_LPIT
+void acpi_init_lpit(void);
+#else
+static inline void acpi_init_lpit(void) { }
+#endif
+
 #endif /* _ACPI_INTERNAL_H_ */
diff --git a/drivers/acpi/osl.c b/drivers/acpi/osl.c
index db78d353bab1..3bb46cb24a99 100644
--- a/drivers/acpi/osl.c
+++ b/drivers/acpi/osl.c
@@ -663,6 +663,29 @@ acpi_status acpi_os_write_port(acpi_io_address port, u32 value, u32 width)
 
 EXPORT_SYMBOL(acpi_os_write_port);
 
+int acpi_os_read_iomem(void __iomem *virt_addr, u64 *value, u32 width)
+{
+
+        switch (width) {
+        case 8:
+                *(u8 *) value = readb(virt_addr);
+                break;
+        case 16:
+                *(u16 *) value = readw(virt_addr);
+                break;
+        case 32:
+                *(u32 *) value = readl(virt_addr);
+                break;
+        case 64:
+                *(u64 *) value = readq(virt_addr);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
 acpi_status
 acpi_os_read_memory(acpi_physical_address phys_addr, u64 *value, u32 width)
 {
@@ -670,6 +693,7 @@ acpi_os_read_memory(acpi_physical_address phys_addr, u64 *value, u32 width)
         unsigned int size = width / 8;
         bool unmap = false;
         u64 dummy;
+        int error;
 
         rcu_read_lock();
         virt_addr = acpi_map_vaddr_lookup(phys_addr, size);
@@ -684,22 +708,8 @@ acpi_os_read_memory(acpi_physical_address phys_addr, u64 *value, u32 width)
         if (!value)
                 value = &dummy;
 
-        switch (width) {
-        case 8:
-                *(u8 *) value = readb(virt_addr);
-                break;
-        case 16:
-                *(u16 *) value = readw(virt_addr);
-                break;
-        case 32:
-                *(u32 *) value = readl(virt_addr);
-                break;
-        case 64:
-                *(u64 *) value = readq(virt_addr);
-                break;
-        default:
-                BUG();
-        }
+        error = acpi_os_read_iomem(virt_addr, value, width);
+        BUG_ON(error);
 
         if (unmap)
                 iounmap(virt_addr);
diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c
index 602f8ff212f2..81367edc8a10 100644
--- a/drivers/acpi/scan.c
+++ b/drivers/acpi/scan.c
@@ -2122,6 +2122,7 @@ int __init acpi_scan_init(void)
         acpi_int340x_thermal_init();
         acpi_amba_init();
         acpi_watchdog_init();
+        acpi_init_lpit();
 
         acpi_scan_add_handler(&generic_device_handler);
 
diff --git a/include/acpi/acpiosxf.h b/include/acpi/acpiosxf.h
index c66eb8ffa454..d5c0f5153c4e 100644
--- a/include/acpi/acpiosxf.h
+++ b/include/acpi/acpiosxf.h
@@ -287,6 +287,8 @@ acpi_status acpi_os_write_port(acpi_io_address address, u32 value, u32 width);
 /*
  * Platform and hardware-independent physical memory interfaces
  */
+int acpi_os_read_iomem(void __iomem *virt_addr, u64 *value, u32 width);
+
 #ifndef ACPI_USE_ALTERNATE_PROTOTYPE_acpi_os_read_memory
 acpi_status
 acpi_os_read_memory(acpi_physical_address address, u64 *value, u32 width);
diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index d18c92d4ba19..2b1738f840ab 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -1248,4 +1248,13 @@ int acpi_irq_get(acpi_handle handle, unsigned int index, struct resource *res)
 }
 #endif
 
+#ifdef CONFIG_ACPI_LPIT
+int lpit_read_residency_count_address(u64 *address);
+#else
+static inline int lpit_read_residency_count_address(u64 *address)
+{
+        return -EINVAL;
+}
+#endif
+
 #endif  /*_LINUX_ACPI_H*/