drivers/acpi/acpica/utxfinit.c

   1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2 /******************************************************************************
   3  *
   4  * Module Name: utxfinit - External interfaces for ACPICA initialization
   5  *
   6  * Copyright (C) 2000 - 2018, Intel Corp.
   7  *
   8  *****************************************************************************/
   9
  10 #define EXPORT_ACPI_INTERFACES
  11
  12 #include <acpi/acpi.h>
  13 #include "accommon.h"
  14 #include "acevents.h"
  15 #include "acnamesp.h"
  16 #include "acdebug.h"
  17 #include "actables.h"
  18
  19 #define _COMPONENT          ACPI_UTILITIES
  20 ACPI_MODULE_NAME("utxfinit")
  21
  22 /* For acpi_exec only */
  23 void ae_do_object_overrides(void);
  24
  25 /*******************************************************************************
  26  *
  27  * FUNCTION:    acpi_initialize_subsystem
  28  *
  29  * PARAMETERS:  None
  30  *
  31  * RETURN:      Status
  32  *
  33  * DESCRIPTION: Initializes all global variables. This is the first function
  34  *              called, so any early initialization belongs here.
  35  *
  36  ******************************************************************************/
  37
  38 acpi_status ACPI_INIT_FUNCTION acpi_initialize_subsystem(void)
  39 {
  40         acpi_status status;
  41
  42         ACPI_FUNCTION_TRACE(acpi_initialize_subsystem);
  43
  44         acpi_gbl_startup_flags = ACPI_SUBSYSTEM_INITIALIZE;
  45         ACPI_DEBUG_EXEC(acpi_ut_init_stack_ptr_trace());
  46
  47         /* Initialize the OS-Dependent layer */
  48
  49         status = acpi_os_initialize();
  50         if (ACPI_FAILURE(status)) {
  51                 ACPI_EXCEPTION((AE_INFO, status, "During OSL initialization"));
  52                 return_ACPI_STATUS(status);
  53         }
  54
  55         /* Initialize all globals used by the subsystem */
  56
  57         status = acpi_ut_init_globals();
  58         if (ACPI_FAILURE(status)) {
  59                 ACPI_EXCEPTION((AE_INFO, status,
  60                                 "During initialization of globals"));
  61                 return_ACPI_STATUS(status);
  62         }
  63
  64         /* Create the default mutex objects */
  65
  66         status = acpi_ut_mutex_initialize();
  67         if (ACPI_FAILURE(status)) {
  68                 ACPI_EXCEPTION((AE_INFO, status,
  69                                 "During Global Mutex creation"));
  70                 return_ACPI_STATUS(status);
  71         }
  72
  73         /*
  74          * Initialize the namespace manager and
  75          * the root of the namespace tree
  76          */
  77         status = acpi_ns_root_initialize();
  78         if (ACPI_FAILURE(status)) {
  79                 ACPI_EXCEPTION((AE_INFO, status,
  80                                 "During Namespace initialization"));
  81                 return_ACPI_STATUS(status);
  82         }
  83
  84         /* Initialize the global OSI interfaces list with the static names */
  85
  86         status = acpi_ut_initialize_interfaces();
  87         if (ACPI_FAILURE(status)) {
  88                 ACPI_EXCEPTION((AE_INFO, status,
  89                                 "During OSI interfaces initialization"));
  90                 return_ACPI_STATUS(status);
  91         }
  92
  93         return_ACPI_STATUS(AE_OK);
  94 }
  95
  96 ACPI_EXPORT_SYMBOL_INIT(acpi_initialize_subsystem)
  97
  98 /*******************************************************************************
  99  *
 100  * FUNCTION:    acpi_enable_subsystem
 101  *
 102  * PARAMETERS:  flags               - Init/enable Options
 103  *
 104  * RETURN:      Status
 105  *
 106  * DESCRIPTION: Completes the subsystem initialization including hardware.
 107  *              Puts system into ACPI mode if it isn't already.
 108  *
 109  ******************************************************************************/
 110 acpi_status ACPI_INIT_FUNCTION acpi_enable_subsystem(u32 flags)
 111 {
 112         acpi_status status = AE_OK;
 113
 114         ACPI_FUNCTION_TRACE(acpi_enable_subsystem);
 115
 116         /*
 117          * The early initialization phase is complete. The namespace is loaded,
 118          * and we can now support address spaces other than Memory, I/O, and
 119          * PCI_Config.
 120          */
 121         acpi_gbl_early_initialization = FALSE;
 122
 123 #if (!ACPI_REDUCED_HARDWARE)
 124
 125         /* Enable ACPI mode */
 126
 127         if (!(flags & ACPI_NO_ACPI_ENABLE)) {
 128                 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
 129                                   "[Init] Going into ACPI mode\n"));
 130
 131                 acpi_gbl_original_mode = acpi_hw_get_mode();
 132
 133                 status = acpi_enable();
 134                 if (ACPI_FAILURE(status)) {
 135                         ACPI_WARNING((AE_INFO, "AcpiEnable failed"));
 136                         return_ACPI_STATUS(status);
 137                 }
 138         }
 139
 140         /*
 141          * Obtain a permanent mapping for the FACS. This is required for the
 142          * Global Lock and the Firmware Waking Vector
 143          */
 144         if (!(flags & ACPI_NO_FACS_INIT)) {
 145                 status = acpi_tb_initialize_facs();
 146                 if (ACPI_FAILURE(status)) {
 147                         ACPI_WARNING((AE_INFO, "Could not map the FACS table"));
 148                         return_ACPI_STATUS(status);
 149                 }
 150         }
 151
 152         /*
 153          * Initialize ACPI Event handling (Fixed and General Purpose)
 154          *
 155          * Note1: We must have the hardware and events initialized before we can
 156          * execute any control methods safely. Any control method can require
 157          * ACPI hardware support, so the hardware must be fully initialized before
 158          * any method execution!
 159          *
 160          * Note2: Fixed events are initialized and enabled here. GPEs are
 161          * initialized, but cannot be enabled until after the hardware is
 162          * completely initialized (SCI and global_lock activated) and the various
 163          * initialization control methods are run (_REG, _STA, _INI) on the
 164          * entire namespace.
 165          */
 166         if (!(flags & ACPI_NO_EVENT_INIT)) {
 167                 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
 168                                   "[Init] Initializing ACPI events\n"));
 169
 170                 status = acpi_ev_initialize_events();
 171                 if (ACPI_FAILURE(status)) {
 172                         return_ACPI_STATUS(status);
 173                 }
 174         }
 175
 176         /*
 177          * Install the SCI handler and Global Lock handler. This completes the
 178          * hardware initialization.
 179          */
 180         if (!(flags & ACPI_NO_HANDLER_INIT)) {
 181                 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
 182                                   "[Init] Installing SCI/GL handlers\n"));
 183
 184                 status = acpi_ev_install_xrupt_handlers();
 185                 if (ACPI_FAILURE(status)) {
 186                         return_ACPI_STATUS(status);
 187                 }
 188         }
 189 #endif                          /* !ACPI_REDUCED_HARDWARE */
 190
 191         return_ACPI_STATUS(status);
 192 }
 193
 194 ACPI_EXPORT_SYMBOL_INIT(acpi_enable_subsystem)
 195
 196 /*******************************************************************************
 197  *
 198  * FUNCTION:    acpi_initialize_objects
 199  *
 200  * PARAMETERS:  flags               - Init/enable Options
 201  *
 202  * RETURN:      Status
 203  *
 204  * DESCRIPTION: Completes namespace initialization by initializing device
 205  *              objects and executing AML code for Regions, buffers, etc.
 206  *
 207  ******************************************************************************/
 208 acpi_status ACPI_INIT_FUNCTION acpi_initialize_objects(u32 flags)
 209 {
 210         acpi_status status = AE_OK;
 211
 212         ACPI_FUNCTION_TRACE(acpi_initialize_objects);
 213
 214         /*
 215          * This case handles the legacy option that groups all module-level
 216          * code blocks together and defers execution until all of the tables
 217          * are loaded. Execute all of these blocks at this time.
 218          * Execute any module-level code that was detected during the table
 219          * load phase.
 220          *
 221          * Note: this option is deprecated and will be eliminated in the
 222          * future. Use of this option can cause problems with AML code that
 223          * depends upon in-order immediate execution of module-level code.
 224          */
 225         acpi_ns_exec_module_code_list();
 226
 227         /*
 228          * Initialize the objects that remain uninitialized. This
 229          * runs the executable AML that may be part of the
 230          * declaration of these objects:
 231          * operation_regions, buffer_fields, Buffers, and Packages.
 232          */
 233         if (!(flags & ACPI_NO_OBJECT_INIT)) {
 234                 status = acpi_ns_initialize_objects();
 235                 if (ACPI_FAILURE(status)) {
 236                         return_ACPI_STATUS(status);
 237                 }
 238         }
 239
 240         /*
 241          * Initialize all device/region objects in the namespace. This runs
 242          * the device _STA and _INI methods and region _REG methods.
 243          */
 244         if (!(flags & (ACPI_NO_DEVICE_INIT | ACPI_NO_ADDRESS_SPACE_INIT))) {
 245                 status = acpi_ns_initialize_devices(flags);
 246                 if (ACPI_FAILURE(status)) {
 247                         return_ACPI_STATUS(status);
 248                 }
 249         }
 250
 251         /*
 252          * Empty the caches (delete the cached objects) on the assumption that
 253          * the table load filled them up more than they will be at runtime --
 254          * thus wasting non-paged memory.
 255          */
 256         status = acpi_purge_cached_objects();
 257
 258         acpi_gbl_startup_flags |= ACPI_INITIALIZED_OK;
 259         return_ACPI_STATUS(status);
 260 }
 261
 262 ACPI_EXPORT_SYMBOL_INIT(acpi_initialize_objects)