Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 0f849d2c authored by Lin Ming's avatar Lin Ming Committed by Len Brown
Browse files

ACPICA: Minimize the differences between linux GPE code and ACPICA code base 

We have ported Rafael's major GPE changes
(ACPI: Use GPE reference counting to support shared GPEs) into ACPICA code base.
But the port and Rafael's original patch have some differences, so we made
below patch to make linux GPE code consistent with ACPICA code base.

Most changes are about comments and coding styles.
Other noticeable changes are based on:

Rafael: Reduce code duplication related to GPE lookup
https://patchwork.kernel.org/patch/86237/

Rafael: Always use the same lock for GPE locking
https://patchwork.kernel.org/patch/90471/



A new field gpe_count in struct acpi_gpe_block_info to record the number
of individual GPEs in block.

Rename acpi_ev_save_method_info to acpi_ev_match_gpe_method.

Signed-off-by: default avatarRafael J. Wysocki <rjw@sisk.pl>
Signed-off-by: default avatarRobert Moore <robert.moore@intel.com>
Signed-off-by: default avatarLin Ming <ming.m.lin@intel.com>
Signed-off-by: default avatarLen Brown <len.brown@intel.com>
parent aa2110cb

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);

}