Commit 3cfd53d5 authored by Lin Ming's avatar Lin Ming Committed by Len Brown
Browse files

ACPICA: Move GPE functions to new file evxfgpe.c 



Create a new file evxfgpe.c and move GPE specific functions to it.

Acked-by: default avatarRafael J. Wysocki <rjw@sisk.pl>
Signed-off-by: default avatarLin Ming <ming.m.lin@intel.com>
Signed-off-by: default avatarLen Brown <len.brown@intel.com>
parent 3c0eee3f

drivers/acpi/acpica/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -14,7 +14,7 @@ acpi-y := dsfield.o dsmthdat.o dsopcode.o dswexec.o dswscope.o \ 


acpi-y += evevent.o  evregion.o  evsci.o    evxfevnt.o \

	 evmisc.o   evrgnini.o  evxface.o  evxfregn.o \

	 evgpe.o    evgpeblk.o evgpeinit.o  evgpeutil.o

	 evgpe.o    evgpeblk.o evgpeinit.o  evgpeutil.o evxfgpe.o



acpi-y += exconfig.o  exfield.o  exnames.o   exoparg6.o  exresolv.o  exstorob.o\

	 exconvrt.o  exfldio.o  exoparg1.o  exprep.o    exresop.o   exsystem.o\

drivers/acpi/acpica/acevents.h

+4 −0
Original line number Diff line number Diff line
@@ -138,6 +138,10 @@ acpi_ev_walk_gpe_list(acpi_gpe_callback gpe_walk_callback, void *context); 


u8 acpi_ev_valid_gpe_event(struct acpi_gpe_event_info *gpe_event_info);



acpi_status

acpi_ev_get_gpe_device(struct acpi_gpe_xrupt_info *gpe_xrupt_info,

		       struct acpi_gpe_block_info *gpe_block, void *context);



struct acpi_gpe_xrupt_info *acpi_ev_get_gpe_xrupt_block(u32 interrupt_number);



acpi_status acpi_ev_delete_gpe_xrupt(struct acpi_gpe_xrupt_info *gpe_xrupt);

drivers/acpi/acpica/evgpeutil.c

+39 −0
Original line number Diff line number Diff line
@@ -152,6 +152,45 @@ u8 acpi_ev_valid_gpe_event(struct acpi_gpe_event_info *gpe_event_info) 
	return (FALSE);

}



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

 *

 * FUNCTION:    acpi_ev_get_gpe_device

 *

 * PARAMETERS:  GPE_WALK_CALLBACK

 *

 * RETURN:      Status

 *

 * DESCRIPTION: Matches the input GPE index (0-current_gpe_count) with a GPE

 *              block device. NULL if the GPE is one of the FADT-defined GPEs.

 *

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



acpi_status

acpi_ev_get_gpe_device(struct acpi_gpe_xrupt_info *gpe_xrupt_info,

		       struct acpi_gpe_block_info *gpe_block, void *context)

{

	struct acpi_gpe_device_info *info = context;



	/* Increment Index by the number of GPEs in this block */



	info->next_block_base_index += gpe_block->gpe_count;



	if (info->index < info->next_block_base_index) {

		/*

		 * The GPE index is within this block, get the node. Leave the node

		 * NULL for the FADT-defined GPEs

		 */

		if ((gpe_block->node)->type == ACPI_TYPE_DEVICE) {

			info->gpe_device = gpe_block->node;

		}



		info->status = AE_OK;

		return (AE_CTRL_END);

	}



	return (AE_OK);

}



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

 *

 * FUNCTION:    acpi_ev_get_gpe_xrupt_block

drivers/acpi/acpica/evxfevnt.c

+0 −600
Original line number Diff line number Diff line
@@ -43,18 +43,11 @@ 


#include <acpi/acpi.h>

#include "accommon.h"

#include "acevents.h"

#include "acnamesp.h"

#include "actables.h"



#define _COMPONENT          ACPI_EVENTS

ACPI_MODULE_NAME("evxfevnt")



/* Local prototypes */

static acpi_status

acpi_ev_get_gpe_device(struct acpi_gpe_xrupt_info *gpe_xrupt_info,

		       struct acpi_gpe_block_info *gpe_block, void *context);



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

 *

 * FUNCTION:    acpi_enable
@@ -211,185 +204,6 @@ acpi_status acpi_enable_event(u32 event, u32 flags) 


