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 - 2019, 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) 263