Subversion Repositories Kolibri OS

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

 *

 * Module Name: utaddress - op_region address range check

 *

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

/*

 * Copyright (C) 2000 - 2015, Intel Corp.

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions, and the following disclaimer,

 *    without modification.

 * 2. Redistributions in binary form must reproduce at minimum a disclaimer

 *    substantially similar to the "NO WARRANTY" disclaimer below

 *    ("Disclaimer") and any redistribution must be conditioned upon

 *    including a substantially similar Disclaimer requirement for further

 *    binary redistribution.

 * 3. Neither the names of the above-listed copyright holders nor the names

 *    of any contributors may be used to endorse or promote products derived

 *    from this software without specific prior written permission.

 *

 * Alternatively, this software may be distributed under the terms of the

 * GNU General Public License ("GPL") version 2 as published by the Free

 * Software Foundation.

 *

 * NO WARRANTY

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING

 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGES.

 */

#include 

#include "accommon.h"

#include "acnamesp.h"

#define _COMPONENT          ACPI_UTILITIES

ACPI_MODULE_NAME("utaddress")

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

 *

 * FUNCTION:    acpi_ut_add_address_range

 *

 * PARAMETERS:  space_id            - Address space ID

 *              address             - op_region start address

 *              length              - op_region length

 *              region_node         - op_region namespace node

 *

 * RETURN:      Status

 *

 * DESCRIPTION: Add the Operation Region address range to the global list.

 *              The only supported Space IDs are Memory and I/O. Called when

 *              the op_region address/length operands are fully evaluated.

 *

 * MUTEX:       Locks the namespace

 *

 * NOTE: Because this interface is only called when an op_region argument

 * list is evaluated, there cannot be any duplicate region_nodes.

 * Duplicate Address/Length values are allowed, however, so that multiple

 * address conflicts can be detected.

 *

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

acpi_status

acpi_ut_add_address_range(acpi_adr_space_type space_id,

			  acpi_physical_address address,

			  u32 length, struct acpi_namespace_node *region_node)

{

	struct acpi_address_range *range_info;

	acpi_status status;

	ACPI_FUNCTION_TRACE(ut_add_address_range);

	if ((space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY) &&

	    (space_id != ACPI_ADR_SPACE_SYSTEM_IO)) {

		return_ACPI_STATUS(AE_OK);

	}

	/* Allocate/init a new info block, add it to the appropriate list */

	range_info = ACPI_ALLOCATE(sizeof(struct acpi_address_range));

	if (!range_info) {

		return_ACPI_STATUS(AE_NO_MEMORY);

	}

	range_info->start_address = address;

	range_info->end_address = (address + length - 1);

	range_info->region_node = region_node;

	status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);

	if (ACPI_FAILURE(status)) {

		ACPI_FREE(range_info);

		return_ACPI_STATUS(status);

	}

	range_info->next = acpi_gbl_address_range_list[space_id];

	acpi_gbl_address_range_list[space_id] = range_info;

	ACPI_DEBUG_PRINT((ACPI_DB_NAMES,

			  "\nAdded [%4.4s] address range: 0x%8.8X%8.8X-0x%8.8X%8.8X\n",

			  acpi_ut_get_node_name(range_info->region_node),

			  ACPI_FORMAT_UINT64(address),

			  ACPI_FORMAT_UINT64(range_info->end_address)));

	(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);

	return_ACPI_STATUS(AE_OK);

}

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

 *

 * FUNCTION:    acpi_ut_remove_address_range

 *

 * PARAMETERS:  space_id            - Address space ID

 *              region_node         - op_region namespace node

 *

 * RETURN:      None

 *

 * DESCRIPTION: Remove the Operation Region from the global list. The only

 *              supported Space IDs are Memory and I/O. Called when an

 *              op_region is deleted.

 *

 * MUTEX:       Assumes the namespace is locked

 *

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

void

acpi_ut_remove_address_range(acpi_adr_space_type space_id,

			     struct acpi_namespace_node *region_node)

{

	struct acpi_address_range *range_info;

	struct acpi_address_range *prev;

	ACPI_FUNCTION_TRACE(ut_remove_address_range);

	if ((space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY) &&

	    (space_id != ACPI_ADR_SPACE_SYSTEM_IO)) {

		return_VOID;

	}