ACPI_EXPORT_SYMBOL(acpi_enable_event)



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

 *

 * FUNCTION:    acpi_gpe_wakeup

 *

 * PARAMETERS:  gpe_device      - Parent GPE Device. NULL for GPE0/GPE1

 *              gpe_number      - GPE level within the GPE block

 *              Action          - Enable or Disable

 *

 * RETURN:      Status

 *

 * DESCRIPTION: Set or clear the GPE's wakeup enable mask bit.

 *

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

acpi_status acpi_gpe_wakeup(acpi_handle gpe_device, u32 gpe_number, u8 action)

{

	acpi_status status = AE_OK;

	struct acpi_gpe_event_info *gpe_event_info;

	struct acpi_gpe_register_info *gpe_register_info;

	acpi_cpu_flags flags;

	u32 register_bit;



	ACPI_FUNCTION_TRACE(acpi_gpe_wakeup);



	flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);



	/* Ensure that we have a valid GPE number */



	gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);

	if (!gpe_event_info || !(gpe_event_info->flags & ACPI_GPE_CAN_WAKE)) {

		status = AE_BAD_PARAMETER;

		goto unlock_and_exit;

	}



	gpe_register_info = gpe_event_info->register_info;

	if (!gpe_register_info) {

		status = AE_NOT_EXIST;

		goto unlock_and_exit;

	}



	register_bit =

	    acpi_hw_get_gpe_register_bit(gpe_event_info, gpe_register_info);



	/* Perform the action */



	switch (action) {

	case ACPI_GPE_ENABLE:

		ACPI_SET_BIT(gpe_register_info->enable_for_wake,

			     (u8)register_bit);

		break;



	case ACPI_GPE_DISABLE:

		ACPI_CLEAR_BIT(gpe_register_info->enable_for_wake,

			       (u8)register_bit);

		break;



	default:

		ACPI_ERROR((AE_INFO, "%u, Invalid action", action));

		status = AE_BAD_PARAMETER;

		break;

	}



unlock_and_exit:

	acpi_os_release_lock(acpi_gbl_gpe_lock, flags);

	return_ACPI_STATUS(status);

}



ACPI_EXPORT_SYMBOL(acpi_gpe_wakeup)



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

 *

 * FUNCTION:    acpi_enable_gpe

 *

 * PARAMETERS:  gpe_device      - Parent GPE Device. NULL for GPE0/GPE1

 *              gpe_number      - GPE level within the GPE block

 *

 * RETURN:      Status

 *

 * DESCRIPTION: Add a reference to a GPE. On the first reference, the GPE is

 *              hardware-enabled.

 *

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

acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number)

{

	acpi_status status = AE_BAD_PARAMETER;

	struct acpi_gpe_event_info *gpe_event_info;

	acpi_cpu_flags flags;



	ACPI_FUNCTION_TRACE(acpi_enable_gpe);



	flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);



	/* Ensure that we have a valid GPE number */



	gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);

	if (gpe_event_info) {

		status = acpi_raw_enable_gpe(gpe_event_info);

	}



	acpi_os_release_lock(acpi_gbl_gpe_lock, flags);

	return_ACPI_STATUS(status);

}

ACPI_EXPORT_SYMBOL(acpi_enable_gpe)



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

 *

 * FUNCTION:    acpi_disable_gpe

 *

 * PARAMETERS:  gpe_device      - Parent GPE Device. NULL for GPE0/GPE1

 *              gpe_number      - GPE level within the GPE block

 *

 * RETURN:      Status

 *

 * DESCRIPTION: Remove a reference to a GPE. When the last reference is

 *              removed, only then is the GPE disabled (for runtime GPEs), or

 *              the GPE mask bit disabled (for wake GPEs)

 *

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

acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number)

{

	acpi_status status = AE_BAD_PARAMETER;

	struct acpi_gpe_event_info *gpe_event_info;

	acpi_cpu_flags flags;



	ACPI_FUNCTION_TRACE(acpi_disable_gpe);



	flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);



	/* Ensure that we have a valid GPE number */



	gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);

	if (gpe_event_info) {

		status = acpi_raw_disable_gpe(gpe_event_info) ;

	}



	acpi_os_release_lock(acpi_gbl_gpe_lock, flags);

	return_ACPI_STATUS(status);

}

ACPI_EXPORT_SYMBOL(acpi_disable_gpe)



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

 *

 * FUNCTION:    acpi_gpe_can_wake

 *

 * PARAMETERS:  gpe_device      - Parent GPE Device. NULL for GPE0/GPE1

 *              gpe_number      - GPE level within the GPE block

 *

 * RETURN:      Status

 *

 * DESCRIPTION: Set the ACPI_GPE_CAN_WAKE flag for the given GPE.  If the GPE

 *              has a corresponding method and is currently enabled, disable it

 *              (GPEs with corresponding methods are enabled unconditionally

 *              during initialization, but GPEs that can wake up are expected

 *              to be initially disabled).

 *

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

