自学教程：C++ ACPI_FUNCTION_TRACE_STR函数代码示例

ACPI_STATUSAcpiExOpcode_2A_2T_1R (    ACPI_WALK_STATE         *WalkState){    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];    ACPI_OPERAND_OBJECT     *ReturnDesc1 = NULL;    ACPI_OPERAND_OBJECT     *ReturnDesc2 = NULL;    ACPI_STATUS             Status;    ACPI_FUNCTION_TRACE_STR (ExOpcode_2A_2T_1R,        AcpiPsGetOpcodeName (WalkState->Opcode));    /* Execute the opcode */    switch (WalkState->Opcode)    {    case AML_DIVIDE_OP:        /* Divide (Dividend, Divisor, RemainderResult QuotientResult) */        ReturnDesc1 = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);        if (!ReturnDesc1)        {            Status = AE_NO_MEMORY;            goto Cleanup;        }        ReturnDesc2 = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);        if (!ReturnDesc2)        {            Status = AE_NO_MEMORY;            goto Cleanup;        }        /* Quotient to ReturnDesc1, remainder to ReturnDesc2 */        Status = AcpiUtDivide (Operand[0]->Integer.Value,                               Operand[1]->Integer.Value,                               &ReturnDesc1->Integer.Value,                               &ReturnDesc2->Integer.Value);        if (ACPI_FAILURE (Status))        {            goto Cleanup;        }        break;    default:        ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",            WalkState->Opcode));        Status = AE_AML_BAD_OPCODE;        goto Cleanup;    }    /* Store the results to the target reference operands */    Status = AcpiExStore (ReturnDesc2, Operand[2], WalkState);    if (ACPI_FAILURE (Status))    {        goto Cleanup;    }    Status = AcpiExStore (ReturnDesc1, Operand[3], WalkState);    if (ACPI_FAILURE (Status))    {        goto Cleanup;    }Cleanup:    /*     * Since the remainder is not returned indirectly, remove a reference to     * it. Only the quotient is returned indirectly.     */    AcpiUtRemoveReference (ReturnDesc2);    if (ACPI_FAILURE (Status))    {        /* Delete the return object */        AcpiUtRemoveReference (ReturnDesc1);    }    /* Save return object (the remainder) on success */    else    {        WalkState->ResultObj = ReturnDesc1;    }    return_ACPI_STATUS (Status);}

