1 /******************************************************************************
2 *
3 * Module Name: oswintbl - Windows OSL for obtaining ACPI tables
4 *
5 *****************************************************************************/
6
7 /******************************************************************************
8 *
9 * 1. Copyright Notice
10 *
11 * Some or all of this work - Copyright (c) 1999 - 2023, Intel Corp.
12 * All rights reserved.
13 *
14 * 2. License
15 *
16 * 2.1. This is your license from Intel Corp. under its intellectual property
17 * rights. You may have additional license terms from the party that provided
18 * you this software, covering your right to use that party's intellectual
19 * property rights.
20 *
21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22 * copy of the source code appearing in this file ("Covered Code") an
23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24 * base code distributed originally by Intel ("Original Intel Code") to copy,
25 * make derivatives, distribute, use and display any portion of the Covered
26 * Code in any form, with the right to sublicense such rights; and
27 *
28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29 * license (with the right to sublicense), under only those claims of Intel
30 * patents that are infringed by the Original Intel Code, to make, use, sell,
31 * offer to sell, and import the Covered Code and derivative works thereof
32 * solely to the minimum extent necessary to exercise the above copyright
33 * license, and in no event shall the patent license extend to any additions
34 * to or modifications of the Original Intel Code. No other license or right
35 * is granted directly or by implication, estoppel or otherwise;
36 *
37 * The above copyright and patent license is granted only if the following
38 * conditions are met:
39 *
40 * 3. Conditions
41 *
42 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43 * Redistribution of source code of any substantial portion of the Covered
44 * Code or modification with rights to further distribute source must include
45 * the above Copyright Notice, the above License, this list of Conditions,
46 * and the following Disclaimer and Export Compliance provision. In addition,
47 * Licensee must cause all Covered Code to which Licensee contributes to
48 * contain a file documenting the changes Licensee made to create that Covered
49 * Code and the date of any change. Licensee must include in that file the
50 * documentation of any changes made by any predecessor Licensee. Licensee
51 * must include a prominent statement that the modification is derived,
52 * directly or indirectly, from Original Intel Code.
53 *
54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55 * Redistribution of source code of any substantial portion of the Covered
56 * Code or modification without rights to further distribute source must
57 * include the following Disclaimer and Export Compliance provision in the
58 * documentation and/or other materials provided with distribution. In
59 * addition, Licensee may not authorize further sublicense of source of any
60 * portion of the Covered Code, and must include terms to the effect that the
61 * license from Licensee to its licensee is limited to the intellectual
62 * property embodied in the software Licensee provides to its licensee, and
63 * not to intellectual property embodied in modifications its licensee may
64 * make.
65 *
66 * 3.3. Redistribution of Executable. Redistribution in executable form of any
67 * substantial portion of the Covered Code or modification must reproduce the
68 * above Copyright Notice, and the following Disclaimer and Export Compliance
69 * provision in the documentation and/or other materials provided with the
70 * distribution.
71 *
72 * 3.4. Intel retains all right, title, and interest in and to the Original
73 * Intel Code.
74 *
75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76 * Intel shall be used in advertising or otherwise to promote the sale, use or
77 * other dealings in products derived from or relating to the Covered Code
78 * without prior written authorization from Intel.
79 *
80 * 4. Disclaimer and Export Compliance
81 *
82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88 * PARTICULAR PURPOSE.
89 *
90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97 * LIMITED REMEDY.
98 *
99 * 4.3. Licensee shall not export, either directly or indirectly, any of this
100 * software or system incorporating such software without first obtaining any
101 * required license or other approval from the U. S. Department of Commerce or
102 * any other agency or department of the United States Government. In the
103 * event Licensee exports any such software from the United States or
104 * re-exports any such software from a foreign destination, Licensee shall
105 * ensure that the distribution and export/re-export of the software is in
106 * compliance with all laws, regulations, orders, or other restrictions of the
107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108 * any of its subsidiaries will export/re-export any technical data, process,
109 * software, or service, directly or indirectly, to any country for which the
110 * United States government or any agency thereof requires an export license,
111 * other governmental approval, or letter of assurance, without first obtaining
112 * such license, approval or letter.
113 *
114 *****************************************************************************
115 *
116 * Alternatively, you may choose to be licensed under the terms of the
117 * following license:
118 *
119 * Redistribution and use in source and binary forms, with or without
120 * modification, are permitted provided that the following conditions
121 * are met:
122 * 1. Redistributions of source code must retain the above copyright
123 * notice, this list of conditions, and the following disclaimer,
124 * without modification.
125 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
126 * substantially similar to the "NO WARRANTY" disclaimer below
127 * ("Disclaimer") and any redistribution must be conditioned upon
128 * including a substantially similar Disclaimer requirement for further
129 * binary redistribution.
130 * 3. Neither the names of the above-listed copyright holders nor the names
131 * of any contributors may be used to endorse or promote products derived
132 * from this software without specific prior written permission.
133 *
134 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
135 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
136 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
137 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
138 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
139 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
140 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
141 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
142 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
143 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
144 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
145 *
146 * Alternatively, you may choose to be licensed under the terms of the
147 * GNU General Public License ("GPL") version 2 as published by the Free
148 * Software Foundation.
149 *
150 *****************************************************************************/
151
152 #include "acpi.h"
153 #include "accommon.h"
154 #include "acutils.h"
155 #include <stdio.h>
156
157 #ifdef WIN32
158 #pragma warning(disable:4115) /* warning C4115: (caused by rpcasync.h) */
159 #include <windows.h>
160
161 #elif WIN64
162 #include <windowsx.h>
163 #endif
164
165 #define _COMPONENT ACPI_OS_SERVICES
166 ACPI_MODULE_NAME ("oswintbl")
167
168 /* Local prototypes */
169
170 static char *
171 WindowsFormatException (
172 LONG WinStatus);
173
174 /* Globals */
175
176 #define LOCAL_BUFFER_SIZE 64
177
178 static char KeyBuffer[LOCAL_BUFFER_SIZE];
179 static char ErrorBuffer[LOCAL_BUFFER_SIZE];
180
181 /*
182 * List of table signatures reported by EnumSystemFirmwareTables ()
183 */
184 UINT32 *Gbl_AvailableTableSignatures;
185 UINT32 Gbl_TableCount = 0;
186 UINT32 Gbl_SsdtInstance = 0;
187
188 BOOLEAN Gbl_TableListInitialized = FALSE;
189
190 static ACPI_STATUS
191 OslTableInitialize (
192 void);
193
194
195 /******************************************************************************
196 *
197 * FUNCTION: WindowsFormatException
198 *
199 * PARAMETERS: WinStatus - Status from a Windows system call
200 *
201 * RETURN: Formatted (ascii) exception code. Front-end to Windows
202 * FormatMessage interface.
203 *
204 * DESCRIPTION: Decode a windows exception
205 *
206 *****************************************************************************/
207
208 static char *
WindowsFormatException(LONG WinStatus)209 WindowsFormatException (
210 LONG WinStatus)
211 {
212
213 ErrorBuffer[0] = 0;
214 FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, NULL, WinStatus, 0,
215 ErrorBuffer, LOCAL_BUFFER_SIZE, NULL);
216
217 return (ErrorBuffer);
218 }
219
220
221 /******************************************************************************
222 *
223 * FUNCTION: AcpiOsGetTableByAddress
224 *
225 * PARAMETERS: Address - Physical address of the ACPI table
226 * Table - Where a pointer to the table is returned
227 *
228 * RETURN: Status; Table buffer is returned if AE_OK.
229 * AE_NOT_FOUND: A valid table was not found at the address
230 *
231 * DESCRIPTION: Get an ACPI table via a physical memory address.
232 *
233 * NOTE: Cannot be implemented without a Windows device driver.
234 *
235 *****************************************************************************/
236
237 ACPI_STATUS
AcpiOsGetTableByAddress(ACPI_PHYSICAL_ADDRESS Address,ACPI_TABLE_HEADER ** Table)238 AcpiOsGetTableByAddress (
239 ACPI_PHYSICAL_ADDRESS Address,
240 ACPI_TABLE_HEADER **Table)
241 {
242
243 fprintf (stderr, "Get table by address is not supported on Windows\n");
244 return (AE_SUPPORT);
245 }
246
247
248 /******************************************************************************
249 *
250 * FUNCTION: AcpiOsGetTableByIndex
251 *
252 * PARAMETERS: Index - Which table to get
253 * Table - Where a pointer to the table is returned
254 * Instance - Where a pointer to the table instance no. is
255 * returned
256 * Address - Where the table physical address is returned
257 *
258 * RETURN: Status; Table buffer and physical address returned if AE_OK.
259 * AE_LIMIT: Index is beyond valid limit
260 *
261 * DESCRIPTION: Get an ACPI table via an index value (0 through n). Returns
262 * AE_LIMIT when an invalid index is reached. Index is not
263 * necessarily an index into the RSDT/XSDT.
264 * SSDT tables are obtained from the Windows registry. All other
265 * tables are obtained through GetSystemFirmwareTable ().
266 *
267 * NOTE: Cannot get the physical address from the windows registry;
268 * zero is returned instead.
269 *
270 *****************************************************************************/
271
272 ACPI_STATUS
AcpiOsGetTableByIndex(UINT32 Index,ACPI_TABLE_HEADER ** Table,UINT32 * Instance,ACPI_PHYSICAL_ADDRESS * Address)273 AcpiOsGetTableByIndex (
274 UINT32 Index,
275 ACPI_TABLE_HEADER **Table,
276 UINT32 *Instance,
277 ACPI_PHYSICAL_ADDRESS *Address)
278 {
279 ACPI_STATUS Status;
280 char *Signature;
281 UINT32 CurrentInstance;
282
283
284 /* Enumerate all ACPI table signatures on first invocation of this function */
285
286 Status = OslTableInitialize ();
287 if (ACPI_FAILURE (Status))
288 {
289 return (Status);
290 }
291
292 /* Validate Index */
293
294 if (Index < Gbl_TableCount)
295 {
296 Signature = malloc (ACPI_NAMESEG_SIZE + 1);
297 if (!Signature)
298 {
299 return (AE_NO_MEMORY);
300 }
301
302 Signature = memmove (Signature, &Gbl_AvailableTableSignatures[Index], ACPI_NAMESEG_SIZE);
303 }
304 else
305 {
306 return (AE_LIMIT);
307 }
308
309 if (ACPI_COMPARE_NAMESEG (Signature, ACPI_SIG_SSDT))
310 {
311 CurrentInstance = Gbl_SsdtInstance;
312 Gbl_SsdtInstance++;
313 }
314 else
315 {
316 CurrentInstance = 0;
317 }
318
319 Status = AcpiOsGetTableByName (Signature, CurrentInstance, Table, Address);
320 if (ACPI_SUCCESS (Status))
321 {
322 *Instance = CurrentInstance;
323 }
324 else if (Status == AE_NOT_FOUND &&
325 ACPI_COMPARE_NAMESEG (Signature, ACPI_SIG_SSDT))
326 {
327 /* Treat SSDTs that are not found as invalid index. */
328 Status = AE_LIMIT;
329 }
330
331 free (Signature);
332 return (Status);
333 }
334
335 /******************************************************************************
336 *
337 * FUNCTION: OslTableInitialize
338 *
339 * PARAMETERS: None
340 *
341 * RETURN: Status
342 *
343 * DESCRIPTION: Initialize ACPI table data. Enumerate all ACPI table signatures
344 * and save them to a global list.
345 *
346 *****************************************************************************/
347 static ACPI_STATUS
OslTableInitialize(void)348 OslTableInitialize (
349 void)
350 {
351 UINT32 ResultSize;
352 UINT32 DataSize;
353
354 if (Gbl_TableListInitialized)
355 {
356 return (AE_OK);
357 }
358
359 /*
360 * ACPI table signatures are always 4 characters. Therefore, the data size
361 * buffer should be a multiple of 4
362 */
363 DataSize = EnumSystemFirmwareTables ('ACPI', NULL, 0);
364 if (DataSize % ACPI_NAMESEG_SIZE)
365 {
366 return (AE_ERROR);
367 }
368
369 /*
370 * EnumSystemFirmwareTables () does not report the DSDT or XSDT. Work around this
371 * by adding these entries manually.
372 */
373 Gbl_TableCount = 2 + DataSize / ACPI_NAMESEG_SIZE;
374 Gbl_AvailableTableSignatures = malloc (Gbl_TableCount * ACPI_NAMESEG_SIZE);
375 if (!Gbl_AvailableTableSignatures)
376 {
377 return (AE_NO_MEMORY);
378 }
379
380 ResultSize = EnumSystemFirmwareTables ('ACPI', Gbl_AvailableTableSignatures, DataSize);
381 if (ResultSize > DataSize)
382 {
383 return (AE_ERROR);
384 }
385
386 /* Insert the DSDT and XSDT tables signatures */
387
388 Gbl_AvailableTableSignatures [Gbl_TableCount - 1] = 'TDSD';
389 Gbl_AvailableTableSignatures [Gbl_TableCount - 2] = 'TDSX';
390
391 Gbl_TableListInitialized = TRUE;
392 return (AE_OK);
393 }
394
395
396 /******************************************************************************
397 *
398 * FUNCTION: WindowsGetTableFromRegistry
399 *
400 * PARAMETERS: Signature - ACPI Signature for desired table. Must be
401 * a null terminated 4-character string.
402 * Instance - For SSDTs (0...n). Use 0 otherwise.
403 * Table - Where a pointer to the table is returned
404 * Address - Where the table physical address is returned
405 *
406 * RETURN: Status; Table buffer and physical address returned if AE_OK.
407 * AE_LIMIT: Instance is beyond valid limit
408 * AE_NOT_FOUND: A table with the signature was not found
409 *
410 * DESCRIPTION: Get an ACPI table via a table signature (4 ASCII characters).
411 * Returns AE_LIMIT when an invalid instance is reached.
412 * Table is obtained from the Windows registry.
413 *
414 * NOTE: Assumes the input signature is uppercase.
415 * Cannot get the physical address from the windows registry;
416 * zero is returned instead.
417 *
418 *****************************************************************************/
419
420 static ACPI_STATUS
WindowsGetTableFromRegistry(char * Signature,UINT32 Instance,ACPI_TABLE_HEADER ** Table,ACPI_PHYSICAL_ADDRESS * Address)421 WindowsGetTableFromRegistry (
422 char *Signature,
423 UINT32 Instance,
424 ACPI_TABLE_HEADER **Table,
425 ACPI_PHYSICAL_ADDRESS *Address)
426 {
427 HKEY Handle = NULL;
428 LONG WinStatus;
429 ULONG Type;
430 ULONG NameSize;
431 ULONG DataSize;
432 HKEY SubKey;
433 ULONG i;
434 ACPI_TABLE_HEADER *ReturnTable;
435 ACPI_STATUS Status = AE_OK;
436
437
438 /* Get a handle to the table key */
439
440 while (1)
441 {
442 strcpy(KeyBuffer, "HARDWARE\\ACPI\\");
443 if (AcpiUtSafeStrcat(KeyBuffer, sizeof(KeyBuffer), Signature))
444 {
445 return (AE_BUFFER_OVERFLOW);
446 }
447
448 /*
449 * Windows stores SSDT at SSDT, SSD1, ..., SSD9, SSDA, ..., SSDS, SSDT,
450 * SSDU, ..., SSDY. If the first (0th) and the 29th tables have the same
451 * OEM ID, Table ID and Revision, then the 29th entry will overwrite the
452 * first entry... Let's hope that we do not have that many entries.
453 */
454 if (Instance > 0 && ACPI_COMPARE_NAMESEG(Signature, ACPI_SIG_SSDT))
455 {
456 if (Instance < 10)
457 {
458 KeyBuffer[strlen(KeyBuffer) - 1] = '0' + (char)Instance;
459 }
460 else if (Instance < 29)
461 {
462 KeyBuffer[strlen(KeyBuffer) - 1] = 'A' + (char)(Instance - 10);
463 }
464 else
465 {
466 return (AE_LIMIT);
467 }
468 }
469
470 WinStatus = RegOpenKeyEx(HKEY_LOCAL_MACHINE, KeyBuffer,
471 0L, KEY_READ, &Handle);
472
473 if (WinStatus != ERROR_SUCCESS)
474 {
475 /*
476 * Somewhere along the way, MS changed the registry entry for
477 * the FADT from
478 * HARDWARE/ACPI/FACP to
479 * HARDWARE/ACPI/FADT.
480 *
481 * This code allows for both.
482 */
483 if (ACPI_COMPARE_NAMESEG(Signature, "FACP"))
484 {
485 Signature = "FADT";
486 }
487 else if (ACPI_COMPARE_NAMESEG(Signature, "XSDT"))
488 {
489 Signature = "RSDT";
490 }
491 else if (ACPI_COMPARE_NAMESEG(Signature, ACPI_SIG_SSDT))
492 {
493 /*
494 * SSDT may not be present on older Windows versions, but it is
495 * also possible that the index is not found.
496 */
497 return (AE_NOT_FOUND);
498 }
499 else
500 {
501 fprintf(stderr,
502 "Could not find %s in registry at %s: %s (WinStatus=0x%X)\n",
503 Signature, KeyBuffer, WindowsFormatException(WinStatus), WinStatus);
504 return (AE_NOT_FOUND);
505 }
506 }
507 else
508 {
509 break;
510 }
511 }
512
513 /* Actual data for the table is down a couple levels */
514
515 for (i = 0; ;)
516 {
517 WinStatus = RegEnumKey(Handle, i, KeyBuffer, sizeof(KeyBuffer));
518 i++;
519 if (WinStatus == ERROR_NO_MORE_ITEMS)
520 {
521 break;
522 }
523
524 WinStatus = RegOpenKey(Handle, KeyBuffer, &SubKey);
525 if (WinStatus != ERROR_SUCCESS)
526 {
527 fprintf(stderr, "Could not open %s entry: %s\n",
528 Signature, WindowsFormatException(WinStatus));
529 Status = AE_ERROR;
530 goto Cleanup;
531 }
532
533 RegCloseKey(Handle);
534 Handle = SubKey;
535 i = 0;
536 }
537
538 /* Find the (binary) table entry */
539
540 for (i = 0; ; i++)
541 {
542 NameSize = sizeof(KeyBuffer);
543 WinStatus = RegEnumValue(Handle, i, KeyBuffer, &NameSize, NULL,
544 &Type, NULL, 0);
545 if (WinStatus != ERROR_SUCCESS)
546 {
547 fprintf(stderr, "Could not get %s registry entry: %s\n",
548 Signature, WindowsFormatException(WinStatus));
549 Status = AE_ERROR;
550 goto Cleanup;
551 }
552
553 if (Type == REG_BINARY)
554 {
555 break;
556 }
557 }
558
559 /* Get the size of the table */
560
561 WinStatus = RegQueryValueEx(Handle, KeyBuffer, NULL, NULL,
562 NULL, &DataSize);
563 if (WinStatus != ERROR_SUCCESS)
564 {
565 fprintf(stderr, "Could not read the %s table size: %s\n",
566 Signature, WindowsFormatException(WinStatus));
567 Status = AE_ERROR;
568 goto Cleanup;
569 }
570
571 /* Allocate a new buffer for the table */
572
573 ReturnTable = malloc(DataSize);
574 if (!ReturnTable)
575 {
576 Status = AE_NO_MEMORY;
577 goto Cleanup;
578 }
579
580 /* Get the actual table from the registry */
581
582 WinStatus = RegQueryValueEx(Handle, KeyBuffer, NULL, NULL,
583 (UCHAR *)ReturnTable, &DataSize);
584
585 if (WinStatus != ERROR_SUCCESS)
586 {
587 fprintf(stderr, "Could not read %s data: %s\n",
588 Signature, WindowsFormatException(WinStatus));
589 free(ReturnTable);
590 Status = AE_ERROR;
591 goto Cleanup;
592 }
593
594 *Table = ReturnTable;
595 *Address = 0;
596
597 Cleanup:
598 RegCloseKey(Handle);
599 return (Status);
600 }
601
602
603 /******************************************************************************
604 *
605 * FUNCTION: AcpiOsGetTableByName
606 *
607 * PARAMETERS: Signature - ACPI Signature for desired table. Must be
608 * a null terminated 4-character string.
609 * Instance - For SSDTs (0...n). Use 0 otherwise.
610 * Table - Where a pointer to the table is returned
611 * Address - Where the table physical address is returned
612 *
613 * RETURN: Status; Table buffer and physical address returned if AE_OK.
614 * AE_LIMIT: Instance is beyond valid limit
615 * AE_NOT_FOUND: A table with the signature was not found
616 *
617 * DESCRIPTION: Get an ACPI table via a table signature (4 ASCII characters).
618 * Returns AE_LIMIT when an invalid instance is reached.
619 * Table is obtained from the Windows registry.
620 *
621 * NOTE: Assumes the input signature is uppercase.
622 * Cannot get the physical address from the windows registry;
623 * zero is returned instead.
624 *
625 *****************************************************************************/
626
627 ACPI_STATUS
AcpiOsGetTableByName(char * Signature,UINT32 Instance,ACPI_TABLE_HEADER ** Table,ACPI_PHYSICAL_ADDRESS * Address)628 AcpiOsGetTableByName(
629 char *Signature,
630 UINT32 Instance,
631 ACPI_TABLE_HEADER **Table,
632 ACPI_PHYSICAL_ADDRESS *Address)
633 {
634 LONG Result;
635 ACPI_STATUS Status = AE_OK;
636 UINT32 DataSize;
637 ACPI_TABLE_HEADER *ReturnTable;
638 UINT32 UIntSignature = 0;
639
640
641 /* Multiple instances are only supported for SSDT tables. */
642
643 if (Instance > 0 && !ACPI_COMPARE_NAMESEG (Signature, ACPI_SIG_SSDT))
644 {
645 return (AE_LIMIT);
646 }
647
648 if (ACPI_COMPARE_NAMESEG (Signature, ACPI_SIG_SSDT))
649 {
650 Status = WindowsGetTableFromRegistry ("SSDT", Instance, Table, Address);
651 return (Status);
652 }
653
654 /* GetSystemFirmwareTable requires the table signature to be UINT32 */
655
656 UIntSignature = *ACPI_CAST_PTR (UINT32, Signature);
657 DataSize = GetSystemFirmwareTable('ACPI', UIntSignature, NULL, 0);
658 if (!DataSize)
659 {
660 fprintf(stderr, "The table signature %s does not exist.", Signature);
661 return (AE_ERROR);
662 }
663
664 ReturnTable = malloc(DataSize);
665 if (!ReturnTable)
666 {
667 return (AE_NO_MEMORY);
668 }
669
670 Result = GetSystemFirmwareTable('ACPI', UIntSignature, ReturnTable, DataSize);
671 if (Result > (LONG) DataSize)
672 {
673 /* Clean up */
674
675 fprintf (stderr, "Could not read %s data\n", Signature);
676 free (ReturnTable);
677 return (AE_ERROR);
678 }
679
680 *Table = ReturnTable;
681 return (Status);
682 }
683
684
685 /* These are here for acpidump only, so we don't need to link oswinxf */
686
687 #ifdef ACPI_DUMP_APP
688 /******************************************************************************
689 *
690 * FUNCTION: AcpiOsMapMemory
691 *
692 * PARAMETERS: Where - Physical address of memory to be mapped
693 * Length - How much memory to map
694 *
695 * RETURN: Pointer to mapped memory. Null on error.
696 *
697 * DESCRIPTION: Map physical memory into caller's address space
698 *
699 *****************************************************************************/
700
701 void *
AcpiOsMapMemory(ACPI_PHYSICAL_ADDRESS Where,ACPI_SIZE Length)702 AcpiOsMapMemory (
703 ACPI_PHYSICAL_ADDRESS Where,
704 ACPI_SIZE Length)
705 {
706
707 return (ACPI_TO_POINTER ((ACPI_SIZE) Where));
708 }
709
710
711 /******************************************************************************
712 *
713 * FUNCTION: AcpiOsUnmapMemory
714 *
715 * PARAMETERS: Where - Logical address of memory to be unmapped
716 * Length - How much memory to unmap
717 *
718 * RETURN: None.
719 *
720 * DESCRIPTION: Delete a previously created mapping. Where and Length must
721 * correspond to a previous mapping exactly.
722 *
723 *****************************************************************************/
724
725 void
AcpiOsUnmapMemory(void * Where,ACPI_SIZE Length)726 AcpiOsUnmapMemory (
727 void *Where,
728 ACPI_SIZE Length)
729 {
730
731 return;
732 }
733 #endif
734
