1 /****************************************************************************** 2 * 3 * Module Name: utxfinit - External interfaces for ACPICA initialization 4 * 5 *****************************************************************************/ 6 7 /****************************************************************************** 8 * 9 * 1. Copyright Notice 10 * 11 * Some or all of this work - Copyright (c) 1999 - 2016, Intel Corp. 12 * All rights reserved. 13 * 14 * 2. License 15 * 16 * 2.1. This is your license from Intel Corp. under its intellectual property 17 * rights. You may have additional license terms from the party that provided 18 * you this software, covering your right to use that party's intellectual 19 * property rights. 20 * 21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 22 * copy of the source code appearing in this file ("Covered Code") an 23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 24 * base code distributed originally by Intel ("Original Intel Code") to copy, 25 * make derivatives, distribute, use and display any portion of the Covered 26 * Code in any form, with the right to sublicense such rights; and 27 * 28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 29 * license (with the right to sublicense), under only those claims of Intel 30 * patents that are infringed by the Original Intel Code, to make, use, sell, 31 * offer to sell, and import the Covered Code and derivative works thereof 32 * solely to the minimum extent necessary to exercise the above copyright 33 * license, and in no event shall the patent license extend to any additions 34 * to or modifications of the Original Intel Code. No other license or right 35 * is granted directly or by implication, estoppel or otherwise; 36 * 37 * The above copyright and patent license is granted only if the following 38 * conditions are met: 39 * 40 * 3. Conditions 41 * 42 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 43 * Redistribution of source code of any substantial portion of the Covered 44 * Code or modification with rights to further distribute source must include 45 * the above Copyright Notice, the above License, this list of Conditions, 46 * and the following Disclaimer and Export Compliance provision. In addition, 47 * Licensee must cause all Covered Code to which Licensee contributes to 48 * contain a file documenting the changes Licensee made to create that Covered 49 * Code and the date of any change. Licensee must include in that file the 50 * documentation of any changes made by any predecessor Licensee. Licensee 51 * must include a prominent statement that the modification is derived, 52 * directly or indirectly, from Original Intel Code. 53 * 54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 55 * Redistribution of source code of any substantial portion of the Covered 56 * Code or modification without rights to further distribute source must 57 * include the following Disclaimer and Export Compliance provision in the 58 * documentation and/or other materials provided with distribution. In 59 * addition, Licensee may not authorize further sublicense of source of any 60 * portion of the Covered Code, and must include terms to the effect that the 61 * license from Licensee to its licensee is limited to the intellectual 62 * property embodied in the software Licensee provides to its licensee, and 63 * not to intellectual property embodied in modifications its licensee may 64 * make. 65 * 66 * 3.3. Redistribution of Executable. Redistribution in executable form of any 67 * substantial portion of the Covered Code or modification must reproduce the 68 * above Copyright Notice, and the following Disclaimer and Export Compliance 69 * provision in the documentation and/or other materials provided with the 70 * distribution. 71 * 72 * 3.4. Intel retains all right, title, and interest in and to the Original 73 * Intel Code. 74 * 75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 76 * Intel shall be used in advertising or otherwise to promote the sale, use or 77 * other dealings in products derived from or relating to the Covered Code 78 * without prior written authorization from Intel. 79 * 80 * 4. Disclaimer and Export Compliance 81 * 82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 88 * PARTICULAR PURPOSE. 89 * 90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 97 * LIMITED REMEDY. 98 * 99 * 4.3. Licensee shall not export, either directly or indirectly, any of this 100 * software or system incorporating such software without first obtaining any 101 * required license or other approval from the U. S. Department of Commerce or 102 * any other agency or department of the United States Government. In the 103 * event Licensee exports any such software from the United States or 104 * re-exports any such software from a foreign destination, Licensee shall 105 * ensure that the distribution and export/re-export of the software is in 106 * compliance with all laws, regulations, orders, or other restrictions of the 107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 108 * any of its subsidiaries will export/re-export any technical data, process, 109 * software, or service, directly or indirectly, to any country for which the 110 * United States government or any agency thereof requires an export license, 111 * other governmental approval, or letter of assurance, without first obtaining 112 * such license, approval or letter. 113 * 114 *****************************************************************************/ 115 116 #define EXPORT_ACPI_INTERFACES 117 118 #include "acpi.h" 119 #include "accommon.h" 120 #include "acevents.h" 121 #include "acnamesp.h" 122 #include "acdebug.h" 123 #include "actables.h" 124 125 #define _COMPONENT ACPI_UTILITIES 126 ACPI_MODULE_NAME ("utxfinit") 127 128 /* For AcpiExec only */ 129 void 130 AeDoObjectOverrides ( 131 void); 132 133 134 /******************************************************************************* 135 * 136 * FUNCTION: AcpiInitializeSubsystem 137 * 138 * PARAMETERS: None 139 * 140 * RETURN: Status 141 * 142 * DESCRIPTION: Initializes all global variables. This is the first function 143 * called, so any early initialization belongs here. 144 * 145 ******************************************************************************/ 146 147 ACPI_STATUS 148 AcpiInitializeSubsystem ( 149 void) 150 { 151 ACPI_STATUS Status; 152 153 154 ACPI_FUNCTION_TRACE (AcpiInitializeSubsystem); 155 156 157 AcpiGbl_StartupFlags = ACPI_SUBSYSTEM_INITIALIZE; 158 ACPI_DEBUG_EXEC (AcpiUtInitStackPtrTrace ()); 159 160 /* Initialize the OS-Dependent layer */ 161 162 Status = AcpiOsInitialize (); 163 if (ACPI_FAILURE (Status)) 164 { 165 ACPI_EXCEPTION ((AE_INFO, Status, "During OSL initialization")); 166 return_ACPI_STATUS (Status); 167 } 168 169 /* Initialize all globals used by the subsystem */ 170 171 Status = AcpiUtInitGlobals (); 172 if (ACPI_FAILURE (Status)) 173 { 174 ACPI_EXCEPTION ((AE_INFO, Status, "During initialization of globals")); 175 return_ACPI_STATUS (Status); 176 } 177 178 /* Create the default mutex objects */ 179 180 Status = AcpiUtMutexInitialize (); 181 if (ACPI_FAILURE (Status)) 182 { 183 ACPI_EXCEPTION ((AE_INFO, Status, "During Global Mutex creation")); 184 return_ACPI_STATUS (Status); 185 } 186 187 /* 188 * Initialize the namespace manager and 189 * the root of the namespace tree 190 */ 191 Status = AcpiNsRootInitialize (); 192 if (ACPI_FAILURE (Status)) 193 { 194 ACPI_EXCEPTION ((AE_INFO, Status, "During Namespace initialization")); 195 return_ACPI_STATUS (Status); 196 } 197 198 /* Initialize the global OSI interfaces list with the static names */ 199 200 Status = AcpiUtInitializeInterfaces (); 201 if (ACPI_FAILURE (Status)) 202 { 203 ACPI_EXCEPTION ((AE_INFO, Status, "During OSI interfaces initialization")); 204 return_ACPI_STATUS (Status); 205 } 206 207 if (!AcpiGbl_OverrideDefaultRegionHandlers) 208 { 209 /* 210 * Install the default operation region handlers. These are the 211 * handlers that are defined by the ACPI specification to be 212 * "always accessible" -- namely, SystemMemory, SystemIO, and 213 * PCI_Config. This also means that no _REG methods need to be 214 * run for these address spaces. We need to have these handlers 215 * installed before any AML code can be executed, especially any 216 * module-level code (11/2015). 217 */ 218 Status = AcpiEvInstallRegionHandlers (); 219 if (ACPI_FAILURE (Status)) 220 { 221 ACPI_EXCEPTION ((AE_INFO, Status, "During Region initialization")); 222 return_ACPI_STATUS (Status); 223 } 224 } 225 226 return_ACPI_STATUS (AE_OK); 227 } 228 229 ACPI_EXPORT_SYMBOL_INIT (AcpiInitializeSubsystem) 230 231 232 /******************************************************************************* 233 * 234 * FUNCTION: AcpiEnableSubsystem 235 * 236 * PARAMETERS: Flags - Init/enable Options 237 * 238 * RETURN: Status 239 * 240 * DESCRIPTION: Completes the subsystem initialization including hardware. 241 * Puts system into ACPI mode if it isn't already. 242 * 243 ******************************************************************************/ 244 245 ACPI_STATUS 246 AcpiEnableSubsystem ( 247 UINT32 Flags) 248 { 249 ACPI_STATUS Status = AE_OK; 250 251 252 ACPI_FUNCTION_TRACE (AcpiEnableSubsystem); 253 254 255 /* 256 * The early initialization phase is complete. The namespace is loaded, 257 * and we can now support address spaces other than Memory, I/O, and 258 * PCI_Config. 259 */ 260 AcpiGbl_EarlyInitialization = FALSE; 261 262 if (AcpiGbl_OverrideDefaultRegionHandlers) 263 { 264 /* 265 * Install the default operation region handlers. These are the 266 * handlers that are defined by the ACPI specification to be 267 * "always accessible" -- namely, SystemMemory, SystemIO, and 268 * PCI_Config. This also means that no _REG methods need to be 269 * run for these address spaces. We need to have these handlers 270 * installed before any AML code can be executed, especially any 271 * module-level code (11/2015). 272 */ 273 Status = AcpiEvInstallRegionHandlers (); 274 if (ACPI_FAILURE (Status)) 275 { 276 ACPI_EXCEPTION ((AE_INFO, Status, "During Region initialization")); 277 return_ACPI_STATUS (Status); 278 } 279 } 280 281 282 #if (!ACPI_REDUCED_HARDWARE) 283 284 /* Enable ACPI mode */ 285 286 if (!(Flags & ACPI_NO_ACPI_ENABLE)) 287 { 288 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[Init] Going into ACPI mode\n")); 289 290 AcpiGbl_OriginalMode = AcpiHwGetMode(); 291 292 Status = AcpiEnable (); 293 if (ACPI_FAILURE (Status)) 294 { 295 ACPI_WARNING ((AE_INFO, "AcpiEnable failed")); 296 return_ACPI_STATUS (Status); 297 } 298 } 299 300 /* 301 * Obtain a permanent mapping for the FACS. This is required for the 302 * Global Lock and the Firmware Waking Vector 303 */ 304 if (!(Flags & ACPI_NO_FACS_INIT)) 305 { 306 Status = AcpiTbInitializeFacs (); 307 if (ACPI_FAILURE (Status)) 308 { 309 ACPI_WARNING ((AE_INFO, "Could not map the FACS table")); 310 return_ACPI_STATUS (Status); 311 } 312 } 313 314 /* 315 * Initialize ACPI Event handling (Fixed and General Purpose) 316 * 317 * Note1: We must have the hardware and events initialized before we can 318 * execute any control methods safely. Any control method can require 319 * ACPI hardware support, so the hardware must be fully initialized before 320 * any method execution! 321 * 322 * Note2: Fixed events are initialized and enabled here. GPEs are 323 * initialized, but cannot be enabled until after the hardware is 324 * completely initialized (SCI and GlobalLock activated) and the various 325 * initialization control methods are run (_REG, _STA, _INI) on the 326 * entire namespace. 327 */ 328 if (!(Flags & ACPI_NO_EVENT_INIT)) 329 { 330 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, 331 "[Init] Initializing ACPI events\n")); 332 333 Status = AcpiEvInitializeEvents (); 334 if (ACPI_FAILURE (Status)) 335 { 336 return_ACPI_STATUS (Status); 337 } 338 } 339 340 /* 341 * Install the SCI handler and Global Lock handler. This completes the 342 * hardware initialization. 343 */ 344 if (!(Flags & ACPI_NO_HANDLER_INIT)) 345 { 346 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, 347 "[Init] Installing SCI/GL handlers\n")); 348 349 Status = AcpiEvInstallXruptHandlers (); 350 if (ACPI_FAILURE (Status)) 351 { 352 return_ACPI_STATUS (Status); 353 } 354 } 355 356 #endif /* !ACPI_REDUCED_HARDWARE */ 357 358 return_ACPI_STATUS (Status); 359 } 360 361 ACPI_EXPORT_SYMBOL_INIT (AcpiEnableSubsystem) 362 363 364 /******************************************************************************* 365 * 366 * FUNCTION: AcpiInitializeObjects 367 * 368 * PARAMETERS: Flags - Init/enable Options 369 * 370 * RETURN: Status 371 * 372 * DESCRIPTION: Completes namespace initialization by initializing device 373 * objects and executing AML code for Regions, buffers, etc. 374 * 375 ******************************************************************************/ 376 377 ACPI_STATUS 378 AcpiInitializeObjects ( 379 UINT32 Flags) 380 { 381 ACPI_STATUS Status = AE_OK; 382 383 384 ACPI_FUNCTION_TRACE (AcpiInitializeObjects); 385 386 387 /* 388 * Run all _REG methods 389 * 390 * Note: Any objects accessed by the _REG methods will be automatically 391 * initialized, even if they contain executable AML (see the call to 392 * AcpiNsInitializeObjects below). 393 */ 394 if (!(Flags & ACPI_NO_ADDRESS_SPACE_INIT)) 395 { 396 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, 397 "[Init] Executing _REG OpRegion methods\n")); 398 399 Status = AcpiEvInitializeOpRegions (); 400 if (ACPI_FAILURE (Status)) 401 { 402 return_ACPI_STATUS (Status); 403 } 404 } 405 406 #ifdef ACPI_EXEC_APP 407 /* 408 * This call implements the "initialization file" option for AcpiExec. 409 * This is the precise point that we want to perform the overrides. 410 */ 411 AeDoObjectOverrides (); 412 #endif 413 414 /* 415 * Execute any module-level code that was detected during the table load 416 * phase. Although illegal since ACPI 2.0, there are many machines that 417 * contain this type of code. Each block of detected executable AML code 418 * outside of any control method is wrapped with a temporary control 419 * method object and placed on a global list. The methods on this list 420 * are executed below. 421 * 422 * This case executes the module-level code for all tables only after 423 * all of the tables have been loaded. It is a legacy option and is 424 * not compatible with other ACPI implementations. See AcpiNsLoadTable. 425 */ 426 if (AcpiGbl_GroupModuleLevelCode) 427 { 428 AcpiNsExecModuleCodeList (); 429 } 430 431 /* 432 * Initialize the objects that remain uninitialized. This runs the 433 * executable AML that may be part of the declaration of these objects: 434 * OperationRegions, BufferFields, Buffers, and Packages. 435 */ 436 if (!(Flags & ACPI_NO_OBJECT_INIT)) 437 { 438 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, 439 "[Init] Completing Initialization of ACPI Objects\n")); 440 441 Status = AcpiNsInitializeObjects (); 442 if (ACPI_FAILURE (Status)) 443 { 444 return_ACPI_STATUS (Status); 445 } 446 } 447 448 /* 449 * Initialize all device objects in the namespace. This runs the device 450 * _STA and _INI methods. 451 */ 452 if (!(Flags & ACPI_NO_DEVICE_INIT)) 453 { 454 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, 455 "[Init] Initializing ACPI Devices\n")); 456 457 Status = AcpiNsInitializeDevices (); 458 if (ACPI_FAILURE (Status)) 459 { 460 return_ACPI_STATUS (Status); 461 } 462 } 463 464 /* 465 * Empty the caches (delete the cached objects) on the assumption that 466 * the table load filled them up more than they will be at runtime -- 467 * thus wasting non-paged memory. 468 */ 469 Status = AcpiPurgeCachedObjects (); 470 471 AcpiGbl_StartupFlags |= ACPI_INITIALIZED_OK; 472 return_ACPI_STATUS (Status); 473 } 474 475 ACPI_EXPORT_SYMBOL_INIT (AcpiInitializeObjects) 476