rsmemory.c revision 99679
1100928Snectar/******************************************************************************* 2100928Snectar * 3100928Snectar * Module Name: rsmem24 - Memory resource descriptors 4100928Snectar * $Revision: 20 $ 5100928Snectar * 6100928Snectar ******************************************************************************/ 7100928Snectar 8100928Snectar/****************************************************************************** 9100928Snectar * 10100928Snectar * 1. Copyright Notice 11100928Snectar * 12100928Snectar * Some or all of this work - Copyright (c) 1999 - 2002, Intel Corp. 13100928Snectar * All rights reserved. 14100928Snectar * 15100928Snectar * 2. License 16100928Snectar * 17100928Snectar * 2.1. This is your license from Intel Corp. under its intellectual property 18100936Snectar * rights. You may have additional license terms from the party that provided 19100936Snectar * you this software, covering your right to use that party's intellectual 20100928Snectar * property rights. 21100936Snectar * 22100936Snectar * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 23100928Snectar * copy of the source code appearing in this file ("Covered Code") an 24100928Snectar * irrevocable, perpetual, worldwide license under Intel's copyrights in the 25100928Snectar * base code distributed originally by Intel ("Original Intel Code") to copy, 26100928Snectar * make derivatives, distribute, use and display any portion of the Covered 27100928Snectar * Code in any form, with the right to sublicense such rights; and 28100928Snectar * 29100928Snectar * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 30100936Snectar * license (with the right to sublicense), under only those claims of Intel 31100936Snectar * patents that are infringed by the Original Intel Code, to make, use, sell, 32269682Sjkim * offer to sell, and import the Covered Code and derivative works thereof 33100936Snectar * solely to the minimum extent necessary to exercise the above copyright 34100936Snectar * license, and in no event shall the patent license extend to any additions 35100936Snectar * to or modifications of the Original Intel Code. No other license or right 36100936Snectar * is granted directly or by implication, estoppel or otherwise; 37100928Snectar * 38100928Snectar * The above copyright and patent license is granted only if the following 39100928Snectar * conditions are met: 40100928Snectar * 41100928Snectar * 3. Conditions 42100928Snectar * 43100928Snectar * 3.1. Redistribution of Source with Rights to Further Distribute Source. 44100936Snectar * Redistribution of source code of any substantial portion of the Covered 45100936Snectar * Code or modification with rights to further distribute source must include 46100936Snectar * the above Copyright Notice, the above License, this list of Conditions, 47100936Snectar * and the following Disclaimer and Export Compliance provision. In addition, 48100936Snectar * Licensee must cause all Covered Code to which Licensee contributes to 49100936Snectar * contain a file documenting the changes Licensee made to create that Covered 50100936Snectar * Code and the date of any change. Licensee must include in that file the 51100936Snectar * documentation of any changes made by any predecessor Licensee. Licensee 52100928Snectar * must include a prominent statement that the modification is derived, 53100936Snectar * directly or indirectly, from Original Intel Code. 54100936Snectar * 55100928Snectar * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 56100928Snectar * Redistribution of source code of any substantial portion of the Covered 57100936Snectar * Code or modification without rights to further distribute source must 58100936Snectar * include the following Disclaimer and Export Compliance provision in the 59100936Snectar * documentation and/or other materials provided with distribution. In 60100936Snectar * addition, Licensee may not authorize further sublicense of source of any 61100936Snectar * portion of the Covered Code, and must include terms to the effect that the 62100928Snectar * license from Licensee to its licensee is limited to the intellectual 63100928Snectar * property embodied in the software Licensee provides to its licensee, and 64100928Snectar * not to intellectual property embodied in modifications its licensee may 65100928Snectar * make. 66100928Snectar * 67100928Snectar * 3.3. Redistribution of Executable. Redistribution in executable form of any 68100928Snectar * substantial portion of the Covered Code or modification must reproduce the 69100928Snectar * above Copyright Notice, and the following Disclaimer and Export Compliance 70100928Snectar * provision in the documentation and/or other materials provided with the 71100928Snectar * distribution. 72100928Snectar * 73100928Snectar * 3.4. Intel retains all right, title, and interest in and to the Original 74100928Snectar * Intel Code. 75100928Snectar * 76100928Snectar * 3.5. Neither the name Intel nor any other trademark owned or controlled by 77100928Snectar * Intel shall be used in advertising or otherwise to promote the sale, use or 78100928Snectar * other dealings in products derived from or relating to the Covered Code 79100928Snectar * without prior written authorization from Intel. 80100928Snectar * 81100928Snectar * 4. Disclaimer and Export Compliance 82100928Snectar * 83100928Snectar * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 84100928Snectar * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 85100928Snectar * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 86100928Snectar * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 87100928Snectar * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 88100928Snectar * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 89100928Snectar * PARTICULAR PURPOSE. 90100928Snectar * 91100928Snectar * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 92100928Snectar * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 93100928Snectar * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 94100928Snectar * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 95 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 96 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 97 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 98 * LIMITED REMEDY. 99 * 100 * 4.3. Licensee shall not export, either directly or indirectly, any of this 101 * software or system incorporating such software without first obtaining any 102 * required license or other approval from the U. S. Department of Commerce or 103 * any other agency or department of the United States Government. In the 104 * event Licensee exports any such software from the United States or 105 * re-exports any such software from a foreign destination, Licensee shall 106 * ensure that the distribution and export/re-export of the software is in 107 * compliance with all laws, regulations, orders, or other restrictions of the 108 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 109 * any of its subsidiaries will export/re-export any technical data, process, 110 * software, or service, directly or indirectly, to any country for which the 111 * United States government or any agency thereof requires an export license, 112 * other governmental approval, or letter of assurance, without first obtaining 113 * such license, approval or letter. 114 * 115 *****************************************************************************/ 116 117#define __RSMEMORY_C__ 118 119#include "acpi.h" 120#include "acresrc.h" 121 122#define _COMPONENT ACPI_RESOURCES 123 ACPI_MODULE_NAME ("rsmemory") 124 125 126/******************************************************************************* 127 * 128 * FUNCTION: AcpiRsMemory24Resource 129 * 130 * PARAMETERS: ByteStreamBuffer - Pointer to the resource input byte 131 * stream 132 * BytesConsumed - Pointer to where the number of bytes 133 * consumed the ByteStreamBuffer is 134 * returned 135 * OutputBuffer - Pointer to the return data buffer 136 * StructureSize - Pointer to where the number of bytes 137 * in the return data struct is returned 138 * 139 * RETURN: Status 140 * 141 * DESCRIPTION: Take the resource byte stream and fill out the appropriate 142 * structure pointed to by the OutputBuffer. Return the 143 * number of bytes consumed from the byte stream. 144 * 145 ******************************************************************************/ 146 147ACPI_STATUS 148AcpiRsMemory24Resource ( 149 UINT8 *ByteStreamBuffer, 150 ACPI_SIZE *BytesConsumed, 151 UINT8 **OutputBuffer, 152 ACPI_SIZE *StructureSize) 153{ 154 UINT8 *Buffer = ByteStreamBuffer; 155 ACPI_RESOURCE *OutputStruct = (void *) *OutputBuffer; 156 UINT16 Temp16 = 0; 157 UINT8 Temp8 = 0; 158 ACPI_SIZE StructSize = ACPI_SIZEOF_RESOURCE (ACPI_RESOURCE_MEM24); 159 160 161 ACPI_FUNCTION_TRACE ("RsMemory24Resource"); 162 163 164 /* 165 * Point past the Descriptor to get the number of bytes consumed 166 */ 167 Buffer += 1; 168 169 ACPI_MOVE_UNALIGNED16_TO_16 (&Temp16, Buffer); 170 Buffer += 2; 171 *BytesConsumed = (ACPI_SIZE) Temp16 + 3; 172 OutputStruct->Id = ACPI_RSTYPE_MEM24; 173 174 /* 175 * Check Byte 3 the Read/Write bit 176 */ 177 Temp8 = *Buffer; 178 Buffer += 1; 179 OutputStruct->Data.Memory24.ReadWriteAttribute = Temp8 & 0x01; 180 181 /* 182 * Get MinBaseAddress (Bytes 4-5) 183 */ 184 ACPI_MOVE_UNALIGNED16_TO_16 (&Temp16, Buffer); 185 Buffer += 2; 186 OutputStruct->Data.Memory24.MinBaseAddress = Temp16; 187 188 /* 189 * Get MaxBaseAddress (Bytes 6-7) 190 */ 191 ACPI_MOVE_UNALIGNED16_TO_16 (&Temp16, Buffer); 192 Buffer += 2; 193 OutputStruct->Data.Memory24.MaxBaseAddress = Temp16; 194 195 /* 196 * Get Alignment (Bytes 8-9) 197 */ 198 ACPI_MOVE_UNALIGNED16_TO_16 (&Temp16, Buffer); 199 Buffer += 2; 200 OutputStruct->Data.Memory24.Alignment = Temp16; 201 202 /* 203 * Get RangeLength (Bytes 10-11) 204 */ 205 ACPI_MOVE_UNALIGNED16_TO_16 (&Temp16, Buffer); 206 OutputStruct->Data.Memory24.RangeLength = Temp16; 207 208 /* 209 * Set the Length parameter 210 */ 211 OutputStruct->Length = (UINT32) StructSize; 212 213 /* 214 * Return the final size of the structure 215 */ 216 *StructureSize = StructSize; 217 return_ACPI_STATUS (AE_OK); 218} 219 220 221/******************************************************************************* 222 * 223 * FUNCTION: AcpiRsMemory24Stream 224 * 225 * PARAMETERS: LinkedList - Pointer to the resource linked list 226 * OutputBuffer - Pointer to the user's return buffer 227 * BytesConsumed - Pointer to where the number of bytes 228 * used in the OutputBuffer is returned 229 * 230 * RETURN: Status 231 * 232 * DESCRIPTION: Take the linked list resource structure and fills in the 233 * the appropriate bytes in a byte stream 234 * 235 ******************************************************************************/ 236 237ACPI_STATUS 238AcpiRsMemory24Stream ( 239 ACPI_RESOURCE *LinkedList, 240 UINT8 **OutputBuffer, 241 ACPI_SIZE *BytesConsumed) 242{ 243 UINT8 *Buffer = *OutputBuffer; 244 UINT16 Temp16 = 0; 245 UINT8 Temp8 = 0; 246 247 248 ACPI_FUNCTION_TRACE ("RsMemory24Stream"); 249 250 251 /* 252 * The descriptor field is static 253 */ 254 *Buffer = 0x81; 255 Buffer += 1; 256 257 /* 258 * The length field is static 259 */ 260 Temp16 = 0x09; 261 ACPI_MOVE_UNALIGNED16_TO_16 (Buffer, &Temp16); 262 Buffer += 2; 263 264 /* 265 * Set the Information Byte 266 */ 267 Temp8 = (UINT8) (LinkedList->Data.Memory24.ReadWriteAttribute & 0x01); 268 *Buffer = Temp8; 269 Buffer += 1; 270 271 /* 272 * Set the Range minimum base address 273 */ 274 ACPI_MOVE_UNALIGNED16_TO_16 (Buffer, &LinkedList->Data.Memory24.MinBaseAddress); 275 Buffer += 2; 276 277 /* 278 * Set the Range maximum base address 279 */ 280 ACPI_MOVE_UNALIGNED16_TO_16 (Buffer, &LinkedList->Data.Memory24.MaxBaseAddress); 281 Buffer += 2; 282 283 /* 284 * Set the base alignment 285 */ 286 ACPI_MOVE_UNALIGNED16_TO_16 (Buffer, &LinkedList->Data.Memory24.Alignment); 287 Buffer += 2; 288 289 /* 290 * Set the range length 291 */ 292 ACPI_MOVE_UNALIGNED16_TO_16 (Buffer, &LinkedList->Data.Memory24.RangeLength); 293 Buffer += 2; 294 295 /* 296 * Return the number of bytes consumed in this operation 297 */ 298 *BytesConsumed = ACPI_PTR_DIFF (Buffer, *OutputBuffer); 299 return_ACPI_STATUS (AE_OK); 300} 301 302 303/******************************************************************************* 304 * 305 * FUNCTION: AcpiRsMemory32RangeResource 306 * 307 * PARAMETERS: ByteStreamBuffer - Pointer to the resource input byte 308 * stream 309 * BytesConsumed - Pointer to where the number of bytes 310 * consumed the ByteStreamBuffer is 311 * returned 312 * OutputBuffer - Pointer to the return data buffer 313 * StructureSize - Pointer to where the number of bytes 314 * in the return data struct is returned 315 * 316 * RETURN: Status 317 * 318 * DESCRIPTION: Take the resource byte stream and fill out the appropriate 319 * structure pointed to by the OutputBuffer. Return the 320 * number of bytes consumed from the byte stream. 321 * 322 ******************************************************************************/ 323 324ACPI_STATUS 325AcpiRsMemory32RangeResource ( 326 UINT8 *ByteStreamBuffer, 327 ACPI_SIZE *BytesConsumed, 328 UINT8 **OutputBuffer, 329 ACPI_SIZE *StructureSize) 330{ 331 UINT8 *Buffer = ByteStreamBuffer; 332 ACPI_RESOURCE *OutputStruct = (void *) *OutputBuffer; 333 UINT16 Temp16 = 0; 334 UINT8 Temp8 = 0; 335 ACPI_SIZE StructSize = ACPI_SIZEOF_RESOURCE (ACPI_RESOURCE_MEM32); 336 337 338 ACPI_FUNCTION_TRACE ("RsMemory32RangeResource"); 339 340 341 /* 342 * Point past the Descriptor to get the number of bytes consumed 343 */ 344 Buffer += 1; 345 346 ACPI_MOVE_UNALIGNED16_TO_16 (&Temp16, Buffer); 347 Buffer += 2; 348 *BytesConsumed = (ACPI_SIZE) Temp16 + 3; 349 350 OutputStruct->Id = ACPI_RSTYPE_MEM32; 351 352 /* 353 * Point to the place in the output buffer where the data portion will 354 * begin. 355 * 1. Set the RESOURCE_DATA * Data to point to it's own address, then 356 * 2. Set the pointer to the next address. 357 * 358 * NOTE: OutputStruct->Data is cast to UINT8, otherwise, this addition adds 359 * 4 * sizeof(RESOURCE_DATA) instead of 4 * sizeof(UINT8) 360 */ 361 362 /* 363 * Check Byte 3 the Read/Write bit 364 */ 365 Temp8 = *Buffer; 366 Buffer += 1; 367 368 OutputStruct->Data.Memory32.ReadWriteAttribute = Temp8 & 0x01; 369 370 /* 371 * Get MinBaseAddress (Bytes 4-7) 372 */ 373 ACPI_MOVE_UNALIGNED32_TO_32 (&OutputStruct->Data.Memory32.MinBaseAddress, 374 Buffer); 375 Buffer += 4; 376 377 /* 378 * Get MaxBaseAddress (Bytes 8-11) 379 */ 380 ACPI_MOVE_UNALIGNED32_TO_32 (&OutputStruct->Data.Memory32.MaxBaseAddress, 381 Buffer); 382 Buffer += 4; 383 384 /* 385 * Get Alignment (Bytes 12-15) 386 */ 387 ACPI_MOVE_UNALIGNED32_TO_32 (&OutputStruct->Data.Memory32.Alignment, Buffer); 388 Buffer += 4; 389 390 /* 391 * Get RangeLength (Bytes 16-19) 392 */ 393 ACPI_MOVE_UNALIGNED32_TO_32 (&OutputStruct->Data.Memory32.RangeLength, Buffer); 394 395 /* 396 * Set the Length parameter 397 */ 398 OutputStruct->Length = (UINT32) StructSize; 399 400 /* 401 * Return the final size of the structure 402 */ 403 *StructureSize = StructSize; 404 return_ACPI_STATUS (AE_OK); 405} 406 407 408/******************************************************************************* 409 * 410 * FUNCTION: AcpiRsFixedMemory32Resource 411 * 412 * PARAMETERS: ByteStreamBuffer - Pointer to the resource input byte 413 * stream 414 * BytesConsumed - Pointer to where the number of bytes 415 * consumed the ByteStreamBuffer is 416 * returned 417 * OutputBuffer - Pointer to the return data buffer 418 * StructureSize - Pointer to where the number of bytes 419 * in the return data struct is returned 420 * 421 * RETURN: Status 422 * 423 * DESCRIPTION: Take the resource byte stream and fill out the appropriate 424 * structure pointed to by the OutputBuffer. Return the 425 * number of bytes consumed from the byte stream. 426 * 427 ******************************************************************************/ 428 429ACPI_STATUS 430AcpiRsFixedMemory32Resource ( 431 UINT8 *ByteStreamBuffer, 432 ACPI_SIZE *BytesConsumed, 433 UINT8 **OutputBuffer, 434 ACPI_SIZE *StructureSize) 435{ 436 UINT8 *Buffer = ByteStreamBuffer; 437 ACPI_RESOURCE *OutputStruct = (void *) *OutputBuffer; 438 UINT16 Temp16 = 0; 439 UINT8 Temp8 = 0; 440 ACPI_SIZE StructSize = ACPI_SIZEOF_RESOURCE (ACPI_RESOURCE_FIXED_MEM32); 441 442 443 ACPI_FUNCTION_TRACE ("RsFixedMemory32Resource"); 444 445 446 /* 447 * Point past the Descriptor to get the number of bytes consumed 448 */ 449 Buffer += 1; 450 ACPI_MOVE_UNALIGNED16_TO_16 (&Temp16, Buffer); 451 452 Buffer += 2; 453 *BytesConsumed = (ACPI_SIZE) Temp16 + 3; 454 455 OutputStruct->Id = ACPI_RSTYPE_FIXED_MEM32; 456 457 /* 458 * Check Byte 3 the Read/Write bit 459 */ 460 Temp8 = *Buffer; 461 Buffer += 1; 462 OutputStruct->Data.FixedMemory32.ReadWriteAttribute = Temp8 & 0x01; 463 464 /* 465 * Get RangeBaseAddress (Bytes 4-7) 466 */ 467 ACPI_MOVE_UNALIGNED32_TO_32 (&OutputStruct->Data.FixedMemory32.RangeBaseAddress, 468 Buffer); 469 Buffer += 4; 470 471 /* 472 * Get RangeLength (Bytes 8-11) 473 */ 474 ACPI_MOVE_UNALIGNED32_TO_32 (&OutputStruct->Data.FixedMemory32.RangeLength, 475 Buffer); 476 477 /* 478 * Set the Length parameter 479 */ 480 OutputStruct->Length = (UINT32) StructSize; 481 482 /* 483 * Return the final size of the structure 484 */ 485 *StructureSize = StructSize; 486 return_ACPI_STATUS (AE_OK); 487} 488 489 490/******************************************************************************* 491 * 492 * FUNCTION: AcpiRsMemory32RangeStream 493 * 494 * PARAMETERS: LinkedList - Pointer to the resource linked list 495 * OutputBuffer - Pointer to the user's return buffer 496 * BytesConsumed - Pointer to where the number of bytes 497 * used in the OutputBuffer is returned 498 * 499 * RETURN: Status 500 * 501 * DESCRIPTION: Take the linked list resource structure and fills in the 502 * the appropriate bytes in a byte stream 503 * 504 ******************************************************************************/ 505 506ACPI_STATUS 507AcpiRsMemory32RangeStream ( 508 ACPI_RESOURCE *LinkedList, 509 UINT8 **OutputBuffer, 510 ACPI_SIZE *BytesConsumed) 511{ 512 UINT8 *Buffer = *OutputBuffer; 513 UINT16 Temp16 = 0; 514 UINT8 Temp8 = 0; 515 516 517 ACPI_FUNCTION_TRACE ("RsMemory32RangeStream"); 518 519 520 /* 521 * The descriptor field is static 522 */ 523 *Buffer = 0x85; 524 Buffer += 1; 525 526 /* 527 * The length field is static 528 */ 529 Temp16 = 0x11; 530 531 ACPI_MOVE_UNALIGNED16_TO_16 (Buffer, &Temp16); 532 Buffer += 2; 533 534 /* 535 * Set the Information Byte 536 */ 537 Temp8 = (UINT8) (LinkedList->Data.Memory32.ReadWriteAttribute & 0x01); 538 *Buffer = Temp8; 539 Buffer += 1; 540 541 /* 542 * Set the Range minimum base address 543 */ 544 ACPI_MOVE_UNALIGNED32_TO_32 (Buffer, &LinkedList->Data.Memory32.MinBaseAddress); 545 Buffer += 4; 546 547 /* 548 * Set the Range maximum base address 549 */ 550 ACPI_MOVE_UNALIGNED32_TO_32 (Buffer, &LinkedList->Data.Memory32.MaxBaseAddress); 551 Buffer += 4; 552 553 /* 554 * Set the base alignment 555 */ 556 ACPI_MOVE_UNALIGNED32_TO_32 (Buffer, &LinkedList->Data.Memory32.Alignment); 557 Buffer += 4; 558 559 /* 560 * Set the range length 561 */ 562 ACPI_MOVE_UNALIGNED32_TO_32 (Buffer, &LinkedList->Data.Memory32.RangeLength); 563 Buffer += 4; 564 565 /* 566 * Return the number of bytes consumed in this operation 567 */ 568 *BytesConsumed = ACPI_PTR_DIFF (Buffer, *OutputBuffer); 569 return_ACPI_STATUS (AE_OK); 570} 571 572 573/******************************************************************************* 574 * 575 * FUNCTION: AcpiRsFixedMemory32Stream 576 * 577 * PARAMETERS: LinkedList - Pointer to the resource linked list 578 * OutputBuffer - Pointer to the user's return buffer 579 * BytesConsumed - Pointer to where the number of bytes 580 * used in the OutputBuffer is returned 581 * 582 * RETURN: Status 583 * 584 * DESCRIPTION: Take the linked list resource structure and fills in the 585 * the appropriate bytes in a byte stream 586 * 587 ******************************************************************************/ 588 589ACPI_STATUS 590AcpiRsFixedMemory32Stream ( 591 ACPI_RESOURCE *LinkedList, 592 UINT8 **OutputBuffer, 593 ACPI_SIZE *BytesConsumed) 594{ 595 UINT8 *Buffer = *OutputBuffer; 596 UINT16 Temp16 = 0; 597 UINT8 Temp8 = 0; 598 599 600 ACPI_FUNCTION_TRACE ("RsFixedMemory32Stream"); 601 602 603 /* 604 * The descriptor field is static 605 */ 606 *Buffer = 0x86; 607 Buffer += 1; 608 609 /* 610 * The length field is static 611 */ 612 Temp16 = 0x09; 613 614 ACPI_MOVE_UNALIGNED16_TO_16 (Buffer, &Temp16); 615 Buffer += 2; 616 617 /* 618 * Set the Information Byte 619 */ 620 Temp8 = (UINT8) (LinkedList->Data.FixedMemory32.ReadWriteAttribute & 0x01); 621 *Buffer = Temp8; 622 Buffer += 1; 623 624 /* 625 * Set the Range base address 626 */ 627 ACPI_MOVE_UNALIGNED32_TO_32 (Buffer, 628 &LinkedList->Data.FixedMemory32.RangeBaseAddress); 629 Buffer += 4; 630 631 /* 632 * Set the range length 633 */ 634 ACPI_MOVE_UNALIGNED32_TO_32 (Buffer, 635 &LinkedList->Data.FixedMemory32.RangeLength); 636 Buffer += 4; 637 638 /* 639 * Return the number of bytes consumed in this operation 640 */ 641 *BytesConsumed = ACPI_PTR_DIFF (Buffer, *OutputBuffer); 642 return_ACPI_STATUS (AE_OK); 643} 644 645