[PATCH v2 0/5] arm64: SPE ACPI enablement

[PATCH v2 0/5] arm64: SPE ACPI enablement

[Jeremy Linton]

This patch series enables the Arm Statistical Profiling
Extension (SPE) on ACPI platforms.

This is possible because ACPI 6.3 uses a previously
reserved field in the MADT to store the SPE interrupt
number, similarly to how the normal PMU is described.
If a consistent valid interrupt exists across all the
cores in the system, a platform device is registered.
That then triggers the SPE module, which runs as normal.

This version also adds the ability to parse the PPTT for
IDENTICAL cores. We then use this to sanity check the
single SPE device we create. This creates a bit of a
problem with respect to the specification though. The
specification says that its legal for multiple tree's
to exist in the PPTT. We handle this fine, but what
happens in the case of multiple tree's is that the lack
of a common node with IDENTICAL set forces us to assume
that there are multiple non IDENTICAL cores in the
machine.

v1->v2: Wrap the code which creates the SPE device in
    a new CONFIG_ARM_SPE_ACPI ifdef.
	Move arm,spe-v1 device name into common header file
	Some comment/case sensitivity/function name changes.

Jeremy Linton (5):
  ACPI/PPTT: Trivial, Modify the case of CPU
  ACPI/PPTT: Add function to return ACPI 6.3 Identical tokens
  ACPI/PPTT: Modify node flag detection to find last IDENTICAL
  arm_pmu: acpi: spe: Add initial MADT/SPE probing
  perf: arm_spe: Enable ACPI/Platform automatic module loading

 arch/arm64/include/asm/acpi.h |   3 +
 drivers/acpi/pptt.c           | 130 +++++++++++++++++++++++++---------
 drivers/perf/Kconfig          |   5 ++
 drivers/perf/arm_pmu_acpi.c   |  76 ++++++++++++++++++++
 drivers/perf/arm_spe_pmu.c    |  12 +++-
 include/linux/acpi.h          |   5 ++
 include/linux/perf/arm_pmu.h  |   2 +
 7 files changed, 196 insertions(+), 37 deletions(-)

-- 
2.20.1

[PATCH v2 0/5] arm64: SPE ACPI enablement

[Jeremy Linton]

This patch series enables the Arm Statistical Profiling
Extension (SPE) on ACPI platforms.

This is possible because ACPI 6.3 uses a previously
reserved field in the MADT to store the SPE interrupt
number, similarly to how the normal PMU is described.
If a consistent valid interrupt exists across all the
cores in the system, a platform device is registered.
That then triggers the SPE module, which runs as normal.

This version also adds the ability to parse the PPTT for
IDENTICAL cores. We then use this to sanity check the
single SPE device we create. This creates a bit of a
problem with respect to the specification though. The
specification says that its legal for multiple tree's
to exist in the PPTT. We handle this fine, but what
happens in the case of multiple tree's is that the lack
of a common node with IDENTICAL set forces us to assume
that there are multiple non IDENTICAL cores in the
machine.

v1->v2: Wrap the code which creates the SPE device in
    a new CONFIG_ARM_SPE_ACPI ifdef.
	Move arm,spe-v1 device name into common header file
	Some comment/case sensitivity/function name changes.

Jeremy Linton (5):
  ACPI/PPTT: Trivial, Modify the case of CPU
  ACPI/PPTT: Add function to return ACPI 6.3 Identical tokens
  ACPI/PPTT: Modify node flag detection to find last IDENTICAL
  arm_pmu: acpi: spe: Add initial MADT/SPE probing
  perf: arm_spe: Enable ACPI/Platform automatic module loading

 arch/arm64/include/asm/acpi.h |   3 +
 drivers/acpi/pptt.c           | 130 +++++++++++++++++++++++++---------
 drivers/perf/Kconfig          |   5 ++
 drivers/perf/arm_pmu_acpi.c   |  76 ++++++++++++++++++++
 drivers/perf/arm_spe_pmu.c    |  12 +++-
 include/linux/acpi.h          |   5 ++
 include/linux/perf/arm_pmu.h  |   2 +
 7 files changed, 196 insertions(+), 37 deletions(-)

-- 
2.20.1

[PATCH v2 1/5] ACPI/PPTT: Trivial, Modify the case of CPU

[Jeremy Linton]

CPU is an acronym and customarily capitalized. Much of the
commenting in the PPTT code has been using "cpu" rather
than "CPU". Correct that, and other human readable strings.

Signed-off-by: Jeremy Linton <jeremy.linton@arm.com>
---
 drivers/acpi/pptt.c | 48 ++++++++++++++++++++++-----------------------
 1 file changed, 24 insertions(+), 24 deletions(-)

diff --git a/drivers/acpi/pptt.c b/drivers/acpi/pptt.c
index 065c4fc245d1..83a026765faa 100644
--- a/drivers/acpi/pptt.c
+++ b/drivers/acpi/pptt.c
@@ -164,7 +164,7 @@ static struct acpi_pptt_cache *acpi_find_cache_level(struct acpi_table_header *t
 }
 
 /**
- * acpi_count_levels() - Given a PPTT table, and a cpu node, count the caches
+ * acpi_count_levels() - Given a PPTT table, and a CPU node, count the caches
  * @table_hdr: Pointer to the head of the PPTT table
  * @cpu_node: processor node we wish to count caches for
  *
@@ -235,7 +235,7 @@ static int acpi_pptt_leaf_node(struct acpi_table_header *table_hdr,
 /**
  * acpi_find_processor_node() - Given a PPTT table find the requested processor
  * @table_hdr:  Pointer to the head of the PPTT table
- * @acpi_cpu_id: cpu we are searching for
+ * @acpi_cpu_id: CPU we are searching for
  *
  * Find the subtable entry describing the provided processor.
  * This is done by iterating the PPTT table looking for processor nodes
@@ -456,21 +456,21 @@ static struct acpi_pptt_processor *acpi_find_processor_package_id(struct acpi_ta
 
 static void acpi_pptt_warn_missing(void)
 {
-	pr_warn_once("No PPTT table found, cpu and cache topology may be inaccurate\n");
+	pr_warn_once("No PPTT table found, CPU and cache topology may be inaccurate\n");
 }
 
 /**
  * topology_get_acpi_cpu_tag() - Find a unique topology value for a feature
  * @table: Pointer to the head of the PPTT table
- * @cpu: Kernel logical cpu number
+ * @cpu: Kernel logical CPU number
  * @level: A level that terminates the search
  * @flag: A flag which terminates the search
  *
- * Get a unique value given a cpu, and a topology level, that can be
- * matched to determine which cpus share common topological features
+ * Get a unique value given a CPU, and a topology level, that can be
+ * matched to determine which CPUs share common topological features
  * at that level.
  *
- * Return: Unique value, or -ENOENT if unable to locate cpu
+ * Return: Unique value, or -ENOENT if unable to locate CPU
  */
 static int topology_get_acpi_cpu_tag(struct acpi_table_header *table,
 				     unsigned int cpu, int level, int flag)
@@ -510,7 +510,7 @@ static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, int flag)
 		return -ENOENT;
 	}
 	retval = topology_get_acpi_cpu_tag(table, cpu, level, flag);
-	pr_debug("Topology Setup ACPI cpu %d, level %d ret = %d\n",
+	pr_debug("Topology Setup ACPI CPU %d, level %d ret = %d\n",
 		 cpu, level, retval);
 	acpi_put_table(table);
 
@@ -519,9 +519,9 @@ static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, int flag)
 
 /**
  * acpi_find_last_cache_level() - Determines the number of cache levels for a PE
- * @cpu: Kernel logical cpu number
+ * @cpu: Kernel logical CPU number
  *
- * Given a logical cpu number, returns the number of levels of cache represented
+ * Given a logical CPU number, returns the number of levels of cache represented
  * in the PPTT. Errors caused by lack of a PPTT table, or otherwise, return 0
  * indicating we didn't find any cache levels.
  *
@@ -534,7 +534,7 @@ int acpi_find_last_cache_level(unsigned int cpu)
 	int number_of_levels = 0;
 	acpi_status status;
 
-	pr_debug("Cache Setup find last level cpu=%d\n", cpu);
+	pr_debug("Cache Setup find last level CPU=%d\n", cpu);
 
 	acpi_cpu_id = get_acpi_id_for_cpu(cpu);
 	status = acpi_get_table(ACPI_SIG_PPTT, 0, &table);
@@ -551,14 +551,14 @@ int acpi_find_last_cache_level(unsigned int cpu)
 
 /**
  * cache_setup_acpi() - Override CPU cache topology with data from the PPTT
- * @cpu: Kernel logical cpu number
+ * @cpu: Kernel logical CPU number
  *
  * Updates the global cache info provided by cpu_get_cacheinfo()
  * when there are valid properties in the acpi_pptt_cache nodes. A
  * successful parse may not result in any updates if none of the
  * cache levels have any valid flags set.  Futher, a unique value is
  * associated with each known CPU cache entry. This unique value
- * can be used to determine whether caches are shared between cpus.
+ * can be used to determine whether caches are shared between CPUs.
  *
  * Return: -ENOENT on failure to find table, or 0 on success
  */
@@ -567,7 +567,7 @@ int cache_setup_acpi(unsigned int cpu)
 	struct acpi_table_header *table;
 	acpi_status status;
 
-	pr_debug("Cache Setup ACPI cpu %d\n", cpu);
+	pr_debug("Cache Setup ACPI CPU %d\n", cpu);
 
 	status = acpi_get_table(ACPI_SIG_PPTT, 0, &table);
 	if (ACPI_FAILURE(status)) {
@@ -582,8 +582,8 @@ int cache_setup_acpi(unsigned int cpu)
 }
 
 /**
- * find_acpi_cpu_topology() - Determine a unique topology value for a given cpu
- * @cpu: Kernel logical cpu number
+ * find_acpi_cpu_topology() - Determine a unique topology value for a given CPU
+ * @cpu: Kernel logical CPU number
  * @level: The topological level for which we would like a unique ID
  *
  * Determine a topology unique ID for each thread/core/cluster/mc_grouping
@@ -596,7 +596,7 @@ int cache_setup_acpi(unsigned int cpu)
  * other levels beyond this use a generated value to uniquely identify
  * a topological feature.
  *
- * Return: -ENOENT if the PPTT doesn't exist, or the cpu cannot be found.
+ * Return: -ENOENT if the PPTT doesn't exist, or the CPU cannot be found.
  * Otherwise returns a value which represents a unique topological feature.
  */
 int find_acpi_cpu_topology(unsigned int cpu, int level)
@@ -606,12 +606,12 @@ int find_acpi_cpu_topology(unsigned int cpu, int level)
 
 /**
  * find_acpi_cpu_cache_topology() - Determine a unique cache topology value
- * @cpu: Kernel logical cpu number
+ * @cpu: Kernel logical CPU number
  * @level: The cache level for which we would like a unique ID
  *
  * Determine a unique ID for each unified cache in the system
  *
- * Return: -ENOENT if the PPTT doesn't exist, or the cpu cannot be found.
+ * Return: -ENOENT if the PPTT doesn't exist, or the CPU cannot be found.
  * Otherwise returns a value which represents a unique topological feature.
  */
 int find_acpi_cpu_cache_topology(unsigned int cpu, int level)
@@ -643,17 +643,17 @@ int find_acpi_cpu_cache_topology(unsigned int cpu, int level)
 
 
 /**
- * find_acpi_cpu_topology_package() - Determine a unique cpu package value
- * @cpu: Kernel logical cpu number
+ * find_acpi_cpu_topology_package() - Determine a unique CPU package value
+ * @cpu: Kernel logical CPU number
  *
- * Determine a topology unique package ID for the given cpu.
+ * Determine a topology unique package ID for the given CPU.
  * This ID can then be used to group peers, which will have matching ids.
  *
  * The search terminates when either a level is found with the PHYSICAL_PACKAGE
  * flag set or we reach a root node.
  *
- * Return: -ENOENT if the PPTT doesn't exist, or the cpu cannot be found.
- * Otherwise returns a value which represents the package for this cpu.
+ * Return: -ENOENT if the PPTT doesn't exist, or the CPU cannot be found.
+ * Otherwise returns a value which represents the package for this CPU.
  */
 int find_acpi_cpu_topology_package(unsigned int cpu)
 {
-- 
2.20.1

[PATCH v2 1/5] ACPI/PPTT: Trivial, Modify the case of CPU

[Jeremy Linton]

CPU is an acronym and customarily capitalized. Much of the
commenting in the PPTT code has been using "cpu" rather
than "CPU". Correct that, and other human readable strings.

Signed-off-by: Jeremy Linton <jeremy.linton@arm.com>
---
 drivers/acpi/pptt.c | 48 ++++++++++++++++++++++-----------------------
 1 file changed, 24 insertions(+), 24 deletions(-)

diff --git a/drivers/acpi/pptt.c b/drivers/acpi/pptt.c
index 065c4fc245d1..83a026765faa 100644
--- a/drivers/acpi/pptt.c
+++ b/drivers/acpi/pptt.c
@@ -164,7 +164,7 @@ static struct acpi_pptt_cache *acpi_find_cache_level(struct acpi_table_header *t
 }
 
 /**
- * acpi_count_levels() - Given a PPTT table, and a cpu node, count the caches
+ * acpi_count_levels() - Given a PPTT table, and a CPU node, count the caches
  * @table_hdr: Pointer to the head of the PPTT table
  * @cpu_node: processor node we wish to count caches for
  *
@@ -235,7 +235,7 @@ static int acpi_pptt_leaf_node(struct acpi_table_header *table_hdr,
 /**
  * acpi_find_processor_node() - Given a PPTT table find the requested processor
  * @table_hdr:  Pointer to the head of the PPTT table
- * @acpi_cpu_id: cpu we are searching for
+ * @acpi_cpu_id: CPU we are searching for
  *
  * Find the subtable entry describing the provided processor.
  * This is done by iterating the PPTT table looking for processor nodes
@@ -456,21 +456,21 @@ static struct acpi_pptt_processor *acpi_find_processor_package_id(struct acpi_ta
 
 static void acpi_pptt_warn_missing(void)
 {
-	pr_warn_once("No PPTT table found, cpu and cache topology may be inaccurate\n");
+	pr_warn_once("No PPTT table found, CPU and cache topology may be inaccurate\n");
 }
 
 /**
  * topology_get_acpi_cpu_tag() - Find a unique topology value for a feature
  * @table: Pointer to the head of the PPTT table
- * @cpu: Kernel logical cpu number
+ * @cpu: Kernel logical CPU number
  * @level: A level that terminates the search
  * @flag: A flag which terminates the search
  *
- * Get a unique value given a cpu, and a topology level, that can be
- * matched to determine which cpus share common topological features
+ * Get a unique value given a CPU, and a topology level, that can be
+ * matched to determine which CPUs share common topological features
  * at that level.
  *
- * Return: Unique value, or -ENOENT if unable to locate cpu
+ * Return: Unique value, or -ENOENT if unable to locate CPU
  */
 static int topology_get_acpi_cpu_tag(struct acpi_table_header *table,
 				     unsigned int cpu, int level, int flag)
@@ -510,7 +510,7 @@ static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, int flag)
 		return -ENOENT;
 	}
 	retval = topology_get_acpi_cpu_tag(table, cpu, level, flag);
