1 /******************************************************************************
2 *
3 * Module Name: utaddress - op_region address range check
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2016, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
25 *
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
29 *
30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
43
44 #include <acpi/acpi.h>
45 #include "accommon.h"
46 #include "acnamesp.h"
47
48 #define _COMPONENT ACPI_UTILITIES
49 ACPI_MODULE_NAME("utaddress")
50
51 /*******************************************************************************
52 *
53 * FUNCTION: acpi_ut_add_address_range
54 *
55 * PARAMETERS: space_id - Address space ID
56 * address - op_region start address
57 * length - op_region length
58 * region_node - op_region namespace node
59 *
60 * RETURN: Status
61 *
62 * DESCRIPTION: Add the Operation Region address range to the global list.
63 * The only supported Space IDs are Memory and I/O. Called when
64 * the op_region address/length operands are fully evaluated.
65 *
66 * MUTEX: Locks the namespace
67 *
68 * NOTE: Because this interface is only called when an op_region argument
69 * list is evaluated, there cannot be any duplicate region_nodes.
70 * Duplicate Address/Length values are allowed, however, so that multiple
71 * address conflicts can be detected.
72 *
73 ******************************************************************************/
74 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)75 acpi_ut_add_address_range(acpi_adr_space_type space_id,
76 acpi_physical_address address,
77 u32 length, struct acpi_namespace_node *region_node)
78 {
79 struct acpi_address_range *range_info;
80
81 ACPI_FUNCTION_TRACE(ut_add_address_range);
82
83 if ((space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY) &&
84 (space_id != ACPI_ADR_SPACE_SYSTEM_IO)) {
85 return_ACPI_STATUS(AE_OK);
86 }
87
88 /* Allocate/init a new info block, add it to the appropriate list */
89
90 range_info = ACPI_ALLOCATE(sizeof(struct acpi_address_range));
91 if (!range_info) {
92 return_ACPI_STATUS(AE_NO_MEMORY);
93 }
94
95 range_info->start_address = address;
96 range_info->end_address = (address + length - 1);
97 range_info->region_node = region_node;
98
99 range_info->next = acpi_gbl_address_range_list[space_id];
100 acpi_gbl_address_range_list[space_id] = range_info;
101
102 ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
103 "\nAdded [%4.4s] address range: 0x%8.8X%8.8X-0x%8.8X%8.8X\n",
104 acpi_ut_get_node_name(range_info->region_node),
105 ACPI_FORMAT_UINT64(address),
106 ACPI_FORMAT_UINT64(range_info->end_address)));
107
108 return_ACPI_STATUS(AE_OK);
109 }
110
111 /*******************************************************************************
112 *
113 * FUNCTION: acpi_ut_remove_address_range
114 *
115 * PARAMETERS: space_id - Address space ID
116 * region_node - op_region namespace node
117 *
118 * RETURN: None
119 *
120 * DESCRIPTION: Remove the Operation Region from the global list. The only
121 * supported Space IDs are Memory and I/O. Called when an
122 * op_region is deleted.
123 *
124 * MUTEX: Assumes the namespace is locked
125 *
126 ******************************************************************************/
127
128 void
acpi_ut_remove_address_range(acpi_adr_space_type space_id,struct acpi_namespace_node * region_node)129 acpi_ut_remove_address_range(acpi_adr_space_type space_id,
130 struct acpi_namespace_node *region_node)
131 {
132 struct acpi_address_range *range_info;
133 struct acpi_address_range *prev;
134
135 ACPI_FUNCTION_TRACE(ut_remove_address_range);
136
137 if ((space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY) &&
138 (space_id != ACPI_ADR_SPACE_SYSTEM_IO)) {
139 return_VOID;
140 }
141
142 /* Get the appropriate list head and check the list */
143
144 range_info = prev = acpi_gbl_address_range_list[space_id];
145 while (range_info) {
146 if (range_info->region_node == region_node) {
147 if (range_info == prev) { /* Found at list head */
148 acpi_gbl_address_range_list[space_id] =
149 range_info->next;
150 } else {
151 prev->next = range_info->next;
152 }
153
154 ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
155 "\nRemoved [%4.4s] address range: 0x%8.8X%8.8X-0x%8.8X%8.8X\n",
156 acpi_ut_get_node_name(range_info->
157 region_node),
158 ACPI_FORMAT_UINT64(range_info->
159 start_address),
160 ACPI_FORMAT_UINT64(range_info->
161 end_address)));
162
163 ACPI_FREE(range_info);
164 return_VOID;
165 }
166
167 prev = range_info;
168 range_info = range_info->next;
169 }
170
171 return_VOID;
172 }
173
174 /*******************************************************************************
175 *
176 * FUNCTION: acpi_ut_check_address_range
177 *
178 * PARAMETERS: space_id - Address space ID
179 * address - Start address
180 * length - Length of address range
181 * warn - TRUE if warning on overlap desired
182 *
183 * RETURN: Count of the number of conflicts detected. Zero is always
184 * returned for Space IDs other than Memory or I/O.
185 *
186 * DESCRIPTION: Check if the input address range overlaps any of the
187 * ASL operation region address ranges. The only supported
188 * Space IDs are Memory and I/O.
189 *
190 * MUTEX: Assumes the namespace is locked.
191 *
192 ******************************************************************************/
193
194 u32
acpi_ut_check_address_range(acpi_adr_space_type space_id,acpi_physical_address address,u32 length,u8 warn)195 acpi_ut_check_address_range(acpi_adr_space_type space_id,
196 acpi_physical_address address, u32 length, u8 warn)
197 {
198 struct acpi_address_range *range_info;
199 acpi_physical_address end_address;
200 char *pathname;
201 u32 overlap_count = 0;
202
203 ACPI_FUNCTION_TRACE(ut_check_address_range);
204
205 if ((space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY) &&
206 (space_id != ACPI_ADR_SPACE_SYSTEM_IO)) {
207 return_UINT32(0);
208 }
209
210 range_info = acpi_gbl_address_range_list[space_id];
211 end_address = address + length - 1;
212
213 /* Check entire list for all possible conflicts */
214
215 while (range_info) {
216 /*
217 * Check if the requested address/length overlaps this
218 * address range. There are four cases to consider:
219 *
220 * 1) Input address/length is contained completely in the
221 * address range
222 * 2) Input address/length overlaps range at the range start
223 * 3) Input address/length overlaps range at the range end
224 * 4) Input address/length completely encompasses the range
225 */
226 if ((address <= range_info->end_address) &&
227 (end_address >= range_info->start_address)) {
228
229 /* Found an address range overlap */
230
231 overlap_count++;
232 if (warn) { /* Optional warning message */
233 pathname =
234 acpi_ns_get_normalized_pathname(range_info->
235 region_node,
236 TRUE);
237
238 ACPI_WARNING((AE_INFO,
239 "%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)",
240 acpi_ut_get_region_name(space_id),
241 ACPI_FORMAT_UINT64(address),
242 ACPI_FORMAT_UINT64(end_address),
243 ACPI_FORMAT_UINT64(range_info->
244 start_address),
245 ACPI_FORMAT_UINT64(range_info->
246 end_address),
247 pathname));
248 ACPI_FREE(pathname);
249 }
250 }
251
252 range_info = range_info->next;
253 }
254
255 return_UINT32(overlap_count);
256 }
257
258 /*******************************************************************************
259 *
260 * FUNCTION: acpi_ut_delete_address_lists
261 *
262 * PARAMETERS: None
263 *
264 * RETURN: None
265 *
266 * DESCRIPTION: Delete all global address range lists (called during
267 * subsystem shutdown).
268 *
269 ******************************************************************************/
270
acpi_ut_delete_address_lists(void)271 void acpi_ut_delete_address_lists(void)
272 {
273 struct acpi_address_range *next;
274 struct acpi_address_range *range_info;
275 int i;
276
277 /* Delete all elements in all address range lists */
278
279 for (i = 0; i < ACPI_ADDRESS_RANGE_MAX; i++) {
280 next = acpi_gbl_address_range_list[i];
281
282 while (next) {
283 range_info = next;
284 next = range_info->next;
285 ACPI_FREE(range_info);
286 }
287
288 acpi_gbl_address_range_list[i] = NULL;
289 }
290 }
291