1 /*
2 * Copyright (c) 2009 The DragonFly Project. All rights reserved.
3 *
4 * This code is derived from software contributed to The DragonFly Project
5 * by Sepherosa Ziehau <sepherosa@gmail.com>
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 *
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 */
34
35 #include <sys/param.h>
36 #include <sys/kernel.h>
37 #include <sys/systm.h>
38
39 #include <machine/pmap.h>
40 #include <machine/vmparam.h>
41
42 #include <contrib/dev/acpica/source/include/acpi.h>
43
44 #include "acpi_sdt_var.h"
45
46 #define SDT_VPRINTF(fmt, arg...) \
47 do { \
48 if (bootverbose) \
49 kprintf("ACPI SDT: " fmt , ##arg); \
50 } while (0)
51
52 typedef vm_paddr_t (*sdt_search_t)(vm_paddr_t, const uint8_t *);
53
54 static const ACPI_TABLE_RSDP *sdt_rsdp_search(const uint8_t *, int);
55 static vm_paddr_t sdt_search_xsdt(vm_paddr_t, const uint8_t *);
56 static vm_paddr_t sdt_search_rsdt(vm_paddr_t, const uint8_t *);
57
58 extern u_long ebda_addr;
59
60 static sdt_search_t sdt_search_func;
61 static vm_paddr_t sdt_search_paddr;
62
63 static void
sdt_probe(void)64 sdt_probe(void)
65 {
66 const ACPI_TABLE_RSDP *rsdp;
67 vm_size_t mapsz;
68 uint8_t *ptr;
69 u_long rsdp_paddr;
70
71 if (kgetenv_ulong("hint.acpi.0.rsdp", &rsdp_paddr) == 1) {
72 SDT_VPRINTF("RSDP in kenv hint\n");
73 mapsz = PAGE_SIZE;
74 ptr = pmap_mapdev(rsdp_paddr, mapsz);
75 rsdp = (const ACPI_TABLE_RSDP *)ptr;
76 goto found_rsdp;
77 }
78
79 if (ebda_addr != 0) {
80 mapsz = ACPI_EBDA_WINDOW_SIZE;
81 ptr = pmap_mapdev(ebda_addr, mapsz);
82
83 rsdp = sdt_rsdp_search(ptr, mapsz);
84 if (rsdp == NULL) {
85 SDT_VPRINTF("RSDP not in EBDA\n");
86 pmap_unmapdev((vm_offset_t)ptr, mapsz);
87
88 ptr = NULL;
89 mapsz = 0;
90 } else {
91 SDT_VPRINTF("RSDP in EBDA\n");
92 goto found_rsdp;
93 }
94 }
95
96 mapsz = ACPI_HI_RSDP_WINDOW_SIZE;
97 ptr = pmap_mapdev(ACPI_HI_RSDP_WINDOW_BASE, mapsz);
98
99 rsdp = sdt_rsdp_search(ptr, mapsz);
100 if (rsdp == NULL) {
101 kprintf("sdt_probe: no RSDP\n");
102 pmap_unmapdev((vm_offset_t)ptr, mapsz);
103 return;
104 } else {
105 SDT_VPRINTF("RSDP in BIOS mem\n");
106 }
107
108 found_rsdp:
109 if (rsdp->Revision != 2 /* || AcpiGbl_DoNotUseXsdt */) {
110 sdt_search_func = sdt_search_rsdt;
111 sdt_search_paddr = rsdp->RsdtPhysicalAddress;
112 } else {
113 sdt_search_func = sdt_search_xsdt;
114 sdt_search_paddr = rsdp->XsdtPhysicalAddress;
115 }
116 pmap_unmapdev((vm_offset_t)ptr, mapsz);
117 }
118 SYSINIT(sdt_probe, SI_BOOT2_PRESMP, SI_ORDER_FIRST, sdt_probe, 0);
119
120 static const ACPI_TABLE_RSDP *
sdt_rsdp_search(const uint8_t * target,int size)121 sdt_rsdp_search(const uint8_t *target, int size)
122 {
123 const ACPI_TABLE_RSDP *rsdp;
124 int i;
125
126 KKASSERT(size > sizeof(*rsdp));
127
128 for (i = 0; i < size - sizeof(*rsdp); i += ACPI_RSDP_SCAN_STEP) {
129 rsdp = (const ACPI_TABLE_RSDP *)&target[i];
130 if (memcmp(rsdp->Signature, ACPI_SIG_RSDP,
131 sizeof(rsdp->Signature)) == 0)
132 return rsdp;
133 }
134 return NULL;
135 }
136
137 void *
sdt_sdth_map(vm_paddr_t paddr)138 sdt_sdth_map(vm_paddr_t paddr)
139 {
140 ACPI_TABLE_HEADER *sdth;
141 vm_size_t mapsz;
142
143 sdth = pmap_mapdev(paddr, sizeof(*sdth));
144 mapsz = sdth->Length;
145 pmap_unmapdev((vm_offset_t)sdth, sizeof(*sdth));
146
147 if (mapsz < sizeof(*sdth))
148 return NULL;
149
150 return pmap_mapdev(paddr, mapsz);
151 }
152
153 void
sdt_sdth_unmap(ACPI_TABLE_HEADER * sdth)154 sdt_sdth_unmap(ACPI_TABLE_HEADER *sdth)
155 {
156 pmap_unmapdev((vm_offset_t)sdth, sdth->Length);
157 }
158
159 static vm_paddr_t
sdt_search_xsdt(vm_paddr_t xsdt_paddr,const uint8_t * sig)160 sdt_search_xsdt(vm_paddr_t xsdt_paddr, const uint8_t *sig)
161 {
162 ACPI_TABLE_XSDT *xsdt;
163 vm_paddr_t sdt_paddr = 0;
164 int i, nent;
165
166 if (xsdt_paddr == 0) {
167 kprintf("sdt_search_xsdt: XSDT paddr == 0\n");
168 return 0;
169 }
170
171 xsdt = sdt_sdth_map(xsdt_paddr);
172 if (xsdt == NULL) {
173 kprintf("sdt_search_xsdt: can't map XSDT\n");
174 return 0;
175 }
176
177 if (memcmp(xsdt->Header.Signature, ACPI_SIG_XSDT,
178 ACPI_NAMESEG_SIZE) != 0) {
179 kprintf("sdt_search_xsdt: not XSDT\n");
180 goto back;
181 }
182
183 if (xsdt->Header.Revision != 1) {
184 kprintf("sdt_search_xsdt: unknown XSDT revision %d\n",
185 xsdt->Header.Revision);
186 }
187
188 if (xsdt->Header.Length < sizeof(xsdt->Header)) {
189 kprintf("sdt_search_xsdt: invalid XSDT length %u\n",
190 xsdt->Header.Length);
191 goto back;
192 }
193
194 nent = (xsdt->Header.Length - sizeof(xsdt->Header)) /
195 sizeof(xsdt->TableOffsetEntry[0]);
196 for (i = 0; i < nent; ++i) {
197 ACPI_TABLE_HEADER *sdth;
198
199 if (xsdt->TableOffsetEntry[i] == 0)
200 continue;
201
202 sdth = sdt_sdth_map(xsdt->TableOffsetEntry[i]);
203 if (sdth != NULL) {
204 int ret;
205
206 ret = memcmp(sdth->Signature, sig, ACPI_NAMESEG_SIZE);
207 sdt_sdth_unmap(sdth);
208
209 if (ret == 0) {
210 sdt_paddr = xsdt->TableOffsetEntry[i];
211 break;
212 }
213 }
214 }
215 back:
216 sdt_sdth_unmap(&xsdt->Header);
217 return sdt_paddr;
218 }
219
220 static vm_paddr_t
sdt_search_rsdt(vm_paddr_t rsdt_paddr,const uint8_t * sig)221 sdt_search_rsdt(vm_paddr_t rsdt_paddr, const uint8_t *sig)
222 {
223 ACPI_TABLE_RSDT *rsdt;
224 vm_paddr_t sdt_paddr = 0;
225 int i, nent;
226
227 if (rsdt_paddr == 0) {
228 kprintf("sdt_search_rsdt: RSDT paddr == 0\n");
229 return 0;
230 }
231
232 rsdt = sdt_sdth_map(rsdt_paddr);
233 if (rsdt == NULL) {
234 kprintf("sdt_search_rsdt: can't map RSDT\n");
235 return 0;
236 }
237
238 if (memcmp(rsdt->Header.Signature, ACPI_SIG_RSDT,
239 ACPI_NAMESEG_SIZE) != 0) {
240 kprintf("sdt_search_rsdt: not RSDT\n");
241 goto back;
242 }
243
244 if (rsdt->Header.Revision != 1) {
245 kprintf("sdt_search_rsdt: unknown RSDT revision %d\n",
246 rsdt->Header.Revision);
247 }
248
249 if (rsdt->Header.Length < sizeof(rsdt->Header)) {
250 kprintf("sdt_search_rsdt: invalid RSDT length %u\n",
251 rsdt->Header.Length);
252 goto back;
253 }
254
255 nent = (rsdt->Header.Length - sizeof(rsdt->Header)) /
256 sizeof(rsdt->TableOffsetEntry[0]);
257 for (i = 0; i < nent; ++i) {
258 ACPI_TABLE_HEADER *sdth;
259
260 if (rsdt->TableOffsetEntry[i] == 0)
261 continue;
262
263 sdth = sdt_sdth_map(rsdt->TableOffsetEntry[i]);
264 if (sdth != NULL) {
265 int ret;
266
267 ret = memcmp(sdth->Signature, sig, ACPI_NAMESEG_SIZE);
268 sdt_sdth_unmap(sdth);
269
270 if (ret == 0) {
271 sdt_paddr = rsdt->TableOffsetEntry[i];
272 break;
273 }
274 }
275 }
276 back:
277 sdt_sdth_unmap(&rsdt->Header);
278 return sdt_paddr;
279 }
280
281 vm_paddr_t
sdt_search(const uint8_t * sig)282 sdt_search(const uint8_t *sig)
283 {
284 if (sdt_search_func == NULL)
285 return 0;
286 return sdt_search_func(sdt_search_paddr, sig);
287 }
288