tools headers UAPI: Sync files changed by the quotactl_path unwiring
[linux-2.6-microblaze.git] / drivers / acpi / acpi_lpit.c
1 // SPDX-License-Identifier: GPL-2.0-only
2
3 /*
4  * acpi_lpit.c - LPIT table processing functions
5  *
6  * Copyright (C) 2017 Intel Corporation. All rights reserved.
7  */
8
9 #include <linux/cpu.h>
10 #include <linux/acpi.h>
11 #include <asm/msr.h>
12 #include <asm/tsc.h>
13
14 struct lpit_residency_info {
15         struct acpi_generic_address gaddr;
16         u64 frequency;
17         void __iomem *iomem_addr;
18 };
19
20 /* Storage for an memory mapped and FFH based entries */
21 static struct lpit_residency_info residency_info_mem;
22 static struct lpit_residency_info residency_info_ffh;
23
24 static int lpit_read_residency_counter_us(u64 *counter, bool io_mem)
25 {
26         int err;
27
28         if (io_mem) {
29                 u64 count = 0;
30                 int error;
31
32                 error = acpi_os_read_iomem(residency_info_mem.iomem_addr, &count,
33                                            residency_info_mem.gaddr.bit_width);
34                 if (error)
35                         return error;
36
37                 *counter = div64_u64(count * 1000000ULL, residency_info_mem.frequency);
38                 return 0;
39         }
40
41         err = rdmsrl_safe(residency_info_ffh.gaddr.address, counter);
42         if (!err) {
43                 u64 mask = GENMASK_ULL(residency_info_ffh.gaddr.bit_offset +
44                                        residency_info_ffh.gaddr. bit_width - 1,
45                                        residency_info_ffh.gaddr.bit_offset);
46
47                 *counter &= mask;
48                 *counter >>= residency_info_ffh.gaddr.bit_offset;
49                 *counter = div64_u64(*counter * 1000000ULL, residency_info_ffh.frequency);
50                 return 0;
51         }
52
53         return -ENODATA;
54 }
55
56 static ssize_t low_power_idle_system_residency_us_show(struct device *dev,
57                                                        struct device_attribute *attr,
58                                                        char *buf)
59 {
60         u64 counter;
61         int ret;
62
63         ret = lpit_read_residency_counter_us(&counter, true);
64         if (ret)
65                 return ret;
66
67         return sprintf(buf, "%llu\n", counter);
68 }
69 static DEVICE_ATTR_RO(low_power_idle_system_residency_us);
70
71 static ssize_t low_power_idle_cpu_residency_us_show(struct device *dev,
72                                                     struct device_attribute *attr,
73                                                     char *buf)
74 {
75         u64 counter;
76         int ret;
77
78         ret = lpit_read_residency_counter_us(&counter, false);
79         if (ret)
80                 return ret;
81
82         return sprintf(buf, "%llu\n", counter);
83 }
84 static DEVICE_ATTR_RO(low_power_idle_cpu_residency_us);
85
86 int lpit_read_residency_count_address(u64 *address)
87 {
88         if (!residency_info_mem.gaddr.address)
89                 return -EINVAL;
90
91         *address = residency_info_mem.gaddr.address;
92
93         return 0;
94 }
95 EXPORT_SYMBOL_GPL(lpit_read_residency_count_address);
96
97 static void lpit_update_residency(struct lpit_residency_info *info,
98                                  struct acpi_lpit_native *lpit_native)
99 {
100         info->frequency = lpit_native->counter_frequency ?
101                                 lpit_native->counter_frequency : tsc_khz * 1000;
102         if (!info->frequency)
103                 info->frequency = 1;
104
105         info->gaddr = lpit_native->residency_counter;
106         if (info->gaddr.space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
107                 info->iomem_addr = ioremap(info->gaddr.address,
108                                                    info->gaddr.bit_width / 8);
109                 if (!info->iomem_addr)
110                         return;
111
112                 if (!(acpi_gbl_FADT.flags & ACPI_FADT_LOW_POWER_S0))
113                         return;
114
115                 /* Silently fail, if cpuidle attribute group is not present */
116                 sysfs_add_file_to_group(&cpu_subsys.dev_root->kobj,
117                                         &dev_attr_low_power_idle_system_residency_us.attr,
118                                         "cpuidle");
119         } else if (info->gaddr.space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) {
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_cpu_residency_us.attr,
126                                         "cpuidle");
127         }
128 }
129
130 static void lpit_process(u64 begin, u64 end)
131 {
132         while (begin + sizeof(struct acpi_lpit_native) <= end) {
133                 struct acpi_lpit_native *lpit_native = (struct acpi_lpit_native *)begin;
134
135                 if (!lpit_native->header.type && !lpit_native->header.flags) {
136                         if (lpit_native->residency_counter.space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY &&
137                             !residency_info_mem.gaddr.address) {
138                                 lpit_update_residency(&residency_info_mem, lpit_native);
139                         } else if (lpit_native->residency_counter.space_id == ACPI_ADR_SPACE_FIXED_HARDWARE &&
140                                    !residency_info_ffh.gaddr.address) {
141                                 lpit_update_residency(&residency_info_ffh, lpit_native);
142                         }
143                 }
144                 begin += lpit_native->header.length;
145         }
146 }
147
148 void acpi_init_lpit(void)
149 {
150         acpi_status status;
151         struct acpi_table_lpit *lpit;
152
153         status = acpi_get_table(ACPI_SIG_LPIT, 0, (struct acpi_table_header **)&lpit);
154         if (ACPI_FAILURE(status))
155                 return;
156
157         lpit_process((u64)lpit + sizeof(*lpit),
158                      (u64)lpit + lpit->header.length);
159
160         acpi_put_table((struct acpi_table_header *)lpit);
161 }