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