drivers/acpi/processor_core.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2005 Intel Corporation
   4  * Copyright (C) 2009 Hewlett-Packard Development Company, L.P.
   5  *
   6  *      Alex Chiang <[email protected]>
   7  *      - Unified x86/ia64 implementations
   8  *
   9  * I/O APIC hotplug support
  10  *      Yinghai Lu <[email protected]>
  11  *      Jiang Liu <[email protected]>
  12  */
  13 #include <linux/export.h>
  14 #include <linux/acpi.h>
  15 #include <acpi/processor.h>
  16
  17 static struct acpi_table_madt *get_madt_table(void)
  18 {
  19         static struct acpi_table_madt *madt;
  20         static int read_madt;
  21
  22         if (!read_madt) {
  23                 if (ACPI_FAILURE(acpi_get_table(ACPI_SIG_MADT, 0,
  24                                         (struct acpi_table_header **)&madt)))
  25                         madt = NULL;
  26                 read_madt++;
  27         }
  28
  29         return madt;
  30 }
  31
  32 static int map_lapic_id(struct acpi_subtable_header *entry,
  33                  u32 acpi_id, phys_cpuid_t *apic_id)
  34 {
  35         struct acpi_madt_local_apic *lapic =
  36                 container_of(entry, struct acpi_madt_local_apic, header);
  37
  38         if (!(lapic->lapic_flags & ACPI_MADT_ENABLED))
  39                 return -ENODEV;
  40
  41         if (lapic->processor_id != acpi_id)
  42                 return -EINVAL;
  43
  44         *apic_id = lapic->id;
  45         return 0;
  46 }
  47
  48 static int map_x2apic_id(struct acpi_subtable_header *entry,
  49                 int device_declaration, u32 acpi_id, phys_cpuid_t *apic_id)
  50 {
  51         struct acpi_madt_local_x2apic *apic =
  52                 container_of(entry, struct acpi_madt_local_x2apic, header);
  53
  54         if (!(apic->lapic_flags & ACPI_MADT_ENABLED))
  55                 return -ENODEV;
  56
  57         if (device_declaration && (apic->uid == acpi_id)) {
  58                 *apic_id = apic->local_apic_id;
  59                 return 0;
  60         }
  61
  62         return -EINVAL;
  63 }
  64
  65 static int map_lsapic_id(struct acpi_subtable_header *entry,
  66                 int device_declaration, u32 acpi_id, phys_cpuid_t *apic_id)
  67 {
  68         struct acpi_madt_local_sapic *lsapic =
  69                 container_of(entry, struct acpi_madt_local_sapic, header);
  70
  71         if (!(lsapic->lapic_flags & ACPI_MADT_ENABLED))
  72                 return -ENODEV;
  73
  74         if (device_declaration) {
  75                 if ((entry->length < 16) || (lsapic->uid != acpi_id))
  76                         return -EINVAL;
  77         } else if (lsapic->processor_id != acpi_id)
  78                 return -EINVAL;
  79
  80         *apic_id = (lsapic->id << 8) | lsapic->eid;
  81         return 0;
  82 }
  83
  84 /*
  85  * Retrieve the ARM CPU physical identifier (MPIDR)
  86  */
  87 static int map_gicc_mpidr(struct acpi_subtable_header *entry,
  88                 int device_declaration, u32 acpi_id, phys_cpuid_t *mpidr)
  89 {
  90         struct acpi_madt_generic_interrupt *gicc =
  91             container_of(entry, struct acpi_madt_generic_interrupt, header);
  92
  93         if (!(gicc->flags & ACPI_MADT_ENABLED))
  94                 return -ENODEV;
  95
  96         /* device_declaration means Device object in DSDT, in the
  97          * GIC interrupt model, logical processors are required to
  98          * have a Processor Device object in the DSDT, so we should
  99          * check device_declaration here
 100          */
 101         if (device_declaration && (gicc->uid == acpi_id)) {
 102                 *mpidr = gicc->arm_mpidr;
 103                 return 0;
 104         }
 105
 106         return -EINVAL;
 107 }
 108
 109 /*
 110  * Retrieve the RISC-V hartid for the processor
 111  */
 112 static int map_rintc_hartid(struct acpi_subtable_header *entry,
 113                             int device_declaration, u32 acpi_id,
 114                             phys_cpuid_t *hartid)
 115 {
 116         struct acpi_madt_rintc *rintc =
 117             container_of(entry, struct acpi_madt_rintc, header);
 118
 119         if (!(rintc->flags & ACPI_MADT_ENABLED))
 120                 return -ENODEV;
 121
 122         /* device_declaration means Device object in DSDT, in the
 123          * RISC-V, logical processors are required to
 124          * have a Processor Device object in the DSDT, so we should
 125          * check device_declaration here
 126          */
 127         if (device_declaration && rintc->uid == acpi_id) {
 128                 *hartid = rintc->hart_id;
 129                 return 0;
 130         }
 131
 132         return -EINVAL;
 133 }
 134
 135 static phys_cpuid_t map_madt_entry(struct acpi_table_madt *madt,
 136                                    int type, u32 acpi_id)
 137 {
 138         unsigned long madt_end, entry;
 139         phys_cpuid_t phys_id = PHYS_CPUID_INVALID;      /* CPU hardware ID */
 140
 141         if (!madt)
 142                 return phys_id;
 143
 144         entry = (unsigned long)madt;
 145         madt_end = entry + madt->header.length;
 146
 147         /* Parse all entries looking for a match. */
 148
 149         entry += sizeof(struct acpi_table_madt);
 150         while (entry + sizeof(struct acpi_subtable_header) < madt_end) {
 151                 struct acpi_subtable_header *header =
 152                         (struct acpi_subtable_header *)entry;
 153                 if (header->type == ACPI_MADT_TYPE_LOCAL_APIC) {
 154                         if (!map_lapic_id(header, acpi_id, &phys_id))
 155                                 break;
 156                 } else if (header->type == ACPI_MADT_TYPE_LOCAL_X2APIC) {
 157                         if (!map_x2apic_id(header, type, acpi_id, &phys_id))
 158                                 break;
 159                 } else if (header->type == ACPI_MADT_TYPE_LOCAL_SAPIC) {
 160                         if (!map_lsapic_id(header, type, acpi_id, &phys_id))
 161                                 break;
 162                 } else if (header->type == ACPI_MADT_TYPE_GENERIC_INTERRUPT) {
 163                         if (!map_gicc_mpidr(header, type, acpi_id, &phys_id))
 164                                 break;
 165                 } else if (header->type == ACPI_MADT_TYPE_RINTC) {
 166                         if (!map_rintc_hartid(header, type, acpi_id, &phys_id))
 167                                 break;
 168                 }
 169                 entry += header->length;
 170         }
 171         return phys_id;
 172 }
 173
 174 phys_cpuid_t __init acpi_map_madt_entry(u32 acpi_id)
 175 {
 176         struct acpi_table_madt *madt = NULL;
 177         phys_cpuid_t rv;
 178
 179         acpi_get_table(ACPI_SIG_MADT, 0,
 180                        (struct acpi_table_header **)&madt);
 181         if (!madt)
 182                 return PHYS_CPUID_INVALID;
 183
 184         rv = map_madt_entry(madt, 1, acpi_id);
 185
 186         acpi_put_table((struct acpi_table_header *)madt);
 187
 188         return rv;
 189 }
 190
 191 static phys_cpuid_t map_mat_entry(acpi_handle handle, int type, u32 acpi_id)
 192 {
 193         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 194         union acpi_object *obj;
 195         struct acpi_subtable_header *header;
 196         phys_cpuid_t phys_id = PHYS_CPUID_INVALID;
 197
 198         if (ACPI_FAILURE(acpi_evaluate_object(handle, "_MAT", NULL, &buffer)))
 199                 goto exit;
 200
 201         if (!buffer.length || !buffer.pointer)
 202                 goto exit;
 203
 204         obj = buffer.pointer;
 205         if (obj->type != ACPI_TYPE_BUFFER ||
 206             obj->buffer.length < sizeof(struct acpi_subtable_header)) {
 207                 goto exit;
 208         }
 209
 210         header = (struct acpi_subtable_header *)obj->buffer.pointer;
 211         if (header->type == ACPI_MADT_TYPE_LOCAL_APIC)
 212                 map_lapic_id(header, acpi_id, &phys_id);
 213         else if (header->type == ACPI_MADT_TYPE_LOCAL_SAPIC)
 214                 map_lsapic_id(header, type, acpi_id, &phys_id);
 215         else if (header->type == ACPI_MADT_TYPE_LOCAL_X2APIC)
 216                 map_x2apic_id(header, type, acpi_id, &phys_id);
 217         else if (header->type == ACPI_MADT_TYPE_GENERIC_INTERRUPT)
 218                 map_gicc_mpidr(header, type, acpi_id, &phys_id);
 219
 220 exit:
 221         kfree(buffer.pointer);
 222         return phys_id;
 223 }
 224
 225 phys_cpuid_t acpi_get_phys_id(acpi_handle handle, int type, u32 acpi_id)
 226 {
 227         phys_cpuid_t phys_id;
 228
 229         phys_id = map_mat_entry(handle, type, acpi_id);
 230         if (invalid_phys_cpuid(phys_id))
 231                 phys_id = map_madt_entry(get_madt_table(), type, acpi_id);
 232
 233         return phys_id;
 234 }
 235 EXPORT_SYMBOL_GPL(acpi_get_phys_id);
 236
 237 int acpi_map_cpuid(phys_cpuid_t phys_id, u32 acpi_id)
 238 {
 239 #ifdef CONFIG_SMP
 240         int i;
 241 #endif
 242
 243         if (invalid_phys_cpuid(phys_id)) {
 244                 /*
 245                  * On UP processor, there is no _MAT or MADT table.
 246                  * So above phys_id is always set to PHYS_CPUID_INVALID.
 247                  *
 248                  * BIOS may define multiple CPU handles even for UP processor.
 249                  * For example,
 250                  *
 251                  * Scope (_PR)
 252                  * {
 253                  *     Processor (CPU0, 0x00, 0x00000410, 0x06) {}
 254                  *     Processor (CPU1, 0x01, 0x00000410, 0x06) {}
 255                  *     Processor (CPU2, 0x02, 0x00000410, 0x06) {}
 256                  *     Processor (CPU3, 0x03, 0x00000410, 0x06) {}
 257                  * }
 258                  *
 259                  * Ignores phys_id and always returns 0 for the processor
 260                  * handle with acpi id 0 if nr_cpu_ids is 1.
 261                  * This should be the case if SMP tables are not found.
 262                  * Return -EINVAL for other CPU's handle.
 263                  */
 264                 if (nr_cpu_ids <= 1 && acpi_id == 0)
 265                         return acpi_id;
 266                 else
 267                         return -EINVAL;
 268         }
 269
 270 #ifdef CONFIG_SMP
 271         for_each_possible_cpu(i) {
 272                 if (cpu_physical_id(i) == phys_id)
 273                         return i;
 274         }
 275 #else
 276         /* In UP kernel, only processor 0 is valid */
 277         if (phys_id == 0)
 278                 return phys_id;
 279 #endif
 280         return -ENODEV;
 281 }
 282
 283 int acpi_get_cpuid(acpi_handle handle, int type, u32 acpi_id)
 284 {
 285         phys_cpuid_t phys_id;
 286
 287         phys_id = acpi_get_phys_id(handle, type, acpi_id);
 288
 289         return acpi_map_cpuid(phys_id, acpi_id);
 290 }
 291 EXPORT_SYMBOL_GPL(acpi_get_cpuid);
 292
 293 #ifdef CONFIG_ACPI_HOTPLUG_IOAPIC
 294 static int get_ioapic_id(struct acpi_subtable_header *entry, u32 gsi_base,
 295                          u64 *phys_addr, int *ioapic_id)
 296 {
 297         struct acpi_madt_io_apic *ioapic = (struct acpi_madt_io_apic *)entry;
 298
 299         if (ioapic->global_irq_base != gsi_base)
 300                 return 0;
 301
 302         *phys_addr = ioapic->address;
 303         *ioapic_id = ioapic->id;
 304         return 1;
 305 }
 306
 307 static int parse_madt_ioapic_entry(u32 gsi_base, u64 *phys_addr)
 308 {
 309         struct acpi_subtable_header *hdr;
 310         unsigned long madt_end, entry;
 311         struct acpi_table_madt *madt;
 312         int apic_id = -1;
 313
 314         madt = get_madt_table();
 315         if (!madt)
 316                 return apic_id;
 317
 318         entry = (unsigned long)madt;
 319         madt_end = entry + madt->header.length;
 320
 321         /* Parse all entries looking for a match. */
 322         entry += sizeof(struct acpi_table_madt);
 323         while (entry + sizeof(struct acpi_subtable_header) < madt_end) {
 324                 hdr = (struct acpi_subtable_header *)entry;
 325                 if (hdr->type == ACPI_MADT_TYPE_IO_APIC &&
 326                     get_ioapic_id(hdr, gsi_base, phys_addr, &apic_id))
 327                         break;
 328                 else
 329                         entry += hdr->length;
 330         }
 331
 332         return apic_id;
 333 }
 334
 335 static int parse_mat_ioapic_entry(acpi_handle handle, u32 gsi_base,
 336                                   u64 *phys_addr)
 337 {
 338         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 339         struct acpi_subtable_header *header;
 340         union acpi_object *obj;
 341         int apic_id = -1;
 342
 343         if (ACPI_FAILURE(acpi_evaluate_object(handle, "_MAT", NULL, &buffer)))
 344                 goto exit;
 345
 346         if (!buffer.length || !buffer.pointer)
 347                 goto exit;
 348
 349         obj = buffer.pointer;
 350         if (obj->type != ACPI_TYPE_BUFFER ||
 351             obj->buffer.length < sizeof(struct acpi_subtable_header))
 352                 goto exit;
 353
 354         header = (struct acpi_subtable_header *)obj->buffer.pointer;
 355         if (header->type == ACPI_MADT_TYPE_IO_APIC)
 356                 get_ioapic_id(header, gsi_base, phys_addr, &apic_id);
 357
 358 exit:
 359         kfree(buffer.pointer);
 360         return apic_id;
 361 }
 362
 363 /**
 364  * acpi_get_ioapic_id - Get IOAPIC ID and physical address matching @gsi_base
 365  * @handle:     ACPI object for IOAPIC device
 366  * @gsi_base:   GSI base to match with
 367  * @phys_addr:  Pointer to store physical address of matching IOAPIC record
 368  *
 369  * Walk resources returned by ACPI_MAT method, then ACPI MADT table, to search
 370  * for an ACPI IOAPIC record matching @gsi_base.
 371  * Return IOAPIC id and store physical address in @phys_addr if found a match,
 372  * otherwise return <0.
 373  */
 374 int acpi_get_ioapic_id(acpi_handle handle, u32 gsi_base, u64 *phys_addr)
 375 {
 376         int apic_id;
 377
 378         apic_id = parse_mat_ioapic_entry(handle, gsi_base, phys_addr);
 379         if (apic_id == -1)
 380                 apic_id = parse_madt_ioapic_entry(gsi_base, phys_addr);
 381
 382         return apic_id;
 383 }
 384 #endif /* CONFIG_ACPI_HOTPLUG_IOAPIC */