1 2/****************************************************************************** 3 * 4 * Module Name: aslrestype2e - Large Extended address resource descriptors 5 * 6 *****************************************************************************/ 7 8/* 9 * Copyright (C) 2000 - 2011, 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 46#include <contrib/dev/acpica/compiler/aslcompiler.h> 47 48#define _COMPONENT ACPI_COMPILER 49 ACPI_MODULE_NAME ("aslrestype2e") 50 51/* 52 * This module contains the Extended (64-bit) address space descriptors: 53 * 54 * ExtendedIO 55 * ExtendedMemory 56 * ExtendedSpace 57 */ 58 59/******************************************************************************* 60 * 61 * FUNCTION: RsDoExtendedIoDescriptor 62 * 63 * PARAMETERS: Op - Parent resource descriptor parse node 64 * CurrentByteOffset - Offset into the resource template AML 65 * buffer (to track references to the desc) 66 * 67 * RETURN: Completed resource node 68 * 69 * DESCRIPTION: Construct a long "ExtendedIO" descriptor 70 * 71 ******************************************************************************/ 72 73ASL_RESOURCE_NODE * 74RsDoExtendedIoDescriptor ( 75 ACPI_PARSE_OBJECT *Op, 76 UINT32 CurrentByteOffset) 77{ 78 AML_RESOURCE *Descriptor; 79 ACPI_PARSE_OBJECT *InitializerOp; 80 ACPI_PARSE_OBJECT *MinOp = NULL; 81 ACPI_PARSE_OBJECT *MaxOp = NULL; 82 ACPI_PARSE_OBJECT *LengthOp = NULL; 83 ACPI_PARSE_OBJECT *GranOp = NULL; 84 ASL_RESOURCE_NODE *Rnode; 85 UINT16 StringLength = 0; 86 UINT32 i; 87 88 89 InitializerOp = Op->Asl.Child; 90 StringLength = RsGetStringDataLength (InitializerOp); 91 92 Rnode = RsAllocateResourceNode ( 93 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength); 94 95 Descriptor = Rnode->Buffer; 96 Descriptor->ExtAddress64.DescriptorType = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64; 97 Descriptor->ExtAddress64.ResourceType = ACPI_ADDRESS_TYPE_IO_RANGE; 98 Descriptor->ExtAddress64.RevisionID = AML_RESOURCE_EXTENDED_ADDRESS_REVISION; 99 100 Descriptor->ExtAddress64.ResourceLength = (UINT16) 101 (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) - 102 sizeof (AML_RESOURCE_LARGE_HEADER)); 103 104 /* Process all child initialization nodes */ 105 106 for (i = 0; InitializerOp; i++) 107 { 108 switch (i) 109 { 110 case 0: /* Resource Usage */ 111 112 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1); 113 break; 114 115 case 1: /* MinType */ 116 117 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0); 118 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE, 119 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2); 120 break; 121 122 case 2: /* MaxType */ 123 124 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0); 125 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE, 126 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3); 127 break; 128 129 case 3: /* DecodeType */ 130 131 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0); 132 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE, 133 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1); 134 break; 135 136 case 4: /* Range Type */ 137 138 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 3); 139 RsCreateBitField (InitializerOp, ACPI_RESTAG_RANGETYPE, 140 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0); 141 break; 142 143 case 5: /* Address Granularity */ 144 145 Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer; 146 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY, 147 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity)); 148 GranOp = InitializerOp; 149 break; 150 151 case 6: /* Address Min */ 152 153 Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer; 154 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR, 155 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum)); 156 MinOp = InitializerOp; 157 break; 158 159 case 7: /* Address Max */ 160 161 Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer; 162 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR, 163 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum)); 164 MaxOp = InitializerOp; 165 break; 166 167 case 8: /* Translation Offset */ 168 169 Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer; 170 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION, 171 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset)); 172 break; 173 174 case 9: /* Address Length */ 175 176 Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer; 177 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH, 178 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength)); 179 LengthOp = InitializerOp; 180 break; 181 182 case 10: /* Type-Specific Attributes */ 183 184 Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer; 185 RsCreateByteField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES, 186 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific)); 187 break; 188 189 case 11: /* ResourceTag */ 190 191 UtAttachNamepathToOwner (Op, InitializerOp); 192 break; 193 194 case 12: /* Type */ 195 196 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 4, 0); 197 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE, 198 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 4); 199 break; 200 201 case 13: /* Translation Type */ 202 203 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0); 204 RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE, 205 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5); 206 break; 207 208 default: 209 210 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL); 211 break; 212 } 213 214 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 215 } 216 217 /* Validate the Min/Max/Len/Gran values */ 218 219 RsLargeAddressCheck ( 220 Descriptor->ExtAddress64.Minimum, 221 Descriptor->ExtAddress64.Maximum, 222 Descriptor->ExtAddress64.AddressLength, 223 Descriptor->ExtAddress64.Granularity, 224 Descriptor->ExtAddress64.Flags, 225 MinOp, MaxOp, LengthOp, GranOp, Op); 226 227 Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + StringLength; 228 return (Rnode); 229} 230 231 232/******************************************************************************* 233 * 234 * FUNCTION: RsDoExtendedMemoryDescriptor 235 * 236 * PARAMETERS: Op - Parent resource descriptor parse node 237 * CurrentByteOffset - Offset into the resource template AML 238 * buffer (to track references to the desc) 239 * 240 * RETURN: Completed resource node 241 * 242 * DESCRIPTION: Construct a long "ExtendedMemory" descriptor 243 * 244 ******************************************************************************/ 245 246ASL_RESOURCE_NODE * 247RsDoExtendedMemoryDescriptor ( 248 ACPI_PARSE_OBJECT *Op, 249 UINT32 CurrentByteOffset) 250{ 251 AML_RESOURCE *Descriptor; 252 ACPI_PARSE_OBJECT *InitializerOp; 253 ACPI_PARSE_OBJECT *MinOp = NULL; 254 ACPI_PARSE_OBJECT *MaxOp = NULL; 255 ACPI_PARSE_OBJECT *LengthOp = NULL; 256 ACPI_PARSE_OBJECT *GranOp = NULL; 257 ASL_RESOURCE_NODE *Rnode; 258 UINT16 StringLength = 0; 259 UINT32 i; 260 261 262 InitializerOp = Op->Asl.Child; 263 StringLength = RsGetStringDataLength (InitializerOp); 264 265 Rnode = RsAllocateResourceNode ( 266 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength); 267 268 Descriptor = Rnode->Buffer; 269 Descriptor->ExtAddress64.DescriptorType = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64; 270 Descriptor->ExtAddress64.ResourceType = ACPI_ADDRESS_TYPE_MEMORY_RANGE; 271 Descriptor->ExtAddress64.RevisionID = AML_RESOURCE_EXTENDED_ADDRESS_REVISION; 272 273 Descriptor->ExtAddress64.ResourceLength = (UINT16) 274 (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) - 275 sizeof (AML_RESOURCE_LARGE_HEADER)); 276 277 /* Process all child initialization nodes */ 278 279 for (i = 0; InitializerOp; i++) 280 { 281 switch (i) 282 { 283 case 0: /* Resource Usage */ 284 285 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1); 286 break; 287 288 case 1: /* DecodeType */ 289 290 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0); 291 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE, 292 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1); 293 break; 294 295 case 2: /* MinType */ 296 297 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0); 298 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE, 299 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2); 300 break; 301 302 case 3: /* MaxType */ 303 304 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0); 305 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE, 306 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3); 307 break; 308 309 case 4: /* Memory Type */ 310 311 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 1, 0); 312 RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMTYPE, 313 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 1); 314 break; 315 316 case 5: /* Read/Write Type */ 317 318 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 1); 319 RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE, 320 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0); 321 break; 322 323 case 6: /* Address Granularity */ 324 325 Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer; 326 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY, 327 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity)); 328 GranOp = InitializerOp; 329 break; 330 331 case 7: /* Min Address */ 332 333 Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer; 334 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR, 335 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum)); 336 MinOp = InitializerOp; 337 break; 338 339 case 8: /* Max Address */ 340 341 Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer; 342 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR, 343 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum)); 344 MaxOp = InitializerOp; 345 break; 346 347 case 9: /* Translation Offset */ 348 349 Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer; 350 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION, 351 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset)); 352 break; 353 354 case 10: /* Address Length */ 355 356 Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer; 357 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH, 358 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength)); 359 LengthOp = InitializerOp; 360 break; 361 362 case 11: /* Type-Specific Attributes */ 363 364 Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer; 365 RsCreateByteField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES, 366 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific)); 367 break; 368 369 case 12: /* ResourceTag */ 370 371 UtAttachNamepathToOwner (Op, InitializerOp); 372 break; 373 374 375 case 13: /* Address Range */ 376 377 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 3, 0); 378 RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES, 379 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 3); 380 break; 381 382 case 14: /* Type */ 383 384 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0); 385 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE, 386 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5); 387 break; 388 389 default: 390 391 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL); 392 break; 393 } 394 395 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 396 } 397 398 /* Validate the Min/Max/Len/Gran values */ 399 400 RsLargeAddressCheck ( 401 Descriptor->ExtAddress64.Minimum, 402 Descriptor->ExtAddress64.Maximum, 403 Descriptor->ExtAddress64.AddressLength, 404 Descriptor->ExtAddress64.Granularity, 405 Descriptor->ExtAddress64.Flags, 406 MinOp, MaxOp, LengthOp, GranOp, Op); 407 408 Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + StringLength; 409 return (Rnode); 410} 411 412 413/******************************************************************************* 414 * 415 * FUNCTION: RsDoExtendedSpaceDescriptor 416 * 417 * PARAMETERS: Op - Parent resource descriptor parse node 418 * CurrentByteOffset - Offset into the resource template AML 419 * buffer (to track references to the desc) 420 * 421 * RETURN: Completed resource node 422 * 423 * DESCRIPTION: Construct a long "ExtendedSpace" descriptor 424 * 425 ******************************************************************************/ 426 427ASL_RESOURCE_NODE * 428RsDoExtendedSpaceDescriptor ( 429 ACPI_PARSE_OBJECT *Op, 430 UINT32 CurrentByteOffset) 431{ 432 AML_RESOURCE *Descriptor; 433 ACPI_PARSE_OBJECT *InitializerOp; 434 ACPI_PARSE_OBJECT *MinOp = NULL; 435 ACPI_PARSE_OBJECT *MaxOp = NULL; 436 ACPI_PARSE_OBJECT *LengthOp = NULL; 437 ACPI_PARSE_OBJECT *GranOp = NULL; 438 ASL_RESOURCE_NODE *Rnode; 439 UINT16 StringLength = 0; 440 UINT32 i; 441 442 443 InitializerOp = Op->Asl.Child; 444 StringLength = RsGetStringDataLength (InitializerOp); 445 446 Rnode = RsAllocateResourceNode ( 447 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength); 448 449 Descriptor = Rnode->Buffer; 450 Descriptor->ExtAddress64.DescriptorType = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64; 451 Descriptor->ExtAddress64.RevisionID = AML_RESOURCE_EXTENDED_ADDRESS_REVISION; 452 453 Descriptor->ExtAddress64.ResourceLength = (UINT16) 454 (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) - 455 sizeof (AML_RESOURCE_LARGE_HEADER)); 456 457 /* Process all child initialization nodes */ 458 459 for (i = 0; InitializerOp; i++) 460 { 461 switch (i) 462 { 463 case 0: /* Resource Type */ 464 465 Descriptor->ExtAddress64.ResourceType = 466 (UINT8) InitializerOp->Asl.Value.Integer; 467 break; 468 469 case 1: /* Resource Usage */ 470 471 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1); 472 break; 473 474 case 2: /* DecodeType */ 475 476 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0); 477 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE, 478 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1); 479 break; 480 481 case 3: /* MinType */ 482 483 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0); 484 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE, 485 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2); 486 break; 487 488 case 4: /* MaxType */ 489 490 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0); 491 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE, 492 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3); 493 break; 494 495 case 5: /* Type-Specific flags */ 496 497 Descriptor->ExtAddress64.SpecificFlags = 498 (UINT8) InitializerOp->Asl.Value.Integer; 499 break; 500 501 case 6: /* Address Granularity */ 502 503 Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer; 504 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY, 505 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity)); 506 GranOp = InitializerOp; 507 break; 508 509 case 7: /* Min Address */ 510 511 Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer; 512 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR, 513 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum)); 514 MinOp = InitializerOp; 515 break; 516 517 case 8: /* Max Address */ 518 519 Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer; 520 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR, 521 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum)); 522 MaxOp = InitializerOp; 523 break; 524 525 case 9: /* Translation Offset */ 526 527 Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer; 528 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION, 529 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset)); 530 break; 531 532 case 10: /* Address Length */ 533 534 Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer; 535 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH, 536 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength)); 537 LengthOp = InitializerOp; 538 break; 539 540 case 11: /* Type-Specific Attributes */ 541 542 Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer; 543 RsCreateByteField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES, 544 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific)); 545 break; 546 547 case 12: /* ResourceTag */ 548 549 UtAttachNamepathToOwner (Op, InitializerOp); 550 break; 551 552 default: 553 554 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL); 555 break; 556 } 557 558 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 559 } 560 561 /* Validate the Min/Max/Len/Gran values */ 562 563 RsLargeAddressCheck ( 564 Descriptor->ExtAddress64.Minimum, 565 Descriptor->ExtAddress64.Maximum, 566 Descriptor->ExtAddress64.AddressLength, 567 Descriptor->ExtAddress64.Granularity, 568 Descriptor->ExtAddress64.Flags, 569 MinOp, MaxOp, LengthOp, GranOp, Op); 570 571 Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + StringLength; 572 return (Rnode); 573} 574