Annotation of src/sys/external/bsd/acpica/dist/tables/tbdata.c, Revision 1.2.2.4
1.1 christos 1: /******************************************************************************
2: *
3: * Module Name: tbdata - Table manager data structure functions
4: *
5: *****************************************************************************/
6:
7: /*
1.2.2.3 skrll 8: * Copyright (C) 2000 - 2016, Intel Corp.
1.1 christos 9: * All rights reserved.
10: *
11: * Redistribution and use in source and binary forms, with or without
12: * modification, are permitted provided that the following conditions
13: * are met:
14: * 1. Redistributions of source code must retain the above copyright
15: * notice, this list of conditions, and the following disclaimer,
16: * without modification.
17: * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18: * substantially similar to the "NO WARRANTY" disclaimer below
19: * ("Disclaimer") and any redistribution must be conditioned upon
20: * including a substantially similar Disclaimer requirement for further
21: * binary redistribution.
22: * 3. Neither the names of the above-listed copyright holders nor the names
23: * of any contributors may be used to endorse or promote products derived
24: * from this software without specific prior written permission.
25: *
26: * Alternatively, this software may be distributed under the terms of the
27: * GNU General Public License ("GPL") version 2 as published by the Free
28: * Software Foundation.
29: *
30: * NO WARRANTY
31: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32: * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33: * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34: * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35: * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40: * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41: * POSSIBILITY OF SUCH DAMAGES.
42: */
43:
44: #include "acpi.h"
45: #include "accommon.h"
46: #include "acnamesp.h"
47: #include "actables.h"
48:
49: #define _COMPONENT ACPI_TABLES
50: ACPI_MODULE_NAME ("tbdata")
51:
52:
53: /*******************************************************************************
54: *
55: * FUNCTION: AcpiTbInitTableDescriptor
56: *
57: * PARAMETERS: TableDesc - Table descriptor
58: * Address - Physical address of the table
59: * Flags - Allocation flags of the table
60: * Table - Pointer to the table
61: *
62: * RETURN: None
63: *
64: * DESCRIPTION: Initialize a new table descriptor
65: *
66: ******************************************************************************/
67:
68: void
69: AcpiTbInitTableDescriptor (
70: ACPI_TABLE_DESC *TableDesc,
71: ACPI_PHYSICAL_ADDRESS Address,
72: UINT8 Flags,
73: ACPI_TABLE_HEADER *Table)
74: {
75:
76: /*
77: * Initialize the table descriptor. Set the pointer to NULL, since the
78: * table is not fully mapped at this time.
79: */
1.2.2.2 skrll 80: memset (TableDesc, 0, sizeof (ACPI_TABLE_DESC));
1.1 christos 81: TableDesc->Address = Address;
82: TableDesc->Length = Table->Length;
83: TableDesc->Flags = Flags;
84: ACPI_MOVE_32_TO_32 (TableDesc->Signature.Ascii, Table->Signature);
85: }
86:
87:
88: /*******************************************************************************
89: *
90: * FUNCTION: AcpiTbAcquireTable
91: *
92: * PARAMETERS: TableDesc - Table descriptor
93: * TablePtr - Where table is returned
94: * TableLength - Where table length is returned
95: * TableFlags - Where table allocation flags are returned
96: *
97: * RETURN: Status
98: *
99: * DESCRIPTION: Acquire an ACPI table. It can be used for tables not
100: * maintained in the AcpiGbl_RootTableList.
101: *
102: ******************************************************************************/
103:
104: ACPI_STATUS
105: AcpiTbAcquireTable (
106: ACPI_TABLE_DESC *TableDesc,
107: ACPI_TABLE_HEADER **TablePtr,
108: UINT32 *TableLength,
109: UINT8 *TableFlags)
110: {
111: ACPI_TABLE_HEADER *Table = NULL;
112:
113:
114: switch (TableDesc->Flags & ACPI_TABLE_ORIGIN_MASK)
115: {
116: case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL:
117:
118: Table = AcpiOsMapMemory (TableDesc->Address, TableDesc->Length);
119: break;
120:
121: case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL:
122: case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL:
123:
1.2.2.1 skrll 124: Table = ACPI_CAST_PTR (ACPI_TABLE_HEADER,
1.2.2.3 skrll 125: ACPI_PHYSADDR_TO_PTR (TableDesc->Address));
1.1 christos 126: break;
127:
128: default:
129:
130: break;
131: }
132:
133: /* Table is not valid yet */
134:
135: if (!Table)
136: {
137: return (AE_NO_MEMORY);
138: }
139:
140: /* Fill the return values */
141:
142: *TablePtr = Table;
143: *TableLength = TableDesc->Length;
144: *TableFlags = TableDesc->Flags;
145: return (AE_OK);
146: }
147:
148:
149: /*******************************************************************************
150: *
151: * FUNCTION: AcpiTbReleaseTable
152: *
153: * PARAMETERS: Table - Pointer for the table
154: * TableLength - Length for the table
155: * TableFlags - Allocation flags for the table
156: *
157: * RETURN: None
158: *
159: * DESCRIPTION: Release a table. The inverse of AcpiTbAcquireTable().
160: *
161: ******************************************************************************/
162:
163: void
164: AcpiTbReleaseTable (
165: ACPI_TABLE_HEADER *Table,
166: UINT32 TableLength,
167: UINT8 TableFlags)
168: {
169:
170: switch (TableFlags & ACPI_TABLE_ORIGIN_MASK)
171: {
172: case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL:
173:
174: AcpiOsUnmapMemory (Table, TableLength);
175: break;
176:
177: case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL:
178: case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL:
179: default:
180:
181: break;
182: }
183: }
184:
185:
186: /*******************************************************************************
187: *
188: * FUNCTION: AcpiTbAcquireTempTable
189: *
190: * PARAMETERS: TableDesc - Table descriptor to be acquired
191: * Address - Address of the table
192: * Flags - Allocation flags of the table
193: *
194: * RETURN: Status
195: *
196: * DESCRIPTION: This function validates the table header to obtain the length
197: * of a table and fills the table descriptor to make its state as
198: * "INSTALLED". Such a table descriptor is only used for verified
199: * installation.
200: *
201: ******************************************************************************/
202:
203: ACPI_STATUS
204: AcpiTbAcquireTempTable (
205: ACPI_TABLE_DESC *TableDesc,
206: ACPI_PHYSICAL_ADDRESS Address,
207: UINT8 Flags)
208: {
209: ACPI_TABLE_HEADER *TableHeader;
210:
211:
212: switch (Flags & ACPI_TABLE_ORIGIN_MASK)
213: {
214: case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL:
215:
216: /* Get the length of the full table from the header */
217:
218: TableHeader = AcpiOsMapMemory (Address, sizeof (ACPI_TABLE_HEADER));
219: if (!TableHeader)
220: {
221: return (AE_NO_MEMORY);
222: }
223:
224: AcpiTbInitTableDescriptor (TableDesc, Address, Flags, TableHeader);
225: AcpiOsUnmapMemory (TableHeader, sizeof (ACPI_TABLE_HEADER));
226: return (AE_OK);
227:
228: case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL:
229: case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL:
230:
1.2.2.1 skrll 231: TableHeader = ACPI_CAST_PTR (ACPI_TABLE_HEADER,
1.2.2.3 skrll 232: ACPI_PHYSADDR_TO_PTR (Address));
1.1 christos 233: if (!TableHeader)
234: {
235: return (AE_NO_MEMORY);
236: }
237:
238: AcpiTbInitTableDescriptor (TableDesc, Address, Flags, TableHeader);
239: return (AE_OK);
240:
241: default:
242:
243: break;
244: }
245:
246: /* Table is not valid yet */
247:
248: return (AE_NO_MEMORY);
249: }
250:
251:
252: /*******************************************************************************
253: *
254: * FUNCTION: AcpiTbReleaseTempTable
255: *
256: * PARAMETERS: TableDesc - Table descriptor to be released
257: *
258: * RETURN: Status
259: *
260: * DESCRIPTION: The inverse of AcpiTbAcquireTempTable().
261: *
262: *****************************************************************************/
263:
264: void
265: AcpiTbReleaseTempTable (
266: ACPI_TABLE_DESC *TableDesc)
267: {
268:
269: /*
270: * Note that the .Address is maintained by the callers of
271: * AcpiTbAcquireTempTable(), thus do not invoke AcpiTbUninstallTable()
272: * where .Address will be freed.
273: */
274: AcpiTbInvalidateTable (TableDesc);
275: }
276:
277:
278: /******************************************************************************
279: *
280: * FUNCTION: AcpiTbValidateTable
281: *
282: * PARAMETERS: TableDesc - Table descriptor
283: *
284: * RETURN: Status
285: *
286: * DESCRIPTION: This function is called to validate the table, the returned
287: * table descriptor is in "VALIDATED" state.
288: *
289: *****************************************************************************/
290:
291: ACPI_STATUS
292: AcpiTbValidateTable (
293: ACPI_TABLE_DESC *TableDesc)
294: {
295: ACPI_STATUS Status = AE_OK;
296:
297:
298: ACPI_FUNCTION_TRACE (TbValidateTable);
299:
300:
301: /* Validate the table if necessary */
302:
303: if (!TableDesc->Pointer)
304: {
305: Status = AcpiTbAcquireTable (TableDesc, &TableDesc->Pointer,
1.2.2.3 skrll 306: &TableDesc->Length, &TableDesc->Flags);
1.1 christos 307: if (!TableDesc->Pointer)
308: {
309: Status = AE_NO_MEMORY;
310: }
311: }
312:
313: return_ACPI_STATUS (Status);
314: }
315:
316:
317: /*******************************************************************************
318: *
319: * FUNCTION: AcpiTbInvalidateTable
320: *
321: * PARAMETERS: TableDesc - Table descriptor
322: *
323: * RETURN: None
324: *
325: * DESCRIPTION: Invalidate one internal ACPI table, this is the inverse of
326: * AcpiTbValidateTable().
327: *
328: ******************************************************************************/
329:
330: void
331: AcpiTbInvalidateTable (
332: ACPI_TABLE_DESC *TableDesc)
333: {
334:
335: ACPI_FUNCTION_TRACE (TbInvalidateTable);
336:
337:
338: /* Table must be validated */
339:
340: if (!TableDesc->Pointer)
341: {
342: return_VOID;
343: }
344:
345: AcpiTbReleaseTable (TableDesc->Pointer, TableDesc->Length,
346: TableDesc->Flags);
347: TableDesc->Pointer = NULL;
348:
349: return_VOID;
350: }
351:
352:
353: /******************************************************************************
354: *
355: * FUNCTION: AcpiTbValidateTempTable
356: *
357: * PARAMETERS: TableDesc - Table descriptor
358: *
359: * RETURN: Status
360: *
361: * DESCRIPTION: This function is called to validate the table, the returned
362: * table descriptor is in "VALIDATED" state.
363: *
364: *****************************************************************************/
365:
366: ACPI_STATUS
367: AcpiTbValidateTempTable (
368: ACPI_TABLE_DESC *TableDesc)
369: {
370:
371: if (!TableDesc->Pointer && !AcpiGbl_VerifyTableChecksum)
372: {
373: /*
374: * Only validates the header of the table.
375: * Note that Length contains the size of the mapping after invoking
376: * this work around, this value is required by
377: * AcpiTbReleaseTempTable().
378: * We can do this because in AcpiInitTableDescriptor(), the Length
379: * field of the installed descriptor is filled with the actual
380: * table length obtaining from the table header.
381: */
382: TableDesc->Length = sizeof (ACPI_TABLE_HEADER);
383: }
384:
385: return (AcpiTbValidateTable (TableDesc));
386: }
387:
388:
389: /******************************************************************************
390: *
391: * FUNCTION: AcpiTbVerifyTempTable
392: *
393: * PARAMETERS: TableDesc - Table descriptor
394: * Signature - Table signature to verify
395: *
396: * RETURN: Status
397: *
398: * DESCRIPTION: This function is called to validate and verify the table, the
399: * returned table descriptor is in "VALIDATED" state.
400: *
401: *****************************************************************************/
402:
403: ACPI_STATUS
404: AcpiTbVerifyTempTable (
405: ACPI_TABLE_DESC *TableDesc,
1.2 christos 406: const char *Signature)
1.1 christos 407: {
408: ACPI_STATUS Status = AE_OK;
409:
410:
411: ACPI_FUNCTION_TRACE (TbVerifyTempTable);
412:
413:
414: /* Validate the table */
415:
416: Status = AcpiTbValidateTempTable (TableDesc);
417: if (ACPI_FAILURE (Status))
418: {
419: return_ACPI_STATUS (AE_NO_MEMORY);
420: }
421:
422: /* If a particular signature is expected (DSDT/FACS), it must match */
423:
424: if (Signature &&
425: !ACPI_COMPARE_NAME (&TableDesc->Signature, Signature))
426: {
427: ACPI_BIOS_ERROR ((AE_INFO,
428: "Invalid signature 0x%X for ACPI table, expected [%s]",
429: TableDesc->Signature.Integer, Signature));
430: Status = AE_BAD_SIGNATURE;
431: goto InvalidateAndExit;
432: }
433:
434: /* Verify the checksum */
435:
436: if (AcpiGbl_VerifyTableChecksum)
437: {
438: Status = AcpiTbVerifyChecksum (TableDesc->Pointer, TableDesc->Length);
439: if (ACPI_FAILURE (Status))
440: {
441: ACPI_EXCEPTION ((AE_INFO, AE_NO_MEMORY,
1.2.2.1 skrll 442: "%4.4s 0x%8.8X%8.8X"
1.1 christos 443: " Attempted table install failed",
1.2.2.4 ! skrll 444: AcpiUtValidNameseg (TableDesc->Signature.Ascii) ?
1.1 christos 445: TableDesc->Signature.Ascii : "????",
1.2.2.1 skrll 446: ACPI_FORMAT_UINT64 (TableDesc->Address)));
1.2.2.3 skrll 447:
1.1 christos 448: goto InvalidateAndExit;
449: }
450: }
451:
452: return_ACPI_STATUS (AE_OK);
453:
454: InvalidateAndExit:
455: AcpiTbInvalidateTable (TableDesc);
456: return_ACPI_STATUS (Status);
457: }
458:
459:
460: /*******************************************************************************
461: *
462: * FUNCTION: AcpiTbResizeRootTableList
463: *
464: * PARAMETERS: None
465: *
466: * RETURN: Status
467: *
468: * DESCRIPTION: Expand the size of global table array
469: *
470: ******************************************************************************/
471:
472: ACPI_STATUS
473: AcpiTbResizeRootTableList (
474: void)
475: {
476: ACPI_TABLE_DESC *Tables;
477: UINT32 TableCount;
478:
479:
480: ACPI_FUNCTION_TRACE (TbResizeRootTableList);
481:
482:
483: /* AllowResize flag is a parameter to AcpiInitializeTables */
484:
485: if (!(AcpiGbl_RootTableList.Flags & ACPI_ROOT_ALLOW_RESIZE))
486: {
487: ACPI_ERROR ((AE_INFO, "Resize of Root Table Array is not allowed"));
488: return_ACPI_STATUS (AE_SUPPORT);
489: }
490:
491: /* Increase the Table Array size */
492:
493: if (AcpiGbl_RootTableList.Flags & ACPI_ROOT_ORIGIN_ALLOCATED)
494: {
495: TableCount = AcpiGbl_RootTableList.MaxTableCount;
496: }
497: else
498: {
499: TableCount = AcpiGbl_RootTableList.CurrentTableCount;
500: }
501:
502: Tables = ACPI_ALLOCATE_ZEROED (
503: ((ACPI_SIZE) TableCount + ACPI_ROOT_TABLE_SIZE_INCREMENT) *
504: sizeof (ACPI_TABLE_DESC));
505: if (!Tables)
506: {
507: ACPI_ERROR ((AE_INFO, "Could not allocate new root table array"));
508: return_ACPI_STATUS (AE_NO_MEMORY);
509: }
510:
511: /* Copy and free the previous table array */
512:
513: if (AcpiGbl_RootTableList.Tables)
514: {
1.2.2.2 skrll 515: memcpy (Tables, AcpiGbl_RootTableList.Tables,
1.1 christos 516: (ACPI_SIZE) TableCount * sizeof (ACPI_TABLE_DESC));
517:
518: if (AcpiGbl_RootTableList.Flags & ACPI_ROOT_ORIGIN_ALLOCATED)
519: {
520: ACPI_FREE (AcpiGbl_RootTableList.Tables);
521: }
522: }
523:
524: AcpiGbl_RootTableList.Tables = Tables;
525: AcpiGbl_RootTableList.MaxTableCount =
526: TableCount + ACPI_ROOT_TABLE_SIZE_INCREMENT;
527: AcpiGbl_RootTableList.Flags |= ACPI_ROOT_ORIGIN_ALLOCATED;
528:
529: return_ACPI_STATUS (AE_OK);
530: }
531:
532:
533: /*******************************************************************************
534: *
1.2.2.1 skrll 535: * FUNCTION: AcpiTbGetNextTableDescriptor
1.1 christos 536: *
537: * PARAMETERS: TableIndex - Where table index is returned
1.2.2.1 skrll 538: * TableDesc - Where table descriptor is returned
1.1 christos 539: *
1.2.2.1 skrll 540: * RETURN: Status and table index/descriptor.
1.1 christos 541: *
542: * DESCRIPTION: Allocate a new ACPI table entry to the global table list
543: *
544: ******************************************************************************/
545:
546: ACPI_STATUS
1.2.2.1 skrll 547: AcpiTbGetNextTableDescriptor (
548: UINT32 *TableIndex,
549: ACPI_TABLE_DESC **TableDesc)
1.1 christos 550: {
551: ACPI_STATUS Status;
1.2.2.1 skrll 552: UINT32 i;
1.1 christos 553:
554:
555: /* Ensure that there is room for the table in the Root Table List */
556:
557: if (AcpiGbl_RootTableList.CurrentTableCount >=
558: AcpiGbl_RootTableList.MaxTableCount)
559: {
560: Status = AcpiTbResizeRootTableList();
561: if (ACPI_FAILURE (Status))
562: {
563: return (Status);
564: }
565: }
566:
1.2.2.1 skrll 567: i = AcpiGbl_RootTableList.CurrentTableCount;
1.1 christos 568: AcpiGbl_RootTableList.CurrentTableCount++;
1.2.2.1 skrll 569:
570: if (TableIndex)
571: {
572: *TableIndex = i;
573: }
574: if (TableDesc)
575: {
576: *TableDesc = &AcpiGbl_RootTableList.Tables[i];
577: }
578:
1.1 christos 579: return (AE_OK);
580: }
581:
582:
583: /*******************************************************************************
584: *
585: * FUNCTION: AcpiTbTerminate
586: *
587: * PARAMETERS: None
588: *
589: * RETURN: None
590: *
591: * DESCRIPTION: Delete all internal ACPI tables
592: *
593: ******************************************************************************/
594:
595: void
596: AcpiTbTerminate (
597: void)
598: {
599: UINT32 i;
600:
601:
602: ACPI_FUNCTION_TRACE (TbTerminate);
603:
604:
605: (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
606:
607: /* Delete the individual tables */
608:
609: for (i = 0; i < AcpiGbl_RootTableList.CurrentTableCount; i++)
610: {
611: AcpiTbUninstallTable (&AcpiGbl_RootTableList.Tables[i]);
612: }
613:
614: /*
615: * Delete the root table array if allocated locally. Array cannot be
616: * mapped, so we don't need to check for that flag.
617: */
618: if (AcpiGbl_RootTableList.Flags & ACPI_ROOT_ORIGIN_ALLOCATED)
619: {
620: ACPI_FREE (AcpiGbl_RootTableList.Tables);
621: }
622:
623: AcpiGbl_RootTableList.Tables = NULL;
624: AcpiGbl_RootTableList.Flags = 0;
625: AcpiGbl_RootTableList.CurrentTableCount = 0;
626:
627: ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "ACPI Tables freed\n"));
628:
629: (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
630: return_VOID;
631: }
632:
633:
634: /*******************************************************************************
635: *
636: * FUNCTION: AcpiTbDeleteNamespaceByOwner
637: *
638: * PARAMETERS: TableIndex - Table index
639: *
640: * RETURN: Status
641: *
642: * DESCRIPTION: Delete all namespace objects created when this table was loaded.
643: *
644: ******************************************************************************/
645:
646: ACPI_STATUS
647: AcpiTbDeleteNamespaceByOwner (
648: UINT32 TableIndex)
649: {
650: ACPI_OWNER_ID OwnerId;
651: ACPI_STATUS Status;
652:
653:
654: ACPI_FUNCTION_TRACE (TbDeleteNamespaceByOwner);
655:
656:
657: Status = AcpiUtAcquireMutex (ACPI_MTX_TABLES);
658: if (ACPI_FAILURE (Status))
659: {
660: return_ACPI_STATUS (Status);
661: }
662:
663: if (TableIndex >= AcpiGbl_RootTableList.CurrentTableCount)
664: {
665: /* The table index does not exist */
666:
667: (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
668: return_ACPI_STATUS (AE_NOT_EXIST);
669: }
670:
671: /* Get the owner ID for this table, used to delete namespace nodes */
672:
673: OwnerId = AcpiGbl_RootTableList.Tables[TableIndex].OwnerId;
674: (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
675:
676: /*
677: * Need to acquire the namespace writer lock to prevent interference
678: * with any concurrent namespace walks. The interpreter must be
679: * released during the deletion since the acquisition of the deletion
680: * lock may block, and also since the execution of a namespace walk
681: * must be allowed to use the interpreter.
682: */
683: (void) AcpiUtReleaseMutex (ACPI_MTX_INTERPRETER);
684: Status = AcpiUtAcquireWriteLock (&AcpiGbl_NamespaceRwLock);
685:
686: AcpiNsDeleteNamespaceByOwner (OwnerId);
687: if (ACPI_FAILURE (Status))
688: {
689: return_ACPI_STATUS (Status);
690: }
691:
692: AcpiUtReleaseWriteLock (&AcpiGbl_NamespaceRwLock);
693:
694: Status = AcpiUtAcquireMutex (ACPI_MTX_INTERPRETER);
695: return_ACPI_STATUS (Status);
696: }
697:
698:
699: /*******************************************************************************
700: *
701: * FUNCTION: AcpiTbAllocateOwnerId
702: *
703: * PARAMETERS: TableIndex - Table index
704: *
705: * RETURN: Status
706: *
707: * DESCRIPTION: Allocates OwnerId in TableDesc
708: *
709: ******************************************************************************/
710:
711: ACPI_STATUS
712: AcpiTbAllocateOwnerId (
713: UINT32 TableIndex)
714: {
715: ACPI_STATUS Status = AE_BAD_PARAMETER;
716:
717:
718: ACPI_FUNCTION_TRACE (TbAllocateOwnerId);
719:
720:
721: (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
722: if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount)
723: {
724: Status = AcpiUtAllocateOwnerId (
1.2.2.3 skrll 725: &(AcpiGbl_RootTableList.Tables[TableIndex].OwnerId));
1.1 christos 726: }
727:
728: (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
729: return_ACPI_STATUS (Status);
730: }
731:
732:
733: /*******************************************************************************
734: *
735: * FUNCTION: AcpiTbReleaseOwnerId
736: *
737: * PARAMETERS: TableIndex - Table index
738: *
739: * RETURN: Status
740: *
741: * DESCRIPTION: Releases OwnerId in TableDesc
742: *
743: ******************************************************************************/
744:
745: ACPI_STATUS
746: AcpiTbReleaseOwnerId (
747: UINT32 TableIndex)
748: {
749: ACPI_STATUS Status = AE_BAD_PARAMETER;
750:
751:
752: ACPI_FUNCTION_TRACE (TbReleaseOwnerId);
753:
754:
755: (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
756: if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount)
757: {
758: AcpiUtReleaseOwnerId (
759: &(AcpiGbl_RootTableList.Tables[TableIndex].OwnerId));
760: Status = AE_OK;
761: }
762:
763: (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
764: return_ACPI_STATUS (Status);
765: }
766:
767:
768: /*******************************************************************************
769: *
770: * FUNCTION: AcpiTbGetOwnerId
771: *
772: * PARAMETERS: TableIndex - Table index
773: * OwnerId - Where the table OwnerId is returned
774: *
775: * RETURN: Status
776: *
777: * DESCRIPTION: returns OwnerId for the ACPI table
778: *
779: ******************************************************************************/
780:
781: ACPI_STATUS
782: AcpiTbGetOwnerId (
783: UINT32 TableIndex,
784: ACPI_OWNER_ID *OwnerId)
785: {
786: ACPI_STATUS Status = AE_BAD_PARAMETER;
787:
788:
789: ACPI_FUNCTION_TRACE (TbGetOwnerId);
790:
791:
792: (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
793: if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount)
794: {
795: *OwnerId = AcpiGbl_RootTableList.Tables[TableIndex].OwnerId;
796: Status = AE_OK;
797: }
798:
799: (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
800: return_ACPI_STATUS (Status);
801: }
802:
803:
804: /*******************************************************************************
805: *
806: * FUNCTION: AcpiTbIsTableLoaded
807: *
808: * PARAMETERS: TableIndex - Index into the root table
809: *
810: * RETURN: Table Loaded Flag
811: *
812: ******************************************************************************/
813:
814: BOOLEAN
815: AcpiTbIsTableLoaded (
816: UINT32 TableIndex)
817: {
818: BOOLEAN IsLoaded = FALSE;
819:
820:
821: (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
822: if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount)
823: {
824: IsLoaded = (BOOLEAN)
825: (AcpiGbl_RootTableList.Tables[TableIndex].Flags &
826: ACPI_TABLE_IS_LOADED);
827: }
828:
829: (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
830: return (IsLoaded);
831: }
832:
833:
834: /*******************************************************************************
835: *
836: * FUNCTION: AcpiTbSetTableLoadedFlag
837: *
838: * PARAMETERS: TableIndex - Table index
839: * IsLoaded - TRUE if table is loaded, FALSE otherwise
840: *
841: * RETURN: None
842: *
843: * DESCRIPTION: Sets the table loaded flag to either TRUE or FALSE.
844: *
845: ******************************************************************************/
846:
847: void
848: AcpiTbSetTableLoadedFlag (
849: UINT32 TableIndex,
850: BOOLEAN IsLoaded)
851: {
852:
853: (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
854: if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount)
855: {
856: if (IsLoaded)
857: {
858: AcpiGbl_RootTableList.Tables[TableIndex].Flags |=
859: ACPI_TABLE_IS_LOADED;
860: }
861: else
862: {
863: AcpiGbl_RootTableList.Tables[TableIndex].Flags &=
864: ~ACPI_TABLE_IS_LOADED;
865: }
866: }
867:
868: (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
869: }
CVSweb <webmaster@jp.NetBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to tbdata.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [cvs.NetBSD.org] / src / sys / external / bsd / acpica / dist / tables