1 // SPDX-License-Identifier: GPL-2.0
3 * pptt.c - parsing of Processor Properties Topology Table (PPTT)
5 * Copyright (C) 2018, ARM
7 * This file implements parsing of the Processor Properties Topology Table
8 * which is optionally used to describe the processor and cache topology.
9 * Due to the relative pointers used throughout the table, this doesn't
10 * leverage the existing subtable parsing in the kernel.
12 * The PPTT structure is an inverted tree, with each node potentially
13 * holding one or two inverted tree data structures describing
14 * the caches available at that level. Each cache structure optionally
15 * contains properties describing the cache at a given level which can be
16 * used to override hardware probed values.
18 #define pr_fmt(fmt) "ACPI PPTT: " fmt
20 #include <linux/acpi.h>
21 #include <linux/cacheinfo.h>
22 #include <acpi/processor.h>
24 static struct acpi_subtable_header
*fetch_pptt_subtable(struct acpi_table_header
*table_hdr
,
27 struct acpi_subtable_header
*entry
;
29 /* there isn't a subtable at reference 0 */
30 if (pptt_ref
< sizeof(struct acpi_subtable_header
))
33 if (pptt_ref
+ sizeof(struct acpi_subtable_header
) > table_hdr
->length
)
36 entry
= ACPI_ADD_PTR(struct acpi_subtable_header
, table_hdr
, pptt_ref
);
38 if (entry
->length
== 0)
41 if (pptt_ref
+ entry
->length
> table_hdr
->length
)
47 static struct acpi_pptt_processor
*fetch_pptt_node(struct acpi_table_header
*table_hdr
,
50 return (struct acpi_pptt_processor
*)fetch_pptt_subtable(table_hdr
, pptt_ref
);
53 static struct acpi_pptt_cache
*fetch_pptt_cache(struct acpi_table_header
*table_hdr
,
56 return (struct acpi_pptt_cache
*)fetch_pptt_subtable(table_hdr
, pptt_ref
);
59 static struct acpi_subtable_header
*acpi_get_pptt_resource(struct acpi_table_header
*table_hdr
,
60 struct acpi_pptt_processor
*node
,
65 if (resource
>= node
->number_of_priv_resources
)
68 ref
= ACPI_ADD_PTR(u32
, node
, sizeof(struct acpi_pptt_processor
));
71 return fetch_pptt_subtable(table_hdr
, *ref
);
74 static inline bool acpi_pptt_match_type(int table_type
, int type
)
76 return ((table_type
& ACPI_PPTT_MASK_CACHE_TYPE
) == type
||
77 table_type
& ACPI_PPTT_CACHE_TYPE_UNIFIED
& type
);
81 * acpi_pptt_walk_cache() - Attempt to find the requested acpi_pptt_cache
82 * @table_hdr: Pointer to the head of the PPTT table
83 * @local_level: passed res reflects this cache level
84 * @res: cache resource in the PPTT we want to walk
85 * @found: returns a pointer to the requested level if found
86 * @level: the requested cache level
87 * @type: the requested cache type
89 * Attempt to find a given cache level, while counting the max number
90 * of cache levels for the cache node.
92 * Given a pptt resource, verify that it is a cache node, then walk
93 * down each level of caches, counting how many levels are found
94 * as well as checking the cache type (icache, dcache, unified). If a
95 * level & type match, then we set found, and continue the search.
96 * Once the entire cache branch has been walked return its max
99 * Return: The cache structure and the level we terminated with.
101 static int acpi_pptt_walk_cache(struct acpi_table_header
*table_hdr
,
103 struct acpi_subtable_header
*res
,
104 struct acpi_pptt_cache
**found
,
107 struct acpi_pptt_cache
*cache
;
109 if (res
->type
!= ACPI_PPTT_TYPE_CACHE
)
112 cache
= (struct acpi_pptt_cache
*) res
;
116 if (local_level
== level
&&
117 cache
->flags
& ACPI_PPTT_CACHE_TYPE_VALID
&&
118 acpi_pptt_match_type(cache
->attributes
, type
)) {
119 if (*found
!= NULL
&& cache
!= *found
)
120 pr_warn("Found duplicate cache level/type unable to determine uniqueness\n");
122 pr_debug("Found cache @ level %d\n", level
);
125 * continue looking at this node's resource list
126 * to verify that we don't find a duplicate
130 cache
= fetch_pptt_cache(table_hdr
, cache
->next_level_of_cache
);
135 static struct acpi_pptt_cache
*acpi_find_cache_level(struct acpi_table_header
*table_hdr
,
136 struct acpi_pptt_processor
*cpu_node
,
137 int *starting_level
, int level
,
140 struct acpi_subtable_header
*res
;
141 int number_of_levels
= *starting_level
;
143 struct acpi_pptt_cache
*ret
= NULL
;
146 /* walk down from processor node */
147 while ((res
= acpi_get_pptt_resource(table_hdr
, cpu_node
, resource
))) {
150 local_level
= acpi_pptt_walk_cache(table_hdr
, *starting_level
,
151 res
, &ret
, level
, type
);
153 * we are looking for the max depth. Since its potentially
154 * possible for a given node to have resources with differing
155 * depths verify that the depth we have found is the largest.
157 if (number_of_levels
< local_level
)
158 number_of_levels
= local_level
;
160 if (number_of_levels
> *starting_level
)
161 *starting_level
= number_of_levels
;
167 * acpi_count_levels() - Given a PPTT table, and a cpu node, count the caches
168 * @table_hdr: Pointer to the head of the PPTT table
169 * @cpu_node: processor node we wish to count caches for
171 * Given a processor node containing a processing unit, walk into it and count
172 * how many levels exist solely for it, and then walk up each level until we hit
173 * the root node (ignore the package level because it may be possible to have
174 * caches that exist across packages). Count the number of cache levels that
175 * exist at each level on the way up.
177 * Return: Total number of levels found.
179 static int acpi_count_levels(struct acpi_table_header
*table_hdr
,
180 struct acpi_pptt_processor
*cpu_node
)
182 int total_levels
= 0;
185 acpi_find_cache_level(table_hdr
, cpu_node
, &total_levels
, 0, 0);
186 cpu_node
= fetch_pptt_node(table_hdr
, cpu_node
->parent
);
193 * acpi_pptt_leaf_node() - Given a processor node, determine if its a leaf
194 * @table_hdr: Pointer to the head of the PPTT table
195 * @node: passed node is checked to see if its a leaf
197 * Determine if the *node parameter is a leaf node by iterating the
198 * PPTT table, looking for nodes which reference it.
200 * Return: 0 if we find a node referencing the passed node (or table error),
203 static int acpi_pptt_leaf_node(struct acpi_table_header
*table_hdr
,
204 struct acpi_pptt_processor
*node
)
206 struct acpi_subtable_header
*entry
;
207 unsigned long table_end
;
209 struct acpi_pptt_processor
*cpu_node
;
212 table_end
= (unsigned long)table_hdr
+ table_hdr
->length
;
213 node_entry
= ACPI_PTR_DIFF(node
, table_hdr
);
214 entry
= ACPI_ADD_PTR(struct acpi_subtable_header
, table_hdr
,
215 sizeof(struct acpi_table_pptt
));
216 proc_sz
= sizeof(struct acpi_pptt_processor
*);
218 while ((unsigned long)entry
+ proc_sz
< table_end
) {
219 cpu_node
= (struct acpi_pptt_processor
*)entry
;
220 if (entry
->type
== ACPI_PPTT_TYPE_PROCESSOR
&&
221 cpu_node
->parent
== node_entry
)
223 if (entry
->length
== 0)
225 entry
= ACPI_ADD_PTR(struct acpi_subtable_header
, entry
,
233 * acpi_find_processor_node() - Given a PPTT table find the requested processor
234 * @table_hdr: Pointer to the head of the PPTT table
235 * @acpi_cpu_id: cpu we are searching for
237 * Find the subtable entry describing the provided processor.
238 * This is done by iterating the PPTT table looking for processor nodes
239 * which have an acpi_processor_id that matches the acpi_cpu_id parameter
240 * passed into the function. If we find a node that matches this criteria
241 * we verify that its a leaf node in the topology rather than depending
242 * on the valid flag, which doesn't need to be set for leaf nodes.
244 * Return: NULL, or the processors acpi_pptt_processor*
246 static struct acpi_pptt_processor
*acpi_find_processor_node(struct acpi_table_header
*table_hdr
,
249 struct acpi_subtable_header
*entry
;
250 unsigned long table_end
;
251 struct acpi_pptt_processor
*cpu_node
;
254 table_end
= (unsigned long)table_hdr
+ table_hdr
->length
;
255 entry
= ACPI_ADD_PTR(struct acpi_subtable_header
, table_hdr
,
256 sizeof(struct acpi_table_pptt
));
257 proc_sz
= sizeof(struct acpi_pptt_processor
*);
259 /* find the processor structure associated with this cpuid */
260 while ((unsigned long)entry
+ proc_sz
< table_end
) {
261 cpu_node
= (struct acpi_pptt_processor
*)entry
;
263 if (entry
->length
== 0) {
264 pr_warn("Invalid zero length subtable\n");
267 if (entry
->type
== ACPI_PPTT_TYPE_PROCESSOR
&&
268 acpi_cpu_id
== cpu_node
->acpi_processor_id
&&
269 acpi_pptt_leaf_node(table_hdr
, cpu_node
)) {
270 return (struct acpi_pptt_processor
*)entry
;
273 entry
= ACPI_ADD_PTR(struct acpi_subtable_header
, entry
,
280 static int acpi_find_cache_levels(struct acpi_table_header
*table_hdr
,
283 int number_of_levels
= 0;
284 struct acpi_pptt_processor
*cpu
;
286 cpu
= acpi_find_processor_node(table_hdr
, acpi_cpu_id
);
288 number_of_levels
= acpi_count_levels(table_hdr
, cpu
);
290 return number_of_levels
;
293 static u8
acpi_cache_type(enum cache_type type
)
296 case CACHE_TYPE_DATA
:
297 pr_debug("Looking for data cache\n");
298 return ACPI_PPTT_CACHE_TYPE_DATA
;
299 case CACHE_TYPE_INST
:
300 pr_debug("Looking for instruction cache\n");
301 return ACPI_PPTT_CACHE_TYPE_INSTR
;
303 case CACHE_TYPE_UNIFIED
:
304 pr_debug("Looking for unified cache\n");
306 * It is important that ACPI_PPTT_CACHE_TYPE_UNIFIED
307 * contains the bit pattern that will match both
308 * ACPI unified bit patterns because we use it later
309 * to match both cases.
311 return ACPI_PPTT_CACHE_TYPE_UNIFIED
;
315 static struct acpi_pptt_cache
*acpi_find_cache_node(struct acpi_table_header
*table_hdr
,
317 enum cache_type type
,
319 struct acpi_pptt_processor
**node
)
321 int total_levels
= 0;
322 struct acpi_pptt_cache
*found
= NULL
;
323 struct acpi_pptt_processor
*cpu_node
;
324 u8 acpi_type
= acpi_cache_type(type
);
326 pr_debug("Looking for CPU %d's level %d cache type %d\n",
327 acpi_cpu_id
, level
, acpi_type
);
329 cpu_node
= acpi_find_processor_node(table_hdr
, acpi_cpu_id
);
331 while (cpu_node
&& !found
) {
332 found
= acpi_find_cache_level(table_hdr
, cpu_node
,
333 &total_levels
, level
, acpi_type
);
335 cpu_node
= fetch_pptt_node(table_hdr
, cpu_node
->parent
);
341 /* total number of attributes checked by the properties code */
342 #define PPTT_CHECKED_ATTRIBUTES 4
345 * update_cache_properties() - Update cacheinfo for the given processor
346 * @this_leaf: Kernel cache info structure being updated
347 * @found_cache: The PPTT node describing this cache instance
348 * @cpu_node: A unique reference to describe this cache instance
350 * The ACPI spec implies that the fields in the cache structures are used to
351 * extend and correct the information probed from the hardware. Lets only
352 * set fields that we determine are VALID.
354 * Return: nothing. Side effect of updating the global cacheinfo
356 static void update_cache_properties(struct cacheinfo
*this_leaf
,
357 struct acpi_pptt_cache
*found_cache
,
358 struct acpi_pptt_processor
*cpu_node
)
362 this_leaf
->fw_token
= cpu_node
;
363 if (found_cache
->flags
& ACPI_PPTT_SIZE_PROPERTY_VALID
) {
364 this_leaf
->size
= found_cache
->size
;
367 if (found_cache
->flags
& ACPI_PPTT_LINE_SIZE_VALID
) {
368 this_leaf
->coherency_line_size
= found_cache
->line_size
;
371 if (found_cache
->flags
& ACPI_PPTT_NUMBER_OF_SETS_VALID
) {
372 this_leaf
->number_of_sets
= found_cache
->number_of_sets
;
375 if (found_cache
->flags
& ACPI_PPTT_ASSOCIATIVITY_VALID
) {
376 this_leaf
->ways_of_associativity
= found_cache
->associativity
;
379 if (found_cache
->flags
& ACPI_PPTT_WRITE_POLICY_VALID
) {
380 switch (found_cache
->attributes
& ACPI_PPTT_MASK_WRITE_POLICY
) {
381 case ACPI_PPTT_CACHE_POLICY_WT
:
382 this_leaf
->attributes
= CACHE_WRITE_THROUGH
;
384 case ACPI_PPTT_CACHE_POLICY_WB
:
385 this_leaf
->attributes
= CACHE_WRITE_BACK
;
389 if (found_cache
->flags
& ACPI_PPTT_ALLOCATION_TYPE_VALID
) {
390 switch (found_cache
->attributes
& ACPI_PPTT_MASK_ALLOCATION_TYPE
) {
391 case ACPI_PPTT_CACHE_READ_ALLOCATE
:
392 this_leaf
->attributes
|= CACHE_READ_ALLOCATE
;
394 case ACPI_PPTT_CACHE_WRITE_ALLOCATE
:
395 this_leaf
->attributes
|= CACHE_WRITE_ALLOCATE
;
397 case ACPI_PPTT_CACHE_RW_ALLOCATE
:
398 case ACPI_PPTT_CACHE_RW_ALLOCATE_ALT
:
399 this_leaf
->attributes
|=
400 CACHE_READ_ALLOCATE
| CACHE_WRITE_ALLOCATE
;
405 * If the above flags are valid, and the cache type is NOCACHE
406 * update the cache type as well.
408 if (this_leaf
->type
== CACHE_TYPE_NOCACHE
&&
409 valid_flags
== PPTT_CHECKED_ATTRIBUTES
)
410 this_leaf
->type
= CACHE_TYPE_UNIFIED
;
413 static void cache_setup_acpi_cpu(struct acpi_table_header
*table
,
416 struct acpi_pptt_cache
*found_cache
;
417 struct cpu_cacheinfo
*this_cpu_ci
= get_cpu_cacheinfo(cpu
);
418 u32 acpi_cpu_id
= get_acpi_id_for_cpu(cpu
);
419 struct cacheinfo
*this_leaf
;
420 unsigned int index
= 0;
421 struct acpi_pptt_processor
*cpu_node
= NULL
;
423 while (index
< get_cpu_cacheinfo(cpu
)->num_leaves
) {
424 this_leaf
= this_cpu_ci
->info_list
+ index
;
425 found_cache
= acpi_find_cache_node(table
, acpi_cpu_id
,
429 pr_debug("found = %p %p\n", found_cache
, cpu_node
);
431 update_cache_properties(this_leaf
,
439 /* Passing level values greater than this will result in search termination */
440 #define PPTT_ABORT_PACKAGE 0xFF
442 static struct acpi_pptt_processor
*acpi_find_processor_package_id(struct acpi_table_header
*table_hdr
,
443 struct acpi_pptt_processor
*cpu
,
446 struct acpi_pptt_processor
*prev_node
;
448 while (cpu
&& level
) {
449 if (cpu
->flags
& flag
)
451 pr_debug("level %d\n", level
);
452 prev_node
= fetch_pptt_node(table_hdr
, cpu
->parent
);
453 if (prev_node
== NULL
)
462 * topology_get_acpi_cpu_tag() - Find a unique topology value for a feature
463 * @table: Pointer to the head of the PPTT table
464 * @cpu: Kernel logical cpu number
465 * @level: A level that terminates the search
466 * @flag: A flag which terminates the search
468 * Get a unique value given a cpu, and a topology level, that can be
469 * matched to determine which cpus share common topological features
472 * Return: Unique value, or -ENOENT if unable to locate cpu
474 static int topology_get_acpi_cpu_tag(struct acpi_table_header
*table
,
475 unsigned int cpu
, int level
, int flag
)
477 struct acpi_pptt_processor
*cpu_node
;
478 u32 acpi_cpu_id
= get_acpi_id_for_cpu(cpu
);
480 cpu_node
= acpi_find_processor_node(table
, acpi_cpu_id
);
482 cpu_node
= acpi_find_processor_package_id(table
, cpu_node
,
485 * As per specification if the processor structure represents
486 * an actual processor, then ACPI processor ID must be valid.
487 * For processor containers ACPI_PPTT_ACPI_PROCESSOR_ID_VALID
488 * should be set if the UID is valid
491 cpu_node
->flags
& ACPI_PPTT_ACPI_PROCESSOR_ID_VALID
)
492 return cpu_node
->acpi_processor_id
;
493 return ACPI_PTR_DIFF(cpu_node
, table
);
495 pr_warn_once("PPTT table found, but unable to locate core %d (%d)\n",
500 static int find_acpi_cpu_topology_tag(unsigned int cpu
, int level
, int flag
)
502 struct acpi_table_header
*table
;
506 status
= acpi_get_table(ACPI_SIG_PPTT
, 0, &table
);
507 if (ACPI_FAILURE(status
)) {
508 pr_warn_once("No PPTT table found, cpu topology may be inaccurate\n");
511 retval
= topology_get_acpi_cpu_tag(table
, cpu
, level
, flag
);
512 pr_debug("Topology Setup ACPI cpu %d, level %d ret = %d\n",
514 acpi_put_table(table
);
520 * acpi_find_last_cache_level() - Determines the number of cache levels for a PE
521 * @cpu: Kernel logical cpu number
523 * Given a logical cpu number, returns the number of levels of cache represented
524 * in the PPTT. Errors caused by lack of a PPTT table, or otherwise, return 0
525 * indicating we didn't find any cache levels.
527 * Return: Cache levels visible to this core.
529 int acpi_find_last_cache_level(unsigned int cpu
)
532 struct acpi_table_header
*table
;
533 int number_of_levels
= 0;
536 pr_debug("Cache Setup find last level cpu=%d\n", cpu
);
538 acpi_cpu_id
= get_acpi_id_for_cpu(cpu
);
539 status
= acpi_get_table(ACPI_SIG_PPTT
, 0, &table
);
540 if (ACPI_FAILURE(status
)) {
541 pr_warn_once("No PPTT table found, cache topology may be inaccurate\n");
543 number_of_levels
= acpi_find_cache_levels(table
, acpi_cpu_id
);
544 acpi_put_table(table
);
546 pr_debug("Cache Setup find last level level=%d\n", number_of_levels
);
548 return number_of_levels
;
552 * cache_setup_acpi() - Override CPU cache topology with data from the PPTT
553 * @cpu: Kernel logical cpu number
555 * Updates the global cache info provided by cpu_get_cacheinfo()
556 * when there are valid properties in the acpi_pptt_cache nodes. A
557 * successful parse may not result in any updates if none of the
558 * cache levels have any valid flags set. Futher, a unique value is
559 * associated with each known CPU cache entry. This unique value
560 * can be used to determine whether caches are shared between cpus.
562 * Return: -ENOENT on failure to find table, or 0 on success
564 int cache_setup_acpi(unsigned int cpu
)
566 struct acpi_table_header
*table
;
569 pr_debug("Cache Setup ACPI cpu %d\n", cpu
);
571 status
= acpi_get_table(ACPI_SIG_PPTT
, 0, &table
);
572 if (ACPI_FAILURE(status
)) {
573 pr_warn_once("No PPTT table found, cache topology may be inaccurate\n");
577 cache_setup_acpi_cpu(table
, cpu
);
578 acpi_put_table(table
);
584 * find_acpi_cpu_topology() - Determine a unique topology value for a given cpu
585 * @cpu: Kernel logical cpu number
586 * @level: The topological level for which we would like a unique ID
588 * Determine a topology unique ID for each thread/core/cluster/mc_grouping
589 * /socket/etc. This ID can then be used to group peers, which will have
592 * The search terminates when either the requested level is found or
593 * we reach a root node. Levels beyond the termination point will return the
594 * same unique ID. The unique id for level 0 is the acpi processor id. All
595 * other levels beyond this use a generated value to uniquely identify
596 * a topological feature.
598 * Return: -ENOENT if the PPTT doesn't exist, or the cpu cannot be found.
599 * Otherwise returns a value which represents a unique topological feature.
601 int find_acpi_cpu_topology(unsigned int cpu
, int level
)
603 return find_acpi_cpu_topology_tag(cpu
, level
, 0);
607 * find_acpi_cpu_cache_topology() - Determine a unique cache topology value
608 * @cpu: Kernel logical cpu number
609 * @level: The cache level for which we would like a unique ID
611 * Determine a unique ID for each unified cache in the system
613 * Return: -ENOENT if the PPTT doesn't exist, or the cpu cannot be found.
614 * Otherwise returns a value which represents a unique topological feature.
616 int find_acpi_cpu_cache_topology(unsigned int cpu
, int level
)
618 struct acpi_table_header
*table
;
619 struct acpi_pptt_cache
*found_cache
;
621 u32 acpi_cpu_id
= get_acpi_id_for_cpu(cpu
);
622 struct acpi_pptt_processor
*cpu_node
= NULL
;
625 status
= acpi_get_table(ACPI_SIG_PPTT
, 0, &table
);
626 if (ACPI_FAILURE(status
)) {
627 pr_warn_once("No PPTT table found, topology may be inaccurate\n");
631 found_cache
= acpi_find_cache_node(table
, acpi_cpu_id
,
636 ret
= ACPI_PTR_DIFF(cpu_node
, table
);
638 acpi_put_table(table
);
645 * find_acpi_cpu_topology_package() - Determine a unique cpu package value
646 * @cpu: Kernel logical cpu number
648 * Determine a topology unique package ID for the given cpu.
649 * This ID can then be used to group peers, which will have matching ids.
651 * The search terminates when either a level is found with the PHYSICAL_PACKAGE
652 * flag set or we reach a root node.
654 * Return: -ENOENT if the PPTT doesn't exist, or the cpu cannot be found.
655 * Otherwise returns a value which represents the package for this cpu.
657 int find_acpi_cpu_topology_package(unsigned int cpu
)
659 return find_acpi_cpu_topology_tag(cpu
, PPTT_ABORT_PACKAGE
,
660 ACPI_PPTT_PHYSICAL_PACKAGE
);