Warning, cross-references for /kernel/drivers/acpica/evxface.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 __EVXFACE_C__
0118
0119 #include "acpi.h"
0120 #include "accommon.h"
0121 #include "acnamesp.h"
0122 #include "acevents.h"
0123 #include "acinterp.h"
0124
0125 #define _COMPONENT ACPI_EVENTS
0126 ACPI_MODULE_NAME ("evxface")
0127
0128
0129
0130
0131
0132
0133
0134
0135
0136
0137
0138
0139
0140
0141
0142 ACPI_STATUS
0143 AcpiInstallExceptionHandler (
0144 ACPI_EXCEPTION_HANDLER Handler)
0145 {
0146 ACPI_STATUS Status;
0147
0148
0149 ACPI_FUNCTION_TRACE (AcpiInstallExceptionHandler);
0150
0151
0152 Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
0153 if (ACPI_FAILURE (Status))
0154 {
0155 return_ACPI_STATUS (Status);
0156 }
0157
0158
0159
0160 if (AcpiGbl_ExceptionHandler)
0161 {
0162 Status = AE_ALREADY_EXISTS;
0163 goto Cleanup;
0164 }
0165
0166
0167
0168 AcpiGbl_ExceptionHandler = Handler;
0169
0170 Cleanup:
0171 (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
0172 return_ACPI_STATUS (Status);
0173 }
0174
0175 ACPI_EXPORT_SYMBOL (AcpiInstallExceptionHandler)
0176
0177
0178
0179
0180
0181
0182
0183
0184
0185
0186
0187
0188
0189
0190
0191
0192
0193
0194 ACPI_STATUS
0195 AcpiInstallFixedEventHandler (
0196 UINT32 Event,
0197 ACPI_EVENT_HANDLER Handler,
0198 void *Context)
0199 {
0200 ACPI_STATUS Status;
0201
0202
0203 ACPI_FUNCTION_TRACE (AcpiInstallFixedEventHandler);
0204
0205
0206
0207
0208 if (Event > ACPI_EVENT_MAX)
0209 {
0210 return_ACPI_STATUS (AE_BAD_PARAMETER);
0211 }
0212
0213 Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
0214 if (ACPI_FAILURE (Status))
0215 {
0216 return_ACPI_STATUS (Status);
0217 }
0218
0219
0220
0221 if (NULL != AcpiGbl_FixedEventHandlers[Event].Handler)
0222 {
0223 Status = AE_ALREADY_EXISTS;
0224 goto Cleanup;
0225 }
0226
0227
0228
0229 AcpiGbl_FixedEventHandlers[Event].Handler = Handler;
0230 AcpiGbl_FixedEventHandlers[Event].Context = Context;
0231
0232 Status = AcpiEnableEvent (Event, 0);
0233 if (ACPI_FAILURE (Status))
0234 {
0235 ACPI_WARNING ((AE_INFO, "Could not enable fixed event %X", Event));
0236
0237
0238
0239 AcpiGbl_FixedEventHandlers[Event].Handler = NULL;
0240 AcpiGbl_FixedEventHandlers[Event].Context = NULL;
0241 }
0242 else
0243 {
0244 ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
0245 "Enabled fixed event %X, Handler=%p\n", Event, Handler));
0246 }
0247
0248
0249 Cleanup:
0250 (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
0251 return_ACPI_STATUS (Status);
0252 }
0253
0254 ACPI_EXPORT_SYMBOL (AcpiInstallFixedEventHandler)
0255
0256
0257
0258
0259
0260
0261
0262
0263
0264
0265
0266
0267
0268
0269
0270 ACPI_STATUS
0271 AcpiRemoveFixedEventHandler (
0272 UINT32 Event,
0273 ACPI_EVENT_HANDLER Handler)
0274 {
0275 ACPI_STATUS Status = AE_OK;
0276
0277
0278 ACPI_FUNCTION_TRACE (AcpiRemoveFixedEventHandler);
0279
0280
0281
0282
0283 if (Event > ACPI_EVENT_MAX)
0284 {
0285 return_ACPI_STATUS (AE_BAD_PARAMETER);
0286 }
0287
0288 Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
0289 if (ACPI_FAILURE (Status))
0290 {
0291 return_ACPI_STATUS (Status);
0292 }
0293
0294
0295
0296 Status = AcpiDisableEvent (Event, 0);
0297
0298
0299
0300 AcpiGbl_FixedEventHandlers[Event].Handler = NULL;
0301 AcpiGbl_FixedEventHandlers[Event].Context = NULL;
0302
0303 if (ACPI_FAILURE (Status))
0304 {
0305 ACPI_WARNING ((AE_INFO,
0306 "Could not write to fixed event enable register %X", Event));
0307 }
0308 else
0309 {
0310 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Disabled fixed event %X\n", Event));
0311 }
0312
0313 (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
0314 return_ACPI_STATUS (Status);
0315 }
0316
0317 ACPI_EXPORT_SYMBOL (AcpiRemoveFixedEventHandler)
0318
0319
0320
0321
0322
0323
0324
0325
0326
0327
0328
0329
0330
0331
0332
0333
0334
0335
0336
0337
0338 ACPI_STATUS
0339 AcpiInstallNotifyHandler (
0340 ACPI_HANDLE Device,
0341 UINT32 HandlerType,
0342 ACPI_NOTIFY_HANDLER Handler,
0343 void *Context)
0344 {
0345 ACPI_OPERAND_OBJECT *ObjDesc;
0346 ACPI_OPERAND_OBJECT *NotifyObj;
0347 ACPI_NAMESPACE_NODE *Node;
0348 ACPI_STATUS Status;
0349
0350
0351 ACPI_FUNCTION_TRACE (AcpiInstallNotifyHandler);
0352
0353
0354
0355
0356 if ((!Device) ||
0357 (!Handler) ||
0358 (HandlerType > ACPI_MAX_NOTIFY_HANDLER_TYPE))
0359 {
0360 return_ACPI_STATUS (AE_BAD_PARAMETER);
0361 }
0362
0363 Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
0364 if (ACPI_FAILURE (Status))
0365 {
0366 return_ACPI_STATUS (Status);
0367 }
0368
0369
0370
0371 Node = AcpiNsMapHandleToNode (Device);
0372 if (!Node)
0373 {
0374 Status = AE_BAD_PARAMETER;
0375 goto UnlockAndExit;
0376 }
0377
0378
0379
0380
0381
0382
0383
0384 if (Device == ACPI_ROOT_OBJECT)
0385 {
0386
0387
0388 if (((HandlerType & ACPI_SYSTEM_NOTIFY) &&
0389 AcpiGbl_SystemNotify.Handler) ||
0390 ((HandlerType & ACPI_DEVICE_NOTIFY) &&
0391 AcpiGbl_DeviceNotify.Handler))
0392 {
0393 Status = AE_ALREADY_EXISTS;
0394 goto UnlockAndExit;
0395 }
0396
0397 if (HandlerType & ACPI_SYSTEM_NOTIFY)
0398 {
0399 AcpiGbl_SystemNotify.Node = Node;
0400 AcpiGbl_SystemNotify.Handler = Handler;
0401 AcpiGbl_SystemNotify.Context = Context;
0402 }
0403
0404 if (HandlerType & ACPI_DEVICE_NOTIFY)
0405 {
0406 AcpiGbl_DeviceNotify.Node = Node;
0407 AcpiGbl_DeviceNotify.Handler = Handler;
0408 AcpiGbl_DeviceNotify.Context = Context;
0409 }
0410
0411
0412 }
0413
0414
0415
0416
0417
0418
0419 else
0420 {
0421
0422
0423 if (!AcpiEvIsNotifyObject (Node))
0424 {
0425 Status = AE_TYPE;
0426 goto UnlockAndExit;
0427 }
0428
0429
0430
0431 ObjDesc = AcpiNsGetAttachedObject (Node);
0432 if (ObjDesc)
0433 {
0434
0435
0436 if (((HandlerType & ACPI_SYSTEM_NOTIFY) &&
0437 ObjDesc->CommonNotify.SystemNotify) ||
0438 ((HandlerType & ACPI_DEVICE_NOTIFY) &&
0439 ObjDesc->CommonNotify.DeviceNotify))
0440 {
0441 Status = AE_ALREADY_EXISTS;
0442 goto UnlockAndExit;
0443 }
0444 }
0445 else
0446 {
0447
0448
0449 ObjDesc = AcpiUtCreateInternalObject (Node->Type);
0450 if (!ObjDesc)
0451 {
0452 Status = AE_NO_MEMORY;
0453 goto UnlockAndExit;
0454 }
0455
0456
0457
0458 Status = AcpiNsAttachObject (Device, ObjDesc, Node->Type);
0459
0460
0461
0462 AcpiUtRemoveReference (ObjDesc);
0463 if (ACPI_FAILURE (Status))
0464 {
0465 goto UnlockAndExit;
0466 }
0467 }
0468
0469
0470
0471 NotifyObj = AcpiUtCreateInternalObject (ACPI_TYPE_LOCAL_NOTIFY);
0472 if (!NotifyObj)
0473 {
0474 Status = AE_NO_MEMORY;
0475 goto UnlockAndExit;
0476 }
0477
0478 NotifyObj->Notify.Node = Node;
0479 NotifyObj->Notify.Handler = Handler;
0480 NotifyObj->Notify.Context = Context;
0481
0482 if (HandlerType & ACPI_SYSTEM_NOTIFY)
0483 {
0484 ObjDesc->CommonNotify.SystemNotify = NotifyObj;
0485 }
0486
0487 if (HandlerType & ACPI_DEVICE_NOTIFY)
0488 {
0489 ObjDesc->CommonNotify.DeviceNotify = NotifyObj;
0490 }
0491
0492 if (HandlerType == ACPI_ALL_NOTIFY)
0493 {
0494
0495
0496 AcpiUtAddReference (NotifyObj);
0497 }
0498 }
0499
0500
0501 UnlockAndExit:
0502 (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
0503 return_ACPI_STATUS (Status);
0504 }
0505
0506 ACPI_EXPORT_SYMBOL (AcpiInstallNotifyHandler)
0507
0508
0509
0510
0511
0512
0513
0514
0515
0516
0517
0518
0519
0520
0521
0522
0523
0524
0525
0526 ACPI_STATUS
0527 AcpiRemoveNotifyHandler (
0528 ACPI_HANDLE Device,
0529 UINT32 HandlerType,
0530 ACPI_NOTIFY_HANDLER Handler)
0531 {
0532 ACPI_OPERAND_OBJECT *NotifyObj;
0533 ACPI_OPERAND_OBJECT *ObjDesc;
0534 ACPI_NAMESPACE_NODE *Node;
0535 ACPI_STATUS Status;
0536
0537
0538 ACPI_FUNCTION_TRACE (AcpiRemoveNotifyHandler);
0539
0540
0541
0542
0543 if ((!Device) ||
0544 (!Handler) ||
0545 (HandlerType > ACPI_MAX_NOTIFY_HANDLER_TYPE))
0546 {
0547 return_ACPI_STATUS (AE_BAD_PARAMETER);
0548 }
0549
0550 Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
0551 if (ACPI_FAILURE (Status))
0552 {
0553 return_ACPI_STATUS (Status);
0554 }
0555
0556
0557
0558 Node = AcpiNsMapHandleToNode (Device);
0559 if (!Node)
0560 {
0561 Status = AE_BAD_PARAMETER;
0562 goto UnlockAndExit;
0563 }
0564
0565
0566
0567 if (Device == ACPI_ROOT_OBJECT)
0568 {
0569 ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
0570 "Removing notify handler for namespace root object\n"));
0571
0572 if (((HandlerType & ACPI_SYSTEM_NOTIFY) &&
0573 !AcpiGbl_SystemNotify.Handler) ||
0574 ((HandlerType & ACPI_DEVICE_NOTIFY) &&
0575 !AcpiGbl_DeviceNotify.Handler))
0576 {
0577 Status = AE_NOT_EXIST;
0578 goto UnlockAndExit;
0579 }
0580
0581 if (HandlerType & ACPI_SYSTEM_NOTIFY)
0582 {
0583 AcpiGbl_SystemNotify.Node = NULL;
0584 AcpiGbl_SystemNotify.Handler = NULL;
0585 AcpiGbl_SystemNotify.Context = NULL;
0586 }
0587
0588 if (HandlerType & ACPI_DEVICE_NOTIFY)
0589 {
0590 AcpiGbl_DeviceNotify.Node = NULL;
0591 AcpiGbl_DeviceNotify.Handler = NULL;
0592 AcpiGbl_DeviceNotify.Context = NULL;
0593 }
0594 }
0595
0596
0597
0598 else
0599 {
0600
0601
0602 if (!AcpiEvIsNotifyObject (Node))
0603 {
0604 Status = AE_TYPE;
0605 goto UnlockAndExit;
0606 }
0607
0608
0609
0610 ObjDesc = AcpiNsGetAttachedObject (Node);
0611 if (!ObjDesc)
0612 {
0613 Status = AE_NOT_EXIST;
0614 goto UnlockAndExit;
0615 }
0616
0617
0618
0619 if (HandlerType & ACPI_SYSTEM_NOTIFY)
0620 {
0621 NotifyObj = ObjDesc->CommonNotify.SystemNotify;
0622 if (!NotifyObj)
0623 {
0624 Status = AE_NOT_EXIST;
0625 goto UnlockAndExit;
0626 }
0627
0628 if (NotifyObj->Notify.Handler != Handler)
0629 {
0630 Status = AE_BAD_PARAMETER;
0631 goto UnlockAndExit;
0632 }
0633
0634
0635
0636 ObjDesc->CommonNotify.SystemNotify = NULL;
0637 AcpiUtRemoveReference (NotifyObj);
0638 }
0639
0640 if (HandlerType & ACPI_DEVICE_NOTIFY)
0641 {
0642 NotifyObj = ObjDesc->CommonNotify.DeviceNotify;
0643 if (!NotifyObj)
0644 {
0645 Status = AE_NOT_EXIST;
0646 goto UnlockAndExit;
0647 }
0648
0649 if (NotifyObj->Notify.Handler != Handler)
0650 {
0651 Status = AE_BAD_PARAMETER;
0652 goto UnlockAndExit;
0653 }
0654
0655
0656
0657 ObjDesc->CommonNotify.DeviceNotify = NULL;
0658 AcpiUtRemoveReference (NotifyObj);
0659 }
0660 }
0661
0662
0663 UnlockAndExit:
0664 (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
0665 return_ACPI_STATUS (Status);
0666 }
0667
0668 ACPI_EXPORT_SYMBOL (AcpiRemoveNotifyHandler)
0669
0670
0671
0672
0673
0674
0675
0676
0677
0678
0679
0680
0681
0682
0683
0684
0685
0686
0687
0688
0689 ACPI_STATUS
0690 AcpiInstallGpeHandler (
0691 ACPI_HANDLE GpeDevice,
0692 UINT32 GpeNumber,
0693 UINT32 Type,
0694 ACPI_EVENT_HANDLER Address,
0695 void *Context)
0696 {
0697 ACPI_GPE_EVENT_INFO *GpeEventInfo;
0698 ACPI_HANDLER_INFO *Handler;
0699 ACPI_STATUS Status;
0700 ACPI_CPU_FLAGS Flags;
0701
0702
0703 ACPI_FUNCTION_TRACE (AcpiInstallGpeHandler);
0704
0705
0706
0707
0708 if ((!Address) || (Type > ACPI_GPE_XRUPT_TYPE_MASK))
0709 {
0710 return_ACPI_STATUS (AE_BAD_PARAMETER);
0711 }
0712
0713 Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
0714 if (ACPI_FAILURE (Status))
0715 {
0716 return_ACPI_STATUS (Status);
0717 }
0718
0719
0720
0721 GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
0722 if (!GpeEventInfo)
0723 {
0724 Status = AE_BAD_PARAMETER;
0725 goto UnlockAndExit;
0726 }
0727
0728
0729
0730 if ((GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK) ==
0731 ACPI_GPE_DISPATCH_HANDLER)
0732 {
0733 Status = AE_ALREADY_EXISTS;
0734 goto UnlockAndExit;
0735 }
0736
0737
0738
0739 Handler = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_HANDLER_INFO));
0740 if (!Handler)
0741 {
0742 Status = AE_NO_MEMORY;
0743 goto UnlockAndExit;
0744 }
0745
0746 Handler->Address = Address;
0747 Handler->Context = Context;
0748 Handler->MethodNode = GpeEventInfo->Dispatch.MethodNode;
0749
0750
0751
0752 Status = AcpiEvDisableGpe (GpeEventInfo);
0753 if (ACPI_FAILURE (Status))
0754 {
0755 goto UnlockAndExit;
0756 }
0757
0758
0759
0760 Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
0761 GpeEventInfo->Dispatch.Handler = Handler;
0762
0763
0764
0765 GpeEventInfo->Flags &= ~(ACPI_GPE_XRUPT_TYPE_MASK | ACPI_GPE_DISPATCH_MASK);
0766 GpeEventInfo->Flags |= (UINT8) (Type | ACPI_GPE_DISPATCH_HANDLER);
0767
0768 AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
0769
0770
0771 UnlockAndExit:
0772 (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
0773 return_ACPI_STATUS (Status);
0774 }
0775
0776 ACPI_EXPORT_SYMBOL (AcpiInstallGpeHandler)
0777
0778
0779
0780
0781
0782
0783
0784
0785
0786
0787
0788
0789
0790
0791
0792
0793
0794 ACPI_STATUS
0795 AcpiRemoveGpeHandler (
0796 ACPI_HANDLE GpeDevice,
0797 UINT32 GpeNumber,
0798 ACPI_EVENT_HANDLER Address)
0799 {
0800 ACPI_GPE_EVENT_INFO *GpeEventInfo;
0801 ACPI_HANDLER_INFO *Handler;
0802 ACPI_STATUS Status;
0803 ACPI_CPU_FLAGS Flags;
0804
0805
0806 ACPI_FUNCTION_TRACE (AcpiRemoveGpeHandler);
0807
0808
0809
0810
0811 if (!Address)
0812 {
0813 return_ACPI_STATUS (AE_BAD_PARAMETER);
0814 }
0815
0816 Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
0817 if (ACPI_FAILURE (Status))
0818 {
0819 return_ACPI_STATUS (Status);
0820 }
0821
0822
0823
0824 GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
0825 if (!GpeEventInfo)
0826 {
0827 Status = AE_BAD_PARAMETER;
0828 goto UnlockAndExit;
0829 }
0830
0831
0832
0833 if ((GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK) !=
0834 ACPI_GPE_DISPATCH_HANDLER)
0835 {
0836 Status = AE_NOT_EXIST;
0837 goto UnlockAndExit;
0838 }
0839
0840
0841
0842 if (GpeEventInfo->Dispatch.Handler->Address != Address)
0843 {
0844 Status = AE_BAD_PARAMETER;
0845 goto UnlockAndExit;
0846 }
0847
0848
0849
0850 Status = AcpiEvDisableGpe (GpeEventInfo);
0851 if (ACPI_FAILURE (Status))
0852 {
0853 goto UnlockAndExit;
0854 }
0855
0856
0857
0858 Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
0859 Handler = GpeEventInfo->Dispatch.Handler;
0860
0861
0862
0863 GpeEventInfo->Dispatch.MethodNode = Handler->MethodNode;
0864 GpeEventInfo->Flags &= ~ACPI_GPE_DISPATCH_MASK;
0865 if (Handler->MethodNode)
0866 {
0867 GpeEventInfo->Flags |= ACPI_GPE_DISPATCH_METHOD;
0868 }
0869 AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
0870
0871
0872
0873 ACPI_FREE (Handler);
0874
0875
0876 UnlockAndExit:
0877 (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
0878 return_ACPI_STATUS (Status);
0879 }
0880
0881 ACPI_EXPORT_SYMBOL (AcpiRemoveGpeHandler)
0882
0883
0884
0885
0886
0887
0888
0889
0890
0891
0892
0893
0894
0895
0896
0897
0898
0899
0900
0901
0902
0903
0904 ACPI_STATUS
0905 AcpiAcquireGlobalLock (
0906 UINT16 Timeout,
0907 UINT32 *Handle)
0908 {
0909 ACPI_STATUS Status;
0910
0911
0912 if (!Handle)
0913 {
0914 return (AE_BAD_PARAMETER);
0915 }
0916
0917
0918
0919 AcpiExEnterInterpreter ();
0920
0921 Status = AcpiExAcquireMutexObject (Timeout,
0922 AcpiGbl_GlobalLockMutex, AcpiOsGetThreadId ());
0923
0924 if (ACPI_SUCCESS (Status))
0925 {
0926
0927
0928 *Handle = AcpiGbl_GlobalLockHandle;
0929 }
0930
0931 AcpiExExitInterpreter ();
0932 return (Status);
0933 }
0934
0935 ACPI_EXPORT_SYMBOL (AcpiAcquireGlobalLock)
0936
0937
0938
0939
0940
0941
0942
0943
0944
0945
0946
0947
0948
0949
0950 ACPI_STATUS
0951 AcpiReleaseGlobalLock (
0952 UINT32 Handle)
0953 {
0954 ACPI_STATUS Status;
0955
0956
0957 if (!Handle || (Handle != AcpiGbl_GlobalLockHandle))
0958 {
0959 return (AE_NOT_ACQUIRED);
0960 }
0961
0962 Status = AcpiExReleaseMutexObject (AcpiGbl_GlobalLockMutex);
0963 return (Status);
0964 }
0965
0966 ACPI_EXPORT_SYMBOL (AcpiReleaseGlobalLock)
0967