drivers/acpi/processor_core.c

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