ViewVC Help
View File | Revision Log | Show Annotations | Download File | View Changeset | Root Listing
root/src/trunk/sys/contrib/dev/acpica/compiler/aslrestype2e.c
Revision: 12109
Committed: Sun Oct 21 15:53:47 2018 UTC (5 years, 6 months ago) by laffer1
Content type: text/plain
File size: 21222 byte(s)
Log Message: 
ACPICA 20170119

File Contents

# Content
1 /* $MidnightBSD$ */
2 /******************************************************************************
3 *
4 * Module Name: aslrestype2e - Large Extended address resource descriptors
5 *
6 *****************************************************************************/
7
8 /*
9 * Copyright (C) 2000 - 2017, Intel Corp.
10 * All rights reserved.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions, and the following disclaimer,
17 * without modification.
18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
19 * substantially similar to the "NO WARRANTY" disclaimer below
20 * ("Disclaimer") and any redistribution must be conditioned upon
21 * including a substantially similar Disclaimer requirement for further
22 * binary redistribution.
23 * 3. Neither the names of the above-listed copyright holders nor the names
24 * of any contributors may be used to endorse or promote products derived
25 * from this software without specific prior written permission.
26 *
27 * Alternatively, this software may be distributed under the terms of the
28 * GNU General Public License ("GPL") version 2 as published by the Free
29 * Software Foundation.
30 *
31 * NO WARRANTY
32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
42 * POSSIBILITY OF SUCH DAMAGES.
43 */
44
45 #include <contrib/dev/acpica/compiler/aslcompiler.h>
46
47 #define _COMPONENT ACPI_COMPILER
48 ACPI_MODULE_NAME ("aslrestype2e")
49
50 /*
51 * This module contains the Extended (64-bit) address space descriptors:
52 *
53 * ExtendedIO
54 * ExtendedMemory
55 * ExtendedSpace
56 */
57
58 /*******************************************************************************
59 *
60 * FUNCTION: RsDoExtendedIoDescriptor
61 *
62 * PARAMETERS: Info - Parse Op and resource template offset
63 *
64 * RETURN: Completed resource node
65 *
66 * DESCRIPTION: Construct a long "ExtendedIO" descriptor
67 *
68 ******************************************************************************/
69
70 ASL_RESOURCE_NODE *
71 RsDoExtendedIoDescriptor (
72 ASL_RESOURCE_INFO *Info)
73 {
74 AML_RESOURCE *Descriptor;
75 ACPI_PARSE_OBJECT *InitializerOp;
76 ACPI_PARSE_OBJECT *MinOp = NULL;
77 ACPI_PARSE_OBJECT *MaxOp = NULL;
78 ACPI_PARSE_OBJECT *LengthOp = NULL;
79 ACPI_PARSE_OBJECT *GranOp = NULL;
80 ASL_RESOURCE_NODE *Rnode;
81 UINT16 StringLength = 0;
82 UINT32 CurrentByteOffset;
83 UINT32 i;
84
85
86 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
87 StringLength = RsGetStringDataLength (InitializerOp);
88 CurrentByteOffset = Info->CurrentByteOffset;
89
90 Rnode = RsAllocateResourceNode (
91 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
92
93 Descriptor = Rnode->Buffer;
94 Descriptor->ExtAddress64.DescriptorType = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
95 Descriptor->ExtAddress64.ResourceType = ACPI_ADDRESS_TYPE_IO_RANGE;
96 Descriptor->ExtAddress64.RevisionID = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
97
98 Descriptor->ExtAddress64.ResourceLength = (UINT16)
99 (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
100 sizeof (AML_RESOURCE_LARGE_HEADER));
101
102 /* Process all child initialization nodes */
103
104 for (i = 0; InitializerOp; i++)
105 {
106 switch (i)
107 {
108 case 0: /* Resource Usage */
109
110 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
111 break;
112
113 case 1: /* MinType */
114
115 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
116 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
117 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
118 break;
119
120 case 2: /* MaxType */
121
122 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
123 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
124 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
125 break;
126
127 case 3: /* DecodeType */
128
129 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
130 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
131 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
132 break;
133
134 case 4: /* Range Type */
135
136 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 3);
137 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
138 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0, 2);
139 break;
140
141 case 5: /* Address Granularity */
142
143 Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
144 RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
145 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
146 GranOp = InitializerOp;
147 break;
148
149 case 6: /* Address Min */
150
151 Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
152 RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
153 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
154 MinOp = InitializerOp;
155 break;
156
157 case 7: /* Address Max */
158
159 Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
160 RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
161 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
162 MaxOp = InitializerOp;
163 break;
164
165 case 8: /* Translation Offset */
166
167 Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
168 RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
169 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
170 break;
171
172 case 9: /* Address Length */
173
174 Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
175 RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
176 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
177 LengthOp = InitializerOp;
178 break;
179
180 case 10: /* Type-Specific Attributes */
181
182 Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
183 RsCreateQwordField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
184 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
185 break;
186
187 case 11: /* ResourceTag */
188
189 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
190 break;
191
192 case 12: /* Type */
193
194 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 4, 0);
195 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
196 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 4);
197 break;
198
199 case 13: /* Translation Type */
200
201 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0);
202 RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE,
203 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5);
204 break;
205
206 default:
207
208 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
209 break;
210 }
211
212 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
213 }
214
215 /* Validate the Min/Max/Len/Gran values */
216
217 RsLargeAddressCheck (
218 Descriptor->ExtAddress64.Minimum,
219 Descriptor->ExtAddress64.Maximum,
220 Descriptor->ExtAddress64.AddressLength,
221 Descriptor->ExtAddress64.Granularity,
222 Descriptor->ExtAddress64.Flags,
223 MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
224
225 Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) +
226 StringLength;
227 return (Rnode);
228 }
229
230
231 /*******************************************************************************
232 *
233 * FUNCTION: RsDoExtendedMemoryDescriptor
234 *
235 * PARAMETERS: Info - Parse Op and resource template offset
236 *
237 * RETURN: Completed resource node
238 *
239 * DESCRIPTION: Construct a long "ExtendedMemory" descriptor
240 *
241 ******************************************************************************/
242
243 ASL_RESOURCE_NODE *
244 RsDoExtendedMemoryDescriptor (
245 ASL_RESOURCE_INFO *Info)
246 {
247 AML_RESOURCE *Descriptor;
248 ACPI_PARSE_OBJECT *InitializerOp;
249 ACPI_PARSE_OBJECT *MinOp = NULL;
250 ACPI_PARSE_OBJECT *MaxOp = NULL;
251 ACPI_PARSE_OBJECT *LengthOp = NULL;
252 ACPI_PARSE_OBJECT *GranOp = NULL;
253 ASL_RESOURCE_NODE *Rnode;
254 UINT16 StringLength = 0;
255 UINT32 CurrentByteOffset;
256 UINT32 i;
257
258
259 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
260 StringLength = RsGetStringDataLength (InitializerOp);
261 CurrentByteOffset = Info->CurrentByteOffset;
262
263 Rnode = RsAllocateResourceNode (
264 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
265
266 Descriptor = Rnode->Buffer;
267 Descriptor->ExtAddress64.DescriptorType = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
268 Descriptor->ExtAddress64.ResourceType = ACPI_ADDRESS_TYPE_MEMORY_RANGE;
269 Descriptor->ExtAddress64.RevisionID = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
270
271 Descriptor->ExtAddress64.ResourceLength = (UINT16)
272 (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
273 sizeof (AML_RESOURCE_LARGE_HEADER));
274
275 /* Process all child initialization nodes */
276
277 for (i = 0; InitializerOp; i++)
278 {
279 switch (i)
280 {
281 case 0: /* Resource Usage */
282
283 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
284 break;
285
286 case 1: /* DecodeType */
287
288 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
289 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
290 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
291 break;
292
293 case 2: /* MinType */
294
295 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
296 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
297 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
298 break;
299
300 case 3: /* MaxType */
301
302 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
303 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
304 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
305 break;
306
307 case 4: /* Memory Type */
308
309 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 1, 0);
310 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
311 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 1, 2);
312 break;
313
314 case 5: /* Read/Write Type */
315
316 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 1);
317 RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
318 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0);
319 break;
320
321 case 6: /* Address Granularity */
322
323 Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
324 RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
325 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
326 GranOp = InitializerOp;
327 break;
328
329 case 7: /* Min Address */
330
331 Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
332 RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
333 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
334 MinOp = InitializerOp;
335 break;
336
337 case 8: /* Max Address */
338
339 Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
340 RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
341 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
342 MaxOp = InitializerOp;
343 break;
344
345 case 9: /* Translation Offset */
346
347 Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
348 RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
349 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
350 break;
351
352 case 10: /* Address Length */
353
354 Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
355 RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
356 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
357 LengthOp = InitializerOp;
358 break;
359
360 case 11: /* Type-Specific Attributes */
361
362 Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
363 RsCreateQwordField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
364 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
365 break;
366
367 case 12: /* ResourceTag */
368
369 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
370 break;
371
372
373 case 13: /* Address Range */
374
375 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 3, 0);
376 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
377 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 3, 2);
378 break;
379
380 case 14: /* Type */
381
382 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0);
383 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
384 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5);
385 break;
386
387 default:
388
389 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
390 break;
391 }
392
393 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
394 }
395
396 /* Validate the Min/Max/Len/Gran values */
397
398 RsLargeAddressCheck (
399 Descriptor->ExtAddress64.Minimum,
400 Descriptor->ExtAddress64.Maximum,
401 Descriptor->ExtAddress64.AddressLength,
402 Descriptor->ExtAddress64.Granularity,
403 Descriptor->ExtAddress64.Flags,
404 MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
405
406 Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) +
407 StringLength;
408 return (Rnode);
409 }
410
411
412 /*******************************************************************************
413 *
414 * FUNCTION: RsDoExtendedSpaceDescriptor
415 *
416 * PARAMETERS: Info - Parse Op and resource template offset
417 *
418 * RETURN: Completed resource node
419 *
420 * DESCRIPTION: Construct a long "ExtendedSpace" descriptor
421 *
422 ******************************************************************************/
423
424 ASL_RESOURCE_NODE *
425 RsDoExtendedSpaceDescriptor (
426 ASL_RESOURCE_INFO *Info)
427 {
428 AML_RESOURCE *Descriptor;
429 ACPI_PARSE_OBJECT *InitializerOp;
430 ACPI_PARSE_OBJECT *MinOp = NULL;
431 ACPI_PARSE_OBJECT *MaxOp = NULL;
432 ACPI_PARSE_OBJECT *LengthOp = NULL;
433 ACPI_PARSE_OBJECT *GranOp = NULL;
434 ASL_RESOURCE_NODE *Rnode;
435 UINT16 StringLength = 0;
436 UINT32 CurrentByteOffset;
437 UINT32 i;
438
439
440 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
441 StringLength = RsGetStringDataLength (InitializerOp);
442 CurrentByteOffset = Info->CurrentByteOffset;
443
444 Rnode = RsAllocateResourceNode (
445 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
446
447 Descriptor = Rnode->Buffer;
448 Descriptor->ExtAddress64.DescriptorType = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
449 Descriptor->ExtAddress64.RevisionID = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
450
451 Descriptor->ExtAddress64.ResourceLength = (UINT16)
452 (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
453 sizeof (AML_RESOURCE_LARGE_HEADER));
454
455 /* Process all child initialization nodes */
456
457 for (i = 0; InitializerOp; i++)
458 {
459 switch (i)
460 {
461 case 0: /* Resource Type */
462
463 Descriptor->ExtAddress64.ResourceType =
464 (UINT8) InitializerOp->Asl.Value.Integer;
465 break;
466
467 case 1: /* Resource Usage */
468
469 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
470 break;
471
472 case 2: /* DecodeType */
473
474 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
475 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
476 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
477 break;
478
479 case 3: /* MinType */
480
481 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
482 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
483 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
484 break;
485
486 case 4: /* MaxType */
487
488 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
489 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
490 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
491 break;
492
493 case 5: /* Type-Specific flags */
494
495 Descriptor->ExtAddress64.SpecificFlags =
496 (UINT8) InitializerOp->Asl.Value.Integer;
497 break;
498
499 case 6: /* Address Granularity */
500
501 Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
502 RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
503 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
504 GranOp = InitializerOp;
505 break;
506
507 case 7: /* Min Address */
508
509 Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
510 RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
511 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
512 MinOp = InitializerOp;
513 break;
514
515 case 8: /* Max Address */
516
517 Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
518 RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
519 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
520 MaxOp = InitializerOp;
521 break;
522
523 case 9: /* Translation Offset */
524
525 Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
526 RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
527 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
528 break;
529
530 case 10: /* Address Length */
531
532 Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
533 RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
534 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
535 LengthOp = InitializerOp;
536 break;
537
538 case 11: /* Type-Specific Attributes */
539
540 Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
541 RsCreateQwordField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
542 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
543 break;
544
545 case 12: /* ResourceTag */
546
547 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
548 break;
549
550 default:
551
552 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
553 break;
554 }
555
556 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
557 }
558
559 /* Validate the Min/Max/Len/Gran values */
560
561 RsLargeAddressCheck (
562 Descriptor->ExtAddress64.Minimum,
563 Descriptor->ExtAddress64.Maximum,
564 Descriptor->ExtAddress64.AddressLength,
565 Descriptor->ExtAddress64.Granularity,
566 Descriptor->ExtAddress64.Flags,
567 MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
568
569 Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) +
570 StringLength;
571 return (Rnode);
572 }

Properties

Name Value
svn:keywords MidnightBSD=%H