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

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