acpi_status acpi_gpe_can_wake(acpi_handle gpe_device, u32 gpe_number)

{

	acpi_status status = AE_OK;

	struct acpi_gpe_event_info *gpe_event_info;

	acpi_cpu_flags flags;



	ACPI_FUNCTION_TRACE(acpi_gpe_can_wake);



	flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);



	/* Ensure that we have a valid GPE number */



	gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);

	if (gpe_event_info) {

		gpe_event_info->flags |= ACPI_GPE_CAN_WAKE;

	} else {

		status = AE_BAD_PARAMETER;

	}



	acpi_os_release_lock(acpi_gbl_gpe_lock, flags);

	return_ACPI_STATUS(status);

}

ACPI_EXPORT_SYMBOL(acpi_gpe_can_wake)



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

 *

 * FUNCTION:    acpi_disable_event
@@ -481,44 +295,6 @@ acpi_status acpi_clear_event(u32 event) 


ACPI_EXPORT_SYMBOL(acpi_clear_event)



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

 *

 * FUNCTION:    acpi_clear_gpe

 *

 * PARAMETERS:  gpe_device      - Parent GPE Device. NULL for GPE0/GPE1

 *              gpe_number      - GPE level within the GPE block

 *

 * RETURN:      Status

 *

 * DESCRIPTION: Clear an ACPI event (general purpose)

 *

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

acpi_status acpi_clear_gpe(acpi_handle gpe_device, u32 gpe_number)

{

	acpi_status status = AE_OK;

	struct acpi_gpe_event_info *gpe_event_info;

	acpi_cpu_flags flags;



	ACPI_FUNCTION_TRACE(acpi_clear_gpe);



	flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);



	/* Ensure that we have a valid GPE number */



	gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);

	if (!gpe_event_info) {

		status = AE_BAD_PARAMETER;

		goto unlock_and_exit;

	}



	status = acpi_hw_clear_gpe(gpe_event_info);



      unlock_and_exit:

	acpi_os_release_lock(acpi_gbl_gpe_lock, flags);

	return_ACPI_STATUS(status);

}



ACPI_EXPORT_SYMBOL(acpi_clear_gpe)

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

 *

 * FUNCTION:    acpi_get_event_status
@@ -575,379 +351,3 @@ acpi_status acpi_get_event_status(u32 event, acpi_event_status * event_status) 
}



ACPI_EXPORT_SYMBOL(acpi_get_event_status)
 


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

 *

 * FUNCTION:    acpi_get_gpe_status

 *

 * PARAMETERS:  gpe_device      - Parent GPE Device. NULL for GPE0/GPE1

 *              gpe_number      - GPE level within the GPE block

 *              event_status    - Where the current status of the event will

 *                                be returned

 *

 * RETURN:      Status

 *

 * DESCRIPTION: Get status of an event (general purpose)

 *

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

acpi_status

acpi_get_gpe_status(acpi_handle gpe_device,

		    u32 gpe_number, acpi_event_status *event_status)

{

	acpi_status status = AE_OK;

	struct acpi_gpe_event_info *gpe_event_info;

	acpi_cpu_flags flags;



	ACPI_FUNCTION_TRACE(acpi_get_gpe_status);



	flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);



	/* Ensure that we have a valid GPE number */



	gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);

	if (!gpe_event_info) {

		status = AE_BAD_PARAMETER;

		goto unlock_and_exit;

	}



	/* Obtain status on the requested GPE number */



	status = acpi_hw_get_gpe_status(gpe_event_info, event_status);



	if (gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK)

		*event_status |= ACPI_EVENT_FLAG_HANDLE;



      unlock_and_exit:

	acpi_os_release_lock(acpi_gbl_gpe_lock, flags);

	return_ACPI_STATUS(status);

}



ACPI_EXPORT_SYMBOL(acpi_get_gpe_status)

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

 *

 * FUNCTION:    acpi_install_gpe_block

 *

 * PARAMETERS:  gpe_device          - Handle to the parent GPE Block Device

 *              gpe_block_address   - Address and space_iD

 *              register_count      - Number of GPE register pairs in the block

 *              interrupt_number    - H/W interrupt for the block

 *

 * RETURN:      Status

 *

 * DESCRIPTION: Create and Install a block of GPE registers

 *

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