-	pr_debug("Topology Setup ACPI cpu %d, level %d ret = %d\n",
+	pr_debug("Topology Setup ACPI CPU %d, level %d ret = %d\n",
 		 cpu, level, retval);
 	acpi_put_table(table);
 
@@ -519,9 +519,9 @@ static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, int flag)
 
 /**
  * acpi_find_last_cache_level() - Determines the number of cache levels for a PE
- * @cpu: Kernel logical cpu number
+ * @cpu: Kernel logical CPU number
  *
- * Given a logical cpu number, returns the number of levels of cache represented
+ * Given a logical CPU number, returns the number of levels of cache represented
  * in the PPTT. Errors caused by lack of a PPTT table, or otherwise, return 0
  * indicating we didn't find any cache levels.
  *
@@ -534,7 +534,7 @@ int acpi_find_last_cache_level(unsigned int cpu)
 	int number_of_levels = 0;
 	acpi_status status;
 
-	pr_debug("Cache Setup find last level cpu=%d\n", cpu);
+	pr_debug("Cache Setup find last level CPU=%d\n", cpu);
 
 	acpi_cpu_id = get_acpi_id_for_cpu(cpu);
 	status = acpi_get_table(ACPI_SIG_PPTT, 0, &table);
@@ -551,14 +551,14 @@ int acpi_find_last_cache_level(unsigned int cpu)
 
 /**
  * cache_setup_acpi() - Override CPU cache topology with data from the PPTT
- * @cpu: Kernel logical cpu number
+ * @cpu: Kernel logical CPU number
  *
  * Updates the global cache info provided by cpu_get_cacheinfo()
  * when there are valid properties in the acpi_pptt_cache nodes. A
  * successful parse may not result in any updates if none of the
  * cache levels have any valid flags set.  Futher, a unique value is
  * associated with each known CPU cache entry. This unique value
- * can be used to determine whether caches are shared between cpus.
+ * can be used to determine whether caches are shared between CPUs.
  *
  * Return: -ENOENT on failure to find table, or 0 on success
  */
@@ -567,7 +567,7 @@ int cache_setup_acpi(unsigned int cpu)
 	struct acpi_table_header *table;
 	acpi_status status;
 
-	pr_debug("Cache Setup ACPI cpu %d\n", cpu);
+	pr_debug("Cache Setup ACPI CPU %d\n", cpu);
 
 	status = acpi_get_table(ACPI_SIG_PPTT, 0, &table);
 	if (ACPI_FAILURE(status)) {
@@ -582,8 +582,8 @@ int cache_setup_acpi(unsigned int cpu)
 }
 
 /**
- * find_acpi_cpu_topology() - Determine a unique topology value for a given cpu
- * @cpu: Kernel logical cpu number
+ * find_acpi_cpu_topology() - Determine a unique topology value for a given CPU
+ * @cpu: Kernel logical CPU number
  * @level: The topological level for which we would like a unique ID
  *
  * Determine a topology unique ID for each thread/core/cluster/mc_grouping
@@ -596,7 +596,7 @@ int cache_setup_acpi(unsigned int cpu)
  * other levels beyond this use a generated value to uniquely identify
  * a topological feature.
  *
- * Return: -ENOENT if the PPTT doesn't exist, or the cpu cannot be found.
+ * Return: -ENOENT if the PPTT doesn't exist, or the CPU cannot be found.
  * Otherwise returns a value which represents a unique topological feature.
  */
 int find_acpi_cpu_topology(unsigned int cpu, int level)
@@ -606,12 +606,12 @@ int find_acpi_cpu_topology(unsigned int cpu, int level)
 
 /**
  * find_acpi_cpu_cache_topology() - Determine a unique cache topology value
- * @cpu: Kernel logical cpu number
+ * @cpu: Kernel logical CPU number
  * @level: The cache level for which we would like a unique ID
  *
  * Determine a unique ID for each unified cache in the system
  *
- * Return: -ENOENT if the PPTT doesn't exist, or the cpu cannot be found.
+ * Return: -ENOENT if the PPTT doesn't exist, or the CPU cannot be found.
  * Otherwise returns a value which represents a unique topological feature.
  */
 int find_acpi_cpu_cache_topology(unsigned int cpu, int level)
@@ -643,17 +643,17 @@ int find_acpi_cpu_cache_topology(unsigned int cpu, int level)
 
 
 /**
- * find_acpi_cpu_topology_package() - Determine a unique cpu package value
- * @cpu: Kernel logical cpu number
+ * find_acpi_cpu_topology_package() - Determine a unique CPU package value
+ * @cpu: Kernel logical CPU number
  *
- * Determine a topology unique package ID for the given cpu.
+ * Determine a topology unique package ID for the given CPU.
  * This ID can then be used to group peers, which will have matching ids.
  *
  * The search terminates when either a level is found with the PHYSICAL_PACKAGE
  * flag set or we reach a root node.
  *
- * Return: -ENOENT if the PPTT doesn't exist, or the cpu cannot be found.
- * Otherwise returns a value which represents the package for this cpu.
+ * Return: -ENOENT if the PPTT doesn't exist, or the CPU cannot be found.
+ * Otherwise returns a value which represents the package for this CPU.
  */
 int find_acpi_cpu_topology_package(unsigned int cpu)
 {
-- 
2.20.1

[PATCH v2 2/5] ACPI/PPTT: Add function to return ACPI 6.3 Identical tokens

[Jeremy Linton]

ACPI 6.3 adds a flag to indicate that child nodes are all
identical cores. This is useful to authoritatively determine
if a set of (possibly offline) cores are identical or not.

Since the flag doesn't give us a unique id we can generate
one and use it to create bitmaps of sibling nodes, or simply
in a loop to determine if a subset of cores are identical.

Signed-off-by: Jeremy Linton <jeremy.linton@arm.com>
---
 drivers/acpi/pptt.c  | 26 ++++++++++++++++++++++++++
 include/linux/acpi.h |  5 +++++
 2 files changed, 31 insertions(+)

diff --git a/drivers/acpi/pptt.c b/drivers/acpi/pptt.c
index 83a026765faa..1865515297ca 100644
--- a/drivers/acpi/pptt.c
+++ b/drivers/acpi/pptt.c
@@ -660,3 +660,29 @@ int find_acpi_cpu_topology_package(unsigned int cpu)
 	return find_acpi_cpu_topology_tag(cpu, PPTT_ABORT_PACKAGE,
 					  ACPI_PPTT_PHYSICAL_PACKAGE);
 }
+
+/**
+ * find_acpi_cpu_topology_hetero_id() - Get a core architecture tag
+ * @cpu: Kernel logical CPU number
+ *
+ * Determine a unique heterogeneous tag for the given CPU. CPUs with the same
+ * implementation should have matching tags.
+ *
+ * The returned tag can be used to group peers with identical implementation.
+ *
+ * The search terminates when a level is found with the identical implementation
+ * flag set or we reach a root node.
+ *
+ * Due to limitations in the PPTT data structure, there may be rare situations
+ * where two cores in a heterogeneous machine may be identical, but won't have
+ * the same tag.
+ *
+ * Return: -ENOENT if the PPTT doesn't exist, or the CPU cannot be found.
+ * Otherwise returns a value which represents a group of identical cores
+ * similar to this CPU.
+ */
+int find_acpi_cpu_topology_hetero_id(unsigned int cpu)
+{
+	return find_acpi_cpu_topology_tag(cpu, PPTT_ABORT_PACKAGE,
+					  ACPI_PPTT_ACPI_IDENTICAL);
+}
diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index d5dcebd7aad3..1444fb042898 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -1309,6 +1309,7 @@ static inline int lpit_read_residency_count_address(u64 *address)
 #ifdef CONFIG_ACPI_PPTT
 int find_acpi_cpu_topology(unsigned int cpu, int level);
 int find_acpi_cpu_topology_package(unsigned int cpu);
+int find_acpi_cpu_topology_hetero_id(unsigned int cpu);
 int find_acpi_cpu_cache_topology(unsigned int cpu, int level);
 #else
 static inline int find_acpi_cpu_topology(unsigned int cpu, int level)
@@ -1319,6 +1320,10 @@ static inline int find_acpi_cpu_topology_package(unsigned int cpu)
 {
 	return -EINVAL;
 }
+static int find_acpi_cpu_topology_hetero_id(unsigned int cpu)
+{
+	return -EINVAL;
+}
 static inline int find_acpi_cpu_cache_topology(unsigned int cpu, int level)
 {
 	return -EINVAL;
-- 
2.20.1

[PATCH v2 2/5] ACPI/PPTT: Add function to return ACPI 6.3 Identical tokens

[Jeremy Linton]

ACPI 6.3 adds a flag to indicate that child nodes are all
identical cores. This is useful to authoritatively determine
if a set of (possibly offline) cores are identical or not.

Since the flag doesn't give us a unique id we can generate
one and use it to create bitmaps of sibling nodes, or simply
in a loop to determine if a subset of cores are identical.

Signed-off-by: Jeremy Linton <jeremy.linton@arm.com>
---
 drivers/acpi/pptt.c  | 26 ++++++++++++++++++++++++++
 include/linux/acpi.h |  5 +++++
 2 files changed, 31 insertions(+)

diff --git a/drivers/acpi/pptt.c b/drivers/acpi/pptt.c
index 83a026765faa..1865515297ca 100644
--- a/drivers/acpi/pptt.c
+++ b/drivers/acpi/pptt.c
@@ -660,3 +660,29 @@ int find_acpi_cpu_topology_package(unsigned int cpu)
 	return find_acpi_cpu_topology_tag(cpu, PPTT_ABORT_PACKAGE,
 					  ACPI_PPTT_PHYSICAL_PACKAGE);
 }
+
+/**
+ * find_acpi_cpu_topology_hetero_id() - Get a core architecture tag
+ * @cpu: Kernel logical CPU number
+ *
+ * Determine a unique heterogeneous tag for the given CPU. CPUs with the same
+ * implementation should have matching tags.
+ *
+ * The returned tag can be used to group peers with identical implementation.
+ *
+ * The search terminates when a level is found with the identical implementation
+ * flag set or we reach a root node.
+ *
+ * Due to limitations in the PPTT data structure, there may be rare situations
+ * where two cores in a heterogeneous machine may be identical, but won't have
+ * the same tag.
+ *
+ * Return: -ENOENT if the PPTT doesn't exist, or the CPU cannot be found.
+ * Otherwise returns a value which represents a group of identical cores
+ * similar to this CPU.
+ */
+int find_acpi_cpu_topology_hetero_id(unsigned int cpu)
+{
+	return find_acpi_cpu_topology_tag(cpu, PPTT_ABORT_PACKAGE,
+					  ACPI_PPTT_ACPI_IDENTICAL);
+}
diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index d5dcebd7aad3..1444fb042898 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -1309,6 +1309,7 @@ static inline int lpit_read_residency_count_address(u64 *address)
 #ifdef CONFIG_ACPI_PPTT
 int find_acpi_cpu_topology(unsigned int cpu, int level);
 int find_acpi_cpu_topology_package(unsigned int cpu);
+int find_acpi_cpu_topology_hetero_id(unsigned int cpu);
 int find_acpi_cpu_cache_topology(unsigned int cpu, int level);
 #else
 static inline int find_acpi_cpu_topology(unsigned int cpu, int level)
@@ -1319,6 +1320,10 @@ static inline int find_acpi_cpu_topology_package(unsigned int cpu)
 {
 	return -EINVAL;
 }
+static int find_acpi_cpu_topology_hetero_id(unsigned int cpu)
+{
+	return -EINVAL;
+}
 static inline int find_acpi_cpu_cache_topology(unsigned int cpu, int level)
 {
 	return -EINVAL;
-- 
2.20.1

[PATCH v2 3/5] ACPI/PPTT: Modify node flag detection to find last IDENTICAL

[Jeremy Linton]

The ACPI specification implies that the IDENTICAL flag should be
set on all non leaf nodes where the children are identical.
This means that we need to be searching for the last node with
the identical flag set rather than the first one.

To achieve this with the existing code we need to pass a
function through the tree traversal logic so we can check
the next node to assure that IDENTICAL isn't set before returning
a node with IDENTICAL set.

Signed-off-by: Jeremy Linton <jeremy.linton@arm.com>
---
 drivers/acpi/pptt.c | 62 +++++++++++++++++++++++++++++++++++----------
 1 file changed, 48 insertions(+), 14 deletions(-)

diff --git a/drivers/acpi/pptt.c b/drivers/acpi/pptt.c
index 1865515297ca..39f660d8be0a 100644
--- a/drivers/acpi/pptt.c
+++ b/drivers/acpi/pptt.c
@@ -432,17 +432,51 @@ static void cache_setup_acpi_cpu(struct acpi_table_header *table,
 	}
 }
 
+
+typedef bool (*node_check)(struct acpi_table_header *table_hdr,
+			   struct acpi_pptt_processor *cpu);
+static bool flag_package(struct acpi_table_header *table_hdr,
+			 struct acpi_pptt_processor *cpu)
+{
+	return cpu->flags & ACPI_PPTT_PHYSICAL_PACKAGE;
+}
+
+static bool flag_identical(struct acpi_table_header *table_hdr,
+			   struct acpi_pptt_processor *cpu)
+{
+	struct acpi_pptt_processor *next;
+
+	/* heterogeneous machines must use PPTT revision > 1 */
+	if (table_hdr->revision < 2)
+		return false;
+
+	/* Locate the last node in the tree with IDENTICAL set */
+	if (cpu->flags & ACPI_PPTT_ACPI_IDENTICAL) {
+		next = fetch_pptt_node(table_hdr, cpu->parent);
+		if (!(next && next->flags & ACPI_PPTT_ACPI_IDENTICAL))
+			return true;
+	}
+
+	return false;
+}
+
+static bool flag_none(struct acpi_table_header *table_hdr,
+		      struct acpi_pptt_processor *cpu)
+{
+	return false;
+}
+
 /* Passing level values greater than this will result in search termination */
 #define PPTT_ABORT_PACKAGE 0xFF
 
