ACPICA: Minimize the differences between linux GPE code and ACPICA code base (0f849d2c) · Commits · 戴 / test

drivers/acpi/acpica/acevents.h

+4 −3

Original line number	Diff line number	Diff line
		@@ -85,6 +85,10 @@ acpi_status acpi_ev_disable_gpe(struct acpi_gpe_event_info *gpe_event_info);
		struct acpi_gpe_event_info *acpi_ev_get_gpe_event_info(acpi_handle gpe_device,
		u32 gpe_number);

		struct acpi_gpe_event_info *acpi_ev_low_get_gpe_info(u32 gpe_number,
		struct acpi_gpe_block_info
		*gpe_block);

		/*
		* evgpeblk
		*/
		@@ -118,9 +122,6 @@ acpi_ev_gpe_dispatch(struct acpi_gpe_event_info *gpe_event_info,

		u32 acpi_ev_gpe_detect(struct acpi_gpe_xrupt_info *gpe_xrupt_list);

		acpi_status
		acpi_ev_check_for_wake_only_gpe(struct acpi_gpe_event_info *gpe_event_info);

		acpi_status acpi_ev_gpe_initialize(void);

		/*

drivers/acpi/acpica/aclocal.h

+3 −2

Original line number	Diff line number	Diff line
		@@ -427,8 +427,8 @@ struct acpi_gpe_event_info {
		struct acpi_gpe_register_info register_info; / Backpointer to register info */
		u8 flags; /* Misc info about this GPE */
		u8 gpe_number; /* This GPE */
		u8 runtime_count;
		u8 wakeup_count;
		u8 runtime_count; /* References to a run GPE */
		u8 wakeup_count; /* References to a wake GPE */
		};

		/* Information about a GPE register pair, one per each status/enable pair in an array */
		@@ -454,6 +454,7 @@ struct acpi_gpe_block_info {
		struct acpi_gpe_event_info event_info; / One for each GPE */
		struct acpi_generic_address block_address; /* Base address of the block */
		u32 register_count; /* Number of register pairs in block */
		u16 gpe_count; /* Number of individual GPEs in block */
		u8 block_base_number; /* Base GPE number for this block */
		};

drivers/acpi/acpica/evgpe.c

+109 −44

