drivers/acpi/common/cmxface.c

   1 /******************************************************************************
   2  *
   3  * Module Name: cmxface - External interfaces for "global" ACPI functions
   4  *              $Revision: 55 $
   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 "acevents.h"
  29 #include "achware.h"
  30 #include "acnamesp.h"
  31 #include "acinterp.h"
  32 #include "amlcode.h"
  33 #include "acdebug.h"
  34
  35
  36 #define _COMPONENT          MISCELLANEOUS
  37          MODULE_NAME         ("cmxface")
  38
  39
  40 /*******************************************************************************
  41  *
  42  * FUNCTION:    Acpi_initialize_subsystem
  43  *
  44  * PARAMETERS:  None
  45  *
  46  * RETURN:      Status
  47  *
  48  * DESCRIPTION: Initializes all global variables.  This is the first function
  49  *              called, so any early initialization belongs here.
  50  *
  51  ******************************************************************************/
  52
  53 ACPI_STATUS
  54 acpi_initialize_subsystem (
  55         void)
  56 {
  57         ACPI_STATUS             status;
  58
  59
  60         /* Initialize all globals used by the subsystem */
  61
  62         acpi_cm_init_globals ();
  63
  64         /* Initialize the OS-Dependent layer */
  65
  66         status = acpi_os_initialize ();
  67         if (ACPI_FAILURE (status)) {
  68                 REPORT_ERROR (("OSD failed to initialize, %s\n",
  69                         acpi_cm_format_exception (status)));
  70                 return (status);
  71         }
  72
  73         /* Create the default mutex objects */
  74
  75         status = acpi_cm_mutex_initialize ();
  76         if (ACPI_FAILURE (status)) {
  77                 REPORT_ERROR (("Global mutex creation failure, %s\n",
  78                         acpi_cm_format_exception (status)));
  79                 return (status);
  80         }
  81
  82         /*
  83          * Initialize the namespace manager and
  84          * the root of the namespace tree
  85          */
  86
  87         status = acpi_ns_root_initialize ();
  88         if (ACPI_FAILURE (status)) {
  89                 REPORT_ERROR (("Namespace initialization failure, %s\n",
  90                         acpi_cm_format_exception (status)));
  91                 return (status);
  92         }
  93
  94
  95         /* If configured, initialize the AML debugger */
  96
  97         DEBUGGER_EXEC (acpi_db_initialize ());
  98
  99         return (status);
 100 }
 101
 102
 103 /*******************************************************************************
 104  *
 105  * FUNCTION:    Acpi_enable_subsystem
 106  *
 107  * PARAMETERS:  Flags           - Init/enable Options
 108  *
 109  * RETURN:      Status
 110  *
 111  * DESCRIPTION: Completes the subsystem initialization including hardware.
 112  *              Puts system into ACPI mode if it isn't already.
 113  *
 114  ******************************************************************************/
 115
 116 ACPI_STATUS
 117 acpi_enable_subsystem (
 118         u32                     flags)
 119 {
 120         ACPI_STATUS             status = AE_OK;
 121
 122
 123         /* Sanity check the FADT for valid values */
 124
 125         status = acpi_cm_validate_fadt ();
 126         if (ACPI_FAILURE (status)) {
 127                 return (status);
 128         }
 129
 130         /*
 131          * Install the default Op_region handlers. These are
 132          * installed unless other handlers have already been
 133          * installed via the Install_address_space_handler interface
 134          */
 135
 136         if (!(flags & ACPI_NO_ADDRESS_SPACE_INIT)) {
 137                 status = acpi_ev_install_default_address_space_handlers ();
 138                 if (ACPI_FAILURE (status)) {
 139                         return (status);
 140                 }
 141         }
 142
 143         /*
 144          * We must initialize the hardware before we can enable ACPI.
 145          */
 146
 147         if (!(flags & ACPI_NO_HARDWARE_INIT)) {
 148                 status = acpi_hw_initialize ();
 149                 if (ACPI_FAILURE (status)) {
 150                         return (status);
 151                 }
 152         }
 153
 154         /*
 155          * Enable ACPI on this platform
 156          */
 157
 158         if (!(flags & ACPI_NO_ACPI_ENABLE)) {
 159                 status = acpi_enable ();
 160                 if (ACPI_FAILURE (status)) {
 161                         /* TBD: workaround. Old Lions don't enable properly */
 162                         /*return (Status);*/
 163                 }
 164         }
 165
 166         /*
 167          * Note:
 168          * We must have the hardware AND events initialized before we can execute
 169          * ANY control methods SAFELY.  Any control method can require ACPI hardware
 170          * support, so the hardware MUST be initialized before execution!
 171          */
 172
 173         if (!(flags & ACPI_NO_EVENT_INIT)) {
 174                 status = acpi_ev_initialize ();
 175                 if (ACPI_FAILURE (status)) {
 176                         return (status);
 177                 }
 178         }
 179
 180
 181         /*
 182          * Initialize all device objects in the namespace
 183          * This runs the _STA, _INI, and _HID methods, and detects
 184          * the PCI root bus(es)
 185          */
 186
 187         if (!(flags & ACPI_NO_DEVICE_INIT)) {
 188                 status = acpi_ns_initialize_devices (flags & ACPI_NO_PCI_INIT);
 189                 if (ACPI_FAILURE (status)) {
 190                         return (status);
 191                 }
 192         }
 193
 194
 195         /*
 196          * Initialize the objects that remain unitialized.  This
 197          * runs the executable AML that is part of the declaration of Op_regions
 198          * and Fields.
 199          */
 200
 201         if (!(flags & ACPI_NO_OBJECT_INIT)) {
 202                 status = acpi_ns_initialize_objects ();
 203                 if (ACPI_FAILURE (status)) {
 204                         return (status);
 205                 }
 206         }
 207
 208
 209         return (status);
 210 }
 211
 212
 213 /*******************************************************************************
 214  *
 215  * FUNCTION:    Acpi_terminate
 216  *
 217  * PARAMETERS:  None
 218  *
 219  * RETURN:      Status
 220  *
 221  * DESCRIPTION: Shutdown the ACPI subsystem.  Release all resources.
 222  *
 223  ******************************************************************************/
 224
 225 ACPI_STATUS
 226 acpi_terminate (void)
 227 {
 228
 229         /* Terminate the AML Debuger if present */
 230
 231         DEBUGGER_EXEC(acpi_gbl_db_terminate_threads = TRUE);
 232
 233         /* TBD: [Investigate] This is no longer needed?*/
 234 /*    Acpi_cm_release_mutex (ACPI_MTX_DEBUG_CMD_READY); */
 235
 236
 237         /* Shutdown and free all resources */
 238
 239         acpi_cm_subsystem_shutdown ();
 240
 241
 242         /* Free the mutex objects */
 243
 244         acpi_cm_mutex_terminate ();
 245
 246
 247         /* Now we can shutdown the OS-dependent layer */
 248
 249         acpi_os_terminate ();
 250
 251         return (AE_OK);
 252 }
 253
 254
 255 /******************************************************************************
 256  *
 257  * FUNCTION:    Acpi_get_system_info
 258  *
 259  * PARAMETERS:  Out_buffer      - a pointer to a buffer to receive the
 260  *                                resources for the device
 261  *              Buffer_length   - the number of bytes available in the buffer
 262  *
 263  * RETURN:      Status          - the status of the call
 264  *
 265  * DESCRIPTION: This function is called to get information about the current
 266  *              state of the ACPI subsystem.  It will return system information
 267  *              in the Out_buffer.
 268  *
 269  *              If the function fails an appropriate status will be returned
 270  *              and the value of Out_buffer is undefined.
 271  *
 272  ******************************************************************************/
 273
 274 ACPI_STATUS
 275 acpi_get_system_info (
 276         ACPI_BUFFER             *out_buffer)
 277 {
 278         ACPI_SYSTEM_INFO        *info_ptr;
 279         u32                     i;
 280
 281
 282         /*
 283          *  Must have a valid buffer
 284          */
 285         if ((!out_buffer)         ||
 286                 (!out_buffer->pointer))
 287         {
 288                 return (AE_BAD_PARAMETER);
 289         }
 290
 291         if (out_buffer->length < sizeof (ACPI_SYSTEM_INFO)) {
 292                 /*
 293                  *  Caller's buffer is too small
 294                  */
 295                 out_buffer->length = sizeof (ACPI_SYSTEM_INFO);
 296
 297                 return (AE_BUFFER_OVERFLOW);
 298         }
 299
 300
 301         /*
 302          *  Set return length and get data
 303          */
 304         out_buffer->length = sizeof (ACPI_SYSTEM_INFO);
 305         info_ptr = (ACPI_SYSTEM_INFO *) out_buffer->pointer;
 306
 307         /* TBD [Future]: need a version number, or use the version string */
 308         info_ptr->acpi_ca_version   = 0x1234;
 309
 310         /* System flags (ACPI capabilities) */
 311
 312         info_ptr->flags             = acpi_gbl_system_flags;
 313
 314         /* Timer resolution - 24 or 32 bits  */
 315
 316         info_ptr->timer_resolution  = acpi_hw_pmt_resolution ();
 317
 318         /* Clear the reserved fields */
 319
 320         info_ptr->reserved1         = 0;
 321         info_ptr->reserved2         = 0;
 322
 323         /* Current debug levels */
 324
 325         info_ptr->debug_layer       = acpi_dbg_layer;
 326         info_ptr->debug_level       = acpi_dbg_level;
 327
 328         /* Current status of the ACPI tables, per table type */
 329
 330         info_ptr->num_table_types = NUM_ACPI_TABLES;
 331         for (i = 0; i < NUM_ACPI_TABLES; i++) {
 332                 info_ptr->table_info[i].count = acpi_gbl_acpi_tables[i].count;
 333         }
 334
 335         return (AE_OK);
 336 }
 337
 338
 339 /******************************************************************************
 340  *
 341  * FUNCTION:    Acpi_format_exception
 342  *
 343  * PARAMETERS:  Out_buffer      - a pointer to a buffer to receive the
 344  *                                exception name
 345  *
 346  * RETURN:      Status          - the status of the call
 347  *
 348  * DESCRIPTION: This function translates an ACPI exception into an ASCII string.
 349  *
 350  ******************************************************************************/
 351
 352 ACPI_STATUS
 353 acpi_format_exception (
 354         ACPI_STATUS             exception,
 355         ACPI_BUFFER             *out_buffer)
 356 {
 357         u32                     length;
 358         NATIVE_CHAR             *formatted_exception;
 359
 360
 361         /*
 362          *  Must have a valid buffer
 363          */
 364         if ((!out_buffer)         ||
 365                 (!out_buffer->pointer))
 366         {
 367                 return (AE_BAD_PARAMETER);
 368         }
 369
 370
 371         /* Convert the exception code (Handles bad exception codes) */
 372
 373         formatted_exception = acpi_cm_format_exception (exception);
 374
 375         /*
 376          * Get length of string and check if it will fit in caller's buffer
 377          */
 378
 379         length = STRLEN (formatted_exception);
 380         if (out_buffer->length < length) {
 381                 out_buffer->length = length;
 382                 return (AE_BUFFER_OVERFLOW);
 383         }
 384
 385
 386         /* Copy the string, all done */
 387
 388         STRCPY (out_buffer->pointer, formatted_exception);
 389
 390         return (AE_OK);
 391 }
 392