]> Git Repo - J-linux.git/blob - arch/x86/boot/compressed/acpi.c
Merge tag 'vfs-6.13-rc7.fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs
[J-linux.git] / arch / x86 / boot / compressed / acpi.c
1 // SPDX-License-Identifier: GPL-2.0
2 #define BOOT_CTYPE_H
3 #include "misc.h"
4 #include "error.h"
5 #include "../string.h"
6 #include "efi.h"
7
8 #include <asm/bootparam.h>
9
10 #include <linux/numa.h>
11
12 /*
13  * Longest parameter of 'acpi=' is 'copy_dsdt', plus an extra '\0'
14  * for termination.
15  */
16 #define MAX_ACPI_ARG_LENGTH 10
17
18 /*
19  * Immovable memory regions representation. Max amount of memory regions is
20  * MAX_NUMNODES*2.
21  */
22 struct mem_vector immovable_mem[MAX_NUMNODES*2];
23
24 static acpi_physical_address
25 __efi_get_rsdp_addr(unsigned long cfg_tbl_pa, unsigned int cfg_tbl_len)
26 {
27 #ifdef CONFIG_EFI
28         unsigned long rsdp_addr;
29         int ret;
30
31         /*
32          * Search EFI system tables for RSDP. Preferred is ACPI_20_TABLE_GUID to
33          * ACPI_TABLE_GUID because it has more features.
34          */
35         rsdp_addr = efi_find_vendor_table(boot_params_ptr, cfg_tbl_pa, cfg_tbl_len,
36                                           ACPI_20_TABLE_GUID);
37         if (rsdp_addr)
38                 return (acpi_physical_address)rsdp_addr;
39
40         /* No ACPI_20_TABLE_GUID found, fallback to ACPI_TABLE_GUID. */
41         rsdp_addr = efi_find_vendor_table(boot_params_ptr, cfg_tbl_pa, cfg_tbl_len,
42                                           ACPI_TABLE_GUID);
43         if (rsdp_addr)
44                 return (acpi_physical_address)rsdp_addr;
45
46         debug_putstr("Error getting RSDP address.\n");
47 #endif
48         return 0;
49 }
50
51 static acpi_physical_address efi_get_rsdp_addr(void)
52 {
53 #ifdef CONFIG_EFI
54         unsigned long cfg_tbl_pa = 0;
55         unsigned int cfg_tbl_len;
56         unsigned long systab_pa;
57         unsigned int nr_tables;
58         enum efi_type et;
59         int ret;
60
61         et = efi_get_type(boot_params_ptr);
62         if (et == EFI_TYPE_NONE)
63                 return 0;
64
65         systab_pa = efi_get_system_table(boot_params_ptr);
66         if (!systab_pa)
67                 error("EFI support advertised, but unable to locate system table.");
68
69         ret = efi_get_conf_table(boot_params_ptr, &cfg_tbl_pa, &cfg_tbl_len);
70         if (ret || !cfg_tbl_pa)
71                 error("EFI config table not found.");
72
73         return __efi_get_rsdp_addr(cfg_tbl_pa, cfg_tbl_len);
74 #else
75         return 0;
76 #endif
77 }
78
79 static u8 compute_checksum(u8 *buffer, u32 length)
80 {
81         u8 *end = buffer + length;
82         u8 sum = 0;
83
84         while (buffer < end)
85                 sum += *(buffer++);
86
87         return sum;
88 }
89
90 /* Search a block of memory for the RSDP signature. */
91 static u8 *scan_mem_for_rsdp(u8 *start, u32 length)
92 {
93         struct acpi_table_rsdp *rsdp;
94         u8 *address, *end;
95
96         end = start + length;
97
98         /* Search from given start address for the requested length */
99         for (address = start; address < end; address += ACPI_RSDP_SCAN_STEP) {
100                 /*
101                  * Both RSDP signature and checksum must be correct.
102                  * Note: Sometimes there exists more than one RSDP in memory;
103                  * the valid RSDP has a valid checksum, all others have an
104                  * invalid checksum.
105                  */
106                 rsdp = (struct acpi_table_rsdp *)address;
107
108                 /* BAD Signature */
109                 if (!ACPI_VALIDATE_RSDP_SIG(rsdp->signature))
110                         continue;
111
112                 /* Check the standard checksum */
113                 if (compute_checksum((u8 *)rsdp, ACPI_RSDP_CHECKSUM_LENGTH))
114                         continue;
115
116                 /* Check extended checksum if table version >= 2 */
117                 if ((rsdp->revision >= 2) &&
118                     (compute_checksum((u8 *)rsdp, ACPI_RSDP_XCHECKSUM_LENGTH)))
119                         continue;
120
121                 /* Signature and checksum valid, we have found a real RSDP */
122                 return address;
123         }
124         return NULL;
125 }
126
127 /* Search RSDP address in EBDA. */
128 static acpi_physical_address bios_get_rsdp_addr(void)
129 {
130         unsigned long address;
131         u8 *rsdp;
132
133         /* Get the location of the Extended BIOS Data Area (EBDA) */
134         address = *(u16 *)ACPI_EBDA_PTR_LOCATION;
135         address <<= 4;
136
137         /*
138          * Search EBDA paragraphs (EBDA is required to be a minimum of
139          * 1K length)
140          */
141         if (address > 0x400) {
142                 rsdp = scan_mem_for_rsdp((u8 *)address, ACPI_EBDA_WINDOW_SIZE);
143                 if (rsdp)
144                         return (acpi_physical_address)(unsigned long)rsdp;
145         }
146
147         /* Search upper memory: 16-byte boundaries in E0000h-FFFFFh */
148         rsdp = scan_mem_for_rsdp((u8 *) ACPI_HI_RSDP_WINDOW_BASE,
149                                         ACPI_HI_RSDP_WINDOW_SIZE);
150         if (rsdp)
151                 return (acpi_physical_address)(unsigned long)rsdp;
152
153         return 0;
154 }
155
156 /* Return RSDP address on success, otherwise 0. */
157 acpi_physical_address get_rsdp_addr(void)
158 {
159         acpi_physical_address pa;
160
161         pa = boot_params_ptr->acpi_rsdp_addr;
162
163         if (!pa)
164                 pa = efi_get_rsdp_addr();
165
166         if (!pa)
167                 pa = bios_get_rsdp_addr();
168
169         return pa;
170 }
171
172 #if defined(CONFIG_RANDOMIZE_BASE) && defined(CONFIG_MEMORY_HOTREMOVE)
173 /*
174  * Max length of 64-bit hex address string is 19, prefix "0x" + 16 hex
175  * digits, and '\0' for termination.
176  */
177 #define MAX_ADDR_LEN 19
178
179 static unsigned long get_cmdline_acpi_rsdp(void)
180 {
181         unsigned long addr = 0;
182
183 #ifdef CONFIG_KEXEC_CORE
184         char val[MAX_ADDR_LEN] = { };
185         int ret;
186
187         ret = cmdline_find_option("acpi_rsdp", val, MAX_ADDR_LEN);
188         if (ret < 0)
189                 return 0;
190
191         if (boot_kstrtoul(val, 16, &addr))
192                 return 0;
193 #endif
194         return addr;
195 }
196
197 /* Compute SRAT address from RSDP. */
198 static unsigned long get_acpi_srat_table(void)
199 {
200         unsigned long root_table, acpi_table;
201         struct acpi_table_header *header;
202         struct acpi_table_rsdp *rsdp;
203         u32 num_entries, size, len;
204         char arg[10];
205         u8 *entry;
206
207         /*
208          * Check whether we were given an RSDP on the command line. We don't
209          * stash this in boot params because the kernel itself may have
210          * different ideas about whether to trust a command-line parameter.
211          */
212         rsdp = (struct acpi_table_rsdp *)get_cmdline_acpi_rsdp();
213         if (!rsdp)
214                 rsdp = (struct acpi_table_rsdp *)(long)
215                         boot_params_ptr->acpi_rsdp_addr;
216
217         if (!rsdp)
218                 return 0;
219
220         /* Get ACPI root table from RSDP.*/
221         if (!(cmdline_find_option("acpi", arg, sizeof(arg)) == 4 &&
222             !strncmp(arg, "rsdt", 4)) &&
223             rsdp->xsdt_physical_address &&
224             rsdp->revision > 1) {
225                 root_table = rsdp->xsdt_physical_address;
226                 size = ACPI_XSDT_ENTRY_SIZE;
227         } else {
228                 root_table = rsdp->rsdt_physical_address;
229                 size = ACPI_RSDT_ENTRY_SIZE;
230         }
231
232         if (!root_table)
233                 return 0;
234
235         header = (struct acpi_table_header *)root_table;
236         len = header->length;
237         if (len < sizeof(struct acpi_table_header) + size)
238                 return 0;
239
240         num_entries = (len - sizeof(struct acpi_table_header)) / size;
241         entry = (u8 *)(root_table + sizeof(struct acpi_table_header));
242
243         while (num_entries--) {
244                 if (size == ACPI_RSDT_ENTRY_SIZE)
245                         acpi_table = *(u32 *)entry;
246                 else
247                         acpi_table = *(u64 *)entry;
248
249                 if (acpi_table) {
250                         header = (struct acpi_table_header *)acpi_table;
251
252                         if (ACPI_COMPARE_NAMESEG(header->signature, ACPI_SIG_SRAT))
253                                 return acpi_table;
254                 }
255                 entry += size;
256         }
257         return 0;
258 }
259
260 /**
261  * count_immovable_mem_regions - Parse SRAT and cache the immovable
262  * memory regions into the immovable_mem array.
263  *
264  * Return the number of immovable memory regions on success, 0 on failure:
265  *
266  * - Too many immovable memory regions
267  * - ACPI off or no SRAT found
268  * - No immovable memory region found.
269  */
270 int count_immovable_mem_regions(void)
271 {
272         unsigned long table_addr, table_end, table;
273         struct acpi_subtable_header *sub_table;
274         struct acpi_table_header *table_header;
275         char arg[MAX_ACPI_ARG_LENGTH];
276         int num = 0;
277
278         if (cmdline_find_option("acpi", arg, sizeof(arg)) == 3 &&
279             !strncmp(arg, "off", 3))
280                 return 0;
281
282         table_addr = get_acpi_srat_table();
283         if (!table_addr)
284                 return 0;
285
286         table_header = (struct acpi_table_header *)table_addr;
287         table_end = table_addr + table_header->length;
288         table = table_addr + sizeof(struct acpi_table_srat);
289
290         while (table + sizeof(struct acpi_subtable_header) < table_end) {
291
292                 sub_table = (struct acpi_subtable_header *)table;
293                 if (!sub_table->length) {
294                         debug_putstr("Invalid zero length SRAT subtable.\n");
295                         return 0;
296                 }
297
298                 if (sub_table->type == ACPI_SRAT_TYPE_MEMORY_AFFINITY) {
299                         struct acpi_srat_mem_affinity *ma;
300
301                         ma = (struct acpi_srat_mem_affinity *)sub_table;
302                         if (!(ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) && ma->length) {
303                                 immovable_mem[num].start = ma->base_address;
304                                 immovable_mem[num].size = ma->length;
305                                 num++;
306                         }
307
308                         if (num >= MAX_NUMNODES*2) {
309                                 debug_putstr("Too many immovable memory regions, aborting.\n");
310                                 return 0;
311                         }
312                 }
313                 table += sub_table->length;
314         }
315         return num;
316 }
317 #endif /* CONFIG_RANDOMIZE_BASE && CONFIG_MEMORY_HOTREMOVE */
This page took 0.042841 seconds and 4 git commands to generate.