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