acpi_status

acpi_install_gpe_block(acpi_handle gpe_device,

		       struct acpi_generic_address *gpe_block_address,

		       u32 register_count, u32 interrupt_number)

{

	acpi_status status = AE_OK;

	union acpi_operand_object *obj_desc;

	struct acpi_namespace_node *node;

	struct acpi_gpe_block_info *gpe_block;



	ACPI_FUNCTION_TRACE(acpi_install_gpe_block);



	if ((!gpe_device) || (!gpe_block_address) || (!register_count)) {

		return_ACPI_STATUS(AE_BAD_PARAMETER);

	}



	status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);

	if (ACPI_FAILURE(status)) {

		return (status);

	}



	node = acpi_ns_validate_handle(gpe_device);

	if (!node) {

		status = AE_BAD_PARAMETER;

		goto unlock_and_exit;

	}



	/*

	 * For user-installed GPE Block Devices, the gpe_block_base_number

	 * is always zero

	 */

	status =

	    acpi_ev_create_gpe_block(node, gpe_block_address, register_count, 0,

				     interrupt_number, &gpe_block);

	if (ACPI_FAILURE(status)) {

		goto unlock_and_exit;

	}



	/* Install block in the device_object attached to the node */



	obj_desc = acpi_ns_get_attached_object(node);

	if (!obj_desc) {



		/*

		 * No object, create a new one (Device nodes do not always have

		 * an attached object)

		 */

		obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_DEVICE);

		if (!obj_desc) {

			status = AE_NO_MEMORY;

			goto unlock_and_exit;

		}



		status =

		    acpi_ns_attach_object(node, obj_desc, ACPI_TYPE_DEVICE);



		/* Remove local reference to the object */



		acpi_ut_remove_reference(obj_desc);



		if (ACPI_FAILURE(status)) {

			goto unlock_and_exit;

		}

	}



	/* Now install the GPE block in the device_object */



	obj_desc->device.gpe_block = gpe_block;



      unlock_and_exit:

	(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);

	return_ACPI_STATUS(status);

}



ACPI_EXPORT_SYMBOL(acpi_install_gpe_block)



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

 *

 * FUNCTION:    acpi_remove_gpe_block

 *

 * PARAMETERS:  gpe_device          - Handle to the parent GPE Block Device

 *

 * RETURN:      Status

 *

 * DESCRIPTION: Remove a previously installed block of GPE registers

 *

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

acpi_status acpi_remove_gpe_block(acpi_handle gpe_device)

{

	union acpi_operand_object *obj_desc;

	acpi_status status;

	struct acpi_namespace_node *node;



	ACPI_FUNCTION_TRACE(acpi_remove_gpe_block);



	if (!gpe_device) {

		return_ACPI_STATUS(AE_BAD_PARAMETER);

	}



	status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);

	if (ACPI_FAILURE(status)) {

		return (status);

	}



	node = acpi_ns_validate_handle(gpe_device);

	if (!node) {

		status = AE_BAD_PARAMETER;

		goto unlock_and_exit;

	}



	/* Get the device_object attached to the node */



	obj_desc = acpi_ns_get_attached_object(node);

	if (!obj_desc || !obj_desc->device.gpe_block) {

		return_ACPI_STATUS(AE_NULL_OBJECT);

	}



	/* Delete the GPE block (but not the device_object) */



	status = acpi_ev_delete_gpe_block(obj_desc->device.gpe_block);

	if (ACPI_SUCCESS(status)) {

		obj_desc->device.gpe_block = NULL;

	}



      unlock_and_exit:

	(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);

	return_ACPI_STATUS(status);

}



ACPI_EXPORT_SYMBOL(acpi_remove_gpe_block)



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

 *

 * FUNCTION:    acpi_get_gpe_device

 *

 * PARAMETERS:  Index               - System GPE index (0-current_gpe_count)

 *              gpe_device          - Where the parent GPE Device is returned

 *

 * RETURN:      Status

 *

 * DESCRIPTION: Obtain the GPE device associated with the input index. A NULL

 *              gpe device indicates that the gpe number is contained in one of

 *              the FADT-defined gpe blocks. Otherwise, the GPE block device.

 *

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

acpi_status

acpi_get_gpe_device(u32 index, acpi_handle *gpe_device)

