1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 2 /****************************************************************************** 3 * 4 * Module Name: utaddress - op_region address range check 5 * 6 * Copyright (C) 2000 - 2018, Intel Corp. 7 * 8 *****************************************************************************/ 9 10 #include <acpi/acpi.h> 11 #include "accommon.h" 12 #include "acnamesp.h" 13 14 #define _COMPONENT ACPI_UTILITIES 15 ACPI_MODULE_NAME("utaddress") 16 17 /******************************************************************************* 18 * 19 * FUNCTION: acpi_ut_add_address_range 20 * 21 * PARAMETERS: space_id - Address space ID 22 * address - op_region start address 23 * length - op_region length 24 * region_node - op_region namespace node 25 * 26 * RETURN: Status 27 * 28 * DESCRIPTION: Add the Operation Region address range to the global list. 29 * The only supported Space IDs are Memory and I/O. Called when 30 * the op_region address/length operands are fully evaluated. 31 * 32 * MUTEX: Locks the namespace 33 * 34 * NOTE: Because this interface is only called when an op_region argument 35 * list is evaluated, there cannot be any duplicate region_nodes. 36 * Duplicate Address/Length values are allowed, however, so that multiple 37 * address conflicts can be detected. 38 * 39 ******************************************************************************/ 40 acpi_status 41 acpi_ut_add_address_range(acpi_adr_space_type space_id, 42 acpi_physical_address address, 43 u32 length, struct acpi_namespace_node *region_node) 44 { 45 struct acpi_address_range *range_info; 46 47 ACPI_FUNCTION_TRACE(ut_add_address_range); 48 49 if ((space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY) && 50 (space_id != ACPI_ADR_SPACE_SYSTEM_IO)) { 51 return_ACPI_STATUS(AE_OK); 52 } 53 54 /* Allocate/init a new info block, add it to the appropriate list */ 55 56 range_info = ACPI_ALLOCATE(sizeof(struct acpi_address_range)); 57 if (!range_info) { 58 return_ACPI_STATUS(AE_NO_MEMORY); 59 } 60 61 range_info->start_address = address; 62 range_info->end_address = (address + length - 1); 63 range_info->region_node = region_node; 64 65 range_info->next = acpi_gbl_address_range_list[space_id]; 66 acpi_gbl_address_range_list[space_id] = range_info; 67 68 ACPI_DEBUG_PRINT((ACPI_DB_NAMES, 69 "\nAdded [%4.4s] address range: 0x%8.8X%8.8X-0x%8.8X%8.8X\n", 70 acpi_ut_get_node_name(range_info->region_node), 71 ACPI_FORMAT_UINT64(address), 72 ACPI_FORMAT_UINT64(range_info->end_address))); 73 74 return_ACPI_STATUS(AE_OK); 75 } 76 77 /******************************************************************************* 78 * 79 * FUNCTION: acpi_ut_remove_address_range 80 * 81 * PARAMETERS: space_id - Address space ID 82 * region_node - op_region namespace node 83 * 84 * RETURN: None 85 * 86 * DESCRIPTION: Remove the Operation Region from the global list. The only 87 * supported Space IDs are Memory and I/O. Called when an 88 * op_region is deleted. 89 * 90 * MUTEX: Assumes the namespace is locked 91 * 92 ******************************************************************************/ 93 94 void 95 acpi_ut_remove_address_range(acpi_adr_space_type space_id, 96 struct acpi_namespace_node *region_node) 97 { 98 struct acpi_address_range *range_info; 99 struct acpi_address_range *prev; 100 101 ACPI_FUNCTION_TRACE(ut_remove_address_range); 102 103 if ((space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY) && 104 (space_id != ACPI_ADR_SPACE_SYSTEM_IO)) { 105 return_VOID; 106 } 107 108 /* Get the appropriate list head and check the list */ 109 110 range_info = prev = acpi_gbl_address_range_list[space_id]; 111 while (range_info) { 112 if (range_info->region_node == region_node) { 113 if (range_info == prev) { /* Found at list head */ 114 acpi_gbl_address_range_list[space_id] = 115 range_info->next; 116 } else { 117 prev->next = range_info->next; 118 } 119 120 ACPI_DEBUG_PRINT((ACPI_DB_NAMES, 121 "\nRemoved [%4.4s] address range: 0x%8.8X%8.8X-0x%8.8X%8.8X\n", 122 acpi_ut_get_node_name(range_info-> 123 region_node), 124 ACPI_FORMAT_UINT64(range_info-> 125 start_address), 126 ACPI_FORMAT_UINT64(range_info-> 127 end_address))); 128 129 ACPI_FREE(range_info); 130 return_VOID; 131 } 132 133 prev = range_info; 134 range_info = range_info->next; 135 } 136 137 return_VOID; 138 } 139 140 /******************************************************************************* 141 * 142 * FUNCTION: acpi_ut_check_address_range 143 * 144 * PARAMETERS: space_id - Address space ID 145 * address - Start address 146 * length - Length of address range 147 * warn - TRUE if warning on overlap desired 148 * 149 * RETURN: Count of the number of conflicts detected. Zero is always 150 * returned for Space IDs other than Memory or I/O. 151 * 152 * DESCRIPTION: Check if the input address range overlaps any of the 153 * ASL operation region address ranges. The only supported 154 * Space IDs are Memory and I/O. 155 * 156 * MUTEX: Assumes the namespace is locked. 157 * 158 ******************************************************************************/ 159 160 u32 161 acpi_ut_check_address_range(acpi_adr_space_type space_id, 162 acpi_physical_address address, u32 length, u8 warn) 163 { 164 struct acpi_address_range *range_info; 165 acpi_physical_address end_address; 166 char *pathname; 167 u32 overlap_count = 0; 168 169 ACPI_FUNCTION_TRACE(ut_check_address_range); 170 171 if ((space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY) && 172 (space_id != ACPI_ADR_SPACE_SYSTEM_IO)) { 173 return_UINT32(0); 174 } 175 176 range_info = acpi_gbl_address_range_list[space_id]; 177 end_address = address + length - 1; 178 179 /* Check entire list for all possible conflicts */ 180 181 while (range_info) { 182 /* 183 * Check if the requested address/length overlaps this 184 * address range. There are four cases to consider: 185 * 186 * 1) Input address/length is contained completely in the 187 * address range 188 * 2) Input address/length overlaps range at the range start 189 * 3) Input address/length overlaps range at the range end 190 * 4) Input address/length completely encompasses the range 191 */ 192 if ((address <= range_info->end_address) && 193 (end_address >= range_info->start_address)) { 194 195 /* Found an address range overlap */ 196 197 overlap_count++; 198 if (warn) { /* Optional warning message */ 199 pathname = 200 acpi_ns_get_normalized_pathname(range_info-> 201 region_node, 202 TRUE); 203 204 ACPI_WARNING((AE_INFO, 205 "%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)", 206 acpi_ut_get_region_name(space_id), 207 ACPI_FORMAT_UINT64(address), 208 ACPI_FORMAT_UINT64(end_address), 209 ACPI_FORMAT_UINT64(range_info-> 210 start_address), 211 ACPI_FORMAT_UINT64(range_info-> 212 end_address), 213 pathname)); 214 ACPI_FREE(pathname); 215 } 216 } 217 218 range_info = range_info->next; 219 } 220 221 return_UINT32(overlap_count); 222 } 223 224 /******************************************************************************* 225 * 226 * FUNCTION: acpi_ut_delete_address_lists 227 * 228 * PARAMETERS: None 229 * 230 * RETURN: None 231 * 232 * DESCRIPTION: Delete all global address range lists (called during 233 * subsystem shutdown). 234 * 235 ******************************************************************************/ 236 237 void acpi_ut_delete_address_lists(void) 238 { 239 struct acpi_address_range *next; 240 struct acpi_address_range *range_info; 241 int i; 242 243 /* Delete all elements in all address range lists */ 244 245 for (i = 0; i < ACPI_ADDRESS_RANGE_MAX; i++) { 246 next = acpi_gbl_address_range_list[i]; 247 248 while (next) { 249 range_info = next; 250 next = range_info->next; 251 ACPI_FREE(range_info); 252 } 253 254 acpi_gbl_address_range_list[i] = NULL; 255 } 256 } 257