291 lines
9.3 KiB
C
291 lines
9.3 KiB
C
/******************************************************************************
|
|
*
|
|
* Module Name: utaddress - op_region address range check
|
|
*
|
|
*****************************************************************************/
|
|
|
|
/*
|
|
* Copyright (C) 2000 - 2016, 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 <acpi/acpi.h>
|
|
#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_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;
|
|
|
|
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)));
|
|
|
|
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_normalized_pathname(range_info->
|
|
region_node,
|
|
TRUE);
|
|
|
|
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;
|
|
}
|
|
}
|