1/******************************************************************************
2 *
3 * Module Name: utaddress - OpRegion address range check
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2023, 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 MERCHANTABILITY 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.h"
45#include "accommon.h"
46#include "acnamesp.h"
47
48
49#define _COMPONENT          ACPI_UTILITIES
50        ACPI_MODULE_NAME    ("utaddress")
51
52
53/*******************************************************************************
54 *
55 * FUNCTION:    AcpiUtAddAddressRange
56 *
57 * PARAMETERS:  SpaceId             - Address space ID
58 *              Address             - OpRegion start address
59 *              Length              - OpRegion length
60 *              RegionNode          - OpRegion namespace node
61 *
62 * RETURN:      Status
63 *
64 * DESCRIPTION: Add the Operation Region address range to the global list.
65 *              The only supported Space IDs are Memory and I/O. Called when
66 *              the OpRegion address/length operands are fully evaluated.
67 *
68 * MUTEX:       Locks the namespace
69 *
70 * NOTE: Because this interface is only called when an OpRegion argument
71 * list is evaluated, there cannot be any duplicate RegionNodes.
72 * Duplicate Address/Length values are allowed, however, so that multiple
73 * address conflicts can be detected.
74 *
75 ******************************************************************************/
76
77ACPI_STATUS
78AcpiUtAddAddressRange (
79    ACPI_ADR_SPACE_TYPE     SpaceId,
80    ACPI_PHYSICAL_ADDRESS   Address,
81    UINT32                  Length,
82    ACPI_NAMESPACE_NODE     *RegionNode)
83{
84    ACPI_ADDRESS_RANGE      *RangeInfo;
85
86
87    ACPI_FUNCTION_TRACE (UtAddAddressRange);
88
89
90    if ((SpaceId != ACPI_ADR_SPACE_SYSTEM_MEMORY) &&
91        (SpaceId != ACPI_ADR_SPACE_SYSTEM_IO))
92    {
93        return_ACPI_STATUS (AE_OK);
94    }
95
96    /* Allocate/init a new info block, add it to the appropriate list */
97
98    RangeInfo = ACPI_ALLOCATE (sizeof (ACPI_ADDRESS_RANGE));
99    if (!RangeInfo)
100    {
101        return_ACPI_STATUS (AE_NO_MEMORY);
102    }
103
104    RangeInfo->StartAddress = Address;
105    RangeInfo->EndAddress = (Address + Length - 1);
106    RangeInfo->RegionNode = RegionNode;
107
108    RangeInfo->Next = AcpiGbl_AddressRangeList[SpaceId];
109    AcpiGbl_AddressRangeList[SpaceId] = RangeInfo;
110
111    ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
112        "\nAdded [%4.4s] address range: 0x%8.8X%8.8X-0x%8.8X%8.8X\n",
113        AcpiUtGetNodeName (RangeInfo->RegionNode),
114        ACPI_FORMAT_UINT64 (Address),
115        ACPI_FORMAT_UINT64 (RangeInfo->EndAddress)));
116
117    return_ACPI_STATUS (AE_OK);
118}
119
120
121/*******************************************************************************
122 *
123 * FUNCTION:    AcpiUtRemoveAddressRange
124 *
125 * PARAMETERS:  SpaceId             - Address space ID
126 *              RegionNode          - OpRegion namespace node
127 *
128 * RETURN:      None
129 *
130 * DESCRIPTION: Remove the Operation Region from the global list. The only
131 *              supported Space IDs are Memory and I/O. Called when an
132 *              OpRegion is deleted.
133 *
134 * MUTEX:       Assumes the namespace is locked
135 *
136 ******************************************************************************/
137
138void
139AcpiUtRemoveAddressRange (
140    ACPI_ADR_SPACE_TYPE     SpaceId,
141    ACPI_NAMESPACE_NODE     *RegionNode)
142{
143    ACPI_ADDRESS_RANGE      *RangeInfo;
144    ACPI_ADDRESS_RANGE      *Prev;
145
146
147    ACPI_FUNCTION_TRACE (UtRemoveAddressRange);
148
149
150    if ((SpaceId != ACPI_ADR_SPACE_SYSTEM_MEMORY) &&
151        (SpaceId != ACPI_ADR_SPACE_SYSTEM_IO))
152    {
153        return_VOID;
154    }
155
156    /* Get the appropriate list head and check the list */
157
158    RangeInfo = Prev = AcpiGbl_AddressRangeList[SpaceId];
159    while (RangeInfo)
160    {
161        if (RangeInfo->RegionNode == RegionNode)
162        {
163            if (RangeInfo == Prev) /* Found at list head */
164            {
165                AcpiGbl_AddressRangeList[SpaceId] = RangeInfo->Next;
166            }
167            else
168            {
169                Prev->Next = RangeInfo->Next;
170            }
171
172            ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
173                "\nRemoved [%4.4s] address range: 0x%8.8X%8.8X-0x%8.8X%8.8X\n",
174                AcpiUtGetNodeName (RangeInfo->RegionNode),
175                ACPI_FORMAT_UINT64 (RangeInfo->StartAddress),
176                ACPI_FORMAT_UINT64 (RangeInfo->EndAddress)));
177
178            ACPI_FREE (RangeInfo);
179            return_VOID;
180        }
181
182        Prev = RangeInfo;
183        RangeInfo = RangeInfo->Next;
184    }
185
186    return_VOID;
187}
188
189
190/*******************************************************************************
191 *
192 * FUNCTION:    AcpiUtCheckAddressRange
193 *
194 * PARAMETERS:  SpaceId             - Address space ID
195 *              Address             - Start address
196 *              Length              - Length of address range
197 *              Warn                - TRUE if warning on overlap desired
198 *
199 * RETURN:      Count of the number of conflicts detected. Zero is always
200 *              returned for Space IDs other than Memory or I/O.
201 *
202 * DESCRIPTION: Check if the input address range overlaps any of the
203 *              ASL operation region address ranges. The only supported
204 *              Space IDs are Memory and I/O.
205 *
206 * MUTEX:       Assumes the namespace is locked.
207 *
208 ******************************************************************************/
209
210UINT32
211AcpiUtCheckAddressRange (
212    ACPI_ADR_SPACE_TYPE     SpaceId,
213    ACPI_PHYSICAL_ADDRESS   Address,
214    UINT32                  Length,
215    BOOLEAN                 Warn)
216{
217    ACPI_ADDRESS_RANGE      *RangeInfo;
218    ACPI_PHYSICAL_ADDRESS   EndAddress;
219    char                    *Pathname;
220    UINT32                  OverlapCount = 0;
221
222
223    ACPI_FUNCTION_TRACE (UtCheckAddressRange);
224
225
226    if ((SpaceId != ACPI_ADR_SPACE_SYSTEM_MEMORY) &&
227        (SpaceId != ACPI_ADR_SPACE_SYSTEM_IO))
228    {
229        return_UINT32 (0);
230    }
231
232    RangeInfo = AcpiGbl_AddressRangeList[SpaceId];
233    EndAddress = Address + Length - 1;
234
235    /* Check entire list for all possible conflicts */
236
237    while (RangeInfo)
238    {
239        /*
240         * Check if the requested address/length overlaps this
241         * address range. There are four cases to consider:
242         *
243         * 1) Input address/length is contained completely in the
244         *    address range
245         * 2) Input address/length overlaps range at the range start
246         * 3) Input address/length overlaps range at the range end
247         * 4) Input address/length completely encompasses the range
248         */
249        if ((Address <= RangeInfo->EndAddress) &&
250            (EndAddress >= RangeInfo->StartAddress))
251        {
252            /* Found an address range overlap */
253
254            OverlapCount++;
255            if (Warn)   /* Optional warning message */
256            {
257                Pathname = AcpiNsGetNormalizedPathname (RangeInfo->RegionNode, TRUE);
258
259                ACPI_WARNING ((AE_INFO,
260                    "%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)",
261                    AcpiUtGetRegionName (SpaceId),
262                    ACPI_FORMAT_UINT64 (Address),
263                    ACPI_FORMAT_UINT64 (EndAddress),
264                    ACPI_FORMAT_UINT64 (RangeInfo->StartAddress),
265                    ACPI_FORMAT_UINT64 (RangeInfo->EndAddress),
266                    Pathname));
267                ACPI_FREE (Pathname);
268            }
269        }
270
271        RangeInfo = RangeInfo->Next;
272    }
273
274    return_UINT32 (OverlapCount);
275}
276
277
278/*******************************************************************************
279 *
280 * FUNCTION:    AcpiUtDeleteAddressLists
281 *
282 * PARAMETERS:  None
283 *
284 * RETURN:      None
285 *
286 * DESCRIPTION: Delete all global address range lists (called during
287 *              subsystem shutdown).
288 *
289 ******************************************************************************/
290
291void
292AcpiUtDeleteAddressLists (
293    void)
294{
295    ACPI_ADDRESS_RANGE      *Next;
296    ACPI_ADDRESS_RANGE      *RangeInfo;
297    int                     i;
298
299
300    /* Delete all elements in all address range lists */
301
302    for (i = 0; i < ACPI_ADDRESS_RANGE_MAX; i++)
303    {
304        Next = AcpiGbl_AddressRangeList[i];
305
306        while (Next)
307        {
308            RangeInfo = Next;
309            Next = RangeInfo->Next;
310            ACPI_FREE (RangeInfo);
311        }
312
313        AcpiGbl_AddressRangeList[i] = NULL;
314    }
315}
316