Warning, cross-references for /kernel/drivers/acpica/evregion.c need to be fixed.
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017
0018
0019
0020
0021
0022
0023
0024
0025
0026
0027
0028
0029
0030
0031
0032
0033
0034
0035
0036
0037
0038
0039
0040
0041
0042
0043
0044
0045
0046
0047
0048
0049
0050
0051
0052
0053
0054
0055
0056
0057
0058
0059
0060
0061
0062
0063
0064
0065
0066
0067
0068
0069
0070
0071
0072
0073
0074
0075
0076
0077
0078
0079
0080
0081
0082
0083
0084
0085
0086
0087
0088
0089
0090
0091
0092
0093
0094
0095
0096
0097
0098
0099
0100
0101
0102
0103
0104
0105
0106
0107
0108
0109
0110
0111
0112
0113
0114
0115
0116
0117 #define __EVREGION_C__
0118
0119 #include "acpi.h"
0120 #include "accommon.h"
0121 #include "acevents.h"
0122 #include "acnamesp.h"
0123 #include "acinterp.h"
0124
0125 #define _COMPONENT ACPI_EVENTS
0126 ACPI_MODULE_NAME ("evregion")
0127
0128
0129
0130
0131 static ACPI_STATUS
0132 AcpiEvRegRun (
0133 ACPI_HANDLE ObjHandle,
0134 UINT32 Level,
0135 void *Context,
0136 void **ReturnValue);
0137
0138 static ACPI_STATUS
0139 AcpiEvInstallHandler (
0140 ACPI_HANDLE ObjHandle,
0141 UINT32 Level,
0142 void *Context,
0143 void **ReturnValue);
0144
0145
0146
0147 #define ACPI_NUM_DEFAULT_SPACES 4
0148
0149 static UINT8 AcpiGbl_DefaultAddressSpaces[ACPI_NUM_DEFAULT_SPACES] =
0150 {
0151 ACPI_ADR_SPACE_SYSTEM_MEMORY,
0152 ACPI_ADR_SPACE_SYSTEM_IO,
0153 ACPI_ADR_SPACE_PCI_CONFIG,
0154 ACPI_ADR_SPACE_DATA_TABLE
0155 };
0156
0157
0158
0159
0160
0161
0162
0163
0164
0165
0166
0167
0168
0169
0170 ACPI_STATUS
0171 AcpiEvInstallRegionHandlers (
0172 void)
0173 {
0174 ACPI_STATUS Status;
0175 UINT32 i;
0176
0177
0178 ACPI_FUNCTION_TRACE (EvInstallRegionHandlers);
0179
0180
0181 Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
0182 if (ACPI_FAILURE (Status))
0183 {
0184 return_ACPI_STATUS (Status);
0185 }
0186
0187
0188
0189
0190
0191
0192
0193
0194
0195
0196
0197
0198
0199
0200
0201
0202
0203
0204
0205
0206 for (i = 0; i < ACPI_NUM_DEFAULT_SPACES; i++)
0207 {
0208 Status = AcpiEvInstallSpaceHandler (AcpiGbl_RootNode,
0209 AcpiGbl_DefaultAddressSpaces[i],
0210 ACPI_DEFAULT_HANDLER, NULL, NULL);
0211 switch (Status)
0212 {
0213 case AE_OK:
0214 case AE_SAME_HANDLER:
0215 case AE_ALREADY_EXISTS:
0216
0217
0218
0219 Status = AE_OK;
0220 break;
0221
0222 default:
0223
0224 goto UnlockAndExit;
0225 }
0226 }
0227
0228 UnlockAndExit:
0229 (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
0230 return_ACPI_STATUS (Status);
0231 }
0232
0233
0234
0235
0236
0237
0238
0239
0240
0241
0242
0243
0244
0245
0246
0247 ACPI_STATUS
0248 AcpiEvInitializeOpRegions (
0249 void)
0250 {
0251 ACPI_STATUS Status;
0252 UINT32 i;
0253
0254
0255 ACPI_FUNCTION_TRACE (EvInitializeOpRegions);
0256
0257
0258 Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
0259 if (ACPI_FAILURE (Status))
0260 {
0261 return_ACPI_STATUS (Status);
0262 }
0263
0264
0265
0266 for (i = 0; i < ACPI_NUM_DEFAULT_SPACES; i++)
0267 {
0268
0269
0270
0271
0272 Status = AcpiEvExecuteRegMethods (AcpiGbl_RootNode,
0273 AcpiGbl_DefaultAddressSpaces[i]);
0274 }
0275
0276 (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
0277 return_ACPI_STATUS (Status);
0278 }
0279
0280
0281
0282
0283
0284
0285
0286
0287
0288
0289
0290
0291
0292
0293
0294 ACPI_STATUS
0295 AcpiEvExecuteRegMethod (
0296 ACPI_OPERAND_OBJECT *RegionObj,
0297 UINT32 Function)
0298 {
0299 ACPI_EVALUATE_INFO *Info;
0300 ACPI_OPERAND_OBJECT *Args[3];
0301 ACPI_OPERAND_OBJECT *RegionObj2;
0302 ACPI_STATUS Status;
0303
0304
0305 ACPI_FUNCTION_TRACE (EvExecuteRegMethod);
0306
0307
0308 RegionObj2 = AcpiNsGetSecondaryObject (RegionObj);
0309 if (!RegionObj2)
0310 {
0311 return_ACPI_STATUS (AE_NOT_EXIST);
0312 }
0313
0314 if (RegionObj2->Extra.Method_REG == NULL)
0315 {
0316 return_ACPI_STATUS (AE_OK);
0317 }
0318
0319
0320
0321 Info = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EVALUATE_INFO));
0322 if (!Info)
0323 {
0324 return_ACPI_STATUS (AE_NO_MEMORY);
0325 }
0326
0327 Info->PrefixNode = RegionObj2->Extra.Method_REG;
0328 Info->Pathname = NULL;
0329 Info->Parameters = Args;
0330 Info->Flags = ACPI_IGNORE_RETURN_VALUE;
0331
0332
0333
0334
0335
0336
0337
0338
0339
0340
0341
0342 Args[0] = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
0343 if (!Args[0])
0344 {
0345 Status = AE_NO_MEMORY;
0346 goto Cleanup1;
0347 }
0348
0349 Args[1] = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
0350 if (!Args[1])
0351 {
0352 Status = AE_NO_MEMORY;
0353 goto Cleanup2;
0354 }
0355
0356
0357
0358 Args[0]->Integer.Value = RegionObj->Region.SpaceId;
0359 Args[1]->Integer.Value = Function;
0360 Args[2] = NULL;
0361
0362
0363
0364 ACPI_DEBUG_EXEC (
0365 AcpiUtDisplayInitPathname (ACPI_TYPE_METHOD, Info->PrefixNode, NULL));
0366
0367 Status = AcpiNsEvaluate (Info);
0368 AcpiUtRemoveReference (Args[1]);
0369
0370 Cleanup2:
0371 AcpiUtRemoveReference (Args[0]);
0372
0373 Cleanup1:
0374 ACPI_FREE (Info);
0375 return_ACPI_STATUS (Status);
0376 }
0377
0378
0379
0380
0381
0382
0383
0384
0385
0386
0387
0388
0389
0390
0391
0392
0393
0394
0395
0396
0397 ACPI_STATUS
0398 AcpiEvAddressSpaceDispatch (
0399 ACPI_OPERAND_OBJECT *RegionObj,
0400 UINT32 Function,
0401 UINT32 RegionOffset,
0402 UINT32 BitWidth,
0403 ACPI_INTEGER *Value)
0404 {
0405 ACPI_STATUS Status;
0406 ACPI_ADR_SPACE_HANDLER Handler;
0407 ACPI_ADR_SPACE_SETUP RegionSetup;
0408 ACPI_OPERAND_OBJECT *HandlerDesc;
0409 ACPI_OPERAND_OBJECT *RegionObj2;
0410 void *RegionContext = NULL;
0411
0412
0413 ACPI_FUNCTION_TRACE (EvAddressSpaceDispatch);
0414
0415
0416 RegionObj2 = AcpiNsGetSecondaryObject (RegionObj);
0417 if (!RegionObj2)
0418 {
0419 return_ACPI_STATUS (AE_NOT_EXIST);
0420 }
0421
0422
0423
0424 HandlerDesc = RegionObj->Region.Handler;
0425 if (!HandlerDesc)
0426 {
0427 ACPI_ERROR ((AE_INFO,
0428 "No handler for Region [%4.4s] (%p) [%s]",
0429 AcpiUtGetNodeName (RegionObj->Region.Node),
0430 RegionObj, AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
0431
0432 return_ACPI_STATUS (AE_NOT_EXIST);
0433 }
0434
0435
0436
0437
0438
0439 if (!(RegionObj->Region.Flags & AOPOBJ_SETUP_COMPLETE))
0440 {
0441
0442
0443 RegionSetup = HandlerDesc->AddressSpace.Setup;
0444 if (!RegionSetup)
0445 {
0446
0447
0448 ACPI_ERROR ((AE_INFO,
0449 "No init routine for region(%p) [%s]",
0450 RegionObj, AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
0451 return_ACPI_STATUS (AE_NOT_EXIST);
0452 }
0453
0454
0455
0456
0457
0458
0459 AcpiExExitInterpreter ();
0460
0461 Status = RegionSetup (RegionObj, ACPI_REGION_ACTIVATE,
0462 HandlerDesc->AddressSpace.Context, &RegionContext);
0463
0464
0465
0466 AcpiExEnterInterpreter ();
0467
0468
0469
0470 if (ACPI_FAILURE (Status))
0471 {
0472 ACPI_EXCEPTION ((AE_INFO, Status,
0473 "During region initialization: [%s]",
0474 AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
0475 return_ACPI_STATUS (Status);
0476 }
0477
0478
0479
0480 if (!(RegionObj->Region.Flags & AOPOBJ_SETUP_COMPLETE))
0481 {
0482 RegionObj->Region.Flags |= AOPOBJ_SETUP_COMPLETE;
0483
0484 if (RegionObj2->Extra.RegionContext)
0485 {
0486
0487
0488 ACPI_FREE (RegionContext);
0489 }
0490 else
0491 {
0492
0493
0494
0495
0496 RegionObj2->Extra.RegionContext = RegionContext;
0497 }
0498 }
0499 }
0500
0501
0502
0503 Handler = HandlerDesc->AddressSpace.Handler;
0504
0505 ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
0506 "Handler %p (@%p) Address %8.8X%8.8X [%s]\n",
0507 &RegionObj->Region.Handler->AddressSpace, Handler,
0508 ACPI_FORMAT_NATIVE_UINT (RegionObj->Region.Address + RegionOffset),
0509 AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
0510
0511 if (!(HandlerDesc->AddressSpace.HandlerFlags &
0512 ACPI_ADDR_HANDLER_DEFAULT_INSTALLED))
0513 {
0514
0515
0516
0517
0518
0519 AcpiExExitInterpreter();
0520 }
0521
0522
0523
0524 Status = Handler (Function,
0525 (RegionObj->Region.Address + RegionOffset), BitWidth, Value,
0526 HandlerDesc->AddressSpace.Context, RegionObj2->Extra.RegionContext);
0527
0528 if (ACPI_FAILURE (Status))
0529 {
0530 ACPI_EXCEPTION ((AE_INFO, Status, "Returned by Handler for [%s]",
0531 AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
0532 }
0533
0534 if (!(HandlerDesc->AddressSpace.HandlerFlags &
0535 ACPI_ADDR_HANDLER_DEFAULT_INSTALLED))
0536 {
0537
0538
0539
0540
0541 AcpiExEnterInterpreter ();
0542 }
0543
0544 return_ACPI_STATUS (Status);
0545 }
0546
0547
0548
0549
0550
0551
0552
0553
0554
0555
0556
0557
0558
0559
0560
0561
0562 void
0563 AcpiEvDetachRegion(
0564 ACPI_OPERAND_OBJECT *RegionObj,
0565 BOOLEAN AcpiNsIsLocked)
0566 {
0567 ACPI_OPERAND_OBJECT *HandlerObj;
0568 ACPI_OPERAND_OBJECT *ObjDesc;
0569 ACPI_OPERAND_OBJECT **LastObjPtr;
0570 ACPI_ADR_SPACE_SETUP RegionSetup;
0571 void **RegionContext;
0572 ACPI_OPERAND_OBJECT *RegionObj2;
0573 ACPI_STATUS Status;
0574
0575
0576 ACPI_FUNCTION_TRACE (EvDetachRegion);
0577
0578
0579 RegionObj2 = AcpiNsGetSecondaryObject (RegionObj);
0580 if (!RegionObj2)
0581 {
0582 return_VOID;
0583 }
0584 RegionContext = &RegionObj2->Extra.RegionContext;
0585
0586
0587
0588 HandlerObj = RegionObj->Region.Handler;
0589 if (!HandlerObj)
0590 {
0591
0592
0593 return_VOID;
0594 }
0595
0596
0597
0598 ObjDesc = HandlerObj->AddressSpace.RegionList;
0599 LastObjPtr = &HandlerObj->AddressSpace.RegionList;
0600
0601 while (ObjDesc)
0602 {
0603
0604
0605 if (ObjDesc == RegionObj)
0606 {
0607 ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
0608 "Removing Region %p from address handler %p\n",
0609 RegionObj, HandlerObj));
0610
0611
0612
0613 *LastObjPtr = ObjDesc->Region.Next;
0614 ObjDesc->Region.Next = NULL;
0615
0616 if (AcpiNsIsLocked)
0617 {
0618 Status = AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
0619 if (ACPI_FAILURE (Status))
0620 {
0621 return_VOID;
0622 }
0623 }
0624
0625
0626
0627 Status = AcpiEvExecuteRegMethod (RegionObj, 0);
0628 if (ACPI_FAILURE (Status))
0629 {
0630 ACPI_EXCEPTION ((AE_INFO, Status, "from region _REG, [%s]",
0631 AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
0632 }
0633
0634 if (AcpiNsIsLocked)
0635 {
0636 Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
0637 if (ACPI_FAILURE (Status))
0638 {
0639 return_VOID;
0640 }
0641 }
0642
0643
0644
0645
0646
0647 if (RegionObj->Region.Flags & AOPOBJ_SETUP_COMPLETE)
0648 {
0649 RegionSetup = HandlerObj->AddressSpace.Setup;
0650 Status = RegionSetup (RegionObj, ACPI_REGION_DEACTIVATE,
0651 HandlerObj->AddressSpace.Context, RegionContext);
0652
0653
0654
0655 if (ACPI_FAILURE (Status))
0656 {
0657 ACPI_EXCEPTION ((AE_INFO, Status,
0658 "from region handler - deactivate, [%s]",
0659 AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
0660 }
0661
0662 RegionObj->Region.Flags &= ~(AOPOBJ_SETUP_COMPLETE);
0663 }
0664
0665
0666
0667
0668
0669
0670
0671
0672
0673
0674 RegionObj->Region.Handler = NULL;
0675 AcpiUtRemoveReference (HandlerObj);
0676
0677 return_VOID;
0678 }
0679
0680
0681
0682 LastObjPtr = &ObjDesc->Region.Next;
0683 ObjDesc = ObjDesc->Region.Next;
0684 }
0685
0686
0687
0688 ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
0689 "Cannot remove region %p from address handler %p\n",
0690 RegionObj, HandlerObj));
0691
0692 return_VOID;
0693 }
0694
0695
0696
0697
0698
0699
0700
0701
0702
0703
0704
0705
0706
0707
0708
0709
0710
0711 ACPI_STATUS
0712 AcpiEvAttachRegion (
0713 ACPI_OPERAND_OBJECT *HandlerObj,
0714 ACPI_OPERAND_OBJECT *RegionObj,
0715 BOOLEAN AcpiNsIsLocked)
0716 {
0717
0718 ACPI_FUNCTION_TRACE (EvAttachRegion);
0719
0720
0721 ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
0722 "Adding Region [%4.4s] %p to address handler %p [%s]\n",
0723 AcpiUtGetNodeName (RegionObj->Region.Node),
0724 RegionObj, HandlerObj,
0725 AcpiUtGetRegionName (RegionObj->Region.SpaceId)));
0726
0727
0728
0729 RegionObj->Region.Next = HandlerObj->AddressSpace.RegionList;
0730 HandlerObj->AddressSpace.RegionList = RegionObj;
0731
0732
0733
0734 if (RegionObj->Region.Handler)
0735 {
0736 return_ACPI_STATUS (AE_ALREADY_EXISTS);
0737 }
0738
0739 RegionObj->Region.Handler = HandlerObj;
0740 AcpiUtAddReference (HandlerObj);
0741
0742 return_ACPI_STATUS (AE_OK);
0743 }
0744
0745
0746
0747
0748
0749
0750
0751
0752
0753
0754
0755
0756
0757
0758
0759
0760
0761
0762
0763 static ACPI_STATUS
0764 AcpiEvInstallHandler (
0765 ACPI_HANDLE ObjHandle,
0766 UINT32 Level,
0767 void *Context,
0768 void **ReturnValue)
0769 {
0770 ACPI_OPERAND_OBJECT *HandlerObj;
0771 ACPI_OPERAND_OBJECT *NextHandlerObj;
0772 ACPI_OPERAND_OBJECT *ObjDesc;
0773 ACPI_NAMESPACE_NODE *Node;
0774 ACPI_STATUS Status;
0775
0776
0777 ACPI_FUNCTION_NAME (EvInstallHandler);
0778
0779
0780 HandlerObj = (ACPI_OPERAND_OBJECT *) Context;
0781
0782
0783
0784 if (!HandlerObj)
0785 {
0786 return (AE_OK);
0787 }
0788
0789
0790
0791 Node = AcpiNsMapHandleToNode (ObjHandle);
0792 if (!Node)
0793 {
0794 return (AE_BAD_PARAMETER);
0795 }
0796
0797
0798
0799
0800
0801 if ((Node->Type != ACPI_TYPE_DEVICE) &&
0802 (Node->Type != ACPI_TYPE_REGION) &&
0803 (Node != AcpiGbl_RootNode))
0804 {
0805 return (AE_OK);
0806 }
0807
0808
0809
0810 ObjDesc = AcpiNsGetAttachedObject (Node);
0811 if (!ObjDesc)
0812 {
0813
0814
0815 return (AE_OK);
0816 }
0817
0818
0819
0820 if (ObjDesc->Common.Type == ACPI_TYPE_DEVICE)
0821 {
0822
0823
0824 NextHandlerObj = ObjDesc->Device.Handler;
0825 while (NextHandlerObj)
0826 {
0827
0828
0829 if (NextHandlerObj->AddressSpace.SpaceId ==
0830 HandlerObj->AddressSpace.SpaceId)
0831 {
0832 ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
0833 "Found handler for region [%s] in device %p(%p) "
0834 "handler %p\n",
0835 AcpiUtGetRegionName (HandlerObj->AddressSpace.SpaceId),
0836 ObjDesc, NextHandlerObj, HandlerObj));
0837
0838
0839
0840
0841
0842
0843
0844
0845 return (AE_CTRL_DEPTH);
0846 }
0847
0848
0849
0850 NextHandlerObj = NextHandlerObj->AddressSpace.Next;
0851 }
0852
0853
0854
0855
0856
0857 return (AE_OK);
0858 }
0859
0860
0861
0862 if (ObjDesc->Region.SpaceId != HandlerObj->AddressSpace.SpaceId)
0863 {
0864
0865
0866 return (AE_OK);
0867 }
0868
0869
0870
0871
0872
0873
0874 AcpiEvDetachRegion (ObjDesc, FALSE);
0875
0876
0877
0878 Status = AcpiEvAttachRegion (HandlerObj, ObjDesc, FALSE);
0879 return (Status);
0880 }
0881
0882
0883
0884
0885
0886
0887
0888
0889
0890
0891
0892
0893
0894
0895
0896
0897
0898
0899
0900 ACPI_STATUS
0901 AcpiEvInstallSpaceHandler (
0902 ACPI_NAMESPACE_NODE *Node,
0903 ACPI_ADR_SPACE_TYPE SpaceId,
0904 ACPI_ADR_SPACE_HANDLER Handler,
0905 ACPI_ADR_SPACE_SETUP Setup,
0906 void *Context)
0907 {
0908 ACPI_OPERAND_OBJECT *ObjDesc;
0909 ACPI_OPERAND_OBJECT *HandlerObj;
0910 ACPI_STATUS Status;
0911 ACPI_OBJECT_TYPE Type;
0912 UINT8 Flags = 0;
0913
0914
0915 ACPI_FUNCTION_TRACE (EvInstallSpaceHandler);
0916
0917
0918
0919
0920
0921
0922 if ((Node->Type != ACPI_TYPE_DEVICE) &&
0923 (Node->Type != ACPI_TYPE_PROCESSOR) &&
0924 (Node->Type != ACPI_TYPE_THERMAL) &&
0925 (Node != AcpiGbl_RootNode))
0926 {
0927 Status = AE_BAD_PARAMETER;
0928 goto UnlockAndExit;
0929 }
0930
0931 if (Handler == ACPI_DEFAULT_HANDLER)
0932 {
0933 Flags = ACPI_ADDR_HANDLER_DEFAULT_INSTALLED;
0934
0935 switch (SpaceId)
0936 {
0937 case ACPI_ADR_SPACE_SYSTEM_MEMORY:
0938 Handler = AcpiExSystemMemorySpaceHandler;
0939 Setup = AcpiEvSystemMemoryRegionSetup;
0940 break;
0941
0942 case ACPI_ADR_SPACE_SYSTEM_IO:
0943 Handler = AcpiExSystemIoSpaceHandler;
0944 Setup = AcpiEvIoSpaceRegionSetup;
0945 break;
0946
0947 case ACPI_ADR_SPACE_PCI_CONFIG:
0948 Handler = AcpiExPciConfigSpaceHandler;
0949 Setup = AcpiEvPciConfigRegionSetup;
0950 break;
0951
0952 case ACPI_ADR_SPACE_CMOS:
0953 Handler = AcpiExCmosSpaceHandler;
0954 Setup = AcpiEvCmosRegionSetup;
0955 break;
0956
0957 case ACPI_ADR_SPACE_PCI_BAR_TARGET:
0958 Handler = AcpiExPciBarSpaceHandler;
0959 Setup = AcpiEvPciBarRegionSetup;
0960 break;
0961
0962 case ACPI_ADR_SPACE_DATA_TABLE:
0963 Handler = AcpiExDataTableSpaceHandler;
0964 Setup = NULL;
0965 break;
0966
0967 default:
0968 Status = AE_BAD_PARAMETER;
0969 goto UnlockAndExit;
0970 }
0971 }
0972
0973
0974
0975 if (!Setup)
0976 {
0977 Setup = AcpiEvDefaultRegionSetup;
0978 }
0979
0980
0981
0982 ObjDesc = AcpiNsGetAttachedObject (Node);
0983 if (ObjDesc)
0984 {
0985
0986
0987
0988
0989 HandlerObj = ObjDesc->Device.Handler;
0990
0991
0992
0993 while (HandlerObj)
0994 {
0995
0996
0997 if (HandlerObj->AddressSpace.SpaceId == SpaceId)
0998 {
0999 if (HandlerObj->AddressSpace.Handler == Handler)
1000 {
1001
1002
1003
1004
1005
1006 Status = AE_SAME_HANDLER;
1007 goto UnlockAndExit;
1008 }
1009 else
1010 {
1011
1012
1013 Status = AE_ALREADY_EXISTS;
1014 }
1015 goto UnlockAndExit;
1016 }
1017
1018
1019
1020 HandlerObj = HandlerObj->AddressSpace.Next;
1021 }
1022 }
1023 else
1024 {
1025 ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
1026 "Creating object on Device %p while installing handler\n", Node));
1027
1028
1029
1030 if (Node->Type == ACPI_TYPE_ANY)
1031 {
1032 Type = ACPI_TYPE_DEVICE;
1033 }
1034 else
1035 {
1036 Type = Node->Type;
1037 }
1038
1039 ObjDesc = AcpiUtCreateInternalObject (Type);
1040 if (!ObjDesc)
1041 {
1042 Status = AE_NO_MEMORY;
1043 goto UnlockAndExit;
1044 }
1045
1046
1047
1048 ObjDesc->Common.Type = (UINT8) Type;
1049
1050
1051
1052 Status = AcpiNsAttachObject (Node, ObjDesc, Type);
1053
1054
1055
1056 AcpiUtRemoveReference (ObjDesc);
1057
1058 if (ACPI_FAILURE (Status))
1059 {
1060 goto UnlockAndExit;
1061 }
1062 }
1063
1064 ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
1065 "Installing address handler for region %s(%X) on Device %4.4s %p(%p)\n",
1066 AcpiUtGetRegionName (SpaceId), SpaceId,
1067 AcpiUtGetNodeName (Node), Node, ObjDesc));
1068
1069
1070
1071
1072
1073
1074
1075 HandlerObj = AcpiUtCreateInternalObject (ACPI_TYPE_LOCAL_ADDRESS_HANDLER);
1076 if (!HandlerObj)
1077 {
1078 Status = AE_NO_MEMORY;
1079 goto UnlockAndExit;
1080 }
1081
1082
1083
1084 HandlerObj->AddressSpace.SpaceId = (UINT8) SpaceId;
1085 HandlerObj->AddressSpace.HandlerFlags = Flags;
1086 HandlerObj->AddressSpace.RegionList = NULL;
1087 HandlerObj->AddressSpace.Node = Node;
1088 HandlerObj->AddressSpace.Handler = Handler;
1089 HandlerObj->AddressSpace.Context = Context;
1090 HandlerObj->AddressSpace.Setup = Setup;
1091
1092
1093
1094 HandlerObj->AddressSpace.Next = ObjDesc->Device.Handler;
1095
1096
1097
1098
1099
1100 ObjDesc->Device.Handler = HandlerObj;
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114 Status = AcpiNsWalkNamespace (ACPI_TYPE_ANY, Node, ACPI_UINT32_MAX,
1115 ACPI_NS_WALK_UNLOCK, AcpiEvInstallHandler,
1116 HandlerObj, NULL);
1117
1118 UnlockAndExit:
1119 return_ACPI_STATUS (Status);
1120 }
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137 ACPI_STATUS
1138 AcpiEvExecuteRegMethods (
1139 ACPI_NAMESPACE_NODE *Node,
1140 ACPI_ADR_SPACE_TYPE SpaceId)
1141 {
1142 ACPI_STATUS Status;
1143
1144
1145 ACPI_FUNCTION_TRACE (EvExecuteRegMethods);
1146
1147
1148
1149
1150
1151
1152
1153
1154 Status = AcpiNsWalkNamespace (ACPI_TYPE_ANY, Node, ACPI_UINT32_MAX,
1155 ACPI_NS_WALK_UNLOCK, AcpiEvRegRun,
1156 &SpaceId, NULL);
1157
1158 return_ACPI_STATUS (Status);
1159 }
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172 static ACPI_STATUS
1173 AcpiEvRegRun (
1174 ACPI_HANDLE ObjHandle,
1175 UINT32 Level,
1176 void *Context,
1177 void **ReturnValue)
1178 {
1179 ACPI_OPERAND_OBJECT *ObjDesc;
1180 ACPI_NAMESPACE_NODE *Node;
1181 ACPI_ADR_SPACE_TYPE SpaceId;
1182 ACPI_STATUS Status;
1183
1184
1185 SpaceId = *ACPI_CAST_PTR (ACPI_ADR_SPACE_TYPE, Context);
1186
1187
1188
1189 Node = AcpiNsMapHandleToNode (ObjHandle);
1190 if (!Node)
1191 {
1192 return (AE_BAD_PARAMETER);
1193 }
1194
1195
1196
1197
1198
1199 if ((Node->Type != ACPI_TYPE_REGION) &&
1200 (Node != AcpiGbl_RootNode))
1201 {
1202 return (AE_OK);
1203 }
1204
1205
1206
1207 ObjDesc = AcpiNsGetAttachedObject (Node);
1208 if (!ObjDesc)
1209 {
1210
1211
1212 return (AE_OK);
1213 }
1214
1215
1216
1217 if (ObjDesc->Region.SpaceId != SpaceId)
1218 {
1219
1220
1221 return (AE_OK);
1222 }
1223
1224 Status = AcpiEvExecuteRegMethod (ObjDesc, 1);
1225 return (Status);
1226 }
1227