drivers/acpi/events/evxfevnt.c

   1 /******************************************************************************
   2  *
   3  * Module Name: evxfevnt - External Interfaces, ACPI event disable/enable
   4  *              $Revision: 26 $
   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         ("evxfevnt")
  36
  37
  38 /**************************************************************************
  39  *
  40  * FUNCTION:    Acpi_enable
  41  *
  42  * PARAMETERS:  None
  43  *
  44  * RETURN:      Status
  45  *
  46  * DESCRIPTION: Transfers the system into ACPI mode.
  47  *
  48  *************************************************************************/
  49
  50 ACPI_STATUS
  51 acpi_enable (void)
  52 {
  53         ACPI_STATUS             status;
  54
  55
  56         /* Make sure we've got ACPI tables */
  57
  58         if (!acpi_gbl_DSDT) {
  59                 return (AE_NO_ACPI_TABLES);
  60         }
  61
  62         /* Make sure the BIOS supports ACPI mode */
  63
  64         if (SYS_MODE_LEGACY == acpi_hw_get_mode_capabilities()) {
  65                 return (AE_ERROR);
  66         }
  67
  68         /* Transition to ACPI mode */
  69
  70         status = acpi_hw_set_mode (SYS_MODE_ACPI);
  71         if (ACPI_FAILURE (status)) {
  72                 return (status);
  73         }
  74
  75         return (status);
  76 }
  77
  78
  79 /**************************************************************************
  80  *
  81  * FUNCTION:    Acpi_disable
  82  *
  83  * PARAMETERS:  None
  84  *
  85  * RETURN:      Status
  86  *
  87  * DESCRIPTION: Returns the system to original ACPI/legacy mode, and
  88  *              uninstalls the SCI interrupt handler.
  89  *
  90  *************************************************************************/
  91
  92 ACPI_STATUS
  93 acpi_disable (void)
  94 {
  95         ACPI_STATUS             status;
  96
  97
  98         /* Restore original mode  */
  99
 100         status = acpi_hw_set_mode (acpi_gbl_original_mode);
 101         if (ACPI_FAILURE (status)) {
 102                 return (status);
 103         }
 104
 105         /* Unload the SCI interrupt handler  */
 106
 107         acpi_ev_remove_sci_handler ();
 108         acpi_ev_restore_acpi_state ();
 109
 110         return (status);
 111 }
 112
 113
 114 /******************************************************************************
 115  *
 116  * FUNCTION:    Acpi_enable_event
 117  *
 118  * PARAMETERS:  Event           - The fixed event or GPE to be enabled
 119  *              Type            - The type of event
 120  *
 121  * RETURN:      Status
 122  *
 123  * DESCRIPTION: Enable an ACPI event (fixed and general purpose)
 124  *
 125  ******************************************************************************/
 126
 127 ACPI_STATUS
 128 acpi_enable_event (
 129         u32                     event,
 130         u32                     type)
 131 {
 132         ACPI_STATUS             status = AE_OK;
 133         u32                     register_id;
 134
 135
 136         /* The Type must be either Fixed Acpi_event or GPE */
 137
 138         switch (type)
 139         {
 140
 141         case ACPI_EVENT_FIXED:
 142
 143                 /* Decode the Fixed Acpi_event */
 144
 145                 switch (event)
 146                 {
 147                 case ACPI_EVENT_PMTIMER:
 148                         register_id = TMR_EN;
 149                         break;
 150
 151                 case ACPI_EVENT_GLOBAL:
 152                         register_id = GBL_EN;
 153                         break;
 154
 155                 case ACPI_EVENT_POWER_BUTTON:
 156                         register_id = PWRBTN_EN;
 157                         break;
 158
 159                 case ACPI_EVENT_SLEEP_BUTTON:
 160                         register_id = SLPBTN_EN;
 161                         break;
 162
 163                 case ACPI_EVENT_RTC:
 164                         register_id = RTC_EN;
 165                         break;
 166
 167                 default:
 168                         return (AE_BAD_PARAMETER);
 169                         break;
 170                 }
 171
 172                 /*
 173                  * Enable the requested fixed event (by writing a one to the
 174                  * enable register bit)
 175                  */
 176
 177                 acpi_hw_register_bit_access (ACPI_WRITE, ACPI_MTX_LOCK, register_id, 1);
 178
 179                 if (1 != acpi_hw_register_bit_access(ACPI_READ, ACPI_MTX_LOCK, register_id)) {
 180                         return (AE_ERROR);
 181                 }
 182
 183                 break;
 184
 185
 186         case ACPI_EVENT_GPE:
 187
 188                 /* Ensure that we have a valid GPE number */
 189
 190                 if ((event >= NUM_GPE) ||
 191                         (acpi_gbl_gpe_valid[event] == ACPI_GPE_INVALID))
 192                 {
 193                         return (AE_BAD_PARAMETER);
 194                 }
 195
 196
 197                 /* Enable the requested GPE number */
 198
 199                 acpi_hw_enable_gpe (event);
 200                 break;
 201
 202
 203         default:
 204
 205                 status = AE_BAD_PARAMETER;
 206         }
 207
 208
 209         return (status);
 210 }
 211
 212
 213 /******************************************************************************
 214  *
 215  * FUNCTION:    Acpi_disable_event
 216  *
 217  * PARAMETERS:  Event           - The fixed event or GPE to be enabled
 218  *              Type            - The type of event
 219  *
 220  * RETURN:      Status
 221  *
 222  * DESCRIPTION: Disable an ACPI event (fixed and general purpose)
 223  *
 224  ******************************************************************************/
 225
 226 ACPI_STATUS
 227 acpi_disable_event (
 228         u32                     event,
 229         u32                     type)
 230 {
 231         ACPI_STATUS             status = AE_OK;
 232         u32                     register_id;
 233
 234
 235         /* The Type must be either Fixed Acpi_event or GPE */
 236
 237         switch (type)
 238         {
 239
 240         case ACPI_EVENT_FIXED:
 241
 242                 /* Decode the Fixed Acpi_event */
 243
 244                 switch (event)
 245                 {
 246                 case ACPI_EVENT_PMTIMER:
 247                         register_id = TMR_EN;
 248                         break;
 249
 250                 case ACPI_EVENT_GLOBAL:
 251                         register_id = GBL_EN;
 252                         break;
 253
 254                 case ACPI_EVENT_POWER_BUTTON:
 255                         register_id = PWRBTN_EN;
 256                         break;
 257
 258                 case ACPI_EVENT_SLEEP_BUTTON:
 259                         register_id = SLPBTN_EN;
 260                         break;
 261
 262                 case ACPI_EVENT_RTC:
 263                         register_id = RTC_EN;
 264                         break;
 265
 266                 default:
 267                         return (AE_BAD_PARAMETER);
 268                         break;
 269                 }
 270
 271                 /*
 272                  * Disable the requested fixed event (by writing a zero to the
 273                  * enable register bit)
 274                  */
 275
 276                 acpi_hw_register_bit_access (ACPI_WRITE, ACPI_MTX_LOCK, register_id, 0);
 277
 278                 if (0 != acpi_hw_register_bit_access(ACPI_READ, ACPI_MTX_LOCK, register_id)) {
 279                         return (AE_ERROR);
 280                 }
 281
 282                 break;
 283
 284
 285         case ACPI_EVENT_GPE:
 286
 287                 /* Ensure that we have a valid GPE number */
 288
 289                 if ((event >= NUM_GPE) ||
 290                         (acpi_gbl_gpe_valid[event] == ACPI_GPE_INVALID))
 291                 {
 292                         return (AE_BAD_PARAMETER);
 293                 }
 294
 295                 /* Disable the requested GPE number */
 296
 297                 acpi_hw_disable_gpe (event);
 298                 break;
 299
 300
 301         default:
 302                 status = AE_BAD_PARAMETER;
 303         }
 304
 305         return (status);
 306 }
 307
 308
 309 /******************************************************************************
 310  *
 311  * FUNCTION:    Acpi_clear_event
 312  *
 313  * PARAMETERS:  Event           - The fixed event or GPE to be cleared
 314  *              Type            - The type of event
 315  *
 316  * RETURN:      Status
 317  *
 318  * DESCRIPTION: Clear an ACPI event (fixed and general purpose)
 319  *
 320  ******************************************************************************/
 321
 322 ACPI_STATUS
 323 acpi_clear_event (
 324         u32                     event,
 325         u32                     type)
 326 {
 327         ACPI_STATUS             status = AE_OK;
 328         u32                     register_id;
 329
 330
 331         /* The Type must be either Fixed Acpi_event or GPE */
 332
 333         switch (type)
 334         {
 335
 336         case ACPI_EVENT_FIXED:
 337
 338                 /* Decode the Fixed Acpi_event */
 339
 340                 switch (event)
 341                 {
 342                 case ACPI_EVENT_PMTIMER:
 343                         register_id = TMR_STS;
 344                         break;
 345
 346                 case ACPI_EVENT_GLOBAL:
 347                         register_id = GBL_STS;
 348                         break;
 349
 350                 case ACPI_EVENT_POWER_BUTTON:
 351                         register_id = PWRBTN_STS;
 352                         break;
 353
 354                 case ACPI_EVENT_SLEEP_BUTTON:
 355                         register_id = SLPBTN_STS;
 356                         break;
 357
 358                 case ACPI_EVENT_RTC:
 359                         register_id = RTC_STS;
 360                         break;
 361
 362                 default:
 363                         return (AE_BAD_PARAMETER);
 364                         break;
 365                 }
 366
 367                 /*
 368                  * Clear the requested fixed event (By writing a one to the
 369                  * status register bit)
 370                  */
 371
 372                 acpi_hw_register_bit_access (ACPI_WRITE, ACPI_MTX_LOCK, register_id, 1);
 373                 break;
 374
 375
 376         case ACPI_EVENT_GPE:
 377
 378                 /* Ensure that we have a valid GPE number */
 379
 380                 if ((event >= NUM_GPE) ||
 381                         (acpi_gbl_gpe_valid[event] == ACPI_GPE_INVALID))
 382                 {
 383                         return (AE_BAD_PARAMETER);
 384                 }
 385
 386
 387                 acpi_hw_clear_gpe (event);
 388                 break;
 389
 390
 391         default:
 392
 393                 status = AE_BAD_PARAMETER;
 394         }
 395
 396         return (status);
 397 }
 398
 399
 400 /******************************************************************************
 401  *
 402  * FUNCTION:    Acpi_get_event_status
 403  *
 404  * PARAMETERS:  Event           - The fixed event or GPE
 405  *              Type            - The type of event
 406  *              Status          - Where the current status of the event will
 407  *                                be returned
 408  *
 409  * RETURN:      Status
 410  *
 411  * DESCRIPTION: Obtains and returns the current status of the event
 412  *
 413  ******************************************************************************/
 414
 415
 416 ACPI_STATUS
 417 acpi_get_event_status (
 418         u32                     event,
 419         u32                     type,
 420         ACPI_EVENT_STATUS       *event_status)
 421 {
 422         ACPI_STATUS             status = AE_OK;
 423         u32                     register_id;
 424
 425
 426         if (!event_status) {
 427                 return (AE_BAD_PARAMETER);
 428         }
 429
 430
 431         /* The Type must be either Fixed Acpi_event or GPE */
 432
 433         switch (type)
 434         {
 435
 436         case ACPI_EVENT_FIXED:
 437
 438                 /* Decode the Fixed Acpi_event */
 439
 440                 switch (event)
 441                 {
 442                 case ACPI_EVENT_PMTIMER:
 443                         register_id = TMR_STS;
 444                         break;
 445
 446                 case ACPI_EVENT_GLOBAL:
 447                         register_id = GBL_STS;
 448                         break;
 449
 450                 case ACPI_EVENT_POWER_BUTTON:
 451                         register_id = PWRBTN_STS;
 452                         break;
 453
 454                 case ACPI_EVENT_SLEEP_BUTTON:
 455                         register_id = SLPBTN_STS;
 456                         break;
 457
 458                 case ACPI_EVENT_RTC:
 459                         register_id = RTC_STS;
 460                         break;
 461
 462                 default:
 463                         return (AE_BAD_PARAMETER);
 464                         break;
 465                 }
 466
 467                 /* Get the status of the requested fixed event */
 468
 469                 *event_status = acpi_hw_register_bit_access (ACPI_READ, ACPI_MTX_LOCK, register_id);
 470                 break;
 471
 472
 473         case ACPI_EVENT_GPE:
 474
 475                 /* Ensure that we have a valid GPE number */
 476
 477                 if ((event >= NUM_GPE) ||
 478                         (acpi_gbl_gpe_valid[event] == ACPI_GPE_INVALID))
 479                 {
 480                         return (AE_BAD_PARAMETER);
 481                 }
 482
 483
 484                 /* Obtain status on the requested GPE number */
 485
 486                 acpi_hw_get_gpe_status (event, event_status);
 487                 break;
 488
 489
 490         default:
 491                 status = AE_BAD_PARAMETER;
 492         }
 493
 494
 495         return (status);
 496 }
 497