sys/contrib/dev/acpica/tbinstal.c

   1 /******************************************************************************
   2  *
   3  * Module Name: tbinstal - ACPI table installation and removal
   4  *              $Revision: 68 $
   5  *
   6  *****************************************************************************/
   7
   8 /******************************************************************************
   9  *
  10  * 1. Copyright Notice
  11  *
  12  * Some or all of this work - Copyright (c) 1999 - 2003, Intel Corp.
  13  * All rights reserved.
  14  *
  15  * 2. License
  16  *
  17  * 2.1. This is your license from Intel Corp. under its intellectual property
  18  * rights.  You may have additional license terms from the party that provided
  19  * you this software, covering your right to use that party's intellectual
  20  * property rights.
  21  *
  22  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  23  * copy of the source code appearing in this file ("Covered Code") an
  24  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  25  * base code distributed originally by Intel ("Original Intel Code") to copy,
  26  * make derivatives, distribute, use and display any portion of the Covered
  27  * Code in any form, with the right to sublicense such rights; and
  28  *
  29  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  30  * license (with the right to sublicense), under only those claims of Intel
  31  * patents that are infringed by the Original Intel Code, to make, use, sell,
  32  * offer to sell, and import the Covered Code and derivative works thereof
  33  * solely to the minimum extent necessary to exercise the above copyright
  34  * license, and in no event shall the patent license extend to any additions
  35  * to or modifications of the Original Intel Code.  No other license or right
  36  * is granted directly or by implication, estoppel or otherwise;
  37  *
  38  * The above copyright and patent license is granted only if the following
  39  * conditions are met:
  40  *
  41  * 3. Conditions
  42  *
  43  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  44  * Redistribution of source code of any substantial portion of the Covered
  45  * Code or modification with rights to further distribute source must include
  46  * the above Copyright Notice, the above License, this list of Conditions,
  47  * and the following Disclaimer and Export Compliance provision.  In addition,
  48  * Licensee must cause all Covered Code to which Licensee contributes to
  49  * contain a file documenting the changes Licensee made to create that Covered
  50  * Code and the date of any change.  Licensee must include in that file the
  51  * documentation of any changes made by any predecessor Licensee.  Licensee
  52  * must include a prominent statement that the modification is derived,
  53  * directly or indirectly, from Original Intel Code.
  54  *
  55  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  56  * Redistribution of source code of any substantial portion of the Covered
  57  * Code or modification without rights to further distribute source must
  58  * include the following Disclaimer and Export Compliance provision in the
  59  * documentation and/or other materials provided with distribution.  In
  60  * addition, Licensee may not authorize further sublicense of source of any
  61  * portion of the Covered Code, and must include terms to the effect that the
  62  * license from Licensee to its licensee is limited to the intellectual
  63  * property embodied in the software Licensee provides to its licensee, and
  64  * not to intellectual property embodied in modifications its licensee may
  65  * make.
  66  *
  67  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  68  * substantial portion of the Covered Code or modification must reproduce the
  69  * above Copyright Notice, and the following Disclaimer and Export Compliance
  70  * provision in the documentation and/or other materials provided with the
  71  * distribution.
  72  *
  73  * 3.4. Intel retains all right, title, and interest in and to the Original
  74  * Intel Code.
  75  *
  76  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  77  * Intel shall be used in advertising or otherwise to promote the sale, use or
  78  * other dealings in products derived from or relating to the Covered Code
  79  * without prior written authorization from Intel.
  80  *
  81  * 4. Disclaimer and Export Compliance
  82  *
  83  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  84  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  85  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  86  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  87  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  88  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  89  * PARTICULAR PURPOSE.
  90  *
  91  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  92  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  93  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  94  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  95  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  96  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  97  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  98  * LIMITED REMEDY.
  99  *
 100  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 101  * software or system incorporating such software without first obtaining any
 102  * required license or other approval from the U. S. Department of Commerce or
 103  * any other agency or department of the United States Government.  In the
 104  * event Licensee exports any such software from the United States or
 105  * re-exports any such software from a foreign destination, Licensee shall
 106  * ensure that the distribution and export/re-export of the software is in
 107  * compliance with all laws, regulations, orders, or other restrictions of the
 108  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 109  * any of its subsidiaries will export/re-export any technical data, process,
 110  * software, or service, directly or indirectly, to any country for which the
 111  * United States government or any agency thereof requires an export license,
 112  * other governmental approval, or letter of assurance, without first obtaining
 113  * such license, approval or letter.
 114  *
 115  *****************************************************************************/
 116 /* $DragonFly: src/sys/contrib/dev/acpica/Attic/tbinstal.c,v 1.1 2003/09/24 03:32:16 drhodus Exp $                                                               */
 117
 118
 119 #define __TBINSTAL_C__
 120
 121 #include "acpi.h"
 122 #include "actables.h"
 123
 124
 125 #define _COMPONENT          ACPI_TABLES
 126         ACPI_MODULE_NAME    ("tbinstal")
 127
 128
 129 /*******************************************************************************
 130  *
 131  * FUNCTION:    AcpiTbMatchSignature
 132  *
 133  * PARAMETERS:  Signature           - Table signature to match
 134  *              TableInfo           - Return data
 135  *
 136  * RETURN:      Status
 137  *
 138  * DESCRIPTION: Compare signature against the list of "ACPI-subsystem-owned"
 139  *              tables (DSDT/FADT/SSDT, etc.) Returns the TableTypeID on match.
 140  *
 141  ******************************************************************************/
 142
 143 ACPI_STATUS
 144 AcpiTbMatchSignature (
 145     char                    *Signature,
 146     ACPI_TABLE_DESC         *TableInfo,
 147     UINT8                   SearchType)
 148 {
 149     ACPI_NATIVE_UINT        i;
 150
 151
 152     ACPI_FUNCTION_TRACE ("TbMatchSignature");
 153
 154
 155     /*
 156      * Search for a signature match among the known table types
 157      */
 158     for (i = 0; i < NUM_ACPI_TABLES; i++)
 159     {
 160         if (!(AcpiGbl_AcpiTableData[i].Flags & SearchType))
 161         {
 162             continue;
 163         }
 164
 165         if (!ACPI_STRNCMP (Signature, AcpiGbl_AcpiTableData[i].Signature,
 166                       AcpiGbl_AcpiTableData[i].SigLength))
 167         {
 168             /* Found a signature match, return index if requested */
 169
 170             if (TableInfo)
 171             {
 172                 TableInfo->Type = (UINT8) i;
 173             }
 174
 175             ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
 176                 "Table [%4.4s] is an ACPI table consumed by the core subsystem\n",
 177                 (char *) AcpiGbl_AcpiTableData[i].Signature));
 178
 179             return_ACPI_STATUS (AE_OK);
 180         }
 181     }
 182
 183     ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
 184         "Table [%4.4s] is not an ACPI table consumed by the core subsystem - ignored\n",
 185         (char *) Signature));
 186
 187     return_ACPI_STATUS (AE_TABLE_NOT_SUPPORTED);
 188 }
 189
 190
 191 /*******************************************************************************
 192  *
 193  * FUNCTION:    AcpiTbInstallTable
 194  *
 195  * PARAMETERS:  TableInfo           - Return value from AcpiTbGetTableBody
 196  *
 197  * RETURN:      Status
 198  *
 199  * DESCRIPTION: Load and validate all tables other than the RSDT.  The RSDT must
 200  *              already be loaded and validated.
 201  *              Install the table into the global data structs.
 202  *
 203  ******************************************************************************/
 204
 205 ACPI_STATUS
 206 AcpiTbInstallTable (
 207     ACPI_TABLE_DESC         *TableInfo)
 208 {
 209     ACPI_STATUS             Status;
 210
 211     ACPI_FUNCTION_TRACE ("TbInstallTable");
 212
 213
 214     /* Lock tables while installing */
 215
 216     Status = AcpiUtAcquireMutex (ACPI_MTX_TABLES);
 217     if (ACPI_FAILURE (Status))
 218     {
 219         ACPI_REPORT_ERROR (("Could not acquire table mutex for [%4.4s], %s\n",
 220             TableInfo->Pointer->Signature, AcpiFormatException (Status)));
 221         return_ACPI_STATUS (Status);
 222     }
 223
 224     /* Install the table into the global data structure */
 225
 226     Status = AcpiTbInitTableDescriptor (TableInfo->Type, TableInfo);
 227     if (ACPI_FAILURE (Status))
 228     {
 229         ACPI_REPORT_ERROR (("Could not install ACPI table [%4.4s], %s\n",
 230             TableInfo->Pointer->Signature, AcpiFormatException (Status)));
 231     }
 232
 233     ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "%s located at %p\n",
 234         AcpiGbl_AcpiTableData[TableInfo->Type].Name, TableInfo->Pointer));
 235
 236     (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
 237     return_ACPI_STATUS (Status);
 238 }
 239
 240
 241 /*******************************************************************************
 242  *
 243  * FUNCTION:    AcpiTbRecognizeTable
 244  *
 245  * PARAMETERS:  TableInfo           - Return value from AcpiTbGetTableBody
 246  *
 247  * RETURN:      Status
 248  *
 249  * DESCRIPTION: Check a table signature for a match against known table types
 250  *
 251  * NOTE:  All table pointers are validated as follows:
 252  *          1) Table pointer must point to valid physical memory
 253  *          2) Signature must be 4 ASCII chars, even if we don't recognize the
 254  *             name
 255  *          3) Table must be readable for length specified in the header
 256  *          4) Table checksum must be valid (with the exception of the FACS
 257  *             which has no checksum for some odd reason)
 258  *
 259  ******************************************************************************/
 260
 261 ACPI_STATUS
 262 AcpiTbRecognizeTable (
 263     ACPI_TABLE_DESC         *TableInfo,
 264     UINT8                   SearchType)
 265 {
 266     ACPI_TABLE_HEADER       *TableHeader;
 267     ACPI_STATUS             Status;
 268
 269
 270     ACPI_FUNCTION_TRACE ("TbRecognizeTable");
 271
 272
 273     /* Ensure that we have a valid table pointer */
 274
 275     TableHeader = (ACPI_TABLE_HEADER *) TableInfo->Pointer;
 276     if (!TableHeader)
 277     {
 278         return_ACPI_STATUS (AE_BAD_PARAMETER);
 279     }
 280
 281     /*
 282      * We only "recognize" a limited number of ACPI tables -- namely, the
 283      * ones that are used by the subsystem (DSDT, FADT, etc.)
 284      *
 285      * An AE_TABLE_NOT_SUPPORTED means that the table was not recognized.
 286      * This can be any one of many valid ACPI tables, it just isn't one of
 287      * the tables that is consumed by the core subsystem
 288      */
 289     Status = AcpiTbMatchSignature (TableHeader->Signature, TableInfo, SearchType);
 290     if (ACPI_FAILURE (Status))
 291     {
 292         return_ACPI_STATUS (Status);
 293     }
 294
 295     Status = AcpiTbValidateTableHeader (TableHeader);
 296     if (ACPI_FAILURE (Status))
 297     {
 298         return_ACPI_STATUS (Status);
 299     }
 300
 301     /* Return the table type and length via the info struct */
 302
 303     TableInfo->Length = (ACPI_SIZE) TableHeader->Length;
 304
 305     return_ACPI_STATUS (Status);
 306 }
 307
 308
 309 /*******************************************************************************
 310  *
 311  * FUNCTION:    AcpiTbInitTableDescriptor
 312  *
 313  * PARAMETERS:  TableType           - The type of the table
 314  *              TableInfo           - A table info struct
 315  *
 316  * RETURN:      None.
 317  *
 318  * DESCRIPTION: Install a table into the global data structs.
 319  *
 320  ******************************************************************************/
 321
 322 ACPI_STATUS
 323 AcpiTbInitTableDescriptor (
 324     ACPI_TABLE_TYPE         TableType,
 325     ACPI_TABLE_DESC         *TableInfo)
 326 {
 327     ACPI_TABLE_DESC         *ListHead;
 328     ACPI_TABLE_DESC         *TableDesc;
 329
 330
 331     ACPI_FUNCTION_TRACE_U32 ("TbInitTableDescriptor", TableType);
 332
 333     /*
 334      * Install the table into the global data structure
 335      */
 336     ListHead    = &AcpiGbl_AcpiTables[TableType];
 337     TableDesc   = ListHead;
 338
 339     /*
 340      * Two major types of tables:  1) Only one instance is allowed.  This
 341      * includes most ACPI tables such as the DSDT.  2) Multiple instances of
 342      * the table are allowed.  This includes SSDT and PSDTs.
 343      */
 344     if (ACPI_IS_SINGLE_TABLE (AcpiGbl_AcpiTableData[TableType].Flags))
 345     {
 346         /*
 347          * Only one table allowed, and a table has alread been installed
 348          *  at this location, so return an error.
 349          */
 350         if (ListHead->Pointer)
 351         {
 352             return_ACPI_STATUS (AE_ALREADY_EXISTS);
 353         }
 354
 355         TableDesc->Count = 1;
 356         TableDesc->Prev = NULL;
 357         TableDesc->Next = NULL;
 358     }
 359     else
 360     {
 361         /*
 362          * Multiple tables allowed for this table type, we must link
 363          * the new table in to the list of tables of this type.
 364          */
 365         if (ListHead->Pointer)
 366         {
 367             TableDesc = ACPI_MEM_CALLOCATE (sizeof (ACPI_TABLE_DESC));
 368             if (!TableDesc)
 369             {
 370                 return_ACPI_STATUS (AE_NO_MEMORY);
 371             }
 372
 373             ListHead->Count++;
 374
 375             /* Update the original previous */
 376
 377             ListHead->Prev->Next = TableDesc;
 378
 379             /* Update new entry */
 380
 381             TableDesc->Prev = ListHead->Prev;
 382             TableDesc->Next = ListHead;
 383
 384             /* Update list head */
 385
 386             ListHead->Prev = TableDesc;
 387         }
 388         else
 389         {
 390             TableDesc->Count = 1;
 391         }
 392     }
 393
 394     /* Common initialization of the table descriptor */
 395
 396     TableDesc->Type                 = TableInfo->Type;
 397     TableDesc->Pointer              = TableInfo->Pointer;
 398     TableDesc->Length               = TableInfo->Length;
 399     TableDesc->Allocation           = TableInfo->Allocation;
 400     TableDesc->AmlStart             = (UINT8 *) (TableDesc->Pointer + 1),
 401     TableDesc->AmlLength            = (UINT32) (TableDesc->Length -
 402                                         (UINT32) sizeof (ACPI_TABLE_HEADER));
 403     TableDesc->TableId              = AcpiUtAllocateOwnerId (ACPI_OWNER_TYPE_TABLE);
 404     TableDesc->LoadedIntoNamespace  = FALSE;
 405
 406     /*
 407      * Set the appropriate global pointer (if there is one) to point to the
 408      * newly installed table
 409      */
 410     if (AcpiGbl_AcpiTableData[TableType].GlobalPtr)
 411     {
 412         *(AcpiGbl_AcpiTableData[TableType].GlobalPtr) = TableInfo->Pointer;
 413     }
 414
 415     /* Return Data */
 416
 417     TableInfo->TableId          = TableDesc->TableId;
 418     TableInfo->InstalledDesc    = TableDesc;
 419
 420     return_ACPI_STATUS (AE_OK);
 421 }
 422
 423
 424 /*******************************************************************************
 425  *
 426  * FUNCTION:    AcpiTbDeleteAcpiTables
 427  *
 428  * PARAMETERS:  None.
 429  *
 430  * RETURN:      None.
 431  *
 432  * DESCRIPTION: Delete all internal ACPI tables
 433  *
 434  ******************************************************************************/
 435
 436 void
 437 AcpiTbDeleteAcpiTables (void)
 438 {
 439     ACPI_TABLE_TYPE             Type;
 440
 441
 442     /*
 443      * Free memory allocated for ACPI tables
 444      * Memory can either be mapped or allocated
 445      */
 446     for (Type = 0; Type < NUM_ACPI_TABLES; Type++)
 447     {
 448         AcpiTbDeleteAcpiTable (Type);
 449     }
 450 }
 451
 452
 453 /*******************************************************************************
 454  *
 455  * FUNCTION:    AcpiTbDeleteAcpiTable
 456  *
 457  * PARAMETERS:  Type                - The table type to be deleted
 458  *
 459  * RETURN:      None.
 460  *
 461  * DESCRIPTION: Delete an internal ACPI table
 462  *              Locks the ACPI table mutex
 463  *
 464  ******************************************************************************/
 465
 466 void
 467 AcpiTbDeleteAcpiTable (
 468     ACPI_TABLE_TYPE             Type)
 469 {
 470
 471     ACPI_FUNCTION_TRACE_U32 ("TbDeleteAcpiTable", Type);
 472
 473
 474     if (Type > ACPI_TABLE_MAX)
 475     {
 476         return_VOID;
 477     }
 478
 479     if (ACPI_FAILURE (AcpiUtAcquireMutex (ACPI_MTX_TABLES)))
 480     {
 481         return;
 482     }
 483
 484     /* Clear the appropriate "typed" global table pointer */
 485
 486     switch (Type)
 487     {
 488     case ACPI_TABLE_RSDP:
 489         AcpiGbl_RSDP = NULL;
 490         break;
 491
 492     case ACPI_TABLE_DSDT:
 493         AcpiGbl_DSDT = NULL;
 494         break;
 495
 496     case ACPI_TABLE_FADT:
 497         AcpiGbl_FADT = NULL;
 498         break;
 499
 500     case ACPI_TABLE_FACS:
 501         AcpiGbl_FACS = NULL;
 502         break;
 503
 504     case ACPI_TABLE_XSDT:
 505         AcpiGbl_XSDT = NULL;
 506         break;
 507
 508     case ACPI_TABLE_SSDT:
 509     case ACPI_TABLE_PSDT:
 510     default:
 511         break;
 512     }
 513
 514     /* Free the table */
 515
 516     AcpiTbFreeAcpiTablesOfType (&AcpiGbl_AcpiTables[Type]);
 517
 518     (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
 519     return_VOID;
 520 }
 521
 522
 523 /*******************************************************************************
 524  *
 525  * FUNCTION:    AcpiTbFreeAcpiTablesOfType
 526  *
 527  * PARAMETERS:  TableInfo           - A table info struct
 528  *
 529  * RETURN:      None.
 530  *
 531  * DESCRIPTION: Free the memory associated with an internal ACPI table
 532  *              Table mutex should be locked.
 533  *
 534  ******************************************************************************/
 535
 536 void
 537 AcpiTbFreeAcpiTablesOfType (
 538     ACPI_TABLE_DESC         *ListHead)
 539 {
 540     ACPI_TABLE_DESC         *TableDesc;
 541     UINT32                  Count;
 542     UINT32                  i;
 543
 544
 545     ACPI_FUNCTION_TRACE_PTR ("TbFreeAcpiTablesOfType", ListHead);
 546
 547
 548     /* Get the head of the list */
 549
 550     TableDesc   = ListHead;
 551     Count       = ListHead->Count;
 552
 553     /*
 554      * Walk the entire list, deleting both the allocated tables
 555      * and the table descriptors
 556      */
 557     for (i = 0; i < Count; i++)
 558     {
 559         TableDesc = AcpiTbUninstallTable (TableDesc);
 560     }
 561
 562     return_VOID;
 563 }
 564
 565
 566 /*******************************************************************************
 567  *
 568  * FUNCTION:    AcpiTbDeleteSingleTable
 569  *
 570  * PARAMETERS:  TableInfo           - A table info struct
 571  *
 572  * RETURN:      None.
 573  *
 574  * DESCRIPTION: Low-level free for a single ACPI table.  Handles cases where
 575  *              the table was allocated a buffer or was mapped.
 576  *
 577  ******************************************************************************/
 578
 579 void
 580 AcpiTbDeleteSingleTable (
 581     ACPI_TABLE_DESC         *TableDesc)
 582 {
 583
 584     if (!TableDesc)
 585     {
 586         return;
 587     }
 588
 589     if (TableDesc->Pointer)
 590     {
 591         /* Valid table, determine type of memory allocation */
 592
 593         switch (TableDesc->Allocation)
 594         {
 595         case ACPI_MEM_NOT_ALLOCATED:
 596             break;
 597
 598         case ACPI_MEM_ALLOCATED:
 599
 600             ACPI_MEM_FREE (TableDesc->Pointer);
 601             break;
 602
 603         case ACPI_MEM_MAPPED:
 604
 605             AcpiOsUnmapMemory (TableDesc->Pointer, TableDesc->Length);
 606             break;
 607
 608         default:
 609             break;
 610         }
 611     }
 612 }
 613
 614
 615 /*******************************************************************************
 616  *
 617  * FUNCTION:    AcpiTbUninstallTable
 618  *
 619  * PARAMETERS:  TableInfo           - A table info struct
 620  *
 621  * RETURN:      Pointer to the next table in the list (of same type)
 622  *
 623  * DESCRIPTION: Free the memory associated with an internal ACPI table that
 624  *              is either installed or has never been installed.
 625  *              Table mutex should be locked.
 626  *
 627  ******************************************************************************/
 628
 629 ACPI_TABLE_DESC *
 630 AcpiTbUninstallTable (
 631     ACPI_TABLE_DESC         *TableDesc)
 632 {
 633     ACPI_TABLE_DESC         *NextDesc;
 634
 635
 636     ACPI_FUNCTION_TRACE_PTR ("AcpiTbUninstallTable", TableDesc);
 637
 638
 639     if (!TableDesc)
 640     {
 641         return_PTR (NULL);
 642     }
 643
 644     /* Unlink the descriptor */
 645
 646     if (TableDesc->Prev)
 647     {
 648         TableDesc->Prev->Next = TableDesc->Next;
 649     }
 650
 651     if (TableDesc->Next)
 652     {
 653         TableDesc->Next->Prev = TableDesc->Prev;
 654     }
 655
 656     /* Free the memory allocated for the table itself */
 657
 658     AcpiTbDeleteSingleTable (TableDesc);
 659
 660     /* Free the table descriptor (Don't delete the list head, tho) */
 661
 662     if ((TableDesc->Prev) == (TableDesc->Next))
 663     {
 664         NextDesc = NULL;
 665
 666         /* Clear the list head */
 667
 668         TableDesc->Pointer   = NULL;
 669         TableDesc->Length    = 0;
 670         TableDesc->Count     = 0;
 671     }
 672     else
 673     {
 674         /* Free the table descriptor */
 675
 676         NextDesc = TableDesc->Next;
 677         ACPI_MEM_FREE (TableDesc);
 678     }
 679
 680     return_PTR (NextDesc);
 681 }
 682
 683