]> Git Repo - linux.git/blob - arch/loongarch/kernel/acpi.c
Linux 6.14-rc3
[linux.git] / arch / loongarch / kernel / acpi.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * acpi.c - Architecture-Specific Low-Level ACPI Boot Support
4  *
5  * Author: Jianmin Lv <[email protected]>
6  *         Huacai Chen <[email protected]>
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/irq.h>
14 #include <linux/irqdomain.h>
15 #include <linux/memblock.h>
16 #include <linux/of_fdt.h>
17 #include <linux/serial_core.h>
18 #include <asm/io.h>
19 #include <asm/numa.h>
20 #include <asm/loongson.h>
21
22 int acpi_disabled;
23 EXPORT_SYMBOL(acpi_disabled);
24 int acpi_noirq;
25 int acpi_pci_disabled;
26 EXPORT_SYMBOL(acpi_pci_disabled);
27 int acpi_strict = 1; /* We have no workarounds on LoongArch */
28 int num_processors;
29 int disabled_cpus;
30
31 u64 acpi_saved_sp;
32
33 #define PREFIX                  "ACPI: "
34
35 struct acpi_madt_core_pic acpi_core_pic[MAX_CORE_PIC];
36
37 void __init __iomem * __acpi_map_table(unsigned long phys, unsigned long size)
38 {
39
40         if (!phys || !size)
41                 return NULL;
42
43         return early_memremap(phys, size);
44 }
45 void __init __acpi_unmap_table(void __iomem *map, unsigned long size)
46 {
47         if (!map || !size)
48                 return;
49
50         early_memunmap(map, size);
51 }
52
53 void __iomem *acpi_os_ioremap(acpi_physical_address phys, acpi_size size)
54 {
55         if (!memblock_is_memory(phys))
56                 return ioremap(phys, size);
57         else
58                 return ioremap_cache(phys, size);
59 }
60
61 #ifdef CONFIG_SMP
62 static int set_processor_mask(u32 id, u32 pass)
63 {
64         int cpu = -1, cpuid = id;
65
66         if (num_processors >= NR_CPUS) {
67                 pr_warn(PREFIX "nr_cpus limit of %i reached."
68                         " processor 0x%x ignored.\n", NR_CPUS, cpuid);
69
70                 return -ENODEV;
71
72         }
73
74         if (cpuid == loongson_sysconf.boot_cpu_id)
75                 cpu = 0;
76
77         switch (pass) {
78         case 1: /* Pass 1 handle enabled processors */
79                 if (cpu < 0)
80                         cpu = find_first_zero_bit(cpumask_bits(cpu_present_mask), NR_CPUS);
81                 num_processors++;
82                 set_cpu_present(cpu, true);
83                 break;
84         case 2: /* Pass 2 handle disabled processors */
85                 if (cpu < 0)
86                         cpu = find_first_zero_bit(cpumask_bits(cpu_possible_mask), NR_CPUS);
87                 disabled_cpus++;
88                 break;
89         default:
90                 return cpu;
91         }
92
93         set_cpu_possible(cpu, true);
94         __cpu_number_map[cpuid] = cpu;
95         __cpu_logical_map[cpu] = cpuid;
96
97         return cpu;
98 }
99 #endif
100
101 static int __init
102 acpi_parse_p1_processor(union acpi_subtable_headers *header, const unsigned long end)
103 {
104         struct acpi_madt_core_pic *processor = NULL;
105
106         processor = (struct acpi_madt_core_pic *)header;
107         if (BAD_MADT_ENTRY(processor, end))
108                 return -EINVAL;
109
110         acpi_table_print_madt_entry(&header->common);
111 #ifdef CONFIG_SMP
112         acpi_core_pic[processor->core_id] = *processor;
113         if (processor->flags & ACPI_MADT_ENABLED)
114                 set_processor_mask(processor->core_id, 1);
115 #endif
116
117         return 0;
118 }
119
120 static int __init
121 acpi_parse_p2_processor(union acpi_subtable_headers *header, const unsigned long end)
122 {
123         struct acpi_madt_core_pic *processor = NULL;
124
125         processor = (struct acpi_madt_core_pic *)header;
126         if (BAD_MADT_ENTRY(processor, end))
127                 return -EINVAL;
128
129 #ifdef CONFIG_SMP
130         if (!(processor->flags & ACPI_MADT_ENABLED))
131                 set_processor_mask(processor->core_id, 2);
132 #endif
133
134         return 0;
135 }
136 static int __init
137 acpi_parse_eio_master(union acpi_subtable_headers *header, const unsigned long end)
138 {
139         static int core = 0;
140         struct acpi_madt_eio_pic *eiointc = NULL;
141
142         eiointc = (struct acpi_madt_eio_pic *)header;
143         if (BAD_MADT_ENTRY(eiointc, end))
144                 return -EINVAL;
145
146         core = eiointc->node * CORES_PER_EIO_NODE;
147         set_bit(core, loongson_sysconf.cores_io_master);
148
149         return 0;
150 }
151
152 static void __init acpi_process_madt(void)
153 {
154 #ifdef CONFIG_SMP
155         int i;
156
157         for (i = 0; i < NR_CPUS; i++) {
158                 __cpu_number_map[i] = -1;
159                 __cpu_logical_map[i] = -1;
160         }
161 #endif
162         acpi_table_parse_madt(ACPI_MADT_TYPE_CORE_PIC,
163                         acpi_parse_p1_processor, MAX_CORE_PIC);
164
165         acpi_table_parse_madt(ACPI_MADT_TYPE_CORE_PIC,
166                         acpi_parse_p2_processor, MAX_CORE_PIC);
167
168         acpi_table_parse_madt(ACPI_MADT_TYPE_EIO_PIC,
169                         acpi_parse_eio_master, MAX_IO_PICS);
170
171         loongson_sysconf.nr_cpus = num_processors;
172 }
173
174 int pptt_enabled;
175
176 int __init parse_acpi_topology(void)
177 {
178         int cpu, topology_id;
179
180         for_each_possible_cpu(cpu) {
181                 topology_id = find_acpi_cpu_topology(cpu, 0);
182                 if (topology_id < 0) {
183                         pr_warn("Invalid BIOS PPTT\n");
184                         return -ENOENT;
185                 }
186
187                 if (acpi_pptt_cpu_is_thread(cpu) <= 0)
188                         cpu_data[cpu].core = topology_id;
189                 else {
190                         topology_id = find_acpi_cpu_topology(cpu, 1);
191                         if (topology_id < 0)
192                                 return -ENOENT;
193
194                         cpu_data[cpu].core = topology_id;
195                 }
196         }
197
198         pptt_enabled = 1;
199
200         return 0;
201 }
202
203 #ifndef CONFIG_SUSPEND
204 int (*acpi_suspend_lowlevel)(void);
205 #else
206 int (*acpi_suspend_lowlevel)(void) = loongarch_acpi_suspend;
207 #endif
208
209 void __init acpi_boot_table_init(void)
210 {
211         /*
212          * If acpi_disabled, bail out
213          */
214         if (acpi_disabled)
215                 goto fdt_earlycon;
216
217         /*
218          * Initialize the ACPI boot-time table parser.
219          */
220         if (acpi_table_init()) {
221                 disable_acpi();
222                 goto fdt_earlycon;
223         }
224
225         loongson_sysconf.boot_cpu_id = read_csr_cpuid();
226
227         /*
228          * Process the Multiple APIC Description Table (MADT), if present
229          */
230         acpi_process_madt();
231
232         /* Do not enable ACPI SPCR console by default */
233         acpi_parse_spcr(earlycon_acpi_spcr_enable, false);
234
235         if (IS_ENABLED(CONFIG_ACPI_BGRT))
236                 acpi_table_parse(ACPI_SIG_BGRT, acpi_parse_bgrt);
237
238         return;
239
240 fdt_earlycon:
241         if (earlycon_acpi_spcr_enable)
242                 early_init_dt_scan_chosen_stdout();
243 }
244
245 #ifdef CONFIG_ACPI_NUMA
246
247 static __init int setup_node(int pxm)
248 {
249         return acpi_map_pxm_to_node(pxm);
250 }
251
252 /*
253  * Callback for SLIT parsing.  pxm_to_node() returns NUMA_NO_NODE for
254  * I/O localities since SRAT does not list them.  I/O localities are
255  * not supported at this point.
256  */
257 unsigned int numa_distance_cnt;
258
259 static inline unsigned int get_numa_distances_cnt(struct acpi_table_slit *slit)
260 {
261         return slit->locality_count;
262 }
263
264 void __init numa_set_distance(int from, int to, int distance)
265 {
266         if ((u8)distance != distance || (from == to && distance != LOCAL_DISTANCE)) {
267                 pr_warn_once("Warning: invalid distance parameter, from=%d to=%d distance=%d\n",
268                                 from, to, distance);
269                 return;
270         }
271
272         node_distances[from][to] = distance;
273 }
274
275 /* Callback for Proximity Domain -> CPUID mapping */
276 void __init
277 acpi_numa_processor_affinity_init(struct acpi_srat_cpu_affinity *pa)
278 {
279         int pxm, node;
280
281         if (srat_disabled())
282                 return;
283         if (pa->header.length != sizeof(struct acpi_srat_cpu_affinity)) {
284                 bad_srat();
285                 return;
286         }
287         if ((pa->flags & ACPI_SRAT_CPU_ENABLED) == 0)
288                 return;
289         pxm = pa->proximity_domain_lo;
290         if (acpi_srat_revision >= 2) {
291                 pxm |= (pa->proximity_domain_hi[0] << 8);
292                 pxm |= (pa->proximity_domain_hi[1] << 16);
293                 pxm |= (pa->proximity_domain_hi[2] << 24);
294         }
295         node = setup_node(pxm);
296         if (node < 0) {
297                 pr_err("SRAT: Too many proximity domains %x\n", pxm);
298                 bad_srat();
299                 return;
300         }
301
302         if (pa->apic_id >= CONFIG_NR_CPUS) {
303                 pr_info("SRAT: PXM %u -> CPU 0x%02x -> Node %u skipped apicid that is too big\n",
304                                 pxm, pa->apic_id, node);
305                 return;
306         }
307
308         early_numa_add_cpu(pa->apic_id, node);
309
310         set_cpuid_to_node(pa->apic_id, node);
311         node_set(node, numa_nodes_parsed);
312         pr_info("SRAT: PXM %u -> CPU 0x%02x -> Node %u\n", pxm, pa->apic_id, node);
313 }
314
315 #endif
316
317 void __init arch_reserve_mem_area(acpi_physical_address addr, size_t size)
318 {
319         memblock_reserve(addr, size);
320 }
321
322 #ifdef CONFIG_ACPI_HOTPLUG_CPU
323
324 #include <acpi/processor.h>
325
326 static int __ref acpi_map_cpu2node(acpi_handle handle, int cpu, int physid)
327 {
328 #ifdef CONFIG_ACPI_NUMA
329         int nid;
330
331         nid = acpi_get_node(handle);
332
333         if (nid != NUMA_NO_NODE)
334                 nid = early_cpu_to_node(cpu);
335
336         if (nid != NUMA_NO_NODE) {
337                 set_cpuid_to_node(physid, nid);
338                 node_set(nid, numa_nodes_parsed);
339                 set_cpu_numa_node(cpu, nid);
340                 cpumask_set_cpu(cpu, cpumask_of_node(nid));
341         }
342 #endif
343         return 0;
344 }
345
346 int acpi_map_cpu(acpi_handle handle, phys_cpuid_t physid, u32 acpi_id, int *pcpu)
347 {
348         int cpu;
349
350         cpu = cpu_number_map(physid);
351         if (cpu < 0 || cpu >= nr_cpu_ids) {
352                 pr_info(PREFIX "Unable to map lapic to logical cpu number\n");
353                 return -ERANGE;
354         }
355
356         num_processors++;
357         set_cpu_present(cpu, true);
358         acpi_map_cpu2node(handle, cpu, physid);
359
360         *pcpu = cpu;
361
362         return 0;
363 }
364 EXPORT_SYMBOL(acpi_map_cpu);
365
366 int acpi_unmap_cpu(int cpu)
367 {
368 #ifdef CONFIG_ACPI_NUMA
369         set_cpuid_to_node(cpu_logical_map(cpu), NUMA_NO_NODE);
370 #endif
371         set_cpu_present(cpu, false);
372         num_processors--;
373
374         pr_info("cpu%d hot remove!\n", cpu);
375
376         return 0;
377 }
378 EXPORT_SYMBOL(acpi_unmap_cpu);
379
380 #endif /* CONFIG_ACPI_HOTPLUG_CPU */
This page took 0.053029 seconds and 4 git commands to generate.