-static struct acpi_pptt_processor *acpi_find_processor_package_id(struct acpi_table_header *table_hdr,
-								  struct acpi_pptt_processor *cpu,
-								  int level, int flag)
+static struct acpi_pptt_processor *acpi_find_processor_tag_id(struct acpi_table_header *table_hdr,
+							      struct acpi_pptt_processor *cpu,
+							      int level, node_check chk)
 {
 	struct acpi_pptt_processor *prev_node;
 
 	while (cpu && level) {
-		if (cpu->flags & flag)
+		if (chk(table_hdr, cpu))
 			break;
 		pr_debug("level %d\n", level);
 		prev_node = fetch_pptt_node(table_hdr, cpu->parent);
@@ -473,15 +507,15 @@ static void acpi_pptt_warn_missing(void)
  * Return: Unique value, or -ENOENT if unable to locate CPU
  */
 static int topology_get_acpi_cpu_tag(struct acpi_table_header *table,
-				     unsigned int cpu, int level, int flag)
+				     unsigned int cpu, int level, node_check chk)
 {
 	struct acpi_pptt_processor *cpu_node;
 	u32 acpi_cpu_id = get_acpi_id_for_cpu(cpu);
 
 	cpu_node = acpi_find_processor_node(table, acpi_cpu_id);
 	if (cpu_node) {
-		cpu_node = acpi_find_processor_package_id(table, cpu_node,
-							  level, flag);
+		cpu_node = acpi_find_processor_tag_id(table, cpu_node,
+							  level, chk);
 		/*
 		 * As per specification if the processor structure represents
 		 * an actual processor, then ACPI processor ID must be valid.
@@ -498,7 +532,7 @@ static int topology_get_acpi_cpu_tag(struct acpi_table_header *table,
 	return -ENOENT;
 }
 
-static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, int flag)
+static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, node_check chk)
 {
 	struct acpi_table_header *table;
 	acpi_status status;
@@ -509,7 +543,7 @@ static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, int flag)
 		acpi_pptt_warn_missing();
 		return -ENOENT;
 	}
-	retval = topology_get_acpi_cpu_tag(table, cpu, level, flag);
+	retval = topology_get_acpi_cpu_tag(table, cpu, level, chk);
 	pr_debug("Topology Setup ACPI CPU %d, level %d ret = %d\n",
 		 cpu, level, retval);
 	acpi_put_table(table);
@@ -601,7 +635,7 @@ int cache_setup_acpi(unsigned int cpu)
  */
 int find_acpi_cpu_topology(unsigned int cpu, int level)
 {
-	return find_acpi_cpu_topology_tag(cpu, level, 0);
+	return find_acpi_cpu_topology_tag(cpu, level, flag_none);
 }
 
 /**
@@ -658,7 +692,7 @@ int find_acpi_cpu_cache_topology(unsigned int cpu, int level)
 int find_acpi_cpu_topology_package(unsigned int cpu)
 {
 	return find_acpi_cpu_topology_tag(cpu, PPTT_ABORT_PACKAGE,
-					  ACPI_PPTT_PHYSICAL_PACKAGE);
+					  flag_package);
 }
 
 /**
@@ -670,8 +704,8 @@ int find_acpi_cpu_topology_package(unsigned int cpu)
  *
  * The returned tag can be used to group peers with identical implementation.
  *
- * The search terminates when a level is found with the identical implementation
- * flag set or we reach a root node.
+ * The search terminates when a level is found without the identical
+ * implementation flag set following a node with it set, or we reach the root.
  *
  * Due to limitations in the PPTT data structure, there may be rare situations
  * where two cores in a heterogeneous machine may be identical, but won't have
@@ -684,5 +718,5 @@ int find_acpi_cpu_topology_package(unsigned int cpu)
 int find_acpi_cpu_topology_hetero_id(unsigned int cpu)
 {
 	return find_acpi_cpu_topology_tag(cpu, PPTT_ABORT_PACKAGE,
-					  ACPI_PPTT_ACPI_IDENTICAL);
+					  flag_identical);
 }
-- 
2.20.1

[PATCH v2 3/5] ACPI/PPTT: Modify node flag detection to find last IDENTICAL

[Jeremy Linton]

The ACPI specification implies that the IDENTICAL flag should be
set on all non leaf nodes where the children are identical.
This means that we need to be searching for the last node with
the identical flag set rather than the first one.

To achieve this with the existing code we need to pass a
function through the tree traversal logic so we can check
the next node to assure that IDENTICAL isn't set before returning
a node with IDENTICAL set.

Signed-off-by: Jeremy Linton <jeremy.linton@arm.com>
---
 drivers/acpi/pptt.c | 62 +++++++++++++++++++++++++++++++++++----------
 1 file changed, 48 insertions(+), 14 deletions(-)

diff --git a/drivers/acpi/pptt.c b/drivers/acpi/pptt.c
index 1865515297ca..39f660d8be0a 100644
--- a/drivers/acpi/pptt.c
+++ b/drivers/acpi/pptt.c
@@ -432,17 +432,51 @@ static void cache_setup_acpi_cpu(struct acpi_table_header *table,
 	}
 }
 
+
+typedef bool (*node_check)(struct acpi_table_header *table_hdr,
+			   struct acpi_pptt_processor *cpu);
+static bool flag_package(struct acpi_table_header *table_hdr,
+			 struct acpi_pptt_processor *cpu)
+{
+	return cpu->flags & ACPI_PPTT_PHYSICAL_PACKAGE;
+}
+
+static bool flag_identical(struct acpi_table_header *table_hdr,
+			   struct acpi_pptt_processor *cpu)
+{
+	struct acpi_pptt_processor *next;
+
+	/* heterogeneous machines must use PPTT revision > 1 */
+	if (table_hdr->revision < 2)
+		return false;
+
+	/* Locate the last node in the tree with IDENTICAL set */
+	if (cpu->flags & ACPI_PPTT_ACPI_IDENTICAL) {
+		next = fetch_pptt_node(table_hdr, cpu->parent);
+		if (!(next && next->flags & ACPI_PPTT_ACPI_IDENTICAL))
+			return true;
+	}
+
+	return false;
+}
+
+static bool flag_none(struct acpi_table_header *table_hdr,
+		      struct acpi_pptt_processor *cpu)
+{
+	return false;
+}
+
 /* Passing level values greater than this will result in search termination */
 #define PPTT_ABORT_PACKAGE 0xFF
 
-static struct acpi_pptt_processor *acpi_find_processor_package_id(struct acpi_table_header *table_hdr,
-								  struct acpi_pptt_processor *cpu,
-								  int level, int flag)
+static struct acpi_pptt_processor *acpi_find_processor_tag_id(struct acpi_table_header *table_hdr,
+							      struct acpi_pptt_processor *cpu,
+							      int level, node_check chk)
 {
 	struct acpi_pptt_processor *prev_node;
 
 	while (cpu && level) {
-		if (cpu->flags & flag)
+		if (chk(table_hdr, cpu))
 			break;
 		pr_debug("level %d\n", level);
 		prev_node = fetch_pptt_node(table_hdr, cpu->parent);
@@ -473,15 +507,15 @@ static void acpi_pptt_warn_missing(void)
  * Return: Unique value, or -ENOENT if unable to locate CPU
  */
 static int topology_get_acpi_cpu_tag(struct acpi_table_header *table,
-				     unsigned int cpu, int level, int flag)
+				     unsigned int cpu, int level, node_check chk)
 {
 	struct acpi_pptt_processor *cpu_node;
 	u32 acpi_cpu_id = get_acpi_id_for_cpu(cpu);
 
 	cpu_node = acpi_find_processor_node(table, acpi_cpu_id);
 	if (cpu_node) {
-		cpu_node = acpi_find_processor_package_id(table, cpu_node,
-							  level, flag);
+		cpu_node = acpi_find_processor_tag_id(table, cpu_node,
+							  level, chk);
 		/*
 		 * As per specification if the processor structure represents
 		 * an actual processor, then ACPI processor ID must be valid.
@@ -498,7 +532,7 @@ static int topology_get_acpi_cpu_tag(struct acpi_table_header *table,
 	return -ENOENT;
 }
 
-static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, int flag)
+static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, node_check chk)
 {
 	struct acpi_table_header *table;
 	acpi_status status;
@@ -509,7 +543,7 @@ static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, int flag)
 		acpi_pptt_warn_missing();
 		return -ENOENT;
 	}
-	retval = topology_get_acpi_cpu_tag(table, cpu, level, flag);
+	retval = topology_get_acpi_cpu_tag(table, cpu, level, chk);
 	pr_debug("Topology Setup ACPI CPU %d, level %d ret = %d\n",
 		 cpu, level, retval);
 	acpi_put_table(table);
@@ -601,7 +635,7 @@ int cache_setup_acpi(unsigned int cpu)
  */
 int find_acpi_cpu_topology(unsigned int cpu, int level)
 {
-	return find_acpi_cpu_topology_tag(cpu, level, 0);
+	return find_acpi_cpu_topology_tag(cpu, level, flag_none);
 }
 
 /**
@@ -658,7 +692,7 @@ int find_acpi_cpu_cache_topology(unsigned int cpu, int level)
 int find_acpi_cpu_topology_package(unsigned int cpu)
 {
 	return find_acpi_cpu_topology_tag(cpu, PPTT_ABORT_PACKAGE,
-					  ACPI_PPTT_PHYSICAL_PACKAGE);
+					  flag_package);
 }
 
 /**
@@ -670,8 +704,8 @@ int find_acpi_cpu_topology_package(unsigned int cpu)
  *
  * The returned tag can be used to group peers with identical implementation.
  *
- * The search terminates when a level is found with the identical implementation
- * flag set or we reach a root node.
+ * The search terminates when a level is found without the identical
+ * implementation flag set following a node with it set, or we reach the root.
  *
  * Due to limitations in the PPTT data structure, there may be rare situations
  * where two cores in a heterogeneous machine may be identical, but won't have
@@ -684,5 +718,5 @@ int find_acpi_cpu_topology_package(unsigned int cpu)
 int find_acpi_cpu_topology_hetero_id(unsigned int cpu)
 {
 	return find_acpi_cpu_topology_tag(cpu, PPTT_ABORT_PACKAGE,
-					  ACPI_PPTT_ACPI_IDENTICAL);
+					  flag_identical);
 }
-- 
2.20.1

[PATCH v2 4/5] arm_pmu: acpi: spe: Add initial MADT/SPE probing

[Jeremy Linton]

ACPI 6.3 adds additional fields to the MADT GICC
structure to describe SPE PPI's. We pick these out
of the cached reference to the madt_gicc structure
similarly to the core PMU code. We then create a platform
device referring to the IRQ and let the user/module loader
decide whether to load the SPE driver.

Signed-off-by: Jeremy Linton <jeremy.linton@arm.com>
---
 arch/arm64/include/asm/acpi.h |  3 ++
 drivers/perf/Kconfig          |  5 +++
 drivers/perf/arm_pmu_acpi.c   | 76 +++++++++++++++++++++++++++++++++++
 include/linux/perf/arm_pmu.h  |  2 +
 4 files changed, 86 insertions(+)

diff --git a/arch/arm64/include/asm/acpi.h b/arch/arm64/include/asm/acpi.h
index 7628efbe6c12..d10399b9f998 100644
--- a/arch/arm64/include/asm/acpi.h
+++ b/arch/arm64/include/asm/acpi.h
@@ -41,6 +41,9 @@
 	(!(entry) || (entry)->header.length < ACPI_MADT_GICC_MIN_LENGTH || \
 	(unsigned long)(entry) + (entry)->header.length > (end))
 
+#define ACPI_MADT_GICC_SPE  (ACPI_OFFSET(struct acpi_madt_generic_interrupt, \
+	spe_interrupt) + sizeof(u16))
+
 /* Basic configuration for ACPI */
 #ifdef	CONFIG_ACPI
 pgprot_t __acpi_get_mem_attribute(phys_addr_t addr);
diff --git a/drivers/perf/Kconfig b/drivers/perf/Kconfig
index af9bc178495d..bc2647c64c9d 100644
--- a/drivers/perf/Kconfig
+++ b/drivers/perf/Kconfig
@@ -52,6 +52,11 @@ config ARM_PMU_ACPI
 	depends on ARM_PMU && ACPI
 	def_bool y
 
+config ARM_SPE_ACPI
+	depends on ARM_PMU_ACPI && ARM_SPE_PMU
+	def_bool y
+
+
 config ARM_DSU_PMU
 	tristate "ARM DynamIQ Shared Unit (DSU) PMU"
 	depends on ARM64
diff --git a/drivers/perf/arm_pmu_acpi.c b/drivers/perf/arm_pmu_acpi.c
index 0f197516d708..b0244e1e8c91 100644
--- a/drivers/perf/arm_pmu_acpi.c
+++ b/drivers/perf/arm_pmu_acpi.c
@@ -74,6 +74,80 @@ static void arm_pmu_acpi_unregister_irq(int cpu)
 	acpi_unregister_gsi(gsi);
 }
 
+#ifdef CONFIG_ARM_SPE_ACPI
+static struct resource spe_resources[] = {
+	{
+		/* irq */
+		.flags          = IORESOURCE_IRQ,
+	}
+};
+
+static struct platform_device spe_dev = {
+	.name = ARMV8_SPE_PDEV_NAME,
+	.id = -1,
+	.resource = spe_resources,
+	.num_resources = ARRAY_SIZE(spe_resources)
+};
+
+/*
+ * For lack of a better place, hook the normal PMU MADT walk
+ * and create a SPE device if we detect a recent MADT with
+ * a homogeneous PPI mapping.
+ */
+static int arm_spe_acpi_register_device(void)
+{
+	int cpu, ret, irq;
+	int hetid;
+	u16 gsi = 0;
+	bool first = true;
+
+	struct acpi_madt_generic_interrupt *gicc;
+
+	/*
+	 * sanity check all the GICC tables for the same interrupt number
+	 * for now we only support homogeneous ACPI/SPE machines.
+	 */
+	for_each_possible_cpu(cpu) {
+		gicc = acpi_cpu_get_madt_gicc(cpu);
+
+		if (gicc->header.length < ACPI_MADT_GICC_SPE)
+			return -ENODEV;
+		if (first) {
+			gsi = gicc->spe_interrupt;
+			if (!gsi)
+				return -ENODEV;
+			hetid = find_acpi_cpu_topology_hetero_id(cpu);
+			first = false;
+		} else if ((gsi != gicc->spe_interrupt) ||
+			   (hetid != find_acpi_cpu_topology_hetero_id(cpu))) {
+			pr_warn("ACPI: SPE must be homogeneous\n");
+			return -EINVAL;
+		}
+	}
+
+	irq = acpi_register_gsi(NULL, gsi, ACPI_LEVEL_SENSITIVE,
+				ACPI_ACTIVE_HIGH);
+	if (irq < 0) {
+		pr_warn("ACPI: SPE Unable to register interrupt: %d\n", gsi);
+		return irq;
+	}
+
+	spe_resources[0].start = irq;
+	ret = platform_device_register(&spe_dev);
+	if (ret < 0) {
+		pr_warn("ACPI: SPE: Unable to register device\n");
+		acpi_unregister_gsi(gsi);
+	}
+
+	return ret;
+}
+#else
+static inline int arm_spe_acpi_register_device(void)
+{
+	return -ENODEV;
+}
+#endif /* CONFIG_ARM_SPE_ACPI */
+
 static int arm_pmu_acpi_parse_irqs(void)
 {
 	int irq, cpu, irq_cpu, err;
@@ -279,6 +353,8 @@ static int arm_pmu_acpi_init(void)
 	if (acpi_disabled)
 		return 0;
 
+	arm_spe_acpi_register_device(); /* failures are expected */
+
 	ret = arm_pmu_acpi_parse_irqs();
 	if (ret)
 		return ret;
diff --git a/include/linux/perf/arm_pmu.h b/include/linux/perf/arm_pmu.h
index 4641e850b204..784bc58f165a 100644
--- a/include/linux/perf/arm_pmu.h
+++ b/include/linux/perf/arm_pmu.h
@@ -175,4 +175,6 @@ void armpmu_free_irq(int irq, int cpu);
 
 #endif /* CONFIG_ARM_PMU */
 
+#define ARMV8_SPE_PDEV_NAME "arm,spe-v1"
+
 #endif /* __ARM_PMU_H__ */
-- 
2.20.1

[PATCH v2 4/5] arm_pmu: acpi: spe: Add initial MADT/SPE probing

[Jeremy Linton]

ACPI 6.3 adds additional fields to the MADT GICC
structure to describe SPE PPI's. We pick these out
of the cached reference to the madt_gicc structure
similarly to the core PMU code. We then create a platform
device referring to the IRQ and let the user/module loader
decide whether to load the SPE driver.

Signed-off-by: Jeremy Linton <jeremy.linton@arm.com>
---
 arch/arm64/include/asm/acpi.h |  3 ++
 drivers/perf/Kconfig          |  5 +++
 drivers/perf/arm_pmu_acpi.c   | 76 +++++++++++++++++++++++++++++++++++
 include/linux/perf/arm_pmu.h  |  2 +
 4 files changed, 86 insertions(+)

diff --git a/arch/arm64/include/asm/acpi.h b/arch/arm64/include/asm/acpi.h
index 7628efbe6c12..d10399b9f998 100644
--- a/arch/arm64/include/asm/acpi.h
+++ b/arch/arm64/include/asm/acpi.h
@@ -41,6 +41,9 @@
 	(!(entry) || (entry)->header.length < ACPI_MADT_GICC_MIN_LENGTH || \
 	(unsigned long)(entry) + (entry)->header.length > (end))
 
+#define ACPI_MADT_GICC_SPE  (ACPI_OFFSET(struct acpi_madt_generic_interrupt, \
+	spe_interrupt) + sizeof(u16))
+
 /* Basic configuration for ACPI */
 #ifdef	CONFIG_ACPI
 pgprot_t __acpi_get_mem_attribute(phys_addr_t addr);
diff --git a/drivers/perf/Kconfig b/drivers/perf/Kconfig
index af9bc178495d..bc2647c64c9d 100644
--- a/drivers/perf/Kconfig
+++ b/drivers/perf/Kconfig
@@ -52,6 +52,11 @@ config ARM_PMU_ACPI
 	depends on ARM_PMU && ACPI
 	def_bool y
 
+config ARM_SPE_ACPI
+	depends on ARM_PMU_ACPI && ARM_SPE_PMU
+	def_bool y
+
+
 config ARM_DSU_PMU
 	tristate "ARM DynamIQ Shared Unit (DSU) PMU"
 	depends on ARM64
diff --git a/drivers/perf/arm_pmu_acpi.c b/drivers/perf/arm_pmu_acpi.c
index 0f197516d708..b0244e1e8c91 100644
--- a/drivers/perf/arm_pmu_acpi.c
+++ b/drivers/perf/arm_pmu_acpi.c
@@ -74,6 +74,80 @@ static void arm_pmu_acpi_unregister_irq(int cpu)
 	acpi_unregister_gsi(gsi);
 }
 
+#ifdef CONFIG_ARM_SPE_ACPI
+static struct resource spe_resources[] = {
+	{
+		/* irq */
+		.flags          = IORESOURCE_IRQ,
+	}
+};
+
+static struct platform_device spe_dev = {
+	.name = ARMV8_SPE_PDEV_NAME,
+	.id = -1,
+	.resource = spe_resources,
+	.num_resources = ARRAY_SIZE(spe_resources)
+};
+
+/*
+ * For lack of a better place, hook the normal PMU MADT walk
+ * and create a SPE device if we detect a recent MADT with
+ * a homogeneous PPI mapping.
+ */
+static int arm_spe_acpi_register_device(void)
+{
+	int cpu, ret, irq;
+	int hetid;
+	u16 gsi = 0;
+	bool first = true;
+
+	struct acpi_madt_generic_interrupt *gicc;
+
+	/*
+	 * sanity check all the GICC tables for the same interrupt number
+	 * for now we only support homogeneous ACPI/SPE machines.
+	 */
+	for_each_possible_cpu(cpu) {
+		gicc = acpi_cpu_get_madt_gicc(cpu);
+
+		if (gicc->header.length < ACPI_MADT_GICC_SPE)
+			return -ENODEV;
+		if (first) {
+			gsi = gicc->spe_interrupt;
+			if (!gsi)
+				return -ENODEV;
+			hetid = find_acpi_cpu_topology_hetero_id(cpu);
+			first = false;
+		} else if ((gsi != gicc->spe_interrupt) ||
+			   (hetid != find_acpi_cpu_topology_hetero_id(cpu))) {
+			pr_warn("ACPI: SPE must be homogeneous\n");
+			return -EINVAL;
+		}
+	}
+
+	irq = acpi_register_gsi(NULL, gsi, ACPI_LEVEL_SENSITIVE,
+				ACPI_ACTIVE_HIGH);
+	if (irq < 0) {
+		pr_warn("ACPI: SPE Unable to register interrupt: %d\n", gsi);
+		return irq;
+	}
+
+	spe_resources[0].start = irq;
+	ret = platform_device_register(&spe_dev);
+	if (ret < 0) {
+		pr_warn("ACPI: SPE: Unable to register device\n");
+		acpi_unregister_gsi(gsi);
+	}
+
+	return ret;
+}
+#else
+static inline int arm_spe_acpi_register_device(void)
+{
+	return -ENODEV;
+}
+#endif /* CONFIG_ARM_SPE_ACPI */
+
 static int arm_pmu_acpi_parse_irqs(void)
 {
 	int irq, cpu, irq_cpu, err;
@@ -279,6 +353,8 @@ static int arm_pmu_acpi_init(void)
 	if (acpi_disabled)
 		return 0;
 
+	arm_spe_acpi_register_device(); /* failures are expected */
+
 	ret = arm_pmu_acpi_parse_irqs();
 	if (ret)
 		return ret;
diff --git a/include/linux/perf/arm_pmu.h b/include/linux/perf/arm_pmu.h
index 4641e850b204..784bc58f165a 100644
--- a/include/linux/perf/arm_pmu.h
+++ b/include/linux/perf/arm_pmu.h
@@ -175,4 +175,6 @@ void armpmu_free_irq(int irq, int cpu);
 
 #endif /* CONFIG_ARM_PMU */
 
+#define ARMV8_SPE_PDEV_NAME "arm,spe-v1"
+
 #endif /* __ARM_PMU_H__ */
-- 
2.20.1

[PATCH v2 5/5] perf: arm_spe: Enable ACPI/Platform automatic module loading

[Jeremy Linton]

Lets add the MODULE_TABLE and platform id_table entries so that
the SPE driver can attach to the ACPI platform device created by
the core pmu code.

Signed-off-by: Jeremy Linton <jeremy.linton@arm.com>
Reviewed-by: Sudeep Holla <sudeep.holla@arm.com>
---
 drivers/perf/arm_spe_pmu.c | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/drivers/perf/arm_spe_pmu.c b/drivers/perf/arm_spe_pmu.c
index 7cb766dafe85..a11951b08330 100644
--- a/drivers/perf/arm_spe_pmu.c
+++ b/drivers/perf/arm_spe_pmu.c
@@ -38,6 +38,7 @@
 #include <linux/of_address.h>
 #include <linux/of_device.h>
 #include <linux/perf_event.h>
+#include <linux/perf/arm_pmu.h>
 #include <linux/platform_device.h>
 #include <linux/printk.h>
 #include <linux/slab.h>
@@ -1176,7 +1177,13 @@ static const struct of_device_id arm_spe_pmu_of_match[] = {
 };
 MODULE_DEVICE_TABLE(of, arm_spe_pmu_of_match);
 
-static int arm_spe_pmu_device_dt_probe(struct platform_device *pdev)
+static const struct platform_device_id arm_spe_match[] = {
+	{ ARMV8_SPE_PDEV_NAME, 0},
+	{ }
+};
+MODULE_DEVICE_TABLE(platform, arm_spe_match);
+
+static int arm_spe_pmu_device_probe(struct platform_device *pdev)
 {
 	int ret;
 	struct arm_spe_pmu *spe_pmu;
@@ -1236,11 +1243,12 @@ static int arm_spe_pmu_device_remove(struct platform_device *pdev)
 }
 
 static struct platform_driver arm_spe_pmu_driver = {
+	.id_table = arm_spe_match,
 	.driver	= {
 		.name		= DRVNAME,
 		.of_match_table	= of_match_ptr(arm_spe_pmu_of_match),
 	},
-	.probe	= arm_spe_pmu_device_dt_probe,
+	.probe	= arm_spe_pmu_device_probe,
 	.remove	= arm_spe_pmu_device_remove,
 };
 
-- 
2.20.1

[PATCH v2 5/5] perf: arm_spe: Enable ACPI/Platform automatic module loading

[Jeremy Linton]

Lets add the MODULE_TABLE and platform id_table entries so that
the SPE driver can attach to the ACPI platform device created by
the core pmu code.

Signed-off-by: Jeremy Linton <jeremy.linton@arm.com>
Reviewed-by: Sudeep Holla <sudeep.holla@arm.com>
---
 drivers/perf/arm_spe_pmu.c | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/drivers/perf/arm_spe_pmu.c b/drivers/perf/arm_spe_pmu.c
index 7cb766dafe85..a11951b08330 100644
--- a/drivers/perf/arm_spe_pmu.c
+++ b/drivers/perf/arm_spe_pmu.c
@@ -38,6 +38,7 @@
 #include <linux/of_address.h>
 #include <linux/of_device.h>
 #include <linux/perf_event.h>
+#include <linux/perf/arm_pmu.h>
 #include <linux/platform_device.h>
 #include <linux/printk.h>
 #include <linux/slab.h>
@@ -1176,7 +1177,13 @@ static const struct of_device_id arm_spe_pmu_of_match[] = {
 };
 MODULE_DEVICE_TABLE(of, arm_spe_pmu_of_match);
 
-static int arm_spe_pmu_device_dt_probe(struct platform_device *pdev)
+static const struct platform_device_id arm_spe_match[] = {
+	{ ARMV8_SPE_PDEV_NAME, 0},
+	{ }
+};
+MODULE_DEVICE_TABLE(platform, arm_spe_match);
+
+static int arm_spe_pmu_device_probe(struct platform_device *pdev)
 {
 	int ret;
 	struct arm_spe_pmu *spe_pmu;
@@ -1236,11 +1243,12 @@ static int arm_spe_pmu_device_remove(struct platform_device *pdev)
 }
 
 static struct platform_driver arm_spe_pmu_driver = {
+	.id_table = arm_spe_match,
 	.driver	= {
 		.name		= DRVNAME,
 		.of_match_table	= of_match_ptr(arm_spe_pmu_of_match),
 	},
-	.probe	= arm_spe_pmu_device_dt_probe,
+	.probe	= arm_spe_pmu_device_probe,
 	.remove	= arm_spe_pmu_device_remove,
 };
 
-- 
2.20.1

Re: [PATCH v2 1/5] ACPI/PPTT: Trivial, Modify the case of CPU

[Rafael J. Wysocki]

On Sat, Apr 27, 2019 at 12:03 AM Jeremy Linton <jeremy.linton@arm.com> wrote:
>
> CPU is an acronym and customarily capitalized. Much of the
> commenting in the PPTT code has been using "cpu" rather
> than "CPU". Correct that, and other human readable strings.
>
> Signed-off-by: Jeremy Linton <jeremy.linton@arm.com>

It would be better to say "Modify the spelling of CPU" in the subject
IMO, but apart from that

Acked-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>

> ---
>  drivers/acpi/pptt.c | 48 ++++++++++++++++++++++-----------------------
>  1 file changed, 24 insertions(+), 24 deletions(-)
>
> diff --git a/drivers/acpi/pptt.c b/drivers/acpi/pptt.c
> index 065c4fc245d1..83a026765faa 100644
> --- a/drivers/acpi/pptt.c
> +++ b/drivers/acpi/pptt.c
> @@ -164,7 +164,7 @@ static struct acpi_pptt_cache *acpi_find_cache_level(struct acpi_table_header *t
>  }
>
>  /**
> - * acpi_count_levels() - Given a PPTT table, and a cpu node, count the caches
> + * acpi_count_levels() - Given a PPTT table, and a CPU node, count the caches
>   * @table_hdr: Pointer to the head of the PPTT table
>   * @cpu_node: processor node we wish to count caches for
>   *
> @@ -235,7 +235,7 @@ static int acpi_pptt_leaf_node(struct acpi_table_header *table_hdr,
>  /**
>   * acpi_find_processor_node() - Given a PPTT table find the requested processor
>   * @table_hdr:  Pointer to the head of the PPTT table
> - * @acpi_cpu_id: cpu we are searching for
> + * @acpi_cpu_id: CPU we are searching for
>   *
>   * Find the subtable entry describing the provided processor.
>   * This is done by iterating the PPTT table looking for processor nodes
> @@ -456,21 +456,21 @@ static struct acpi_pptt_processor *acpi_find_processor_package_id(struct acpi_ta
>
>  static void acpi_pptt_warn_missing(void)
>  {
> -       pr_warn_once("No PPTT table found, cpu and cache topology may be inaccurate\n");
> +       pr_warn_once("No PPTT table found, CPU and cache topology may be inaccurate\n");
>  }
>
>  /**
>   * topology_get_acpi_cpu_tag() - Find a unique topology value for a feature
>   * @table: Pointer to the head of the PPTT table
> - * @cpu: Kernel logical cpu number
> + * @cpu: Kernel logical CPU number
>   * @level: A level that terminates the search
>   * @flag: A flag which terminates the search
>   *
> - * Get a unique value given a cpu, and a topology level, that can be
> - * matched to determine which cpus share common topological features
> + * Get a unique value given a CPU, and a topology level, that can be
> + * matched to determine which CPUs share common topological features
>   * at that level.
>   *
> - * Return: Unique value, or -ENOENT if unable to locate cpu
> + * Return: Unique value, or -ENOENT if unable to locate CPU
>   */
>  static int topology_get_acpi_cpu_tag(struct acpi_table_header *table,
>                                      unsigned int cpu, int level, int flag)
> @@ -510,7 +510,7 @@ static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, int flag)
>                 return -ENOENT;
>         }
>         retval = topology_get_acpi_cpu_tag(table, cpu, level, flag);
> -       pr_debug("Topology Setup ACPI cpu %d, level %d ret = %d\n",
> +       pr_debug("Topology Setup ACPI CPU %d, level %d ret = %d\n",
>                  cpu, level, retval);
>         acpi_put_table(table);
>
> @@ -519,9 +519,9 @@ static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, int flag)
>
>  /**
>   * acpi_find_last_cache_level() - Determines the number of cache levels for a PE
> - * @cpu: Kernel logical cpu number
> + * @cpu: Kernel logical CPU number
>   *
> - * Given a logical cpu number, returns the number of levels of cache represented
> + * Given a logical CPU number, returns the number of levels of cache represented
>   * in the PPTT. Errors caused by lack of a PPTT table, or otherwise, return 0
>   * indicating we didn't find any cache levels.
>   *
> @@ -534,7 +534,7 @@ int acpi_find_last_cache_level(unsigned int cpu)
>         int number_of_levels = 0;
>         acpi_status status;
>
> -       pr_debug("Cache Setup find last level cpu=%d\n", cpu);
> +       pr_debug("Cache Setup find last level CPU=%d\n", cpu);
>
>         acpi_cpu_id = get_acpi_id_for_cpu(cpu);
>         status = acpi_get_table(ACPI_SIG_PPTT, 0, &table);
> @@ -551,14 +551,14 @@ int acpi_find_last_cache_level(unsigned int cpu)
>
>  /**
>   * cache_setup_acpi() - Override CPU cache topology with data from the PPTT
> - * @cpu: Kernel logical cpu number
> + * @cpu: Kernel logical CPU number
>   *
>   * Updates the global cache info provided by cpu_get_cacheinfo()
>   * when there are valid properties in the acpi_pptt_cache nodes. A
>   * successful parse may not result in any updates if none of the
>   * cache levels have any valid flags set.  Futher, a unique value is
>   * associated with each known CPU cache entry. This unique value
> - * can be used to determine whether caches are shared between cpus.
> + * can be used to determine whether caches are shared between CPUs.
>   *
>   * Return: -ENOENT on failure to find table, or 0 on success
>   */
> @@ -567,7 +567,7 @@ int cache_setup_acpi(unsigned int cpu)
>         struct acpi_table_header *table;
>         acpi_status status;
>
> -       pr_debug("Cache Setup ACPI cpu %d\n", cpu);
> +       pr_debug("Cache Setup ACPI CPU %d\n", cpu);
>
>         status = acpi_get_table(ACPI_SIG_PPTT, 0, &table);
>         if (ACPI_FAILURE(status)) {
> @@ -582,8 +582,8 @@ int cache_setup_acpi(unsigned int cpu)
>  }
>
>  /**
> - * find_acpi_cpu_topology() - Determine a unique topology value for a given cpu
> - * @cpu: Kernel logical cpu number
> + * find_acpi_cpu_topology() - Determine a unique topology value for a given CPU
> + * @cpu: Kernel logical CPU number
>   * @level: The topological level for which we would like a unique ID
>   *
>   * Determine a topology unique ID for each thread/core/cluster/mc_grouping
> @@ -596,7 +596,7 @@ int cache_setup_acpi(unsigned int cpu)
>   * other levels beyond this use a generated value to uniquely identify
>   * a topological feature.
>   *
> - * Return: -ENOENT if the PPTT doesn't exist, or the cpu cannot be found.
> + * Return: -ENOENT if the PPTT doesn't exist, or the CPU cannot be found.
>   * Otherwise returns a value which represents a unique topological feature.
>   */
>  int find_acpi_cpu_topology(unsigned int cpu, int level)
> @@ -606,12 +606,12 @@ int find_acpi_cpu_topology(unsigned int cpu, int level)
>
>  /**
>   * find_acpi_cpu_cache_topology() - Determine a unique cache topology value
> - * @cpu: Kernel logical cpu number
> + * @cpu: Kernel logical CPU number
>   * @level: The cache level for which we would like a unique ID
>   *
>   * Determine a unique ID for each unified cache in the system
>   *
> - * Return: -ENOENT if the PPTT doesn't exist, or the cpu cannot be found.
> + * Return: -ENOENT if the PPTT doesn't exist, or the CPU cannot be found.
>   * Otherwise returns a value which represents a unique topological feature.
>   */
>  int find_acpi_cpu_cache_topology(unsigned int cpu, int level)
> @@ -643,17 +643,17 @@ int find_acpi_cpu_cache_topology(unsigned int cpu, int level)
>
>
>  /**
> - * find_acpi_cpu_topology_package() - Determine a unique cpu package value
> - * @cpu: Kernel logical cpu number
> + * find_acpi_cpu_topology_package() - Determine a unique CPU package value
> + * @cpu: Kernel logical CPU number
>   *
> - * Determine a topology unique package ID for the given cpu.
> + * Determine a topology unique package ID for the given CPU.
>   * This ID can then be used to group peers, which will have matching ids.
>   *
>   * The search terminates when either a level is found with the PHYSICAL_PACKAGE
>   * flag set or we reach a root node.
>   *
> - * Return: -ENOENT if the PPTT doesn't exist, or the cpu cannot be found.
> - * Otherwise returns a value which represents the package for this cpu.
> + * Return: -ENOENT if the PPTT doesn't exist, or the CPU cannot be found.
> + * Otherwise returns a value which represents the package for this CPU.
>   */
>  int find_acpi_cpu_topology_package(unsigned int cpu)
>  {
> --
> 2.20.1
>

Re: [PATCH v2 1/5] ACPI/PPTT: Trivial, Modify the case of CPU

[Rafael J. Wysocki]

On Sat, Apr 27, 2019 at 12:03 AM Jeremy Linton <jeremy.linton@arm.com> wrote:
>
> CPU is an acronym and customarily capitalized. Much of the
> commenting in the PPTT code has been using "cpu" rather
> than "CPU". Correct that, and other human readable strings.
>
> Signed-off-by: Jeremy Linton <jeremy.linton@arm.com>

It would be better to say "Modify the spelling of CPU" in the subject
IMO, but apart from that

Acked-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>

> ---
>  drivers/acpi/pptt.c | 48 ++++++++++++++++++++++-----------------------
>  1 file changed, 24 insertions(+), 24 deletions(-)
>
> diff --git a/drivers/acpi/pptt.c b/drivers/acpi/pptt.c
> index 065c4fc245d1..83a026765faa 100644
> --- a/drivers/acpi/pptt.c
> +++ b/drivers/acpi/pptt.c
> @@ -164,7 +164,7 @@ static struct acpi_pptt_cache *acpi_find_cache_level(struct acpi_table_header *t
>  }
>
>  /**
> - * acpi_count_levels() - Given a PPTT table, and a cpu node, count the caches
> + * acpi_count_levels() - Given a PPTT table, and a CPU node, count the caches
>   * @table_hdr: Pointer to the head of the PPTT table
>   * @cpu_node: processor node we wish to count caches for
>   *
> @@ -235,7 +235,7 @@ static int acpi_pptt_leaf_node(struct acpi_table_header *table_hdr,
>  /**
>   * acpi_find_processor_node() - Given a PPTT table find the requested processor
>   * @table_hdr:  Pointer to the head of the PPTT table
> - * @acpi_cpu_id: cpu we are searching for
> + * @acpi_cpu_id: CPU we are searching for
>   *
>   * Find the subtable entry describing the provided processor.
>   * This is done by iterating the PPTT table looking for processor nodes
> @@ -456,21 +456,21 @@ static struct acpi_pptt_processor *acpi_find_processor_package_id(struct acpi_ta
>
>  static void acpi_pptt_warn_missing(void)
>  {
> -       pr_warn_once("No PPTT table found, cpu and cache topology may be inaccurate\n");
> +       pr_warn_once("No PPTT table found, CPU and cache topology may be inaccurate\n");
>  }
>
>  /**
>   * topology_get_acpi_cpu_tag() - Find a unique topology value for a feature
>   * @table: Pointer to the head of the PPTT table
> - * @cpu: Kernel logical cpu number
> + * @cpu: Kernel logical CPU number
>   * @level: A level that terminates the search
>   * @flag: A flag which terminates the search
>   *
> - * Get a unique value given a cpu, and a topology level, that can be
> - * matched to determine which cpus share common topological features
> + * Get a unique value given a CPU, and a topology level, that can be
> + * matched to determine which CPUs share common topological features
>   * at that level.
>   *
> - * Return: Unique value, or -ENOENT if unable to locate cpu
> + * Return: Unique value, or -ENOENT if unable to locate CPU
>   */
>  static int topology_get_acpi_cpu_tag(struct acpi_table_header *table,
>                                      unsigned int cpu, int level, int flag)
> @@ -510,7 +510,7 @@ static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, int flag)
>                 return -ENOENT;
>         }
>         retval = topology_get_acpi_cpu_tag(table, cpu, level, flag);
> -       pr_debug("Topology Setup ACPI cpu %d, level %d ret = %d\n",
> +       pr_debug("Topology Setup ACPI CPU %d, level %d ret = %d\n",
>                  cpu, level, retval);
>         acpi_put_table(table);
>
> @@ -519,9 +519,9 @@ static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, int flag)
>
>  /**
>   * acpi_find_last_cache_level() - Determines the number of cache levels for a PE
> - * @cpu: Kernel logical cpu number
> + * @cpu: Kernel logical CPU number
>   *
> - * Given a logical cpu number, returns the number of levels of cache represented
> + * Given a logical CPU number, returns the number of levels of cache represented
>   * in the PPTT. Errors caused by lack of a PPTT table, or otherwise, return 0
>   * indicating we didn't find any cache levels.
>   *
> @@ -534,7 +534,7 @@ int acpi_find_last_cache_level(unsigned int cpu)
>         int number_of_levels = 0;
>         acpi_status status;
>
> -       pr_debug("Cache Setup find last level cpu=%d\n", cpu);
> +       pr_debug("Cache Setup find last level CPU=%d\n", cpu);
>
>         acpi_cpu_id = get_acpi_id_for_cpu(cpu);
>         status = acpi_get_table(ACPI_SIG_PPTT, 0, &table);
> @@ -551,14 +551,14 @@ int acpi_find_last_cache_level(unsigned int cpu)
>
>  /**
>   * cache_setup_acpi() - Override CPU cache topology with data from the PPTT
> - * @cpu: Kernel logical cpu number
> + * @cpu: Kernel logical CPU number
>   *
>   * Updates the global cache info provided by cpu_get_cacheinfo()
>   * when there are valid properties in the acpi_pptt_cache nodes. A
>   * successful parse may not result in any updates if none of the
>   * cache levels have any valid flags set.  Futher, a unique value is
>   * associated with each known CPU cache entry. This unique value
> - * can be used to determine whether caches are shared between cpus.
> + * can be used to determine whether caches are shared between CPUs.
>   *
>   * Return: -ENOENT on failure to find table, or 0 on success
>   */
> @@ -567,7 +567,7 @@ int cache_setup_acpi(unsigned int cpu)
>         struct acpi_table_header *table;
>         acpi_status status;
>
> -       pr_debug("Cache Setup ACPI cpu %d\n", cpu);
> +       pr_debug("Cache Setup ACPI CPU %d\n", cpu);
>
>         status = acpi_get_table(ACPI_SIG_PPTT, 0, &table);
>         if (ACPI_FAILURE(status)) {
> @@ -582,8 +582,8 @@ int cache_setup_acpi(unsigned int cpu)
>  }
>
>  /**
> - * find_acpi_cpu_topology() - Determine a unique topology value for a given cpu
> - * @cpu: Kernel logical cpu number
> + * find_acpi_cpu_topology() - Determine a unique topology value for a given CPU
> + * @cpu: Kernel logical CPU number
>   * @level: The topological level for which we would like a unique ID
>   *
>   * Determine a topology unique ID for each thread/core/cluster/mc_grouping
> @@ -596,7 +596,7 @@ int cache_setup_acpi(unsigned int cpu)
>   * other levels beyond this use a generated value to uniquely identify
>   * a topological feature.
>   *
> - * Return: -ENOENT if the PPTT doesn't exist, or the cpu cannot be found.
> + * Return: -ENOENT if the PPTT doesn't exist, or the CPU cannot be found.
>   * Otherwise returns a value which represents a unique topological feature.
>   */
>  int find_acpi_cpu_topology(unsigned int cpu, int level)
> @@ -606,12 +606,12 @@ int find_acpi_cpu_topology(unsigned int cpu, int level)
>
>  /**
>   * find_acpi_cpu_cache_topology() - Determine a unique cache topology value
> - * @cpu: Kernel logical cpu number
> + * @cpu: Kernel logical CPU number
>   * @level: The cache level for which we would like a unique ID
>   *
>   * Determine a unique ID for each unified cache in the system
>   *
> - * Return: -ENOENT if the PPTT doesn't exist, or the cpu cannot be found.
> + * Return: -ENOENT if the PPTT doesn't exist, or the CPU cannot be found.
>   * Otherwise returns a value which represents a unique topological feature.
>   */
>  int find_acpi_cpu_cache_topology(unsigned int cpu, int level)
> @@ -643,17 +643,17 @@ int find_acpi_cpu_cache_topology(unsigned int cpu, int level)
>
>
>  /**
> - * find_acpi_cpu_topology_package() - Determine a unique cpu package value
> - * @cpu: Kernel logical cpu number
> + * find_acpi_cpu_topology_package() - Determine a unique CPU package value
> + * @cpu: Kernel logical CPU number
>   *
> - * Determine a topology unique package ID for the given cpu.
> + * Determine a topology unique package ID for the given CPU.
>   * This ID can then be used to group peers, which will have matching ids.
>   *
>   * The search terminates when either a level is found with the PHYSICAL_PACKAGE
>   * flag set or we reach a root node.
>   *
> - * Return: -ENOENT if the PPTT doesn't exist, or the cpu cannot be found.
> - * Otherwise returns a value which represents the package for this cpu.
> + * Return: -ENOENT if the PPTT doesn't exist, or the CPU cannot be found.
> + * Otherwise returns a value which represents the package for this CPU.
>   */
>  int find_acpi_cpu_topology_package(unsigned int cpu)
>  {
> --
> 2.20.1
>

Re: [PATCH v2 3/5] ACPI/PPTT: Modify node flag detection to find last IDENTICAL

[Rafael J. Wysocki]

On Sat, Apr 27, 2019 at 12:03 AM Jeremy Linton <jeremy.linton@arm.com> wrote:
>
> The ACPI specification implies that the IDENTICAL flag should be
> set on all non leaf nodes where the children are identical.
> This means that we need to be searching for the last node with
> the identical flag set rather than the first one.
>
> To achieve this with the existing code we need to pass a
> function through the tree traversal logic so we can check
> the next node to assure that IDENTICAL isn't set before returning
> a node with IDENTICAL set.
>
> Signed-off-by: Jeremy Linton <jeremy.linton@arm.com>
> ---
>  drivers/acpi/pptt.c | 62 +++++++++++++++++++++++++++++++++++----------
>  1 file changed, 48 insertions(+), 14 deletions(-)
>
> diff --git a/drivers/acpi/pptt.c b/drivers/acpi/pptt.c
> index 1865515297ca..39f660d8be0a 100644
> --- a/drivers/acpi/pptt.c
> +++ b/drivers/acpi/pptt.c
> @@ -432,17 +432,51 @@ static void cache_setup_acpi_cpu(struct acpi_table_header *table,
>         }
>  }
>
> +
> +typedef bool (*node_check)(struct acpi_table_header *table_hdr,
> +                          struct acpi_pptt_processor *cpu);

