rslist.c revision 71867 
1/*******************************************************************************
2 *
3 * Module Name: rslist - AcpiRsByteStreamToList
4 *                       AcpiListToByteStream
5 *              $Revision: 10 $
6 *
7 ******************************************************************************/
8
9/******************************************************************************
10 *
11 * 1. Copyright Notice
12 *
13 * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp.
14 * All rights reserved.
15 *
16 * 2. License
17 *
18 * 2.1. This is your license from Intel Corp. under its intellectual property
19 * rights.  You may have additional license terms from the party that provided
20 * you this software, covering your right to use that party's intellectual
21 * property rights.
22 *
23 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
24 * copy of the source code appearing in this file ("Covered Code") an
25 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
26 * base code distributed originally by Intel ("Original Intel Code") to copy,
27 * make derivatives, distribute, use and display any portion of the Covered
28 * Code in any form, with the right to sublicense such rights; and
29 *
30 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
31 * license (with the right to sublicense), under only those claims of Intel
32 * patents that are infringed by the Original Intel Code, to make, use, sell,
33 * offer to sell, and import the Covered Code and derivative works thereof
34 * solely to the minimum extent necessary to exercise the above copyright
35 * license, and in no event shall the patent license extend to any additions
36 * to or modifications of the Original Intel Code.  No other license or right
37 * is granted directly or by implication, estoppel or otherwise;
38 *
39 * The above copyright and patent license is granted only if the following
40 * conditions are met:
41 *
42 * 3. Conditions
43 *
44 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
45 * Redistribution of source code of any substantial portion of the Covered
46 * Code or modification with rights to further distribute source must include
47 * the above Copyright Notice, the above License, this list of Conditions,
48 * and the following Disclaimer and Export Compliance provision.  In addition,
49 * Licensee must cause all Covered Code to which Licensee contributes to
50 * contain a file documenting the changes Licensee made to create that Covered
51 * Code and the date of any change.  Licensee must include in that file the
52 * documentation of any changes made by any predecessor Licensee.  Licensee
53 * must include a prominent statement that the modification is derived,
54 * directly or indirectly, from Original Intel Code.
55 *
56 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
57 * Redistribution of source code of any substantial portion of the Covered
58 * Code or modification without rights to further distribute source must
59 * include the following Disclaimer and Export Compliance provision in the
60 * documentation and/or other materials provided with distribution.  In
61 * addition, Licensee may not authorize further sublicense of source of any
62 * portion of the Covered Code, and must include terms to the effect that the
63 * license from Licensee to its licensee is limited to the intellectual
64 * property embodied in the software Licensee provides to its licensee, and
65 * not to intellectual property embodied in modifications its licensee may
66 * make.
67 *
68 * 3.3. Redistribution of Executable. Redistribution in executable form of any
69 * substantial portion of the Covered Code or modification must reproduce the
70 * above Copyright Notice, and the following Disclaimer and Export Compliance
71 * provision in the documentation and/or other materials provided with the
72 * distribution.
73 *
74 * 3.4. Intel retains all right, title, and interest in and to the Original
75 * Intel Code.
76 *
77 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
78 * Intel shall be used in advertising or otherwise to promote the sale, use or
79 * other dealings in products derived from or relating to the Covered Code
80 * without prior written authorization from Intel.
81 *
82 * 4. Disclaimer and Export Compliance
83 *
84 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
85 * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
86 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
87 * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
88 * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
89 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
90 * PARTICULAR PURPOSE.
91 *
92 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
93 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
94 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
95 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
96 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
97 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
98 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
99 * LIMITED REMEDY.
100 *
101 * 4.3. Licensee shall not export, either directly or indirectly, any of this
102 * software or system incorporating such software without first obtaining any
103 * required license or other approval from the U. S. Department of Commerce or
104 * any other agency or department of the United States Government.  In the
105 * event Licensee exports any such software from the United States or
106 * re-exports any such software from a foreign destination, Licensee shall
107 * ensure that the distribution and export/re-export of the software is in
108 * compliance with all laws, regulations, orders, or other restrictions of the
109 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
110 * any of its subsidiaries will export/re-export any technical data, process,
111 * software, or service, directly or indirectly, to any country for which the
112 * United States government or any agency thereof requires an export license,
113 * other governmental approval, or letter of assurance, without first obtaining
114 * such license, approval or letter.
115 *
116 *****************************************************************************/
117
118#define __RSLIST_C__
119
120#include "acpi.h"
121#include "acresrc.h"
122
123#define _COMPONENT          RESOURCE_MANAGER
124        MODULE_NAME         ("rslist")
125
126
127/*******************************************************************************
128 *
129 * FUNCTION:    AcpiRsByteStreamToList
130 *
131 * PARAMETERS:  ByteStreamBuffer        - Pointer to the resource byte stream
132 *              ByteStreamBufferLength  - Length of ByteStreamBuffer
133 *              OutputBuffer            - Pointer to the buffer that will
134 *                                          contain the output structures
135 *
136 * RETURN:      Status  AE_OK if okay, else a valid ACPI_STATUS code
137 *
138 * DESCRIPTION: Takes the resource byte stream and parses it, creating a
139 *              linked list of resources in the caller's output buffer
140 *
141 ******************************************************************************/
142
143ACPI_STATUS
144AcpiRsByteStreamToList (
145    UINT8                   *ByteStreamBuffer,
146    UINT32                  ByteStreamBufferLength,
147    UINT8                   **OutputBuffer)
148{
149    ACPI_STATUS             Status;
150    UINT32                  BytesParsed = 0;
151    UINT8                   ResourceType = 0;
152    UINT32                  BytesConsumed = 0;
153    UINT8                   **Buffer = OutputBuffer;
154    UINT32                  StructureSize = 0;
155    BOOLEAN                 EndTagProcessed = FALSE;
156
157
158    FUNCTION_TRACE ("RsByteStreamToList");
159
160
161    while (BytesParsed < ByteStreamBufferLength &&
162            FALSE == EndTagProcessed)
163    {
164        /*
165         * Look at the next byte in the stream
166         */
167        ResourceType = *ByteStreamBuffer;
168
169        /*
170         * See if this is a small or large resource
171         */
172        if(ResourceType & 0x80)
173        {
174            /*
175             * Large Resource Type
176             */
177            switch (ResourceType)
178            {
179            case MEMORY_RANGE_24:
180                /*
181                 * 24-Bit Memory Resource
182                 */
183                Status = AcpiRsMemory24Resource(ByteStreamBuffer,
184                                                &BytesConsumed,
185                                                Buffer,
186                                                &StructureSize);
187
188                break;
189
190            case LARGE_VENDOR_DEFINED:
191                /*
192                 * Vendor Defined Resource
193                 */
194                Status = AcpiRsVendorResource(ByteStreamBuffer,
195                                              &BytesConsumed,
196                                              Buffer,
197                                              &StructureSize);
198
199                break;
200
201            case MEMORY_RANGE_32:
202                /*
203                 * 32-Bit Memory Range Resource
204                 */
205                Status = AcpiRsMemory32RangeResource(ByteStreamBuffer,
206                                                     &BytesConsumed,
207                                                     Buffer,
208                                                     &StructureSize);
209
210                break;
211
212            case FIXED_MEMORY_RANGE_32:
213                /*
214                 * 32-Bit Fixed Memory Resource
215                 */
216                Status = AcpiRsFixedMemory32Resource(ByteStreamBuffer,
217                                                     &BytesConsumed,
218                                                     Buffer,
219                                                     &StructureSize);
220
221                break;
222
223            case DWORD_ADDRESS_SPACE:
224                /*
225                 * 32-Bit Address Resource
226                 */
227                Status = AcpiRsAddress32Resource(ByteStreamBuffer,
228                                                 &BytesConsumed,
229                                                 Buffer,
230                                                 &StructureSize);
231
232                break;
233
234            case WORD_ADDRESS_SPACE:
235                /*
236                 * 16-Bit Address Resource
237                 */
238                Status = AcpiRsAddress16Resource(ByteStreamBuffer,
239                                                 &BytesConsumed,
240                                                 Buffer,
241                                                 &StructureSize);
242
243                break;
244
245            case EXTENDED_IRQ:
246                /*
247                 * Extended IRQ
248                 */
249                Status = AcpiRsExtendedIrqResource(ByteStreamBuffer,
250                                                   &BytesConsumed,
251                                                   Buffer,
252                                                   &StructureSize);
253
254                break;
255
256/* TBD: [Future] 64-bit not currently supported */
257/*
258            case 0x8A:
259                break;
260*/
261
262            default:
263                /*
264                 * If we get here, everything is out of sync,
265                 *  so exit with an error
266                 */
267                return_ACPI_STATUS (AE_AML_ERROR);
268                break;
269            }
270        }
271
272        else
273        {
274            /*
275             * Small Resource Type
276             *  Only bits 7:3 are valid
277             */
278            ResourceType >>= 3;
279
280            switch(ResourceType)
281            {
282            case IRQ_FORMAT:
283                /*
284                 * IRQ Resource
285                 */
286                Status = AcpiRsIrqResource(ByteStreamBuffer,
287                                           &BytesConsumed,
288                                           Buffer,
289                                           &StructureSize);
290
291                break;
292
293            case DMA_FORMAT:
294                /*
295                 * DMA Resource
296                 */
297                Status = AcpiRsDmaResource(ByteStreamBuffer,
298                                           &BytesConsumed,
299                                           Buffer,
300                                           &StructureSize);
301
302                break;
303
304            case START_DEPENDENT_TAG:
305                /*
306                 * Start Dependent Functions Resource
307                 */
308                Status = AcpiRsStartDependentFunctionsResource(ByteStreamBuffer,
309                                                               &BytesConsumed,
310                                                               Buffer,
311                                                               &StructureSize);
312
313                break;
314
315            case END_DEPENDENT_TAG:
316                /*
317                 * End Dependent Functions Resource
318                 */
319                Status = AcpiRsEndDependentFunctionsResource(ByteStreamBuffer,
320                                                             &BytesConsumed,
321                                                             Buffer,
322                                                             &StructureSize);
323
324                break;
325
326            case IO_PORT_DESCRIPTOR:
327                /*
328                 * IO Port Resource
329                 */
330                Status = AcpiRsIoResource(ByteStreamBuffer,
331                                          &BytesConsumed,
332                                          Buffer,
333                                          &StructureSize);
334
335                break;
336
337            case FIXED_LOCATION_IO_DESCRIPTOR:
338                /*
339                 * Fixed IO Port Resource
340                 */
341                Status = AcpiRsFixedIoResource(ByteStreamBuffer,
342                                               &BytesConsumed,
343                                               Buffer,
344                                               &StructureSize);
345
346                break;
347
348            case SMALL_VENDOR_DEFINED:
349                /*
350                 * Vendor Specific Resource
351                 */
352                Status = AcpiRsVendorResource(ByteStreamBuffer,
353                                              &BytesConsumed,
354                                              Buffer,
355                                              &StructureSize);
356
357                break;
358
359            case END_TAG:
360                /*
361                 * End Tag
362                 */
363                Status = AcpiRsEndTagResource(ByteStreamBuffer,
364                                              &BytesConsumed,
365                                              Buffer,
366                                              &StructureSize);
367                EndTagProcessed = TRUE;
368
369                break;
370
371            default:
372                /*
373                 * If we get here, everything is out of sync,
374                 *  so exit with an error
375                 */
376                return_ACPI_STATUS (AE_AML_ERROR);
377                break;
378
379            } /* switch */
380        }  /* end else */
381
382        /*
383         * Update the return value and counter
384         */
385        BytesParsed += BytesConsumed;
386
387        /*
388         * Set the byte stream to point to the next resource
389         */
390        ByteStreamBuffer += BytesConsumed;
391
392        /*
393         * Set the Buffer to the next structure
394         */
395        *Buffer += StructureSize;
396
397    } /*  end while */
398
399    /*
400     * Check the reason for exiting the while loop
401     */
402    if (!(ByteStreamBufferLength == BytesParsed) ||
403         (TRUE != EndTagProcessed))
404    {
405        return_ACPI_STATUS (AE_AML_ERROR);
406    }
407
408    return_ACPI_STATUS (AE_OK);
409}
410
411
412/*******************************************************************************
413 *
414 * FUNCTION:    AcpiRsListToByteStream
415 *
416 * PARAMETERS:  LinkedList              - Pointer to the resource linked list
417 *              ByteSteamSizeNeeded     - Calculated size of the byte stream
418 *                                          needed from calling
419 *                                          AcpiRsCalculateByteStreamLength()
420 *                                          The size of the OutputBuffer is
421 *                                          guaranteed to be >=
422 *                                          ByteStreamSizeNeeded
423 *              OutputBuffer            - Pointer to the buffer that will
424 *                                          contain the byte stream
425 *
426 * RETURN:      Status  AE_OK if okay, else a valid ACPI_STATUS code
427 *
428 * DESCRIPTION: Takes the resource linked list and parses it, creating a
429 *              byte stream of resources in the caller's output buffer
430 *
431 ******************************************************************************/
432
433ACPI_STATUS
434AcpiRsListToByteStream (
435    RESOURCE                *LinkedList,
436    UINT32                  ByteStreamSizeNeeded,
437    UINT8                   **OutputBuffer)
438{
439    ACPI_STATUS             Status;
440    UINT8                   *Buffer = *OutputBuffer;
441    UINT32                  BytesConsumed = 0;
442    BOOLEAN                 Done = FALSE;
443
444
445    FUNCTION_TRACE ("RsListToByteStream");
446
447    while (!Done)
448    {
449        switch (LinkedList->Id)
450        {
451        case Irq:
452            /*
453             * IRQ Resource
454             */
455            Status = AcpiRsIrqStream (LinkedList,
456                                      &Buffer,
457                                      &BytesConsumed);
458            break;
459
460        case Dma:
461            /*
462             * DMA Resource
463             */
464            Status = AcpiRsDmaStream (LinkedList,
465                                      &Buffer,
466                                      &BytesConsumed);
467            break;
468
469        case StartDependentFunctions:
470            /*
471             * Start Dependent Functions Resource
472             */
473            Status = AcpiRsStartDependentFunctionsStream (LinkedList,
474                                                          &Buffer,
475                                                          &BytesConsumed);
476            break;
477
478        case EndDependentFunctions:
479            /*
480             * End Dependent Functions Resource
481             */
482            Status = AcpiRsEndDependentFunctionsStream (LinkedList,
483                                                        &Buffer,
484                                                        &BytesConsumed);
485            break;
486
487        case Io:
488            /*
489             * IO Port Resource
490             */
491            Status = AcpiRsIoStream (LinkedList,
492                                     &Buffer,
493                                     &BytesConsumed);
494            break;
495
496        case FixedIo:
497            /*
498             * Fixed IO Port Resource
499             */
500            Status = AcpiRsFixedIoStream (LinkedList,
501                                          &Buffer,
502                                          &BytesConsumed);
503            break;
504
505        case VendorSpecific:
506            /*
507             * Vendor Defined Resource
508             */
509            Status = AcpiRsVendorStream (LinkedList,
510                                         &Buffer,
511                                         &BytesConsumed);
512            break;
513
514        case EndTag:
515            /*
516             * End Tag
517             */
518            Status = AcpiRsEndTagStream (LinkedList,
519                                         &Buffer,
520                                         &BytesConsumed);
521
522            /*
523             * An End Tag indicates the end of the Resource Template
524             */
525            Done = TRUE;
526            break;
527
528        case Memory24:
529            /*
530             * 24-Bit Memory Resource
531             */
532            Status = AcpiRsMemory24Stream (LinkedList,
533                                           &Buffer,
534                                           &BytesConsumed);
535            break;
536
537        case Memory32:
538            /*
539             * 32-Bit Memory Range Resource
540             */
541            Status = AcpiRsMemory32RangeStream (LinkedList,
542                                                &Buffer,
543                                                &BytesConsumed);
544            break;
545
546        case FixedMemory32:
547            /*
548             * 32-Bit Fixed Memory Resource
549             */
550            Status = AcpiRsFixedMemory32Stream (LinkedList,
551                                                &Buffer,
552                                                &BytesConsumed);
553            break;
554
555        case Address16:
556            /*
557             * 16-Bit Address Descriptor Resource
558             */
559            Status = AcpiRsAddress16Stream (LinkedList,
560                                            &Buffer,
561                                            &BytesConsumed);
562            break;
563
564        case Address32:
565            /*
566             * 32-Bit Address Descriptor Resource
567             */
568            Status = AcpiRsAddress32Stream (LinkedList,
569                                            &Buffer,
570                                            &BytesConsumed);
571            break;
572
573        case ExtendedIrq:
574            /*
575             * Extended IRQ Resource
576             */
577            Status = AcpiRsExtendedIrqStream (LinkedList,
578                                              &Buffer,
579                                              &BytesConsumed);
580            break;
581
582        default:
583            /*
584             * If we get here, everything is out of sync,
585             *  so exit with an error
586             */
587            return_ACPI_STATUS (AE_BAD_DATA);
588            break;
589
590        } /* switch (LinkedList->Id) */
591
592        /*
593         * Set the Buffer to point to the open byte
594         */
595        Buffer += BytesConsumed;
596
597        /*
598         * Point to the next object
599         */
600        LinkedList = (RESOURCE *) ((NATIVE_UINT) LinkedList +
601                     (NATIVE_UINT) LinkedList->Length);
602    }
603
604    return_ACPI_STATUS  (AE_OK);
605}
606
607