{

	struct acpi_gpe_device_info info;

	acpi_status status;



	ACPI_FUNCTION_TRACE(acpi_get_gpe_device);



	if (!gpe_device) {

		return_ACPI_STATUS(AE_BAD_PARAMETER);

	}



	if (index >= acpi_current_gpe_count) {

		return_ACPI_STATUS(AE_NOT_EXIST);

	}



	/* Setup and walk the GPE list */



	info.index = index;

	info.status = AE_NOT_EXIST;

	info.gpe_device = NULL;

	info.next_block_base_index = 0;



	status = acpi_ev_walk_gpe_list(acpi_ev_get_gpe_device, &info);

	if (ACPI_FAILURE(status)) {

		return_ACPI_STATUS(status);

	}



	*gpe_device = info.gpe_device;

	return_ACPI_STATUS(info.status);

}



ACPI_EXPORT_SYMBOL(acpi_get_gpe_device)



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

 *

 * FUNCTION:    acpi_ev_get_gpe_device

 *

 * PARAMETERS:  GPE_WALK_CALLBACK

 *

 * RETURN:      Status

 *

 * DESCRIPTION: Matches the input GPE index (0-current_gpe_count) with a GPE

 *              block device. NULL if the GPE is one of the FADT-defined GPEs.

 *

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

static acpi_status

acpi_ev_get_gpe_device(struct acpi_gpe_xrupt_info *gpe_xrupt_info,

		       struct acpi_gpe_block_info *gpe_block, void *context)

{

	struct acpi_gpe_device_info *info = context;



	/* Increment Index by the number of GPEs in this block */



	info->next_block_base_index += gpe_block->gpe_count;



	if (info->index < info->next_block_base_index) {

		/*

		 * The GPE index is within this block, get the node. Leave the node

		 * NULL for the FADT-defined GPEs

		 */

		if ((gpe_block->node)->type == ACPI_TYPE_DEVICE) {

			info->gpe_device = gpe_block->node;

		}



		info->status = AE_OK;

		return (AE_CTRL_END);

	}



	return (AE_OK);

}



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

 *

 * FUNCTION:    acpi_disable_all_gpes

 *

 * PARAMETERS:  None

 *

 * RETURN:      Status

 *

 * DESCRIPTION: Disable and clear all GPEs in all GPE blocks

 *

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



acpi_status acpi_disable_all_gpes(void)

{

	acpi_status status;



	ACPI_FUNCTION_TRACE(acpi_disable_all_gpes);



	status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);

	if (ACPI_FAILURE(status)) {

		return_ACPI_STATUS(status);

	}



	status = acpi_hw_disable_all_gpes();

	(void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);



	return_ACPI_STATUS(status);

}



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

 *

 * FUNCTION:    acpi_enable_all_runtime_gpes

 *

 * PARAMETERS:  None

 *

 * RETURN:      Status

 *

 * DESCRIPTION: Enable all "runtime" GPEs, in all GPE blocks

 *

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



acpi_status acpi_enable_all_runtime_gpes(void)

{

	acpi_status status;



	ACPI_FUNCTION_TRACE(acpi_enable_all_runtime_gpes);



	status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);

	if (ACPI_FAILURE(status)) {

		return_ACPI_STATUS(status);

	}



	status = acpi_hw_enable_all_runtime_gpes();

	(void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);



	return_ACPI_STATUS(status);

}



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

 *

 * FUNCTION:    acpi_update_gpes

 *

 * PARAMETERS:  None

 *

 * RETURN:      None

 *

 * DESCRIPTION: Enable all GPEs that have associated _Lxx or _Exx methods and

 *              are not pointed to by any device _PRW methods indicating that

 *              these GPEs are generally intended for system or device wakeup

 *              (such GPEs have to be enabled directly when the devices whose

 *              _PRW methods point to them are set up for wakeup signaling).

 *

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



acpi_status acpi_update_gpes(void)

{

	acpi_status status;



	ACPI_FUNCTION_TRACE(acpi_update_gpes);



	status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);

	if (ACPI_FAILURE(status)) {

		return_ACPI_STATUS(status);

	} else if (acpi_all_gpes_initialized) {

		goto unlock;

	}



	status = acpi_ev_walk_gpe_list(acpi_ev_initialize_gpe_block, NULL);

	if (ACPI_SUCCESS(status)) {

		acpi_all_gpes_initialized = TRUE;

	}



unlock:

	(void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);



	return_ACPI_STATUS(status);

}

drivers/acpi/acpica/evxfgpe.c

0 → 100644
+610 −0

File added.

Preview size limit exceeded, changes collapsed.

CRA Git | Maintained and supported by SUSTech CRA and CCSE