| 1 | |
| 2 | |
| 3 | * RISC-V Specific Low-Level ACPI Boot Support
|
| 4 | *
|
| 5 | * Copyright (C) 2013-2014, Linaro Ltd.
|
| 6 | * Author: Al Stone <[email protected]>
|
| 7 | * Author: Graeme Gregory <[email protected]>
|
| 8 | * Author: Hanjun Guo <[email protected]>
|
| 9 | * Author: Tomasz Nowicki <[email protected]>
|
| 10 | * Author: Naresh Bhat <[email protected]>
|
| 11 | *
|
| 12 | * Copyright (C) 2021-2023, Ventana Micro Systems Inc.
|
| 13 | * Author: Sunil V L <[email protected]>
|
| 14 |
|
| 15 |
|
| 16 | #include <linux/acpi.h>
|
| 17 | #include <linux/efi-bgrt.h>
|
| 18 | #include <linux/efi.h>
|
| 19 | #include <linux/io.h>
|
| 20 | #include <linux/memblock.h>
|
| 21 | #include <linux/of_fdt.h>
|
| 22 | #include <linux/pci.h>
|
| 23 | #include <linux/serial_core.h>
|
| 24 |
|
| 25 | int acpi_noirq = 1;
|
| 26 | int acpi_disabled = 1;
|
| 27 | EXPORT_SYMBOL(acpi_disabled);
|
| 28 |
|
| 29 | int acpi_pci_disabled = 1;
|
| 30 | EXPORT_SYMBOL(acpi_pci_disabled);
|
| 31 |
|
| 32 | static bool param_acpi_off __initdata;
|
| 33 | static bool param_acpi_on __initdata;
|
| 34 | static bool param_acpi_force __initdata;
|
| 35 |
|
| 36 | static struct acpi_madt_rintc cpu_madt_rintc[NR_CPUS];
|
| 37 |
|
| 38 | static int __init parse_acpi(char *arg)
|
| 39 | {
|
| 40 | if (!arg)
|
| 41 | return -EINVAL;
|
| 42 |
|
| 43 |
|
| 44 | if (strcmp(arg, "off") == 0)
|
| 45 | param_acpi_off = true;
|
| 46 | else if (strcmp(arg, "on") == 0)
|
| 47 | param_acpi_on = true;
|
| 48 | else if (strcmp(arg, "force") == 0)
|
| 49 | param_acpi_force = true;
|
| 50 | else
|
| 51 | return -EINVAL;
|
| 52 |
|
| 53 | return 0;
|
| 54 | }
|
| 55 | early_param("acpi", parse_acpi);
|
| 56 |
|
| 57 | |
| 58 | * acpi_fadt_sanity_check() - Check FADT presence and carry out sanity
|
| 59 | * checks on it
|
| 60 | *
|
| 61 | * Return 0 on success, <0 on failure
|
| 62 |
|
| 63 | static int __init acpi_fadt_sanity_check(void)
|
| 64 | {
|
| 65 | struct acpi_table_header *table;
|
| 66 | struct acpi_table_fadt *fadt;
|
| 67 | acpi_status status;
|
| 68 | int ret = 0;
|
| 69 |
|
| 70 | |
| 71 | * FADT is required on riscv; retrieve it to check its presence
|
| 72 | * and carry out revision and ACPI HW reduced compliance tests
|
| 73 |
|
| 74 | status = acpi_get_table(ACPI_SIG_FADT, 0, &table);
|
| 75 | if (ACPI_FAILURE(status)) {
|
| 76 | const char *msg = acpi_format_exception(status);
|
| 77 |
|
| 78 | pr_err("Failed to get FADT table, %s\n", msg);
|
| 79 | return -ENODEV;
|
| 80 | }
|
| 81 |
|
| 82 | fadt = (struct acpi_table_fadt *)table;
|
| 83 |
|
| 84 | |
| 85 | * The revision in the table header is the FADT's Major revision. The
|
| 86 | * FADT also has a minor revision, which is stored in the FADT itself.
|
| 87 | *
|
| 88 | * ACPI 6.6 is required for RISC-V as it introduces RISC-V specific
|
| 89 | * tables such as RHCT (RISC-V Hart Capabilities Table) and RIMT
|
| 90 | * (RISC-V I/O Mapping Table).
|
| 91 |
|
| 92 | if (table->revision < 6 || (table->revision == 6 && fadt->minor_revision < 6))
|
| 93 | pr_err(FW_BUG "Unsupported FADT revision %d.%d, should be 6.6+\n",
|
| 94 | table->revision, fadt->minor_revision);
|
| 95 |
|
| 96 | if (!(fadt->flags & ACPI_FADT_HW_REDUCED)) {
|
| 97 | pr_err("FADT not ACPI hardware reduced compliant\n");
|
| 98 | ret = -EINVAL;
|
| 99 | }
|
| 100 |
|
| 101 | |
| 102 | * acpi_get_table() creates FADT table mapping that
|
| 103 | * should be released after parsing and before resuming boot
|
| 104 |
|
| 105 | acpi_put_table(table);
|
| 106 | return ret;
|
| 107 | }
|
| 108 |
|
| 109 | |
| 110 | * acpi_boot_table_init() called from setup_arch(), always.
|
| 111 | * 1. find RSDP and get its address, and then find XSDT
|
| 112 | * 2. extract all tables and checksums them all
|
| 113 | * 3. check ACPI FADT HW reduced flag
|
| 114 | *
|
| 115 | * We can parse ACPI boot-time tables such as MADT after
|
| 116 | * this function is called.
|
| 117 | *
|
| 118 | * On return ACPI is enabled if either:
|
| 119 | *
|
| 120 | * - ACPI tables are initialized and sanity checks passed
|
| 121 | * - acpi=force was passed in the command line and ACPI was not disabled
|
| 122 | * explicitly through acpi=off command line parameter
|
| 123 | *
|
| 124 | * ACPI is disabled on function return otherwise
|
| 125 |
|
| 126 | void __init acpi_boot_table_init(void)
|
| 127 | {
|
| 128 | |
| 129 | * Enable ACPI instead of device tree unless
|
| 130 | * - ACPI has been disabled explicitly (acpi=off), or
|
| 131 | * - firmware has not populated ACPI ptr in EFI system table
|
| 132 | * and ACPI has not been [force] enabled (acpi=on|force)
|
| 133 |
|
| 134 | if (param_acpi_off ||
|
| 135 | (!param_acpi_on && !param_acpi_force &&
|
| 136 | efi.acpi20 == EFI_INVALID_TABLE_ADDR))
|
| 137 | goto done;
|
| 138 |
|
| 139 | |
| 140 | * ACPI is disabled at this point. Enable it in order to parse
|
| 141 | * the ACPI tables and carry out sanity checks
|
| 142 |
|
| 143 | enable_acpi();
|
| 144 |
|
| 145 | |
| 146 | * If ACPI tables are initialized and FADT sanity checks passed,
|
| 147 | * leave ACPI enabled and carry on booting; otherwise disable ACPI
|
| 148 | * on initialization error.
|
| 149 | * If acpi=force was passed on the command line it forces ACPI
|
| 150 | * to be enabled even if its initialization failed.
|
| 151 |
|
| 152 | if (acpi_table_init() || acpi_fadt_sanity_check()) {
|
| 153 | pr_err("Failed to init ACPI tables\n");
|
| 154 | if (!param_acpi_force)
|
| 155 | disable_acpi();
|
| 156 | }
|
| 157 |
|
| 158 | done:
|
| 159 | if (acpi_disabled) {
|
| 160 | if (earlycon_acpi_spcr_enable)
|
| 161 | early_init_dt_scan_chosen_stdout();
|
| 162 | } else {
|
| 163 | acpi_parse_spcr(earlycon_acpi_spcr_enable, true);
|
| 164 | if (IS_ENABLED(CONFIG_ACPI_BGRT))
|
| 165 | acpi_table_parse(ACPI_SIG_BGRT, acpi_parse_bgrt);
|
| 166 | }
|
| 167 | }
|
| 168 |
|
| 169 | static int acpi_parse_madt_rintc(union acpi_subtable_headers *header, const unsigned long end)
|
| 170 | {
|
| 171 | struct acpi_madt_rintc *rintc = (struct acpi_madt_rintc *)header;
|
| 172 | int cpuid;
|
| 173 |
|
| 174 | if (!(rintc->flags & ACPI_MADT_ENABLED))
|
| 175 | return 0;
|
| 176 |
|
| 177 | cpuid = riscv_hartid_to_cpuid(rintc->hart_id);
|
| 178 | |
| 179 | * When CONFIG_SMP is disabled, mapping won't be created for
|
| 180 | * all cpus.
|
| 181 | * CPUs more than num_possible_cpus, will be ignored.
|
| 182 |
|
| 183 | if (cpuid >= 0 && cpuid < num_possible_cpus())
|
| 184 | cpu_madt_rintc[cpuid] = *rintc;
|
| 185 |
|
| 186 | return 0;
|
| 187 | }
|
| 188 |
|
| 189 | |
| 190 | * Instead of parsing (and freeing) the ACPI table, cache
|
| 191 | * the RINTC structures since they are frequently used
|
| 192 | * like in cpuinfo.
|
| 193 |
|
| 194 | void __init acpi_init_rintc_map(void)
|
| 195 | {
|
| 196 | if (acpi_table_parse_madt(ACPI_MADT_TYPE_RINTC, acpi_parse_madt_rintc, 0) <= 0) {
|
| 197 | pr_err("No valid RINTC entries exist\n");
|
| 198 | BUG();
|
| 199 | }
|
| 200 | }
|
| 201 |
|
| 202 | struct acpi_madt_rintc *acpi_cpu_get_madt_rintc(int cpu)
|
| 203 | {
|
| 204 | return &cpu_madt_rintc[cpu];
|
| 205 | }
|
| 206 |
|
| 207 | |
| 208 | * __acpi_map_table() will be called before paging_init(), so early_ioremap()
|
| 209 | * or early_memremap() should be called here to for ACPI table mapping.
|
| 210 |
|
| 211 | void __init __iomem *__acpi_map_table(unsigned long phys, unsigned long size)
|
| 212 | {
|
| 213 | if (!size)
|
| 214 | return NULL;
|
| 215 |
|
| 216 | return early_memremap(phys, size);
|
| 217 | }
|
| 218 |
|
| 219 | void __init __acpi_unmap_table(void __iomem *map, unsigned long size)
|
| 220 | {
|
| 221 | if (!map || !size)
|
| 222 | return;
|
| 223 |
|
| 224 | early_memunmap(map, size);
|
| 225 | }
|
| 226 |
|
| 227 | void __iomem *acpi_os_ioremap(acpi_physical_address phys, acpi_size size)
|
| 228 | {
|
| 229 | efi_memory_desc_t *md, *region = NULL;
|
| 230 | pgprot_t prot;
|
| 231 |
|
| 232 | if (WARN_ON_ONCE(!efi_enabled(EFI_MEMMAP)))
|
| 233 | return NULL;
|
| 234 |
|
| 235 | for_each_efi_memory_desc(md) {
|
| 236 | u64 end = md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT);
|
| 237 |
|
| 238 | if (phys < md->phys_addr || phys >= end)
|
| 239 | continue;
|
| 240 |
|
| 241 | if (phys + size > end) {
|
| 242 | pr_warn(FW_BUG "requested region covers multiple EFI memory regions\n");
|
| 243 | return NULL;
|
| 244 | }
|
| 245 | region = md;
|
| 246 | break;
|
| 247 | }
|
| 248 |
|
| 249 | |
| 250 | * It is fine for AML to remap regions that are not represented in the
|
| 251 | * EFI memory map at all, as it only describes normal memory, and MMIO
|
| 252 | * regions that require a virtual mapping to make them accessible to
|
| 253 | * the EFI runtime services.
|
| 254 |
|
| 255 | prot = PAGE_KERNEL_IO;
|
| 256 | if (region) {
|
| 257 | switch (region->type) {
|
| 258 | case EFI_LOADER_CODE:
|
| 259 | case EFI_LOADER_DATA:
|
| 260 | case EFI_BOOT_SERVICES_CODE:
|
| 261 | case EFI_BOOT_SERVICES_DATA:
|
| 262 | case EFI_CONVENTIONAL_MEMORY:
|
| 263 | case EFI_PERSISTENT_MEMORY:
|
| 264 | if (memblock_is_map_memory(phys) ||
|
| 265 | !memblock_is_region_memory(phys, size)) {
|
| 266 | pr_warn(FW_BUG "requested region covers kernel memory\n");
|
| 267 | return NULL;
|
| 268 | }
|
| 269 |
|
| 270 | |
| 271 | * Mapping kernel memory is permitted if the region in
|
| 272 | * question is covered by a single memblock with the
|
| 273 | * NOMAP attribute set: this enables the use of ACPI
|
| 274 | * table overrides passed via initramfs.
|
| 275 | * This particular use case only requires read access.
|
| 276 |
|
| 277 | fallthrough;
|
| 278 |
|
| 279 | case EFI_RUNTIME_SERVICES_CODE:
|
| 280 | |
| 281 | * This would be unusual, but not problematic per se,
|
| 282 | * as long as we take care not to create a writable
|
| 283 | * mapping for executable code.
|
| 284 |
|
| 285 | prot = PAGE_KERNEL_RO;
|
| 286 | break;
|
| 287 |
|
| 288 | case EFI_ACPI_RECLAIM_MEMORY:
|
| 289 | |
| 290 | * ACPI reclaim memory is used to pass firmware tables
|
| 291 | * and other data that is intended for consumption by
|
| 292 | * the OS only, which may decide it wants to reclaim
|
| 293 | * that memory and use it for something else. We never
|
| 294 | * do that, but we usually add it to the linear map
|
| 295 | * anyway, in which case we should use the existing
|
| 296 | * mapping.
|
| 297 |
|
| 298 | if (memblock_is_map_memory(phys))
|
| 299 | return (void __iomem *)__va(phys);
|
| 300 | fallthrough;
|
| 301 |
|
| 302 | default:
|
| 303 | if (region->attribute & EFI_MEMORY_WB)
|
| 304 | prot = PAGE_KERNEL;
|
| 305 | else if ((region->attribute & EFI_MEMORY_WC) ||
|
| 306 | (region->attribute & EFI_MEMORY_WT))
|
| 307 | prot = pgprot_writecombine(PAGE_KERNEL);
|
| 308 | }
|
| 309 | }
|
| 310 |
|
| 311 | return ioremap_prot(phys, size, prot);
|
| 312 | }
|
| 313 |
|
| 314 | #ifdef CONFIG_PCI
|
| 315 |
|
| 316 | |
| 317 | * raw_pci_read/write - Platform-specific PCI config space access.
|
| 318 |
|
| 319 | int raw_pci_read(unsigned int domain, unsigned int bus,
|
| 320 | unsigned int devfn, int reg, int len, u32 *val)
|
| 321 | {
|
| 322 | struct pci_bus *b = pci_find_bus(domain, bus);
|
| 323 |
|
| 324 | if (!b)
|
| 325 | return PCIBIOS_DEVICE_NOT_FOUND;
|
| 326 | return b->ops->read(b, devfn, reg, len, val);
|
| 327 | }
|
| 328 |
|
| 329 | int raw_pci_write(unsigned int domain, unsigned int bus,
|
| 330 | unsigned int devfn, int reg, int len, u32 val)
|
| 331 | {
|
| 332 | struct pci_bus *b = pci_find_bus(domain, bus);
|
| 333 |
|
| 334 | if (!b)
|
| 335 | return PCIBIOS_DEVICE_NOT_FOUND;
|
| 336 | return b->ops->write(b, devfn, reg, len, val);
|
| 337 | }
|
| 338 |
|
| 339 | #endif
|
| 340 |
|
| 341 | int acpi_get_cpu_uid(unsigned int cpu, u32 *uid)
|
| 342 | {
|
| 343 | struct acpi_madt_rintc *rintc;
|
| 344 |
|
| 345 | if (cpu >= nr_cpu_ids)
|
| 346 | return -EINVAL;
|
| 347 |
|
| 348 | rintc = acpi_cpu_get_madt_rintc(cpu);
|
| 349 | if (!rintc)
|
| 350 | return -ENODEV;
|
| 351 |
|
| 352 | *uid = rintc->uid;
|
| 353 | return 0;
|
| 354 | }
|
| 355 | EXPORT_SYMBOL_GPL(acpi_get_cpu_uid);
|
| 356 |
|
| 357 | void __init arch_reserve_mem_area(acpi_physical_address addr, size_t size)
|
| 358 | {
|
| 359 | memblock_mark_nomap(addr, size);
|
| 360 | }
|