1 /****************************************************************************** 2 * 3 * Module Name: aslrestype1 - Miscellaneous small resource descriptors 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2015, 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 #include "aslcompiler.h" 45 #include "aslcompiler.y.h" 46 47 #define _COMPONENT ACPI_COMPILER 48 ACPI_MODULE_NAME ("aslrestype1") 49 50 /* 51 * This module contains miscellaneous small resource descriptors: 52 * 53 * EndTag 54 * EndDependentFn 55 * Memory24 56 * Memory32 57 * Memory32Fixed 58 * StartDependentFn 59 * StartDependentFnNoPri 60 * VendorShort 61 */ 62 63 /******************************************************************************* 64 * 65 * FUNCTION: RsDoEndTagDescriptor 66 * 67 * PARAMETERS: Info - Parse Op and resource template offset 68 * 69 * RETURN: Completed resource node 70 * 71 * DESCRIPTION: Construct a short "EndDependentFn" descriptor 72 * 73 ******************************************************************************/ 74 75 ASL_RESOURCE_NODE * 76 RsDoEndTagDescriptor ( 77 ASL_RESOURCE_INFO *Info) 78 { 79 AML_RESOURCE *Descriptor; 80 ASL_RESOURCE_NODE *Rnode; 81 82 83 Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_END_TAG)); 84 85 Descriptor = Rnode->Buffer; 86 Descriptor->EndTag.DescriptorType = ACPI_RESOURCE_NAME_END_TAG | 87 ASL_RDESC_END_TAG_SIZE; 88 Descriptor->EndTag.Checksum = 0; 89 90 return (Rnode); 91 } 92 93 94 /******************************************************************************* 95 * 96 * FUNCTION: RsDoEndDependentDescriptor 97 * 98 * PARAMETERS: Info - Parse Op and resource template offset 99 * 100 * RETURN: Completed resource node 101 * 102 * DESCRIPTION: Construct a short "EndDependentFn" descriptor 103 * 104 ******************************************************************************/ 105 106 ASL_RESOURCE_NODE * 107 RsDoEndDependentDescriptor ( 108 ASL_RESOURCE_INFO *Info) 109 { 110 AML_RESOURCE *Descriptor; 111 ASL_RESOURCE_NODE *Rnode; 112 113 114 Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_END_DEPENDENT)); 115 116 Descriptor = Rnode->Buffer; 117 Descriptor->EndDpf.DescriptorType = ACPI_RESOURCE_NAME_END_DEPENDENT | 118 ASL_RDESC_END_DEPEND_SIZE; 119 return (Rnode); 120 } 121 122 123 /******************************************************************************* 124 * 125 * FUNCTION: RsDoMemory24Descriptor 126 * 127 * PARAMETERS: Info - Parse Op and resource template offset 128 * 129 * RETURN: Completed resource node 130 * 131 * DESCRIPTION: Construct a short "Memory24" descriptor 132 * 133 ******************************************************************************/ 134 135 ASL_RESOURCE_NODE * 136 RsDoMemory24Descriptor ( 137 ASL_RESOURCE_INFO *Info) 138 { 139 AML_RESOURCE *Descriptor; 140 ACPI_PARSE_OBJECT *InitializerOp; 141 ACPI_PARSE_OBJECT *MinOp = NULL; 142 ACPI_PARSE_OBJECT *MaxOp = NULL; 143 ACPI_PARSE_OBJECT *LengthOp = NULL; 144 ASL_RESOURCE_NODE *Rnode; 145 UINT32 CurrentByteOffset; 146 UINT32 i; 147 148 149 InitializerOp = Info->DescriptorTypeOp->Asl.Child; 150 CurrentByteOffset = Info->CurrentByteOffset; 151 Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_MEMORY24)); 152 153 Descriptor = Rnode->Buffer; 154 Descriptor->Memory24.DescriptorType = ACPI_RESOURCE_NAME_MEMORY24; 155 Descriptor->Memory24.ResourceLength = 9; 156 157 /* Process all child initialization nodes */ 158 159 for (i = 0; InitializerOp; i++) 160 { 161 switch (i) 162 { 163 case 0: /* Read/Write type */ 164 165 RsSetFlagBits (&Descriptor->Memory24.Flags, InitializerOp, 0, 1); 166 RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE, 167 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.Flags), 0); 168 break; 169 170 case 1: /* Min Address */ 171 172 Descriptor->Memory24.Minimum = (UINT16) InitializerOp->Asl.Value.Integer; 173 RsCreateWordField (InitializerOp, ACPI_RESTAG_MINADDR, 174 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.Minimum)); 175 MinOp = InitializerOp; 176 break; 177 178 case 2: /* Max Address */ 179 180 Descriptor->Memory24.Maximum = (UINT16) InitializerOp->Asl.Value.Integer; 181 RsCreateWordField (InitializerOp, ACPI_RESTAG_MAXADDR, 182 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.Maximum)); 183 MaxOp = InitializerOp; 184 break; 185 186 case 3: /* Alignment */ 187 188 Descriptor->Memory24.Alignment = (UINT16) InitializerOp->Asl.Value.Integer; 189 RsCreateWordField (InitializerOp, ACPI_RESTAG_ALIGNMENT, 190 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.Alignment)); 191 break; 192 193 case 4: /* Length */ 194 195 Descriptor->Memory24.AddressLength = (UINT16) InitializerOp->Asl.Value.Integer; 196 RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH, 197 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.AddressLength)); 198 LengthOp = InitializerOp; 199 break; 200 201 case 5: /* Name */ 202 203 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp); 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/Align values (Alignment==0 means 64K) */ 216 217 RsSmallAddressCheck (ACPI_RESOURCE_NAME_MEMORY24, 218 Descriptor->Memory24.Minimum, 219 Descriptor->Memory24.Maximum, 220 Descriptor->Memory24.AddressLength, 221 Descriptor->Memory24.Alignment, 222 MinOp, MaxOp, LengthOp, NULL, Info->DescriptorTypeOp); 223 224 return (Rnode); 225 } 226 227 228 /******************************************************************************* 229 * 230 * FUNCTION: RsDoMemory32Descriptor 231 * 232 * PARAMETERS: Info - Parse Op and resource template offset 233 * 234 * RETURN: Completed resource node 235 * 236 * DESCRIPTION: Construct a short "Memory32" descriptor 237 * 238 ******************************************************************************/ 239 240 ASL_RESOURCE_NODE * 241 RsDoMemory32Descriptor ( 242 ASL_RESOURCE_INFO *Info) 243 { 244 AML_RESOURCE *Descriptor; 245 ACPI_PARSE_OBJECT *InitializerOp; 246 ACPI_PARSE_OBJECT *MinOp = NULL; 247 ACPI_PARSE_OBJECT *MaxOp = NULL; 248 ACPI_PARSE_OBJECT *LengthOp = NULL; 249 ACPI_PARSE_OBJECT *AlignOp = NULL; 250 ASL_RESOURCE_NODE *Rnode; 251 UINT32 CurrentByteOffset; 252 UINT32 i; 253 254 255 InitializerOp = Info->DescriptorTypeOp->Asl.Child; 256 CurrentByteOffset = Info->CurrentByteOffset; 257 Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_MEMORY32)); 258 259 Descriptor = Rnode->Buffer; 260 Descriptor->Memory32.DescriptorType = ACPI_RESOURCE_NAME_MEMORY32; 261 Descriptor->Memory32.ResourceLength = 17; 262 263 /* Process all child initialization nodes */ 264 265 for (i = 0; InitializerOp; i++) 266 { 267 switch (i) 268 { 269 case 0: /* Read/Write type */ 270 271 RsSetFlagBits (&Descriptor->Memory32.Flags, InitializerOp, 0, 1); 272 RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE, 273 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.Flags), 0); 274 break; 275 276 case 1: /* Min Address */ 277 278 Descriptor->Memory32.Minimum = (UINT32) InitializerOp->Asl.Value.Integer; 279 RsCreateDwordField (InitializerOp, ACPI_RESTAG_MINADDR, 280 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.Minimum)); 281 MinOp = InitializerOp; 282 break; 283 284 case 2: /* Max Address */ 285 286 Descriptor->Memory32.Maximum = (UINT32) InitializerOp->Asl.Value.Integer; 287 RsCreateDwordField (InitializerOp, ACPI_RESTAG_MAXADDR, 288 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.Maximum)); 289 MaxOp = InitializerOp; 290 break; 291 292 case 3: /* Alignment */ 293 294 Descriptor->Memory32.Alignment = (UINT32) InitializerOp->Asl.Value.Integer; 295 RsCreateDwordField (InitializerOp, ACPI_RESTAG_ALIGNMENT, 296 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.Alignment)); 297 AlignOp = InitializerOp; 298 break; 299 300 case 4: /* Length */ 301 302 Descriptor->Memory32.AddressLength = (UINT32) InitializerOp->Asl.Value.Integer; 303 RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH, 304 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.AddressLength)); 305 LengthOp = InitializerOp; 306 break; 307 308 case 5: /* Name */ 309 310 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp); 311 break; 312 313 default: 314 315 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL); 316 break; 317 } 318 319 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 320 } 321 322 /* Validate the Min/Max/Len/Align values */ 323 324 RsSmallAddressCheck (ACPI_RESOURCE_NAME_MEMORY32, 325 Descriptor->Memory32.Minimum, 326 Descriptor->Memory32.Maximum, 327 Descriptor->Memory32.AddressLength, 328 Descriptor->Memory32.Alignment, 329 MinOp, MaxOp, LengthOp, AlignOp, Info->DescriptorTypeOp); 330 331 return (Rnode); 332 } 333 334 335 /******************************************************************************* 336 * 337 * FUNCTION: RsDoMemory32FixedDescriptor 338 * 339 * PARAMETERS: Info - Parse Op and resource template offset 340 * 341 * RETURN: Completed resource node 342 * 343 * DESCRIPTION: Construct a short "Memory32Fixed" descriptor 344 * 345 ******************************************************************************/ 346 347 ASL_RESOURCE_NODE * 348 RsDoMemory32FixedDescriptor ( 349 ASL_RESOURCE_INFO *Info) 350 { 351 AML_RESOURCE *Descriptor; 352 ACPI_PARSE_OBJECT *InitializerOp; 353 ASL_RESOURCE_NODE *Rnode; 354 UINT32 CurrentByteOffset; 355 UINT32 i; 356 357 358 InitializerOp = Info->DescriptorTypeOp->Asl.Child; 359 CurrentByteOffset = Info->CurrentByteOffset; 360 Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_FIXED_MEMORY32)); 361 362 Descriptor = Rnode->Buffer; 363 Descriptor->FixedMemory32.DescriptorType = ACPI_RESOURCE_NAME_FIXED_MEMORY32; 364 Descriptor->FixedMemory32.ResourceLength = 9; 365 366 /* Process all child initialization nodes */ 367 368 for (i = 0; InitializerOp; i++) 369 { 370 switch (i) 371 { 372 case 0: /* Read/Write type */ 373 374 RsSetFlagBits (&Descriptor->FixedMemory32.Flags, InitializerOp, 0, 1); 375 RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE, 376 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedMemory32.Flags), 0); 377 break; 378 379 case 1: /* Address */ 380 381 Descriptor->FixedMemory32.Address = (UINT32) InitializerOp->Asl.Value.Integer; 382 RsCreateDwordField (InitializerOp, ACPI_RESTAG_BASEADDRESS, 383 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedMemory32.Address)); 384 break; 385 386 case 2: /* Length */ 387 388 Descriptor->FixedMemory32.AddressLength = (UINT32) InitializerOp->Asl.Value.Integer; 389 RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH, 390 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedMemory32.AddressLength)); 391 break; 392 393 case 3: /* Name */ 394 395 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp); 396 break; 397 398 default: 399 400 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL); 401 break; 402 } 403 404 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 405 } 406 407 return (Rnode); 408 } 409 410 411 /******************************************************************************* 412 * 413 * FUNCTION: RsDoStartDependentDescriptor 414 * 415 * PARAMETERS: Info - Parse Op and resource template offset 416 * 417 * RETURN: Completed resource node 418 * 419 * DESCRIPTION: Construct a short "StartDependentFn" descriptor 420 * 421 ******************************************************************************/ 422 423 ASL_RESOURCE_NODE * 424 RsDoStartDependentDescriptor ( 425 ASL_RESOURCE_INFO *Info) 426 { 427 AML_RESOURCE *Descriptor; 428 ACPI_PARSE_OBJECT *InitializerOp; 429 ASL_RESOURCE_NODE *Rnode; 430 ASL_RESOURCE_NODE *PreviousRnode; 431 ASL_RESOURCE_NODE *NextRnode; 432 ASL_RESOURCE_INFO NextInfo; 433 UINT32 CurrentByteOffset; 434 UINT32 i; 435 UINT8 State; 436 437 438 InitializerOp = Info->DescriptorTypeOp->Asl.Child; 439 CurrentByteOffset = Info->CurrentByteOffset; 440 Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_START_DEPENDENT)); 441 442 PreviousRnode = Rnode; 443 Descriptor = Rnode->Buffer; 444 445 /* Increment offset past StartDependent descriptor */ 446 447 CurrentByteOffset += sizeof (AML_RESOURCE_START_DEPENDENT); 448 449 /* Descriptor has priority byte */ 450 451 Descriptor->StartDpf.DescriptorType = ACPI_RESOURCE_NAME_START_DEPENDENT | 452 (ASL_RDESC_ST_DEPEND_SIZE + 0x01); 453 454 /* Process all child initialization nodes */ 455 456 State = ACPI_RSTATE_START_DEPENDENT; 457 for (i = 0; InitializerOp; i++) 458 { 459 switch (i) 460 { 461 case 0: /* Compatibility Priority */ 462 463 if ((UINT8) InitializerOp->Asl.Value.Integer > 2) 464 { 465 AslError (ASL_ERROR, ASL_MSG_INVALID_PRIORITY, 466 InitializerOp, NULL); 467 } 468 469 RsSetFlagBits (&Descriptor->StartDpf.Flags, InitializerOp, 0, 0); 470 break; 471 472 case 1: /* Performance/Robustness Priority */ 473 474 if ((UINT8) InitializerOp->Asl.Value.Integer > 2) 475 { 476 AslError (ASL_ERROR, ASL_MSG_INVALID_PERFORMANCE, 477 InitializerOp, NULL); 478 } 479 480 RsSetFlagBits (&Descriptor->StartDpf.Flags, InitializerOp, 2, 0); 481 break; 482 483 default: 484 485 NextInfo.CurrentByteOffset = CurrentByteOffset; 486 NextInfo.DescriptorTypeOp = InitializerOp; 487 488 NextRnode = RsDoOneResourceDescriptor (&NextInfo, &State); 489 490 /* 491 * Update current byte offset to indicate the number of bytes from the 492 * start of the buffer. Buffer can include multiple descriptors, we 493 * must keep track of the offset of not only each descriptor, but each 494 * element (field) within each descriptor as well. 495 */ 496 CurrentByteOffset += RsLinkDescriptorChain (&PreviousRnode, 497 NextRnode); 498 break; 499 } 500 501 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 502 } 503 504 return (Rnode); 505 } 506 507 508 /******************************************************************************* 509 * 510 * FUNCTION: RsDoStartDependentNoPriDescriptor 511 * 512 * PARAMETERS: Info - Parse Op and resource template offset 513 * 514 * RETURN: Completed resource node 515 * 516 * DESCRIPTION: Construct a short "StartDependentNoPri" descriptor 517 * 518 ******************************************************************************/ 519 520 ASL_RESOURCE_NODE * 521 RsDoStartDependentNoPriDescriptor ( 522 ASL_RESOURCE_INFO *Info) 523 { 524 AML_RESOURCE *Descriptor; 525 ACPI_PARSE_OBJECT *InitializerOp; 526 ASL_RESOURCE_NODE *Rnode; 527 ASL_RESOURCE_NODE *PreviousRnode; 528 ASL_RESOURCE_NODE *NextRnode; 529 ASL_RESOURCE_INFO NextInfo; 530 UINT32 CurrentByteOffset; 531 UINT8 State; 532 533 534 InitializerOp = Info->DescriptorTypeOp->Asl.Child; 535 CurrentByteOffset = Info->CurrentByteOffset; 536 Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_START_DEPENDENT_NOPRIO)); 537 538 Descriptor = Rnode->Buffer; 539 Descriptor->StartDpf.DescriptorType = ACPI_RESOURCE_NAME_START_DEPENDENT | 540 ASL_RDESC_ST_DEPEND_SIZE; 541 PreviousRnode = Rnode; 542 543 /* Increment offset past StartDependentNoPri descriptor */ 544 545 CurrentByteOffset += sizeof (AML_RESOURCE_START_DEPENDENT_NOPRIO); 546 547 /* Process all child initialization nodes */ 548 549 State = ACPI_RSTATE_START_DEPENDENT; 550 while (InitializerOp) 551 { 552 NextInfo.CurrentByteOffset = CurrentByteOffset; 553 NextInfo.DescriptorTypeOp = InitializerOp; 554 555 NextRnode = RsDoOneResourceDescriptor (&NextInfo, &State); 556 557 /* 558 * Update current byte offset to indicate the number of bytes from the 559 * start of the buffer. Buffer can include multiple descriptors, we 560 * must keep track of the offset of not only each descriptor, but each 561 * element (field) within each descriptor as well. 562 */ 563 CurrentByteOffset += RsLinkDescriptorChain (&PreviousRnode, NextRnode); 564 565 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 566 } 567 568 return (Rnode); 569 } 570 571 572 /******************************************************************************* 573 * 574 * FUNCTION: RsDoVendorSmallDescriptor 575 * 576 * PARAMETERS: Info - Parse Op and resource template offset 577 * 578 * RETURN: Completed resource node 579 * 580 * DESCRIPTION: Construct a short "VendorShort" descriptor 581 * 582 ******************************************************************************/ 583 584 ASL_RESOURCE_NODE * 585 RsDoVendorSmallDescriptor ( 586 ASL_RESOURCE_INFO *Info) 587 { 588 AML_RESOURCE *Descriptor; 589 ACPI_PARSE_OBJECT *InitializerOp; 590 ASL_RESOURCE_NODE *Rnode; 591 UINT8 *VendorData; 592 UINT32 i; 593 594 595 InitializerOp = Info->DescriptorTypeOp->Asl.Child; 596 597 /* Allocate worst case - 7 vendor bytes */ 598 599 Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_VENDOR_SMALL) + 7); 600 601 Descriptor = Rnode->Buffer; 602 Descriptor->VendorSmall.DescriptorType = ACPI_RESOURCE_NAME_VENDOR_SMALL; 603 VendorData = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_SMALL_HEADER); 604 605 /* Process all child initialization nodes */ 606 607 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 608 for (i = 0; InitializerOp; i++) 609 { 610 if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG) 611 { 612 break; 613 } 614 615 /* Maximum 7 vendor data bytes allowed (0-6) */ 616 617 if (i >= 7) 618 { 619 AslError (ASL_ERROR, ASL_MSG_VENDOR_LIST, InitializerOp, NULL); 620 621 /* Eat the excess initializers */ 622 623 while (InitializerOp) 624 { 625 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 626 } 627 break; 628 } 629 630 VendorData[i] = (UINT8) InitializerOp->Asl.Value.Integer; 631 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 632 } 633 634 /* Adjust the Rnode buffer size, so correct number of bytes are emitted */ 635 636 Rnode->BufferLength -= (7 - i); 637 638 /* Set the length in the Type Tag */ 639 640 Descriptor->VendorSmall.DescriptorType |= (UINT8) i; 641 return (Rnode); 642 } 643