sys/contrib/dev/acpica/nsinit.c

   1 /******************************************************************************
   2  *
   3  * Module Name: nsinit - namespace initialization
   4  *              $Revision: 1.68 $
   5  *
   6  *****************************************************************************/
   7
   8 /******************************************************************************
   9  *
  10  * 1. Copyright Notice
  11  *
  12  * Some or all of this work - Copyright (c) 1999 - 2005, 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
 117
 118 #define __NSXFINIT_C__
 119
 120 #include <contrib/dev/acpica/acpi.h>
 121 #include <contrib/dev/acpica/acnamesp.h>
 122 #include <contrib/dev/acpica/acdispat.h>
 123 #include <contrib/dev/acpica/acinterp.h>
 124
 125 #define _COMPONENT          ACPI_NAMESPACE
 126         ACPI_MODULE_NAME    ("nsinit")
 127
 128 /* Local prototypes */
 129
 130 static ACPI_STATUS
 131 AcpiNsInitOneObject (
 132     ACPI_HANDLE             ObjHandle,
 133     UINT32                  Level,
 134     void                    *Context,
 135     void                    **ReturnValue);
 136
 137 static ACPI_STATUS
 138 AcpiNsInitOneDevice (
 139     ACPI_HANDLE             ObjHandle,
 140     UINT32                  NestingLevel,
 141     void                    *Context,
 142     void                    **ReturnValue);
 143
 144
 145 /*******************************************************************************
 146  *
 147  * FUNCTION:    AcpiNsInitializeObjects
 148  *
 149  * PARAMETERS:  None
 150  *
 151  * RETURN:      Status
 152  *
 153  * DESCRIPTION: Walk the entire namespace and perform any necessary
 154  *              initialization on the objects found therein
 155  *
 156  ******************************************************************************/
 157
 158 ACPI_STATUS
 159 AcpiNsInitializeObjects (
 160     void)
 161 {
 162     ACPI_STATUS             Status;
 163     ACPI_INIT_WALK_INFO     Info;
 164
 165
 166     ACPI_FUNCTION_TRACE ("NsInitializeObjects");
 167
 168
 169     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
 170         "**** Starting initialization of namespace objects ****\n"));
 171     ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INIT,
 172         "Completing Region/Field/Buffer/Package initialization:"));
 173
 174     /* Set all init info to zero */
 175
 176     ACPI_MEMSET (&Info, 0, sizeof (ACPI_INIT_WALK_INFO));
 177
 178     /* Walk entire namespace from the supplied root */
 179
 180     Status = AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
 181                                 ACPI_UINT32_MAX, AcpiNsInitOneObject,
 182                                 &Info, NULL);
 183     if (ACPI_FAILURE (Status))
 184     {
 185         ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "WalkNamespace failed! %s\n",
 186             AcpiFormatException (Status)));
 187     }
 188
 189     ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INIT,
 190         "\nInitialized %hd/%hd Regions %hd/%hd Fields %hd/%hd Buffers %hd/%hd Packages (%hd nodes)\n",
 191         Info.OpRegionInit,  Info.OpRegionCount,
 192         Info.FieldInit,     Info.FieldCount,
 193         Info.BufferInit,    Info.BufferCount,
 194         Info.PackageInit,   Info.PackageCount, Info.ObjectCount));
 195
 196     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
 197         "%hd Control Methods found\n", Info.MethodCount));
 198     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
 199         "%hd Op Regions found\n", Info.OpRegionCount));
 200
 201     return_ACPI_STATUS (AE_OK);
 202 }
 203
 204
 205 /*******************************************************************************
 206  *
 207  * FUNCTION:    AcpiNsInitializeDevices
 208  *
 209  * PARAMETERS:  None
 210  *
 211  * RETURN:      ACPI_STATUS
 212  *
 213  * DESCRIPTION: Walk the entire namespace and initialize all ACPI devices.
 214  *              This means running _INI on all present devices.
 215  *
 216  *              Note: We install PCI config space handler on region access,
 217  *              not here.
 218  *
 219  ******************************************************************************/
 220
 221 ACPI_STATUS
 222 AcpiNsInitializeDevices (
 223     void)
 224 {
 225     ACPI_STATUS             Status;
 226     ACPI_DEVICE_WALK_INFO   Info;
 227
 228
 229     ACPI_FUNCTION_TRACE ("NsInitializeDevices");
 230
 231
 232     /* Init counters */
 233
 234     Info.DeviceCount = 0;
 235     Info.Num_STA = 0;
 236     Info.Num_INI = 0;
 237
 238     ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INIT,
 239         "Executing all Device _STA and_INI methods:"));
 240
 241     Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
 242     if (ACPI_FAILURE (Status))
 243     {
 244         return_ACPI_STATUS (Status);
 245     }
 246
 247     /* Walk namespace for all objects */
 248
 249     Status = AcpiNsWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
 250                     ACPI_UINT32_MAX, TRUE, AcpiNsInitOneDevice, &Info, NULL);
 251
 252     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 253
 254     if (ACPI_FAILURE (Status))
 255     {
 256         ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "WalkNamespace failed! %s\n",
 257             AcpiFormatException (Status)));
 258     }
 259
 260     ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INIT,
 261         "\n%hd Devices found containing: %hd _STA, %hd _INI methods\n",
 262         Info.DeviceCount, Info.Num_STA, Info.Num_INI));
 263
 264     return_ACPI_STATUS (Status);
 265 }
 266
 267
 268 /*******************************************************************************
 269  *
 270  * FUNCTION:    AcpiNsInitOneObject
 271  *
 272  * PARAMETERS:  ObjHandle       - Node
 273  *              Level           - Current nesting level
 274  *              Context         - Points to a init info struct
 275  *              ReturnValue     - Not used
 276  *
 277  * RETURN:      Status
 278  *
 279  * DESCRIPTION: Callback from AcpiWalkNamespace.  Invoked for every object
 280  *              within the  namespace.
 281  *
 282  *              Currently, the only objects that require initialization are:
 283  *              1) Methods
 284  *              2) Op Regions
 285  *
 286  ******************************************************************************/
 287
 288 static ACPI_STATUS
 289 AcpiNsInitOneObject (
 290     ACPI_HANDLE             ObjHandle,
 291     UINT32                  Level,
 292     void                    *Context,
 293     void                    **ReturnValue)
 294 {
 295     ACPI_OBJECT_TYPE        Type;
 296     ACPI_STATUS             Status;
 297     ACPI_INIT_WALK_INFO     *Info = (ACPI_INIT_WALK_INFO *) Context;
 298     ACPI_NAMESPACE_NODE     *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;
 299     ACPI_OPERAND_OBJECT     *ObjDesc;
 300
 301
 302     ACPI_FUNCTION_NAME ("NsInitOneObject");
 303
 304
 305     Info->ObjectCount++;
 306
 307     /* And even then, we are only interested in a few object types */
 308
 309     Type = AcpiNsGetType (ObjHandle);
 310     ObjDesc = AcpiNsGetAttachedObject (Node);
 311     if (!ObjDesc)
 312     {
 313         return (AE_OK);
 314     }
 315
 316     /* Increment counters for object types we are looking for */
 317
 318     switch (Type)
 319     {
 320     case ACPI_TYPE_REGION:
 321         Info->OpRegionCount++;
 322         break;
 323
 324     case ACPI_TYPE_BUFFER_FIELD:
 325         Info->FieldCount++;
 326         break;
 327
 328     case ACPI_TYPE_BUFFER:
 329         Info->BufferCount++;
 330         break;
 331
 332     case ACPI_TYPE_PACKAGE:
 333         Info->PackageCount++;
 334         break;
 335
 336     default:
 337
 338         /* No init required, just exit now */
 339         return (AE_OK);
 340     }
 341
 342     /*
 343      * If the object is already initialized, nothing else to do
 344      */
 345     if (ObjDesc->Common.Flags & AOPOBJ_DATA_VALID)
 346     {
 347         return (AE_OK);
 348     }
 349
 350     /*
 351      * Must lock the interpreter before executing AML code
 352      */
 353     Status = AcpiExEnterInterpreter ();
 354     if (ACPI_FAILURE (Status))
 355     {
 356         return (Status);
 357     }
 358
 359     /*
 360      * Each of these types can contain executable AML code within the
 361      * declaration.
 362      */
 363     switch (Type)
 364     {
 365     case ACPI_TYPE_REGION:
 366
 367         Info->OpRegionInit++;
 368         Status = AcpiDsGetRegionArguments (ObjDesc);
 369         break;
 370
 371     case ACPI_TYPE_BUFFER_FIELD:
 372
 373         Info->FieldInit++;
 374         Status = AcpiDsGetBufferFieldArguments (ObjDesc);
 375         break;
 376
 377     case ACPI_TYPE_BUFFER:
 378
 379         Info->BufferInit++;
 380         Status = AcpiDsGetBufferArguments (ObjDesc);
 381         break;
 382
 383     case ACPI_TYPE_PACKAGE:
 384
 385         Info->PackageInit++;
 386         Status = AcpiDsGetPackageArguments (ObjDesc);
 387         break;
 388
 389     default:
 390         /* No other types can get here */
 391         break;
 392     }
 393
 394     if (ACPI_FAILURE (Status))
 395     {
 396         ACPI_DEBUG_PRINT_RAW ((ACPI_DB_ERROR, "\n"));
 397         ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 398                 "Could not execute arguments for [%4.4s] (%s), %s\n",
 399                 AcpiUtGetNodeName (Node), AcpiUtGetTypeName (Type),
 400                 AcpiFormatException (Status)));
 401     }
 402
 403     /*
 404      * Print a dot for each object unless we are going to print the entire
 405      * pathname
 406      */
 407     if (!(AcpiDbgLevel & ACPI_LV_INIT_NAMES))
 408     {
 409         ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INIT, "."));
 410     }
 411
 412     /*
 413      * We ignore errors from above, and always return OK, since we don't want
 414      * to abort the walk on any single error.
 415      */
 416     AcpiExExitInterpreter ();
 417     return (AE_OK);
 418 }
 419
 420
 421 /*******************************************************************************
 422  *
 423  * FUNCTION:    AcpiNsInitOneDevice
 424  *
 425  * PARAMETERS:  ACPI_WALK_CALLBACK
 426  *
 427  * RETURN:      ACPI_STATUS
 428  *
 429  * DESCRIPTION: This is called once per device soon after ACPI is enabled
 430  *              to initialize each device. It determines if the device is
 431  *              present, and if so, calls _INI.
 432  *
 433  ******************************************************************************/
 434
 435 static ACPI_STATUS
 436 AcpiNsInitOneDevice (
 437     ACPI_HANDLE             ObjHandle,
 438     UINT32                  NestingLevel,
 439     void                    *Context,
 440     void                    **ReturnValue)
 441 {
 442     ACPI_DEVICE_WALK_INFO  *Info = (ACPI_DEVICE_WALK_INFO *) Context;
 443     ACPI_PARAMETER_INFO     Pinfo;
 444     UINT32                  Flags;
 445     ACPI_STATUS             Status;
 446
 447
 448     ACPI_FUNCTION_TRACE ("NsInitOneDevice");
 449
 450
 451     Pinfo.Parameters = NULL;
 452     Pinfo.ParameterType = ACPI_PARAM_ARGS;
 453
 454     Pinfo.Node = AcpiNsMapHandleToNode (ObjHandle);
 455     if (!Pinfo.Node)
 456     {
 457         return_ACPI_STATUS (AE_BAD_PARAMETER);
 458     }
 459
 460     /*
 461      * We will run _STA/_INI on Devices, Processors and ThermalZones only
 462      */
 463     if ((Pinfo.Node->Type != ACPI_TYPE_DEVICE)      &&
 464         (Pinfo.Node->Type != ACPI_TYPE_PROCESSOR)   &&
 465         (Pinfo.Node->Type != ACPI_TYPE_THERMAL))
 466     {
 467         return_ACPI_STATUS (AE_OK);
 468     }
 469
 470     if ((AcpiDbgLevel <= ACPI_LV_ALL_EXCEPTIONS) &&
 471         (!(AcpiDbgLevel & ACPI_LV_INFO)))
 472     {
 473         ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INIT, "."));
 474     }
 475
 476     Info->DeviceCount++;
 477
 478     /*
 479      * Run _STA to determine if we can run _INI on the device.
 480      */
 481     ACPI_DEBUG_EXEC (AcpiUtDisplayInitPathname (ACPI_TYPE_METHOD,
 482                         Pinfo.Node, METHOD_NAME__STA));
 483     Status = AcpiUtExecute_STA (Pinfo.Node, &Flags);
 484
 485     if (ACPI_FAILURE (Status))
 486     {
 487         if (Pinfo.Node->Type == ACPI_TYPE_DEVICE)
 488         {
 489             /* Ignore error and move on to next device */
 490
 491             return_ACPI_STATUS (AE_OK);
 492         }
 493
 494         /* _STA is not required for Processor or ThermalZone objects */
 495     }
 496     else
 497     {
 498         Info->Num_STA++;
 499
 500         if (!(Flags & 0x01))
 501         {
 502             /* Don't look at children of a not present device */
 503
 504             return_ACPI_STATUS(AE_CTRL_DEPTH);
 505         }
 506     }
 507
 508     /*
 509      * The device is present. Run _INI.
 510      */
 511     ACPI_DEBUG_EXEC (AcpiUtDisplayInitPathname (ACPI_TYPE_METHOD,
 512                         Pinfo.Node, METHOD_NAME__INI));
 513     Status = AcpiNsEvaluateRelative (METHOD_NAME__INI, &Pinfo);
 514     if (ACPI_FAILURE (Status))
 515     {
 516         /* No _INI (AE_NOT_FOUND) means device requires no initialization */
 517
 518         if (Status != AE_NOT_FOUND)
 519         {
 520             /* Ignore error and move on to next device */
 521
 522 #ifdef ACPI_DEBUG_OUTPUT
 523             char        *ScopeName = AcpiNsGetExternalPathname (Pinfo.Node);
 524
 525             ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "%s._INI failed: %s\n",
 526                     ScopeName, AcpiFormatException (Status)));
 527
 528             ACPI_MEM_FREE (ScopeName);
 529 #endif
 530         }
 531
 532         Status = AE_OK;
 533     }
 534     else
 535     {
 536         /* Delete any return object (especially if ImplicitReturn is enabled) */
 537
 538         if (Pinfo.ReturnObject)
 539         {
 540             AcpiUtRemoveReference (Pinfo.ReturnObject);
 541         }
 542
 543         /* Count of successful INIs */
 544
 545         Info->Num_INI++;
 546     }
 547
 548     if (AcpiGbl_InitHandler)
 549     {
 550         /* External initialization handler is present, call it */
 551
 552         Status = AcpiGbl_InitHandler (Pinfo.Node, ACPI_INIT_DEVICE_INI);
 553     }
 554
 555     return_ACPI_STATUS (Status);
 556 }