1 files changed, 55 insertions, 6 deletions

diff --git a/drivers/acpi/pptt.c b/drivers/acpi/pptt.c
index b72e6afaa8fb..1e7ac0bd0d3a 100644
--- a/drivers/acpi/pptt.c
+++ b/drivers/acpi/pptt.c
@@ -432,17 +432,40 @@ static void cache_setup_acpi_cpu(struct acpi_table_header *table,
         }
 }
 
+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;
+}
+
 /* 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(struct acpi_table_header *table_hdr,
+                                                           struct acpi_pptt_processor *cpu,
+                                                           int level, int flag)
 {
         struct acpi_pptt_processor *prev_node;
 
         while (cpu && level) {
-                if (cpu->flags & flag)
+                /* special case the identical flag to find last identical */
+                if (flag == ACPI_PPTT_ACPI_IDENTICAL) {
+                        if (flag_identical(table_hdr, cpu))
+                                break;
+                } else if (cpu->flags & flag)
                         break;
                 pr_debug("level %d\n", level);
                 prev_node = fetch_pptt_node(table_hdr, cpu->parent);
@@ -480,8 +503,8 @@ static int topology_get_acpi_cpu_tag(struct acpi_table_header *table,
 
         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(table, cpu_node,
+                                                   level, flag);
                 /*
                  * As per specification if the processor structure represents
                  * an actual processor, then ACPI processor ID must be valid.
@@ -660,3 +683,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);
+}