acpi_statusacpi_ex_opcode_6A_0T_1R (	struct acpi_walk_state          *walk_state){	union acpi_operand_object       **operand = &walk_state->operands[0];	union acpi_operand_object       *return_desc = NULL;	acpi_status                     status = AE_OK;	u32                             index;	union acpi_operand_object       *this_element;	ACPI_FUNCTION_TRACE_STR ("ex_opcode_6A_0T_1R", acpi_ps_get_opcode_name (walk_state->opcode));	switch (walk_state->opcode) {	case AML_MATCH_OP:		/*		 * Match (search_package[0], match_op1[1], match_object1[2],		 *                          match_op2[3], match_object2[4], start_index[5])		 */		/* Validate match comparison sub-opcodes */		if ((operand[1]->integer.value > MAX_MATCH_OPERATOR) ||			(operand[3]->integer.value > MAX_MATCH_OPERATOR)) {			ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "operation encoding out of range/n"));			status = AE_AML_OPERAND_VALUE;			goto cleanup;		}		index = (u32) operand[5]->integer.value;		if (index >= (u32) operand[0]->package.count) {			ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Index beyond package end/n"));			status = AE_AML_PACKAGE_LIMIT;			goto cleanup;		}		return_desc = acpi_ut_create_internal_object (ACPI_TYPE_INTEGER);		if (!return_desc) {			status = AE_NO_MEMORY;			goto cleanup;		}		/* Default return value if no match found */		return_desc->integer.value = ACPI_INTEGER_MAX;		/*		 * Examine each element until a match is found.  Within the loop,		 * "continue" signifies that the current element does not match		 * and the next should be examined.		 *		 * Upon finding a match, the loop will terminate via "break" at		 * the bottom.  If it terminates "normally", match_value will be -1		 * (its initial value) indicating that no match was found.  When		 * returned as a Number, this will produce the Ones value as specified.		 */		for ( ; index < operand[0]->package.count; index++) {			this_element = operand[0]->package.elements[index];			/*			 * Treat any NULL or non-numeric elements as non-matching.			 */			if (!this_element ||				ACPI_GET_OBJECT_TYPE (this_element) != ACPI_TYPE_INTEGER) {				continue;			}			/*			 * "continue" (proceed to next iteration of enclosing			 * "for" loop) signifies a non-match.			 */			if (!acpi_ex_do_match ((u32) operand[1]->integer.value,					   this_element->integer.value, operand[2]->integer.value)) {				continue;			}			if (!acpi_ex_do_match ((u32) operand[3]->integer.value,					   this_element->integer.value, operand[4]->integer.value)) {				continue;			}			/* Match found: Index is the return value */			return_desc->integer.value = index;			break;		}		break;	case AML_LOAD_TABLE_OP:		status = acpi_ex_load_table_op (walk_state, &return_desc);		break;	default://.........这里部分代码省略.........

/******************************************************************************* * * FUNCTION:    acpi_ut_strtoul64 * * PARAMETERS:  string                  - Null terminated input string, *                                        must be a valid pointer *              return_value            - Where the converted integer is *                                        returned. Must be a valid pointer * * RETURN:      Status and converted integer. Returns an exception on a *              64-bit numeric overflow * * DESCRIPTION: Convert a string into an unsigned integer. Always performs a *              full 64-bit conversion, regardless of the current global *              integer width. Supports Decimal, Hex, and Octal strings. * * Current users of this function: * *  iASL        - Preprocessor (constants and math expressions) *  iASL        - Main ASL parser, conversion of ASL constants to integers *  iASL        - Data Table Compiler parser (constants and math expressions) *  interpreter - Repair code for return values from predefined names *  acpi_dump   - ACPI table physical addresses *  acpi_exec   - Support for namespace overrides * ******************************************************************************/acpi_status acpi_ut_strtoul64(char *string, u64 *return_value){	acpi_status status = AE_OK;	u8 original_bit_width;	u32 base = 10;		/* Default is decimal */	ACPI_FUNCTION_TRACE_STR(ut_strtoul64, string);	*return_value = 0;	/* A NULL return string returns a value of zero */	if (*string == 0) {		return_ACPI_STATUS(AE_OK);	}	if (!acpi_ut_remove_whitespace(&string)) {		return_ACPI_STATUS(AE_OK);	}	/*	 * 1) Check for a hex constant. A "0x" prefix indicates base 16.	 */	if (acpi_ut_detect_hex_prefix(&string)) {		base = 16;	}	/*	 * 2) Check for an octal constant, defined to be a leading zero	 * followed by sequence of octal digits (0-7)	 */	else if (acpi_ut_detect_octal_prefix(&string)) {		base = 8;	}	if (!acpi_ut_remove_leading_zeros(&string)) {		return_ACPI_STATUS(AE_OK);	/* Return value 0 */	}	/*	 * Force a full 64-bit conversion. The caller (usually iASL) must	 * check for a 32-bit overflow later as necessary (If current mode	 * is 32-bit, meaning a 32-bit DSDT).	 */	original_bit_width = acpi_gbl_integer_bit_width;	acpi_gbl_integer_bit_width = 64;	/*	 * Perform the base 8, 10, or 16 conversion. A 64-bit numeric overflow	 * will return an exception (to allow iASL to flag the statement).	 */	switch (base) {	case 8:		status = acpi_ut_convert_octal_string(string, return_value);		break;	case 10:		status = acpi_ut_convert_decimal_string(string, return_value);		break;	case 16:	default:		status = acpi_ut_convert_hex_string(string, return_value);		break;	}	/* Only possible exception from above is a 64-bit overflow */	acpi_gbl_integer_bit_width = original_bit_width;	return_ACPI_STATUS(status);}

ACPI_STATUSAcpiExOpcode_1A_0T_1R (    ACPI_WALK_STATE         *WalkState){    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];    ACPI_OPERAND_OBJECT     *TempDesc;    ACPI_OPERAND_OBJECT     *ReturnDesc = NULL;    ACPI_STATUS             Status = AE_OK;    UINT32                  Type;    ACPI_INTEGER            Value;    ACPI_FUNCTION_TRACE_STR (ExOpcode_1A_0T_1R,        AcpiPsGetOpcodeName (WalkState->Opcode));    /* Examine the AML opcode */    switch (WalkState->Opcode)    {    case AML_LNOT_OP:               /* LNot (Operand) */        ReturnDesc = AcpiUtCreateIntegerObject ((UINT64) 0);        if (!ReturnDesc)        {            Status = AE_NO_MEMORY;            goto Cleanup;        }        /*         * Set result to ONES (TRUE) if Value == 0.  Note:         * ReturnDesc->Integer.Value is initially == 0 (FALSE) from above.         */        if (!Operand[0]->Integer.Value)        {            ReturnDesc->Integer.Value = ACPI_INTEGER_MAX;        }        break;    case AML_DECREMENT_OP:          /* Decrement (Operand)  */    case AML_INCREMENT_OP:          /* Increment (Operand)  */        /*         * Create a new integer.  Can't just get the base integer and         * increment it because it may be an Arg or Field.         */        ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);        if (!ReturnDesc)        {            Status = AE_NO_MEMORY;            goto Cleanup;        }        /*         * Since we are expecting a Reference operand, it can be either a         * NS Node or an internal object.         */        TempDesc = Operand[0];        if (ACPI_GET_DESCRIPTOR_TYPE (TempDesc) == ACPI_DESC_TYPE_OPERAND)        {            /* Internal reference object - prevent deletion */            AcpiUtAddReference (TempDesc);        }        /*         * Convert the Reference operand to an Integer (This removes a         * reference on the Operand[0] object)         *         * NOTE:  We use LNOT_OP here in order to force resolution of the         * reference operand to an actual integer.         */        Status = AcpiExResolveOperands (AML_LNOT_OP, &TempDesc, WalkState);        if (ACPI_FAILURE (Status))        {            ACPI_EXCEPTION ((AE_INFO, Status,                "While resolving operands for [%s]",                AcpiPsGetOpcodeName (WalkState->Opcode)));            goto Cleanup;        }        /*         * TempDesc is now guaranteed to be an Integer object --         * Perform the actual increment or decrement         */        if (WalkState->Opcode == AML_INCREMENT_OP)        {            ReturnDesc->Integer.Value = TempDesc->Integer.Value +1;        }        else        {            ReturnDesc->Integer.Value = TempDesc->Integer.Value -1;        }        /* Finished with this Integer object */        AcpiUtRemoveReference (TempDesc);//.........这里部分代码省略.........

ACPI_STATUSAcpiUtStrtoul64 (    char                    *String,    UINT32                  Base,    UINT64                  *RetInteger){    UINT32                  ThisDigit = 0;    UINT64                  ReturnValue = 0;    UINT64                  Quotient;    UINT64                  Dividend;    UINT32                  ToIntegerOp = (Base == ACPI_ANY_BASE);    UINT32                  Mode32 = (AcpiGbl_IntegerByteWidth == 4);    UINT8                   ValidDigits = 0;    UINT8                   SignOf0x = 0;    UINT8                   Term = 0;    ACPI_FUNCTION_TRACE_STR (UtStroul64, String);    switch (Base)    {    case ACPI_ANY_BASE:    case 16:        break;    default:        /* Invalid Base */        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    if (!String)    {        goto ErrorExit;    }    /* Skip over any white space in the buffer */    while ((*String) && (ACPI_IS_SPACE (*String) || *String == '/t'))    {        String++;    }    if (ToIntegerOp)    {        /*         * Base equal to ACPI_ANY_BASE means 'ToInteger operation case'.         * We need to determine if it is decimal or hexadecimal.         */        if ((*String == '0') && (ACPI_TOLOWER (*(String + 1)) == 'x'))        {            SignOf0x = 1;            Base = 16;            /* Skip over the leading '0x' */            String += 2;        }        else        {            Base = 10;        }    }    /* Any string left? Check that '0x' is not followed by white space. */    if (!(*String) || ACPI_IS_SPACE (*String) || *String == '/t')    {        if (ToIntegerOp)        {            goto ErrorExit;        }        else        {            goto AllDone;        }    }    /*     * Perform a 32-bit or 64-bit conversion, depending upon the current     * execution mode of the interpreter     */    Dividend = (Mode32) ? ACPI_UINT32_MAX : ACPI_UINT64_MAX;    /* Main loop: convert the string to a 32- or 64-bit integer */    while (*String)    {        if (ACPI_IS_DIGIT (*String))        {            /* Convert ASCII 0-9 to Decimal value */            ThisDigit = ((UINT8) *String) - '0';        }        else if (Base == 10)        {            /* Digit is out of range; possible in ToInteger case only *///.........这里部分代码省略.........

ACPI_STATUSAcpiExOpcode_1A_0T_0R (    ACPI_WALK_STATE         *WalkState){    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];    ACPI_STATUS             Status = AE_OK;    ACPI_FUNCTION_TRACE_STR (ExOpcode_1A_0T_0R,        AcpiPsGetOpcodeName (WalkState->Opcode));    /* Examine the AML opcode */    switch (WalkState->Opcode)    {    case AML_RELEASE_OP:    /*  Release (MutexObject) */        Status = AcpiExReleaseMutex (Operand[0], WalkState);        break;    case AML_RESET_OP:      /*  Reset (EventObject) */        Status = AcpiExSystemResetEvent (Operand[0]);        break;    case AML_SIGNAL_OP:     /*  Signal (EventObject) */        Status = AcpiExSystemSignalEvent (Operand[0]);        break;    case AML_SLEEP_OP:      /*  Sleep (MsecTime) */        Status = AcpiExSystemDoSuspend (Operand[0]->Integer.Value);        break;    case AML_STALL_OP:      /*  Stall (UsecTime) */        Status = AcpiExSystemDoStall ((UINT32) Operand[0]->Integer.Value);        break;    case AML_UNLOAD_OP:     /*  Unload (Handle) */        Status = AcpiExUnloadTable (Operand[0]);        break;    default:                /*  Unknown opcode  */        ACPI_ERROR ((AE_INFO, "Unknown AML opcode %X",            WalkState->Opcode));        Status = AE_AML_BAD_OPCODE;        break;    }    return_ACPI_STATUS (Status);}

acpi_status acpi_ex_opcode_1A_1T_1R(struct acpi_walk_state *walk_state){	acpi_status status = AE_OK;	union acpi_operand_object **operand = &walk_state->operands[0];	union acpi_operand_object *return_desc = NULL;	union acpi_operand_object *return_desc2 = NULL;	u32 temp32;	u32 i;	acpi_integer power_of_ten;	acpi_integer digit;	ACPI_FUNCTION_TRACE_STR(ex_opcode_1A_1T_1R,				acpi_ps_get_opcode_name(walk_state->opcode));	/* Examine the AML opcode */	switch (walk_state->opcode) {	case AML_BIT_NOT_OP:	case AML_FIND_SET_LEFT_BIT_OP:	case AML_FIND_SET_RIGHT_BIT_OP:	case AML_FROM_BCD_OP:	case AML_TO_BCD_OP:	case AML_COND_REF_OF_OP:		/* Create a return object of type Integer for these opcodes */		return_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);		if (!return_desc) {			status = AE_NO_MEMORY;			goto cleanup;		}		switch (walk_state->opcode) {		case AML_BIT_NOT_OP:	/* Not (Operand, Result)  */			return_desc->integer.value = ~operand[0]->integer.value;			break;		case AML_FIND_SET_LEFT_BIT_OP:	/* find_set_left_bit (Operand, Result) */			return_desc->integer.value = operand[0]->integer.value;			/*			 * Acpi specification describes Integer type as a little			 * endian unsigned value, so this boundary condition is valid.			 */			for (temp32 = 0; return_desc->integer.value &&			     temp32 < ACPI_INTEGER_BIT_SIZE; ++temp32) {				return_desc->integer.value >>= 1;			}			return_desc->integer.value = temp32;			break;		case AML_FIND_SET_RIGHT_BIT_OP:	/* find_set_right_bit (Operand, Result) */			return_desc->integer.value = operand[0]->integer.value;			/*			 * The Acpi specification describes Integer type as a little			 * endian unsigned value, so this boundary condition is valid.			 */			for (temp32 = 0; return_desc->integer.value &&			     temp32 < ACPI_INTEGER_BIT_SIZE; ++temp32) {				return_desc->integer.value <<= 1;			}			/* Since the bit position is one-based, subtract from 33 (65) */			return_desc->integer.value =			    temp32 ==			    0 ? 0 : (ACPI_INTEGER_BIT_SIZE + 1) - temp32;			break;		case AML_FROM_BCD_OP:	/* from_bcd (BCDValue, Result) */			/*			 * The 64-bit ACPI integer can hold 16 4-bit BCD characters			 * (if table is 32-bit, integer can hold 8 BCD characters)			 * Convert each 4-bit BCD value			 */			power_of_ten = 1;			return_desc->integer.value = 0;			digit = operand[0]->integer.value;			/* Convert each BCD digit (each is one nybble wide) */			for (i = 0;			     (i < acpi_gbl_integer_nybble_width) && (digit > 0);			     i++) {				/* Get the least significant 4-bit BCD digit */				temp32 = ((u32) digit) & 0xF;				/* Check the range of the digit */				if (temp32 > 9) {					ACPI_ERROR((AE_INFO,						    "BCD digit too large (not decimal): 0x%X",//.........这里部分代码省略.........

acpi_status acpi_ex_opcode_1A_0T_1R(struct acpi_walk_state *walk_state){	union acpi_operand_object **operand = &walk_state->operands[0];	union acpi_operand_object *temp_desc;	union acpi_operand_object *return_desc = NULL;	acpi_status status = AE_OK;	u32 type;	acpi_integer value;	ACPI_FUNCTION_TRACE_STR(ex_opcode_1A_0T_1R,				acpi_ps_get_opcode_name(walk_state->opcode));	/* Examine the AML opcode */	switch (walk_state->opcode) {	case AML_LNOT_OP:	/* LNot (Operand) */		return_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);		if (!return_desc) {			status = AE_NO_MEMORY;			goto cleanup;		}		/*		 * Set result to ONES (TRUE) if Value == 0.  Note:		 * return_desc->Integer.Value is initially == 0 (FALSE) from above.		 */		if (!operand[0]->integer.value) {			return_desc->integer.value = ACPI_INTEGER_MAX;		}		break;	case AML_DECREMENT_OP:	/* Decrement (Operand)  */	case AML_INCREMENT_OP:	/* Increment (Operand)  */		/*		 * Create a new integer.  Can't just get the base integer and		 * increment it because it may be an Arg or Field.		 */		return_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);		if (!return_desc) {			status = AE_NO_MEMORY;			goto cleanup;		}		/*		 * Since we are expecting a Reference operand, it can be either a		 * NS Node or an internal object.		 */		temp_desc = operand[0];		if (ACPI_GET_DESCRIPTOR_TYPE(temp_desc) ==		    ACPI_DESC_TYPE_OPERAND) {			/* Internal reference object - prevent deletion */			acpi_ut_add_reference(temp_desc);		}		/*		 * Convert the Reference operand to an Integer (This removes a		 * reference on the Operand[0] object)		 *		 * NOTE:  We use LNOT_OP here in order to force resolution of the		 * reference operand to an actual integer.		 */		status =		    acpi_ex_resolve_operands(AML_LNOT_OP, &temp_desc,					     walk_state);		if (ACPI_FAILURE(status)) {			ACPI_EXCEPTION((AE_INFO, status,					"While resolving operands for [%s]",					acpi_ps_get_opcode_name(walk_state->								opcode)));			goto cleanup;		}		/*		 * temp_desc is now guaranteed to be an Integer object --		 * Perform the actual increment or decrement		 */		if (walk_state->opcode == AML_INCREMENT_OP) {			return_desc->integer.value =			    temp_desc->integer.value + 1;		} else {			return_desc->integer.value =			    temp_desc->integer.value - 1;		}		/* Finished with this Integer object */		acpi_ut_remove_reference(temp_desc);		/*		 * Store the result back (indirectly) through the original		 * Reference object		 */		status = acpi_ex_store(return_desc, operand[0], walk_state);		break;//.........这里部分代码省略.........

/******************************************************************************* * * FUNCTION:    acpi_ex_opcode_3A_0T_0R * * PARAMETERS:  walk_state          - Current walk state * * RETURN:      Status * * DESCRIPTION: Execute Triadic operator (3 operands) * ******************************************************************************/acpi_status acpi_ex_opcode_3A_0T_0R(struct acpi_walk_state *walk_state){	union acpi_operand_object **operand = &walk_state->operands[0];	struct acpi_signal_fatal_info *fatal;	acpi_status status = AE_OK;	ACPI_FUNCTION_TRACE_STR(ex_opcode_3A_0T_0R,				acpi_ps_get_opcode_name(walk_state->opcode));	switch (walk_state->opcode) {	case AML_FATAL_OP:	/* Fatal (fatal_type fatal_code fatal_arg) */		ACPI_DEBUG_PRINT((ACPI_DB_INFO,				  "FatalOp: Type %X Code %X Arg %X "				  "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<</n",				  (u32)operand[0]->integer.value,				  (u32)operand[1]->integer.value,				  (u32)operand[2]->integer.value));		fatal = ACPI_ALLOCATE(sizeof(struct acpi_signal_fatal_info));		if (fatal) {			fatal->type = (u32) operand[0]->integer.value;			fatal->code = (u32) operand[1]->integer.value;			fatal->argument = (u32) operand[2]->integer.value;		}		/* Always signal the OS! */		status = acpi_os_signal(ACPI_SIGNAL_FATAL, fatal);		/* Might return while OS is shutting down, just continue */		ACPI_FREE(fatal);		goto cleanup;	case AML_EXTERNAL_OP:		/*		 * If the interpreter sees this opcode, just ignore it. The External		 * op is intended for use by disassemblers in order to properly		 * disassemble control method invocations. The opcode or group of		 * opcodes should be surrounded by an "if (0)" clause to ensure that		 * AML interpreters never see the opcode. Thus, something is		 * wrong if an external opcode ever gets here.		 */		ACPI_ERROR((AE_INFO, "Executed External Op"));		status = AE_OK;		goto cleanup;	default:		ACPI_ERROR((AE_INFO, "Unknown AML opcode 0x%X",			    walk_state->opcode));		status = AE_AML_BAD_OPCODE;		goto cleanup;	}cleanup:	return_ACPI_STATUS(status);}

acpi_status acpi_ex_opcode_6A_0T_1R(struct acpi_walk_state * walk_state){    union acpi_operand_object **operand = &walk_state->operands[0];    union acpi_operand_object *return_desc = NULL;    acpi_status status = AE_OK;    acpi_integer index;    union acpi_operand_object *this_element;    ACPI_FUNCTION_TRACE_STR("ex_opcode_6A_0T_1R",                            acpi_ps_get_opcode_name(walk_state->opcode));    switch (walk_state->opcode) {    case AML_MATCH_OP:        /*         * Match (search_pkg[0], match_op1[1], match_obj1[2],         *                      match_op2[3], match_obj2[4], start_index[5])         */        /* Validate both Match Term Operators (MTR, MEQ, etc.) */        if ((operand[1]->integer.value > MAX_MATCH_OPERATOR) ||                (operand[3]->integer.value > MAX_MATCH_OPERATOR)) {            ACPI_ERROR((AE_INFO, "Match operator out of range"));            status = AE_AML_OPERAND_VALUE;            goto cleanup;        }        /* Get the package start_index, validate against the package length */        index = operand[5]->integer.value;        if (index >= operand[0]->package.count) {            ACPI_ERROR((AE_INFO,                        "Index (%X%8.8X) beyond package end (%X)",                        ACPI_FORMAT_UINT64(index),                        operand[0]->package.count));            status = AE_AML_PACKAGE_LIMIT;            goto cleanup;        }        /* Create an integer for the return value */        return_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);        if (!return_desc) {            status = AE_NO_MEMORY;            goto cleanup;        }        /* Default return value if no match found */        return_desc->integer.value = ACPI_INTEGER_MAX;        /*         * Examine each element until a match is found. Both match conditions         * must be satisfied for a match to occur. Within the loop,         * "continue" signifies that the current element does not match         * and the next should be examined.         *         * Upon finding a match, the loop will terminate via "break" at         * the bottom.  If it terminates "normally", match_value will be         * ACPI_INTEGER_MAX (Ones) (its initial value) indicating that no         * match was found.         */        for (; index < operand[0]->package.count; index++) {            /* Get the current package element */            this_element = operand[0]->package.elements[index];            /* Treat any uninitialized (NULL) elements as non-matching */            if (!this_element) {                continue;            }            /*             * Both match conditions must be satisfied. Execution of a continue             * (proceed to next iteration of enclosing for loop) signifies a             * non-match.             */            if (!acpi_ex_do_match((u32) operand[1]->integer.value,                                  this_element, operand[2])) {                continue;            }            if (!acpi_ex_do_match((u32) operand[3]->integer.value,                                  this_element, operand[4])) {                continue;            }            /* Match found: Index is the return value */            return_desc->integer.value = index;            break;        }        break;    case AML_LOAD_TABLE_OP:        status = acpi_ex_load_table_op(walk_state, &return_desc);        break;//.........这里部分代码省略.........

ACPI_STATUSAcpiUtStrtoul64 (    char                    *String,    UINT64                  *ReturnValue){    ACPI_STATUS             Status = AE_OK;    UINT8                   OriginalBitWidth;    UINT32                  Base = 10;          /* Default is decimal */    ACPI_FUNCTION_TRACE_STR (UtStrtoul64, String);    *ReturnValue = 0;    /* A NULL return string returns a value of zero */    if (*String == 0)    {        return_ACPI_STATUS (AE_OK);    }    if (!AcpiUtRemoveWhitespace (&String))    {        return_ACPI_STATUS (AE_OK);    }    /*     * 1) Check for a hex constant. A "0x" prefix indicates base 16.     */    if (AcpiUtDetectHexPrefix (&String))    {        Base = 16;    }    /*     * 2) Check for an octal constant, defined to be a leading zero     * followed by sequence of octal digits (0-7)     */    else if (AcpiUtDetectOctalPrefix (&String))    {        Base = 8;    }    if (!AcpiUtRemoveLeadingZeros (&String))    {        return_ACPI_STATUS (AE_OK);     /* Return value 0 */    }    /*     * Force a full 64-bit conversion. The caller (usually iASL) must     * check for a 32-bit overflow later as necessary (If current mode     * is 32-bit, meaning a 32-bit DSDT).     */    OriginalBitWidth = AcpiGbl_IntegerBitWidth;    AcpiGbl_IntegerBitWidth = 64;    /*     * Perform the base 8, 10, or 16 conversion. A 64-bit numeric overflow     * will return an exception (to allow iASL to flag the statement).     */    switch (Base)    {    case 8:        Status = AcpiUtConvertOctalString (String, ReturnValue);        break;    case 10:        Status = AcpiUtConvertDecimalString (String, ReturnValue);        break;    case 16:    default:        Status = AcpiUtConvertHexString (String, ReturnValue);        break;    }    /* Only possible exception from above is a 64-bit overflow */    AcpiGbl_IntegerBitWidth = OriginalBitWidth;    return_ACPI_STATUS (Status);}

ACPI_STATUSAcpiExOpcode_2A_0T_0R (    ACPI_WALK_STATE         *WalkState){    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];    ACPI_NAMESPACE_NODE     *Node;    UINT32                  Value;    ACPI_STATUS             Status = AE_OK;    ACPI_FUNCTION_TRACE_STR (ExOpcode_2A_0T_0R,            AcpiPsGetOpcodeName (WalkState->Opcode));    /* Examine the opcode */    switch (WalkState->Opcode)    {    case AML_NOTIFY_OP:         /* Notify (NotifyObject, NotifyValue) */        /* The first operand is a namespace node */        Node = (ACPI_NAMESPACE_NODE *) Operand[0];        /* Second value is the notify value */        Value = (UINT32) Operand[1]->Integer.Value;        /* Are notifies allowed on this object? */        if (!AcpiEvIsNotifyObject (Node))        {            ACPI_ERROR ((AE_INFO,                "Unexpected notify object type [%s]",                AcpiUtGetTypeName (Node->Type)));            Status = AE_AML_OPERAND_TYPE;            break;        }#ifdef ACPI_GPE_NOTIFY_CHECK        /*         * GPE method wake/notify check.  Here, we want to ensure that we         * don't receive any "DeviceWake" Notifies from a GPE _Lxx or _Exx         * GPE method during system runtime.  If we do, the GPE is marked         * as "wake-only" and disabled.         *         * 1) Is the Notify() value == DeviceWake?         * 2) Is this a GPE deferred method?  (An _Lxx or _Exx method)         * 3) Did the original GPE happen at system runtime?         *    (versus during wake)         *         * If all three cases are true, this is a wake-only GPE that should         * be disabled at runtime.         */        if (Value == 2)     /* DeviceWake */        {            Status = AcpiEvCheckForWakeOnlyGpe (WalkState->GpeEventInfo);            if (ACPI_FAILURE (Status))            {                /* AE_WAKE_ONLY_GPE only error, means ignore this notify */                return_ACPI_STATUS (AE_OK)            }        }#endif        /*         * Dispatch the notify to the appropriate handler         * NOTE: the request is queued for execution after this method         * completes.  The notify handlers are NOT invoked synchronously         * from this thread -- because handlers may in turn run other         * control methods.         */        Status = AcpiEvQueueNotifyRequest (Node, Value);        break;    default:        ACPI_ERROR ((AE_INFO, "Unknown AML opcode %X",            WalkState->Opcode));        Status = AE_AML_BAD_OPCODE;    }

ACPI_STATUSAcpiExOpcode_2A_1T_1R (    ACPI_WALK_STATE         *WalkState){    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];    ACPI_OPERAND_OBJECT     *ReturnDesc = NULL;    UINT64                  Index;    ACPI_STATUS             Status = AE_OK;    ACPI_SIZE               Length = 0;    ACPI_FUNCTION_TRACE_STR (ExOpcode_2A_1T_1R,        AcpiPsGetOpcodeName (WalkState->Opcode));    /* Execute the opcode */    if (WalkState->OpInfo->Flags & AML_MATH)    {        /* All simple math opcodes (add, etc.) */        ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);        if (!ReturnDesc)        {            Status = AE_NO_MEMORY;            goto Cleanup;        }        ReturnDesc->Integer.Value = AcpiExDoMathOp (WalkState->Opcode,                                                Operand[0]->Integer.Value,                                                Operand[1]->Integer.Value);        goto StoreResultToTarget;    }    switch (WalkState->Opcode)    {    case AML_MOD_OP: /* Mod (Dividend, Divisor, RemainderResult (ACPI 2.0) */        ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);        if (!ReturnDesc)        {            Status = AE_NO_MEMORY;            goto Cleanup;        }        /* ReturnDesc will contain the remainder */        Status = AcpiUtDivide (Operand[0]->Integer.Value,                               Operand[1]->Integer.Value,                               NULL,                               &ReturnDesc->Integer.Value);        break;    case AML_CONCAT_OP: /* Concatenate (Data1, Data2, Result) */        Status = AcpiExDoConcatenate (Operand[0], Operand[1],                    &ReturnDesc, WalkState);        break;    case AML_TO_STRING_OP: /* ToString (Buffer, Length, Result) (ACPI 2.0) */        /*         * Input object is guaranteed to be a buffer at this point (it may have         * been converted.)  Copy the raw buffer data to a new object of         * type String.         */        /*         * Get the length of the new string. It is the smallest of:         * 1) Length of the input buffer         * 2) Max length as specified in the ToString operator         * 3) Length of input buffer up to a zero byte (null terminator)         *         * NOTE: A length of zero is ok, and will create a zero-length, null         *       terminated string.         */        while ((Length < Operand[0]->Buffer.Length) &&               (Length < Operand[1]->Integer.Value) &&               (Operand[0]->Buffer.Pointer[Length]))        {            Length++;        }        /* Allocate a new string object */        ReturnDesc = AcpiUtCreateStringObject (Length);        if (!ReturnDesc)        {            Status = AE_NO_MEMORY;            goto Cleanup;        }        /*         * Copy the raw buffer data with no transform.         * (NULL terminated already)         */        ACPI_MEMCPY (ReturnDesc->String.Pointer,            Operand[0]->Buffer.Pointer, Length);        break;    case AML_CONCAT_RES_OP://.........这里部分代码省略.........

ACPI_STATUSAcpiExOpcode_3A_0T_0R (    ACPI_WALK_STATE         *WalkState){    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];    ACPI_SIGNAL_FATAL_INFO  *Fatal;    ACPI_STATUS             Status = AE_OK;    ACPI_FUNCTION_TRACE_STR (ExOpcode_3A_0T_0R,        AcpiPsGetOpcodeName (WalkState->Opcode));    switch (WalkState->Opcode)    {    case AML_FATAL_OP:          /* Fatal (FatalType  FatalCode  FatalArg) */        ACPI_DEBUG_PRINT ((ACPI_DB_INFO,            "FatalOp: Type %X Code %X Arg %X "            "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<</n",            (UINT32) Operand[0]->Integer.Value,            (UINT32) Operand[1]->Integer.Value,            (UINT32) Operand[2]->Integer.Value));        Fatal = ACPI_ALLOCATE (sizeof (ACPI_SIGNAL_FATAL_INFO));        if (Fatal)        {            Fatal->Type = (UINT32) Operand[0]->Integer.Value;            Fatal->Code = (UINT32) Operand[1]->Integer.Value;            Fatal->Argument = (UINT32) Operand[2]->Integer.Value;        }        /* Always signal the OS! */        Status = AcpiOsSignal (ACPI_SIGNAL_FATAL, Fatal);        /* Might return while OS is shutting down, just continue */        ACPI_FREE (Fatal);        goto Cleanup;    case AML_EXTERNAL_OP:        /*         * If the interpreter sees this opcode, just ignore it. The External         * op is intended for use by disassemblers in order to properly         * disassemble control method invocations. The opcode or group of         * opcodes should be surrounded by an "if (0)" clause to ensure that         * AML interpreters never see the opcode. Thus, something is         * wrong if an external opcode ever gets here.         */        ACPI_ERROR ((AE_INFO, "Executed External Op"));        Status = AE_OK;        goto Cleanup;    default:        ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",            WalkState->Opcode));        Status = AE_AML_BAD_OPCODE;        goto Cleanup;    }Cleanup:    return_ACPI_STATUS (Status);}

ACPI_STATUSAcpiExOpcode_2A_0T_1R (    ACPI_WALK_STATE         *WalkState){    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];    ACPI_OPERAND_OBJECT     *ReturnDesc = NULL;    ACPI_STATUS             Status = AE_OK;    BOOLEAN                 LogicalResult = FALSE;    ACPI_FUNCTION_TRACE_STR (ExOpcode_2A_0T_1R,        AcpiPsGetOpcodeName (WalkState->Opcode));    /* Create the internal return object */    ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);    if (!ReturnDesc)    {        Status = AE_NO_MEMORY;        goto Cleanup;    }    /* Execute the Opcode */    if (WalkState->OpInfo->Flags & AML_LOGICAL_NUMERIC)    {        /* LogicalOp  (Operand0, Operand1) */        Status = AcpiExDoLogicalNumericOp (WalkState->Opcode,                        Operand[0]->Integer.Value, Operand[1]->Integer.Value,                        &LogicalResult);        goto StoreLogicalResult;    }    else if (WalkState->OpInfo->Flags & AML_LOGICAL)    {        /* LogicalOp  (Operand0, Operand1) */        Status = AcpiExDoLogicalOp (WalkState->Opcode, Operand[0],                    Operand[1], &LogicalResult);        goto StoreLogicalResult;    }    switch (WalkState->Opcode)    {    case AML_ACQUIRE_OP:            /* Acquire (MutexObject, Timeout) */        Status = AcpiExAcquireMutex (Operand[1], Operand[0], WalkState);        if (Status == AE_TIME)        {            LogicalResult = TRUE;       /* TRUE = Acquire timed out */            Status = AE_OK;        }        break;    case AML_WAIT_OP:               /* Wait (EventObject, Timeout) */        Status = AcpiExSystemWaitEvent (Operand[1], Operand[0]);        if (Status == AE_TIME)        {            LogicalResult = TRUE;       /* TRUE, Wait timed out */            Status = AE_OK;        }        break;    default:        ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",            WalkState->Opcode));        Status = AE_AML_BAD_OPCODE;        goto Cleanup;    }StoreLogicalResult:    /*     * Set return value to according to LogicalResult. logical TRUE (all ones)     * Default is FALSE (zero)     */    if (LogicalResult)    {        ReturnDesc->Integer.Value = ACPI_UINT64_MAX;    }Cleanup:    /* Delete return object on error */    if (ACPI_FAILURE (Status))    {        AcpiUtRemoveReference (ReturnDesc);    }    /* Save return object on success */    else    {        WalkState->ResultObj = ReturnDesc;    }//.........这里部分代码省略.........

acpi_statusacpi_ut_strtoul64(char *string,		  u32 base, u32 max_integer_byte_width, u64 *ret_integer){	u32 this_digit = 0;	u64 return_value = 0;	u64 quotient;	u64 dividend;	u8 valid_digits = 0;	u8 sign_of0x = 0;	u8 term = 0;	ACPI_FUNCTION_TRACE_STR(ut_strtoul64, string);	switch (base) {	case ACPI_ANY_BASE:	case 10:	case 16:		break;	default:		/* Invalid Base */		return_ACPI_STATUS(AE_BAD_PARAMETER);	}	if (!string) {		goto error_exit;	}	/* Skip over any white space in the buffer */	while ((*string) && (isspace((int)*string) || *string == '/t')) {		string++;	}	if (base == ACPI_ANY_BASE) {		/*		 * Base equal to ACPI_ANY_BASE means 'Either decimal or hex'.		 * We need to determine if it is decimal or hexadecimal.		 */		if ((*string == '0') && (tolower((int)*(string + 1)) == 'x')) {			sign_of0x = 1;			base = 16;			/* Skip over the leading '0x' */			string += 2;		} else {			base = 10;		}	}	/* Any string left? Check that '0x' is not followed by white space. */	if (!(*string) || isspace((int)*string) || *string == '/t') {		if (base == ACPI_ANY_BASE) {			goto error_exit;		} else {			goto all_done;		}	}	/*	 * Perform a 32-bit or 64-bit conversion, depending upon the input	 * byte width	 */	dividend = (max_integer_byte_width <= ACPI_MAX32_BYTE_WIDTH) ?	    ACPI_UINT32_MAX : ACPI_UINT64_MAX;	/* Main loop: convert the string to a 32- or 64-bit integer */	while (*string) {		if (isdigit((int)*string)) {			/* Convert ASCII 0-9 to Decimal value */			this_digit = ((u8)*string) - '0';		} else if (base == 10) {			/* Digit is out of range; possible in to_integer case only */			term = 1;		} else {			this_digit = (u8)toupper((int)*string);			if (isxdigit((int)this_digit)) {				/* Convert ASCII Hex char to value */				this_digit = this_digit - 'A' + 10;			} else {				term = 1;			}		}		if (term) {			if (base == ACPI_ANY_BASE) {				goto error_exit;			} else {//.........这里部分代码省略.........

ACPI_STATUSAcpiExOpcode_6A_0T_1R (    ACPI_WALK_STATE         *WalkState){    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];    ACPI_OPERAND_OBJECT     *ReturnDesc = NULL;    ACPI_STATUS             Status = AE_OK;    ACPI_INTEGER            Index;    ACPI_OPERAND_OBJECT     *ThisElement;    ACPI_FUNCTION_TRACE_STR (ExOpcode_6A_0T_1R,        AcpiPsGetOpcodeName (WalkState->Opcode));    switch (WalkState->Opcode)    {    case AML_MATCH_OP:        /*         * Match (SearchPkg[0], MatchOp1[1], MatchObj1[2],         *                      MatchOp2[3], MatchObj2[4], StartIndex[5])         */        /* Validate both Match Term Operators (MTR, MEQ, etc.) */        if ((Operand[1]->Integer.Value > MAX_MATCH_OPERATOR) ||            (Operand[3]->Integer.Value > MAX_MATCH_OPERATOR))        {            ACPI_ERROR ((AE_INFO, "Match operator out of range"));            Status = AE_AML_OPERAND_VALUE;            goto Cleanup;        }        /* Get the package StartIndex, validate against the package length */        Index = Operand[5]->Integer.Value;        if (Index >= Operand[0]->Package.Count)        {            ACPI_ERROR ((AE_INFO,                "Index (%X%8.8X) beyond package end (%X)",                ACPI_FORMAT_UINT64 (Index), Operand[0]->Package.Count));            Status = AE_AML_PACKAGE_LIMIT;            goto Cleanup;        }        /* Create an integer for the return value */        ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);        if (!ReturnDesc)        {            Status = AE_NO_MEMORY;            goto Cleanup;        }        /* Default return value if no match found */        ReturnDesc->Integer.Value = ACPI_INTEGER_MAX;        /*         * Examine each element until a match is found. Both match conditions         * must be satisfied for a match to occur. Within the loop,         * "continue" signifies that the current element does not match         * and the next should be examined.         *         * Upon finding a match, the loop will terminate via "break" at         * the bottom.  If it terminates "normally", MatchValue will be         * ACPI_INTEGER_MAX (Ones) (its initial value) indicating that no         * match was found.         */        for ( ; Index < Operand[0]->Package.Count; Index++)        {            /* Get the current package element */            ThisElement = Operand[0]->Package.Elements[Index];            /* Treat any uninitialized (NULL) elements as non-matching */            if (!ThisElement)            {                continue;            }            /*             * Both match conditions must be satisfied. Execution of a continue             * (proceed to next iteration of enclosing for loop) signifies a             * non-match.             */            if (!AcpiExDoMatch ((UINT32) Operand[1]->Integer.Value,                                ThisElement, Operand[2]))            {                continue;            }            if (!AcpiExDoMatch ((UINT32) Operand[3]->Integer.Value,                                ThisElement, Operand[4]))            {                continue;            }//.........这里部分代码省略.........

ACPI_STATUSAcpiExOpcode_1A_1T_1R (    ACPI_WALK_STATE         *WalkState){    ACPI_STATUS             Status = AE_OK;    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];    ACPI_OPERAND_OBJECT     *ReturnDesc = NULL;    ACPI_OPERAND_OBJECT     *ReturnDesc2 = NULL;    UINT32                  Temp32;    UINT32                  i;    ACPI_INTEGER            PowerOfTen;    ACPI_INTEGER            Digit;    ACPI_FUNCTION_TRACE_STR (ExOpcode_1A_1T_1R,        AcpiPsGetOpcodeName (WalkState->Opcode));    /* Examine the AML opcode */    switch (WalkState->Opcode)    {    case AML_BIT_NOT_OP:    case AML_FIND_SET_LEFT_BIT_OP:    case AML_FIND_SET_RIGHT_BIT_OP:    case AML_FROM_BCD_OP:    case AML_TO_BCD_OP:    case AML_COND_REF_OF_OP:        /* Create a return object of type Integer for these opcodes */        ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);        if (!ReturnDesc)        {            Status = AE_NO_MEMORY;            goto Cleanup;        }        switch (WalkState->Opcode)        {        case AML_BIT_NOT_OP:            /* Not (Operand, Result)  */            ReturnDesc->Integer.Value = ~Operand[0]->Integer.Value;            break;        case AML_FIND_SET_LEFT_BIT_OP:  /* FindSetLeftBit (Operand, Result) */            ReturnDesc->Integer.Value = Operand[0]->Integer.Value;            /*             * Acpi specification describes Integer type as a little             * endian unsigned value, so this boundary condition is valid.             */            for (Temp32 = 0; ReturnDesc->Integer.Value &&                             Temp32 < ACPI_INTEGER_BIT_SIZE; ++Temp32)            {                ReturnDesc->Integer.Value >>= 1;            }            ReturnDesc->Integer.Value = Temp32;            break;        case AML_FIND_SET_RIGHT_BIT_OP: /* FindSetRightBit (Operand, Result) */            ReturnDesc->Integer.Value = Operand[0]->Integer.Value;            /*             * The Acpi specification describes Integer type as a little             * endian unsigned value, so this boundary condition is valid.             */            for (Temp32 = 0; ReturnDesc->Integer.Value &&                             Temp32 < ACPI_INTEGER_BIT_SIZE; ++Temp32)            {                ReturnDesc->Integer.Value <<= 1;            }            /* Since the bit position is one-based, subtract from 33 (65) */            ReturnDesc->Integer.Value =                Temp32 == 0 ? 0 : (ACPI_INTEGER_BIT_SIZE + 1) - Temp32;            break;        case AML_FROM_BCD_OP:           /* FromBcd (BCDValue, Result)  */            /*             * The 64-bit ACPI integer can hold 16 4-bit BCD characters             * (if table is 32-bit, integer can hold 8 BCD characters)             * Convert each 4-bit BCD value             */            PowerOfTen = 1;            ReturnDesc->Integer.Value = 0;            Digit = Operand[0]->Integer.Value;            /* Convert each BCD digit (each is one nybble wide) */            for (i = 0; (i < AcpiGbl_IntegerNybbleWidth) && (Digit > 0); i++)            {//.........这里部分代码省略.........

ACPI_OPERAND_OBJECT  *AcpiUtCreateInternalObjectDbg (    const char              *ModuleName,    UINT32                  LineNumber,    UINT32                  ComponentId,    ACPI_OBJECT_TYPE        Type){    ACPI_OPERAND_OBJECT     *Object;    ACPI_OPERAND_OBJECT     *SecondObject;    ACPI_FUNCTION_TRACE_STR (UtCreateInternalObjectDbg,        AcpiUtGetTypeName (Type));    /* Allocate the raw object descriptor */    Object = AcpiUtAllocateObjectDescDbg (        ModuleName, LineNumber, ComponentId);    if (!Object)    {        return_PTR (NULL);    }    switch (Type)    {    case ACPI_TYPE_REGION:    case ACPI_TYPE_BUFFER_FIELD:    case ACPI_TYPE_LOCAL_BANK_FIELD:        /* These types require a secondary object */        SecondObject = AcpiUtAllocateObjectDescDbg (            ModuleName, LineNumber, ComponentId);        if (!SecondObject)        {            AcpiUtDeleteObjectDesc (Object);            return_PTR (NULL);        }        SecondObject->Common.Type = ACPI_TYPE_LOCAL_EXTRA;        SecondObject->Common.ReferenceCount = 1;        /* Link the second object to the first */        Object->Common.NextObject = SecondObject;        break;    default:        /* All others have no secondary object */        break;    }    /* Save the object type in the object descriptor */    Object->Common.Type = (UINT8) Type;    /* Init the reference count */    Object->Common.ReferenceCount = 1;    /* Any per-type initialization should go here */    return_PTR (Object);}

/******************************************************************************* * * FUNCTION:    acpi_ex_opcode_2A_0T_0R * * PARAMETERS:  walk_state          - Current walk state * * RETURN:      Status * * DESCRIPTION: Execute opcode with two arguments, no target, and no return *              value. * * ALLOCATION:  Deletes both operands * ******************************************************************************/acpi_status acpi_ex_opcode_2A_0T_0R(struct acpi_walk_state *walk_state){    union acpi_operand_object **operand = &walk_state->operands[0];    struct acpi_namespace_node *node;    u32 value;    acpi_status status = AE_OK;    ACPI_FUNCTION_TRACE_STR(ex_opcode_2A_0T_0R,                            acpi_ps_get_opcode_name(walk_state->opcode));    /* Examine the opcode */    switch (walk_state->opcode) {    case AML_NOTIFY_OP:	/* Notify (notify_object, notify_value) */        /* The first operand is a namespace node */        node = (struct acpi_namespace_node *)operand[0];        /* Second value is the notify value */        value = (u32) operand[1]->integer.value;        /* Are notifies allowed on this object? */        if (!acpi_ev_is_notify_object(node)) {            ACPI_ERROR((AE_INFO,                        "Unexpected notify object type [%s]",                        acpi_ut_get_type_name(node->type)));            status = AE_AML_OPERAND_TYPE;            break;        }#ifdef ACPI_GPE_NOTIFY_CHECK        /*         * GPE method wake/notify check.  Here, we want to ensure that we         * don't receive any "DeviceWake" Notifies from a GPE _Lxx or _Exx         * GPE method during system runtime.  If we do, the GPE is marked         * as "wake-only" and disabled.         *         * 1) Is the Notify() value == device_wake?         * 2) Is this a GPE deferred method?  (An _Lxx or _Exx method)         * 3) Did the original GPE happen at system runtime?         *    (versus during wake)         *         * If all three cases are true, this is a wake-only GPE that should         * be disabled at runtime.         */        if (value == 2) {	/* device_wake */            status =                acpi_ev_check_for_wake_only_gpe(walk_state->                                                gpe_event_info);            if (ACPI_FAILURE(status)) {                /* AE_WAKE_ONLY_GPE only error, means ignore this notify */                return_ACPI_STATUS(AE_OK)            }        }#endif        /*         * Dispatch the notify to the appropriate handler         * NOTE: the request is queued for execution after this method         * completes.  The notify handlers are NOT invoked synchronously         * from this thread -- because handlers may in turn run other         * control methods.         */        status = acpi_ev_queue_notify_request(node, value);        break;    default:        ACPI_ERROR((AE_INFO, "Unknown AML opcode %X",                    walk_state->opcode));        status = AE_AML_BAD_OPCODE;    }

acpi_status acpi_ut_strtoul64(char *string, u32 flags, u64 *return_value){	acpi_status status = AE_OK;	u32 base;	ACPI_FUNCTION_TRACE_STR(ut_strtoul64, string);	/* Parameter validation */	if (!string || !return_value) {		return_ACPI_STATUS(AE_BAD_PARAMETER);	}	*return_value = 0;	/* Check for zero-length string, returns 0 */	if (*string == 0) {		return_ACPI_STATUS(AE_OK);	}	/* Skip over any white space at start of string */	while (isspace((int)*string)) {		string++;	}	/* End of string? return 0 */	if (*string == 0) {		return_ACPI_STATUS(AE_OK);	}	/*	 * 1) The "0x" prefix indicates base 16. Per the ACPI specification,	 * the "0x" prefix is only allowed for implicit (non-strict) conversions.	 * However, we always allow it for compatibility with older ACPICA.	 */	if ((*string == ACPI_ASCII_ZERO) &&	    (tolower((int)*(string + 1)) == 'x')) {		string += 2;	/* Go past the 0x */		if (*string == 0) {			return_ACPI_STATUS(AE_OK);	/* Return value 0 */		}		base = 16;	}	/* 2) Force to base 16 (implicit conversion case) */	else if (flags & ACPI_STRTOUL_BASE16) {		base = 16;	}	/* 3) Default fallback is to Base 10 */	else {		base = 10;	}	/* Skip all leading zeros */	while (*string == ACPI_ASCII_ZERO) {		string++;		if (*string == 0) {			return_ACPI_STATUS(AE_OK);	/* Return value 0 */		}	}	/* Perform the base 16 or 10 conversion */	if (base == 16) {		*return_value = acpi_ut_strtoul_base16(string, flags);	} else {		*return_value = acpi_ut_strtoul_base10(string, flags);	}	return_ACPI_STATUS(status);}

acpi_status acpi_ex_opcode_3A_1T_1R(struct acpi_walk_state *walk_state){    union acpi_operand_object **operand = &walk_state->operands[0];    union acpi_operand_object *return_desc = NULL;    char *buffer = NULL;    acpi_status status = AE_OK;    acpi_integer index;    acpi_size length;    ACPI_FUNCTION_TRACE_STR(ex_opcode_3A_1T_1R,                            acpi_ps_get_opcode_name(walk_state->opcode));    switch (walk_state->opcode) {    case AML_MID_OP:    /* Mid (Source[0], Index[1], Length[2], Result[3]) */        /*         * Create the return object.  The Source operand is guaranteed to be         * either a String or a Buffer, so just use its type.         */        return_desc =            acpi_ut_create_internal_object(ACPI_GET_OBJECT_TYPE                                           (operand[0]));        if (!return_desc) {            status = AE_NO_MEMORY;            goto cleanup;        }        /* Get the Integer values from the objects */        index = operand[1]->integer.value;        length = (acpi_size) operand[2]->integer.value;        /*         * If the index is beyond the length of the String/Buffer, or if the         * requested length is zero, return a zero-length String/Buffer         */        if (index >= operand[0]->string.length) {            length = 0;        }        /* Truncate request if larger than the actual String/Buffer */        else if ((index + length) > operand[0]->string.length) {            length = (acpi_size) operand[0]->string.length -                     (acpi_size) index;        }        /* Strings always have a sub-pointer, not so for buffers */        switch (ACPI_GET_OBJECT_TYPE(operand[0])) {        case ACPI_TYPE_STRING:            /* Always allocate a new buffer for the String */            buffer = ACPI_ALLOCATE_ZEROED((acpi_size) length + 1);            if (!buffer) {                status = AE_NO_MEMORY;                goto cleanup;            }            break;        case ACPI_TYPE_BUFFER:            /* If the requested length is zero, don't allocate a buffer */            if (length > 0) {                /* Allocate a new buffer for the Buffer */                buffer = ACPI_ALLOCATE_ZEROED(length);                if (!buffer) {                    status = AE_NO_MEMORY;                    goto cleanup;                }            }            break;        default:    /* Should not happen */            status = AE_AML_OPERAND_TYPE;            goto cleanup;        }        if (buffer) {            /* We have a buffer, copy the portion requested */            ACPI_MEMCPY(buffer, operand[0]->string.pointer + index,                        length);        }        /* Set the length of the new String/Buffer */        return_desc->string.pointer = buffer;        return_desc->string.length = (u32) length;        /* Mark buffer initialized */        return_desc->buffer.flags |= AOPOBJ_DATA_VALID;        break;//.........这里部分代码省略.........