Original line number	Diff line number	Diff line
		@@ -60,7 +60,8 @@ static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context);
		*
		* RETURN: Status
		*
		* DESCRIPTION: Updates GPE register enable masks based on the GPE type
		* DESCRIPTION: Updates GPE register enable masks based upon whether there are
		* references (either wake or run) to this GPE
		*
		******************************************************************************/

		@@ -81,14 +82,20 @@ acpi_ev_update_gpe_enable_masks(struct acpi_gpe_event_info *gpe_event_info)
		(1 <<
		(gpe_event_info->gpe_number - gpe_register_info->base_gpe_number));

		/* Clear the wake/run bits up front */

		ACPI_CLEAR_BIT(gpe_register_info->enable_for_wake, register_bit);
		ACPI_CLEAR_BIT(gpe_register_info->enable_for_run, register_bit);

		if (gpe_event_info->runtime_count)
		/* Set the mask bits only if there are references to this GPE */

		if (gpe_event_info->runtime_count) {
		ACPI_SET_BIT(gpe_register_info->enable_for_run, register_bit);
		}

		if (gpe_event_info->wakeup_count)
		if (gpe_event_info->wakeup_count) {
		ACPI_SET_BIT(gpe_register_info->enable_for_wake, register_bit);
		}

		return_ACPI_STATUS(AE_OK);
		}
		@@ -101,7 +108,10 @@ acpi_ev_update_gpe_enable_masks(struct acpi_gpe_event_info *gpe_event_info)
		*
		* RETURN: Status
		*
		* DESCRIPTION: Enable a GPE based on the GPE type
		* DESCRIPTION: Hardware-enable a GPE. Always enables the GPE, regardless
		* of type or number of references.
		*
		* Note: The GPE lock should be already acquired when this function is called.
		*
		******************************************************************************/

		@@ -109,20 +119,36 @@ acpi_status acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info)
		{
		acpi_status status;


		ACPI_FUNCTION_TRACE(ev_enable_gpe);

		/* Make sure HW enable masks are updated */

		/*
		* We will only allow a GPE to be enabled if it has either an
		* associated method (_Lxx/_Exx) or a handler. Otherwise, the
		* GPE will be immediately disabled by acpi_ev_gpe_dispatch the
		* first time it fires.
		*/
		if (!(gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK)) {
		return_ACPI_STATUS(AE_NO_HANDLER);
		}

		/* Ensure the HW enable masks are current */

		status = acpi_ev_update_gpe_enable_masks(gpe_event_info);
		if (ACPI_FAILURE(status))
		if (ACPI_FAILURE(status)) {
		return_ACPI_STATUS(status);
		}

		/* Clear the GPE (of stale events) */

		/* Clear the GPE (of stale events), then enable it */
		status = acpi_hw_clear_gpe(gpe_event_info);
		if (ACPI_FAILURE(status))
		if (ACPI_FAILURE(status)) {
		return_ACPI_STATUS(status);
		}

		/* Enable the requested GPE */

		status = acpi_hw_write_gpe_enable_reg(gpe_event_info);
		return_ACPI_STATUS(status);
		}
		@@ -135,7 +161,10 @@ acpi_status acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info)
		*
		* RETURN: Status
		*
		* DESCRIPTION: Disable a GPE based on the GPE type
		* DESCRIPTION: Hardware-disable a GPE. Always disables the requested GPE,
		* regardless of the type or number of references.
		*
		* Note: The GPE lock should be already acquired when this function is called.
		*
		******************************************************************************/

		@@ -145,24 +174,71 @@ acpi_status acpi_ev_disable_gpe(struct acpi_gpe_event_info *gpe_event_info)

		ACPI_FUNCTION_TRACE(ev_disable_gpe);

		/* Make sure HW enable masks are updated */

		/*
		* Note: Always disable the GPE, even if we think that that it is already
		* disabled. It is possible that the AML or some other code has enabled
		* the GPE behind our back.
		*/

		/* Ensure the HW enable masks are current */

		status = acpi_ev_update_gpe_enable_masks(gpe_event_info);
		if (ACPI_FAILURE(status))
		if (ACPI_FAILURE(status)) {
		return_ACPI_STATUS(status);
		}

		/*
		* Even if we don't know the GPE type, make sure that we always
		* disable it. low_disable_gpe will just clear the enable bit for this
		* GPE and write it. It will not write out the current GPE enable mask,
		* since this may inadvertently enable GPEs too early, if a rogue GPE has
		* come in during ACPICA initialization - possibly as a result of AML or
		* other code that has enabled the GPE.
		* Always H/W disable this GPE, even if we don't know the GPE type.
		* Simply clear the enable bit for this particular GPE, but do not
		* write out the current GPE enable mask since this may inadvertently
		* enable GPEs too early. An example is a rogue GPE that has arrived
		* during ACPICA initialization - possibly because AML or other code
		* has enabled the GPE.
		*/
		status = acpi_hw_low_disable_gpe(gpe_event_info);
		return_ACPI_STATUS(status);
		}


		/*******************************************************************************
		*
		* FUNCTION: acpi_ev_low_get_gpe_info
		*
		* PARAMETERS: gpe_number - Raw GPE number
		* gpe_block - A GPE info block
		*
		* RETURN: A GPE event_info struct. NULL if not a valid GPE (The gpe_number
		* is not within the specified GPE block)
		*
		* DESCRIPTION: Returns the event_info struct associated with this GPE. This is
		* the low-level implementation of ev_get_gpe_event_info.
		*
		******************************************************************************/

		struct acpi_gpe_event_info *acpi_ev_low_get_gpe_info(u32 gpe_number,
		struct acpi_gpe_block_info
		*gpe_block)
		{
		u32 gpe_index;

		/*
		* Validate that the gpe_number is within the specified gpe_block.
		* (Two steps)
		*/
		if (!gpe_block \|\| (gpe_number < gpe_block->block_base_number)) {
		return (NULL);
		}

		gpe_index = gpe_number - gpe_block->block_base_number;
		if (gpe_index >= gpe_block->gpe_count) {
		return (NULL);
		}

		return (&gpe_block->event_info[gpe_index]);
		}


		/*******************************************************************************
		*
		* FUNCTION: acpi_ev_get_gpe_event_info
		@@ -184,7 +260,7 @@ struct acpi_gpe_event_info *acpi_ev_get_gpe_event_info(acpi_handle gpe_device,
		u32 gpe_number)
		{
		union acpi_operand_object *obj_desc;
		struct acpi_gpe_block_info *gpe_block;
		struct acpi_gpe_event_info *gpe_info;
		u32 i;

		ACPI_FUNCTION_ENTRY();
		@@ -196,17 +272,11 @@ struct acpi_gpe_event_info *acpi_ev_get_gpe_event_info(acpi_handle gpe_device,
		/* Examine GPE Block 0 and 1 (These blocks are permanent) */

		for (i = 0; i < ACPI_MAX_GPE_BLOCKS; i++) {
		gpe_block = acpi_gbl_gpe_fadt_blocks[i];
		if (gpe_block) {
		if ((gpe_number >= gpe_block->block_base_number)
		&& (gpe_number <
		gpe_block->block_base_number +
		(gpe_block->register_count * 8))) {
		return (&gpe_block->
		event_info[gpe_number -
		gpe_block->
		block_base_number]);
		}
		gpe_info = acpi_ev_low_get_gpe_info(gpe_number,
		acpi_gbl_gpe_fadt_blocks
		[i]);
		if (gpe_info) {
		return (gpe_info);
		}
		}

		@@ -223,16 +293,8 @@ struct acpi_gpe_event_info *acpi_ev_get_gpe_event_info(acpi_handle gpe_device,
		return (NULL);
		}

		gpe_block = obj_desc->device.gpe_block;

		if ((gpe_number >= gpe_block->block_base_number) &&
		(gpe_number <
		gpe_block->block_base_number + (gpe_block->register_count * 8))) {
		return (&gpe_block->
		event_info[gpe_number - gpe_block->block_base_number]);
		}

		return (NULL);
		return (acpi_ev_low_get_gpe_info
		(gpe_number, obj_desc->device.gpe_block));
		}

		/*******************************************************************************
		@@ -389,7 +451,7 @@ static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context)
		return_VOID;
		}

		/* Set the GPE flags for return to enabled state */
		/* Update the GPE register masks for return to enabled state */

		(void)acpi_ev_update_gpe_enable_masks(gpe_event_info);

		@@ -569,15 +631,18 @@ acpi_ev_gpe_dispatch(struct acpi_gpe_event_info *gpe_event_info, u32 gpe_number)

		default:

		/* No handler or method to run! */

		/*
		* No handler or method to run!
		* 03/2010: This case should no longer be possible. We will not allow
		* a GPE to be enabled if it has no handler or method.
		*/
		ACPI_ERROR((AE_INFO,
		"No handler or method for GPE[0x%2X], disabling event",
		gpe_number));

		/*
		* Disable the GPE. The GPE will remain disabled until the ACPICA
		* Core Subsystem is restarted, or a handler is installed.
		* Disable the GPE. The GPE will remain disabled a handler
		* is installed or ACPICA is restarted.
		*/
		status = acpi_ev_disable_gpe(gpe_event_info);
		if (ACPI_FAILURE(status)) {

drivers/acpi/acpica/evgpeblk.c

+76 −67

Original line number	Diff line number	Diff line
		@@ -51,7 +51,7 @@ ACPI_MODULE_NAME("evgpeblk")

		/* Local prototypes */
		static acpi_status
		acpi_ev_save_method_info(acpi_handle obj_handle,
		acpi_ev_match_gpe_method(acpi_handle obj_handle,
		u32 level, void obj_desc, void *return_value);

		static acpi_status
		@@ -104,9 +104,7 @@ u8 acpi_ev_valid_gpe_event(struct acpi_gpe_event_info *gpe_event_info)

		while (gpe_block) {
		if ((&gpe_block->event_info[0] <= gpe_event_info) &&
		(&gpe_block->event_info[((acpi_size)
		gpe_block->
		register_count) * 8] >
		(&gpe_block->event_info[gpe_block->gpe_count] >
		gpe_event_info)) {
		return (TRUE);
		}
		@@ -229,7 +227,7 @@ acpi_ev_delete_gpe_handlers(struct acpi_gpe_xrupt_info *gpe_xrupt_info,

		/*******************************************************************************
		*
		* FUNCTION: acpi_ev_save_method_info
		* FUNCTION: acpi_ev_match_gpe_method
		*
		* PARAMETERS: Callback from walk_namespace
		*
		@@ -241,8 +239,7 @@ acpi_ev_delete_gpe_handlers(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
		* information for quick lookup during GPE dispatch
		*
		* The name of each GPE control method is of the form:
		* "_Lxx" or "_Exx"
		* Where:
		* "_Lxx" or "_Exx", where:
		* L - means that the GPE is level triggered
		* E - means that the GPE is edge triggered
		* xx - is the GPE number [in HEX]
		@@ -250,9 +247,11 @@ acpi_ev_delete_gpe_handlers(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
		******************************************************************************/

		static acpi_status
		acpi_ev_save_method_info(acpi_handle obj_handle,
		acpi_ev_match_gpe_method(acpi_handle obj_handle,
		u32 level, void obj_desc, void *return_value)
		{
		struct acpi_namespace_node *method_node =
		ACPI_CAST_PTR(struct acpi_namespace_node, obj_handle);
		struct acpi_gpe_block_info gpe_block = (void )obj_desc;
		struct acpi_gpe_event_info *gpe_event_info;
		u32 gpe_number;
		@@ -262,21 +261,25 @@ acpi_ev_save_method_info(acpi_handle obj_handle,
		ACPI_FUNCTION_TRACE(ev_save_method_info);

		/*
		* _Lxx and _Exx GPE method support
		* Match and decode the _Lxx and _Exx GPE method names
		*
		* 1) Extract the name from the object and convert to a string
		* 1) Extract the method name and null terminate it
		*/
		ACPI_MOVE_32_TO_32(name,
		&((struct acpi_namespace_node *)obj_handle)->name.
		integer);
		ACPI_MOVE_32_TO_32(name, &method_node->name.integer);
		name[ACPI_NAME_SIZE] = 0;

		/* 2) Name must begin with an underscore */

		if (name[0] != '_') {
		return_ACPI_STATUS(AE_OK); /* Ignore this method */
		}

		/*
		* 2) Edge/Level determination is based on the 2nd character
		* 3) Edge/Level determination is based on the 2nd character
		* of the method name
		*
		* NOTE: Default GPE type is RUNTIME. May be changed later to WAKE
		* if a _PRW object is found that points to this GPE.
		* NOTE: Default GPE type is RUNTIME only. Later, if a _PRW object is
		* found that points to this GPE, the ACPI_GPE_CAN_WAKE flag is set.
		*/
		switch (name[1]) {
		case 'L':
		@@ -288,7 +291,7 @@ acpi_ev_save_method_info(acpi_handle obj_handle,
		break;

		default:
		/* Unknown method type, just ignore it! */
		/* Unknown method type, just ignore it */

		ACPI_DEBUG_PRINT((ACPI_DB_LOAD,
		"Ignoring unknown GPE method type: %s "
		@@ -296,7 +299,7 @@ acpi_ev_save_method_info(acpi_handle obj_handle,
		return_ACPI_STATUS(AE_OK);
		}

		/* Convert the last two characters of the name to the GPE Number */
		/* 4) The last two characters of the name are the hex GPE Number */

		gpe_number = ACPI_STRTOUL(&name[2], NULL, 16);
		if (gpe_number == ACPI_UINT32_MAX) {
		@@ -311,28 +314,22 @@ acpi_ev_save_method_info(acpi_handle obj_handle,

		/* Ensure that we have a valid GPE number for this GPE block */

		if ((gpe_number < gpe_block->block_base_number) \|\|
		(gpe_number >= (gpe_block->block_base_number +
		(gpe_block->register_count * 8)))) {
		gpe_event_info = acpi_ev_low_get_gpe_info(gpe_number, gpe_block);
		if (!gpe_event_info) {
		/*
		* Not valid for this GPE block, just ignore it. However, it may be
		* valid for a different GPE block, since GPE0 and GPE1 methods both
		* appear under \_GPE.
		* This gpe_number is not valid for this GPE block, just ignore it.
		* However, it may be valid for a different GPE block, since GPE0
		* and GPE1 methods both appear under \_GPE.
		*/
		return_ACPI_STATUS(AE_OK);
		}

		/*
		* Now we can add this information to the gpe_event_info block for use
		* during dispatch of this GPE.
		* Add the GPE information from above to the gpe_event_info block for
		* use during dispatch of this GPE.
		*/
		gpe_event_info =
		&gpe_block->event_info[gpe_number - gpe_block->block_base_number];

		gpe_event_info->flags = (u8)(type \| ACPI_GPE_DISPATCH_METHOD);

		gpe_event_info->dispatch.method_node =
		(struct acpi_namespace_node *)obj_handle;
		gpe_event_info->dispatch.method_node = method_node;

		ACPI_DEBUG_PRINT((ACPI_DB_LOAD,
		"Registered GPE method %s as GPE number 0x%.2X\n",
		@@ -351,7 +348,7 @@ acpi_ev_save_method_info(acpi_handle obj_handle,
		*
		* DESCRIPTION: Called from acpi_walk_namespace. Expects each object to be a
		* Device. Run the _PRW method. If present, extract the GPE
		* number and mark the GPE as a WAKE GPE.
		* number and mark the GPE as a CAN_WAKE GPE.
		*
		******************************************************************************/

		@@ -377,7 +374,7 @@ acpi_ev_match_prw_and_gpe(acpi_handle obj_handle,
		ACPI_BTYPE_PACKAGE, &pkg_desc);
		if (ACPI_FAILURE(status)) {

		/* Ignore all errors from _PRW, we don't want to abort the subsystem */
		/* Ignore all errors from _PRW, we don't want to abort the walk */

		return_ACPI_STATUS(AE_OK);
		}
		@@ -439,13 +436,13 @@ acpi_ev_match_prw_and_gpe(acpi_handle obj_handle,
		* 2) The GPE index(number) is within the range of the Gpe Block
		* associated with the GPE device.
		*/
		if ((gpe_device == target_gpe_device) &&
		(gpe_number >= gpe_block->block_base_number) &&
		(gpe_number < gpe_block->block_base_number +
		(gpe_block->register_count * 8))) {
		gpe_event_info = &gpe_block->event_info[gpe_number -
		gpe_block->
		block_base_number];
		if (gpe_device != target_gpe_device) {
		goto cleanup;
		}

		gpe_event_info = acpi_ev_low_get_gpe_info(gpe_number, gpe_block);
		if (gpe_event_info) {
		/* This GPE can wake the system */

		gpe_event_info->flags \|= ACPI_GPE_CAN_WAKE;
		}
		@@ -705,8 +702,7 @@ acpi_status acpi_ev_delete_gpe_block(struct acpi_gpe_block_info *gpe_block)
		acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
		}

		acpi_current_gpe_count -=
		gpe_block->register_count * ACPI_GPE_REGISTER_WIDTH;
		acpi_current_gpe_count -= gpe_block->gpe_count;

		/* Free the gpe_block */

		@@ -760,9 +756,7 @@ acpi_ev_create_gpe_info_blocks(struct acpi_gpe_block_info *gpe_block)
		* Allocate the GPE event_info block. There are eight distinct GPEs
		* per register. Initialization to zeros is sufficient.
		*/
		gpe_event_info = ACPI_ALLOCATE_ZEROED(((acpi_size) gpe_block->
		register_count *
		ACPI_GPE_REGISTER_WIDTH) *
		gpe_event_info = ACPI_ALLOCATE_ZEROED((acpi_size) gpe_block->gpe_count *
		sizeof(struct
		acpi_gpe_event_info));
		if (!gpe_event_info) {
		@@ -897,6 +891,7 @@ acpi_ev_create_gpe_block(struct acpi_namespace_node *gpe_device,
		/* Initialize the new GPE block */

		gpe_block->node = gpe_device;
		gpe_block->gpe_count = (u16)(register_count * ACPI_GPE_REGISTER_WIDTH);
		gpe_block->register_count = register_count;
		gpe_block->block_base_number = gpe_block_base_number;

		@@ -925,7 +920,7 @@ acpi_ev_create_gpe_block(struct acpi_namespace_node *gpe_device,

		status = acpi_ns_walk_namespace(ACPI_TYPE_METHOD, gpe_device,
		ACPI_UINT32_MAX, ACPI_NS_WALK_NO_UNLOCK,
		acpi_ev_save_method_info, NULL,
		acpi_ev_match_gpe_method, NULL,
		gpe_block, NULL);

		/* Return the new block */
		@@ -938,14 +933,13 @@ acpi_ev_create_gpe_block(struct acpi_namespace_node *gpe_device,
		"GPE %02X to %02X [%4.4s] %u regs on int 0x%X\n",
		(u32) gpe_block->block_base_number,
		(u32) (gpe_block->block_base_number +
		((gpe_block->register_count *
		ACPI_GPE_REGISTER_WIDTH) - 1)),
		(gpe_block->gpe_count - 1)),
		gpe_device->name.ascii, gpe_block->register_count,
		interrupt_number));

		/* Update global count of currently available GPEs */

		acpi_current_gpe_count += register_count * ACPI_GPE_REGISTER_WIDTH;
		acpi_current_gpe_count += gpe_block->gpe_count;
		return_ACPI_STATUS(AE_OK);
		}

		@@ -969,10 +963,13 @@ acpi_status
		acpi_ev_initialize_gpe_block(struct acpi_namespace_node *gpe_device,
		struct acpi_gpe_block_info *gpe_block)
		{
		acpi_status status;
		struct acpi_gpe_event_info *gpe_event_info;
		struct acpi_gpe_walk_info gpe_info;
		u32 wake_gpe_count;
		u32 gpe_enabled_count;
		u32 gpe_index;
		u32 gpe_number;
		u32 i;
		u32 j;

		@@ -998,49 +995,61 @@ acpi_ev_initialize_gpe_block(struct acpi_namespace_node *gpe_device,
		gpe_info.gpe_block = gpe_block;
		gpe_info.gpe_device = gpe_device;

		acpi_ns_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
		status = acpi_ns_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
		ACPI_UINT32_MAX, ACPI_NS_WALK_UNLOCK,
		acpi_ev_match_prw_and_gpe, NULL,
		&gpe_info, NULL);
		if (ACPI_FAILURE(status)) {
		ACPI_EXCEPTION((AE_INFO, status,
		"While executing _PRW methods"));
		}
		}

		/*
		* Enable all GPEs that have a corresponding method and aren't
		* Enable all GPEs that have a corresponding method and are not
		* capable of generating wakeups. Any other GPEs within this block
		* must be enabled via the acpi_enable_gpe() interface.
		* must be enabled via the acpi_enable_gpe interface.
		*/
		wake_gpe_count = 0;
		gpe_enabled_count = 0;
		if (gpe_device == acpi_gbl_fadt_gpe_device)

		if (gpe_device == acpi_gbl_fadt_gpe_device) {
		gpe_device = NULL;
		}

		for (i = 0; i < gpe_block->register_count; i++) {
		for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) {
		acpi_status status;
		acpi_size gpe_index;
		int gpe_number;

		/* Get the info block for this particular GPE */
		gpe_index = (acpi_size)i * ACPI_GPE_REGISTER_WIDTH + j;

		gpe_index = (i * ACPI_GPE_REGISTER_WIDTH) + j;
		gpe_event_info = &gpe_block->event_info[gpe_index];

		if (gpe_event_info->flags & ACPI_GPE_CAN_WAKE) {
		wake_gpe_count++;
		if (acpi_gbl_leave_wake_gpes_disabled)
		if (acpi_gbl_leave_wake_gpes_disabled) {
		continue;
		}
		}

		if (!(gpe_event_info->flags & ACPI_GPE_DISPATCH_METHOD))
		/* Ignore GPEs that have no corresponding _Lxx/_Exx method */

		if (!(gpe_event_info->flags & ACPI_GPE_DISPATCH_METHOD)) {
		continue;
		}

		/* Enable this GPE */

		gpe_number = gpe_index + gpe_block->block_base_number;
		status = acpi_enable_gpe(gpe_device, gpe_number,
		ACPI_GPE_TYPE_RUNTIME);
		if (ACPI_FAILURE(status))
		ACPI_ERROR((AE_INFO,
		"Failed to enable GPE %02X\n",
		if (ACPI_FAILURE(status)) {
		ACPI_EXCEPTION((AE_INFO, status,
		"Could not enable GPE 0x%02X",
		gpe_number));
		else
		continue;
		}

		gpe_enabled_count++;
		}
		}

drivers/acpi/acpica/evxface.c

+11 −9

Original line number	Diff line number	Diff line
		@@ -682,14 +682,13 @@ acpi_install_gpe_handler(acpi_handle gpe_device,

		/* Parameter validation */

		if ((!address) \|\| (type > ACPI_GPE_XRUPT_TYPE_MASK)) {
		status = AE_BAD_PARAMETER;
		goto exit;
		if ((!address) \|\| (type & ~ACPI_GPE_XRUPT_TYPE_MASK)) {
		return_ACPI_STATUS(AE_BAD_PARAMETER);
		}

		status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
		if (ACPI_FAILURE(status)) {
		goto exit;
		return_ACPI_STATUS(status);
		}

		/* Ensure that we have a valid GPE number */
		@@ -720,6 +719,13 @@ acpi_install_gpe_handler(acpi_handle gpe_device,
		handler->context = context;
		handler->method_node = gpe_event_info->dispatch.method_node;

		/* Disable the GPE before installing the handler */

		status = acpi_ev_disable_gpe(gpe_event_info);
		if (ACPI_FAILURE (status)) {
		goto unlock_and_exit;
		}

		/* Install the handler */

		flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
		@@ -735,10 +741,6 @@ acpi_install_gpe_handler(acpi_handle gpe_device,

		unlock_and_exit:
		(void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
		exit:
		if (ACPI_FAILURE(status))
		ACPI_EXCEPTION((AE_INFO, status,
		"Installing notify handler failed"));
		return_ACPI_STATUS(status);
		}

Admin message