1/*******************************************************************************
2 *
3 * Module Name: utresrc - Resource management utilities
4 *
5 ******************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2012, 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
45#define __UTRESRC_C__
46
47#include <contrib/dev/acpica/include/acpi.h>
48#include <contrib/dev/acpica/include/accommon.h>
49#include <contrib/dev/acpica/include/acresrc.h>
50
51
52#define _COMPONENT ACPI_UTILITIES
53 ACPI_MODULE_NAME ("utresrc")
54
55
56#if defined(ACPI_DISASSEMBLER) || defined (ACPI_DEBUGGER)
57
58/*
59 * Strings used to decode resource descriptors.
60 * Used by both the disassembler and the debugger resource dump routines
61 */
62const char *AcpiGbl_BmDecode[] =
63{
64 "NotBusMaster",
65 "BusMaster"
66};
67
68const char *AcpiGbl_ConfigDecode[] =
69{
70 "0 - Good Configuration",
71 "1 - Acceptable Configuration",
72 "2 - Suboptimal Configuration",
73 "3 - ***Invalid Configuration***",
74};
75
76const char *AcpiGbl_ConsumeDecode[] =
77{
78 "ResourceProducer",
79 "ResourceConsumer"
80};
81
82const char *AcpiGbl_DecDecode[] =
83{
84 "PosDecode",
85 "SubDecode"
86};
87
88const char *AcpiGbl_HeDecode[] =
89{
90 "Level",
91 "Edge"
92};
93
94const char *AcpiGbl_IoDecode[] =
95{
96 "Decode10",
97 "Decode16"
98};
99
100const char *AcpiGbl_LlDecode[] =
101{
102 "ActiveHigh",
103 "ActiveLow"
104};
105
106const char *AcpiGbl_MaxDecode[] =
107{
108 "MaxNotFixed",
109 "MaxFixed"
110};
111
112const char *AcpiGbl_MemDecode[] =
113{
114 "NonCacheable",
115 "Cacheable",
116 "WriteCombining",
117 "Prefetchable"
118};
119
120const char *AcpiGbl_MinDecode[] =
121{
122 "MinNotFixed",
123 "MinFixed"
124};
125
126const char *AcpiGbl_MtpDecode[] =
127{
128 "AddressRangeMemory",
129 "AddressRangeReserved",
130 "AddressRangeACPI",
131 "AddressRangeNVS"
132};
133
134const char *AcpiGbl_RngDecode[] =
135{
136 "InvalidRanges",
137 "NonISAOnlyRanges",
138 "ISAOnlyRanges",
139 "EntireRange"
140};
141
142const char *AcpiGbl_RwDecode[] =
143{
144 "ReadOnly",
145 "ReadWrite"
146};
147
148const char *AcpiGbl_ShrDecode[] =
149{
150 "Exclusive",
| 1/*******************************************************************************
2 *
3 * Module Name: utresrc - Resource management utilities
4 *
5 ******************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2012, 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
45#define __UTRESRC_C__
46
47#include <contrib/dev/acpica/include/acpi.h>
48#include <contrib/dev/acpica/include/accommon.h>
49#include <contrib/dev/acpica/include/acresrc.h>
50
51
52#define _COMPONENT ACPI_UTILITIES
53 ACPI_MODULE_NAME ("utresrc")
54
55
56#if defined(ACPI_DISASSEMBLER) || defined (ACPI_DEBUGGER)
57
58/*
59 * Strings used to decode resource descriptors.
60 * Used by both the disassembler and the debugger resource dump routines
61 */
62const char *AcpiGbl_BmDecode[] =
63{
64 "NotBusMaster",
65 "BusMaster"
66};
67
68const char *AcpiGbl_ConfigDecode[] =
69{
70 "0 - Good Configuration",
71 "1 - Acceptable Configuration",
72 "2 - Suboptimal Configuration",
73 "3 - ***Invalid Configuration***",
74};
75
76const char *AcpiGbl_ConsumeDecode[] =
77{
78 "ResourceProducer",
79 "ResourceConsumer"
80};
81
82const char *AcpiGbl_DecDecode[] =
83{
84 "PosDecode",
85 "SubDecode"
86};
87
88const char *AcpiGbl_HeDecode[] =
89{
90 "Level",
91 "Edge"
92};
93
94const char *AcpiGbl_IoDecode[] =
95{
96 "Decode10",
97 "Decode16"
98};
99
100const char *AcpiGbl_LlDecode[] =
101{
102 "ActiveHigh",
103 "ActiveLow"
104};
105
106const char *AcpiGbl_MaxDecode[] =
107{
108 "MaxNotFixed",
109 "MaxFixed"
110};
111
112const char *AcpiGbl_MemDecode[] =
113{
114 "NonCacheable",
115 "Cacheable",
116 "WriteCombining",
117 "Prefetchable"
118};
119
120const char *AcpiGbl_MinDecode[] =
121{
122 "MinNotFixed",
123 "MinFixed"
124};
125
126const char *AcpiGbl_MtpDecode[] =
127{
128 "AddressRangeMemory",
129 "AddressRangeReserved",
130 "AddressRangeACPI",
131 "AddressRangeNVS"
132};
133
134const char *AcpiGbl_RngDecode[] =
135{
136 "InvalidRanges",
137 "NonISAOnlyRanges",
138 "ISAOnlyRanges",
139 "EntireRange"
140};
141
142const char *AcpiGbl_RwDecode[] =
143{
144 "ReadOnly",
145 "ReadWrite"
146};
147
148const char *AcpiGbl_ShrDecode[] =
149{
150 "Exclusive",
|
151 "Shared"
| 151 "Shared",
152 "ExclusiveAndWake", /* ACPI 5.0 */
153 "SharedAndWake" /* ACPI 5.0 */
|
152};
153
154const char *AcpiGbl_SizDecode[] =
155{
156 "Transfer8",
157 "Transfer8_16",
158 "Transfer16",
159 "InvalidSize"
160};
161
162const char *AcpiGbl_TrsDecode[] =
163{
164 "DenseTranslation",
165 "SparseTranslation"
166};
167
168const char *AcpiGbl_TtpDecode[] =
169{
170 "TypeStatic",
171 "TypeTranslation"
172};
173
174const char *AcpiGbl_TypDecode[] =
175{
176 "Compatibility",
177 "TypeA",
178 "TypeB",
179 "TypeF"
180};
181
182const char *AcpiGbl_PpcDecode[] =
183{
184 "PullDefault",
185 "PullUp",
186 "PullDown",
187 "PullNone"
188};
189
190const char *AcpiGbl_IorDecode[] =
191{
192 "IoRestrictionNone",
193 "IoRestrictionInputOnly",
194 "IoRestrictionOutputOnly",
195 "IoRestrictionNoneAndPreserve"
196};
197
198const char *AcpiGbl_DtsDecode[] =
199{
200 "Width8bit",
201 "Width16bit",
202 "Width32bit",
203 "Width64bit",
204 "Width128bit",
205 "Width256bit",
206};
207
208/* GPIO connection type */
209
210const char *AcpiGbl_CtDecode[] =
211{
212 "Interrupt",
213 "I/O"
214};
215
216/* Serial bus type */
217
218const char *AcpiGbl_SbtDecode[] =
219{
220 "/* UNKNOWN serial bus type */",
221 "I2C",
222 "SPI",
223 "UART"
224};
225
226/* I2C serial bus access mode */
227
228const char *AcpiGbl_AmDecode[] =
229{
230 "AddressingMode7Bit",
231 "AddressingMode10Bit"
232};
233
234/* I2C serial bus slave mode */
235
236const char *AcpiGbl_SmDecode[] =
237{
238 "ControllerInitiated",
239 "DeviceInitiated"
240};
241
242/* SPI serial bus wire mode */
243
244const char *AcpiGbl_WmDecode[] =
245{
246 "FourWireMode",
247 "ThreeWireMode"
248};
249
250/* SPI serial clock phase */
251
252const char *AcpiGbl_CphDecode[] =
253{
254 "ClockPhaseFirst",
255 "ClockPhaseSecond"
256};
257
258/* SPI serial bus clock polarity */
259
260const char *AcpiGbl_CpoDecode[] =
261{
262 "ClockPolarityLow",
263 "ClockPolarityHigh"
264};
265
266/* SPI serial bus device polarity */
267
268const char *AcpiGbl_DpDecode[] =
269{
270 "PolarityLow",
271 "PolarityHigh"
272};
273
274/* UART serial bus endian */
275
276const char *AcpiGbl_EdDecode[] =
277{
278 "LittleEndian",
279 "BigEndian"
280};
281
282/* UART serial bus bits per byte */
283
284const char *AcpiGbl_BpbDecode[] =
285{
286 "DataBitsFive",
287 "DataBitsSix",
288 "DataBitsSeven",
289 "DataBitsEight",
290 "DataBitsNine",
291 "/* UNKNOWN Bits per byte */",
292 "/* UNKNOWN Bits per byte */",
293 "/* UNKNOWN Bits per byte */"
294};
295
296/* UART serial bus stop bits */
297
298const char *AcpiGbl_SbDecode[] =
299{
300 "StopBitsNone",
301 "StopBitsOne",
302 "StopBitsOnePlusHalf",
303 "StopBitsTwo"
304};
305
306/* UART serial bus flow control */
307
308const char *AcpiGbl_FcDecode[] =
309{
310 "FlowControlNone",
311 "FlowControlHardware",
312 "FlowControlXON",
313 "/* UNKNOWN flow control keyword */"
314};
315
316/* UART serial bus parity type */
317
318const char *AcpiGbl_PtDecode[] =
319{
320 "ParityTypeNone",
321 "ParityTypeEven",
322 "ParityTypeOdd",
323 "ParityTypeMark",
324 "ParityTypeSpace",
325 "/* UNKNOWN parity keyword */",
326 "/* UNKNOWN parity keyword */",
327 "/* UNKNOWN parity keyword */"
328};
329
330#endif
331
332
333/*
334 * Base sizes of the raw AML resource descriptors, indexed by resource type.
335 * Zero indicates a reserved (and therefore invalid) resource type.
336 */
337const UINT8 AcpiGbl_ResourceAmlSizes[] =
338{
339 /* Small descriptors */
340
341 0,
342 0,
343 0,
344 0,
345 ACPI_AML_SIZE_SMALL (AML_RESOURCE_IRQ),
346 ACPI_AML_SIZE_SMALL (AML_RESOURCE_DMA),
347 ACPI_AML_SIZE_SMALL (AML_RESOURCE_START_DEPENDENT),
348 ACPI_AML_SIZE_SMALL (AML_RESOURCE_END_DEPENDENT),
349 ACPI_AML_SIZE_SMALL (AML_RESOURCE_IO),
350 ACPI_AML_SIZE_SMALL (AML_RESOURCE_FIXED_IO),
351 ACPI_AML_SIZE_SMALL (AML_RESOURCE_FIXED_DMA),
352 0,
353 0,
354 0,
355 ACPI_AML_SIZE_SMALL (AML_RESOURCE_VENDOR_SMALL),
356 ACPI_AML_SIZE_SMALL (AML_RESOURCE_END_TAG),
357
358 /* Large descriptors */
359
360 0,
361 ACPI_AML_SIZE_LARGE (AML_RESOURCE_MEMORY24),
362 ACPI_AML_SIZE_LARGE (AML_RESOURCE_GENERIC_REGISTER),
363 0,
364 ACPI_AML_SIZE_LARGE (AML_RESOURCE_VENDOR_LARGE),
365 ACPI_AML_SIZE_LARGE (AML_RESOURCE_MEMORY32),
366 ACPI_AML_SIZE_LARGE (AML_RESOURCE_FIXED_MEMORY32),
367 ACPI_AML_SIZE_LARGE (AML_RESOURCE_ADDRESS32),
368 ACPI_AML_SIZE_LARGE (AML_RESOURCE_ADDRESS16),
369 ACPI_AML_SIZE_LARGE (AML_RESOURCE_EXTENDED_IRQ),
370 ACPI_AML_SIZE_LARGE (AML_RESOURCE_ADDRESS64),
371 ACPI_AML_SIZE_LARGE (AML_RESOURCE_EXTENDED_ADDRESS64),
372 ACPI_AML_SIZE_LARGE (AML_RESOURCE_GPIO),
373 0,
374 ACPI_AML_SIZE_LARGE (AML_RESOURCE_COMMON_SERIALBUS),
375};
376
377const UINT8 AcpiGbl_ResourceAmlSerialBusSizes[] =
378{
379 0,
380 ACPI_AML_SIZE_LARGE (AML_RESOURCE_I2C_SERIALBUS),
381 ACPI_AML_SIZE_LARGE (AML_RESOURCE_SPI_SERIALBUS),
382 ACPI_AML_SIZE_LARGE (AML_RESOURCE_UART_SERIALBUS),
383};
384
385
386/*
387 * Resource types, used to validate the resource length field.
388 * The length of fixed-length types must match exactly, variable
389 * lengths must meet the minimum required length, etc.
390 * Zero indicates a reserved (and therefore invalid) resource type.
391 */
392static const UINT8 AcpiGbl_ResourceTypes[] =
393{
394 /* Small descriptors */
395
396 0,
397 0,
398 0,
399 0,
400 ACPI_SMALL_VARIABLE_LENGTH, /* 04 IRQ */
401 ACPI_FIXED_LENGTH, /* 05 DMA */
402 ACPI_SMALL_VARIABLE_LENGTH, /* 06 StartDependentFunctions */
403 ACPI_FIXED_LENGTH, /* 07 EndDependentFunctions */
404 ACPI_FIXED_LENGTH, /* 08 IO */
405 ACPI_FIXED_LENGTH, /* 09 FixedIO */
406 ACPI_FIXED_LENGTH, /* 0A FixedDMA */
407 0,
408 0,
409 0,
410 ACPI_VARIABLE_LENGTH, /* 0E VendorShort */
411 ACPI_FIXED_LENGTH, /* 0F EndTag */
412
413 /* Large descriptors */
414
415 0,
416 ACPI_FIXED_LENGTH, /* 01 Memory24 */
417 ACPI_FIXED_LENGTH, /* 02 GenericRegister */
418 0,
419 ACPI_VARIABLE_LENGTH, /* 04 VendorLong */
420 ACPI_FIXED_LENGTH, /* 05 Memory32 */
421 ACPI_FIXED_LENGTH, /* 06 Memory32Fixed */
422 ACPI_VARIABLE_LENGTH, /* 07 Dword* address */
423 ACPI_VARIABLE_LENGTH, /* 08 Word* address */
424 ACPI_VARIABLE_LENGTH, /* 09 ExtendedIRQ */
425 ACPI_VARIABLE_LENGTH, /* 0A Qword* address */
426 ACPI_FIXED_LENGTH, /* 0B Extended* address */
427 ACPI_VARIABLE_LENGTH, /* 0C Gpio* */
428 0,
429 ACPI_VARIABLE_LENGTH /* 0E *SerialBus */
430};
431
| 154};
155
156const char *AcpiGbl_SizDecode[] =
157{
158 "Transfer8",
159 "Transfer8_16",
160 "Transfer16",
161 "InvalidSize"
162};
163
164const char *AcpiGbl_TrsDecode[] =
165{
166 "DenseTranslation",
167 "SparseTranslation"
168};
169
170const char *AcpiGbl_TtpDecode[] =
171{
172 "TypeStatic",
173 "TypeTranslation"
174};
175
176const char *AcpiGbl_TypDecode[] =
177{
178 "Compatibility",
179 "TypeA",
180 "TypeB",
181 "TypeF"
182};
183
184const char *AcpiGbl_PpcDecode[] =
185{
186 "PullDefault",
187 "PullUp",
188 "PullDown",
189 "PullNone"
190};
191
192const char *AcpiGbl_IorDecode[] =
193{
194 "IoRestrictionNone",
195 "IoRestrictionInputOnly",
196 "IoRestrictionOutputOnly",
197 "IoRestrictionNoneAndPreserve"
198};
199
200const char *AcpiGbl_DtsDecode[] =
201{
202 "Width8bit",
203 "Width16bit",
204 "Width32bit",
205 "Width64bit",
206 "Width128bit",
207 "Width256bit",
208};
209
210/* GPIO connection type */
211
212const char *AcpiGbl_CtDecode[] =
213{
214 "Interrupt",
215 "I/O"
216};
217
218/* Serial bus type */
219
220const char *AcpiGbl_SbtDecode[] =
221{
222 "/* UNKNOWN serial bus type */",
223 "I2C",
224 "SPI",
225 "UART"
226};
227
228/* I2C serial bus access mode */
229
230const char *AcpiGbl_AmDecode[] =
231{
232 "AddressingMode7Bit",
233 "AddressingMode10Bit"
234};
235
236/* I2C serial bus slave mode */
237
238const char *AcpiGbl_SmDecode[] =
239{
240 "ControllerInitiated",
241 "DeviceInitiated"
242};
243
244/* SPI serial bus wire mode */
245
246const char *AcpiGbl_WmDecode[] =
247{
248 "FourWireMode",
249 "ThreeWireMode"
250};
251
252/* SPI serial clock phase */
253
254const char *AcpiGbl_CphDecode[] =
255{
256 "ClockPhaseFirst",
257 "ClockPhaseSecond"
258};
259
260/* SPI serial bus clock polarity */
261
262const char *AcpiGbl_CpoDecode[] =
263{
264 "ClockPolarityLow",
265 "ClockPolarityHigh"
266};
267
268/* SPI serial bus device polarity */
269
270const char *AcpiGbl_DpDecode[] =
271{
272 "PolarityLow",
273 "PolarityHigh"
274};
275
276/* UART serial bus endian */
277
278const char *AcpiGbl_EdDecode[] =
279{
280 "LittleEndian",
281 "BigEndian"
282};
283
284/* UART serial bus bits per byte */
285
286const char *AcpiGbl_BpbDecode[] =
287{
288 "DataBitsFive",
289 "DataBitsSix",
290 "DataBitsSeven",
291 "DataBitsEight",
292 "DataBitsNine",
293 "/* UNKNOWN Bits per byte */",
294 "/* UNKNOWN Bits per byte */",
295 "/* UNKNOWN Bits per byte */"
296};
297
298/* UART serial bus stop bits */
299
300const char *AcpiGbl_SbDecode[] =
301{
302 "StopBitsNone",
303 "StopBitsOne",
304 "StopBitsOnePlusHalf",
305 "StopBitsTwo"
306};
307
308/* UART serial bus flow control */
309
310const char *AcpiGbl_FcDecode[] =
311{
312 "FlowControlNone",
313 "FlowControlHardware",
314 "FlowControlXON",
315 "/* UNKNOWN flow control keyword */"
316};
317
318/* UART serial bus parity type */
319
320const char *AcpiGbl_PtDecode[] =
321{
322 "ParityTypeNone",
323 "ParityTypeEven",
324 "ParityTypeOdd",
325 "ParityTypeMark",
326 "ParityTypeSpace",
327 "/* UNKNOWN parity keyword */",
328 "/* UNKNOWN parity keyword */",
329 "/* UNKNOWN parity keyword */"
330};
331
332#endif
333
334
335/*
336 * Base sizes of the raw AML resource descriptors, indexed by resource type.
337 * Zero indicates a reserved (and therefore invalid) resource type.
338 */
339const UINT8 AcpiGbl_ResourceAmlSizes[] =
340{
341 /* Small descriptors */
342
343 0,
344 0,
345 0,
346 0,
347 ACPI_AML_SIZE_SMALL (AML_RESOURCE_IRQ),
348 ACPI_AML_SIZE_SMALL (AML_RESOURCE_DMA),
349 ACPI_AML_SIZE_SMALL (AML_RESOURCE_START_DEPENDENT),
350 ACPI_AML_SIZE_SMALL (AML_RESOURCE_END_DEPENDENT),
351 ACPI_AML_SIZE_SMALL (AML_RESOURCE_IO),
352 ACPI_AML_SIZE_SMALL (AML_RESOURCE_FIXED_IO),
353 ACPI_AML_SIZE_SMALL (AML_RESOURCE_FIXED_DMA),
354 0,
355 0,
356 0,
357 ACPI_AML_SIZE_SMALL (AML_RESOURCE_VENDOR_SMALL),
358 ACPI_AML_SIZE_SMALL (AML_RESOURCE_END_TAG),
359
360 /* Large descriptors */
361
362 0,
363 ACPI_AML_SIZE_LARGE (AML_RESOURCE_MEMORY24),
364 ACPI_AML_SIZE_LARGE (AML_RESOURCE_GENERIC_REGISTER),
365 0,
366 ACPI_AML_SIZE_LARGE (AML_RESOURCE_VENDOR_LARGE),
367 ACPI_AML_SIZE_LARGE (AML_RESOURCE_MEMORY32),
368 ACPI_AML_SIZE_LARGE (AML_RESOURCE_FIXED_MEMORY32),
369 ACPI_AML_SIZE_LARGE (AML_RESOURCE_ADDRESS32),
370 ACPI_AML_SIZE_LARGE (AML_RESOURCE_ADDRESS16),
371 ACPI_AML_SIZE_LARGE (AML_RESOURCE_EXTENDED_IRQ),
372 ACPI_AML_SIZE_LARGE (AML_RESOURCE_ADDRESS64),
373 ACPI_AML_SIZE_LARGE (AML_RESOURCE_EXTENDED_ADDRESS64),
374 ACPI_AML_SIZE_LARGE (AML_RESOURCE_GPIO),
375 0,
376 ACPI_AML_SIZE_LARGE (AML_RESOURCE_COMMON_SERIALBUS),
377};
378
379const UINT8 AcpiGbl_ResourceAmlSerialBusSizes[] =
380{
381 0,
382 ACPI_AML_SIZE_LARGE (AML_RESOURCE_I2C_SERIALBUS),
383 ACPI_AML_SIZE_LARGE (AML_RESOURCE_SPI_SERIALBUS),
384 ACPI_AML_SIZE_LARGE (AML_RESOURCE_UART_SERIALBUS),
385};
386
387
388/*
389 * Resource types, used to validate the resource length field.
390 * The length of fixed-length types must match exactly, variable
391 * lengths must meet the minimum required length, etc.
392 * Zero indicates a reserved (and therefore invalid) resource type.
393 */
394static const UINT8 AcpiGbl_ResourceTypes[] =
395{
396 /* Small descriptors */
397
398 0,
399 0,
400 0,
401 0,
402 ACPI_SMALL_VARIABLE_LENGTH, /* 04 IRQ */
403 ACPI_FIXED_LENGTH, /* 05 DMA */
404 ACPI_SMALL_VARIABLE_LENGTH, /* 06 StartDependentFunctions */
405 ACPI_FIXED_LENGTH, /* 07 EndDependentFunctions */
406 ACPI_FIXED_LENGTH, /* 08 IO */
407 ACPI_FIXED_LENGTH, /* 09 FixedIO */
408 ACPI_FIXED_LENGTH, /* 0A FixedDMA */
409 0,
410 0,
411 0,
412 ACPI_VARIABLE_LENGTH, /* 0E VendorShort */
413 ACPI_FIXED_LENGTH, /* 0F EndTag */
414
415 /* Large descriptors */
416
417 0,
418 ACPI_FIXED_LENGTH, /* 01 Memory24 */
419 ACPI_FIXED_LENGTH, /* 02 GenericRegister */
420 0,
421 ACPI_VARIABLE_LENGTH, /* 04 VendorLong */
422 ACPI_FIXED_LENGTH, /* 05 Memory32 */
423 ACPI_FIXED_LENGTH, /* 06 Memory32Fixed */
424 ACPI_VARIABLE_LENGTH, /* 07 Dword* address */
425 ACPI_VARIABLE_LENGTH, /* 08 Word* address */
426 ACPI_VARIABLE_LENGTH, /* 09 ExtendedIRQ */
427 ACPI_VARIABLE_LENGTH, /* 0A Qword* address */
428 ACPI_FIXED_LENGTH, /* 0B Extended* address */
429 ACPI_VARIABLE_LENGTH, /* 0C Gpio* */
430 0,
431 ACPI_VARIABLE_LENGTH /* 0E *SerialBus */
432};
433
|
432/*
433 * For the iASL compiler/disassembler, we don't want any error messages
434 * because the disassembler uses the resource validation code to determine
435 * if Buffer objects are actually Resource Templates.
436 */
437#ifdef ACPI_ASL_COMPILER
438#define ACPI_RESOURCE_ERROR(plist)
439#else
440#define ACPI_RESOURCE_ERROR(plist) ACPI_ERROR(plist)
441#endif
| |
442
| 434
|
443
| |
444/*******************************************************************************
445 *
446 * FUNCTION: AcpiUtWalkAmlResources
447 *
| 435/*******************************************************************************
436 *
437 * FUNCTION: AcpiUtWalkAmlResources
438 *
|
448 * PARAMETERS: Aml - Pointer to the raw AML resource template
449 * AmlLength - Length of the entire template
450 * UserFunction - Called once for each descriptor found. If
451 * NULL, a pointer to the EndTag is returned
452 * Context - Passed to UserFunction
| 439 * PARAMETERS: WalkState - Current walk info
440 * PARAMETERS: Aml - Pointer to the raw AML resource template
441 * AmlLength - Length of the entire template
442 * UserFunction - Called once for each descriptor found. If
443 * NULL, a pointer to the EndTag is returned
444 * Context - Passed to UserFunction
|
453 *
454 * RETURN: Status
455 *
456 * DESCRIPTION: Walk a raw AML resource list(buffer). User function called
457 * once for each resource found.
458 *
459 ******************************************************************************/
460
461ACPI_STATUS
462AcpiUtWalkAmlResources (
| 445 *
446 * RETURN: Status
447 *
448 * DESCRIPTION: Walk a raw AML resource list(buffer). User function called
449 * once for each resource found.
450 *
451 ******************************************************************************/
452
453ACPI_STATUS
454AcpiUtWalkAmlResources (
|
| 455 ACPI_WALK_STATE *WalkState,
|
463 UINT8 *Aml,
464 ACPI_SIZE AmlLength,
465 ACPI_WALK_AML_CALLBACK UserFunction,
466 void *Context)
467{
468 ACPI_STATUS Status;
469 UINT8 *EndAml;
470 UINT8 ResourceIndex;
471 UINT32 Length;
472 UINT32 Offset = 0;
473 UINT8 EndTag[2] = {0x79, 0x00};
474
475
476 ACPI_FUNCTION_TRACE (UtWalkAmlResources);
477
478
479 /* The absolute minimum resource template is one EndTag descriptor */
480
481 if (AmlLength < sizeof (AML_RESOURCE_END_TAG))
482 {
483 return_ACPI_STATUS (AE_AML_NO_RESOURCE_END_TAG);
484 }
485
486 /* Point to the end of the resource template buffer */
487
488 EndAml = Aml + AmlLength;
489
490 /* Walk the byte list, abort on any invalid descriptor type or length */
491
492 while (Aml < EndAml)
493 {
494 /* Validate the Resource Type and Resource Length */
495
| 456 UINT8 *Aml,
457 ACPI_SIZE AmlLength,
458 ACPI_WALK_AML_CALLBACK UserFunction,
459 void *Context)
460{
461 ACPI_STATUS Status;
462 UINT8 *EndAml;
463 UINT8 ResourceIndex;
464 UINT32 Length;
465 UINT32 Offset = 0;
466 UINT8 EndTag[2] = {0x79, 0x00};
467
468
469 ACPI_FUNCTION_TRACE (UtWalkAmlResources);
470
471
472 /* The absolute minimum resource template is one EndTag descriptor */
473
474 if (AmlLength < sizeof (AML_RESOURCE_END_TAG))
475 {
476 return_ACPI_STATUS (AE_AML_NO_RESOURCE_END_TAG);
477 }
478
479 /* Point to the end of the resource template buffer */
480
481 EndAml = Aml + AmlLength;
482
483 /* Walk the byte list, abort on any invalid descriptor type or length */
484
485 while (Aml < EndAml)
486 {
487 /* Validate the Resource Type and Resource Length */
488
|
496 Status = AcpiUtValidateResource (Aml, &ResourceIndex);
| 489 Status = AcpiUtValidateResource (WalkState, Aml, &ResourceIndex);
|
497 if (ACPI_FAILURE (Status))
498 {
499 /*
500 * Exit on failure. Cannot continue because the descriptor length
501 * may be bogus also.
502 */
503 return_ACPI_STATUS (Status);
504 }
505
506 /* Get the length of this descriptor */
507
508 Length = AcpiUtGetDescriptorLength (Aml);
509
510 /* Invoke the user function */
511
512 if (UserFunction)
513 {
514 Status = UserFunction (Aml, Length, Offset, ResourceIndex, Context);
515 if (ACPI_FAILURE (Status))
516 {
517 return_ACPI_STATUS (Status);
518 }
519 }
520
521 /* An EndTag descriptor terminates this resource template */
522
523 if (AcpiUtGetResourceType (Aml) == ACPI_RESOURCE_NAME_END_TAG)
524 {
525 /*
526 * There must be at least one more byte in the buffer for
527 * the 2nd byte of the EndTag
528 */
529 if ((Aml + 1) >= EndAml)
530 {
531 return_ACPI_STATUS (AE_AML_NO_RESOURCE_END_TAG);
532 }
533
534 /* Return the pointer to the EndTag if requested */
535
536 if (!UserFunction)
537 {
538 *(void **) Context = Aml;
539 }
540
541 /* Normal exit */
542
543 return_ACPI_STATUS (AE_OK);
544 }
545
546 Aml += Length;
547 Offset += Length;
548 }
549
550 /* Did not find an EndTag descriptor */
551
552 if (UserFunction)
553 {
554 /* Insert an EndTag anyway. AcpiRsGetListLength always leaves room */
555
| 490 if (ACPI_FAILURE (Status))
491 {
492 /*
493 * Exit on failure. Cannot continue because the descriptor length
494 * may be bogus also.
495 */
496 return_ACPI_STATUS (Status);
497 }
498
499 /* Get the length of this descriptor */
500
501 Length = AcpiUtGetDescriptorLength (Aml);
502
503 /* Invoke the user function */
504
505 if (UserFunction)
506 {
507 Status = UserFunction (Aml, Length, Offset, ResourceIndex, Context);
508 if (ACPI_FAILURE (Status))
509 {
510 return_ACPI_STATUS (Status);
511 }
512 }
513
514 /* An EndTag descriptor terminates this resource template */
515
516 if (AcpiUtGetResourceType (Aml) == ACPI_RESOURCE_NAME_END_TAG)
517 {
518 /*
519 * There must be at least one more byte in the buffer for
520 * the 2nd byte of the EndTag
521 */
522 if ((Aml + 1) >= EndAml)
523 {
524 return_ACPI_STATUS (AE_AML_NO_RESOURCE_END_TAG);
525 }
526
527 /* Return the pointer to the EndTag if requested */
528
529 if (!UserFunction)
530 {
531 *(void **) Context = Aml;
532 }
533
534 /* Normal exit */
535
536 return_ACPI_STATUS (AE_OK);
537 }
538
539 Aml += Length;
540 Offset += Length;
541 }
542
543 /* Did not find an EndTag descriptor */
544
545 if (UserFunction)
546 {
547 /* Insert an EndTag anyway. AcpiRsGetListLength always leaves room */
548
|
556 (void) AcpiUtValidateResource (EndTag, &ResourceIndex);
| 549 (void) AcpiUtValidateResource (WalkState, EndTag, &ResourceIndex);
|
557 Status = UserFunction (EndTag, 2, Offset, ResourceIndex, Context);
558 if (ACPI_FAILURE (Status))
559 {
560 return_ACPI_STATUS (Status);
561 }
562 }
563
564 return_ACPI_STATUS (AE_AML_NO_RESOURCE_END_TAG);
565}
566
567
568/*******************************************************************************
569 *
570 * FUNCTION: AcpiUtValidateResource
571 *
| 550 Status = UserFunction (EndTag, 2, Offset, ResourceIndex, Context);
551 if (ACPI_FAILURE (Status))
552 {
553 return_ACPI_STATUS (Status);
554 }
555 }
556
557 return_ACPI_STATUS (AE_AML_NO_RESOURCE_END_TAG);
558}
559
560
561/*******************************************************************************
562 *
563 * FUNCTION: AcpiUtValidateResource
564 *
|
572 * PARAMETERS: Aml - Pointer to the raw AML resource descriptor
573 * ReturnIndex - Where the resource index is returned. NULL
574 * if the index is not required.
| 565 * PARAMETERS: WalkState - Current walk info
566 * Aml - Pointer to the raw AML resource descriptor
567 * ReturnIndex - Where the resource index is returned. NULL
568 * if the index is not required.
|
575 *
576 * RETURN: Status, and optionally the Index into the global resource tables
577 *
578 * DESCRIPTION: Validate an AML resource descriptor by checking the Resource
579 * Type and Resource Length. Returns an index into the global
580 * resource information/dispatch tables for later use.
581 *
582 ******************************************************************************/
583
584ACPI_STATUS
585AcpiUtValidateResource (
| 569 *
570 * RETURN: Status, and optionally the Index into the global resource tables
571 *
572 * DESCRIPTION: Validate an AML resource descriptor by checking the Resource
573 * Type and Resource Length. Returns an index into the global
574 * resource information/dispatch tables for later use.
575 *
576 ******************************************************************************/
577
578ACPI_STATUS
579AcpiUtValidateResource (
|
| 580 ACPI_WALK_STATE *WalkState,
|
586 void *Aml,
587 UINT8 *ReturnIndex)
588{
589 AML_RESOURCE *AmlResource;
590 UINT8 ResourceType;
591 UINT8 ResourceIndex;
592 ACPI_RS_LENGTH ResourceLength;
593 ACPI_RS_LENGTH MinimumResourceLength;
594
595
596 ACPI_FUNCTION_ENTRY ();
597
598
599 /*
600 * 1) Validate the ResourceType field (Byte 0)
601 */
602 ResourceType = ACPI_GET8 (Aml);
603
604 /*
605 * Byte 0 contains the descriptor name (Resource Type)
606 * Examine the large/small bit in the resource header
607 */
608 if (ResourceType & ACPI_RESOURCE_NAME_LARGE)
609 {
610 /* Verify the large resource type (name) against the max */
611
612 if (ResourceType > ACPI_RESOURCE_NAME_LARGE_MAX)
613 {
614 goto InvalidResource;
615 }
616
617 /*
618 * Large Resource Type -- bits 6:0 contain the name
619 * Translate range 0x80-0x8B to index range 0x10-0x1B
620 */
621 ResourceIndex = (UINT8) (ResourceType - 0x70);
622 }
623 else
624 {
625 /*
626 * Small Resource Type -- bits 6:3 contain the name
627 * Shift range to index range 0x00-0x0F
628 */
629 ResourceIndex = (UINT8)
630 ((ResourceType & ACPI_RESOURCE_NAME_SMALL_MASK) >> 3);
631 }
632
633 /*
634 * Check validity of the resource type, via AcpiGbl_ResourceTypes. Zero
635 * indicates an invalid resource.
636 */
637 if (!AcpiGbl_ResourceTypes[ResourceIndex])
638 {
639 goto InvalidResource;
640 }
641
642 /*
643 * Validate the ResourceLength field. This ensures that the length
644 * is at least reasonable, and guarantees that it is non-zero.
645 */
646 ResourceLength = AcpiUtGetResourceLength (Aml);
647 MinimumResourceLength = AcpiGbl_ResourceAmlSizes[ResourceIndex];
648
649 /* Validate based upon the type of resource - fixed length or variable */
650
651 switch (AcpiGbl_ResourceTypes[ResourceIndex])
652 {
653 case ACPI_FIXED_LENGTH:
654
655 /* Fixed length resource, length must match exactly */
656
657 if (ResourceLength != MinimumResourceLength)
658 {
659 goto BadResourceLength;
660 }
661 break;
662
663 case ACPI_VARIABLE_LENGTH:
664
665 /* Variable length resource, length must be at least the minimum */
666
667 if (ResourceLength < MinimumResourceLength)
668 {
669 goto BadResourceLength;
670 }
671 break;
672
673 case ACPI_SMALL_VARIABLE_LENGTH:
674
675 /* Small variable length resource, length can be (Min) or (Min-1) */
676
677 if ((ResourceLength > MinimumResourceLength) ||
678 (ResourceLength < (MinimumResourceLength - 1)))
679 {
680 goto BadResourceLength;
681 }
682 break;
683
684 default:
685
686 /* Shouldn't happen (because of validation earlier), but be sure */
687
688 goto InvalidResource;
689 }
690
691 AmlResource = ACPI_CAST_PTR (AML_RESOURCE, Aml);
692 if (ResourceType == ACPI_RESOURCE_NAME_SERIAL_BUS)
693 {
694 /* Validate the BusType field */
695
696 if ((AmlResource->CommonSerialBus.Type == 0) ||
697 (AmlResource->CommonSerialBus.Type > AML_RESOURCE_MAX_SERIALBUSTYPE))
698 {
| 581 void *Aml,
582 UINT8 *ReturnIndex)
583{
584 AML_RESOURCE *AmlResource;
585 UINT8 ResourceType;
586 UINT8 ResourceIndex;
587 ACPI_RS_LENGTH ResourceLength;
588 ACPI_RS_LENGTH MinimumResourceLength;
589
590
591 ACPI_FUNCTION_ENTRY ();
592
593
594 /*
595 * 1) Validate the ResourceType field (Byte 0)
596 */
597 ResourceType = ACPI_GET8 (Aml);
598
599 /*
600 * Byte 0 contains the descriptor name (Resource Type)
601 * Examine the large/small bit in the resource header
602 */
603 if (ResourceType & ACPI_RESOURCE_NAME_LARGE)
604 {
605 /* Verify the large resource type (name) against the max */
606
607 if (ResourceType > ACPI_RESOURCE_NAME_LARGE_MAX)
608 {
609 goto InvalidResource;
610 }
611
612 /*
613 * Large Resource Type -- bits 6:0 contain the name
614 * Translate range 0x80-0x8B to index range 0x10-0x1B
615 */
616 ResourceIndex = (UINT8) (ResourceType - 0x70);
617 }
618 else
619 {
620 /*
621 * Small Resource Type -- bits 6:3 contain the name
622 * Shift range to index range 0x00-0x0F
623 */
624 ResourceIndex = (UINT8)
625 ((ResourceType & ACPI_RESOURCE_NAME_SMALL_MASK) >> 3);
626 }
627
628 /*
629 * Check validity of the resource type, via AcpiGbl_ResourceTypes. Zero
630 * indicates an invalid resource.
631 */
632 if (!AcpiGbl_ResourceTypes[ResourceIndex])
633 {
634 goto InvalidResource;
635 }
636
637 /*
638 * Validate the ResourceLength field. This ensures that the length
639 * is at least reasonable, and guarantees that it is non-zero.
640 */
641 ResourceLength = AcpiUtGetResourceLength (Aml);
642 MinimumResourceLength = AcpiGbl_ResourceAmlSizes[ResourceIndex];
643
644 /* Validate based upon the type of resource - fixed length or variable */
645
646 switch (AcpiGbl_ResourceTypes[ResourceIndex])
647 {
648 case ACPI_FIXED_LENGTH:
649
650 /* Fixed length resource, length must match exactly */
651
652 if (ResourceLength != MinimumResourceLength)
653 {
654 goto BadResourceLength;
655 }
656 break;
657
658 case ACPI_VARIABLE_LENGTH:
659
660 /* Variable length resource, length must be at least the minimum */
661
662 if (ResourceLength < MinimumResourceLength)
663 {
664 goto BadResourceLength;
665 }
666 break;
667
668 case ACPI_SMALL_VARIABLE_LENGTH:
669
670 /* Small variable length resource, length can be (Min) or (Min-1) */
671
672 if ((ResourceLength > MinimumResourceLength) ||
673 (ResourceLength < (MinimumResourceLength - 1)))
674 {
675 goto BadResourceLength;
676 }
677 break;
678
679 default:
680
681 /* Shouldn't happen (because of validation earlier), but be sure */
682
683 goto InvalidResource;
684 }
685
686 AmlResource = ACPI_CAST_PTR (AML_RESOURCE, Aml);
687 if (ResourceType == ACPI_RESOURCE_NAME_SERIAL_BUS)
688 {
689 /* Validate the BusType field */
690
691 if ((AmlResource->CommonSerialBus.Type == 0) ||
692 (AmlResource->CommonSerialBus.Type > AML_RESOURCE_MAX_SERIALBUSTYPE))
693 {
|
699 ACPI_RESOURCE_ERROR ((AE_INFO,
700 "Invalid/unsupported SerialBus resource descriptor: BusType 0x%2.2X",
701 AmlResource->CommonSerialBus.Type));
| 694 if (WalkState)
695 {
696 ACPI_ERROR ((AE_INFO,
697 "Invalid/unsupported SerialBus resource descriptor: BusType 0x%2.2X",
698 AmlResource->CommonSerialBus.Type));
699 }
|
702 return (AE_AML_INVALID_RESOURCE_TYPE);
703 }
704 }
705
706 /* Optionally return the resource table index */
707
708 if (ReturnIndex)
709 {
710 *ReturnIndex = ResourceIndex;
711 }
712
713 return (AE_OK);
714
715
716InvalidResource:
717
| 700 return (AE_AML_INVALID_RESOURCE_TYPE);
701 }
702 }
703
704 /* Optionally return the resource table index */
705
706 if (ReturnIndex)
707 {
708 *ReturnIndex = ResourceIndex;
709 }
710
711 return (AE_OK);
712
713
714InvalidResource:
715
|
718 ACPI_RESOURCE_ERROR ((AE_INFO,
719 "Invalid/unsupported resource descriptor: Type 0x%2.2X",
720 ResourceType));
| 716 if (WalkState)
717 {
718 ACPI_ERROR ((AE_INFO,
719 "Invalid/unsupported resource descriptor: Type 0x%2.2X",
720 ResourceType));
721 }
|
721 return (AE_AML_INVALID_RESOURCE_TYPE);
722
723BadResourceLength:
724
| 722 return (AE_AML_INVALID_RESOURCE_TYPE);
723
724BadResourceLength:
725
|
725 ACPI_RESOURCE_ERROR ((AE_INFO,
726 "Invalid resource descriptor length: Type "
727 "0x%2.2X, Length 0x%4.4X, MinLength 0x%4.4X",
728 ResourceType, ResourceLength, MinimumResourceLength));
| 726 if (WalkState)
727 {
728 ACPI_ERROR ((AE_INFO,
729 "Invalid resource descriptor length: Type "
730 "0x%2.2X, Length 0x%4.4X, MinLength 0x%4.4X",
731 ResourceType, ResourceLength, MinimumResourceLength));
732 }
|
729 return (AE_AML_BAD_RESOURCE_LENGTH);
730}
731
732
733/*******************************************************************************
734 *
735 * FUNCTION: AcpiUtGetResourceType
736 *
737 * PARAMETERS: Aml - Pointer to the raw AML resource descriptor
738 *
739 * RETURN: The Resource Type with no extraneous bits (except the
740 * Large/Small descriptor bit -- this is left alone)
741 *
742 * DESCRIPTION: Extract the Resource Type/Name from the first byte of
743 * a resource descriptor.
744 *
745 ******************************************************************************/
746
747UINT8
748AcpiUtGetResourceType (
749 void *Aml)
750{
751 ACPI_FUNCTION_ENTRY ();
752
753
754 /*
755 * Byte 0 contains the descriptor name (Resource Type)
756 * Examine the large/small bit in the resource header
757 */
758 if (ACPI_GET8 (Aml) & ACPI_RESOURCE_NAME_LARGE)
759 {
760 /* Large Resource Type -- bits 6:0 contain the name */
761
762 return (ACPI_GET8 (Aml));
763 }
764 else
765 {
766 /* Small Resource Type -- bits 6:3 contain the name */
767
768 return ((UINT8) (ACPI_GET8 (Aml) & ACPI_RESOURCE_NAME_SMALL_MASK));
769 }
770}
771
772
773/*******************************************************************************
774 *
775 * FUNCTION: AcpiUtGetResourceLength
776 *
777 * PARAMETERS: Aml - Pointer to the raw AML resource descriptor
778 *
779 * RETURN: Byte Length
780 *
781 * DESCRIPTION: Get the "Resource Length" of a raw AML descriptor. By
782 * definition, this does not include the size of the descriptor
783 * header or the length field itself.
784 *
785 ******************************************************************************/
786
787UINT16
788AcpiUtGetResourceLength (
789 void *Aml)
790{
791 ACPI_RS_LENGTH ResourceLength;
792
793
794 ACPI_FUNCTION_ENTRY ();
795
796
797 /*
798 * Byte 0 contains the descriptor name (Resource Type)
799 * Examine the large/small bit in the resource header
800 */
801 if (ACPI_GET8 (Aml) & ACPI_RESOURCE_NAME_LARGE)
802 {
803 /* Large Resource type -- bytes 1-2 contain the 16-bit length */
804
805 ACPI_MOVE_16_TO_16 (&ResourceLength, ACPI_ADD_PTR (UINT8, Aml, 1));
806
807 }
808 else
809 {
810 /* Small Resource type -- bits 2:0 of byte 0 contain the length */
811
812 ResourceLength = (UINT16) (ACPI_GET8 (Aml) &
813 ACPI_RESOURCE_NAME_SMALL_LENGTH_MASK);
814 }
815
816 return (ResourceLength);
817}
818
819
820/*******************************************************************************
821 *
822 * FUNCTION: AcpiUtGetResourceHeaderLength
823 *
824 * PARAMETERS: Aml - Pointer to the raw AML resource descriptor
825 *
826 * RETURN: Length of the AML header (depends on large/small descriptor)
827 *
828 * DESCRIPTION: Get the length of the header for this resource.
829 *
830 ******************************************************************************/
831
832UINT8
833AcpiUtGetResourceHeaderLength (
834 void *Aml)
835{
836 ACPI_FUNCTION_ENTRY ();
837
838
839 /* Examine the large/small bit in the resource header */
840
841 if (ACPI_GET8 (Aml) & ACPI_RESOURCE_NAME_LARGE)
842 {
843 return (sizeof (AML_RESOURCE_LARGE_HEADER));
844 }
845 else
846 {
847 return (sizeof (AML_RESOURCE_SMALL_HEADER));
848 }
849}
850
851
852/*******************************************************************************
853 *
854 * FUNCTION: AcpiUtGetDescriptorLength
855 *
856 * PARAMETERS: Aml - Pointer to the raw AML resource descriptor
857 *
858 * RETURN: Byte length
859 *
860 * DESCRIPTION: Get the total byte length of a raw AML descriptor, including the
861 * length of the descriptor header and the length field itself.
862 * Used to walk descriptor lists.
863 *
864 ******************************************************************************/
865
866UINT32
867AcpiUtGetDescriptorLength (
868 void *Aml)
869{
870 ACPI_FUNCTION_ENTRY ();
871
872
873 /*
874 * Get the Resource Length (does not include header length) and add
875 * the header length (depends on if this is a small or large resource)
876 */
877 return (AcpiUtGetResourceLength (Aml) +
878 AcpiUtGetResourceHeaderLength (Aml));
879}
880
881
882/*******************************************************************************
883 *
884 * FUNCTION: AcpiUtGetResourceEndTag
885 *
886 * PARAMETERS: ObjDesc - The resource template buffer object
887 * EndTag - Where the pointer to the EndTag is returned
888 *
889 * RETURN: Status, pointer to the end tag
890 *
891 * DESCRIPTION: Find the EndTag resource descriptor in an AML resource template
892 * Note: allows a buffer length of zero.
893 *
894 ******************************************************************************/
895
896ACPI_STATUS
897AcpiUtGetResourceEndTag (
898 ACPI_OPERAND_OBJECT *ObjDesc,
899 UINT8 **EndTag)
900{
901 ACPI_STATUS Status;
902
903
904 ACPI_FUNCTION_TRACE (UtGetResourceEndTag);
905
906
907 /* Allow a buffer length of zero */
908
909 if (!ObjDesc->Buffer.Length)
910 {
911 *EndTag = ObjDesc->Buffer.Pointer;
912 return_ACPI_STATUS (AE_OK);
913 }
914
915 /* Validate the template and get a pointer to the EndTag */
916
| 733 return (AE_AML_BAD_RESOURCE_LENGTH);
734}
735
736
737/*******************************************************************************
738 *
739 * FUNCTION: AcpiUtGetResourceType
740 *
741 * PARAMETERS: Aml - Pointer to the raw AML resource descriptor
742 *
743 * RETURN: The Resource Type with no extraneous bits (except the
744 * Large/Small descriptor bit -- this is left alone)
745 *
746 * DESCRIPTION: Extract the Resource Type/Name from the first byte of
747 * a resource descriptor.
748 *
749 ******************************************************************************/
750
751UINT8
752AcpiUtGetResourceType (
753 void *Aml)
754{
755 ACPI_FUNCTION_ENTRY ();
756
757
758 /*
759 * Byte 0 contains the descriptor name (Resource Type)
760 * Examine the large/small bit in the resource header
761 */
762 if (ACPI_GET8 (Aml) & ACPI_RESOURCE_NAME_LARGE)
763 {
764 /* Large Resource Type -- bits 6:0 contain the name */
765
766 return (ACPI_GET8 (Aml));
767 }
768 else
769 {
770 /* Small Resource Type -- bits 6:3 contain the name */
771
772 return ((UINT8) (ACPI_GET8 (Aml) & ACPI_RESOURCE_NAME_SMALL_MASK));
773 }
774}
775
776
777/*******************************************************************************
778 *
779 * FUNCTION: AcpiUtGetResourceLength
780 *
781 * PARAMETERS: Aml - Pointer to the raw AML resource descriptor
782 *
783 * RETURN: Byte Length
784 *
785 * DESCRIPTION: Get the "Resource Length" of a raw AML descriptor. By
786 * definition, this does not include the size of the descriptor
787 * header or the length field itself.
788 *
789 ******************************************************************************/
790
791UINT16
792AcpiUtGetResourceLength (
793 void *Aml)
794{
795 ACPI_RS_LENGTH ResourceLength;
796
797
798 ACPI_FUNCTION_ENTRY ();
799
800
801 /*
802 * Byte 0 contains the descriptor name (Resource Type)
803 * Examine the large/small bit in the resource header
804 */
805 if (ACPI_GET8 (Aml) & ACPI_RESOURCE_NAME_LARGE)
806 {
807 /* Large Resource type -- bytes 1-2 contain the 16-bit length */
808
809 ACPI_MOVE_16_TO_16 (&ResourceLength, ACPI_ADD_PTR (UINT8, Aml, 1));
810
811 }
812 else
813 {
814 /* Small Resource type -- bits 2:0 of byte 0 contain the length */
815
816 ResourceLength = (UINT16) (ACPI_GET8 (Aml) &
817 ACPI_RESOURCE_NAME_SMALL_LENGTH_MASK);
818 }
819
820 return (ResourceLength);
821}
822
823
824/*******************************************************************************
825 *
826 * FUNCTION: AcpiUtGetResourceHeaderLength
827 *
828 * PARAMETERS: Aml - Pointer to the raw AML resource descriptor
829 *
830 * RETURN: Length of the AML header (depends on large/small descriptor)
831 *
832 * DESCRIPTION: Get the length of the header for this resource.
833 *
834 ******************************************************************************/
835
836UINT8
837AcpiUtGetResourceHeaderLength (
838 void *Aml)
839{
840 ACPI_FUNCTION_ENTRY ();
841
842
843 /* Examine the large/small bit in the resource header */
844
845 if (ACPI_GET8 (Aml) & ACPI_RESOURCE_NAME_LARGE)
846 {
847 return (sizeof (AML_RESOURCE_LARGE_HEADER));
848 }
849 else
850 {
851 return (sizeof (AML_RESOURCE_SMALL_HEADER));
852 }
853}
854
855
856/*******************************************************************************
857 *
858 * FUNCTION: AcpiUtGetDescriptorLength
859 *
860 * PARAMETERS: Aml - Pointer to the raw AML resource descriptor
861 *
862 * RETURN: Byte length
863 *
864 * DESCRIPTION: Get the total byte length of a raw AML descriptor, including the
865 * length of the descriptor header and the length field itself.
866 * Used to walk descriptor lists.
867 *
868 ******************************************************************************/
869
870UINT32
871AcpiUtGetDescriptorLength (
872 void *Aml)
873{
874 ACPI_FUNCTION_ENTRY ();
875
876
877 /*
878 * Get the Resource Length (does not include header length) and add
879 * the header length (depends on if this is a small or large resource)
880 */
881 return (AcpiUtGetResourceLength (Aml) +
882 AcpiUtGetResourceHeaderLength (Aml));
883}
884
885
886/*******************************************************************************
887 *
888 * FUNCTION: AcpiUtGetResourceEndTag
889 *
890 * PARAMETERS: ObjDesc - The resource template buffer object
891 * EndTag - Where the pointer to the EndTag is returned
892 *
893 * RETURN: Status, pointer to the end tag
894 *
895 * DESCRIPTION: Find the EndTag resource descriptor in an AML resource template
896 * Note: allows a buffer length of zero.
897 *
898 ******************************************************************************/
899
900ACPI_STATUS
901AcpiUtGetResourceEndTag (
902 ACPI_OPERAND_OBJECT *ObjDesc,
903 UINT8 **EndTag)
904{
905 ACPI_STATUS Status;
906
907
908 ACPI_FUNCTION_TRACE (UtGetResourceEndTag);
909
910
911 /* Allow a buffer length of zero */
912
913 if (!ObjDesc->Buffer.Length)
914 {
915 *EndTag = ObjDesc->Buffer.Pointer;
916 return_ACPI_STATUS (AE_OK);
917 }
918
919 /* Validate the template and get a pointer to the EndTag */
920
|
917 Status = AcpiUtWalkAmlResources (ObjDesc->Buffer.Pointer,
| 921 Status = AcpiUtWalkAmlResources (NULL, ObjDesc->Buffer.Pointer,
|
918 ObjDesc->Buffer.Length, NULL, EndTag);
919
920 return_ACPI_STATUS (Status);
921}
| 922 ObjDesc->Buffer.Length, NULL, EndTag);
923
924 return_ACPI_STATUS (Status);
925}
|