Merge branch 'gpe-defer' into release (6e04c417) · Commits · e / devices / android_kernel_fairphone_FP4

drivers/acpi/acpica/acevents.h

+3 −2

Original line number	Original line	Diff line number	Diff line
	@@ -105,8 +105,9 @@ acpi_ev_create_gpe_block(struct acpi_namespace_node *gpe_device,
	struct acpi_gpe_block_info **return_gpe_block);		struct acpi_gpe_block_info **return_gpe_block);

	acpi_status		acpi_status
	acpi_ev_initialize_gpe_block(struct acpi_namespace_node *gpe_device,		acpi_ev_initialize_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
	struct acpi_gpe_block_info *gpe_block);		struct acpi_gpe_block_info *gpe_block,
			void *ignored);

	acpi_status acpi_ev_delete_gpe_block(struct acpi_gpe_block_info *gpe_block);		acpi_status acpi_ev_delete_gpe_block(struct acpi_gpe_block_info *gpe_block);

drivers/acpi/acpica/acglobal.h

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -370,6 +370,7 @@ ACPI_EXTERN struct acpi_fixed_event_handler
	ACPI_EXTERN struct acpi_gpe_xrupt_info *acpi_gbl_gpe_xrupt_list_head;		ACPI_EXTERN struct acpi_gpe_xrupt_info *acpi_gbl_gpe_xrupt_list_head;
	ACPI_EXTERN struct acpi_gpe_block_info		ACPI_EXTERN struct acpi_gpe_block_info
	*acpi_gbl_gpe_fadt_blocks[ACPI_MAX_GPE_BLOCKS];		*acpi_gbl_gpe_fadt_blocks[ACPI_MAX_GPE_BLOCKS];
			ACPI_EXTERN u8 acpi_all_gpes_initialized;

	/*****************************************************************************		/*****************************************************************************
	*		*

drivers/acpi/acpica/aclocal.h

+2 −1

Original line number	Original line	Diff line number	Diff line
	@@ -413,6 +413,7 @@ struct acpi_handler_info {
	void context; / Context to be passed to handler */		void context; / Context to be passed to handler */
	struct acpi_namespace_node method_node; / Method node for this GPE level (saved) */		struct acpi_namespace_node method_node; / Method node for this GPE level (saved) */
	u8 orig_flags; /* Original misc info about this GPE */		u8 orig_flags; /* Original misc info about this GPE */
			u8 orig_enabled; /* Set if the GPE was originally enabled */
	};		};

	union acpi_gpe_dispatch_info {		union acpi_gpe_dispatch_info {
	@@ -457,6 +458,7 @@ struct acpi_gpe_block_info {
	u32 register_count; /* Number of register pairs in block */		u32 register_count; /* Number of register pairs in block */
	u16 gpe_count; /* Number of individual GPEs in block */		u16 gpe_count; /* Number of individual GPEs in block */
	u8 block_base_number; /* Base GPE number for this block */		u8 block_base_number; /* Base GPE number for this block */
			u8 initialized; /* If set, the GPE block has been initialized */
	};		};

	/* Information about GPE interrupt handlers, one per each interrupt level used for GPEs */		/* Information about GPE interrupt handlers, one per each interrupt level used for GPEs */
	@@ -473,7 +475,6 @@ struct acpi_gpe_walk_info {
	struct acpi_gpe_block_info *gpe_block;		struct acpi_gpe_block_info *gpe_block;
	u16 count;		u16 count;
	acpi_owner_id owner_id;		acpi_owner_id owner_id;
	u8 enable_this_gpe;
	u8 execute_by_owner_id;		u8 execute_by_owner_id;
	};		};

drivers/acpi/acpica/evevent.c

+0 −41

