reactos/drivers/bus/acpi/acpica/events/evregion.c

   1 /******************************************************************************
   2  *
   3  * Module Name: evregion - Operation Region support
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2016, Intel Corp.
   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 "acevents.h"
  47 #include "acnamesp.h"
  48 #include "acinterp.h"
  49
  50 #define _COMPONENT          ACPI_EVENTS
  51         ACPI_MODULE_NAME    ("evregion")
  52
  53
  54 extern UINT8        AcpiGbl_DefaultAddressSpaces[];
  55
  56 /* Local prototypes */
  57
  58 static void
  59 AcpiEvOrphanEcRegMethod (
  60     ACPI_NAMESPACE_NODE     *EcDeviceNode);
  61
  62 static ACPI_STATUS
  63 AcpiEvRegRun (
  64     ACPI_HANDLE             ObjHandle,
  65     UINT32                  Level,
  66     void                    *Context,
  67     void                    **ReturnValue);
  68
  69
  70 /*******************************************************************************
  71  *
  72  * FUNCTION:    AcpiEvInitializeOpRegions
  73  *
  74  * PARAMETERS:  None
  75  *
  76  * RETURN:      Status
  77  *
  78  * DESCRIPTION: Execute _REG methods for all Operation Regions that have
  79  *              an installed default region handler.
  80  *
  81  ******************************************************************************/
  82
  83 ACPI_STATUS
  84 AcpiEvInitializeOpRegions (
  85     void)
  86 {
  87     ACPI_STATUS             Status;
  88     UINT32                  i;
  89
  90
  91     ACPI_FUNCTION_TRACE (EvInitializeOpRegions);
  92
  93
  94     Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
  95     if (ACPI_FAILURE (Status))
  96     {
  97         return_ACPI_STATUS (Status);
  98     }
  99
 100     /* Run the _REG methods for OpRegions in each default address space */
 101
 102     AcpiGbl_RegMethodsEnabled = TRUE;
 103     for (i = 0; i < ACPI_NUM_DEFAULT_SPACES; i++)
 104     {
 105         /*
 106          * Make sure the installed handler is the DEFAULT handler. If not the
 107          * default, the _REG methods will have already been run (when the
 108          * handler was installed)
 109          */
 110         if (AcpiEvHasDefaultHandler (AcpiGbl_RootNode,
 111                AcpiGbl_DefaultAddressSpaces[i]))
 112         {
 113             AcpiEvExecuteRegMethods (AcpiGbl_RootNode,
 114                 AcpiGbl_DefaultAddressSpaces[i], ACPI_REG_CONNECT);
 115         }
 116     }
 117
 118     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 119     return_ACPI_STATUS (Status);
 120 }
 121
 122
 123 /*******************************************************************************
 124  *
 125  * FUNCTION:    AcpiEvAddressSpaceDispatch
 126  *
 127  * PARAMETERS:  RegionObj           - Internal region object
 128  *              FieldObj            - Corresponding field. Can be NULL.
 129  *              Function            - Read or Write operation
 130  *              RegionOffset        - Where in the region to read or write
 131  *              BitWidth            - Field width in bits (8, 16, 32, or 64)
 132  *              Value               - Pointer to in or out value, must be
 133  *                                    a full 64-bit integer
 134  *
 135  * RETURN:      Status
 136  *
 137  * DESCRIPTION: Dispatch an address space or operation region access to
 138  *              a previously installed handler.
 139  *
 140  * NOTE: During early initialization, we always install the default region
 141  * handlers for Memory, I/O and PCI_Config. This ensures that these operation
 142  * region address spaces are always available as per the ACPI specification.
 143  * This is especially needed in order to support the execution of
 144  * module-level AML code during loading of the ACPI tables.
 145  *
 146  ******************************************************************************/
 147
 148 ACPI_STATUS
 149 AcpiEvAddressSpaceDispatch (
 150     ACPI_OPERAND_OBJECT     *RegionObj,
 151     ACPI_OPERAND_OBJECT     *FieldObj,
 152     UINT32                  Function,
 153     UINT32                  RegionOffset,
 154     UINT32                  BitWidth,
 155     UINT64                  *Value)
 156 {
 157     ACPI_STATUS             Status;
 158     ACPI_ADR_SPACE_HANDLER  Handler;
 159     ACPI_ADR_SPACE_SETUP    RegionSetup;
 160     ACPI_OPERAND_OBJECT     *HandlerDesc;
 161     ACPI_OPERAND_OBJECT     *RegionObj2;
 162     void                    *RegionContext = NULL;
 163     ACPI_CONNECTION_INFO    *Context;
 164     ACPI_PHYSICAL_ADDRESS   Address;
 165
 166
 167     ACPI_FUNCTION_TRACE (EvAddressSpaceDispatch);
 168
 169
 170     RegionObj2 = AcpiNsGetSecondaryObject (RegionObj);
 171     if (!RegionObj2)
 172     {
 173         return_ACPI_STATUS (AE_NOT_EXIST);
 174     }
 175
 176     /* Ensure that there is a handler associated with this region */
 177
 178     HandlerDesc = RegionObj->Region.Handler;
 179     if (!HandlerDesc)
 180     {
 181         ACPI_ERROR ((AE_INFO,
 182             "No handler for Region [%4.4s] (%p) [%s]",
 183             AcpiUtGetNodeName (RegionObj->Region.Node),
 184             RegionObj, AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
 185
 186         return_ACPI_STATUS (AE_NOT_EXIST);
 187     }
 188
 189     Context = HandlerDesc->AddressSpace.Context;
 190
 191     /*
 192      * It may be the case that the region has never been initialized.
 193      * Some types of regions require special init code
 194      */
 195     if (!(RegionObj->Region.Flags & AOPOBJ_SETUP_COMPLETE))
 196     {
 197         /* This region has not been initialized yet, do it */
 198
 199         RegionSetup = HandlerDesc->AddressSpace.Setup;
 200         if (!RegionSetup)
 201         {
 202             /* No initialization routine, exit with error */
 203
 204             ACPI_ERROR ((AE_INFO,
 205                 "No init routine for region(%p) [%s]",
 206                 RegionObj, AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
 207             return_ACPI_STATUS (AE_NOT_EXIST);
 208         }
 209
 210         /*
 211          * We must exit the interpreter because the region setup will
 212          * potentially execute control methods (for example, the _REG method
 213          * for this region)
 214          */
 215         AcpiExExitInterpreter ();
 216
 217         Status = RegionSetup (RegionObj, ACPI_REGION_ACTIVATE,
 218             Context, &RegionContext);
 219
 220         /* Re-enter the interpreter */
 221
 222         AcpiExEnterInterpreter ();
 223
 224         /* Check for failure of the Region Setup */
 225
 226         if (ACPI_FAILURE (Status))
 227         {
 228             ACPI_EXCEPTION ((AE_INFO, Status,
 229                 "During region initialization: [%s]",
 230                 AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
 231             return_ACPI_STATUS (Status);
 232         }
 233
 234         /* Region initialization may have been completed by RegionSetup */
 235
 236         if (!(RegionObj->Region.Flags & AOPOBJ_SETUP_COMPLETE))
 237         {
 238             RegionObj->Region.Flags |= AOPOBJ_SETUP_COMPLETE;
 239
 240             /*
 241              * Save the returned context for use in all accesses to
 242              * the handler for this particular region
 243              */
 244             if (!(RegionObj2->Extra.RegionContext))
 245             {
 246                 RegionObj2->Extra.RegionContext = RegionContext;
 247             }
 248         }
 249     }
 250
 251     /* We have everything we need, we can invoke the address space handler */
 252
 253     Handler = HandlerDesc->AddressSpace.Handler;
 254     Address = (RegionObj->Region.Address + RegionOffset);
 255
 256     /*
 257      * Special handling for GenericSerialBus and GeneralPurposeIo:
 258      * There are three extra parameters that must be passed to the
 259      * handler via the context:
 260      *   1) Connection buffer, a resource template from Connection() op
 261      *   2) Length of the above buffer
 262      *   3) Actual access length from the AccessAs() op
 263      *
 264      * In addition, for GeneralPurposeIo, the Address and BitWidth fields
 265      * are defined as follows:
 266      *   1) Address is the pin number index of the field (bit offset from
 267      *      the previous Connection)
 268      *   2) BitWidth is the actual bit length of the field (number of pins)
 269      */
 270     if ((RegionObj->Region.SpaceId == ACPI_ADR_SPACE_GSBUS) &&
 271         Context &&
 272         FieldObj)
 273     {
 274         /* Get the Connection (ResourceTemplate) buffer */
 275
 276         Context->Connection = FieldObj->Field.ResourceBuffer;
 277         Context->Length = FieldObj->Field.ResourceLength;
 278         Context->AccessLength = FieldObj->Field.AccessLength;
 279     }
 280     if ((RegionObj->Region.SpaceId == ACPI_ADR_SPACE_GPIO) &&
 281         Context &&
 282         FieldObj)
 283     {
 284         /* Get the Connection (ResourceTemplate) buffer */
 285
 286         Context->Connection = FieldObj->Field.ResourceBuffer;
 287         Context->Length = FieldObj->Field.ResourceLength;
 288         Context->AccessLength = FieldObj->Field.AccessLength;
 289         Address = FieldObj->Field.PinNumberIndex;
 290         BitWidth = FieldObj->Field.BitLength;
 291     }
 292
 293     ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
 294         "Handler %p (@%p) Address %8.8X%8.8X [%s]\n",
 295         &RegionObj->Region.Handler->AddressSpace, Handler,
 296         ACPI_FORMAT_UINT64 (Address),
 297         AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
 298
 299     if (!(HandlerDesc->AddressSpace.HandlerFlags &
 300         ACPI_ADDR_HANDLER_DEFAULT_INSTALLED))
 301     {
 302         /*
 303          * For handlers other than the default (supplied) handlers, we must
 304          * exit the interpreter because the handler *might* block -- we don't
 305          * know what it will do, so we can't hold the lock on the intepreter.
 306          */
 307         AcpiExExitInterpreter();
 308     }
 309
 310     /* Call the handler */
 311
 312     Status = Handler (Function, Address, BitWidth, Value, Context,
 313         RegionObj2->Extra.RegionContext);
 314
 315     if (ACPI_FAILURE (Status))
 316     {
 317         ACPI_EXCEPTION ((AE_INFO, Status, "Returned by Handler for [%s]",
 318             AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
 319     }
 320
 321     if (!(HandlerDesc->AddressSpace.HandlerFlags &
 322         ACPI_ADDR_HANDLER_DEFAULT_INSTALLED))
 323     {
 324         /*
 325          * We just returned from a non-default handler, we must re-enter the
 326          * interpreter
 327          */
 328         AcpiExEnterInterpreter ();
 329     }
 330
 331     return_ACPI_STATUS (Status);
 332 }
 333
 334
 335 /*******************************************************************************
 336  *
 337  * FUNCTION:    AcpiEvDetachRegion
 338  *
 339  * PARAMETERS:  RegionObj           - Region Object
 340  *              AcpiNsIsLocked      - Namespace Region Already Locked?
 341  *
 342  * RETURN:      None
 343  *
 344  * DESCRIPTION: Break the association between the handler and the region
 345  *              this is a two way association.
 346  *
 347  ******************************************************************************/
 348
 349 void
 350 AcpiEvDetachRegion (
 351     ACPI_OPERAND_OBJECT     *RegionObj,
 352     BOOLEAN                 AcpiNsIsLocked)
 353 {
 354     ACPI_OPERAND_OBJECT     *HandlerObj;
 355     ACPI_OPERAND_OBJECT     *ObjDesc;
 356     ACPI_OPERAND_OBJECT     *StartDesc;
 357     ACPI_OPERAND_OBJECT     **LastObjPtr;
 358     ACPI_ADR_SPACE_SETUP    RegionSetup;
 359     void                    **RegionContext;
 360     ACPI_OPERAND_OBJECT     *RegionObj2;
 361     ACPI_STATUS             Status;
 362
 363
 364     ACPI_FUNCTION_TRACE (EvDetachRegion);
 365
 366
 367     RegionObj2 = AcpiNsGetSecondaryObject (RegionObj);
 368     if (!RegionObj2)
 369     {
 370         return_VOID;
 371     }
 372     RegionContext = &RegionObj2->Extra.RegionContext;
 373
 374     /* Get the address handler from the region object */
 375
 376     HandlerObj = RegionObj->Region.Handler;
 377     if (!HandlerObj)
 378     {
 379         /* This region has no handler, all done */
 380
 381         return_VOID;
 382     }
 383
 384     /* Find this region in the handler's list */
 385
 386     ObjDesc = HandlerObj->AddressSpace.RegionList;
 387     StartDesc = ObjDesc;
 388     LastObjPtr = &HandlerObj->AddressSpace.RegionList;
 389
 390     while (ObjDesc)
 391     {
 392         /* Is this the correct Region? */
 393
 394         if (ObjDesc == RegionObj)
 395         {
 396             ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
 397                 "Removing Region %p from address handler %p\n",
 398                 RegionObj, HandlerObj));
 399
 400             /* This is it, remove it from the handler's list */
 401
 402             *LastObjPtr = ObjDesc->Region.Next;
 403             ObjDesc->Region.Next = NULL;        /* Must clear field */
 404
 405             if (AcpiNsIsLocked)
 406             {
 407                 Status = AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 408                 if (ACPI_FAILURE (Status))
 409                 {
 410                     return_VOID;
 411                 }
 412             }
 413
 414             /* Now stop region accesses by executing the _REG method */
 415
 416             Status = AcpiEvExecuteRegMethod (RegionObj, ACPI_REG_DISCONNECT);
 417             if (ACPI_FAILURE (Status))
 418             {
 419                 ACPI_EXCEPTION ((AE_INFO, Status, "from region _REG, [%s]",
 420                     AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
 421             }
 422
 423             if (AcpiNsIsLocked)
 424             {
 425                 Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
 426                 if (ACPI_FAILURE (Status))
 427                 {
 428                     return_VOID;
 429                 }
 430             }
 431
 432             /*
 433              * If the region has been activated, call the setup handler with
 434              * the deactivate notification
 435              */
 436             if (RegionObj->Region.Flags & AOPOBJ_SETUP_COMPLETE)
 437             {
 438                 RegionSetup = HandlerObj->AddressSpace.Setup;
 439                 Status = RegionSetup (RegionObj, ACPI_REGION_DEACTIVATE,
 440                     HandlerObj->AddressSpace.Context, RegionContext);
 441
 442                 /*
 443                  * RegionContext should have been released by the deactivate
 444                  * operation. We don't need access to it anymore here.
 445                  */
 446                 if (RegionContext)
 447                 {
 448                     *RegionContext = NULL;
 449                 }
 450
 451                 /* Init routine may fail, Just ignore errors */
 452
 453                 if (ACPI_FAILURE (Status))
 454                 {
 455                     ACPI_EXCEPTION ((AE_INFO, Status,
 456                         "from region handler - deactivate, [%s]",
 457                         AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
 458                 }
 459
 460                 RegionObj->Region.Flags &= ~(AOPOBJ_SETUP_COMPLETE);
 461             }
 462
 463             /*
 464              * Remove handler reference in the region
 465              *
 466              * NOTE: this doesn't mean that the region goes away, the region
 467              * is just inaccessible as indicated to the _REG method
 468              *
 469              * If the region is on the handler's list, this must be the
 470              * region's handler
 471              */
 472             RegionObj->Region.Handler = NULL;
 473             AcpiUtRemoveReference (HandlerObj);
 474
 475             return_VOID;
 476         }
 477
 478         /* Walk the linked list of handlers */
 479
 480         LastObjPtr = &ObjDesc->Region.Next;
 481         ObjDesc = ObjDesc->Region.Next;
 482
 483         /* Prevent infinite loop if list is corrupted */
 484
 485         if (ObjDesc == StartDesc)
 486         {
 487             ACPI_ERROR ((AE_INFO,
 488                 "Circular handler list in region object %p",
 489                 RegionObj));
 490             return_VOID;
 491         }
 492     }
 493
 494     /* If we get here, the region was not in the handler's region list */
 495
 496     ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
 497         "Cannot remove region %p from address handler %p\n",
 498         RegionObj, HandlerObj));
 499
 500     return_VOID;
 501 }
 502
 503
 504 /*******************************************************************************
 505  *
 506  * FUNCTION:    AcpiEvAttachRegion
 507  *
 508  * PARAMETERS:  HandlerObj          - Handler Object
 509  *              RegionObj           - Region Object
 510  *              AcpiNsIsLocked      - Namespace Region Already Locked?
 511  *
 512  * RETURN:      None
 513  *
 514  * DESCRIPTION: Create the association between the handler and the region
 515  *              this is a two way association.
 516  *
 517  ******************************************************************************/
 518
 519 ACPI_STATUS
 520 AcpiEvAttachRegion (
 521     ACPI_OPERAND_OBJECT     *HandlerObj,
 522     ACPI_OPERAND_OBJECT     *RegionObj,
 523     BOOLEAN                 AcpiNsIsLocked)
 524 {
 525
 526     ACPI_FUNCTION_TRACE (EvAttachRegion);
 527
 528
 529     /* Install the region's handler */
 530
 531     if (RegionObj->Region.Handler)
 532     {
 533         return_ACPI_STATUS (AE_ALREADY_EXISTS);
 534     }
 535
 536     ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
 537         "Adding Region [%4.4s] %p to address handler %p [%s]\n",
 538         AcpiUtGetNodeName (RegionObj->Region.Node),
 539         RegionObj, HandlerObj,
 540         AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
 541
 542     /* Link this region to the front of the handler's list */
 543
 544     RegionObj->Region.Next = HandlerObj->AddressSpace.RegionList;
 545     HandlerObj->AddressSpace.RegionList = RegionObj;
 546     RegionObj->Region.Handler = HandlerObj;
 547     AcpiUtAddReference (HandlerObj);
 548
 549     return_ACPI_STATUS (AE_OK);
 550 }
 551
 552
 553 /*******************************************************************************
 554  *
 555  * FUNCTION:    AcpiEvAssociateRegMethod
 556  *
 557  * PARAMETERS:  RegionObj           - Region object
 558  *
 559  * RETURN:      Status
 560  *
 561  * DESCRIPTION: Find and associate _REG method to a region
 562  *
 563  ******************************************************************************/
 564
 565 void
 566 AcpiEvAssociateRegMethod (
 567     ACPI_OPERAND_OBJECT     *RegionObj)
 568 {
 569     ACPI_NAME               *RegNamePtr = (ACPI_NAME *) METHOD_NAME__REG;
 570     ACPI_NAMESPACE_NODE     *MethodNode;
 571     ACPI_NAMESPACE_NODE     *Node;
 572     ACPI_OPERAND_OBJECT     *RegionObj2;
 573     ACPI_STATUS             Status;
 574
 575
 576     ACPI_FUNCTION_TRACE (EvAssociateRegMethod);
 577
 578
 579     RegionObj2 = AcpiNsGetSecondaryObject (RegionObj);
 580     if (!RegionObj2)
 581     {
 582         return_VOID;
 583     }
 584
 585     Node = RegionObj->Region.Node->Parent;
 586
 587     /* Find any "_REG" method associated with this region definition */
 588
 589     Status = AcpiNsSearchOneScope (
 590         *RegNamePtr, Node, ACPI_TYPE_METHOD, &MethodNode);
 591     if (ACPI_SUCCESS (Status))
 592     {
 593         /*
 594          * The _REG method is optional and there can be only one per region
 595          * definition. This will be executed when the handler is attached
 596          * or removed
 597          */
 598         RegionObj2->Extra.Method_REG = MethodNode;
 599     }
 600
 601     return_VOID;
 602 }
 603
 604
 605 /*******************************************************************************
 606  *
 607  * FUNCTION:    AcpiEvExecuteRegMethod
 608  *
 609  * PARAMETERS:  RegionObj           - Region object
 610  *              Function            - Passed to _REG: On (1) or Off (0)
 611  *
 612  * RETURN:      Status
 613  *
 614  * DESCRIPTION: Execute _REG method for a region
 615  *
 616  ******************************************************************************/
 617
 618 ACPI_STATUS
 619 AcpiEvExecuteRegMethod (
 620     ACPI_OPERAND_OBJECT     *RegionObj,
 621     UINT32                  Function)
 622 {
 623     ACPI_EVALUATE_INFO      *Info;
 624     ACPI_OPERAND_OBJECT     *Args[3];
 625     ACPI_OPERAND_OBJECT     *RegionObj2;
 626     ACPI_STATUS             Status;
 627
 628
 629     ACPI_FUNCTION_TRACE (EvExecuteRegMethod);
 630
 631
 632     RegionObj2 = AcpiNsGetSecondaryObject (RegionObj);
 633     if (!RegionObj2)
 634     {
 635         return_ACPI_STATUS (AE_NOT_EXIST);
 636     }
 637
 638     if (RegionObj2->Extra.Method_REG == NULL ||
 639         RegionObj->Region.Handler == NULL ||
 640         !AcpiGbl_RegMethodsEnabled)
 641     {
 642         return_ACPI_STATUS (AE_OK);
 643     }
 644
 645     /* _REG(DISCONNECT) should be paired with _REG(CONNECT) */
 646
 647     if ((Function == ACPI_REG_CONNECT &&
 648         RegionObj->Common.Flags & AOPOBJ_REG_CONNECTED) ||
 649         (Function == ACPI_REG_DISCONNECT &&
 650          !(RegionObj->Common.Flags & AOPOBJ_REG_CONNECTED)))
 651     {
 652         return_ACPI_STATUS (AE_OK);
 653     }
 654
 655     /* Allocate and initialize the evaluation information block */
 656
 657     Info = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EVALUATE_INFO));
 658     if (!Info)
 659     {
 660         return_ACPI_STATUS (AE_NO_MEMORY);
 661     }
 662
 663     Info->PrefixNode = RegionObj2->Extra.Method_REG;
 664     Info->RelativePathname = NULL;
 665     Info->Parameters = Args;
 666     Info->Flags = ACPI_IGNORE_RETURN_VALUE;
 667
 668     /*
 669      * The _REG method has two arguments:
 670      *
 671      * Arg0 - Integer:
 672      *  Operation region space ID Same value as RegionObj->Region.SpaceId
 673      *
 674      * Arg1 - Integer:
 675      *  connection status 1 for connecting the handler, 0 for disconnecting
 676      *  the handler (Passed as a parameter)
 677      */
 678     Args[0] = AcpiUtCreateIntegerObject ((UINT64) RegionObj->Region.SpaceId);
 679     if (!Args[0])
 680     {
 681         Status = AE_NO_MEMORY;
 682         goto Cleanup1;
 683     }
 684
 685     Args[1] = AcpiUtCreateIntegerObject ((UINT64) Function);
 686     if (!Args[1])
 687     {
 688         Status = AE_NO_MEMORY;
 689         goto Cleanup2;
 690     }
 691
 692     Args[2] = NULL; /* Terminate list */
 693
 694     /* Execute the method, no return value */
 695
 696     ACPI_DEBUG_EXEC (
 697         AcpiUtDisplayInitPathname (ACPI_TYPE_METHOD, Info->PrefixNode, NULL));
 698
 699     Status = AcpiNsEvaluate (Info);
 700     AcpiUtRemoveReference (Args[1]);
 701
 702     if (ACPI_FAILURE (Status))
 703     {
 704         goto Cleanup2;
 705     }
 706
 707     if (Function == ACPI_REG_CONNECT)
 708     {
 709         RegionObj->Common.Flags |= AOPOBJ_REG_CONNECTED;
 710     }
 711     else
 712     {
 713         RegionObj->Common.Flags &= ~AOPOBJ_REG_CONNECTED;
 714     }
 715
 716 Cleanup2:
 717     AcpiUtRemoveReference (Args[0]);
 718
 719 Cleanup1:
 720     ACPI_FREE (Info);
 721     return_ACPI_STATUS (Status);
 722 }
 723
 724
 725 /*******************************************************************************
 726  *
 727  * FUNCTION:    AcpiEvExecuteRegMethods
 728  *
 729  * PARAMETERS:  Node            - Namespace node for the device
 730  *              SpaceId         - The address space ID
 731  *              Function        - Passed to _REG: On (1) or Off (0)
 732  *
 733  * RETURN:      None
 734  *
 735  * DESCRIPTION: Run all _REG methods for the input Space ID;
 736  *              Note: assumes namespace is locked, or system init time.
 737  *
 738  ******************************************************************************/
 739
 740 void
 741 AcpiEvExecuteRegMethods (
 742     ACPI_NAMESPACE_NODE     *Node,
 743     ACPI_ADR_SPACE_TYPE     SpaceId,
 744     UINT32                  Function)
 745 {
 746     ACPI_REG_WALK_INFO      Info;
 747
 748
 749     ACPI_FUNCTION_TRACE (EvExecuteRegMethods);
 750
 751     Info.SpaceId = SpaceId;
 752     Info.Function = Function;
 753     Info.RegRunCount = 0;
 754
 755     ACPI_DEBUG_PRINT_RAW ((ACPI_DB_NAMES,
 756         "    Running _REG methods for SpaceId %s\n",
 757         AcpiUtGetRegionName (Info.SpaceId)));
 758
 759     /*
 760      * Run all _REG methods for all Operation Regions for this space ID. This
 761      * is a separate walk in order to handle any interdependencies between
 762      * regions and _REG methods. (i.e. handlers must be installed for all
 763      * regions of this Space ID before we can run any _REG methods)
 764      */
 765     (void) AcpiNsWalkNamespace (ACPI_TYPE_ANY, Node, ACPI_UINT32_MAX,
 766         ACPI_NS_WALK_UNLOCK, AcpiEvRegRun, NULL, &Info, NULL);
 767
 768     /* Special case for EC: handle "orphan" _REG methods with no region */
 769
 770     if (SpaceId == ACPI_ADR_SPACE_EC)
 771     {
 772         AcpiEvOrphanEcRegMethod (Node);
 773     }
 774
 775     ACPI_DEBUG_PRINT_RAW ((ACPI_DB_NAMES,
 776         "    Executed %u _REG methods for SpaceId %s\n",
 777         Info.RegRunCount, AcpiUtGetRegionName (Info.SpaceId)));
 778
 779     return_VOID;
 780 }
 781
 782
 783 /*******************************************************************************
 784  *
 785  * FUNCTION:    AcpiEvRegRun
 786  *
 787  * PARAMETERS:  WalkNamespace callback
 788  *
 789  * DESCRIPTION: Run _REG method for region objects of the requested spaceID
 790  *
 791  ******************************************************************************/
 792
 793 static ACPI_STATUS
 794 AcpiEvRegRun (
 795     ACPI_HANDLE             ObjHandle,
 796     UINT32                  Level,
 797     void                    *Context,
 798     void                    **ReturnValue)
 799 {
 800     ACPI_OPERAND_OBJECT     *ObjDesc;
 801     ACPI_NAMESPACE_NODE     *Node;
 802     ACPI_STATUS             Status;
 803     ACPI_REG_WALK_INFO      *Info;
 804
 805
 806     Info = ACPI_CAST_PTR (ACPI_REG_WALK_INFO, Context);
 807
 808     /* Convert and validate the device handle */
 809
 810     Node = AcpiNsValidateHandle (ObjHandle);
 811     if (!Node)
 812     {
 813         return (AE_BAD_PARAMETER);
 814     }
 815
 816     /*
 817      * We only care about regions.and objects that are allowed to have address
 818      * space handlers
 819      */
 820     if ((Node->Type != ACPI_TYPE_REGION) &&
 821         (Node != AcpiGbl_RootNode))
 822     {
 823         return (AE_OK);
 824     }
 825
 826     /* Check for an existing internal object */
 827
 828     ObjDesc = AcpiNsGetAttachedObject (Node);
 829     if (!ObjDesc)
 830     {
 831         /* No object, just exit */
 832
 833         return (AE_OK);
 834     }
 835
 836     /* Object is a Region */
 837
 838     if (ObjDesc->Region.SpaceId != Info->SpaceId)
 839     {
 840         /* This region is for a different address space, just ignore it */
 841
 842         return (AE_OK);
 843     }
 844
 845     Info->RegRunCount++;
 846     Status = AcpiEvExecuteRegMethod (ObjDesc, Info->Function);
 847     return (Status);
 848 }
 849
 850
 851 /*******************************************************************************
 852  *
 853  * FUNCTION:    AcpiEvOrphanEcRegMethod
 854  *
 855  * PARAMETERS:  EcDeviceNode        - Namespace node for an EC device
 856  *
 857  * RETURN:      None
 858  *
 859  * DESCRIPTION: Execute an "orphan" _REG method that appears under the EC
 860  *              device. This is a _REG method that has no corresponding region
 861  *              within the EC device scope. The orphan _REG method appears to
 862  *              have been enabled by the description of the ECDT in the ACPI
 863  *              specification: "The availability of the region space can be
 864  *              detected by providing a _REG method object underneath the
 865  *              Embedded Controller device."
 866  *
 867  *              To quickly access the EC device, we use the EcDeviceNode used
 868  *              during EC handler installation. Otherwise, we would need to
 869  *              perform a time consuming namespace walk, executing _HID
 870  *              methods to find the EC device.
 871  *
 872  *  MUTEX:      Assumes the namespace is locked
 873  *
 874  ******************************************************************************/
 875
 876 static void
 877 AcpiEvOrphanEcRegMethod (
 878     ACPI_NAMESPACE_NODE     *EcDeviceNode)
 879 {
 880     ACPI_HANDLE             RegMethod;
 881     ACPI_NAMESPACE_NODE     *NextNode;
 882     ACPI_STATUS             Status;
 883     ACPI_OBJECT_LIST        Args;
 884     ACPI_OBJECT             Objects[2];
 885
 886
 887     ACPI_FUNCTION_TRACE (EvOrphanEcRegMethod);
 888
 889
 890     if (!EcDeviceNode)
 891     {
 892         return_VOID;
 893     }
 894
 895     /* Namespace is currently locked, must release */
 896
 897     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 898
 899     /* Get a handle to a _REG method immediately under the EC device */
 900
 901     Status = AcpiGetHandle (EcDeviceNode, METHOD_NAME__REG, &RegMethod);
 902     if (ACPI_FAILURE (Status))
 903     {
 904         goto Exit; /* There is no _REG method present */
 905     }
 906
 907     /*
 908      * Execute the _REG method only if there is no Operation Region in
 909      * this scope with the Embedded Controller space ID. Otherwise, it
 910      * will already have been executed. Note, this allows for Regions
 911      * with other space IDs to be present; but the code below will then
 912      * execute the _REG method with the EmbeddedControl SpaceID argument.
 913      */
 914     NextNode = AcpiNsGetNextNode (EcDeviceNode, NULL);
 915     while (NextNode)
 916     {
 917         if ((NextNode->Type == ACPI_TYPE_REGION) &&
 918             (NextNode->Object) &&
 919             (NextNode->Object->Region.SpaceId == ACPI_ADR_SPACE_EC))
 920         {
 921             goto Exit; /* Do not execute the _REG */
 922         }
 923
 924         NextNode = AcpiNsGetNextNode (EcDeviceNode, NextNode);
 925     }
 926
 927     /* Evaluate the _REG(EmbeddedControl,Connect) method */
 928
 929     Args.Count = 2;
 930     Args.Pointer = Objects;
 931     Objects[0].Type = ACPI_TYPE_INTEGER;
 932     Objects[0].Integer.Value = ACPI_ADR_SPACE_EC;
 933     Objects[1].Type = ACPI_TYPE_INTEGER;
 934     Objects[1].Integer.Value = ACPI_REG_CONNECT;
 935
 936     Status = AcpiEvaluateObject (RegMethod, NULL, &Args, NULL);
 937
 938 Exit:
 939     /* We ignore all errors from above, don't care */
 940
 941     Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
 942     return_VOID;
 943 }