1 2 /* 3 * acpi_lpit.c - LPIT table processing functions 4 * 5 * Copyright (C) 2017 Intel Corporation. All rights reserved. 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License version 9 * 2 as published by the Free Software Foundation. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 */ 16 17 #include <linux/cpu.h> 18 #include <linux/acpi.h> 19 #include <asm/msr.h> 20 #include <asm/tsc.h> 21 22 struct lpit_residency_info { 23 struct acpi_generic_address gaddr; 24 u64 frequency; 25 void __iomem *iomem_addr; 26 }; 27 28 /* Storage for an memory mapped and FFH based entries */ 29 static struct lpit_residency_info residency_info_mem; 30 static struct lpit_residency_info residency_info_ffh; 31 32 static int lpit_read_residency_counter_us(u64 *counter, bool io_mem) 33 { 34 int err; 35 36 if (io_mem) { 37 u64 count = 0; 38 int error; 39 40 error = acpi_os_read_iomem(residency_info_mem.iomem_addr, &count, 41 residency_info_mem.gaddr.bit_width); 42 if (error) 43 return error; 44 45 *counter = div64_u64(count * 1000000ULL, residency_info_mem.frequency); 46 return 0; 47 } 48 49 err = rdmsrl_safe(residency_info_ffh.gaddr.address, counter); 50 if (!err) { 51 u64 mask = GENMASK_ULL(residency_info_ffh.gaddr.bit_offset + 52 residency_info_ffh.gaddr. bit_width - 1, 53 residency_info_ffh.gaddr.bit_offset); 54 55 *counter &= mask; 56 *counter >>= residency_info_ffh.gaddr.bit_offset; 57 *counter = div64_u64(*counter * 1000000ULL, residency_info_ffh.frequency); 58 return 0; 59 } 60 61 return -ENODATA; 62 } 63 64 static ssize_t low_power_idle_system_residency_us_show(struct device *dev, 65 struct device_attribute *attr, 66 char *buf) 67 { 68 u64 counter; 69 int ret; 70 71 ret = lpit_read_residency_counter_us(&counter, true); 72 if (ret) 73 return ret; 74 75 return sprintf(buf, "%llu\n", counter); 76 } 77 static DEVICE_ATTR_RO(low_power_idle_system_residency_us); 78 79 static ssize_t low_power_idle_cpu_residency_us_show(struct device *dev, 80 struct device_attribute *attr, 81 char *buf) 82 { 83 u64 counter; 84 int ret; 85 86 ret = lpit_read_residency_counter_us(&counter, false); 87 if (ret) 88 return ret; 89 90 return sprintf(buf, "%llu\n", counter); 91 } 92 static DEVICE_ATTR_RO(low_power_idle_cpu_residency_us); 93 94 int lpit_read_residency_count_address(u64 *address) 95 { 96 if (!residency_info_mem.gaddr.address) 97 return -EINVAL; 98 99 *address = residency_info_mem.gaddr.address; 100 101 return 0; 102 } 103 EXPORT_SYMBOL_GPL(lpit_read_residency_count_address); 104 105 static void lpit_update_residency(struct lpit_residency_info *info, 106 struct acpi_lpit_native *lpit_native) 107 { 108 info->frequency = lpit_native->counter_frequency ? 109 lpit_native->counter_frequency : tsc_khz * 1000; 110 if (!info->frequency) 111 info->frequency = 1; 112 113 info->gaddr = lpit_native->residency_counter; 114 if (info->gaddr.space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) { 115 info->iomem_addr = ioremap_nocache(info->gaddr.address, 116 info->gaddr.bit_width / 8); 117 if (!info->iomem_addr) 118 return; 119 120 if (!(acpi_gbl_FADT.flags & ACPI_FADT_LOW_POWER_S0)) 121 return; 122 123 /* Silently fail, if cpuidle attribute group is not present */ 124 sysfs_add_file_to_group(&cpu_subsys.dev_root->kobj, 125 &dev_attr_low_power_idle_system_residency_us.attr, 126 "cpuidle"); 127 } else if (info->gaddr.space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) { 128 if (!(acpi_gbl_FADT.flags & ACPI_FADT_LOW_POWER_S0)) 129 return; 130 131 /* Silently fail, if cpuidle attribute group is not present */ 132 sysfs_add_file_to_group(&cpu_subsys.dev_root->kobj, 133 &dev_attr_low_power_idle_cpu_residency_us.attr, 134 "cpuidle"); 135 } 136 } 137 138 static void lpit_process(u64 begin, u64 end) 139 { 140 while (begin + sizeof(struct acpi_lpit_native) < end) { 141 struct acpi_lpit_native *lpit_native = (struct acpi_lpit_native *)begin; 142 143 if (!lpit_native->header.type && !lpit_native->header.flags) { 144 if (lpit_native->residency_counter.space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY && 145 !residency_info_mem.gaddr.address) { 146 lpit_update_residency(&residency_info_mem, lpit_native); 147 } else if (lpit_native->residency_counter.space_id == ACPI_ADR_SPACE_FIXED_HARDWARE && 148 !residency_info_ffh.gaddr.address) { 149 lpit_update_residency(&residency_info_ffh, lpit_native); 150 } 151 } 152 begin += lpit_native->header.length; 153 } 154 } 155 156 void acpi_init_lpit(void) 157 { 158 acpi_status status; 159 u64 lpit_begin; 160 struct acpi_table_lpit *lpit; 161 162 status = acpi_get_table(ACPI_SIG_LPIT, 0, (struct acpi_table_header **)&lpit); 163 164 if (ACPI_FAILURE(status)) 165 return; 166 167 lpit_begin = (u64)lpit + sizeof(*lpit); 168 lpit_process(lpit_begin, lpit_begin + lpit->header.length); 169 } 170