I would just use a function pointer with the entire arg list in the
function header(s).  Using this just makes things harder to follow
IMO.

> +static bool flag_package(struct acpi_table_header *table_hdr,
> +                        struct acpi_pptt_processor *cpu)
> +{
> +       return cpu->flags & ACPI_PPTT_PHYSICAL_PACKAGE;
> +}
> +
> +static bool flag_identical(struct acpi_table_header *table_hdr,
> +                          struct acpi_pptt_processor *cpu)
> +{
> +       struct acpi_pptt_processor *next;
> +
> +       /* heterogeneous machines must use PPTT revision > 1 */
> +       if (table_hdr->revision < 2)
> +               return false;
> +
> +       /* Locate the last node in the tree with IDENTICAL set */
> +       if (cpu->flags & ACPI_PPTT_ACPI_IDENTICAL) {
> +               next = fetch_pptt_node(table_hdr, cpu->parent);
> +               if (!(next && next->flags & ACPI_PPTT_ACPI_IDENTICAL))
> +                       return true;
> +       }
> +
> +       return false;
> +}
> +
> +static bool flag_none(struct acpi_table_header *table_hdr,
> +                     struct acpi_pptt_processor *cpu)
> +{
> +       return false;
> +}
> +
>  /* Passing level values greater than this will result in search termination */
>  #define PPTT_ABORT_PACKAGE 0xFF
>
> -static struct acpi_pptt_processor *acpi_find_processor_package_id(struct acpi_table_header *table_hdr,
> -                                                                 struct acpi_pptt_processor *cpu,
> -                                                                 int level, int flag)
> +static struct acpi_pptt_processor *acpi_find_processor_tag_id(struct acpi_table_header *table_hdr,
> +                                                             struct acpi_pptt_processor *cpu,
> +                                                             int level, node_check chk)
>  {
>         struct acpi_pptt_processor *prev_node;
>
>         while (cpu && level) {
> -               if (cpu->flags & flag)
> +               if (chk(table_hdr, cpu))
>                         break;
>                 pr_debug("level %d\n", level);
>                 prev_node = fetch_pptt_node(table_hdr, cpu->parent);
> @@ -473,15 +507,15 @@ static void acpi_pptt_warn_missing(void)
>   * Return: Unique value, or -ENOENT if unable to locate CPU
>   */
>  static int topology_get_acpi_cpu_tag(struct acpi_table_header *table,
> -                                    unsigned int cpu, int level, int flag)
> +                                    unsigned int cpu, int level, node_check chk)
>  {
>         struct acpi_pptt_processor *cpu_node;
>         u32 acpi_cpu_id = get_acpi_id_for_cpu(cpu);
>
>         cpu_node = acpi_find_processor_node(table, acpi_cpu_id);
>         if (cpu_node) {
> -               cpu_node = acpi_find_processor_package_id(table, cpu_node,
> -                                                         level, flag);
> +               cpu_node = acpi_find_processor_tag_id(table, cpu_node,
> +                                                         level, chk);
>                 /*
>                  * As per specification if the processor structure represents
>                  * an actual processor, then ACPI processor ID must be valid.
> @@ -498,7 +532,7 @@ static int topology_get_acpi_cpu_tag(struct acpi_table_header *table,
>         return -ENOENT;
>  }
>
> -static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, int flag)
> +static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, node_check chk)
>  {
>         struct acpi_table_header *table;
>         acpi_status status;
> @@ -509,7 +543,7 @@ static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, int flag)
>                 acpi_pptt_warn_missing();
>                 return -ENOENT;
>         }
> -       retval = topology_get_acpi_cpu_tag(table, cpu, level, flag);
> +       retval = topology_get_acpi_cpu_tag(table, cpu, level, chk);
>         pr_debug("Topology Setup ACPI CPU %d, level %d ret = %d\n",
>                  cpu, level, retval);
>         acpi_put_table(table);
> @@ -601,7 +635,7 @@ int cache_setup_acpi(unsigned int cpu)
>   */
>  int find_acpi_cpu_topology(unsigned int cpu, int level)
>  {
> -       return find_acpi_cpu_topology_tag(cpu, level, 0);
> +       return find_acpi_cpu_topology_tag(cpu, level, flag_none);
>  }
>
>  /**
> @@ -658,7 +692,7 @@ int find_acpi_cpu_cache_topology(unsigned int cpu, int level)
>  int find_acpi_cpu_topology_package(unsigned int cpu)
>  {
>         return find_acpi_cpu_topology_tag(cpu, PPTT_ABORT_PACKAGE,
> -                                         ACPI_PPTT_PHYSICAL_PACKAGE);
> +                                         flag_package);
>  }
>
>  /**
> @@ -670,8 +704,8 @@ int find_acpi_cpu_topology_package(unsigned int cpu)
>   *
>   * The returned tag can be used to group peers with identical implementation.
>   *
> - * The search terminates when a level is found with the identical implementation
> - * flag set or we reach a root node.
> + * The search terminates when a level is found without the identical
> + * implementation flag set following a node with it set, or we reach the root.
>   *
>   * Due to limitations in the PPTT data structure, there may be rare situations
>   * where two cores in a heterogeneous machine may be identical, but won't have
> @@ -684,5 +718,5 @@ int find_acpi_cpu_topology_package(unsigned int cpu)
>  int find_acpi_cpu_topology_hetero_id(unsigned int cpu)
>  {
>         return find_acpi_cpu_topology_tag(cpu, PPTT_ABORT_PACKAGE,
> -                                         ACPI_PPTT_ACPI_IDENTICAL);
> +                                         flag_identical);
>  }
> --

I'm not a super big fan of passing function pointers in general.

I kind of see how this works for you, but why exactly the flag
(ACPI_PPTT_ACPI_IDENTICAL in this case) is not sufficient to
distinguish between the cases?

Re: [PATCH v2 3/5] ACPI/PPTT: Modify node flag detection to find last IDENTICAL

[Rafael J. Wysocki]

On Sat, Apr 27, 2019 at 12:03 AM Jeremy Linton <jeremy.linton@arm.com> wrote:
>
> The ACPI specification implies that the IDENTICAL flag should be
> set on all non leaf nodes where the children are identical.
> This means that we need to be searching for the last node with
> the identical flag set rather than the first one.
>
> To achieve this with the existing code we need to pass a
> function through the tree traversal logic so we can check
> the next node to assure that IDENTICAL isn't set before returning
> a node with IDENTICAL set.
>
> Signed-off-by: Jeremy Linton <jeremy.linton@arm.com>
> ---
>  drivers/acpi/pptt.c | 62 +++++++++++++++++++++++++++++++++++----------
>  1 file changed, 48 insertions(+), 14 deletions(-)
>
> diff --git a/drivers/acpi/pptt.c b/drivers/acpi/pptt.c
> index 1865515297ca..39f660d8be0a 100644
> --- a/drivers/acpi/pptt.c
> +++ b/drivers/acpi/pptt.c
> @@ -432,17 +432,51 @@ static void cache_setup_acpi_cpu(struct acpi_table_header *table,
>         }
>  }
>
> +
> +typedef bool (*node_check)(struct acpi_table_header *table_hdr,
> +                          struct acpi_pptt_processor *cpu);

I would just use a function pointer with the entire arg list in the
function header(s).  Using this just makes things harder to follow
IMO.

> +static bool flag_package(struct acpi_table_header *table_hdr,
> +                        struct acpi_pptt_processor *cpu)
> +{
> +       return cpu->flags & ACPI_PPTT_PHYSICAL_PACKAGE;
> +}
> +
> +static bool flag_identical(struct acpi_table_header *table_hdr,
> +                          struct acpi_pptt_processor *cpu)
> +{
> +       struct acpi_pptt_processor *next;
> +
> +       /* heterogeneous machines must use PPTT revision > 1 */
> +       if (table_hdr->revision < 2)
> +               return false;
> +
> +       /* Locate the last node in the tree with IDENTICAL set */
> +       if (cpu->flags & ACPI_PPTT_ACPI_IDENTICAL) {
> +               next = fetch_pptt_node(table_hdr, cpu->parent);
> +               if (!(next && next->flags & ACPI_PPTT_ACPI_IDENTICAL))
> +                       return true;
> +       }
> +
> +       return false;
> +}
> +
> +static bool flag_none(struct acpi_table_header *table_hdr,
> +                     struct acpi_pptt_processor *cpu)
> +{
> +       return false;
> +}
> +
>  /* Passing level values greater than this will result in search termination */
>  #define PPTT_ABORT_PACKAGE 0xFF
>
> -static struct acpi_pptt_processor *acpi_find_processor_package_id(struct acpi_table_header *table_hdr,
> -                                                                 struct acpi_pptt_processor *cpu,
> -                                                                 int level, int flag)
> +static struct acpi_pptt_processor *acpi_find_processor_tag_id(struct acpi_table_header *table_hdr,
> +                                                             struct acpi_pptt_processor *cpu,
> +                                                             int level, node_check chk)
>  {
>         struct acpi_pptt_processor *prev_node;
>
>         while (cpu && level) {
> -               if (cpu->flags & flag)
> +               if (chk(table_hdr, cpu))
>                         break;
>                 pr_debug("level %d\n", level);
>                 prev_node = fetch_pptt_node(table_hdr, cpu->parent);
> @@ -473,15 +507,15 @@ static void acpi_pptt_warn_missing(void)
>   * Return: Unique value, or -ENOENT if unable to locate CPU
>   */
>  static int topology_get_acpi_cpu_tag(struct acpi_table_header *table,
> -                                    unsigned int cpu, int level, int flag)
> +                                    unsigned int cpu, int level, node_check chk)
>  {
>         struct acpi_pptt_processor *cpu_node;
>         u32 acpi_cpu_id = get_acpi_id_for_cpu(cpu);
>
>         cpu_node = acpi_find_processor_node(table, acpi_cpu_id);
>         if (cpu_node) {
> -               cpu_node = acpi_find_processor_package_id(table, cpu_node,
> -                                                         level, flag);
> +               cpu_node = acpi_find_processor_tag_id(table, cpu_node,
> +                                                         level, chk);
>                 /*
>                  * As per specification if the processor structure represents
>                  * an actual processor, then ACPI processor ID must be valid.
> @@ -498,7 +532,7 @@ static int topology_get_acpi_cpu_tag(struct acpi_table_header *table,
>         return -ENOENT;
>  }
>
> -static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, int flag)
> +static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, node_check chk)
>  {
>         struct acpi_table_header *table;
>         acpi_status status;
> @@ -509,7 +543,7 @@ static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, int flag)
>                 acpi_pptt_warn_missing();
>                 return -ENOENT;
>         }
> -       retval = topology_get_acpi_cpu_tag(table, cpu, level, flag);
> +       retval = topology_get_acpi_cpu_tag(table, cpu, level, chk);
>         pr_debug("Topology Setup ACPI CPU %d, level %d ret = %d\n",
>                  cpu, level, retval);
>         acpi_put_table(table);
> @@ -601,7 +635,7 @@ int cache_setup_acpi(unsigned int cpu)
>   */
>  int find_acpi_cpu_topology(unsigned int cpu, int level)
>  {
> -       return find_acpi_cpu_topology_tag(cpu, level, 0);
> +       return find_acpi_cpu_topology_tag(cpu, level, flag_none);
>  }
>
>  /**
> @@ -658,7 +692,7 @@ int find_acpi_cpu_cache_topology(unsigned int cpu, int level)
>  int find_acpi_cpu_topology_package(unsigned int cpu)
>  {
>         return find_acpi_cpu_topology_tag(cpu, PPTT_ABORT_PACKAGE,
> -                                         ACPI_PPTT_PHYSICAL_PACKAGE);
> +                                         flag_package);
>  }
>
>  /**
> @@ -670,8 +704,8 @@ int find_acpi_cpu_topology_package(unsigned int cpu)
>   *
>   * The returned tag can be used to group peers with identical implementation.
>   *
> - * The search terminates when a level is found with the identical implementation
> - * flag set or we reach a root node.
> + * The search terminates when a level is found without the identical
> + * implementation flag set following a node with it set, or we reach the root.
>   *
>   * Due to limitations in the PPTT data structure, there may be rare situations
>   * where two cores in a heterogeneous machine may be identical, but won't have
> @@ -684,5 +718,5 @@ int find_acpi_cpu_topology_package(unsigned int cpu)
>  int find_acpi_cpu_topology_hetero_id(unsigned int cpu)
>  {
>         return find_acpi_cpu_topology_tag(cpu, PPTT_ABORT_PACKAGE,
> -                                         ACPI_PPTT_ACPI_IDENTICAL);
> +                                         flag_identical);
>  }
> --

I'm not a super big fan of passing function pointers in general.

I kind of see how this works for you, but why exactly the flag
(ACPI_PPTT_ACPI_IDENTICAL in this case) is not sufficient to
distinguish between the cases?

Re: [PATCH v2 0/5] arm64: SPE ACPI enablement

[Will Deacon]

Hi Jeremy,

On Fri, Apr 26, 2019 at 05:03:04PM -0500, Jeremy Linton wrote:
> This patch series enables the Arm Statistical Profiling
> Extension (SPE) on ACPI platforms.
> 
> This is possible because ACPI 6.3 uses a previously
> reserved field in the MADT to store the SPE interrupt
> number, similarly to how the normal PMU is described.
> If a consistent valid interrupt exists across all the
> cores in the system, a platform device is registered.
> That then triggers the SPE module, which runs as normal.
> 
> This version also adds the ability to parse the PPTT for
> IDENTICAL cores. We then use this to sanity check the
> single SPE device we create. This creates a bit of a
> problem with respect to the specification though. The
> specification says that its legal for multiple tree's
> to exist in the PPTT. We handle this fine, but what
> happens in the case of multiple tree's is that the lack
> of a common node with IDENTICAL set forces us to assume
> that there are multiple non IDENTICAL cores in the
> machine.

This looks good to me. Please can you respin, addressing Raphael's
outstanding concerns on the third patch?

Will

Re: [PATCH v2 0/5] arm64: SPE ACPI enablement

[Will Deacon]

Hi Jeremy,

On Fri, Apr 26, 2019 at 05:03:04PM -0500, Jeremy Linton wrote:
> This patch series enables the Arm Statistical Profiling
> Extension (SPE) on ACPI platforms.
> 
> This is possible because ACPI 6.3 uses a previously
> reserved field in the MADT to store the SPE interrupt
> number, similarly to how the normal PMU is described.
> If a consistent valid interrupt exists across all the
> cores in the system, a platform device is registered.
> That then triggers the SPE module, which runs as normal.
> 
> This version also adds the ability to parse the PPTT for
> IDENTICAL cores. We then use this to sanity check the
> single SPE device we create. This creates a bit of a
> problem with respect to the specification though. The
> specification says that its legal for multiple tree's
> to exist in the PPTT. We handle this fine, but what
> happens in the case of multiple tree's is that the lack
> of a common node with IDENTICAL set forces us to assume
> that there are multiple non IDENTICAL cores in the
> machine.

This looks good to me. Please can you respin, addressing Raphael's
outstanding concerns on the third patch?

Will

Re: [PATCH v2 1/5] ACPI/PPTT: Trivial, Modify the case of CPU

[Jeremy Linton]

Hi,

And sorry about the delay...

On 4/29/19 3:50 AM, Rafael J. Wysocki wrote:
> On Sat, Apr 27, 2019 at 12:03 AM Jeremy Linton <jeremy.linton@arm.com> wrote:
>>
>> CPU is an acronym and customarily capitalized. Much of the
>> commenting in the PPTT code has been using "cpu" rather
>> than "CPU". Correct that, and other human readable strings.
>>
>> Signed-off-by: Jeremy Linton <jeremy.linton@arm.com>
> 
> It would be better to say "Modify the spelling of CPU" in the subject
> IMO, but apart from that

Hmmm, spelling doesn't seem quite right either, how about "capitalization"?


> 
> Acked-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
> 
>> ---
>>   drivers/acpi/pptt.c | 48 ++++++++++++++++++++++-----------------------
>>   1 file changed, 24 insertions(+), 24 deletions(-)
>>
>> diff --git a/drivers/acpi/pptt.c b/drivers/acpi/pptt.c
>> index 065c4fc245d1..83a026765faa 100644
>> --- a/drivers/acpi/pptt.c
>> +++ b/drivers/acpi/pptt.c
>> @@ -164,7 +164,7 @@ static struct acpi_pptt_cache *acpi_find_cache_level(struct acpi_table_header *t
>>   }
>>
>>   /**
>> - * acpi_count_levels() - Given a PPTT table, and a cpu node, count the caches
>> + * acpi_count_levels() - Given a PPTT table, and a CPU node, count the caches
>>    * @table_hdr: Pointer to the head of the PPTT table
>>    * @cpu_node: processor node we wish to count caches for
>>    *
>> @@ -235,7 +235,7 @@ static int acpi_pptt_leaf_node(struct acpi_table_header *table_hdr,
>>   /**
>>    * acpi_find_processor_node() - Given a PPTT table find the requested  cessor
>>    * @table_hdr:  Pointer to the head of the PPTT table
>> - * @acpi_cpu_id: cpu we are searching for
>> + * @acpi_cpu_id: CPU we are searching for
>>    *
>>    * Find the subtable entry describing the provided processor.
>>    * This is done by iterating the PPTT table looking for processor nodes
>> @@ -456,21 +456,21 @@ static struct acpi_pptt_processor *acpi_find_processor_package_id(struct acpi_ta
>>
>>   static void acpi_pptt_warn_missing(void)
>>   {
>> -       pr_warn_once("No PPTT table found, cpu and cache topology may be inaccurate\n");
>> +       pr_warn_once("No PPTT table found, CPU and cache topology may be inaccurate\n");
>>   }
>>
>>   /**
>>    * topology_get_acpi_cpu_tag() - Find a unique topology value for a feature
>>    * @table: Pointer to the head of the PPTT table
>> - * @cpu: Kernel logical cpu number
>> + * @cpu: Kernel logical CPU number
>>    * @level: A level that terminates the search
>>    * @flag: A flag which terminates the search
>>    *
>> - * Get a unique value given a cpu, and a topology level, that can be
>> - * matched to determine which cpus share common topological features
>> + * Get a unique value given a CPU, and a topology level, that can be
>> + * matched to determine which CPUs share common topological features
>>    * at that level.
>>    *
>> - * Return: Unique value, or -ENOENT if unable to locate cpu
>> + * Return: Unique value, or -ENOENT if unable to locate CPU
>>    */
>>   static int topology_get_acpi_cpu_tag(struct acpi_table_header *table,
>>                                       unsigned int cpu, int level, int flag)
>> @@ -510,7 +510,7 @@ static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, int flag)
>>                  return -ENOENT;
>>          }
>>          retval = topology_get_acpi_cpu_tag(table, cpu, level, flag);
>> -       pr_debug("Topology Setup ACPI cpu %d, level %d ret = %d\n",
>> +       pr_debug("Topology Setup ACPI CPU %d, level %d ret = %d\n",
>>                   cpu, level, retval);
>>          acpi_put_table(table);
>>
>> @@ -519,9 +519,9 @@ static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, int flag)
>>
>>   /**
>>    * acpi_find_last_cache_level() - Determines the number of cache levels for a PE
>> - * @cpu: Kernel logical cpu number
>> + * @cpu: Kernel logical CPU number
>>    *
>> - * Given a logical cpu number, returns the number of levels of cache represented
>> + * Given a logical CPU number, returns the number of levels of cache represented
>>    * in the PPTT. Errors caused by lack of a PPTT table, or otherwise, return 0
>>    * indicating we didn't find any cache levels.
>>    *
>> @@ -534,7 +534,7 @@ int acpi_find_last_cache_level(unsigned int cpu)
>>          int number_of_levels = 0;
>>          acpi_status status;
>>
>> -       pr_debug("Cache Setup find last level cpu=%d\n", cpu);
>> +       pr_debug("Cache Setup find last level CPU=%d\n", cpu);
>>
>>          acpi_cpu_id = get_acpi_id_for_cpu(cpu);
>>          status = acpi_get_table(ACPI_SIG_PPTT, 0, &table);
>> @@ -551,14 +551,14 @@ int acpi_find_last_cache_level(unsigned int cpu)
>>
>>   /**
>>    * cache_setup_acpi() - Override CPU cache topology with data from the PPTT
>> - * @cpu: Kernel logical cpu number
>> + * @cpu: Kernel logical CPU number
>>    *
>>    * Updates the global cache info provided by cpu_get_cacheinfo()
>>    * when there are valid properties in the acpi_pptt_cache nodes. A
>>    * successful parse may not result in any updates if none of the
>>    * cache levels have any valid flags set.  Futher, a unique value is
>>    * associated with each known CPU cache entry. This unique value
>> - * can be used to determine whether caches are shared between cpus.
>> + * can be used to determine whether caches are shared between CPUs.
>>    *
>>    * Return: -ENOENT on failure to find table, or 0 on success
>>    */
>> @@ -567,7 +567,7 @@ int cache_setup_acpi(unsigned int cpu)
>>          struct acpi_table_header *table;
>>          acpi_status status;
>>
>> -       pr_debug("Cache Setup ACPI cpu %d\n", cpu);
>> +       pr_debug("Cache Setup ACPI CPU %d\n", cpu);
>>
>>          status = acpi_get_table(ACPI_SIG_PPTT, 0, &table);
>>          if (ACPI_FAILURE(status)) {
>> @@ -582,8 +582,8 @@ int cache_setup_acpi(unsigned int cpu)
>>   }
>>
>>   /**
>> - * find_acpi_cpu_topology() - Determine a unique topology value for a given cpu
>> - * @cpu: Kernel logical cpu number
>> + * find_acpi_cpu_topology() - Determine a unique topology value for a given CPU
>> + * @cpu: Kernel logical CPU number
>>    * @level: The topological level for which we would like a unique ID
>>    *
>>    * Determine a topology unique ID for each thread/core/cluster/mc_grouping
>> @@ -596,7 +596,7 @@ int cache_setup_acpi(unsigned int cpu)
>>    * other levels beyond this use a generated value to uniquely identify
>>    * a topological feature.
>>    *
>> - * Return: -ENOENT if the PPTT doesn't exist, or the cpu cannot be found.
>> + * Return: -ENOENT if the PPTT doesn't exist, or the CPU cannot be found.
>>    * Otherwise returns a value which represents a unique topological feature.
>>    */
>>   int find_acpi_cpu_topology(unsigned int cpu, int level)
>> @@ -606,12 +606,12 @@ int find_acpi_cpu_topology(unsigned int cpu, int level)
>>
>>   /**
>>    * find_acpi_cpu_cache_topology() - Determine a unique cache topology value
>> - * @cpu: Kernel logical cpu number
>> + * @cpu: Kernel logical CPU number
>>    * @level: The cache level for which we would like a unique ID
>>    *
>>    * Determine a unique ID for each unified cache in the system
>>    *
>> - * Return: -ENOENT if the PPTT doesn't exist, or the cpu cannot be found.
>> + * Return: -ENOENT if the PPTT doesn't exist, or the CPU cannot be found.
>>    * Otherwise returns a value which represents a unique topological feature.
>>    */
>>   int find_acpi_cpu_cache_topology(unsigned int cpu, int level)
>> @@ -643,17 +643,17 @@ int find_acpi_cpu_cache_topology(unsigned int cpu, int level)
>>
>>
>>   /**
>> - * find_acpi_cpu_topology_package() - Determine a unique cpu package value
>> - * @cpu: Kernel logical cpu number
>> + * find_acpi_cpu_topology_package() - Determine a unique CPU package value
>> + * @cpu: Kernel logical CPU number
>>    *
>> - * Determine a topology unique package ID for the given cpu.
>> + * Determine a topology unique package ID for the given CPU.
>>    * This ID can then be used to group peers, which will have matching ids.
>>    *
>>    * The search terminates when either a level is found with the PHYSICAL_PACKAGE
>>    * flag set or we reach a root node.
>>    *
>> - * Return: -ENOENT if the PPTT doesn't exist, or the cpu cannot be found.
>> - * Otherwise returns a value which represents the package for this cpu.
>> + * Return: -ENOENT if the PPTT doesn't exist, or the CPU cannot be found.
>> + * Otherwise returns a value which represents the package for this CPU.
>>    */
>>   int find_acpi_cpu_topology_package(unsigned int cpu)
>>   {
>> --
>> 2.20.1
>>

Re: [PATCH v2 1/5] ACPI/PPTT: Trivial, Modify the case of CPU

[Jeremy Linton]

Hi,

And sorry about the delay...

On 4/29/19 3:50 AM, Rafael J. Wysocki wrote:
> On Sat, Apr 27, 2019 at 12:03 AM Jeremy Linton <jeremy.linton@arm.com> wrote:
>>
>> CPU is an acronym and customarily capitalized. Much of the
>> commenting in the PPTT code has been using "cpu" rather
>> than "CPU". Correct that, and other human readable strings.
>>
>> Signed-off-by: Jeremy Linton <jeremy.linton@arm.com>
> 
> It would be better to say "Modify the spelling of CPU" in the subject
> IMO, but apart from that

Hmmm, spelling doesn't seem quite right either, how about "capitalization"?


> 
> Acked-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
> 
>> ---
>>   drivers/acpi/pptt.c | 48 ++++++++++++++++++++++-----------------------
>>   1 file changed, 24 insertions(+), 24 deletions(-)
>>
>> diff --git a/drivers/acpi/pptt.c b/drivers/acpi/pptt.c
>> index 065c4fc245d1..83a026765faa 100644
>> --- a/drivers/acpi/pptt.c
>> +++ b/drivers/acpi/pptt.c
>> @@ -164,7 +164,7 @@ static struct acpi_pptt_cache *acpi_find_cache_level(struct acpi_table_header *t
>>   }
>>
>>   /**
>> - * acpi_count_levels() - Given a PPTT table, and a cpu node, count the caches
>> + * acpi_count_levels() - Given a PPTT table, and a CPU node, count the caches
>>    * @table_hdr: Pointer to the head of the PPTT table
>>    * @cpu_node: processor node we wish to count caches for
>>    *
>> @@ -235,7 +235,7 @@ static int acpi_pptt_leaf_node(struct acpi_table_header *table_hdr,
>>   /**
>>    * acpi_find_processor_node() - Given a PPTT table find the requested  cessor
>>    * @table_hdr:  Pointer to the head of the PPTT table
>> - * @acpi_cpu_id: cpu we are searching for
>> + * @acpi_cpu_id: CPU we are searching for
>>    *
>>    * Find the subtable entry describing the provided processor.
>>    * This is done by iterating the PPTT table looking for processor nodes
>> @@ -456,21 +456,21 @@ static struct acpi_pptt_processor *acpi_find_processor_package_id(struct acpi_ta
>>
>>   static void acpi_pptt_warn_missing(void)
>>   {
>> -       pr_warn_once("No PPTT table found, cpu and cache topology may be inaccurate\n");
>> +       pr_warn_once("No PPTT table found, CPU and cache topology may be inaccurate\n");
>>   }
>>
>>   /**
>>    * topology_get_acpi_cpu_tag() - Find a unique topology value for a feature
>>    * @table: Pointer to the head of the PPTT table
>> - * @cpu: Kernel logical cpu number
>> + * @cpu: Kernel logical CPU number
>>    * @level: A level that terminates the search
>>    * @flag: A flag which terminates the search
>>    *
>> - * Get a unique value given a cpu, and a topology level, that can be
>> - * matched to determine which cpus share common topological features
>> + * Get a unique value given a CPU, and a topology level, that can be
>> + * matched to determine which CPUs share common topological features
>>    * at that level.
>>    *
>> - * Return: Unique value, or -ENOENT if unable to locate cpu
>> + * Return: Unique value, or -ENOENT if unable to locate CPU
>>    */
>>   static int topology_get_acpi_cpu_tag(struct acpi_table_header *table,
>>                                       unsigned int cpu, int level, int flag)
>> @@ -510,7 +510,7 @@ static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, int flag)
>>                  return -ENOENT;
>>          }
>>          retval = topology_get_acpi_cpu_tag(table, cpu, level, flag);
>> -       pr_debug("Topology Setup ACPI cpu %d, level %d ret = %d\n",
>> +       pr_debug("Topology Setup ACPI CPU %d, level %d ret = %d\n",
>>                   cpu, level, retval);
>>          acpi_put_table(table);
>>
>> @@ -519,9 +519,9 @@ static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, int flag)
>>
>>   /**
>>    * acpi_find_last_cache_level() - Determines the number of cache levels for a PE
>> - * @cpu: Kernel logical cpu number
>> + * @cpu: Kernel logical CPU number
>>    *
>> - * Given a logical cpu number, returns the number of levels of cache represented
>> + * Given a logical CPU number, returns the number of levels of cache represented
>>    * in the PPTT. Errors caused by lack of a PPTT table, or otherwise, return 0
>>    * indicating we didn't find any cache levels.
>>    *
>> @@ -534,7 +534,7 @@ int acpi_find_last_cache_level(unsigned int cpu)
>>          int number_of_levels = 0;
>>          acpi_status status;
>>
>> -       pr_debug("Cache Setup find last level cpu=%d\n", cpu);
>> +       pr_debug("Cache Setup find last level CPU=%d\n", cpu);
>>
>>          acpi_cpu_id = get_acpi_id_for_cpu(cpu);
>>          status = acpi_get_table(ACPI_SIG_PPTT, 0, &table);
>> @@ -551,14 +551,14 @@ int acpi_find_last_cache_level(unsigned int cpu)
>>
>>   /**
>>    * cache_setup_acpi() - Override CPU cache topology with data from the PPTT
>> - * @cpu: Kernel logical cpu number
>> + * @cpu: Kernel logical CPU number
>>    *
>>    * Updates the global cache info provided by cpu_get_cacheinfo()
>>    * when there are valid properties in the acpi_pptt_cache nodes. A
>>    * successful parse may not result in any updates if none of the
>>    * cache levels have any valid flags set.  Futher, a unique value is
>>    * associated with each known CPU cache entry. This unique value
>> - * can be used to determine whether caches are shared between cpus.
>> + * can be used to determine whether caches are shared between CPUs.
>>    *
>>    * Return: -ENOENT on failure to find table, or 0 on success
>>    */
>> @@ -567,7 +567,7 @@ int cache_setup_acpi(unsigned int cpu)
>>          struct acpi_table_header *table;
>>          acpi_status status;
>>
>> -       pr_debug("Cache Setup ACPI cpu %d\n", cpu);
>> +       pr_debug("Cache Setup ACPI CPU %d\n", cpu);
>>
>>          status = acpi_get_table(ACPI_SIG_PPTT, 0, &table);
>>          if (ACPI_FAILURE(status)) {
>> @@ -582,8 +582,8 @@ int cache_setup_acpi(unsigned int cpu)
>>   }
>>
>>   /**
>> - * find_acpi_cpu_topology() - Determine a unique topology value for a given cpu
>> - * @cpu: Kernel logical cpu number
>> + * find_acpi_cpu_topology() - Determine a unique topology value for a given CPU
>> + * @cpu: Kernel logical CPU number
>>    * @level: The topological level for which we would like a unique ID
>>    *
>>    * Determine a topology unique ID for each thread/core/cluster/mc_grouping
>> @@ -596,7 +596,7 @@ int cache_setup_acpi(unsigned int cpu)
>>    * other levels beyond this use a generated value to uniquely identify
>>    * a topological feature.
>>    *
>> - * Return: -ENOENT if the PPTT doesn't exist, or the cpu cannot be found.
>> + * Return: -ENOENT if the PPTT doesn't exist, or the CPU cannot be found.
>>    * Otherwise returns a value which represents a unique topological feature.
>>    */
>>   int find_acpi_cpu_topology(unsigned int cpu, int level)
>> @@ -606,12 +606,12 @@ int find_acpi_cpu_topology(unsigned int cpu, int level)
>>
>>   /**
>>    * find_acpi_cpu_cache_topology() - Determine a unique cache topology value
>> - * @cpu: Kernel logical cpu number
>> + * @cpu: Kernel logical CPU number
>>    * @level: The cache level for which we would like a unique ID
>>    *
>>    * Determine a unique ID for each unified cache in the system
>>    *
>> - * Return: -ENOENT if the PPTT doesn't exist, or the cpu cannot be found.
>> + * Return: -ENOENT if the PPTT doesn't exist, or the CPU cannot be found.
>>    * Otherwise returns a value which represents a unique topological feature.
>>    */
>>   int find_acpi_cpu_cache_topology(unsigned int cpu, int level)
>> @@ -643,17 +643,17 @@ int find_acpi_cpu_cache_topology(unsigned int cpu, int level)
>>
>>
>>   /**
>> - * find_acpi_cpu_topology_package() - Determine a unique cpu package value
>> - * @cpu: Kernel logical cpu number
>> + * find_acpi_cpu_topology_package() - Determine a unique CPU package value
>> + * @cpu: Kernel logical CPU number
>>    *
>> - * Determine a topology unique package ID for the given cpu.
>> + * Determine a topology unique package ID for the given CPU.
>>    * This ID can then be used to group peers, which will have matching ids.
>>    *
>>    * The search terminates when either a level is found with the PHYSICAL_PACKAGE
>>    * flag set or we reach a root node.
>>    *
>> - * Return: -ENOENT if the PPTT doesn't exist, or the cpu cannot be found.
>> - * Otherwise returns a value which represents the package for this cpu.
>> + * Return: -ENOENT if the PPTT doesn't exist, or the CPU cannot be found.
>> + * Otherwise returns a value which represents the package for this CPU.
>>    */
>>   int find_acpi_cpu_topology_package(unsigned int cpu)
>>   {
>> --
>> 2.20.1
>>

Re: [PATCH v2 3/5] ACPI/PPTT: Modify node flag detection to find last IDENTICAL

[Jeremy Linton]

Hi,

On 4/29/19 3:59 AM, Rafael J. Wysocki wrote:
> On Sat, Apr 27, 2019 at 12:03 AM Jeremy Linton <jeremy.linton@arm.com> wrote:
>>
>> The ACPI specification implies that the IDENTICAL flag should be
>> set on all non leaf nodes where the children are identical.
>> This means that we need to be searching for the last node with
>> the identical flag set rather than the first one.
>>
>> To achieve this with the existing code we need to pass a
>> function through the tree traversal logic so we can check
>> the next node to assure that IDENTICAL isn't set before returning
>> a node with IDENTICAL set.
>>
>> Signed-off-by: Jeremy Linton <jeremy.linton@arm.com>
>> ---
>>   drivers/acpi/pptt.c | 62 +++++++++++++++++++++++++++++++++++----------
>>   1 file changed, 48 insertions(+), 14 deletions(-)
>>
>> diff --git a/drivers/acpi/pptt.c b/drivers/acpi/pptt.c
>> index 1865515297ca..39f660d8be0a 100644
>> --- a/drivers/acpi/pptt.c
>> +++ b/drivers/acpi/pptt.c
>> @@ -432,17 +432,51 @@ static void cache_setup_acpi_cpu(struct acpi_table_header *table,
>>          }
>>   }
>>
>> +
>> +typedef bool (*node_check)(struct acpi_table_header *table_hdr,
>> +                          struct acpi_pptt_processor *cpu);
> 
> I would just use a function pointer with the entire arg list in the
> function header(s).  Using this just makes things harder to follow
> IMO.

Ok... that makes the headers a bit big, maybe there is a better way.


> 
>> +static bool flag_package(struct acpi_table_header *table_hdr,
>> +                        struct acpi_pptt_processor *cpu)
>> +{
>> +       return cpu->flags & ACPI_PPTT_PHYSICAL_PACKAGE;
>> +}
>> +
>> +static bool flag_identical(struct acpi_table_header *table_hdr,
>> +                          struct acpi_pptt_processor *cpu)
>> +{
>> +       struct acpi_pptt_processor *next;
>> +
>> +       /* heterogeneous machines must use PPTT revision > 1 */
>> +       if (table_hdr->revision < 2)
>> +               return false;
>> +
>> +       /* Locate the last node in the tree with IDENTICAL set */
>> +       if (cpu->flags & ACPI_PPTT_ACPI_IDENTICAL) {
>> +               next = fetch_pptt_node(table_hdr, cpu->parent);
>> +               if (!(next && next->flags & ACPI_PPTT_ACPI_IDENTICAL))
>> +                       return true;
>> +       }
>> +
>> +       return false;
>> +}
>> +
>> +static bool flag_none(struct acpi_table_header *table_hdr,
>> +                     struct acpi_pptt_processor *cpu)
>> +{
>> +       return false;
>> +}
>> +
>>   /* Passing level values greater than this will result in search termination */
>>   #define PPTT_ABORT_PACKAGE 0xFF
>>
>> -static struct acpi_pptt_processor *acpi_find_processor_package_id(struct acpi_table_header *table_hdr,
>> -                                                                 struct acpi_pptt_processor *cpu,
>> -                                                                 int level, int flag)
>> +static struct acpi_pptt_processor *acpi_find_processor_tag_id(struct acpi_table_header *table_hdr,
>> +                                                             struct acpi_pptt_processor *cpu,
>> +                                                             int level, node_check chk)
>>   {
>>          struct acpi_pptt_processor *prev_node;
>>
>>          while (cpu && level) {
>> -               if (cpu->flags & flag)
>> +               if (chk(table_hdr, cpu))
>>                          break;
>>                  pr_debug("level %d\n", level);
>>                  prev_node = fetch_pptt_node(table_hdr, cpu->parent);
>> @@ -473,15 +507,15 @@ static void acpi_pptt_warn_missing(void)
>>    * Return: Unique value, or -ENOENT if unable to locate CPU
>>    */
>>   static int topology_get_acpi_cpu_tag(struct acpi_table_header *table,
>> -                                    unsigned int cpu, int level, int flag)
>> +                                    unsigned int cpu, int level, node_check chk)
>>   {
>>          struct acpi_pptt_processor *cpu_node;
>>          u32 acpi_cpu_id = get_acpi_id_for_cpu(cpu);
>>
>>          cpu_node = acpi_find_processor_node(table, acpi_cpu_id);
>>          if (cpu_node) {
>> -               cpu_node = acpi_find_processor_package_id(table, cpu_node,
>> -                                                         level, flag);
>> +               cpu_node = acpi_find_processor_tag_id(table, cpu_node,
>> +                                                         level, chk);
>>                  /*
>>                   * As per specification if the processor structure represents
>>                   * an actual processor, then ACPI processor ID must be valid.
>> @@ -498,7 +532,7 @@ static int topology_get_acpi_cpu_tag(struct acpi_table_header *table,
>>          return -ENOENT;
>>   }
>>
>> -static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, int flag)
>> +static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, node_check chk)
>>   {
>>          struct acpi_table_header *table;
>>          acpi_status status;
>> @@ -509,7 +543,7 @@ static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, int flag)
>>                  acpi_pptt_warn_missing();
>>                  return -ENOENT;
>>          }
>> -       retval = topology_get_acpi_cpu_tag(table, cpu, level, flag);
>> +       retval = topology_get_acpi_cpu_tag(table, cpu, level, chk);
>>          pr_debug("Topology Setup ACPI CPU %d, level %d ret = %d\n",
>>                   cpu, level, retval);
>>          acpi_put_table(table);
>> @@ -601,7 +635,7 @@ int cache_setup_acpi(unsigned int cpu)
>>    */
>>   int find_acpi_cpu_topology(unsigned int cpu, int level)
>>   {
>> -       return find_acpi_cpu_topology_tag(cpu, level, 0);
>> +       return find_acpi_cpu_topology_tag(cpu, level, flag_none);
>>   }
>>
>>   /**
>> @@ -658,7 +692,7 @@ int find_acpi_cpu_cache_topology(unsigned int cpu, int level)
>>   int find_acpi_cpu_topology_package(unsigned int cpu)
>>   {
>>          return find_acpi_cpu_topology_tag(cpu, PPTT_ABORT_PACKAGE,
>> -                                         ACPI_PPTT_PHYSICAL_PACKAGE);
>> +                                         flag_package);
>>   }
>>
>>   /**
>> @@ -670,8 +704,8 @@ int find_acpi_cpu_topology_package(unsigned int cpu)
>>    *
>>    * The returned tag can be used to group peers with identical implementation.
>>    *
>> - * The search terminates when a level is found with the identical implementation
>> - * flag set or we reach a root node.
>> + * The search terminates when a level is found without the identical
>> + * implementation flag set following a node with it set, or we reach the root.
>>    *
>>    * Due to limitations in the PPTT data structure, there may be rare situations
>>    * where two cores in a heterogeneous machine may be identical, but won't have
>> @@ -684,5 +718,5 @@ int find_acpi_cpu_topology_package(unsigned int cpu)
>>   int find_acpi_cpu_topology_hetero_id(unsigned int cpu)
>>   {
>>          return find_acpi_cpu_topology_tag(cpu, PPTT_ABORT_PACKAGE,
>> -                                         ACPI_PPTT_ACPI_IDENTICAL);
>> +                                         flag_identical);
>>   }
>> --
> 
> I'm not a super big fan of passing function pointers in general.

Me either really, but it was fairly concise here. We could just switch 
on the flag and opencode the IDENTICAL special case in 
acpi_find_processor_tag_id(). I wouldn't expect there to be too many 
special case flags like this so that may be a better solution.

OTOH, I'm not even sure this patch is the right thing to do, it depends 
on how you read the intention of the spec. That is why I haven't merged 
it with 2/5 and AFAIK, the one machine that was setting the IDENTICAL 
flags everywhere had another problem which is forcing them to update the 
table, and they appear to have also corrected the table to only set it 
on the final identical node.

So, maybe I should drop this piece of the set and wait for someone to 
complain or the spec to be clarified?

> 
> I kind of see how this works for you, but why exactly the flag
> (ACPI_PPTT_ACPI_IDENTICAL in this case) is not sufficient to
> distinguish between the cases?
> 

I guess I'm not clear what your asking here, maybe just a clarification 
of why this patch is needed vs just 2/5? Under that assumption:

The spec reads "A value of 1 indicates that all children processors 
share an identical implementation revision". So AFAIK the intention was 
that it behaves like the Physical package flag, which has an additional 
clarification which reads "Each valid processor must belong to exactly 
one package". Minus that blurb, it seems a valid interpretation is that 
a homogeneous machine can have the IDENTICAL flag set on every non-leaf 
node. Since we are traversing the tree from the leaf to the root 
(because that is the way the tree is structured) we need to find the 
last node along the traversal with the IDENTICAL set in order to return 
the common node closest to the root. With just 2/5 we end up returning 
the node closest the leaf, which means processors which share a 
IDENTICAL node won't necessarily have duplicate tags (which is what we 
need).

If we can assume that there is only a single IDENTICAL flag along the 
path between any given leaf and the root, this patch would not be necessary.

Re: [PATCH v2 3/5] ACPI/PPTT: Modify node flag detection to find last IDENTICAL

[Jeremy Linton]

Hi,

On 4/29/19 3:59 AM, Rafael J. Wysocki wrote:
> On Sat, Apr 27, 2019 at 12:03 AM Jeremy Linton <jeremy.linton@arm.com> wrote:
>>
>> The ACPI specification implies that the IDENTICAL flag should be
>> set on all non leaf nodes where the children are identical.
>> This means that we need to be searching for the last node with
>> the identical flag set rather than the first one.
>>
>> To achieve this with the existing code we need to pass a
>> function through the tree traversal logic so we can check
>> the next node to assure that IDENTICAL isn't set before returning
>> a node with IDENTICAL set.
>>
>> Signed-off-by: Jeremy Linton <jeremy.linton@arm.com>
>> ---
>>   drivers/acpi/pptt.c | 62 +++++++++++++++++++++++++++++++++++----------
>>   1 file changed, 48 insertions(+), 14 deletions(-)
>>
>> diff --git a/drivers/acpi/pptt.c b/drivers/acpi/pptt.c
>> index 1865515297ca..39f660d8be0a 100644
>> --- a/drivers/acpi/pptt.c
>> +++ b/drivers/acpi/pptt.c
>> @@ -432,17 +432,51 @@ static void cache_setup_acpi_cpu(struct acpi_table_header *table,
>>          }
>>   }
>>
>> +
>> +typedef bool (*node_check)(struct acpi_table_header *table_hdr,
>> +                          struct acpi_pptt_processor *cpu);
> 
> I would just use a function pointer with the entire arg list in the
> function header(s).  Using this just makes things harder to follow
> IMO.

Ok... that makes the headers a bit big, maybe there is a better way.


> 
>> +static bool flag_package(struct acpi_table_header *table_hdr,
>> +                        struct acpi_pptt_processor *cpu)
>> +{
>> +       return cpu->flags & ACPI_PPTT_PHYSICAL_PACKAGE;
>> +}
>> +
>> +static bool flag_identical(struct acpi_table_header *table_hdr,
>> +                          struct acpi_pptt_processor *cpu)
>> +{
>> +       struct acpi_pptt_processor *next;
>> +
>> +       /* heterogeneous machines must use PPTT revision > 1 */
>> +       if (table_hdr->revision < 2)
>> +               return false;
>> +
>> +       /* Locate the last node in the tree with IDENTICAL set */
>> +       if (cpu->flags & ACPI_PPTT_ACPI_IDENTICAL) {
>> +               next = fetch_pptt_node(table_hdr, cpu->parent);
>> +               if (!(next && next->flags & ACPI_PPTT_ACPI_IDENTICAL))
>> +                       return true;
>> +       }
>> +
>> +       return false;
>> +}
>> +
>> +static bool flag_none(struct acpi_table_header *table_hdr,
>> +                     struct acpi_pptt_processor *cpu)
>> +{
>> +       return false;
>> +}
>> +
>>   /* Passing level values greater than this will result in search termination */
>>   #define PPTT_ABORT_PACKAGE 0xFF
>>
>> -static struct acpi_pptt_processor *acpi_find_processor_package_id(struct acpi_table_header *table_hdr,
>> -                                                                 struct acpi_pptt_processor *cpu,
>> -                                                                 int level, int flag)
>> +static struct acpi_pptt_processor *acpi_find_processor_tag_id(struct acpi_table_header *table_hdr,
>> +                                                             struct acpi_pptt_processor *cpu,
>> +                                                             int level, node_check chk)
>>   {
>>          struct acpi_pptt_processor *prev_node;
>>
>>          while (cpu && level) {
>> -               if (cpu->flags & flag)
>> +               if (chk(table_hdr, cpu))
>>                          break;
>>                  pr_debug("level %d\n", level);
>>                  prev_node = fetch_pptt_node(table_hdr, cpu->parent);
>> @@ -473,15 +507,15 @@ static void acpi_pptt_warn_missing(void)
>>    * Return: Unique value, or -ENOENT if unable to locate CPU
>>    */
>>   static int topology_get_acpi_cpu_tag(struct acpi_table_header *table,
>> -                                    unsigned int cpu, int level, int flag)
>> +                                    unsigned int cpu, int level, node_check chk)
>>   {
>>          struct acpi_pptt_processor *cpu_node;
>>          u32 acpi_cpu_id = get_acpi_id_for_cpu(cpu);
>>
>>          cpu_node = acpi_find_processor_node(table, acpi_cpu_id);
>>          if (cpu_node) {
>> -               cpu_node = acpi_find_processor_package_id(table, cpu_node,
>> -                                                         level, flag);
>> +               cpu_node = acpi_find_processor_tag_id(table, cpu_node,
>> +                                                         level, chk);
>>                  /*
>>                   * As per specification if the processor structure represents
>>                   * an actual processor, then ACPI processor ID must be valid.
>> @@ -498,7 +532,7 @@ static int topology_get_acpi_cpu_tag(struct acpi_table_header *table,
>>          return -ENOENT;
>>   }
>>
>> -static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, int flag)
>> +static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, node_check chk)
>>   {
>>          struct acpi_table_header *table;
>>          acpi_status status;
>> @@ -509,7 +543,7 @@ static int find_acpi_cpu_topology_tag(unsigned int cpu, int level, int flag)
>>                  acpi_pptt_warn_missing();
>>                  return -ENOENT;
>>          }
>> -       retval = topology_get_acpi_cpu_tag(table, cpu, level, flag);
>> +       retval = topology_get_acpi_cpu_tag(table, cpu, level, chk);
>>          pr_debug("Topology Setup ACPI CPU %d, level %d ret = %d\n",
>>                   cpu, level, retval);
>>          acpi_put_table(table);
>> @@ -601,7 +635,7 @@ int cache_setup_acpi(unsigned int cpu)
>>    */
>>   int find_acpi_cpu_topology(unsigned int cpu, int level)
>>   {
>> -       return find_acpi_cpu_topology_tag(cpu, level, 0);
>> +       return find_acpi_cpu_topology_tag(cpu, level, flag_none);
>>   }
>>
>>   /**
>> @@ -658,7 +692,7 @@ int find_acpi_cpu_cache_topology(unsigned int cpu, int level)
>>   int find_acpi_cpu_topology_package(unsigned int cpu)
>>   {
>>          return find_acpi_cpu_topology_tag(cpu, PPTT_ABORT_PACKAGE,
>> -                                         ACPI_PPTT_PHYSICAL_PACKAGE);
>> +                                         flag_package);
>>   }
>>
>>   /**
>> @@ -670,8 +704,8 @@ int find_acpi_cpu_topology_package(unsigned int cpu)
>>    *
>>    * The returned tag can be used to group peers with identical implementation.
>>    *
>> - * The search terminates when a level is found with the identical implementation
>> - * flag set or we reach a root node.
>> + * The search terminates when a level is found without the identical
>> + * implementation flag set following a node with it set, or we reach the root.
>>    *
>>    * Due to limitations in the PPTT data structure, there may be rare situations
>>    * where two cores in a heterogeneous machine may be identical, but won't have
>> @@ -684,5 +718,5 @@ int find_acpi_cpu_topology_package(unsigned int cpu)
>>   int find_acpi_cpu_topology_hetero_id(unsigned int cpu)
>>   {
>>          return find_acpi_cpu_topology_tag(cpu, PPTT_ABORT_PACKAGE,
>> -                                         ACPI_PPTT_ACPI_IDENTICAL);
>> +                                         flag_identical);
>>   }
>> --
> 
> I'm not a super big fan of passing function pointers in general.

Me either really, but it was fairly concise here. We could just switch 
on the flag and opencode the IDENTICAL special case in 
acpi_find_processor_tag_id(). I wouldn't expect there to be too many 
special case flags like this so that may be a better solution.

OTOH, I'm not even sure this patch is the right thing to do, it depends 
on how you read the intention of the spec. That is why I haven't merged 
it with 2/5 and AFAIK, the one machine that was setting the IDENTICAL 
flags everywhere had another problem which is forcing them to update the 
table, and they appear to have also corrected the table to only set it 
on the final identical node.

So, maybe I should drop this piece of the set and wait for someone to 
complain or the spec to be clarified?

> 
> I kind of see how this works for you, but why exactly the flag
> (ACPI_PPTT_ACPI_IDENTICAL in this case) is not sufficient to
> distinguish between the cases?
> 

I guess I'm not clear what your asking here, maybe just a clarification 
of why this patch is needed vs just 2/5? Under that assumption:

The spec reads "A value of 1 indicates that all children processors 
share an identical implementation revision". So AFAIK the intention was 
that it behaves like the Physical package flag, which has an additional 
clarification which reads "Each valid processor must belong to exactly 
one package". Minus that blurb, it seems a valid interpretation is that 
a homogeneous machine can have the IDENTICAL flag set on every non-leaf 
node. Since we are traversing the tree from the leaf to the root 
(because that is the way the tree is structured) we need to find the 
last node along the traversal with the IDENTICAL set in order to return 
the common node closest to the root. With just 2/5 we end up returning 
the node closest the leaf, which means processors which share a 
IDENTICAL node won't necessarily have duplicate tags (which is what we 
need).

If we can assume that there is only a single IDENTICAL flag along the 
path between any given leaf and the root, this patch would not be necessary.

Re: [PATCH v2 1/5] ACPI/PPTT: Trivial, Modify the case of CPU

[Rafael J. Wysocki]

On Wednesday, May 1, 2019 5:46:49 PM CEST Jeremy Linton wrote:
> Hi,
> 
> And sorry about the delay...
> 
> On 4/29/19 3:50 AM, Rafael J. Wysocki wrote:
> > On Sat, Apr 27, 2019 at 12:03 AM Jeremy Linton <jeremy.linton@arm.com> wrote:
> >>
> >> CPU is an acronym and customarily capitalized. Much of the
> >> commenting in the PPTT code has been using "cpu" rather
> >> than "CPU". Correct that, and other human readable strings.
> >>
> >> Signed-off-by: Jeremy Linton <jeremy.linton@arm.com>
> > 
> > It would be better to say "Modify the spelling of CPU" in the subject
> > IMO, but apart from that
> 
> Hmmm, spelling doesn't seem quite right either, how about "capitalization"?

That would work for me too.

Re: [PATCH v2 1/5] ACPI/PPTT: Trivial, Modify the case of CPU

[Rafael J. Wysocki]

On Wednesday, May 1, 2019 5:46:49 PM CEST Jeremy Linton wrote:
> Hi,
> 
> And sorry about the delay...
> 
> On 4/29/19 3:50 AM, Rafael J. Wysocki wrote:
> > On Sat, Apr 27, 2019 at 12:03 AM Jeremy Linton <jeremy.linton@arm.com> wrote:
> >>
> >> CPU is an acronym and customarily capitalized. Much of the
> >> commenting in the PPTT code has been using "cpu" rather
> >> than "CPU". Correct that, and other human readable strings.
> >>
> >> Signed-off-by: Jeremy Linton <jeremy.linton@arm.com>
> > 
> > It would be better to say "Modify the spelling of CPU" in the subject
> > IMO, but apart from that
> 
> Hmmm, spelling doesn't seem quite right either, how about "capitalization"?

That would work for me too.