xref: /titanic_44/usr/src/uts/intel/io/acpica/resources/rsaddr.c (revision f38cb554a534c6df738be3f4d23327e69888e634)
1 /*******************************************************************************
2  *
3  * Module Name: rsaddr - Address resource descriptors (16/32/64)
4  *
5  ******************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2011, 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 #define __RSADDR_C__
45 
46 #include "acpi.h"
47 #include "accommon.h"
48 #include "acresrc.h"
49 
50 #define _COMPONENT          ACPI_RESOURCES
51         ACPI_MODULE_NAME    ("rsaddr")
52 
53 
54 /*******************************************************************************
55  *
56  * AcpiRsConvertAddress16 - All WORD (16-bit) address resources
57  *
58  ******************************************************************************/
59 
60 ACPI_RSCONVERT_INFO     AcpiRsConvertAddress16[5] =
61 {
62     {ACPI_RSC_INITGET,  ACPI_RESOURCE_TYPE_ADDRESS16,
63                         ACPI_RS_SIZE (ACPI_RESOURCE_ADDRESS16),
64                         ACPI_RSC_TABLE_SIZE (AcpiRsConvertAddress16)},
65 
66     {ACPI_RSC_INITSET,  ACPI_RESOURCE_NAME_ADDRESS16,
67                         sizeof (AML_RESOURCE_ADDRESS16),
68                         0},
69 
70     /* Resource Type, General Flags, and Type-Specific Flags */
71 
72     {ACPI_RSC_ADDRESS,  0, 0, 0},
73 
74     /*
75      * These fields are contiguous in both the source and destination:
76      * Address Granularity
77      * Address Range Minimum
78      * Address Range Maximum
79      * Address Translation Offset
80      * Address Length
81      */
82     {ACPI_RSC_MOVE16,   ACPI_RS_OFFSET (Data.Address16.Granularity),
83                         AML_OFFSET (Address16.Granularity),
84                         5},
85 
86     /* Optional ResourceSource (Index and String) */
87 
88     {ACPI_RSC_SOURCE,   ACPI_RS_OFFSET (Data.Address16.ResourceSource),
89                         0,
90                         sizeof (AML_RESOURCE_ADDRESS16)}
91 };
92 
93 
94 /*******************************************************************************
95  *
96  * AcpiRsConvertAddress32 - All DWORD (32-bit) address resources
97  *
98  ******************************************************************************/
99 
100 ACPI_RSCONVERT_INFO     AcpiRsConvertAddress32[5] =
101 {
102     {ACPI_RSC_INITGET,  ACPI_RESOURCE_TYPE_ADDRESS32,
103                         ACPI_RS_SIZE (ACPI_RESOURCE_ADDRESS32),
104                         ACPI_RSC_TABLE_SIZE (AcpiRsConvertAddress32)},
105 
106     {ACPI_RSC_INITSET,  ACPI_RESOURCE_NAME_ADDRESS32,
107                         sizeof (AML_RESOURCE_ADDRESS32),
108                         0},
109 
110     /* Resource Type, General Flags, and Type-Specific Flags */
111 
112     {ACPI_RSC_ADDRESS,  0, 0, 0},
113 
114     /*
115      * These fields are contiguous in both the source and destination:
116      * Address Granularity
117      * Address Range Minimum
118      * Address Range Maximum
119      * Address Translation Offset
120      * Address Length
121      */
122     {ACPI_RSC_MOVE32,   ACPI_RS_OFFSET (Data.Address32.Granularity),
123                         AML_OFFSET (Address32.Granularity),
124                         5},
125 
126     /* Optional ResourceSource (Index and String) */
127 
128     {ACPI_RSC_SOURCE,   ACPI_RS_OFFSET (Data.Address32.ResourceSource),
129                         0,
130                         sizeof (AML_RESOURCE_ADDRESS32)}
131 };
132 
133 
134 /*******************************************************************************
135  *
136  * AcpiRsConvertAddress64 - All QWORD (64-bit) address resources
137  *
138  ******************************************************************************/
139 
140 ACPI_RSCONVERT_INFO     AcpiRsConvertAddress64[5] =
141 {
142     {ACPI_RSC_INITGET,  ACPI_RESOURCE_TYPE_ADDRESS64,
143                         ACPI_RS_SIZE (ACPI_RESOURCE_ADDRESS64),
144                         ACPI_RSC_TABLE_SIZE (AcpiRsConvertAddress64)},
145 
146     {ACPI_RSC_INITSET,  ACPI_RESOURCE_NAME_ADDRESS64,
147                         sizeof (AML_RESOURCE_ADDRESS64),
148                         0},
149 
150     /* Resource Type, General Flags, and Type-Specific Flags */
151 
152     {ACPI_RSC_ADDRESS,  0, 0, 0},
153 
154     /*
155      * These fields are contiguous in both the source and destination:
156      * Address Granularity
157      * Address Range Minimum
158      * Address Range Maximum
159      * Address Translation Offset
160      * Address Length
161      */
162     {ACPI_RSC_MOVE64,   ACPI_RS_OFFSET (Data.Address64.Granularity),
163                         AML_OFFSET (Address64.Granularity),
164                         5},
165 
166     /* Optional ResourceSource (Index and String) */
167 
168     {ACPI_RSC_SOURCE,   ACPI_RS_OFFSET (Data.Address64.ResourceSource),
169                         0,
170                         sizeof (AML_RESOURCE_ADDRESS64)}
171 };
172 
173 
174 /*******************************************************************************
175  *
176  * AcpiRsConvertExtAddress64 - All Extended (64-bit) address resources
177  *
178  ******************************************************************************/
179 
180 ACPI_RSCONVERT_INFO     AcpiRsConvertExtAddress64[5] =
181 {
182     {ACPI_RSC_INITGET,  ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64,
183                         ACPI_RS_SIZE (ACPI_RESOURCE_EXTENDED_ADDRESS64),
184                         ACPI_RSC_TABLE_SIZE (AcpiRsConvertExtAddress64)},
185 
186     {ACPI_RSC_INITSET,  ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64,
187                         sizeof (AML_RESOURCE_EXTENDED_ADDRESS64),
188                         0},
189 
190     /* Resource Type, General Flags, and Type-Specific Flags */
191 
192     {ACPI_RSC_ADDRESS,  0, 0, 0},
193 
194     /* Revision ID */
195 
196     {ACPI_RSC_MOVE8,    ACPI_RS_OFFSET (Data.ExtAddress64.RevisionID),
197                         AML_OFFSET (ExtAddress64.RevisionID),
198                         1},
199     /*
200      * These fields are contiguous in both the source and destination:
201      * Address Granularity
202      * Address Range Minimum
203      * Address Range Maximum
204      * Address Translation Offset
205      * Address Length
206      * Type-Specific Attribute
207      */
208     {ACPI_RSC_MOVE64,   ACPI_RS_OFFSET (Data.ExtAddress64.Granularity),
209                         AML_OFFSET (ExtAddress64.Granularity),
210                         6}
211 };
212 
213 
214 /*******************************************************************************
215  *
216  * AcpiRsConvertGeneralFlags - Flags common to all address descriptors
217  *
218  ******************************************************************************/
219 
220 static ACPI_RSCONVERT_INFO  AcpiRsConvertGeneralFlags[6] =
221 {
222     {ACPI_RSC_FLAGINIT, 0, AML_OFFSET (Address.Flags),
223                         ACPI_RSC_TABLE_SIZE (AcpiRsConvertGeneralFlags)},
224 
225     /* Resource Type (Memory, Io, BusNumber, etc.) */
226 
227     {ACPI_RSC_MOVE8,    ACPI_RS_OFFSET (Data.Address.ResourceType),
228                         AML_OFFSET (Address.ResourceType),
229                         1},
230 
231     /* General Flags - Consume, Decode, MinFixed, MaxFixed */
232 
233     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET (Data.Address.ProducerConsumer),
234                         AML_OFFSET (Address.Flags),
235                         0},
236 
237     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET (Data.Address.Decode),
238                         AML_OFFSET (Address.Flags),
239                         1},
240 
241     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET (Data.Address.MinAddressFixed),
242                         AML_OFFSET (Address.Flags),
243                         2},
244 
245     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET (Data.Address.MaxAddressFixed),
246                         AML_OFFSET (Address.Flags),
247                         3}
248 };
249 
250 
251 /*******************************************************************************
252  *
253  * AcpiRsConvertMemFlags - Flags common to Memory address descriptors
254  *
255  ******************************************************************************/
256 
257 static ACPI_RSCONVERT_INFO  AcpiRsConvertMemFlags[5] =
258 {
259     {ACPI_RSC_FLAGINIT, 0, AML_OFFSET (Address.SpecificFlags),
260                         ACPI_RSC_TABLE_SIZE (AcpiRsConvertMemFlags)},
261 
262     /* Memory-specific flags */
263 
264     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET (Data.Address.Info.Mem.WriteProtect),
265                         AML_OFFSET (Address.SpecificFlags),
266                         0},
267 
268     {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET (Data.Address.Info.Mem.Caching),
269                         AML_OFFSET (Address.SpecificFlags),
270                         1},
271 
272     {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET (Data.Address.Info.Mem.RangeType),
273                         AML_OFFSET (Address.SpecificFlags),
274                         3},
275 
276     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET (Data.Address.Info.Mem.Translation),
277                         AML_OFFSET (Address.SpecificFlags),
278                         5}
279 };
280 
281 
282 /*******************************************************************************
283  *
284  * AcpiRsConvertIoFlags - Flags common to I/O address descriptors
285  *
286  ******************************************************************************/
287 
288 static ACPI_RSCONVERT_INFO  AcpiRsConvertIoFlags[4] =
289 {
290     {ACPI_RSC_FLAGINIT, 0, AML_OFFSET (Address.SpecificFlags),
291                         ACPI_RSC_TABLE_SIZE (AcpiRsConvertIoFlags)},
292 
293     /* I/O-specific flags */
294 
295     {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET (Data.Address.Info.Io.RangeType),
296                         AML_OFFSET (Address.SpecificFlags),
297                         0},
298 
299     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET (Data.Address.Info.Io.Translation),
300                         AML_OFFSET (Address.SpecificFlags),
301                         4},
302 
303     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET (Data.Address.Info.Io.TranslationType),
304                         AML_OFFSET (Address.SpecificFlags),
305                         5}
306 };
307 
308 
309 /*******************************************************************************
310  *
311  * FUNCTION:    AcpiRsGetAddressCommon
312  *
313  * PARAMETERS:  Resource            - Pointer to the internal resource struct
314  *              Aml                 - Pointer to the AML resource descriptor
315  *
316  * RETURN:      TRUE if the ResourceType field is OK, FALSE otherwise
317  *
318  * DESCRIPTION: Convert common flag fields from a raw AML resource descriptor
319  *              to an internal resource descriptor
320  *
321  ******************************************************************************/
322 
323 BOOLEAN
324 AcpiRsGetAddressCommon (
325     ACPI_RESOURCE           *Resource,
326     AML_RESOURCE            *Aml)
327 {
328     ACPI_FUNCTION_ENTRY ();
329 
330 
331     /* Validate the Resource Type */
332 
333     if ((Aml->Address.ResourceType > 2) && (Aml->Address.ResourceType < 0xC0))
334     {
335         return (FALSE);
336     }
337 
338     /* Get the Resource Type and General Flags */
339 
340     (void) AcpiRsConvertAmlToResource (Resource, Aml, AcpiRsConvertGeneralFlags);
341 
342     /* Get the Type-Specific Flags (Memory and I/O descriptors only) */
343 
344     if (Resource->Data.Address.ResourceType == ACPI_MEMORY_RANGE)
345     {
346         (void) AcpiRsConvertAmlToResource (Resource, Aml, AcpiRsConvertMemFlags);
347     }
348     else if (Resource->Data.Address.ResourceType == ACPI_IO_RANGE)
349     {
350         (void) AcpiRsConvertAmlToResource (Resource, Aml, AcpiRsConvertIoFlags);
351     }
352     else
353     {
354         /* Generic resource type, just grab the TypeSpecific byte */
355 
356         Resource->Data.Address.Info.TypeSpecific = Aml->Address.SpecificFlags;
357     }
358 
359     return (TRUE);
360 }
361 
362 
363 /*******************************************************************************
364  *
365  * FUNCTION:    AcpiRsSetAddressCommon
366  *
367  * PARAMETERS:  Aml                 - Pointer to the AML resource descriptor
368  *              Resource            - Pointer to the internal resource struct
369  *
370  * RETURN:      None
371  *
372  * DESCRIPTION: Convert common flag fields from a resource descriptor to an
373  *              AML descriptor
374  *
375  ******************************************************************************/
376 
377 void
378 AcpiRsSetAddressCommon (
379     AML_RESOURCE            *Aml,
380     ACPI_RESOURCE           *Resource)
381 {
382     ACPI_FUNCTION_ENTRY ();
383 
384 
385     /* Set the Resource Type and General Flags */
386 
387     (void) AcpiRsConvertResourceToAml (Resource, Aml, AcpiRsConvertGeneralFlags);
388 
389     /* Set the Type-Specific Flags (Memory and I/O descriptors only) */
390 
391     if (Resource->Data.Address.ResourceType == ACPI_MEMORY_RANGE)
392     {
393         (void) AcpiRsConvertResourceToAml (Resource, Aml, AcpiRsConvertMemFlags);
394     }
395     else if (Resource->Data.Address.ResourceType == ACPI_IO_RANGE)
396     {
397         (void) AcpiRsConvertResourceToAml (Resource, Aml, AcpiRsConvertIoFlags);
398     }
399     else
400     {
401         /* Generic resource type, just copy the TypeSpecific byte */
402 
403         Aml->Address.SpecificFlags = Resource->Data.Address.Info.TypeSpecific;
404     }
405 }
406 
407 
408