1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * acpi.c - Architecture-Specific Low-Level ACPI Boot Support 4 * 5 * Author: Jianmin Lv <lvjianmin@loongson.cn> 6 * Huacai Chen <chenhuacai@loongson.cn> 7 * Copyright (C) 2020-2022 Loongson Technology Corporation Limited 8 */ 9 10 #include <linux/init.h> 11 #include <linux/acpi.h> 12 #include <linux/efi-bgrt.h> 13 #include <linux/export.h> 14 #include <linux/irq.h> 15 #include <linux/irqdomain.h> 16 #include <linux/kvm_host.h> 17 #include <linux/memblock.h> 18 #include <linux/of_fdt.h> 19 #include <linux/serial_core.h> 20 #include <linux/vmalloc.h> 21 #include <asm/io.h> 22 #include <asm/numa.h> 23 #include <asm/loongson.h> 24 25 int acpi_disabled; 26 EXPORT_SYMBOL(acpi_disabled); 27 int acpi_noirq; 28 int acpi_pci_disabled; 29 EXPORT_SYMBOL(acpi_pci_disabled); 30 int acpi_strict = 1; /* We have no workarounds on LoongArch */ 31 int num_processors; 32 int disabled_cpus; 33 34 u64 acpi_saved_sp; 35 36 #define PREFIX "ACPI: " 37 38 struct acpi_madt_core_pic acpi_core_pic[MAX_CORE_PIC]; 39 40 void __init __iomem * __acpi_map_table(unsigned long phys, unsigned long size) 41 { 42 43 if (!phys || !size) 44 return NULL; 45 46 return early_memremap(phys, size); 47 } 48 void __init __acpi_unmap_table(void __iomem *map, unsigned long size) 49 { 50 if (!map || !size) 51 return; 52 53 early_memunmap(map, size); 54 } 55 56 void __iomem *acpi_os_ioremap(acpi_physical_address phys, acpi_size size) 57 { 58 if (!memblock_is_memory(phys)) 59 return ioremap(phys, size); 60 else 61 return ioremap_cache(phys, size); 62 } 63 64 #define PIO_BASE (unsigned long)PCI_IOBASE 65 #define PIO_SIZE ALIGN(ISA_IOSIZE, PAGE_SIZE) 66 67 static bool acpi_pio; 68 69 /* Add PIO for early access */ 70 void acpi_add_early_pio(void) 71 { 72 if (!acpi_disabled) { 73 acpi_pio = true; 74 vmap_page_range(PIO_BASE, PIO_BASE + PIO_SIZE, 75 LOONGSON_LIO_BASE, pgprot_device(PAGE_KERNEL)); 76 } 77 } 78 79 /* Remove PIO for PCI register */ 80 void acpi_remove_early_pio(void) 81 { 82 if (!acpi_pio) 83 return; 84 85 if (!acpi_disabled) { 86 acpi_pio = false; 87 vunmap_range(PIO_BASE, PIO_BASE + PIO_SIZE); 88 } 89 } 90 91 #ifdef CONFIG_SMP 92 static int set_processor_mask(u32 id, u32 pass) 93 { 94 int cpu = -1, cpuid = id; 95 96 if (num_processors >= NR_CPUS) { 97 pr_warn(PREFIX "nr_cpus limit of %i reached." 98 " processor 0x%x ignored.\n", NR_CPUS, cpuid); 99 100 return -ENODEV; 101 102 } 103 104 if (cpuid == loongson_sysconf.boot_cpu_id) 105 cpu = 0; 106 107 switch (pass) { 108 case 1: /* Pass 1 handle enabled processors */ 109 if (cpu < 0) 110 cpu = find_first_zero_bit(cpumask_bits(cpu_present_mask), NR_CPUS); 111 num_processors++; 112 set_cpu_present(cpu, true); 113 break; 114 case 2: /* Pass 2 handle disabled processors */ 115 if (cpu < 0) 116 cpu = find_first_zero_bit(cpumask_bits(cpu_possible_mask), NR_CPUS); 117 disabled_cpus++; 118 break; 119 default: 120 return cpu; 121 } 122 123 set_cpu_possible(cpu, true); 124 __cpu_number_map[cpuid] = cpu; 125 __cpu_logical_map[cpu] = cpuid; 126 127 return cpu; 128 } 129 #endif 130 131 static int __init 132 acpi_parse_p1_processor(union acpi_subtable_headers *header, const unsigned long end) 133 { 134 struct acpi_madt_core_pic *processor = NULL; 135 136 processor = (struct acpi_madt_core_pic *)header; 137 if (BAD_MADT_ENTRY(processor, end)) 138 return -EINVAL; 139 140 acpi_table_print_madt_entry(&header->common); 141 #ifdef CONFIG_SMP 142 acpi_core_pic[processor->core_id] = *processor; 143 if (processor->flags & ACPI_MADT_ENABLED) 144 set_processor_mask(processor->core_id, 1); 145 #endif 146 147 return 0; 148 } 149 150 static int __init 151 acpi_parse_p2_processor(union acpi_subtable_headers *header, const unsigned long end) 152 { 153 struct acpi_madt_core_pic *processor = NULL; 154 155 processor = (struct acpi_madt_core_pic *)header; 156 if (BAD_MADT_ENTRY(processor, end)) 157 return -EINVAL; 158 159 #ifdef CONFIG_SMP 160 if (!(processor->flags & ACPI_MADT_ENABLED)) 161 set_processor_mask(processor->core_id, 2); 162 #endif 163 164 return 0; 165 } 166 static int __init 167 acpi_parse_eio_master(union acpi_subtable_headers *header, const unsigned long end) 168 { 169 static int core = 0; 170 struct acpi_madt_eio_pic *eiointc = NULL; 171 172 eiointc = (struct acpi_madt_eio_pic *)header; 173 if (BAD_MADT_ENTRY(eiointc, end)) 174 return -EINVAL; 175 176 core = eiointc->node * CORES_PER_EIO_NODE; 177 set_bit(core, loongson_sysconf.cores_io_master); 178 179 return 0; 180 } 181 182 static void __init acpi_process_madt(void) 183 { 184 #ifdef CONFIG_SMP 185 int i; 186 187 for (i = 0; i < NR_CPUS; i++) { 188 __cpu_number_map[i] = -1; 189 __cpu_logical_map[i] = -1; 190 } 191 #endif 192 acpi_table_parse_madt(ACPI_MADT_TYPE_CORE_PIC, 193 acpi_parse_p1_processor, MAX_CORE_PIC); 194 195 acpi_table_parse_madt(ACPI_MADT_TYPE_CORE_PIC, 196 acpi_parse_p2_processor, MAX_CORE_PIC); 197 198 acpi_table_parse_madt(ACPI_MADT_TYPE_EIO_PIC, 199 acpi_parse_eio_master, MAX_IO_PICS); 200 201 loongson_sysconf.nr_cpus = num_processors; 202 } 203 204 int pptt_enabled; 205 static int acpi_nr_packages; 206 static int acpi_package_ids[MAX(MAX_PACKAGES, KVM_MAX_VCPUS)]; 207 208 int __init parse_acpi_topology(void) 209 { 210 int i, cpu, topology_id; 211 212 for_each_possible_cpu(cpu) { 213 topology_id = find_acpi_cpu_topology(cpu, 0); 214 if (topology_id < 0) { 215 pr_warn("Invalid BIOS PPTT\n"); 216 return -ENOENT; 217 } 218 219 if (acpi_pptt_cpu_is_thread(cpu) <= 0) 220 cpu_data[cpu].core = topology_id; 221 else { 222 topology_id = find_acpi_cpu_topology(cpu, 1); 223 if (topology_id < 0) 224 return -ENOENT; 225 226 cpu_data[cpu].core = topology_id; 227 } 228 229 topology_id = find_acpi_cpu_topology_package(cpu); 230 if (topology_id < 0) { 231 pr_warn("Invalid BIOS PPTT\n"); 232 return -ENOENT; 233 } 234 235 for (i = 0; i < acpi_nr_packages; i++) 236 if (acpi_package_ids[i] == topology_id) 237 break; 238 239 if (i == acpi_nr_packages) 240 acpi_package_ids[acpi_nr_packages++] = topology_id; 241 242 cpu_data[cpu].package = topology_id; 243 } 244 245 for_each_possible_cpu(cpu) { 246 for (i = 0; i < acpi_nr_packages; i++) 247 if (cpu_data[cpu].package == acpi_package_ids[i]) { 248 cpu_data[cpu].package = i; /* Canonicalize */ 249 break; 250 } 251 } 252 253 pptt_enabled = 1; 254 255 return 0; 256 } 257 258 #ifndef CONFIG_SUSPEND 259 int (*acpi_suspend_lowlevel)(void); 260 #else 261 int (*acpi_suspend_lowlevel)(void) = loongarch_acpi_suspend; 262 #endif 263 264 void __init acpi_boot_table_init(void) 265 { 266 /* 267 * If acpi_disabled, bail out 268 */ 269 if (acpi_disabled) 270 goto fdt_earlycon; 271 272 /* 273 * Initialize the ACPI boot-time table parser. 274 */ 275 if (acpi_table_init()) { 276 disable_acpi(); 277 goto fdt_earlycon; 278 } 279 280 loongson_sysconf.boot_cpu_id = read_csr_cpuid(); 281 282 /* 283 * Process the Multiple APIC Description Table (MADT), if present 284 */ 285 acpi_process_madt(); 286 287 /* Do not enable ACPI SPCR console by default */ 288 acpi_parse_spcr(earlycon_acpi_spcr_enable, false); 289 290 if (IS_ENABLED(CONFIG_ACPI_BGRT)) 291 acpi_table_parse(ACPI_SIG_BGRT, acpi_parse_bgrt); 292 293 return; 294 295 fdt_earlycon: 296 if (earlycon_acpi_spcr_enable) 297 early_init_dt_scan_chosen_stdout(); 298 } 299 300 #ifdef CONFIG_ACPI_NUMA 301 302 /* Callback for Proximity Domain -> CPUID mapping */ 303 void __init 304 acpi_numa_processor_affinity_init(struct acpi_srat_cpu_affinity *pa) 305 { 306 int pxm, node; 307 308 if (srat_disabled()) 309 return; 310 if (pa->header.length != sizeof(struct acpi_srat_cpu_affinity)) { 311 bad_srat(); 312 return; 313 } 314 if ((pa->flags & ACPI_SRAT_CPU_ENABLED) == 0) 315 return; 316 pxm = pa->proximity_domain_lo; 317 if (acpi_srat_revision >= 2) { 318 pxm |= (pa->proximity_domain_hi[0] << 8); 319 pxm |= (pa->proximity_domain_hi[1] << 16); 320 pxm |= (pa->proximity_domain_hi[2] << 24); 321 } 322 node = acpi_map_pxm_to_node(pxm); 323 if (node < 0) { 324 pr_err("SRAT: Too many proximity domains %x\n", pxm); 325 bad_srat(); 326 return; 327 } 328 329 if (pa->apic_id >= CONFIG_NR_CPUS) { 330 pr_info("SRAT: PXM %u -> CPU 0x%02x -> Node %u skipped apicid that is too big\n", 331 pxm, pa->apic_id, node); 332 return; 333 } 334 335 early_numa_add_cpu(pa->apic_id, node); 336 337 set_cpuid_to_node(pa->apic_id, node); 338 node_set(node, numa_nodes_parsed); 339 pr_info("SRAT: PXM %u -> CPU 0x%02x -> Node %u\n", pxm, pa->apic_id, node); 340 } 341 342 void __init 343 acpi_numa_x2apic_affinity_init(struct acpi_srat_x2apic_cpu_affinity *pa) 344 { 345 int pxm, node; 346 347 if (srat_disabled()) 348 return; 349 if (pa->header.length < sizeof(struct acpi_srat_x2apic_cpu_affinity)) { 350 bad_srat(); 351 return; 352 } 353 if ((pa->flags & ACPI_SRAT_CPU_ENABLED) == 0) 354 return; 355 pxm = pa->proximity_domain; 356 node = acpi_map_pxm_to_node(pxm); 357 if (node < 0) { 358 pr_err("SRAT: Too many proximity domains %x\n", pxm); 359 bad_srat(); 360 return; 361 } 362 363 if (pa->apic_id >= CONFIG_NR_CPUS) { 364 pr_info("SRAT: PXM %u -> CPU 0x%02x -> Node %u skipped apicid that is too big\n", 365 pxm, pa->apic_id, node); 366 return; 367 } 368 369 early_numa_add_cpu(pa->apic_id, node); 370 371 set_cpuid_to_node(pa->apic_id, node); 372 node_set(node, numa_nodes_parsed); 373 pr_info("SRAT: PXM %u -> CPU 0x%02x -> Node %u\n", pxm, pa->apic_id, node); 374 } 375 376 #endif 377 378 void __init arch_reserve_mem_area(acpi_physical_address addr, size_t size) 379 { 380 memblock_reserve(addr, size); 381 } 382 383 #ifdef CONFIG_ACPI_HOTPLUG_CPU 384 385 #include <acpi/processor.h> 386 387 static int __ref acpi_map_cpu2node(acpi_handle handle, int cpu, int physid) 388 { 389 #ifdef CONFIG_ACPI_NUMA 390 int nid; 391 392 nid = acpi_get_node(handle); 393 394 if (nid != NUMA_NO_NODE) 395 nid = early_cpu_to_node(cpu); 396 397 if (nid != NUMA_NO_NODE) { 398 set_cpuid_to_node(physid, nid); 399 node_set(nid, numa_nodes_parsed); 400 set_cpu_numa_node(cpu, nid); 401 cpumask_set_cpu(cpu, cpumask_of_node(nid)); 402 } 403 #endif 404 return 0; 405 } 406 407 int acpi_map_cpu(acpi_handle handle, phys_cpuid_t physid, u32 acpi_id, int *pcpu) 408 { 409 int cpu; 410 411 cpu = cpu_number_map(physid); 412 if (cpu < 0 || cpu >= nr_cpu_ids) { 413 pr_info(PREFIX "Unable to map lapic to logical cpu number\n"); 414 return -ERANGE; 415 } 416 417 num_processors++; 418 set_cpu_present(cpu, true); 419 acpi_map_cpu2node(handle, cpu, physid); 420 421 *pcpu = cpu; 422 423 return 0; 424 } 425 EXPORT_SYMBOL(acpi_map_cpu); 426 427 int acpi_unmap_cpu(int cpu) 428 { 429 #ifdef CONFIG_ACPI_NUMA 430 set_cpuid_to_node(cpu_logical_map(cpu), NUMA_NO_NODE); 431 #endif 432 set_cpu_present(cpu, false); 433 num_processors--; 434 435 pr_info("cpu%d hot remove!\n", cpu); 436 437 return 0; 438 } 439 EXPORT_SYMBOL(acpi_unmap_cpu); 440 441 #endif /* CONFIG_ACPI_HOTPLUG_CPU */ 442 443 int acpi_get_cpu_uid(unsigned int cpu, u32 *uid) 444 { 445 if (cpu >= nr_cpu_ids) 446 return -EINVAL; 447 *uid = acpi_core_pic[cpu_logical_map(cpu)].processor_id; 448 return 0; 449 } 450 EXPORT_SYMBOL_GPL(acpi_get_cpu_uid); 451