Original line number	Original line	Diff line number	Diff line
	@@ -93,47 +93,6 @@ acpi_status acpi_ev_initialize_events(void)
	return_ACPI_STATUS(status);		return_ACPI_STATUS(status);
	}		}

	/*******************************************************************************
	*
	* FUNCTION: acpi_ev_install_fadt_gpes
	*
	* PARAMETERS: None
	*
	* RETURN: Status
	*
	* DESCRIPTION: Completes initialization of the FADT-defined GPE blocks
	* (0 and 1). The HW must be fully initialized at this point,
	* including global lock support.
	*
	******************************************************************************/

	acpi_status acpi_ev_install_fadt_gpes(void)
	{
	acpi_status status;

	ACPI_FUNCTION_TRACE(ev_install_fadt_gpes);

	/* Namespace must be locked */

	status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
	if (ACPI_FAILURE(status)) {
	return (status);
	}

	/* FADT GPE Block 0 */

	(void)acpi_ev_initialize_gpe_block(acpi_gbl_fadt_gpe_device,
	acpi_gbl_gpe_fadt_blocks[0]);

	/* FADT GPE Block 1 */

	(void)acpi_ev_initialize_gpe_block(acpi_gbl_fadt_gpe_device,
	acpi_gbl_gpe_fadt_blocks[1]);

	(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
	return_ACPI_STATUS(AE_OK);
	}

	/*******************************************************************************		/*******************************************************************************
	*		*
	* FUNCTION: acpi_ev_install_xrupt_handlers		* FUNCTION: acpi_ev_install_xrupt_handlers

drivers/acpi/acpica/evgpeblk.c

+21 −26

Original line number	Original line	Diff line number	Diff line
	@@ -363,6 +363,7 @@ acpi_ev_create_gpe_block(struct acpi_namespace_node *gpe_device,
	gpe_block->gpe_count = (u16)(register_count * ACPI_GPE_REGISTER_WIDTH);		gpe_block->gpe_count = (u16)(register_count * ACPI_GPE_REGISTER_WIDTH);
	gpe_block->register_count = register_count;		gpe_block->register_count = register_count;
	gpe_block->block_base_number = gpe_block_base_number;		gpe_block->block_base_number = gpe_block_base_number;
			gpe_block->initialized = FALSE;

	ACPI_MEMCPY(&gpe_block->block_address, gpe_block_address,		ACPI_MEMCPY(&gpe_block->block_address, gpe_block_address,
	sizeof(struct acpi_generic_address));		sizeof(struct acpi_generic_address));
	@@ -385,11 +386,12 @@ acpi_ev_create_gpe_block(struct acpi_namespace_node *gpe_device,
	return_ACPI_STATUS(status);		return_ACPI_STATUS(status);
	}		}

			acpi_all_gpes_initialized = FALSE;

	/* Find all GPE methods (_Lxx or_Exx) for this block */		/* Find all GPE methods (_Lxx or_Exx) for this block */

	walk_info.gpe_block = gpe_block;		walk_info.gpe_block = gpe_block;
	walk_info.gpe_device = gpe_device;		walk_info.gpe_device = gpe_device;
	walk_info.enable_this_gpe = FALSE;
	walk_info.execute_by_owner_id = FALSE;		walk_info.execute_by_owner_id = FALSE;

	status = acpi_ns_walk_namespace(ACPI_TYPE_METHOD, gpe_device,		status = acpi_ns_walk_namespace(ACPI_TYPE_METHOD, gpe_device,
	@@ -434,35 +436,34 @@ acpi_ev_create_gpe_block(struct acpi_namespace_node *gpe_device,
	******************************************************************************/		******************************************************************************/

	acpi_status		acpi_status
	acpi_ev_initialize_gpe_block(struct acpi_namespace_node *gpe_device,		acpi_ev_initialize_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
	struct acpi_gpe_block_info *gpe_block)		struct acpi_gpe_block_info *gpe_block,
			void *ignored)
	{		{
	acpi_status status;		acpi_status status;
	struct acpi_gpe_event_info *gpe_event_info;		struct acpi_gpe_event_info *gpe_event_info;
	u32 gpe_enabled_count;		u32 gpe_enabled_count;
	u32 gpe_index;		u32 gpe_index;
	u32 gpe_number;
	u32 i;		u32 i;
	u32 j;		u32 j;

	ACPI_FUNCTION_TRACE(ev_initialize_gpe_block);		ACPI_FUNCTION_TRACE(ev_initialize_gpe_block);

	/* Ignore a null GPE block (e.g., if no GPE block 1 exists) */		/*
			* Ignore a null GPE block (e.g., if no GPE block 1 exists) and
	if (!gpe_block) {		* GPE blocks that have been initialized already.
			*/
			if (!gpe_block \|\| gpe_block->initialized) {
	return_ACPI_STATUS(AE_OK);		return_ACPI_STATUS(AE_OK);
	}		}

	/*		/*
	* Enable all GPEs that have a corresponding method. Any other GPEs		* Enable all GPEs that have a corresponding method and have the
	* within this block must be enabled via the acpi_enable_gpe interface.		* ACPI_GPE_CAN_WAKE flag unset. Any other GPEs within this block must
			* be enabled via the acpi_enable_gpe() interface.
	*/		*/
	gpe_enabled_count = 0;		gpe_enabled_count = 0;

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

	for (i = 0; i < gpe_block->register_count; i++) {		for (i = 0; i < gpe_block->register_count; i++) {
	for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) {		for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) {

	@@ -470,27 +471,19 @@ acpi_ev_initialize_gpe_block(struct acpi_namespace_node *gpe_device,

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

	/* Ignore GPEs that have no corresponding _Lxx/_Exx method */		/* Ignore GPEs that have no corresponding _Lxx/_Exx method */

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

	/*		status = acpi_raw_enable_gpe(gpe_event_info);
	* If the GPE has already been enabled for runtime
	* signaling, make sure it remains enabled, but do not
	* increment its reference counter.
	*/
	status = gpe_event_info->runtime_count ?
	acpi_ev_enable_gpe(gpe_event_info) :
	acpi_enable_gpe(gpe_device, gpe_number);

	if (ACPI_FAILURE(status)) {		if (ACPI_FAILURE(status)) {
	ACPI_EXCEPTION((AE_INFO, status,		ACPI_EXCEPTION((AE_INFO, status,
	"Could not enable GPE 0x%02X",		"Could not enable GPE 0x%02X",
	gpe_number));		gpe_index + gpe_block->block_base_number));
	continue;		continue;
	}		}

	@@ -504,5 +497,7 @@ acpi_ev_initialize_gpe_block(struct acpi_namespace_node *gpe_device,
	gpe_enabled_count));		gpe_enabled_count));
	}		}

			gpe_block->initialized = TRUE;

	return_ACPI_STATUS(AE_OK);		return_ACPI_STATUS(AE_OK);
	}		}