	/* Get the appropriate list head and check the list */

	range_info = prev = acpi_gbl_address_range_list[space_id];

	while (range_info) {

		if (range_info->region_node == region_node) {

			if (range_info == prev) {	/* Found at list head */

				acpi_gbl_address_range_list[space_id] =

				    range_info->next;

			} else {

				prev->next = range_info->next;

			}

			ACPI_DEBUG_PRINT((ACPI_DB_NAMES,

					  "\nRemoved [%4.4s] address range: 0x%8.8X%8.8X-0x%8.8X%8.8X\n",

					  acpi_ut_get_node_name(range_info->

								region_node),

					  ACPI_FORMAT_UINT64(range_info->

							     start_address),

					  ACPI_FORMAT_UINT64(range_info->

							     end_address)));

			ACPI_FREE(range_info);

			return_VOID;

		}

		prev = range_info;

		range_info = range_info->next;

	}

	return_VOID;

}

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

 *

 * FUNCTION:    acpi_ut_check_address_range

 *

 * PARAMETERS:  space_id            - Address space ID

 *              address             - Start address

 *              length              - Length of address range

 *              warn                - TRUE if warning on overlap desired

 *

 * RETURN:      Count of the number of conflicts detected. Zero is always

 *              returned for Space IDs other than Memory or I/O.

 *

 * DESCRIPTION: Check if the input address range overlaps any of the

 *              ASL operation region address ranges. The only supported

 *              Space IDs are Memory and I/O.

 *

 * MUTEX:       Assumes the namespace is locked.

 *

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

u32

acpi_ut_check_address_range(acpi_adr_space_type space_id,

			    acpi_physical_address address, u32 length, u8 warn)

{

	struct acpi_address_range *range_info;

	acpi_physical_address end_address;

	char *pathname;

	u32 overlap_count = 0;

	ACPI_FUNCTION_TRACE(ut_check_address_range);

	if ((space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY) &&

	    (space_id != ACPI_ADR_SPACE_SYSTEM_IO)) {

		return_UINT32(0);

	}

	range_info = acpi_gbl_address_range_list[space_id];

	end_address = address + length - 1;

	/* Check entire list for all possible conflicts */

	while (range_info) {

		/*

		 * Check if the requested address/length overlaps this

		 * address range. There are four cases to consider:

		 *

		 * 1) Input address/length is contained completely in the

		 *    address range

		 * 2) Input address/length overlaps range at the range start

		 * 3) Input address/length overlaps range at the range end

		 * 4) Input address/length completely encompasses the range

		 */

		if ((address <= range_info->end_address) &&

		    (end_address >= range_info->start_address)) {

			/* Found an address range overlap */

			overlap_count++;

			if (warn) {	/* Optional warning message */

				pathname =

				    acpi_ns_get_external_pathname(range_info->

								  region_node);

				ACPI_WARNING((AE_INFO,

					      "%s range 0x%8.8X%8.8X-0x%8.8X%8.8X conflicts with OpRegion 0x%8.8X%8.8X-0x%8.8X%8.8X (%s)",

					      acpi_ut_get_region_name(space_id),

					      ACPI_FORMAT_UINT64(address),

					      ACPI_FORMAT_UINT64(end_address),

					      ACPI_FORMAT_UINT64(range_info->

								 start_address),

					      ACPI_FORMAT_UINT64(range_info->

								 end_address),

					      pathname));

				ACPI_FREE(pathname);

			}

		}

		range_info = range_info->next;

	}

	return_UINT32(overlap_count);

}

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

 *

 * FUNCTION:    acpi_ut_delete_address_lists

 *

 * PARAMETERS:  None

 *

 * RETURN:      None

 *

 * DESCRIPTION: Delete all global address range lists (called during

 *              subsystem shutdown).

 *

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

void acpi_ut_delete_address_lists(void)

{

	struct acpi_address_range *next;

	struct acpi_address_range *range_info;

	int i;

	/* Delete all elements in all address range lists */

	for (i = 0; i < ACPI_ADDRESS_RANGE_MAX; i++) {

		next = acpi_gbl_address_range_list[i];

		while (next) {

			range_info = next;

			next = range_info->next;

			ACPI_FREE(range_info);

		}

		acpi_gbl_address_range_list[i] = NULL;

	}

}