drivers/acpi/events/evxface.c

   1 /******************************************************************************
   2  *
   3  * Module Name: evxface - External interfaces for ACPI events
   4  *              $Revision: 97 $
   5  *
   6  *****************************************************************************/
   7
   8 /*
   9  *  Copyright (C) 2000 R. Byron Moore
  10  *
  11  *  This program is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This program is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; if not, write to the Free Software
  23  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  24  */
  25
  26
  27 #include "acpi.h"
  28 #include "achware.h"
  29 #include "acnamesp.h"
  30 #include "acevents.h"
  31 #include "amlcode.h"
  32 #include "acinterp.h"
  33
  34 #define _COMPONENT          EVENT_HANDLING
  35          MODULE_NAME         ("evxface")
  36
  37
  38 /******************************************************************************
  39  *
  40  * FUNCTION:    Acpi_install_fixed_event_handler
  41  *
  42  * PARAMETERS:  Event           - Event type to enable.
  43  *              Handler         - Pointer to the handler function for the
  44  *                                event
  45  *              Context         - Value passed to the handler on each GPE
  46  *
  47  * RETURN:      Status
  48  *
  49  * DESCRIPTION: Saves the pointer to the handler function and then enables the
  50  *              event.
  51  *
  52  ******************************************************************************/
  53
  54 ACPI_STATUS
  55 acpi_install_fixed_event_handler (
  56         u32                     event,
  57         FIXED_EVENT_HANDLER     handler,
  58         void                    *context)
  59 {
  60         ACPI_STATUS             status = AE_OK;
  61
  62
  63         /* Sanity check the parameters. */
  64
  65         if (event >= NUM_FIXED_EVENTS) {
  66                 return (AE_BAD_PARAMETER);
  67         }
  68
  69         acpi_cm_acquire_mutex (ACPI_MTX_EVENTS);
  70
  71         /* Don't allow two handlers. */
  72
  73         if (NULL != acpi_gbl_fixed_event_handlers[event].handler) {
  74                 status = AE_EXIST;
  75                 goto cleanup;
  76         }
  77
  78
  79         /* Install the handler before enabling the event - just in case... */
  80
  81         acpi_gbl_fixed_event_handlers[event].handler = handler;
  82         acpi_gbl_fixed_event_handlers[event].context = context;
  83
  84         status = acpi_enable_event(event, ACPI_EVENT_FIXED);
  85
  86         if (!ACPI_SUCCESS(status)) {
  87                 /* Remove the handler */
  88
  89                 acpi_gbl_fixed_event_handlers[event].handler = NULL;
  90                 acpi_gbl_fixed_event_handlers[event].context = NULL;
  91
  92                 status = AE_ERROR;
  93                 goto cleanup;
  94         }
  95
  96
  97 cleanup:
  98         acpi_cm_release_mutex (ACPI_MTX_EVENTS);
  99         return (status);
 100 }
 101
 102
 103 /******************************************************************************
 104  *
 105  * FUNCTION:    Acpi_remove_fixed_event_handler
 106  *
 107  * PARAMETERS:  Event           - Event type to disable.
 108  *              Handler         - Address of the handler
 109  *
 110  * RETURN:      Status
 111  *
 112  * DESCRIPTION: Disables the event and unregisters the event handler.
 113  *
 114  ******************************************************************************/
 115
 116 ACPI_STATUS
 117 acpi_remove_fixed_event_handler (
 118         u32                     event,
 119         FIXED_EVENT_HANDLER     handler)
 120 {
 121         ACPI_STATUS             status = AE_OK;
 122
 123
 124         /* Sanity check the parameters. */
 125
 126         if (event >= NUM_FIXED_EVENTS) {
 127                 return (AE_BAD_PARAMETER);
 128         }
 129
 130         acpi_cm_acquire_mutex (ACPI_MTX_EVENTS);
 131
 132         /* Disable the event before removing the handler - just in case... */
 133
 134         status = acpi_disable_event(event, ACPI_EVENT_FIXED);
 135
 136         if (!ACPI_SUCCESS(status)) {
 137                 status = AE_ERROR;
 138                 acpi_cm_release_mutex (ACPI_MTX_EVENTS);
 139                 return (status);
 140         }
 141
 142         /* Remove the handler */
 143
 144         acpi_gbl_fixed_event_handlers[event].handler = NULL;
 145         acpi_gbl_fixed_event_handlers[event].context = NULL;
 146
 147         acpi_cm_release_mutex (ACPI_MTX_EVENTS);
 148         return (status);
 149 }
 150
 151
 152 /******************************************************************************
 153  *
 154  * FUNCTION:    Acpi_install_notify_handler
 155  *
 156  * PARAMETERS:  Device          - The device for which notifies will be handled
 157  *              Handler_type    - The type of handler:
 158  *                                  ACPI_SYSTEM_NOTIFY: System_handler (00-7f)
 159  *                                  ACPI_DEVICE_NOTIFY: Driver_handler (80-ff)
 160  *              Handler         - Address of the handler
 161  *              Context         - Value passed to the handler on each GPE
 162  *
 163  * RETURN:      Status
 164  *
 165  * DESCRIPTION: Install a handler for notifies on an ACPI device
 166  *
 167  ******************************************************************************/
 168
 169 ACPI_STATUS
 170 acpi_install_notify_handler (
 171         ACPI_HANDLE             device,
 172         u32                     handler_type,
 173         NOTIFY_HANDLER          handler,
 174         void                    *context)
 175 {
 176         ACPI_OPERAND_OBJECT     *obj_desc;
 177         ACPI_OPERAND_OBJECT     *notify_obj;
 178         ACPI_NAMESPACE_NODE     *device_node;
 179         ACPI_STATUS             status = AE_OK;
 180
 181
 182         /* Parameter validation */
 183
 184         if ((!handler) ||
 185                 (handler_type > ACPI_MAX_NOTIFY_HANDLER_TYPE))
 186         {
 187                 return (AE_BAD_PARAMETER);
 188         }
 189
 190         /* Convert and validate the device handle */
 191
 192         acpi_cm_acquire_mutex (ACPI_MTX_NAMESPACE);
 193
 194         device_node = acpi_ns_convert_handle_to_entry (device);
 195         if (!device_node) {
 196                 status = AE_BAD_PARAMETER;
 197                 goto unlock_and_exit;
 198         }
 199
 200
 201         /*
 202          * Support for global notify handlers.  These handlers are invoked for
 203          * every notifiy of the type specifiec
 204          */
 205
 206         if (device == ACPI_ROOT_OBJECT) {
 207                 /*
 208                  *  Make sure the handler is not already installed.
 209                  */
 210
 211                 if (((handler_type == ACPI_SYSTEM_NOTIFY) &&
 212                           acpi_gbl_sys_notify.handler) ||
 213                         ((handler_type == ACPI_DEVICE_NOTIFY) &&
 214                           acpi_gbl_drv_notify.handler))
 215                 {
 216                         status = AE_EXIST;
 217                         goto unlock_and_exit;
 218                 }
 219
 220                 if (handler_type == ACPI_SYSTEM_NOTIFY) {
 221                         acpi_gbl_sys_notify.node = device_node;
 222                         acpi_gbl_sys_notify.handler = handler;
 223                         acpi_gbl_sys_notify.context = context;
 224                 }
 225
 226                 else {
 227                         acpi_gbl_drv_notify.node = device_node;
 228                         acpi_gbl_drv_notify.handler = handler;
 229                         acpi_gbl_drv_notify.context = context;
 230                 }
 231
 232
 233                 /* Global notify handler installed */
 234
 235                 goto unlock_and_exit;
 236         }
 237
 238
 239         /*
 240          * These are the ONLY objects that can receive ACPI notifications
 241          */
 242
 243         if ((device_node->type != ACPI_TYPE_DEVICE)    &&
 244                 (device_node->type != ACPI_TYPE_PROCESSOR) &&
 245                 (device_node->type != ACPI_TYPE_POWER)     &&
 246                 (device_node->type != ACPI_TYPE_THERMAL))
 247         {
 248                 status = AE_BAD_PARAMETER;
 249                 goto unlock_and_exit;
 250         }
 251
 252         /* Check for an existing internal object */
 253
 254         obj_desc = acpi_ns_get_attached_object ((ACPI_HANDLE) device_node);
 255         if (obj_desc) {
 256                 /*
 257                  *  The object exists.
 258                  *  Make sure the handler is not already installed.
 259                  */
 260
 261                 if (((handler_type == ACPI_SYSTEM_NOTIFY) &&
 262                           obj_desc->device.sys_handler) ||
 263                         ((handler_type == ACPI_DEVICE_NOTIFY) &&
 264                           obj_desc->device.drv_handler))
 265                 {
 266                         status = AE_EXIST;
 267                         goto unlock_and_exit;
 268                 }
 269         }
 270
 271         else {
 272                 /* Create a new object */
 273
 274                 obj_desc = acpi_cm_create_internal_object (device_node->type);
 275                 if (!obj_desc) {
 276                         status = AE_NO_MEMORY;
 277                         goto unlock_and_exit;
 278                 }
 279
 280                 /* Attach new object to the Node */
 281
 282                 status = acpi_ns_attach_object (device, obj_desc, (u8) device_node->type);
 283
 284                 if (ACPI_FAILURE (status)) {
 285                         goto unlock_and_exit;
 286                 }
 287         }
 288
 289
 290         /*
 291          *  If we get here, we know that there is no handler installed
 292          *  so let's party
 293          */
 294         notify_obj = acpi_cm_create_internal_object (INTERNAL_TYPE_NOTIFY);
 295         if (!notify_obj) {
 296                 status = AE_NO_MEMORY;
 297                 goto unlock_and_exit;
 298         }
 299
 300         notify_obj->notify_handler.node = device_node;
 301         notify_obj->notify_handler.handler = handler;
 302         notify_obj->notify_handler.context = context;
 303
 304
 305         if (handler_type == ACPI_SYSTEM_NOTIFY) {
 306                 obj_desc->device.sys_handler = notify_obj;
 307         }
 308
 309         else {
 310                 obj_desc->device.drv_handler = notify_obj;
 311         }
 312
 313
 314 unlock_and_exit:
 315         acpi_cm_release_mutex (ACPI_MTX_NAMESPACE);
 316         return (status);
 317 }
 318
 319
 320 /*****************************************************************************
 321  *
 322  * FUNCTION:    Acpi_remove_notify_handler
 323  *
 324  * PARAMETERS:  Device          - The device for which notifies will be handled
 325  *              Handler_type    - The type of handler:
 326  *                                  ACPI_SYSTEM_NOTIFY: System_handler (00-7f)
 327  *                                  ACPI_DEVICE_NOTIFY: Driver_handler (80-ff)
 328  *              Handler         - Address of the handler
 329  * RETURN:      Status
 330  *
 331  * DESCRIPTION: Remove a handler for notifies on an ACPI device
 332  *
 333  ******************************************************************************/
 334
 335 ACPI_STATUS
 336 acpi_remove_notify_handler (
 337         ACPI_HANDLE             device,
 338         u32                     handler_type,
 339         NOTIFY_HANDLER          handler)
 340 {
 341         ACPI_OPERAND_OBJECT     *notify_obj;
 342         ACPI_OPERAND_OBJECT     *obj_desc;
 343         ACPI_NAMESPACE_NODE     *device_node;
 344         ACPI_STATUS             status = AE_OK;
 345
 346
 347         /* Parameter validation */
 348
 349         if ((!handler) ||
 350                 (handler_type > ACPI_MAX_NOTIFY_HANDLER_TYPE))
 351         {
 352                 return (AE_BAD_PARAMETER);
 353         }
 354
 355         acpi_cm_acquire_mutex (ACPI_MTX_NAMESPACE);
 356
 357         /* Convert and validate the device handle */
 358
 359         device_node = acpi_ns_convert_handle_to_entry (device);
 360         if (!device_node) {
 361                 status = AE_BAD_PARAMETER;
 362                 goto unlock_and_exit;
 363         }
 364
 365         /*
 366          * These are the ONLY objects that can receive ACPI notifications
 367          */
 368
 369         if ((device_node->type != ACPI_TYPE_DEVICE)    &&
 370                 (device_node->type != ACPI_TYPE_PROCESSOR) &&
 371                 (device_node->type != ACPI_TYPE_POWER)     &&
 372                 (device_node->type != ACPI_TYPE_THERMAL))
 373         {
 374                 status = AE_BAD_PARAMETER;
 375                 goto unlock_and_exit;
 376         }
 377
 378         /* Check for an existing internal object */
 379
 380         obj_desc = acpi_ns_get_attached_object ((ACPI_HANDLE) device_node);
 381         if (!obj_desc) {
 382                 status = AE_NOT_EXIST;
 383                 goto unlock_and_exit;
 384         }
 385
 386         /*
 387          *  The object exists.
 388          *
 389          *  Make sure the handler is installed.
 390          */
 391
 392         if (handler_type == ACPI_SYSTEM_NOTIFY) {
 393                 notify_obj = obj_desc->device.sys_handler;
 394         }
 395         else {
 396                 notify_obj = obj_desc->device.drv_handler;
 397         }
 398
 399         if ((!notify_obj) ||
 400                 (notify_obj->notify_handler.handler != handler))
 401         {
 402                 status = AE_BAD_PARAMETER;
 403                 goto unlock_and_exit;
 404         }
 405
 406         /*
 407          * Now we can remove the handler
 408          */
 409         if (handler_type == ACPI_SYSTEM_NOTIFY) {
 410                 obj_desc->device.sys_handler = NULL;
 411         }
 412         else {
 413                 obj_desc->device.drv_handler = NULL;
 414         }
 415
 416         acpi_cm_remove_reference (notify_obj);
 417
 418 unlock_and_exit:
 419         acpi_cm_release_mutex (ACPI_MTX_NAMESPACE);
 420         return (status);
 421 }
 422
 423 /******************************************************************************
 424  *
 425  * FUNCTION:    Acpi_install_gpe_handler
 426  *
 427  * PARAMETERS:  Gpe_number      - The GPE number.  The numbering scheme is
 428  *                                bank 0 first, then bank 1.
 429  *              Type            - Whether this GPE should be treated as an
 430  *                                edge- or level-triggered interrupt.
 431  *              Handler         - Address of the handler
 432  *              Context         - Value passed to the handler on each GPE
 433  *
 434  * RETURN:      Status
 435  *
 436  * DESCRIPTION: Install a handler for a General Purpose Event.
 437  *
 438  ******************************************************************************/
 439
 440 ACPI_STATUS
 441 acpi_install_gpe_handler (
 442         u32                     gpe_number,
 443         u32                     type,
 444         GPE_HANDLER             handler,
 445         void                    *context)
 446 {
 447         ACPI_STATUS             status = AE_OK;
 448
 449         /* Parameter validation */
 450
 451         if (!handler || (gpe_number > NUM_GPE)) {
 452                 return (AE_BAD_PARAMETER);
 453         }
 454
 455         /* Ensure that we have a valid GPE number */
 456
 457         if (acpi_gbl_gpe_valid[gpe_number] == ACPI_GPE_INVALID) {
 458                 return (AE_BAD_PARAMETER);
 459         }
 460
 461         acpi_cm_acquire_mutex (ACPI_MTX_EVENTS);
 462
 463         /* Make sure that there isn't a handler there already */
 464
 465         if (acpi_gbl_gpe_info[gpe_number].handler) {
 466                 status = AE_EXIST;
 467                 goto cleanup;
 468         }
 469
 470         /* Install the handler */
 471
 472         acpi_gbl_gpe_info[gpe_number].handler = handler;
 473         acpi_gbl_gpe_info[gpe_number].context = context;
 474         acpi_gbl_gpe_info[gpe_number].type = (u8) type;
 475
 476         /* Clear the GPE (of stale events), the enable it */
 477
 478         acpi_hw_clear_gpe (gpe_number);
 479         acpi_hw_enable_gpe (gpe_number);
 480
 481 cleanup:
 482         acpi_cm_release_mutex (ACPI_MTX_EVENTS);
 483         return (status);
 484 }
 485
 486
 487 /******************************************************************************
 488  *
 489  * FUNCTION:    Acpi_remove_gpe_handler
 490  *
 491  * PARAMETERS:  Gpe_number      - The event to remove a handler
 492  *              Handler         - Address of the handler
 493  *
 494  * RETURN:      Status
 495  *
 496  * DESCRIPTION: Remove a handler for a General Purpose Acpi_event.
 497  *
 498  ******************************************************************************/
 499
 500 ACPI_STATUS
 501 acpi_remove_gpe_handler (
 502         u32                     gpe_number,
 503         GPE_HANDLER             handler)
 504 {
 505         ACPI_STATUS             status = AE_OK;
 506
 507
 508         /* Parameter validation */
 509
 510         if (!handler || (gpe_number > NUM_GPE)) {
 511                 return (AE_BAD_PARAMETER);
 512         }
 513
 514         /* Ensure that we have a valid GPE number */
 515
 516         if (acpi_gbl_gpe_valid[gpe_number] == ACPI_GPE_INVALID) {
 517                 return (AE_BAD_PARAMETER);
 518         }
 519
 520         /* Disable the GPE before removing the handler */
 521
 522         acpi_hw_disable_gpe (gpe_number);
 523
 524         acpi_cm_acquire_mutex (ACPI_MTX_EVENTS);
 525
 526         /* Make sure that the installed handler is the same */
 527
 528         if (acpi_gbl_gpe_info[gpe_number].handler != handler) {
 529                 acpi_hw_enable_gpe (gpe_number);
 530                 status = AE_BAD_PARAMETER;
 531                 goto cleanup;
 532         }
 533
 534         /* Remove the handler */
 535
 536         acpi_gbl_gpe_info[gpe_number].handler = NULL;
 537         acpi_gbl_gpe_info[gpe_number].context = NULL;
 538
 539 cleanup:
 540         acpi_cm_release_mutex (ACPI_MTX_EVENTS);
 541         return (status);
 542 }
 543
 544
 545 /******************************************************************************
 546  *
 547  * FUNCTION:    Acpi_acquire_global_lock
 548  *
 549  * PARAMETERS:  Timeout         - How long the caller is willing to wait
 550  *              Out_handle      - A handle to the lock if acquired
 551  *
 552  * RETURN:      Status
 553  *
 554  * DESCRIPTION: Acquire the ACPI Global Lock
 555  *
 556  ******************************************************************************/
 557 ACPI_STATUS
 558 acpi_acquire_global_lock (
 559         void)
 560 {
 561         ACPI_STATUS             status;
 562
 563
 564         acpi_aml_enter_interpreter ();
 565
 566         /*
 567          * TBD: [Restructure] add timeout param to internal interface, and
 568          * perhaps INTERPRETER_LOCKED
 569          */
 570
 571         status = acpi_ev_acquire_global_lock ();
 572         acpi_aml_exit_interpreter ();
 573
 574         return (status);
 575 }
 576
 577
 578 /******************************************************************************
 579  *
 580  * FUNCTION:    Acpi_release_global_lock
 581  *
 582  * PARAMETERS:  Handle      - Returned from Acpi_acquire_global_lock
 583  *
 584  * RETURN:      Status
 585  *
 586  * DESCRIPTION: Release the ACPI Global Lock
 587  *
 588  ******************************************************************************/
 589
 590 ACPI_STATUS
 591 acpi_release_global_lock (
 592         void)
 593 {
 594         acpi_ev_release_global_lock ();
 595         return (AE_OK);
 596 }
 597
 598