Print this page
update to acpica-unix2-20140114
update to acpica-unix2-20131115
acpica-unix2-20130823
PANKOVs restructure
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/intel/io/acpica/resources/rscreate.c
+++ new/usr/src/common/acpica/components/resources/rscreate.c
1 1 /*******************************************************************************
2 2 *
3 3 * Module Name: rscreate - Create resource lists/tables
4 4 *
5 5 ******************************************************************************/
6 6
7 7 /*
8 - * Copyright (C) 2000 - 2011, Intel Corp.
8 + * Copyright (C) 2000 - 2014, Intel Corp.
9 9 * All rights reserved.
10 10 *
11 11 * Redistribution and use in source and binary forms, with or without
12 12 * modification, are permitted provided that the following conditions
13 13 * are met:
14 14 * 1. Redistributions of source code must retain the above copyright
15 15 * notice, this list of conditions, and the following disclaimer,
16 16 * without modification.
17 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 18 * substantially similar to the "NO WARRANTY" disclaimer below
19 19 * ("Disclaimer") and any redistribution must be conditioned upon
20 20 * including a substantially similar Disclaimer requirement for further
21 21 * binary redistribution.
22 22 * 3. Neither the names of the above-listed copyright holders nor the names
23 23 * of any contributors may be used to endorse or promote products derived
24 24 * from this software without specific prior written permission.
25 25 *
26 26 * Alternatively, this software may be distributed under the terms of the
27 27 * GNU General Public License ("GPL") version 2 as published by the Free
28 28 * Software Foundation.
29 29 *
30 30 * NO WARRANTY
31 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 41 * POSSIBILITY OF SUCH DAMAGES.
42 42 */
43 43
44 44 #define __RSCREATE_C__
45 45
46 46 #include "acpi.h"
|
↓ open down ↓ |
28 lines elided |
↑ open up ↑ |
47 47 #include "accommon.h"
48 48 #include "acresrc.h"
49 49 #include "acnamesp.h"
50 50
51 51 #define _COMPONENT ACPI_RESOURCES
52 52 ACPI_MODULE_NAME ("rscreate")
53 53
54 54
55 55 /*******************************************************************************
56 56 *
57 + * FUNCTION: AcpiBufferToResource
58 + *
59 + * PARAMETERS: AmlBuffer - Pointer to the resource byte stream
60 + * AmlBufferLength - Length of the AmlBuffer
61 + * ResourcePtr - Where the converted resource is returned
62 + *
63 + * RETURN: Status
64 + *
65 + * DESCRIPTION: Convert a raw AML buffer to a resource list
66 + *
67 + ******************************************************************************/
68 +
69 +ACPI_STATUS
70 +AcpiBufferToResource (
71 + UINT8 *AmlBuffer,
72 + UINT16 AmlBufferLength,
73 + ACPI_RESOURCE **ResourcePtr)
74 +{
75 + ACPI_STATUS Status;
76 + ACPI_SIZE ListSizeNeeded;
77 + void *Resource;
78 + void *CurrentResourcePtr;
79 +
80 + /*
81 + * Note: we allow AE_AML_NO_RESOURCE_END_TAG, since an end tag
82 + * is not required here.
83 + */
84 +
85 + /* Get the required length for the converted resource */
86 +
87 + Status = AcpiRsGetListLength (AmlBuffer, AmlBufferLength,
88 + &ListSizeNeeded);
89 + if (Status == AE_AML_NO_RESOURCE_END_TAG)
90 + {
91 + Status = AE_OK;
92 + }
93 + if (ACPI_FAILURE (Status))
94 + {
95 + return (Status);
96 + }
97 +
98 + /* Allocate a buffer for the converted resource */
99 +
100 + Resource = ACPI_ALLOCATE_ZEROED (ListSizeNeeded);
101 + CurrentResourcePtr = Resource;
102 + if (!Resource)
103 + {
104 + return (AE_NO_MEMORY);
105 + }
106 +
107 + /* Perform the AML-to-Resource conversion */
108 +
109 + Status = AcpiUtWalkAmlResources (NULL, AmlBuffer, AmlBufferLength,
110 + AcpiRsConvertAmlToResources, &CurrentResourcePtr);
111 + if (Status == AE_AML_NO_RESOURCE_END_TAG)
112 + {
113 + Status = AE_OK;
114 + }
115 + if (ACPI_FAILURE (Status))
116 + {
117 + ACPI_FREE (Resource);
118 + }
119 + else
120 + {
121 + *ResourcePtr = Resource;
122 + }
123 +
124 + return (Status);
125 +}
126 +
127 +
128 +/*******************************************************************************
129 + *
57 130 * FUNCTION: AcpiRsCreateResourceList
58 131 *
59 132 * PARAMETERS: AmlBuffer - Pointer to the resource byte stream
60 133 * OutputBuffer - Pointer to the user's buffer
61 134 *
62 135 * RETURN: Status: AE_OK if okay, else a valid ACPI_STATUS code
63 136 * If OutputBuffer is not large enough, OutputBufferLength
64 137 * indicates how large OutputBuffer should be, else it
65 138 * indicates how may UINT8 elements of OutputBuffer are valid.
66 139 *
67 140 * DESCRIPTION: Takes the byte stream returned from a _CRS, _PRS control method
68 141 * execution and parses the stream to create a linked list
69 142 * of device resources.
70 143 *
71 144 ******************************************************************************/
72 145
73 146 ACPI_STATUS
74 147 AcpiRsCreateResourceList (
75 148 ACPI_OPERAND_OBJECT *AmlBuffer,
76 149 ACPI_BUFFER *OutputBuffer)
77 150 {
78 151
79 152 ACPI_STATUS Status;
80 153 UINT8 *AmlStart;
81 154 ACPI_SIZE ListSizeNeeded = 0;
82 155 UINT32 AmlBufferLength;
83 156 void *Resource;
84 157
85 158
86 159 ACPI_FUNCTION_TRACE (RsCreateResourceList);
87 160
88 161
89 162 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "AmlBuffer = %p\n",
90 163 AmlBuffer));
91 164
92 165 /* Params already validated, so we don't re-validate here */
93 166
94 167 AmlBufferLength = AmlBuffer->Buffer.Length;
95 168 AmlStart = AmlBuffer->Buffer.Pointer;
96 169
97 170 /*
98 171 * Pass the AmlBuffer into a module that can calculate
99 172 * the buffer size needed for the linked list
100 173 */
101 174 Status = AcpiRsGetListLength (AmlStart, AmlBufferLength,
102 175 &ListSizeNeeded);
103 176
104 177 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Status=%X ListSizeNeeded=%X\n",
105 178 Status, (UINT32) ListSizeNeeded));
106 179 if (ACPI_FAILURE (Status))
107 180 {
108 181 return_ACPI_STATUS (Status);
109 182 }
110 183
111 184 /* Validate/Allocate/Clear caller buffer */
|
↓ open down ↓ |
45 lines elided |
↑ open up ↑ |
112 185
113 186 Status = AcpiUtInitializeBuffer (OutputBuffer, ListSizeNeeded);
114 187 if (ACPI_FAILURE (Status))
115 188 {
116 189 return_ACPI_STATUS (Status);
117 190 }
118 191
119 192 /* Do the conversion */
120 193
121 194 Resource = OutputBuffer->Pointer;
122 - Status = AcpiUtWalkAmlResources (AmlStart, AmlBufferLength,
195 + Status = AcpiUtWalkAmlResources (NULL, AmlStart, AmlBufferLength,
123 196 AcpiRsConvertAmlToResources, &Resource);
124 197 if (ACPI_FAILURE (Status))
125 198 {
126 199 return_ACPI_STATUS (Status);
127 200 }
128 201
129 202 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "OutputBuffer %p Length %X\n",
130 203 OutputBuffer->Pointer, (UINT32) OutputBuffer->Length));
131 204 return_ACPI_STATUS (AE_OK);
132 205 }
133 206
134 207
135 208 /*******************************************************************************
136 209 *
137 210 * FUNCTION: AcpiRsCreatePciRoutingTable
138 211 *
139 - * PARAMETERS: PackageObject - Pointer to an ACPI_OPERAND_OBJECT
140 - * package
212 + * PARAMETERS: PackageObject - Pointer to a package containing one
213 + * of more ACPI_OPERAND_OBJECTs
141 214 * OutputBuffer - Pointer to the user's buffer
142 215 *
143 216 * RETURN: Status AE_OK if okay, else a valid ACPI_STATUS code.
144 217 * If the OutputBuffer is too small, the error will be
145 218 * AE_BUFFER_OVERFLOW and OutputBuffer->Length will point
146 219 * to the size buffer needed.
147 220 *
148 - * DESCRIPTION: Takes the ACPI_OPERAND_OBJECT package and creates a
221 + * DESCRIPTION: Takes the ACPI_OPERAND_OBJECT package and creates a
149 222 * linked list of PCI interrupt descriptions
150 223 *
151 224 * NOTE: It is the caller's responsibility to ensure that the start of the
152 225 * output buffer is aligned properly (if necessary).
153 226 *
154 227 ******************************************************************************/
155 228
156 229 ACPI_STATUS
157 230 AcpiRsCreatePciRoutingTable (
158 231 ACPI_OPERAND_OBJECT *PackageObject,
159 232 ACPI_BUFFER *OutputBuffer)
160 233 {
161 234 UINT8 *Buffer;
162 235 ACPI_OPERAND_OBJECT **TopObjectList;
163 236 ACPI_OPERAND_OBJECT **SubObjectList;
164 237 ACPI_OPERAND_OBJECT *ObjDesc;
165 238 ACPI_SIZE BufferSizeNeeded = 0;
166 239 UINT32 NumberOfElements;
167 240 UINT32 Index;
168 241 ACPI_PCI_ROUTING_TABLE *UserPrt;
169 242 ACPI_NAMESPACE_NODE *Node;
170 243 ACPI_STATUS Status;
171 244 ACPI_BUFFER PathBuffer;
172 245
173 246
174 247 ACPI_FUNCTION_TRACE (RsCreatePciRoutingTable);
175 248
176 249
177 250 /* Params already validated, so we don't re-validate here */
178 251
179 252 /* Get the required buffer length */
180 253
181 254 Status = AcpiRsGetPciRoutingTableLength (PackageObject,
182 255 &BufferSizeNeeded);
183 256 if (ACPI_FAILURE (Status))
184 257 {
185 258 return_ACPI_STATUS (Status);
186 259 }
187 260
188 261 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "BufferSizeNeeded = %X\n",
189 262 (UINT32) BufferSizeNeeded));
190 263
191 264 /* Validate/Allocate/Clear caller buffer */
192 265
193 266 Status = AcpiUtInitializeBuffer (OutputBuffer, BufferSizeNeeded);
194 267 if (ACPI_FAILURE (Status))
195 268 {
196 269 return_ACPI_STATUS (Status);
197 270 }
198 271
199 272 /*
200 273 * Loop through the ACPI_INTERNAL_OBJECTS - Each object should be a
201 274 * package that in turn contains an UINT64 Address, a UINT8 Pin,
202 275 * a Name, and a UINT8 SourceIndex.
203 276 */
204 277 TopObjectList = PackageObject->Package.Elements;
205 278 NumberOfElements = PackageObject->Package.Count;
206 279 Buffer = OutputBuffer->Pointer;
207 280 UserPrt = ACPI_CAST_PTR (ACPI_PCI_ROUTING_TABLE, Buffer);
208 281
209 282 for (Index = 0; Index < NumberOfElements; Index++)
210 283 {
211 284 /*
212 285 * Point UserPrt past this current structure
213 286 *
214 287 * NOTE: On the first iteration, UserPrt->Length will
215 288 * be zero because we cleared the return buffer earlier
216 289 */
|
↓ open down ↓ |
58 lines elided |
↑ open up ↑ |
217 290 Buffer += UserPrt->Length;
218 291 UserPrt = ACPI_CAST_PTR (ACPI_PCI_ROUTING_TABLE, Buffer);
219 292
220 293 /*
221 294 * Fill in the Length field with the information we have at this point.
222 295 * The minus four is to subtract the size of the UINT8 Source[4] member
223 296 * because it is added below.
224 297 */
225 298 UserPrt->Length = (sizeof (ACPI_PCI_ROUTING_TABLE) - 4);
226 299
227 - /* Each element of the top-level package must also be a package */
228 -
229 - if ((*TopObjectList)->Common.Type != ACPI_TYPE_PACKAGE)
230 - {
231 - ACPI_ERROR ((AE_INFO,
232 - "(PRT[%u]) Need sub-package, found %s",
233 - Index, AcpiUtGetObjectTypeName (*TopObjectList)));
234 - return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
235 - }
236 -
237 300 /* Each sub-package must be of length 4 */
238 301
239 302 if ((*TopObjectList)->Package.Count != 4)
240 303 {
241 304 ACPI_ERROR ((AE_INFO,
242 305 "(PRT[%u]) Need package of length 4, found length %u",
243 306 Index, (*TopObjectList)->Package.Count));
244 307 return_ACPI_STATUS (AE_AML_PACKAGE_LIMIT);
245 308 }
246 309
247 310 /*
248 311 * Dereference the sub-package.
249 312 * The SubObjectList will now point to an array of the four IRQ
250 313 * elements: [Address, Pin, Source, SourceIndex]
251 314 */
252 315 SubObjectList = (*TopObjectList)->Package.Elements;
253 316
254 317 /* 1) First subobject: Dereference the PRT.Address */
255 318
256 319 ObjDesc = SubObjectList[0];
257 320 if (ObjDesc->Common.Type != ACPI_TYPE_INTEGER)
258 321 {
259 322 ACPI_ERROR ((AE_INFO, "(PRT[%u].Address) Need Integer, found %s",
260 323 Index, AcpiUtGetObjectTypeName (ObjDesc)));
261 324 return_ACPI_STATUS (AE_BAD_DATA);
262 325 }
263 326
264 327 UserPrt->Address = ObjDesc->Integer.Value;
265 328
266 329 /* 2) Second subobject: Dereference the PRT.Pin */
267 330
268 331 ObjDesc = SubObjectList[1];
|
↓ open down ↓ |
22 lines elided |
↑ open up ↑ |
269 332 if (ObjDesc->Common.Type != ACPI_TYPE_INTEGER)
270 333 {
271 334 ACPI_ERROR ((AE_INFO, "(PRT[%u].Pin) Need Integer, found %s",
272 335 Index, AcpiUtGetObjectTypeName (ObjDesc)));
273 336 return_ACPI_STATUS (AE_BAD_DATA);
274 337 }
275 338
276 339 UserPrt->Pin = (UINT32) ObjDesc->Integer.Value;
277 340
278 341 /*
279 - * If the BIOS has erroneously reversed the _PRT SourceName (index 2)
280 - * and the SourceIndex (index 3), fix it. _PRT is important enough to
281 - * workaround this BIOS error. This also provides compatibility with
282 - * other ACPI implementations.
283 - */
284 - ObjDesc = SubObjectList[3];
285 - if (!ObjDesc || (ObjDesc->Common.Type != ACPI_TYPE_INTEGER))
286 - {
287 - SubObjectList[3] = SubObjectList[2];
288 - SubObjectList[2] = ObjDesc;
289 -
290 - ACPI_WARNING ((AE_INFO,
291 - "(PRT[%X].Source) SourceName and SourceIndex are reversed, fixed",
292 - Index));
293 - }
294 -
295 - /*
296 342 * 3) Third subobject: Dereference the PRT.SourceName
297 343 * The name may be unresolved (slack mode), so allow a null object
298 344 */
299 345 ObjDesc = SubObjectList[2];
300 346 if (ObjDesc)
301 347 {
302 348 switch (ObjDesc->Common.Type)
303 349 {
304 350 case ACPI_TYPE_LOCAL_REFERENCE:
305 351
306 352 if (ObjDesc->Reference.Class != ACPI_REFCLASS_NAME)
307 353 {
308 354 ACPI_ERROR ((AE_INFO,
309 355 "(PRT[%u].Source) Need name, found Reference Class 0x%X",
310 356 Index, ObjDesc->Reference.Class));
311 357 return_ACPI_STATUS (AE_BAD_DATA);
312 358 }
313 359
314 360 Node = ObjDesc->Reference.Node;
315 361
316 362 /* Use *remaining* length of the buffer as max for pathname */
317 363
318 364 PathBuffer.Length = OutputBuffer->Length -
319 365 (UINT32) ((UINT8 *) UserPrt->Source -
|
↓ open down ↓ |
14 lines elided |
↑ open up ↑ |
320 366 (UINT8 *) OutputBuffer->Pointer);
321 367 PathBuffer.Pointer = UserPrt->Source;
322 368
323 369 Status = AcpiNsHandleToPathname ((ACPI_HANDLE) Node, &PathBuffer);
324 370
325 371 /* +1 to include null terminator */
326 372
327 373 UserPrt->Length += (UINT32) ACPI_STRLEN (UserPrt->Source) + 1;
328 374 break;
329 375
330 -
331 376 case ACPI_TYPE_STRING:
332 377
333 378 ACPI_STRCPY (UserPrt->Source, ObjDesc->String.Pointer);
334 379
335 380 /*
336 381 * Add to the Length field the length of the string
337 382 * (add 1 for terminator)
338 383 */
339 384 UserPrt->Length += ObjDesc->String.Length + 1;
340 385 break;
341 386
342 -
343 387 case ACPI_TYPE_INTEGER:
344 388 /*
345 389 * If this is a number, then the Source Name is NULL, since the
346 390 * entire buffer was zeroed out, we can leave this alone.
347 391 *
348 392 * Add to the Length field the length of the UINT32 NULL
349 393 */
350 394 UserPrt->Length += sizeof (UINT32);
351 395 break;
352 396
353 -
354 397 default:
355 398
356 399 ACPI_ERROR ((AE_INFO,
357 400 "(PRT[%u].Source) Need Ref/String/Integer, found %s",
358 401 Index, AcpiUtGetObjectTypeName (ObjDesc)));
359 402 return_ACPI_STATUS (AE_BAD_DATA);
360 403 }
361 404 }
362 405
363 406 /* Now align the current length */
364 407
365 408 UserPrt->Length = (UINT32) ACPI_ROUND_UP_TO_64BIT (UserPrt->Length);
366 409
367 410 /* 4) Fourth subobject: Dereference the PRT.SourceIndex */
368 411
369 412 ObjDesc = SubObjectList[3];
370 413 if (ObjDesc->Common.Type != ACPI_TYPE_INTEGER)
371 414 {
372 415 ACPI_ERROR ((AE_INFO,
373 416 "(PRT[%u].SourceIndex) Need Integer, found %s",
374 417 Index, AcpiUtGetObjectTypeName (ObjDesc)));
375 418 return_ACPI_STATUS (AE_BAD_DATA);
376 419 }
377 420
378 421 UserPrt->SourceIndex = (UINT32) ObjDesc->Integer.Value;
379 422
380 423 /* Point to the next ACPI_OPERAND_OBJECT in the top level package */
381 424
382 425 TopObjectList++;
383 426 }
384 427
|
↓ open down ↓ |
21 lines elided |
↑ open up ↑ |
385 428 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "OutputBuffer %p Length %X\n",
386 429 OutputBuffer->Pointer, (UINT32) OutputBuffer->Length));
387 430 return_ACPI_STATUS (AE_OK);
388 431 }
389 432
390 433
391 434 /*******************************************************************************
392 435 *
393 436 * FUNCTION: AcpiRsCreateAmlResources
394 437 *
395 - * PARAMETERS: LinkedListBuffer - Pointer to the resource linked list
396 - * OutputBuffer - Pointer to the user's buffer
438 + * PARAMETERS: ResourceList - Pointer to the resource list buffer
439 + * OutputBuffer - Where the AML buffer is returned
397 440 *
398 441 * RETURN: Status AE_OK if okay, else a valid ACPI_STATUS code.
399 442 * If the OutputBuffer is too small, the error will be
400 443 * AE_BUFFER_OVERFLOW and OutputBuffer->Length will point
401 444 * to the size buffer needed.
402 445 *
403 - * DESCRIPTION: Takes the linked list of device resources and
404 - * creates a bytestream to be used as input for the
405 - * _SRS control method.
446 + * DESCRIPTION: Converts a list of device resources to an AML bytestream
447 + * to be used as input for the _SRS control method.
406 448 *
407 449 ******************************************************************************/
408 450
409 451 ACPI_STATUS
410 452 AcpiRsCreateAmlResources (
411 - ACPI_RESOURCE *LinkedListBuffer,
453 + ACPI_BUFFER *ResourceList,
412 454 ACPI_BUFFER *OutputBuffer)
413 455 {
414 456 ACPI_STATUS Status;
415 457 ACPI_SIZE AmlSizeNeeded = 0;
416 458
417 459
418 460 ACPI_FUNCTION_TRACE (RsCreateAmlResources);
419 461
420 462
421 - ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "LinkedListBuffer = %p\n",
422 - LinkedListBuffer));
463 + /* Params already validated, no need to re-validate here */
423 464
424 - /*
425 - * Params already validated, so we don't re-validate here
426 - *
427 - * Pass the LinkedListBuffer into a module that calculates
428 - * the buffer size needed for the byte stream.
429 - */
430 - Status = AcpiRsGetAmlLength (LinkedListBuffer,
431 - &AmlSizeNeeded);
465 + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "ResourceList Buffer = %p\n",
466 + ResourceList->Pointer));
432 467
468 + /* Get the buffer size needed for the AML byte stream */
469 +
470 + Status = AcpiRsGetAmlLength (ResourceList->Pointer,
471 + ResourceList->Length, &AmlSizeNeeded);
472 +
433 473 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "AmlSizeNeeded=%X, %s\n",
434 474 (UINT32) AmlSizeNeeded, AcpiFormatException (Status)));
435 475 if (ACPI_FAILURE (Status))
436 476 {
437 477 return_ACPI_STATUS (Status);
438 478 }
439 479
440 480 /* Validate/Allocate/Clear caller buffer */
441 481
442 482 Status = AcpiUtInitializeBuffer (OutputBuffer, AmlSizeNeeded);
443 483 if (ACPI_FAILURE (Status))
444 484 {
445 485 return_ACPI_STATUS (Status);
446 486 }
447 487
448 488 /* Do the conversion */
449 489
450 - Status = AcpiRsConvertResourcesToAml (LinkedListBuffer, AmlSizeNeeded,
451 - OutputBuffer->Pointer);
490 + Status = AcpiRsConvertResourcesToAml (ResourceList->Pointer,
491 + AmlSizeNeeded, OutputBuffer->Pointer);
452 492 if (ACPI_FAILURE (Status))
453 493 {
454 494 return_ACPI_STATUS (Status);
455 495 }
456 496
457 497 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "OutputBuffer %p Length %X\n",
458 - OutputBuffer->Pointer, (UINT32) OutputBuffer->Length));
498 + OutputBuffer->Pointer, (UINT32) OutputBuffer->Length));
459 499 return_ACPI_STATUS (AE_OK);
460 500 }
461 -
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX