static ACPI_STATUS LsAmlListingWalk ( ACPI_PARSE_OBJECT *Op, UINT32 Level, void *Context) { UINT8 FileByte; UINT32 i; UINT32 FileId = (UINT32) ACPI_TO_INTEGER (Context); LsWriteNodeToListing (Op, FileId); if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DATA) { /* Buffer is a resource template, don't dump the data all at once */ return (AE_OK); } /* Write the hex bytes to the listing file(s) (if requested) */ for (i = 0; i < Op->Asl.FinalAmlLength; i++) { if (ACPI_FAILURE (FlReadFile (ASL_FILE_AML_OUTPUT, &FileByte, 1))) { FlFileError (ASL_FILE_AML_OUTPUT, ASL_MSG_READ); AslAbort (); } LsWriteListingHexBytes (&FileByte, 1, FileId); } return (AE_OK); }
void acpi_os_unmap_memory(void *where, acpi_size length) { acpi_physical_address offset; acpi_size page_size; page_size = acpi_os_get_page_size(); offset = ACPI_TO_INTEGER(where) % page_size; munmap((u8 *)where - offset, (length + offset)); }
void AcpiOsUnmapMemory ( void *Where, ACPI_SIZE Length) { ACPI_PHYSICAL_ADDRESS Offset; ACPI_SIZE PageSize; PageSize = AcpiOsGetPageSize (); Offset = ACPI_TO_INTEGER (Where) % PageSize; munmap ((UINT8 *) Where - Offset, (Length + Offset)); }
static ACPI_STATUS AeSetupConfiguration ( void *RegionAddr) { ACPI_OBJECT_LIST ArgList; ACPI_OBJECT Arg[3]; /* * Invoke _CFG method if present */ ArgList.Count = 1; ArgList.Pointer = Arg; Arg[0].Type = ACPI_TYPE_INTEGER; Arg[0].Integer.Value = ACPI_TO_INTEGER (RegionAddr); (void) AcpiEvaluateObject (NULL, "\\_CFG", &ArgList, NULL); return (AE_OK); }
void ExInitializeAcpiTables ( void) { /* Setup RSDP */ Rsdp->RsdtPhysicalAddress = (UINT32) ACPI_TO_INTEGER (RsdtCode); Rsdp->XsdtPhysicalAddress = (UINT64) ACPI_TO_INTEGER (XsdtCode); /* RSDT and XSDT */ Rsdt->TableOffsetEntry[0] = (UINT32) ACPI_TO_INTEGER (FadtCode); Xsdt->TableOffsetEntry[0] = (UINT64) ACPI_TO_INTEGER (FadtCode); /* FADT */ Fadt->Facs = 0; Fadt->Dsdt = 0; Fadt->XFacs = (UINT64) ACPI_TO_INTEGER (FacsCode); Fadt->XDsdt = (UINT64) ACPI_TO_INTEGER (DsdtCode); /* Set new checksums for the modified tables */ Rsdp->Checksum = 0; Rsdp->Checksum = (UINT8) -AcpiTbChecksum ( (void *) RsdpCode, ACPI_RSDP_CHECKSUM_LENGTH); Rsdt->Header.Checksum = 0; Rsdt->Header.Checksum = (UINT8) -AcpiTbChecksum ( (void *) Rsdt, Rsdt->Header.Length); Xsdt->Header.Checksum = 0; Xsdt->Header.Checksum = (UINT8) -AcpiTbChecksum ( (void *) Xsdt, Xsdt->Header.Length); Fadt->Header.Checksum = 0; Fadt->Header.Checksum = (UINT8) -AcpiTbChecksum ( (void *) Fadt, Fadt->Header.Length); }
acpi_status acpi_tb_find_rsdp ( struct acpi_table_desc *table_info, u32 flags) { u8 *table_ptr; u8 *mem_rover; u64 phys_addr; acpi_status status = AE_OK; ACPI_FUNCTION_TRACE ("tb_find_rsdp"); /* * Scan supports either 1) Logical addressing or 2) Physical addressing */ if ((flags & ACPI_MEMORY_MODE) == ACPI_LOGICAL_ADDRESSING) { /* * 1) Search EBDA (low memory) paragraphs */ status = acpi_os_map_memory ((u64) ACPI_LO_RSDP_WINDOW_BASE, ACPI_LO_RSDP_WINDOW_SIZE, (void *) &table_ptr); if (ACPI_FAILURE (status)) { ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Could not map memory at %X for length %X\n", ACPI_LO_RSDP_WINDOW_BASE, ACPI_LO_RSDP_WINDOW_SIZE)); return_ACPI_STATUS (status); } mem_rover = acpi_tb_scan_memory_for_rsdp (table_ptr, ACPI_LO_RSDP_WINDOW_SIZE); acpi_os_unmap_memory (table_ptr, ACPI_LO_RSDP_WINDOW_SIZE); if (mem_rover) { /* Found it, return the physical address */ phys_addr = ACPI_LO_RSDP_WINDOW_BASE; phys_addr += ACPI_PTR_DIFF (mem_rover,table_ptr); table_info->physical_address = phys_addr; return_ACPI_STATUS (AE_OK); } /* * 2) Search upper memory: 16-byte boundaries in E0000h-F0000h */ status = acpi_os_map_memory ((u64) ACPI_HI_RSDP_WINDOW_BASE, ACPI_HI_RSDP_WINDOW_SIZE, (void *) &table_ptr); if (ACPI_FAILURE (status)) { ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Could not map memory at %X for length %X\n", ACPI_HI_RSDP_WINDOW_BASE, ACPI_HI_RSDP_WINDOW_SIZE)); return_ACPI_STATUS (status); } mem_rover = acpi_tb_scan_memory_for_rsdp (table_ptr, ACPI_HI_RSDP_WINDOW_SIZE); acpi_os_unmap_memory (table_ptr, ACPI_HI_RSDP_WINDOW_SIZE); if (mem_rover) { /* Found it, return the physical address */ phys_addr = ACPI_HI_RSDP_WINDOW_BASE; phys_addr += ACPI_PTR_DIFF (mem_rover, table_ptr); table_info->physical_address = phys_addr; return_ACPI_STATUS (AE_OK); } } /* * Physical addressing */ else { /* * 1) Search EBDA (low memory) paragraphs */ mem_rover = acpi_tb_scan_memory_for_rsdp (ACPI_PHYSADDR_TO_PTR (ACPI_LO_RSDP_WINDOW_BASE), ACPI_LO_RSDP_WINDOW_SIZE); if (mem_rover) { /* Found it, return the physical address */ table_info->physical_address = ACPI_TO_INTEGER (mem_rover); return_ACPI_STATUS (AE_OK); } /* * 2) Search upper memory: 16-byte boundaries in E0000h-F0000h */ mem_rover = acpi_tb_scan_memory_for_rsdp (ACPI_PHYSADDR_TO_PTR (ACPI_HI_RSDP_WINDOW_BASE), ACPI_HI_RSDP_WINDOW_SIZE); if (mem_rover) { /* Found it, return the physical address */ table_info->physical_address = ACPI_TO_INTEGER (mem_rover); return_ACPI_STATUS (AE_OK); } } /* RSDP signature was not found */ return_ACPI_STATUS (AE_NOT_FOUND); }
ACPI_STATUS AcpiExLoadOp ( ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT *Target, ACPI_WALK_STATE *WalkState) { ACPI_OPERAND_OBJECT *DdbHandle; ACPI_TABLE_HEADER *Table; ACPI_TABLE_DESC TableDesc; UINT32 TableIndex; ACPI_STATUS Status; UINT32 Length; ACPI_FUNCTION_TRACE (ExLoadOp); ACPI_MEMSET (&TableDesc, 0, sizeof (ACPI_TABLE_DESC)); /* Source Object can be either an OpRegion or a Buffer/Field */ switch (ObjDesc->Common.Type) { case ACPI_TYPE_REGION: ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Load table from Region %p\n", ObjDesc)); /* Region must be SystemMemory (from ACPI spec) */ if (ObjDesc->Region.SpaceId != ACPI_ADR_SPACE_SYSTEM_MEMORY) { return_ACPI_STATUS (AE_AML_OPERAND_TYPE); } /* * If the Region Address and Length have not been previously evaluated, * evaluate them now and save the results. */ if (!(ObjDesc->Common.Flags & AOPOBJ_DATA_VALID)) { Status = AcpiDsGetRegionArguments (ObjDesc); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } } /* Get the table header first so we can get the table length */ Table = ACPI_ALLOCATE (sizeof (ACPI_TABLE_HEADER)); if (!Table) { return_ACPI_STATUS (AE_NO_MEMORY); } Status = AcpiExRegionRead (ObjDesc, sizeof (ACPI_TABLE_HEADER), ACPI_CAST_PTR (UINT8, Table)); Length = Table->Length; ACPI_FREE (Table); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* Must have at least an ACPI table header */ if (Length < sizeof (ACPI_TABLE_HEADER)) { return_ACPI_STATUS (AE_INVALID_TABLE_LENGTH); } /* * The original implementation simply mapped the table, with no copy. * However, the memory region is not guaranteed to remain stable and * we must copy the table to a local buffer. For example, the memory * region is corrupted after suspend on some machines. Dynamically * loaded tables are usually small, so this overhead is minimal. * * The latest implementation (5/2009) does not use a mapping at all. * We use the low-level operation region interface to read the table * instead of the obvious optimization of using a direct mapping. * This maintains a consistent use of operation regions across the * entire subsystem. This is important if additional processing must * be performed in the (possibly user-installed) operation region * handler. For example, AcpiExec and ASLTS depend on this. */ /* Allocate a buffer for the table */ TableDesc.Pointer = ACPI_ALLOCATE (Length); if (!TableDesc.Pointer) { return_ACPI_STATUS (AE_NO_MEMORY); } /* Read the entire table */ Status = AcpiExRegionRead (ObjDesc, Length, ACPI_CAST_PTR (UINT8, TableDesc.Pointer)); if (ACPI_FAILURE (Status)) { ACPI_FREE (TableDesc.Pointer); return_ACPI_STATUS (Status); } TableDesc.Address = ObjDesc->Region.Address; break; case ACPI_TYPE_BUFFER: /* Buffer or resolved RegionField */ ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Load table from Buffer or Field %p\n", ObjDesc)); /* Must have at least an ACPI table header */ if (ObjDesc->Buffer.Length < sizeof (ACPI_TABLE_HEADER)) { return_ACPI_STATUS (AE_INVALID_TABLE_LENGTH); } /* Get the actual table length from the table header */ Table = ACPI_CAST_PTR (ACPI_TABLE_HEADER, ObjDesc->Buffer.Pointer); Length = Table->Length; /* Table cannot extend beyond the buffer */ if (Length > ObjDesc->Buffer.Length) { return_ACPI_STATUS (AE_AML_BUFFER_LIMIT); } if (Length < sizeof (ACPI_TABLE_HEADER)) { return_ACPI_STATUS (AE_INVALID_TABLE_LENGTH); } /* * Copy the table from the buffer because the buffer could be modified * or even deleted in the future */ TableDesc.Pointer = ACPI_ALLOCATE (Length); if (!TableDesc.Pointer) { return_ACPI_STATUS (AE_NO_MEMORY); } ACPI_MEMCPY (TableDesc.Pointer, Table, Length); TableDesc.Address = ACPI_TO_INTEGER (TableDesc.Pointer); break; default: return_ACPI_STATUS (AE_AML_OPERAND_TYPE); } /* Validate table checksum (will not get validated in TbAddTable) */ Status = AcpiTbVerifyChecksum (TableDesc.Pointer, Length); if (ACPI_FAILURE (Status)) { ACPI_FREE (TableDesc.Pointer); return_ACPI_STATUS (Status); } /* Complete the table descriptor */ TableDesc.Length = Length; TableDesc.Flags = ACPI_TABLE_ORIGIN_ALLOCATED; /* Install the new table into the local data structures */ Status = AcpiTbAddTable (&TableDesc, &TableIndex); if (ACPI_FAILURE (Status)) { /* Delete allocated table buffer */ AcpiTbDeleteTable (&TableDesc); return_ACPI_STATUS (Status); } /* * Add the table to the namespace. * * Note: Load the table objects relative to the root of the namespace. * This appears to go against the ACPI specification, but we do it for * compatibility with other ACPI implementations. */ Status = AcpiExAddTable (TableIndex, AcpiGbl_RootNode, &DdbHandle); if (ACPI_FAILURE (Status)) { /* On error, TablePtr was deallocated above */ return_ACPI_STATUS (Status); } /* Store the DdbHandle into the Target operand */ Status = AcpiExStore (DdbHandle, Target, WalkState); if (ACPI_FAILURE (Status)) { (void) AcpiExUnloadTable (DdbHandle); /* TablePtr was deallocated above */ AcpiUtRemoveReference (DdbHandle); return_ACPI_STATUS (Status); } ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Dynamic OEM Table Load:")); AcpiTbPrintTableHeader (0, TableDesc.Pointer); /* Remove the reference by added by AcpiExStore above */ AcpiUtRemoveReference (DdbHandle); /* Invoke table handler if present */ if (AcpiGbl_TableHandler) { (void) AcpiGbl_TableHandler (ACPI_TABLE_EVENT_LOAD, TableDesc.Pointer, AcpiGbl_TableHandlerContext); } return_ACPI_STATUS (Status); }
acpi_status acpi_ns_root_initialize(void) { acpi_status status; const struct acpi_predefined_names *init_val = NULL; struct acpi_namespace_node *new_node; union acpi_operand_object *obj_desc; acpi_string val = NULL; ACPI_FUNCTION_TRACE(ns_root_initialize); status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE); if (ACPI_FAILURE(status)) { return_ACPI_STATUS(status); } if (acpi_gbl_root_node) { status = AE_OK; goto unlock_and_exit; } acpi_gbl_root_node = &acpi_gbl_root_node_struct; ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Entering predefined entries into namespace\n")); for (init_val = acpi_gbl_pre_defined_names; init_val->name; init_val++) { if (!ACPI_STRCMP(init_val->name, "_OSI") && !acpi_gbl_create_osi_method) { continue; } status = acpi_ns_lookup(NULL, init_val->name, init_val->type, ACPI_IMODE_LOAD_PASS2, ACPI_NS_NO_UPSEARCH, NULL, &new_node); if (ACPI_FAILURE(status) || (!new_node)) { ACPI_EXCEPTION((AE_INFO, status, "Could not create predefined name %s", init_val->name)); } if (init_val->val) { status = acpi_os_predefined_override(init_val, &val); if (ACPI_FAILURE(status)) { ACPI_ERROR((AE_INFO, "Could not override predefined %s", init_val->name)); } if (!val) { val = init_val->val; } obj_desc = acpi_ut_create_internal_object(init_val->type); if (!obj_desc) { status = AE_NO_MEMORY; goto unlock_and_exit; } switch (init_val->type) { case ACPI_TYPE_METHOD: obj_desc->method.param_count = (u8) ACPI_TO_INTEGER(val); obj_desc->common.flags |= AOPOBJ_DATA_VALID; #if defined (ACPI_ASL_COMPILER) new_node->value = obj_desc->method.param_count; #else obj_desc->method.info_flags = ACPI_METHOD_INTERNAL_ONLY; obj_desc->method.dispatch.implementation = acpi_ut_osi_implementation; #endif break; case ACPI_TYPE_INTEGER: obj_desc->integer.value = ACPI_TO_INTEGER(val); break; case ACPI_TYPE_STRING: obj_desc->string.length = (u32) ACPI_STRLEN(val); obj_desc->string.pointer = val; obj_desc->common.flags |= AOPOBJ_STATIC_POINTER; break; case ACPI_TYPE_MUTEX: obj_desc->mutex.node = new_node; obj_desc->mutex.sync_level = (u8) (ACPI_TO_INTEGER(val) - 1); status = acpi_os_create_mutex(&obj_desc->mutex. os_mutex); if (ACPI_FAILURE(status)) { acpi_ut_remove_reference(obj_desc); goto unlock_and_exit; } if (ACPI_STRCMP(init_val->name, "_GL_") == 0) { acpi_gbl_global_lock_mutex = obj_desc; status = acpi_os_create_semaphore(1, 0, &acpi_gbl_global_lock_semaphore); if (ACPI_FAILURE(status)) { acpi_ut_remove_reference (obj_desc); goto unlock_and_exit; } } break; default: ACPI_ERROR((AE_INFO, "Unsupported initial type value 0x%X", init_val->type)); acpi_ut_remove_reference(obj_desc); obj_desc = NULL; continue; } status = acpi_ns_attach_object(new_node, obj_desc, obj_desc->common.type); acpi_ut_remove_reference(obj_desc); } } unlock_and_exit: (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE); if (ACPI_SUCCESS(status)) { status = acpi_ns_get_node(NULL, "\\_GPE", ACPI_NS_NO_UPSEARCH, &acpi_gbl_fadt_gpe_device); } return_ACPI_STATUS(status); }
ACPI_STATUS AcpiDsEvalTableRegionOperands ( ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op) { ACPI_STATUS Status; ACPI_OPERAND_OBJECT *ObjDesc; ACPI_OPERAND_OBJECT **Operand; ACPI_NAMESPACE_NODE *Node; ACPI_PARSE_OBJECT *NextOp; UINT32 TableIndex; ACPI_TABLE_HEADER *Table; ACPI_FUNCTION_TRACE_PTR (DsEvalTableRegionOperands, Op); /* * This is where we evaluate the Signature string, OemId string, * and OemTableId string of the Data Table Region declaration */ Node = Op->Common.Node; /* NextOp points to Signature string op */ NextOp = Op->Common.Value.Arg; /* * Evaluate/create the Signature string, OemId string, * and OemTableId string operands */ Status = AcpiDsCreateOperands (WalkState, NextOp); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * Resolve the Signature string, OemId string, * and OemTableId string operands */ Status = AcpiExResolveOperands (Op->Common.AmlOpcode, ACPI_WALK_OPERANDS, WalkState); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } Operand = &WalkState->Operands[0]; /* Find the ACPI table */ Status = AcpiTbFindTable (Operand[0]->String.Pointer, Operand[1]->String.Pointer, Operand[2]->String.Pointer, &TableIndex); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } AcpiUtRemoveReference (Operand[0]); AcpiUtRemoveReference (Operand[1]); AcpiUtRemoveReference (Operand[2]); Status = AcpiGetTableByIndex (TableIndex, &Table); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } ObjDesc = AcpiNsGetAttachedObject (Node); if (!ObjDesc) { return_ACPI_STATUS (AE_NOT_EXIST); } ObjDesc->Region.Address = (ACPI_PHYSICAL_ADDRESS) ACPI_TO_INTEGER (Table); ObjDesc->Region.Length = Table->Length; ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "RgnObj %p Addr %8.8X%8.8X Len %X\n", ObjDesc, ACPI_FORMAT_NATIVE_UINT (ObjDesc->Region.Address), ObjDesc->Region.Length)); /* Now the address and length are valid for this opregion */ ObjDesc->Region.Flags |= AOPOBJ_DATA_VALID; return_ACPI_STATUS (Status); }
static void TrDoSwitch ( ACPI_PARSE_OBJECT *StartNode) { ACPI_PARSE_OBJECT *Next; ACPI_PARSE_OBJECT *CaseOp = NULL; ACPI_PARSE_OBJECT *CaseBlock = NULL; ACPI_PARSE_OBJECT *DefaultOp = NULL; ACPI_PARSE_OBJECT *CurrentParentNode; ACPI_PARSE_OBJECT *Conditional = NULL; ACPI_PARSE_OBJECT *Predicate; ACPI_PARSE_OBJECT *Peer; ACPI_PARSE_OBJECT *NewOp; ACPI_PARSE_OBJECT *NewOp2; ACPI_PARSE_OBJECT *MethodOp; ACPI_PARSE_OBJECT *StoreOp; ACPI_PARSE_OBJECT *BreakOp; ACPI_PARSE_OBJECT *BufferOp; char *PredicateValueName; UINT16 Index; UINT32 Btype; /* Start node is the Switch() node */ CurrentParentNode = StartNode; /* Create a new temp name of the form _T_x */ PredicateValueName = TrAmlGetNextTempName (StartNode, &AslGbl_TempCount); if (!PredicateValueName) { return; } /* First child is the Switch() predicate */ Next = StartNode->Asl.Child; /* * Examine the return type of the Switch Value - * must be Integer/Buffer/String */ Index = (UINT16) (Next->Asl.ParseOpcode - ASL_PARSE_OPCODE_BASE); Btype = AslKeywordMapping[Index].AcpiBtype; if ((Btype != ACPI_BTYPE_INTEGER) && (Btype != ACPI_BTYPE_STRING) && (Btype != ACPI_BTYPE_BUFFER)) { AslError (ASL_WARNING, ASL_MSG_SWITCH_TYPE, Next, NULL); Btype = ACPI_BTYPE_INTEGER; } /* CASE statements start at next child */ Peer = Next->Asl.Next; while (Peer) { Next = Peer; Peer = Next->Asl.Next; if (Next->Asl.ParseOpcode == PARSEOP_CASE) { if (CaseOp) { /* Add an ELSE to complete the previous CASE */ NewOp = TrCreateLeafOp (PARSEOP_ELSE); NewOp->Asl.Parent = Conditional->Asl.Parent; TrAmlInitLineNumbers (NewOp, NewOp->Asl.Parent); /* Link ELSE node as a peer to the previous IF */ TrAmlInsertPeer (Conditional, NewOp); CurrentParentNode = NewOp; } CaseOp = Next; Conditional = CaseOp; CaseBlock = CaseOp->Asl.Child->Asl.Next; Conditional->Asl.Child->Asl.Next = NULL; Predicate = CaseOp->Asl.Child; if ((Predicate->Asl.ParseOpcode == PARSEOP_PACKAGE) || (Predicate->Asl.ParseOpcode == PARSEOP_VAR_PACKAGE)) { /* * Convert the package declaration to this form: * * If (LNotEqual (Match (Package(<size>){<data>}, * MEQ, _T_x, MTR, Zero, Zero), Ones)) */ NewOp2 = TrCreateLeafOp (PARSEOP_MATCHTYPE_MEQ); Predicate->Asl.Next = NewOp2; TrAmlInitLineNumbers (NewOp2, Conditional); NewOp = NewOp2; NewOp2 = TrCreateValuedLeafOp (PARSEOP_NAMESTRING, (UINT64) ACPI_TO_INTEGER (PredicateValueName)); NewOp->Asl.Next = NewOp2; TrAmlInitLineNumbers (NewOp2, Predicate); NewOp = NewOp2; NewOp2 = TrCreateLeafOp (PARSEOP_MATCHTYPE_MTR); NewOp->Asl.Next = NewOp2; TrAmlInitLineNumbers (NewOp2, Predicate); NewOp = NewOp2; NewOp2 = TrCreateLeafOp (PARSEOP_ZERO); NewOp->Asl.Next = NewOp2; TrAmlInitLineNumbers (NewOp2, Predicate); NewOp = NewOp2; NewOp2 = TrCreateLeafOp (PARSEOP_ZERO); NewOp->Asl.Next = NewOp2; TrAmlInitLineNumbers (NewOp2, Predicate); NewOp2 = TrCreateLeafOp (PARSEOP_MATCH); NewOp2->Asl.Child = Predicate; /* PARSEOP_PACKAGE */ TrAmlInitLineNumbers (NewOp2, Conditional); TrAmlSetSubtreeParent (Predicate, NewOp2); NewOp = NewOp2; NewOp2 = TrCreateLeafOp (PARSEOP_ONES); NewOp->Asl.Next = NewOp2; TrAmlInitLineNumbers (NewOp2, Conditional); NewOp2 = TrCreateLeafOp (PARSEOP_LEQUAL); NewOp2->Asl.Child = NewOp; NewOp->Asl.Parent = NewOp2; TrAmlInitLineNumbers (NewOp2, Conditional); TrAmlSetSubtreeParent (NewOp, NewOp2); NewOp = NewOp2; NewOp2 = TrCreateLeafOp (PARSEOP_LNOT); NewOp2->Asl.Child = NewOp; NewOp2->Asl.Parent = Conditional; NewOp->Asl.Parent = NewOp2; TrAmlInitLineNumbers (NewOp2, Conditional); Conditional->Asl.Child = NewOp2; NewOp2->Asl.Next = CaseBlock; } else { /* * Integer and Buffer case. * * Change CaseOp() to: If (LEqual (SwitchValue, CaseValue)) {...} * Note: SwitchValue is first to allow the CaseValue to be implicitly * converted to the type of SwitchValue if necessary. * * CaseOp->Child is the case value * CaseOp->Child->Peer is the beginning of the case block */ NewOp = TrCreateValuedLeafOp (PARSEOP_NAMESTRING, (UINT64) ACPI_TO_INTEGER (PredicateValueName)); NewOp->Asl.Next = Predicate; TrAmlInitLineNumbers (NewOp, Predicate); NewOp2 = TrCreateLeafOp (PARSEOP_LEQUAL); NewOp2->Asl.Parent = Conditional; NewOp2->Asl.Child = NewOp; TrAmlInitLineNumbers (NewOp2, Conditional); TrAmlSetSubtreeParent (NewOp, NewOp2); Predicate = NewOp2; Predicate->Asl.Next = CaseBlock; TrAmlSetSubtreeParent (Predicate, Conditional); Conditional->Asl.Child = Predicate; } /* Reinitialize the CASE node to an IF node */ TrAmlInitNode (Conditional, PARSEOP_IF); /* * The first CASE(IF) is not nested under an ELSE. * All other CASEs are children of a parent ELSE. */ if (CurrentParentNode == StartNode) { Conditional->Asl.Next = NULL; } else { /* * The IF is a child of previous IF/ELSE. It * is therefore without peer. */ CurrentParentNode->Asl.Child = Conditional; Conditional->Asl.Parent = CurrentParentNode; Conditional->Asl.Next = NULL; } } else if (Next->Asl.ParseOpcode == PARSEOP_DEFAULT) { if (DefaultOp) { /* * More than one Default * (Parser does not catch this, must check here) */ AslError (ASL_ERROR, ASL_MSG_MULTIPLE_DEFAULT, Next, NULL); } else { /* Save the DEFAULT node for later, after CASEs */ DefaultOp = Next; } } else { /* Unknown peer opcode */ AcpiOsPrintf ("Unknown parse opcode for switch statement: %s (%u)\n", Next->Asl.ParseOpName, Next->Asl.ParseOpcode); } } /* Add the default case at the end of the if/else construct */ if (DefaultOp) { /* If no CASE statements, this is an error - see below */ if (CaseOp) { /* Convert the DEFAULT node to an ELSE */ TrAmlInitNode (DefaultOp, PARSEOP_ELSE); DefaultOp->Asl.Parent = Conditional->Asl.Parent; /* Link ELSE node as a peer to the previous IF */ TrAmlInsertPeer (Conditional, DefaultOp); } } if (!CaseOp) { AslError (ASL_ERROR, ASL_MSG_NO_CASES, StartNode, NULL); } /* * Create a Name(_T_x, ...) statement. This statement must appear at the * method level, in case a loop surrounds the switch statement and could * cause the name to be created twice (error). */ /* Create the Name node */ Predicate = StartNode->Asl.Child; NewOp = TrCreateLeafOp (PARSEOP_NAME); TrAmlInitLineNumbers (NewOp, StartNode); /* Find the parent method */ Next = StartNode; while ((Next->Asl.ParseOpcode != PARSEOP_METHOD) && (Next->Asl.ParseOpcode != PARSEOP_DEFINITION_BLOCK)) { Next = Next->Asl.Parent; } MethodOp = Next; NewOp->Asl.CompileFlags |= OP_COMPILER_EMITTED; NewOp->Asl.Parent = Next; /* Insert name after the method name and arguments */ Next = Next->Asl.Child; /* Name */ Next = Next->Asl.Next; /* NumArgs */ Next = Next->Asl.Next; /* SerializeRule */ /* * If method is not Serialized, we must make is so, because of the way * that Switch() must be implemented -- we cannot allow multiple threads * to execute this method concurrently since we need to create local * temporary name(s). */ if (Next->Asl.ParseOpcode != PARSEOP_SERIALIZERULE_SERIAL) { AslError (ASL_REMARK, ASL_MSG_SERIALIZED, MethodOp, "Due to use of Switch operator"); Next->Asl.ParseOpcode = PARSEOP_SERIALIZERULE_SERIAL; } Next = Next->Asl.Next; /* SyncLevel */ Next = Next->Asl.Next; /* ReturnType */ Next = Next->Asl.Next; /* ParameterTypes */ TrAmlInsertPeer (Next, NewOp); TrAmlInitLineNumbers (NewOp, Next); /* Create the NameSeg child for the Name node */ NewOp2 = TrCreateValuedLeafOp (PARSEOP_NAMESEG, (UINT64) ACPI_TO_INTEGER (PredicateValueName)); TrAmlInitLineNumbers (NewOp2, NewOp); NewOp2->Asl.CompileFlags |= OP_IS_NAME_DECLARATION; NewOp->Asl.Child = NewOp2; /* Create the initial value for the Name. Btype was already validated above */ switch (Btype) { case ACPI_BTYPE_INTEGER: NewOp2->Asl.Next = TrCreateValuedLeafOp (PARSEOP_ZERO, (UINT64) 0); TrAmlInitLineNumbers (NewOp2->Asl.Next, NewOp); break; case ACPI_BTYPE_STRING: NewOp2->Asl.Next = TrCreateValuedLeafOp (PARSEOP_STRING_LITERAL, (UINT64) ACPI_TO_INTEGER ("")); TrAmlInitLineNumbers (NewOp2->Asl.Next, NewOp); break; case ACPI_BTYPE_BUFFER: (void) TrLinkPeerOp (NewOp2, TrCreateValuedLeafOp (PARSEOP_BUFFER, (UINT64) 0)); Next = NewOp2->Asl.Next; TrAmlInitLineNumbers (Next, NewOp2); (void) TrLinkOpChildren (Next, 1, TrCreateValuedLeafOp (PARSEOP_ZERO, (UINT64) 1)); TrAmlInitLineNumbers (Next->Asl.Child, Next); BufferOp = TrCreateValuedLeafOp (PARSEOP_DEFAULT_ARG, (UINT64) 0); TrAmlInitLineNumbers (BufferOp, Next->Asl.Child); (void) TrLinkPeerOp (Next->Asl.Child, BufferOp); TrAmlSetSubtreeParent (Next->Asl.Child, Next); break; default: break; } TrAmlSetSubtreeParent (NewOp2, NewOp); /* * Transform the Switch() into a While(One)-Break node. * And create a Store() node which will be used to save the * Switch() value. The store is of the form: Store (Value, _T_x) * where _T_x is the temp variable. */ TrAmlInitNode (StartNode, PARSEOP_WHILE); NewOp = TrCreateLeafOp (PARSEOP_ONE); TrAmlInitLineNumbers (NewOp, StartNode); NewOp->Asl.Next = Predicate->Asl.Next; NewOp->Asl.Parent = StartNode; StartNode->Asl.Child = NewOp; /* Create a Store() node */ StoreOp = TrCreateLeafOp (PARSEOP_STORE); TrAmlInitLineNumbers (StoreOp, NewOp); StoreOp->Asl.Parent = StartNode; TrAmlInsertPeer (NewOp, StoreOp); /* Complete the Store subtree */ StoreOp->Asl.Child = Predicate; Predicate->Asl.Parent = StoreOp; NewOp = TrCreateValuedLeafOp (PARSEOP_NAMESEG, (UINT64) ACPI_TO_INTEGER (PredicateValueName)); TrAmlInitLineNumbers (NewOp, StoreOp); NewOp->Asl.Parent = StoreOp; Predicate->Asl.Next = NewOp; /* Create a Break() node and insert it into the end of While() */ Conditional = StartNode->Asl.Child; while (Conditional->Asl.Next) { Conditional = Conditional->Asl.Next; } BreakOp = TrCreateLeafOp (PARSEOP_BREAK); TrAmlInitLineNumbers (BreakOp, NewOp); BreakOp->Asl.Parent = StartNode; TrAmlInsertPeer (Conditional, BreakOp); }
static acpi_status acpi_tb_find_rsdp(struct acpi_table_desc *table_info, u32 flags) { u8 *table_ptr; u8 *mem_rover; u32 physical_address; acpi_status status; ACPI_FUNCTION_TRACE("tb_find_rsdp"); /* * Scan supports either logical addressing or physical addressing */ if ((flags & ACPI_MEMORY_MODE) == ACPI_LOGICAL_ADDRESSING) { /* 1a) Get the location of the Extended BIOS Data Area (EBDA) */ status = acpi_os_map_memory((acpi_physical_address) ACPI_EBDA_PTR_LOCATION, ACPI_EBDA_PTR_LENGTH, (void *)&table_ptr); if (ACPI_FAILURE(status)) { ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Could not map memory at %8.8X for length %X\n", ACPI_EBDA_PTR_LOCATION, ACPI_EBDA_PTR_LENGTH)); return_ACPI_STATUS(status); } ACPI_MOVE_16_TO_32(&physical_address, table_ptr); /* Convert segment part to physical address */ physical_address <<= 4; acpi_os_unmap_memory(table_ptr, ACPI_EBDA_PTR_LENGTH); /* EBDA present? */ if (physical_address > 0x400) { /* * 1b) Search EBDA paragraphs (EBDa is required to be a * minimum of 1_k length) */ status = acpi_os_map_memory((acpi_physical_address) physical_address, ACPI_EBDA_WINDOW_SIZE, (void *)&table_ptr); if (ACPI_FAILURE(status)) { ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Could not map memory at %8.8X for length %X\n", physical_address, ACPI_EBDA_WINDOW_SIZE)); return_ACPI_STATUS(status); } mem_rover = acpi_tb_scan_memory_for_rsdp(table_ptr, ACPI_EBDA_WINDOW_SIZE); acpi_os_unmap_memory(table_ptr, ACPI_EBDA_WINDOW_SIZE); if (mem_rover) { /* Return the physical address */ physical_address += ACPI_PTR_DIFF(mem_rover, table_ptr); table_info->physical_address = (acpi_physical_address) physical_address; return_ACPI_STATUS(AE_OK); } } /* * 2) Search upper memory: 16-byte boundaries in E0000h-FFFFFh */ status = acpi_os_map_memory((acpi_physical_address) ACPI_HI_RSDP_WINDOW_BASE, ACPI_HI_RSDP_WINDOW_SIZE, (void *)&table_ptr); if (ACPI_FAILURE(status)) { ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Could not map memory at %8.8X for length %X\n", ACPI_HI_RSDP_WINDOW_BASE, ACPI_HI_RSDP_WINDOW_SIZE)); return_ACPI_STATUS(status); } mem_rover = acpi_tb_scan_memory_for_rsdp(table_ptr, ACPI_HI_RSDP_WINDOW_SIZE); acpi_os_unmap_memory(table_ptr, ACPI_HI_RSDP_WINDOW_SIZE); if (mem_rover) { /* Return the physical address */ physical_address = ACPI_HI_RSDP_WINDOW_BASE + ACPI_PTR_DIFF(mem_rover, table_ptr); table_info->physical_address = (acpi_physical_address) physical_address; return_ACPI_STATUS(AE_OK); } } /* * Physical addressing */ else { /* 1a) Get the location of the EBDA */ ACPI_MOVE_16_TO_32(&physical_address, ACPI_EBDA_PTR_LOCATION); physical_address <<= 4; /* Convert segment to physical address */ /* EBDA present? */ if (physical_address > 0x400) { /* * 1b) Search EBDA paragraphs (EBDa is required to be a minimum of * 1_k length) */ mem_rover = acpi_tb_scan_memory_for_rsdp(ACPI_PHYSADDR_TO_PTR (physical_address), ACPI_EBDA_WINDOW_SIZE); if (mem_rover) { /* Return the physical address */ table_info->physical_address = ACPI_TO_INTEGER(mem_rover); return_ACPI_STATUS(AE_OK); } } /* 2) Search upper memory: 16-byte boundaries in E0000h-FFFFFh */ mem_rover = acpi_tb_scan_memory_for_rsdp(ACPI_PHYSADDR_TO_PTR (ACPI_HI_RSDP_WINDOW_BASE), ACPI_HI_RSDP_WINDOW_SIZE); if (mem_rover) { /* Found it, return the physical address */ table_info->physical_address = ACPI_TO_INTEGER(mem_rover); return_ACPI_STATUS(AE_OK); } } /* A valid RSDP was not found */ ACPI_REPORT_ERROR(("No valid RSDP was found\n")); return_ACPI_STATUS(AE_NOT_FOUND); }
ACPI_STATUS LsAmlOffsetWalk ( ACPI_PARSE_OBJECT *Op, UINT32 Level, void *Context) { UINT32 FileId = (UINT32) ACPI_TO_INTEGER (Context); ACPI_NAMESPACE_NODE *Node; UINT32 Length; UINT32 NamepathOffset; UINT32 DataOffset; ACPI_PARSE_OBJECT *NextOp; /* Ignore actual data blocks for resource descriptors */ if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DATA) { return (AE_OK); /* Do NOT update the global AML offset */ } /* We are only interested in named objects (have a namespace node) */ Node = Op->Asl.Node; if (!Node) { Gbl_CurrentAmlOffset += Op->Asl.FinalAmlLength; return (AE_OK); } /* Named resource descriptor (has a descriptor tag) */ if ((Node->Type == ACPI_TYPE_LOCAL_RESOURCE) && (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC)) { LsEmitOffsetTableEntry (FileId, Node, 0, Gbl_CurrentAmlOffset, Op->Asl.ParseOpName, 0, Op->Asl.Extra, AML_BUFFER_OP); Gbl_CurrentAmlOffset += Op->Asl.FinalAmlLength; return (AE_OK); } switch (Op->Asl.AmlOpcode) { case AML_NAME_OP: /* Named object -- Name (NameString, DataRefObject) */ if (!Op->Asl.Child) { FlPrintFile (FileId, "%s NO CHILD!\n", MsgBuffer); return (AE_OK); } Length = Op->Asl.FinalAmlLength; NamepathOffset = Gbl_CurrentAmlOffset + Length; /* Get to the NameSeg/NamePath Op (and length of the name) */ Op = Op->Asl.Child; /* Get offset of last nameseg and the actual data */ NamepathOffset = Gbl_CurrentAmlOffset + Length + (Op->Asl.FinalAmlLength - ACPI_NAME_SIZE); DataOffset = Gbl_CurrentAmlOffset + Length + Op->Asl.FinalAmlLength; /* Get actual value associated with the name */ Op = Op->Asl.Next; switch (Op->Asl.AmlOpcode) { case AML_BYTE_OP: case AML_WORD_OP: case AML_DWORD_OP: case AML_QWORD_OP: /* The +1 is to handle the integer size prefix (opcode) */ LsEmitOffsetTableEntry (FileId, Node, NamepathOffset, (DataOffset + 1), Op->Asl.ParseOpName, Op->Asl.Value.Integer, (UINT8) Op->Asl.AmlOpcode, AML_NAME_OP); break; case AML_ONE_OP: case AML_ONES_OP: case AML_ZERO_OP: /* For these, offset will point to the opcode */ LsEmitOffsetTableEntry (FileId, Node, NamepathOffset, DataOffset, Op->Asl.ParseOpName, Op->Asl.Value.Integer, (UINT8) Op->Asl.AmlOpcode, AML_NAME_OP); break; case AML_PACKAGE_OP: case AML_VAR_PACKAGE_OP: /* Get the package element count */ NextOp = Op->Asl.Child; LsEmitOffsetTableEntry (FileId, Node, NamepathOffset, DataOffset, Op->Asl.ParseOpName, NextOp->Asl.Value.Integer, (UINT8) Op->Asl.AmlOpcode, AML_NAME_OP); break; default: break; } Gbl_CurrentAmlOffset += Length; return (AE_OK); case AML_REGION_OP: /* OperationRegion (NameString, RegionSpace, RegionOffset, RegionLength) */ Length = Op->Asl.FinalAmlLength; /* Get the name/namepath node */ NextOp = Op->Asl.Child; /* Get offset of last nameseg and the actual data */ NamepathOffset = Gbl_CurrentAmlOffset + Length + (NextOp->Asl.FinalAmlLength - ACPI_NAME_SIZE); DataOffset = Gbl_CurrentAmlOffset + Length + (NextOp->Asl.FinalAmlLength + 1); /* Get the SpaceId node, then the Offset (address) node */ NextOp = NextOp->Asl.Next; NextOp = NextOp->Asl.Next; switch (NextOp->Asl.AmlOpcode) { /* * We are only interested in integer constants that can be changed * at boot time. Note, the One/Ones/Zero opcodes are considered * non-changeable, so we ignore them here. */ case AML_BYTE_OP: case AML_WORD_OP: case AML_DWORD_OP: case AML_QWORD_OP: LsEmitOffsetTableEntry (FileId, Node, NamepathOffset, (DataOffset + 1), Op->Asl.ParseOpName, NextOp->Asl.Value.Integer, (UINT8) NextOp->Asl.AmlOpcode, AML_REGION_OP); Gbl_CurrentAmlOffset += Length; return (AE_OK); default: break; } break; case AML_METHOD_OP: /* Method (Namepath, ...) */ Length = Op->Asl.FinalAmlLength; /* Get the NameSeg/NamePath Op */ NextOp = Op->Asl.Child; /* Get offset of last nameseg and the actual data (flags byte) */ NamepathOffset = Gbl_CurrentAmlOffset + Length + (NextOp->Asl.FinalAmlLength - ACPI_NAME_SIZE); DataOffset = Gbl_CurrentAmlOffset + Length + NextOp->Asl.FinalAmlLength; /* Get the flags byte Op */ NextOp = NextOp->Asl.Next; LsEmitOffsetTableEntry (FileId, Node, NamepathOffset, DataOffset, Op->Asl.ParseOpName, NextOp->Asl.Value.Integer, (UINT8) Op->Asl.AmlOpcode, AML_METHOD_OP); break; case AML_PROCESSOR_OP: /* Processor (Namepath, ProcessorId, Address, Length) */ Length = Op->Asl.FinalAmlLength; NextOp = Op->Asl.Child; /* Get Namepath */ /* Get offset of last nameseg and the actual data (PBlock address) */ NamepathOffset = Gbl_CurrentAmlOffset + Length + (NextOp->Asl.FinalAmlLength - ACPI_NAME_SIZE); DataOffset = Gbl_CurrentAmlOffset + Length + (NextOp->Asl.FinalAmlLength + 1); NextOp = NextOp->Asl.Next; /* Get ProcessorID (BYTE) */ NextOp = NextOp->Asl.Next; /* Get Address (DWORD) */ LsEmitOffsetTableEntry (FileId, Node, NamepathOffset, DataOffset, Op->Asl.ParseOpName, NextOp->Asl.Value.Integer, (UINT8) AML_DWORD_OP, AML_PROCESSOR_OP); break; case AML_DEVICE_OP: case AML_SCOPE_OP: case AML_THERMAL_ZONE_OP: /* Device/Scope/ThermalZone (Namepath) */ Length = Op->Asl.FinalAmlLength; NextOp = Op->Asl.Child; /* Get Namepath */ /* Get offset of last nameseg */ NamepathOffset = Gbl_CurrentAmlOffset + Length + (NextOp->Asl.FinalAmlLength - ACPI_NAME_SIZE); LsEmitOffsetTableEntry (FileId, Node, NamepathOffset, 0, Op->Asl.ParseOpName, 0, (UINT8) 0, Op->Asl.AmlOpcode); break; default: break; } Gbl_CurrentAmlOffset += Op->Asl.FinalAmlLength; return (AE_OK); }
ACPI_STATUS AcpiNsRootInitialize ( void) { ACPI_STATUS Status; const ACPI_PREDEFINED_NAMES *InitVal = NULL; ACPI_NAMESPACE_NODE *NewNode; ACPI_OPERAND_OBJECT *ObjDesc; ACPI_STRING Val = NULL; ACPI_FUNCTION_TRACE (NsRootInitialize); Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * The global root ptr is initially NULL, so a non-NULL value indicates * that AcpiNsRootInitialize() has already been called; just return. */ if (AcpiGbl_RootNode) { Status = AE_OK; goto UnlockAndExit; } /* * Tell the rest of the subsystem that the root is initialized * (This is OK because the namespace is locked) */ AcpiGbl_RootNode = &AcpiGbl_RootNodeStruct; /* Enter the pre-defined names in the name table */ ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Entering predefined entries into namespace\n")); for (InitVal = AcpiGbl_PreDefinedNames; InitVal->Name; InitVal++) { /* _OSI is optional for now, will be permanent later */ if (!strcmp (InitVal->Name, "_OSI") && !AcpiGbl_CreateOsiMethod) { continue; } Status = AcpiNsLookup (NULL, ACPI_CAST_PTR (char, InitVal->Name), InitVal->Type, ACPI_IMODE_LOAD_PASS2, ACPI_NS_NO_UPSEARCH, NULL, &NewNode); if (ACPI_FAILURE (Status)) { ACPI_EXCEPTION ((AE_INFO, Status, "Could not create predefined name %s", InitVal->Name)); continue; } /* * Name entered successfully. If entry in PreDefinedNames[] specifies * an initial value, create the initial value. */ if (InitVal->Val) { Status = AcpiOsPredefinedOverride (InitVal, &Val); if (ACPI_FAILURE (Status)) { ACPI_ERROR ((AE_INFO, "Could not override predefined %s", InitVal->Name)); } if (!Val) { Val = InitVal->Val; } /* * Entry requests an initial value, allocate a * descriptor for it. */ ObjDesc = AcpiUtCreateInternalObject (InitVal->Type); if (!ObjDesc) { Status = AE_NO_MEMORY; goto UnlockAndExit; } /* * Convert value string from table entry to * internal representation. Only types actually * used for initial values are implemented here. */ switch (InitVal->Type) { case ACPI_TYPE_METHOD: ObjDesc->Method.ParamCount = (UINT8) ACPI_TO_INTEGER (Val); ObjDesc->Common.Flags |= AOPOBJ_DATA_VALID; #if defined (ACPI_ASL_COMPILER) /* Save the parameter count for the iASL compiler */ NewNode->Value = ObjDesc->Method.ParamCount; #else /* Mark this as a very SPECIAL method */ ObjDesc->Method.InfoFlags = ACPI_METHOD_INTERNAL_ONLY; ObjDesc->Method.Dispatch.Implementation = AcpiUtOsiImplementation; #endif break; case ACPI_TYPE_INTEGER: ObjDesc->Integer.Value = ACPI_TO_INTEGER (Val); break; case ACPI_TYPE_STRING: /* Build an object around the static string */ ObjDesc->String.Length = (UINT32) strlen (Val); ObjDesc->String.Pointer = Val; ObjDesc->Common.Flags |= AOPOBJ_STATIC_POINTER; break; case ACPI_TYPE_MUTEX: ObjDesc->Mutex.Node = NewNode; ObjDesc->Mutex.SyncLevel = (UINT8) (ACPI_TO_INTEGER (Val) - 1); /* Create a mutex */ Status = AcpiOsCreateMutex (&ObjDesc->Mutex.OsMutex); if (ACPI_FAILURE (Status)) { AcpiUtRemoveReference (ObjDesc); goto UnlockAndExit; } /* Special case for ACPI Global Lock */ if (strcmp (InitVal->Name, "_GL_") == 0) { AcpiGbl_GlobalLockMutex = ObjDesc; /* Create additional counting semaphore for global lock */ Status = AcpiOsCreateSemaphore ( 1, 0, &AcpiGbl_GlobalLockSemaphore); if (ACPI_FAILURE (Status)) { AcpiUtRemoveReference (ObjDesc); goto UnlockAndExit; } } break; default: ACPI_ERROR ((AE_INFO, "Unsupported initial type value 0x%X", InitVal->Type)); AcpiUtRemoveReference (ObjDesc); ObjDesc = NULL; continue; } /* Store pointer to value descriptor in the Node */ Status = AcpiNsAttachObject (NewNode, ObjDesc, ObjDesc->Common.Type); /* Remove local reference to the object */ AcpiUtRemoveReference (ObjDesc); } } UnlockAndExit: (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); /* Save a handle to "_GPE", it is always present */ if (ACPI_SUCCESS (Status)) { Status = AcpiNsGetNode (NULL, "\\_GPE", ACPI_NS_NO_UPSEARCH, &AcpiGbl_FadtGpeDevice); } return_ACPI_STATUS (Status); }
ACPI_STATUS AeExceptionHandler ( ACPI_STATUS AmlStatus, ACPI_NAME Name, UINT16 Opcode, UINT32 AmlOffset, void *Context) { ACPI_STATUS NewAmlStatus = AmlStatus; ACPI_STATUS Status; ACPI_BUFFER ReturnObj; ACPI_OBJECT_LIST ArgList; ACPI_OBJECT Arg[3]; const char *Exception; Exception = AcpiFormatException (AmlStatus); AcpiOsPrintf ("[AcpiExec] Exception %s during execution ", Exception); if (Name) { AcpiOsPrintf ("of method [%4.4s]", (char *) &Name); } else { AcpiOsPrintf ("at module level (table load)"); } AcpiOsPrintf (" Opcode [%s] @%X\n", AcpiPsGetOpcodeName (Opcode), AmlOffset); /* * Invoke the _ERR method if present * * Setup parameter object */ ArgList.Count = 3; ArgList.Pointer = Arg; Arg[0].Type = ACPI_TYPE_INTEGER; Arg[0].Integer.Value = AmlStatus; Arg[1].Type = ACPI_TYPE_STRING; Arg[1].String.Pointer = ACPI_CAST_PTR (char, Exception); Arg[1].String.Length = ACPI_STRLEN (Exception); Arg[2].Type = ACPI_TYPE_INTEGER; Arg[2].Integer.Value = ACPI_TO_INTEGER (AcpiOsGetThreadId()); /* Setup return buffer */ ReturnObj.Pointer = NULL; ReturnObj.Length = ACPI_ALLOCATE_BUFFER; Status = AcpiEvaluateObject (NULL, "\\_ERR", &ArgList, &ReturnObj); if (ACPI_SUCCESS (Status)) { if (ReturnObj.Pointer) { /* Override original status */ NewAmlStatus = (ACPI_STATUS) ((ACPI_OBJECT *) ReturnObj.Pointer)->Integer.Value; AcpiOsFree (ReturnObj.Pointer); } } else if (Status != AE_NOT_FOUND) { AcpiOsPrintf ("[AcpiExec] Could not execute _ERR method, %s\n", AcpiFormatException (Status)); } /* Global override */ if (AcpiGbl_IgnoreErrors) { NewAmlStatus = AE_OK; } if (NewAmlStatus != AmlStatus) { AcpiOsPrintf ("[AcpiExec] Exception override, new status %s\n", AcpiFormatException (NewAmlStatus)); } return (NewAmlStatus); }
ACPI_STATUS AcpiTbFindRsdp ( ACPI_TABLE_DESC *TableInfo, UINT32 Flags) { UINT8 *TablePtr; UINT8 *MemRover; UINT64 PhysAddr; ACPI_STATUS Status = AE_OK; ACPI_FUNCTION_TRACE ("TbFindRsdp"); /* * Scan supports either 1) Logical addressing or 2) Physical addressing */ if ((Flags & ACPI_MEMORY_MODE) == ACPI_LOGICAL_ADDRESSING) { /* * 1) Search EBDA (low memory) paragraphs */ Status = AcpiOsMapMemory ((UINT64) ACPI_LO_RSDP_WINDOW_BASE, ACPI_LO_RSDP_WINDOW_SIZE, (void **) &TablePtr); if (ACPI_FAILURE (Status)) { ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Could not map memory at %X for length %X\n", ACPI_LO_RSDP_WINDOW_BASE, ACPI_LO_RSDP_WINDOW_SIZE)); return_ACPI_STATUS (Status); } MemRover = AcpiTbScanMemoryForRsdp (TablePtr, ACPI_LO_RSDP_WINDOW_SIZE); AcpiOsUnmapMemory (TablePtr, ACPI_LO_RSDP_WINDOW_SIZE); if (MemRover) { /* Found it, return the physical address */ PhysAddr = ACPI_LO_RSDP_WINDOW_BASE; PhysAddr += ACPI_PTR_DIFF (MemRover,TablePtr); TableInfo->PhysicalAddress = PhysAddr; return_ACPI_STATUS (AE_OK); } /* * 2) Search upper memory: 16-byte boundaries in E0000h-F0000h */ Status = AcpiOsMapMemory ((UINT64) ACPI_HI_RSDP_WINDOW_BASE, ACPI_HI_RSDP_WINDOW_SIZE, (void **) &TablePtr); if (ACPI_FAILURE (Status)) { ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Could not map memory at %X for length %X\n", ACPI_HI_RSDP_WINDOW_BASE, ACPI_HI_RSDP_WINDOW_SIZE)); return_ACPI_STATUS (Status); } MemRover = AcpiTbScanMemoryForRsdp (TablePtr, ACPI_HI_RSDP_WINDOW_SIZE); AcpiOsUnmapMemory (TablePtr, ACPI_HI_RSDP_WINDOW_SIZE); if (MemRover) { /* Found it, return the physical address */ PhysAddr = ACPI_HI_RSDP_WINDOW_BASE; PhysAddr += ACPI_PTR_DIFF (MemRover, TablePtr); TableInfo->PhysicalAddress = PhysAddr; return_ACPI_STATUS (AE_OK); } } /* * Physical addressing */ else { /* * 1) Search EBDA (low memory) paragraphs */ MemRover = AcpiTbScanMemoryForRsdp (ACPI_PHYSADDR_TO_PTR (ACPI_LO_RSDP_WINDOW_BASE), ACPI_LO_RSDP_WINDOW_SIZE); if (MemRover) { /* Found it, return the physical address */ TableInfo->PhysicalAddress = ACPI_TO_INTEGER (MemRover); return_ACPI_STATUS (AE_OK); } /* * 2) Search upper memory: 16-byte boundaries in E0000h-F0000h */ MemRover = AcpiTbScanMemoryForRsdp (ACPI_PHYSADDR_TO_PTR (ACPI_HI_RSDP_WINDOW_BASE), ACPI_HI_RSDP_WINDOW_SIZE); if (MemRover) { /* Found it, return the physical address */ TableInfo->PhysicalAddress = ACPI_TO_INTEGER (MemRover); return_ACPI_STATUS (AE_OK); } } /* RSDP signature was not found */ return_ACPI_STATUS (AE_NOT_FOUND); }
acpi_status acpi_ds_eval_table_region_operands(struct acpi_walk_state *walk_state, union acpi_parse_object *op) { acpi_status status; union acpi_operand_object *obj_desc; union acpi_operand_object **operand; struct acpi_namespace_node *node; union acpi_parse_object *next_op; u32 table_index; struct acpi_table_header *table; ACPI_FUNCTION_TRACE_PTR(ds_eval_table_region_operands, op); /* * This is where we evaluate the signature_string and oem_iDString * and oem_table_iDString of the data_table_region declaration */ node = op->common.node; /* next_op points to signature_string op */ next_op = op->common.value.arg; /* * Evaluate/create the signature_string and oem_iDString * and oem_table_iDString operands */ status = acpi_ds_create_operands(walk_state, next_op); if (ACPI_FAILURE(status)) { return_ACPI_STATUS(status); } /* * Resolve the signature_string and oem_iDString * and oem_table_iDString operands */ status = acpi_ex_resolve_operands(op->common.aml_opcode, ACPI_WALK_OPERANDS, walk_state); if (ACPI_FAILURE(status)) { return_ACPI_STATUS(status); } operand = &walk_state->operands[0]; /* Find the ACPI table */ status = acpi_tb_find_table(operand[0]->string.pointer, operand[1]->string.pointer, operand[2]->string.pointer, &table_index); if (ACPI_FAILURE(status)) { return_ACPI_STATUS(status); } acpi_ut_remove_reference(operand[0]); acpi_ut_remove_reference(operand[1]); acpi_ut_remove_reference(operand[2]); status = acpi_get_table_by_index(table_index, &table); if (ACPI_FAILURE(status)) { return_ACPI_STATUS(status); } obj_desc = acpi_ns_get_attached_object(node); if (!obj_desc) { return_ACPI_STATUS(AE_NOT_EXIST); } obj_desc->region.address = (acpi_physical_address) ACPI_TO_INTEGER(table); obj_desc->region.length = table->length; ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "RgnObj %p Addr %8.8X%8.8X Len %X\n", obj_desc, ACPI_FORMAT_NATIVE_UINT(obj_desc->region.address), obj_desc->region.length)); /* Now the address and length are valid for this opregion */ obj_desc->region.flags |= AOPOBJ_DATA_VALID; return_ACPI_STATUS(status); }
ACPI_STATUS LsAmlOffsetWalk ( ACPI_PARSE_OBJECT *Op, UINT32 Level, void *Context) { UINT32 FileId = (UINT32) ACPI_TO_INTEGER (Context); ACPI_NAMESPACE_NODE *Node; UINT32 Length; UINT32 OffsetOfOpcode; ACPI_PARSE_OBJECT *AddressOp; /* Ignore actual data blocks for resource descriptors */ if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DATA) { return (AE_OK); /* Do NOT update the global AML offset */ } /* We are only interested in named objects (have a namespace node) */ Node = Op->Asl.Node; if (!Node) { Gbl_CurrentAmlOffset += Op->Asl.FinalAmlLength; return (AE_OK); } /* Named resource descriptor (has a descriptor tag) */ if ((Node->Type == ACPI_TYPE_LOCAL_RESOURCE) && (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC)) { LsEmitOffsetTableEntry (FileId, Node, Gbl_CurrentAmlOffset, Op->Asl.FinalAmlLength, Op->Asl.ParseOpName, 0, Op->Asl.Extra); } /* Named object -- Name (NameString, DataRefObject) */ else if (Op->Asl.AmlOpcode == AML_NAME_OP) { if (!Op->Asl.Child) { FlPrintFile (FileId, "%s NO CHILD!\n", MsgBuffer); return (AE_OK); } Length = Op->Asl.FinalAmlLength; /* Get to the NameSeg/NamePath Op (and length of the name) */ Op = Op->Asl.Child; OffsetOfOpcode = Length + Op->Asl.FinalAmlLength; /* Get actual value associated with the name */ Op = Op->Asl.Next; switch (Op->Asl.AmlOpcode) { /* * We are only interested in integer constants that can be changed * at boot time. Note, the One/Ones/Zero opcodes are considered * non-changeable, so we ignore them here. */ case AML_BYTE_OP: case AML_WORD_OP: case AML_DWORD_OP: case AML_QWORD_OP: /* The +1/-1 is to handle the integer size prefix (opcode) */ LsEmitOffsetTableEntry (FileId, Node, (Gbl_CurrentAmlOffset + OffsetOfOpcode + 1), (Op->Asl.FinalAmlLength - 1), Op->Asl.ParseOpName, Op->Asl.Value.Integer, (UINT8) Op->Asl.AmlOpcode); break; default: break; } Gbl_CurrentAmlOffset += Length; return (AE_OK); } /* OperationRegion (NameString, RegionSpace, RegionOffset, RegionLength) */ else if (Op->Asl.AmlOpcode == AML_REGION_OP) { Length = Op->Asl.FinalAmlLength; /* Get the name/namepath node */ AddressOp = Op->Asl.Child; OffsetOfOpcode = Length + AddressOp->Asl.FinalAmlLength + 1; /* Get the SpaceId node, then the Offset (address) node */ AddressOp = AddressOp->Asl.Next; AddressOp = AddressOp->Asl.Next; switch (AddressOp->Asl.AmlOpcode) { /* * We are only interested in integer constants that can be changed * at boot time. Note, the One/Ones/Zero opcodes are considered * non-changeable, so we ignore them here. */ case AML_BYTE_OP: case AML_WORD_OP: case AML_DWORD_OP: case AML_QWORD_OP: /* The +1/-1 is to handle the integer size prefix (opcode) */ LsEmitOffsetTableEntry (FileId, Node, (Gbl_CurrentAmlOffset + OffsetOfOpcode + 1), (AddressOp->Asl.FinalAmlLength - 1), Op->Asl.ParseOpName, AddressOp->Asl.Value.Integer, (UINT8) AddressOp->Asl.AmlOpcode); Gbl_CurrentAmlOffset += Length; return (AE_OK); default: break; } } Gbl_CurrentAmlOffset += Op->Asl.FinalAmlLength; return (AE_OK); }
/******************************************************************************* * * FUNCTION: acpi_ns_root_initialize * * PARAMETERS: None * * RETURN: Status * * DESCRIPTION: Allocate and initialize the default root named objects * * MUTEX: Locks namespace for entire execution * ******************************************************************************/ acpi_status acpi_ns_root_initialize(void) { acpi_status status; const struct acpi_predefined_names *init_val = NULL; struct acpi_namespace_node *new_node; union acpi_operand_object *obj_desc; acpi_string val = NULL; ACPI_FUNCTION_TRACE(ns_root_initialize); status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE); if (ACPI_FAILURE(status)) { return_ACPI_STATUS(status); } /* * The global root ptr is initially NULL, so a non-NULL value indicates * that acpi_ns_root_initialize() has already been called; just return. */ if (acpi_gbl_root_node) { status = AE_OK; goto unlock_and_exit; } /* * Tell the rest of the subsystem that the root is initialized * (This is OK because the namespace is locked) */ acpi_gbl_root_node = &acpi_gbl_root_node_struct; /* Enter the pre-defined names in the name table */ ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Entering predefined entries into namespace\n")); for (init_val = acpi_gbl_pre_defined_names; init_val->name; init_val++) { /* _OSI is optional for now, will be permanent later */ if (!ACPI_STRCMP(init_val->name, "_OSI") && !acpi_gbl_create_osi_method) { continue; } status = acpi_ns_lookup(NULL, init_val->name, init_val->type, ACPI_IMODE_LOAD_PASS2, ACPI_NS_NO_UPSEARCH, NULL, &new_node); if (ACPI_FAILURE(status) || (!new_node)) { /* Must be on same line for code converter */ ACPI_EXCEPTION((AE_INFO, status, "Could not create predefined name %s", init_val->name)); } /* * Name entered successfully. * If entry in pre_defined_names[] specifies an * initial value, create the initial value. */ if (init_val->val) { status = acpi_os_predefined_override(init_val, &val); if (ACPI_FAILURE(status)) { ACPI_ERROR((AE_INFO, "Could not override predefined %s", init_val->name)); } if (!val) { val = init_val->val; } /* * Entry requests an initial value, allocate a * descriptor for it. */ obj_desc = acpi_ut_create_internal_object(init_val->type); if (!obj_desc) { status = AE_NO_MEMORY; goto unlock_and_exit; } /* * Convert value string from table entry to * internal representation. Only types actually * used for initial values are implemented here. */ switch (init_val->type) { case ACPI_TYPE_METHOD: obj_desc->method.param_count = (u8) ACPI_TO_INTEGER(val); obj_desc->common.flags |= AOPOBJ_DATA_VALID; #if defined (ACPI_ASL_COMPILER) /* Save the parameter count for the i_aSL compiler */ new_node->value = obj_desc->method.param_count; #else /* Mark this as a very SPECIAL method */ obj_desc->method.method_flags = AML_METHOD_INTERNAL_ONLY; obj_desc->method.implementation = acpi_ut_osi_implementation; #endif break; case ACPI_TYPE_INTEGER: obj_desc->integer.value = ACPI_TO_INTEGER(val); break; case ACPI_TYPE_STRING: /* * Build an object around the static string */ obj_desc->string.length = (u32) ACPI_STRLEN(val); obj_desc->string.pointer = val; obj_desc->common.flags |= AOPOBJ_STATIC_POINTER; break; case ACPI_TYPE_MUTEX: obj_desc->mutex.node = new_node; obj_desc->mutex.sync_level = (u8) (ACPI_TO_INTEGER(val) - 1); /* Create a mutex */ status = acpi_os_create_mutex(&obj_desc->mutex. os_mutex); if (ACPI_FAILURE(status)) { acpi_ut_remove_reference(obj_desc); goto unlock_and_exit; } /* Special case for ACPI Global Lock */ if (ACPI_STRCMP(init_val->name, "_GL_") == 0) { acpi_gbl_global_lock_mutex = obj_desc; /* Create additional counting semaphore for global lock */ status = acpi_os_create_semaphore(1, 0, &acpi_gbl_global_lock_semaphore); if (ACPI_FAILURE(status)) { acpi_ut_remove_reference (obj_desc); goto unlock_and_exit; } } break; default: ACPI_ERROR((AE_INFO, "Unsupported initial type value %X", init_val->type)); acpi_ut_remove_reference(obj_desc); obj_desc = NULL; continue; } /* Store pointer to value descriptor in the Node */ status = acpi_ns_attach_object(new_node, obj_desc, ACPI_GET_OBJECT_TYPE (obj_desc)); /* Remove local reference to the object */ acpi_ut_remove_reference(obj_desc); } } unlock_and_exit: (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE); /* Save a handle to "_GPE", it is always present */ if (ACPI_SUCCESS(status)) { status = acpi_ns_get_node(NULL, "\\_GPE", ACPI_NS_NO_UPSEARCH, &acpi_gbl_fadt_gpe_device); } return_ACPI_STATUS(status); }
static void ACPI_SYSTEM_XFACE AcpiDbMethodThread ( void *Context) { ACPI_STATUS Status; ACPI_DB_METHOD_INFO *Info = Context; ACPI_DB_METHOD_INFO LocalInfo; UINT32 i; UINT8 Allow; ACPI_BUFFER ReturnObj; /* * AcpiGbl_DbMethodInfo.Arguments will be passed as method arguments. * Prevent AcpiGbl_DbMethodInfo from being modified by multiple threads * concurrently. * * Note: The arguments we are passing are used by the ASL test suite * (aslts). Do not change them without updating the tests. */ (void) AcpiOsWaitSemaphore (Info->InfoGate, 1, ACPI_WAIT_FOREVER); if (Info->InitArgs) { AcpiDbUInt32ToHexString (Info->NumCreated, Info->IndexOfThreadStr); AcpiDbUInt32ToHexString (ACPI_TO_INTEGER (AcpiOsGetThreadId ()), Info->IdOfThreadStr); } if (Info->Threads && (Info->NumCreated < Info->NumThreads)) { Info->Threads[Info->NumCreated++] = ACPI_TO_INTEGER (AcpiOsGetThreadId()); } LocalInfo = *Info; LocalInfo.Args = LocalInfo.Arguments; LocalInfo.Arguments[0] = LocalInfo.NumThreadsStr; LocalInfo.Arguments[1] = LocalInfo.IdOfThreadStr; LocalInfo.Arguments[2] = LocalInfo.IndexOfThreadStr; LocalInfo.Arguments[3] = NULL; (void) AcpiOsSignalSemaphore (Info->InfoGate, 1); for (i = 0; i < Info->NumLoops; i++) { Status = AcpiDbExecuteMethod (&LocalInfo, &ReturnObj); if (ACPI_FAILURE (Status)) { AcpiOsPrintf ("%s During execution of %s at iteration %X\n", AcpiFormatException (Status), Info->Pathname, i); if (Status == AE_ABORT_METHOD) { break; } } #if 0 if ((i % 100) == 0) { AcpiOsPrintf ("%d executions, Thread 0x%x\n", i, AcpiOsGetThreadId ()); } if (ReturnObj.Length) { AcpiOsPrintf ("Execution of %s returned object %p Buflen %X\n", Info->Pathname, ReturnObj.Pointer, (UINT32) ReturnObj.Length); AcpiDbDumpExternalObject (ReturnObj.Pointer, 1); } #endif } /* Signal our completion */ Allow = 0; (void) AcpiOsWaitSemaphore (Info->ThreadCompleteGate, 1, ACPI_WAIT_FOREVER); Info->NumCompleted++; if (Info->NumCompleted == Info->NumThreads) { /* Do signal for main thread once only */ Allow = 1; } (void) AcpiOsSignalSemaphore (Info->ThreadCompleteGate, 1); if (Allow) { Status = AcpiOsSignalSemaphore (Info->MainThreadGate, 1); if (ACPI_FAILURE (Status)) { AcpiOsPrintf ("Could not signal debugger thread sync semaphore, %s\n", AcpiFormatException (Status)); } } }