Some laptops return other values for working toucpads. Allow test_aux_port to
[dragonfly.git] / sys / contrib / dev / acpica-unix-20031203 / resources / rsaddr.c
1 /*******************************************************************************
2  *
3  * Module Name: rsaddr - Address resource descriptors (16/32/64)
4  *              $Revision: 33 $
5  *
6  ******************************************************************************/
7
8 /******************************************************************************
9  *
10  * 1. Copyright Notice
11  *
12  * Some or all of this work - Copyright (c) 1999 - 2003, Intel Corp.
13  * All rights reserved.
14  *
15  * 2. License
16  *
17  * 2.1. This is your license from Intel Corp. under its intellectual property
18  * rights.  You may have additional license terms from the party that provided
19  * you this software, covering your right to use that party's intellectual
20  * property rights.
21  *
22  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
23  * copy of the source code appearing in this file ("Covered Code") an
24  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
25  * base code distributed originally by Intel ("Original Intel Code") to copy,
26  * make derivatives, distribute, use and display any portion of the Covered
27  * Code in any form, with the right to sublicense such rights; and
28  *
29  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
30  * license (with the right to sublicense), under only those claims of Intel
31  * patents that are infringed by the Original Intel Code, to make, use, sell,
32  * offer to sell, and import the Covered Code and derivative works thereof
33  * solely to the minimum extent necessary to exercise the above copyright
34  * license, and in no event shall the patent license extend to any additions
35  * to or modifications of the Original Intel Code.  No other license or right
36  * is granted directly or by implication, estoppel or otherwise;
37  *
38  * The above copyright and patent license is granted only if the following
39  * conditions are met:
40  *
41  * 3. Conditions
42  *
43  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
44  * Redistribution of source code of any substantial portion of the Covered
45  * Code or modification with rights to further distribute source must include
46  * the above Copyright Notice, the above License, this list of Conditions,
47  * and the following Disclaimer and Export Compliance provision.  In addition,
48  * Licensee must cause all Covered Code to which Licensee contributes to
49  * contain a file documenting the changes Licensee made to create that Covered
50  * Code and the date of any change.  Licensee must include in that file the
51  * documentation of any changes made by any predecessor Licensee.  Licensee
52  * must include a prominent statement that the modification is derived,
53  * directly or indirectly, from Original Intel Code.
54  *
55  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
56  * Redistribution of source code of any substantial portion of the Covered
57  * Code or modification without rights to further distribute source must
58  * include the following Disclaimer and Export Compliance provision in the
59  * documentation and/or other materials provided with distribution.  In
60  * addition, Licensee may not authorize further sublicense of source of any
61  * portion of the Covered Code, and must include terms to the effect that the
62  * license from Licensee to its licensee is limited to the intellectual
63  * property embodied in the software Licensee provides to its licensee, and
64  * not to intellectual property embodied in modifications its licensee may
65  * make.
66  *
67  * 3.3. Redistribution of Executable. Redistribution in executable form of any
68  * substantial portion of the Covered Code or modification must reproduce the
69  * above Copyright Notice, and the following Disclaimer and Export Compliance
70  * provision in the documentation and/or other materials provided with the
71  * distribution.
72  *
73  * 3.4. Intel retains all right, title, and interest in and to the Original
74  * Intel Code.
75  *
76  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
77  * Intel shall be used in advertising or otherwise to promote the sale, use or
78  * other dealings in products derived from or relating to the Covered Code
79  * without prior written authorization from Intel.
80  *
81  * 4. Disclaimer and Export Compliance
82  *
83  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
84  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
85  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
86  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
87  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
88  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
89  * PARTICULAR PURPOSE.
90  *
91  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
92  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
93  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
94  * 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 __RSADDR_C__
118
119 #include "acpi.h"
120 #include "acresrc.h"
121
122 #define _COMPONENT          ACPI_RESOURCES
123         ACPI_MODULE_NAME    ("rsaddr")
124
125
126 /*******************************************************************************
127  *
128  * FUNCTION:    AcpiRsAddress16Resource
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
147 ACPI_STATUS
148 AcpiRsAddress16Resource (
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     UINT8                   *TempPtr;
157     ACPI_SIZE               StructSize = ACPI_SIZEOF_RESOURCE (ACPI_RESOURCE_ADDRESS16);
158     UINT32                  Index;
159     UINT16                  Temp16;
160     UINT8                   Temp8;
161
162
163     ACPI_FUNCTION_TRACE ("RsAddress16Resource");
164
165     /*
166      * Point past the Descriptor to get the number of bytes consumed
167      */
168     Buffer += 1;
169     ACPI_MOVE_16_TO_16 (&Temp16, Buffer);
170
171     /* Validate minimum descriptor length */
172
173     if (Temp16 < 13)
174     {
175         return_ACPI_STATUS (AE_AML_BAD_RESOURCE_LENGTH);
176     }
177
178     *BytesConsumed = Temp16 + 3;
179     OutputStruct->Id = ACPI_RSTYPE_ADDRESS16;
180
181     /*
182      * Get the Resource Type (Byte3)
183      */
184     Buffer += 2;
185     Temp8 = *Buffer;
186
187     /* Values 0-2 are valid */
188
189     if (Temp8 > 2)
190     {
191         return_ACPI_STATUS (AE_AML_INVALID_RESOURCE_TYPE);
192     }
193
194     OutputStruct->Data.Address16.ResourceType = Temp8 & 0x03;
195
196     /*
197      * Get the General Flags (Byte4)
198      */
199     Buffer += 1;
200     Temp8 = *Buffer;
201
202     /* Producer / Consumer */
203
204     OutputStruct->Data.Address16.ProducerConsumer = Temp8 & 0x01;
205
206     /* Decode */
207
208     OutputStruct->Data.Address16.Decode = (Temp8 >> 1) & 0x01;
209
210     /* Min Address Fixed */
211
212     OutputStruct->Data.Address16.MinAddressFixed = (Temp8 >> 2) & 0x01;
213
214     /* Max Address Fixed */
215
216     OutputStruct->Data.Address16.MaxAddressFixed = (Temp8 >> 3) & 0x01;
217
218     /*
219      * Get the Type Specific Flags (Byte5)
220      */
221     Buffer += 1;
222     Temp8 = *Buffer;
223
224     if (ACPI_MEMORY_RANGE == OutputStruct->Data.Address16.ResourceType)
225     {
226         OutputStruct->Data.Address16.Attribute.Memory.ReadWriteAttribute =
227                 (UINT16) (Temp8 & 0x01);
228         OutputStruct->Data.Address16.Attribute.Memory.CacheAttribute =
229                 (UINT16) ((Temp8 >> 1) & 0x0F);
230     }
231     else
232     {
233         if (ACPI_IO_RANGE == OutputStruct->Data.Address16.ResourceType)
234         {
235             OutputStruct->Data.Address16.Attribute.Io.RangeAttribute =
236                 (UINT16) (Temp8 & 0x03);
237             OutputStruct->Data.Address16.Attribute.Io.TranslationAttribute =
238                 (UINT16) ((Temp8 >> 4) & 0x03);
239         }
240         else
241         {
242             /* BUS_NUMBER_RANGE == Address16.Data->ResourceType */
243             /* Nothing needs to be filled in */
244         }
245     }
246
247     /*
248      * Get Granularity (Bytes 6-7)
249      */
250     Buffer += 1;
251     ACPI_MOVE_16_TO_32 (&OutputStruct->Data.Address16.Granularity, Buffer);
252
253     /*
254      * Get MinAddressRange (Bytes 8-9)
255      */
256     Buffer += 2;
257     ACPI_MOVE_16_TO_32 (&OutputStruct->Data.Address16.MinAddressRange, Buffer);
258
259     /*
260      * Get MaxAddressRange (Bytes 10-11)
261      */
262     Buffer += 2;
263     ACPI_MOVE_16_TO_32 (&OutputStruct->Data.Address16.MaxAddressRange, Buffer);
264
265     /*
266      * Get AddressTranslationOffset (Bytes 12-13)
267      */
268     Buffer += 2;
269     ACPI_MOVE_16_TO_32 (&OutputStruct->Data.Address16.AddressTranslationOffset, Buffer);
270
271     /*
272      * Get AddressLength (Bytes 14-15)
273      */
274     Buffer += 2;
275     ACPI_MOVE_16_TO_32 (&OutputStruct->Data.Address16.AddressLength, Buffer);
276
277     /*
278      * Resource Source Index (if present)
279      */
280     Buffer += 2;
281
282     /*
283      * This will leave us pointing to the Resource Source Index
284      * If it is present, then save it off and calculate the
285      * pointer to where the null terminated string goes:
286      * Each Interrupt takes 32-bits + the 5 bytes of the
287      * stream that are default.
288      *
289      * Note: Some resource descriptors will have an additional null, so
290      * we add 1 to the length.
291      */
292     if (*BytesConsumed > (16 + 1))
293     {
294         /* Dereference the Index */
295
296         Temp8 = *Buffer;
297         OutputStruct->Data.Address16.ResourceSource.Index = (UINT32) Temp8;
298
299         /* Point to the String */
300
301         Buffer += 1;
302
303         /* Point the String pointer to the end of this structure */
304
305         OutputStruct->Data.Address16.ResourceSource.StringPtr =
306                 (char *)((UINT8 * )OutputStruct + StructSize);
307
308         TempPtr = (UINT8 *) OutputStruct->Data.Address16.ResourceSource.StringPtr;
309
310         /* Copy the string into the buffer */
311
312         Index = 0;
313
314         while (0x00 != *Buffer)
315         {
316             *TempPtr = *Buffer;
317
318             TempPtr += 1;
319             Buffer += 1;
320             Index += 1;
321         }
322
323         /*
324          * Add the terminating null
325          */
326         *TempPtr = 0x00;
327
328         OutputStruct->Data.Address16.ResourceSource.StringLength = Index + 1;
329
330         /*
331          * In order for the StructSize to fall on a 32-bit boundary,
332          * calculate the length of the string and expand the
333          * StructSize to the next 32-bit boundary.
334          */
335         Temp8 = (UINT8) (Index + 1);
336         StructSize += ACPI_ROUND_UP_TO_32BITS (Temp8);
337     }
338     else
339     {
340         OutputStruct->Data.Address16.ResourceSource.Index = 0x00;
341         OutputStruct->Data.Address16.ResourceSource.StringLength = 0;
342         OutputStruct->Data.Address16.ResourceSource.StringPtr = NULL;
343     }
344
345     /*
346      * Set the Length parameter
347      */
348     OutputStruct->Length = (UINT32) StructSize;
349
350     /*
351      * Return the final size of the structure
352      */
353     *StructureSize = StructSize;
354     return_ACPI_STATUS (AE_OK);
355 }
356
357
358 /*******************************************************************************
359  *
360  * FUNCTION:    AcpiRsAddress16Stream
361  *
362  * PARAMETERS:  LinkedList              - Pointer to the resource linked list
363  *              OutputBuffer            - Pointer to the user's return buffer
364  *              BytesConsumed           - Pointer to where the number of bytes
365  *                                        used in the OutputBuffer is returned
366  *
367  * RETURN:      Status
368  *
369  * DESCRIPTION: Take the linked list resource structure and fills in the
370  *              the appropriate bytes in a byte stream
371  *
372  ******************************************************************************/
373
374 ACPI_STATUS
375 AcpiRsAddress16Stream (
376     ACPI_RESOURCE           *LinkedList,
377     UINT8                   **OutputBuffer,
378     ACPI_SIZE               *BytesConsumed)
379 {
380     UINT8                   *Buffer = *OutputBuffer;
381     UINT8                   *LengthField;
382     UINT8                   Temp8;
383     char                    *TempPointer = NULL;
384     ACPI_SIZE               ActualBytes;
385
386
387     ACPI_FUNCTION_TRACE ("RsAddress16Stream");
388
389
390     /*
391      * The descriptor field is static
392      */
393     *Buffer = 0x88;
394     Buffer += 1;
395
396     /*
397      * Save a pointer to the Length field - to be filled in later
398      */
399     LengthField = Buffer;
400     Buffer += 2;
401
402     /*
403      * Set the Resource Type (Memory, Io, BusNumber)
404      */
405     Temp8 = (UINT8) (LinkedList->Data.Address16.ResourceType & 0x03);
406     *Buffer = Temp8;
407     Buffer += 1;
408
409     /*
410      * Set the general flags
411      */
412     Temp8 = (UINT8) (LinkedList->Data.Address16.ProducerConsumer & 0x01);
413
414     Temp8 |= (LinkedList->Data.Address16.Decode & 0x01) << 1;
415     Temp8 |= (LinkedList->Data.Address16.MinAddressFixed & 0x01) << 2;
416     Temp8 |= (LinkedList->Data.Address16.MaxAddressFixed & 0x01) << 3;
417
418     *Buffer = Temp8;
419     Buffer += 1;
420
421     /*
422      * Set the type specific flags
423      */
424     Temp8 = 0;
425
426     if (ACPI_MEMORY_RANGE == LinkedList->Data.Address16.ResourceType)
427     {
428         Temp8 = (UINT8)
429             (LinkedList->Data.Address16.Attribute.Memory.ReadWriteAttribute &
430              0x01);
431
432         Temp8 |=
433             (LinkedList->Data.Address16.Attribute.Memory.CacheAttribute &
434              0x0F) << 1;
435     }
436     else if (ACPI_IO_RANGE == LinkedList->Data.Address16.ResourceType)
437     {
438         Temp8 = (UINT8)
439             (LinkedList->Data.Address16.Attribute.Io.RangeAttribute &
440              0x03);
441         Temp8 |=
442             (LinkedList->Data.Address16.Attribute.Io.TranslationAttribute &
443              0x03) << 4;
444     }
445
446     *Buffer = Temp8;
447     Buffer += 1;
448
449     /*
450      * Set the address space granularity
451      */
452     ACPI_MOVE_32_TO_16 (Buffer, &LinkedList->Data.Address16.Granularity);
453     Buffer += 2;
454
455     /*
456      * Set the address range minimum
457      */
458     ACPI_MOVE_32_TO_16 (Buffer, &LinkedList->Data.Address16.MinAddressRange);
459     Buffer += 2;
460
461     /*
462      * Set the address range maximum
463      */
464     ACPI_MOVE_32_TO_16 (Buffer, &LinkedList->Data.Address16.MaxAddressRange);
465     Buffer += 2;
466
467     /*
468      * Set the address translation offset
469      */
470     ACPI_MOVE_32_TO_16 (Buffer, &LinkedList->Data.Address16.AddressTranslationOffset);
471     Buffer += 2;
472
473     /*
474      * Set the address length
475      */
476     ACPI_MOVE_32_TO_16 (Buffer, &LinkedList->Data.Address16.AddressLength);
477     Buffer += 2;
478
479     /*
480      * Resource Source Index and Resource Source are optional
481      */
482     if (0 != LinkedList->Data.Address16.ResourceSource.StringLength)
483     {
484         Temp8 = (UINT8) LinkedList->Data.Address16.ResourceSource.Index;
485
486         *Buffer = Temp8;
487         Buffer += 1;
488
489         TempPointer = (char *) Buffer;
490
491         /*
492          * Copy the string
493          */
494         ACPI_STRCPY (TempPointer,
495                 LinkedList->Data.Address16.ResourceSource.StringPtr);
496
497         /*
498          * Buffer needs to be set to the length of the sting + one for the
499          * terminating null
500          */
501         Buffer += (ACPI_SIZE)(ACPI_STRLEN (LinkedList->Data.Address16.ResourceSource.StringPtr) + 1);
502     }
503
504     /*
505      * Return the number of bytes consumed in this operation
506      */
507     ActualBytes = ACPI_PTR_DIFF (Buffer, *OutputBuffer);
508     *BytesConsumed = ActualBytes;
509
510     /*
511      * Set the length field to the number of bytes consumed
512      * minus the header size (3 bytes)
513      */
514     ActualBytes -= 3;
515     ACPI_MOVE_SIZE_TO_16 (LengthField, &ActualBytes);
516     return_ACPI_STATUS (AE_OK);
517 }
518
519
520 /*******************************************************************************
521  *
522  * FUNCTION:    AcpiRsAddress32Resource
523  *
524  * PARAMETERS:  ByteStreamBuffer        - Pointer to the resource input byte
525  *                                        stream
526  *              BytesConsumed           - Pointer to where the number of bytes
527  *                                        consumed the ByteStreamBuffer is
528  *                                        returned
529  *              OutputBuffer            - Pointer to the return data buffer
530  *              StructureSize           - Pointer to where the number of bytes
531  *                                        in the return data struct is returned
532  *
533  * RETURN:      Status
534  *
535  * DESCRIPTION: Take the resource byte stream and fill out the appropriate
536  *              structure pointed to by the OutputBuffer.  Return the
537  *              number of bytes consumed from the byte stream.
538  *
539  ******************************************************************************/
540
541 ACPI_STATUS
542 AcpiRsAddress32Resource (
543     UINT8                   *ByteStreamBuffer,
544     ACPI_SIZE               *BytesConsumed,
545     UINT8                   **OutputBuffer,
546     ACPI_SIZE               *StructureSize)
547 {
548     UINT8                   *Buffer;
549     ACPI_RESOURCE           *OutputStruct= (void *) *OutputBuffer;
550     UINT16                  Temp16;
551     UINT8                   Temp8;
552     UINT8                   *TempPtr;
553     ACPI_SIZE               StructSize;
554     UINT32                  Index;
555
556
557     ACPI_FUNCTION_TRACE ("RsAddress32Resource");
558
559
560     Buffer = ByteStreamBuffer;
561     StructSize = ACPI_SIZEOF_RESOURCE (ACPI_RESOURCE_ADDRESS32);
562
563     /*
564      * Point past the Descriptor to get the number of bytes consumed
565      */
566     Buffer += 1;
567     ACPI_MOVE_16_TO_16 (&Temp16, Buffer);
568
569     /* Validate minimum descriptor length */
570
571     if (Temp16 < 23)
572     {
573         return_ACPI_STATUS (AE_AML_BAD_RESOURCE_LENGTH);
574     }
575
576     *BytesConsumed = Temp16 + 3;
577     OutputStruct->Id = ACPI_RSTYPE_ADDRESS32;
578
579     /*
580      * Get the Resource Type (Byte3)
581      */
582     Buffer += 2;
583     Temp8 = *Buffer;
584
585     /* Values 0-2 are valid */
586     if(Temp8 > 2)
587     {
588         return_ACPI_STATUS (AE_AML_INVALID_RESOURCE_TYPE);
589     }
590
591     OutputStruct->Data.Address32.ResourceType = Temp8 & 0x03;
592
593     /*
594      * Get the General Flags (Byte4)
595      */
596     Buffer += 1;
597     Temp8 = *Buffer;
598
599     /*
600      * Producer / Consumer
601      */
602     OutputStruct->Data.Address32.ProducerConsumer = Temp8 & 0x01;
603
604     /*
605      * Decode
606      */
607     OutputStruct->Data.Address32.Decode = (Temp8 >> 1) & 0x01;
608
609     /*
610      * Min Address Fixed
611      */
612     OutputStruct->Data.Address32.MinAddressFixed = (Temp8 >> 2) & 0x01;
613
614     /*
615      * Max Address Fixed
616      */
617     OutputStruct->Data.Address32.MaxAddressFixed = (Temp8 >> 3) & 0x01;
618
619     /*
620      * Get the Type Specific Flags (Byte5)
621      */
622     Buffer += 1;
623     Temp8 = *Buffer;
624
625     if (ACPI_MEMORY_RANGE == OutputStruct->Data.Address32.ResourceType)
626     {
627         OutputStruct->Data.Address32.Attribute.Memory.ReadWriteAttribute =
628                 (UINT16) (Temp8 & 0x01);
629
630         OutputStruct->Data.Address32.Attribute.Memory.CacheAttribute =
631                 (UINT16) ((Temp8 >> 1) & 0x0F);
632     }
633     else
634     {
635         if (ACPI_IO_RANGE == OutputStruct->Data.Address32.ResourceType)
636         {
637             OutputStruct->Data.Address32.Attribute.Io.RangeAttribute =
638                 (UINT16) (Temp8 & 0x03);
639             OutputStruct->Data.Address32.Attribute.Io.TranslationAttribute =
640                 (UINT16) ((Temp8 >> 4) & 0x03);
641         }
642         else
643         {
644             /* BUS_NUMBER_RANGE == OutputStruct->Data.Address32.ResourceType */
645             /* Nothing needs to be filled in */
646         }
647     }
648
649     /*
650      * Get Granularity (Bytes 6-9)
651      */
652     Buffer += 1;
653     ACPI_MOVE_32_TO_32 (&OutputStruct->Data.Address32.Granularity, Buffer);
654
655     /*
656      * Get MinAddressRange (Bytes 10-13)
657      */
658     Buffer += 4;
659     ACPI_MOVE_32_TO_32 (&OutputStruct->Data.Address32.MinAddressRange, Buffer);
660
661     /*
662      * Get MaxAddressRange (Bytes 14-17)
663      */
664     Buffer += 4;
665     ACPI_MOVE_32_TO_32 (&OutputStruct->Data.Address32.MaxAddressRange, Buffer);
666
667     /*
668      * Get AddressTranslationOffset (Bytes 18-21)
669      */
670     Buffer += 4;
671     ACPI_MOVE_32_TO_32 (&OutputStruct->Data.Address32.AddressTranslationOffset, Buffer);
672
673     /*
674      * Get AddressLength (Bytes 22-25)
675      */
676     Buffer += 4;
677     ACPI_MOVE_32_TO_32 (&OutputStruct->Data.Address32.AddressLength, Buffer);
678
679     /*
680      * Resource Source Index (if present)
681      */
682     Buffer += 4;
683
684     /*
685      * This will leave us pointing to the Resource Source Index
686      * If it is present, then save it off and calculate the
687      * pointer to where the null terminated string goes:
688      *
689      * Note: Some resource descriptors will have an additional null, so
690      * we add 1 to the length.
691      */
692     if (*BytesConsumed > (26 + 1))
693     {
694         /* Dereference the Index */
695
696         Temp8 = *Buffer;
697         OutputStruct->Data.Address32.ResourceSource.Index =
698                 (UINT32) Temp8;
699
700         /* Point to the String */
701
702         Buffer += 1;
703
704         /* Point the String pointer to the end of this structure */
705
706         OutputStruct->Data.Address32.ResourceSource.StringPtr =
707                 (char *)((UINT8 *)OutputStruct + StructSize);
708
709         TempPtr = (UINT8 *) OutputStruct->Data.Address32.ResourceSource.StringPtr;
710
711         /* Copy the string into the buffer */
712
713         Index = 0;
714         while (0x00 != *Buffer)
715         {
716             *TempPtr = *Buffer;
717
718             TempPtr += 1;
719             Buffer += 1;
720             Index += 1;
721         }
722
723         /*
724          * Add the terminating null
725          */
726         *TempPtr = 0x00;
727         OutputStruct->Data.Address32.ResourceSource.StringLength = Index + 1;
728
729         /*
730          * In order for the StructSize to fall on a 32-bit boundary,
731          * calculate the length of the string and expand the
732          * StructSize to the next 32-bit boundary.
733          */
734         Temp8 = (UINT8) (Index + 1);
735         StructSize += ACPI_ROUND_UP_TO_32BITS (Temp8);
736     }
737     else
738     {
739         OutputStruct->Data.Address32.ResourceSource.Index = 0x00;
740         OutputStruct->Data.Address32.ResourceSource.StringLength = 0;
741         OutputStruct->Data.Address32.ResourceSource.StringPtr = NULL;
742     }
743
744     /*
745      * Set the Length parameter
746      */
747     OutputStruct->Length = (UINT32) StructSize;
748
749     /*
750      * Return the final size of the structure
751      */
752     *StructureSize = StructSize;
753     return_ACPI_STATUS (AE_OK);
754 }
755
756
757 /*******************************************************************************
758  *
759  * FUNCTION:    AcpiRsAddress32Stream
760  *
761  * PARAMETERS:  LinkedList              - Pointer to the resource linked list
762  *              OutputBuffer            - Pointer to the user's return buffer
763  *              BytesConsumed           - Pointer to where the number of bytes
764  *                                        used in the OutputBuffer is returned
765  *
766  * RETURN:      Status
767  *
768  * DESCRIPTION: Take the linked list resource structure and fills in the
769  *              the appropriate bytes in a byte stream
770  *
771  ******************************************************************************/
772
773 ACPI_STATUS
774 AcpiRsAddress32Stream (
775     ACPI_RESOURCE           *LinkedList,
776     UINT8                   **OutputBuffer,
777     ACPI_SIZE               *BytesConsumed)
778 {
779     UINT8                   *Buffer;
780     UINT16                  *LengthField;
781     UINT8                   Temp8;
782     char                    *TempPointer;
783
784
785     ACPI_FUNCTION_TRACE ("RsAddress32Stream");
786
787
788     Buffer = *OutputBuffer;
789
790     /*
791      * The descriptor field is static
792      */
793     *Buffer = 0x87;
794     Buffer += 1;
795
796     /*
797      * Set a pointer to the Length field - to be filled in later
798      */
799     LengthField = ACPI_CAST_PTR (UINT16, Buffer);
800     Buffer += 2;
801
802     /*
803      * Set the Resource Type (Memory, Io, BusNumber)
804      */
805     Temp8 = (UINT8) (LinkedList->Data.Address32.ResourceType & 0x03);
806
807     *Buffer = Temp8;
808     Buffer += 1;
809
810     /*
811      * Set the general flags
812      */
813     Temp8 = (UINT8) (LinkedList->Data.Address32.ProducerConsumer & 0x01);
814     Temp8 |= (LinkedList->Data.Address32.Decode & 0x01) << 1;
815     Temp8 |= (LinkedList->Data.Address32.MinAddressFixed & 0x01) << 2;
816     Temp8 |= (LinkedList->Data.Address32.MaxAddressFixed & 0x01) << 3;
817
818     *Buffer = Temp8;
819     Buffer += 1;
820
821     /*
822      * Set the type specific flags
823      */
824     Temp8 = 0;
825
826     if (ACPI_MEMORY_RANGE == LinkedList->Data.Address32.ResourceType)
827     {
828         Temp8 = (UINT8)
829             (LinkedList->Data.Address32.Attribute.Memory.ReadWriteAttribute &
830             0x01);
831
832         Temp8 |=
833             (LinkedList->Data.Address32.Attribute.Memory.CacheAttribute &
834              0x0F) << 1;
835     }
836     else if (ACPI_IO_RANGE == LinkedList->Data.Address32.ResourceType)
837     {
838         Temp8 = (UINT8)
839             (LinkedList->Data.Address32.Attribute.Io.RangeAttribute &
840              0x03);
841         Temp8 |=
842             (LinkedList->Data.Address32.Attribute.Io.TranslationAttribute &
843              0x03) << 4;
844     }
845
846     *Buffer = Temp8;
847     Buffer += 1;
848
849     /*
850      * Set the address space granularity
851      */
852     ACPI_MOVE_32_TO_32 (Buffer, &LinkedList->Data.Address32.Granularity);
853     Buffer += 4;
854
855     /*
856      * Set the address range minimum
857      */
858     ACPI_MOVE_32_TO_32 (Buffer, &LinkedList->Data.Address32.MinAddressRange);
859     Buffer += 4;
860
861     /*
862      * Set the address range maximum
863      */
864     ACPI_MOVE_32_TO_32 (Buffer, &LinkedList->Data.Address32.MaxAddressRange);
865     Buffer += 4;
866
867     /*
868      * Set the address translation offset
869      */
870     ACPI_MOVE_32_TO_32 (Buffer, &LinkedList->Data.Address32.AddressTranslationOffset);
871     Buffer += 4;
872
873     /*
874      * Set the address length
875      */
876     ACPI_MOVE_32_TO_32 (Buffer, &LinkedList->Data.Address32.AddressLength);
877     Buffer += 4;
878
879     /*
880      * Resource Source Index and Resource Source are optional
881      */
882     if (0 != LinkedList->Data.Address32.ResourceSource.StringLength)
883     {
884         Temp8 = (UINT8) LinkedList->Data.Address32.ResourceSource.Index;
885
886         *Buffer = Temp8;
887         Buffer += 1;
888
889         TempPointer = (char *) Buffer;
890
891         /*
892          * Copy the string
893          */
894         ACPI_STRCPY (TempPointer,
895             LinkedList->Data.Address32.ResourceSource.StringPtr);
896
897         /*
898          * Buffer needs to be set to the length of the sting + one for the
899          *  terminating null
900          */
901         Buffer += (ACPI_SIZE)(ACPI_STRLEN (LinkedList->Data.Address32.ResourceSource.StringPtr) + 1);
902     }
903
904     /*
905      * Return the number of bytes consumed in this operation
906      */
907     *BytesConsumed = ACPI_PTR_DIFF (Buffer, *OutputBuffer);
908
909     /*
910      * Set the length field to the number of bytes consumed
911      *  minus the header size (3 bytes)
912      */
913     *LengthField = (UINT16) (*BytesConsumed - 3);
914     return_ACPI_STATUS (AE_OK);
915 }
916
917
918 /*******************************************************************************
919  *
920  * FUNCTION:    AcpiRsAddress64Resource
921  *
922  * PARAMETERS:  ByteStreamBuffer        - Pointer to the resource input byte
923  *                                        stream
924  *              BytesConsumed           - Pointer to where the number of bytes
925  *                                        consumed the ByteStreamBuffer is
926  *                                        returned
927  *              OutputBuffer            - Pointer to the return data buffer
928  *              StructureSize           - Pointer to where the number of bytes
929  *                                        in the return data struct is returned
930  *
931  * RETURN:      Status
932  *
933  * DESCRIPTION: Take the resource byte stream and fill out the appropriate
934  *              structure pointed to by the OutputBuffer.  Return the
935  *              number of bytes consumed from the byte stream.
936  *
937  ******************************************************************************/
938
939 ACPI_STATUS
940 AcpiRsAddress64Resource (
941     UINT8                   *ByteStreamBuffer,
942     ACPI_SIZE               *BytesConsumed,
943     UINT8                   **OutputBuffer,
944     ACPI_SIZE               *StructureSize)
945 {
946     UINT8                   *Buffer;
947     ACPI_RESOURCE           *OutputStruct = (void *) *OutputBuffer;
948     UINT16                  Temp16;
949     UINT8                   Temp8;
950     UINT8                   *TempPtr;
951     ACPI_SIZE               StructSize;
952     UINT32                  Index;
953
954
955     ACPI_FUNCTION_TRACE ("RsAddress64Resource");
956
957
958     Buffer = ByteStreamBuffer;
959     StructSize = ACPI_SIZEOF_RESOURCE (ACPI_RESOURCE_ADDRESS64);
960
961     /*
962      * Point past the Descriptor to get the number of bytes consumed
963      */
964     Buffer += 1;
965     ACPI_MOVE_16_TO_16 (&Temp16, Buffer);
966
967     /* Validate minimum descriptor length */
968
969     if (Temp16 < 43)
970     {
971         return_ACPI_STATUS (AE_AML_BAD_RESOURCE_LENGTH);
972     }
973
974     *BytesConsumed = Temp16 + 3;
975     OutputStruct->Id = ACPI_RSTYPE_ADDRESS64;
976
977     /*
978      * Get the Resource Type (Byte3)
979      */
980     Buffer += 2;
981     Temp8 = *Buffer;
982
983     /* Values 0-2 are valid */
984
985     if(Temp8 > 2)
986     {
987         return_ACPI_STATUS (AE_AML_INVALID_RESOURCE_TYPE);
988     }
989
990     OutputStruct->Data.Address64.ResourceType = Temp8 & 0x03;
991
992     /*
993      * Get the General Flags (Byte4)
994      */
995     Buffer += 1;
996     Temp8 = *Buffer;
997
998     /*
999      * Producer / Consumer
1000      */
1001     OutputStruct->Data.Address64.ProducerConsumer = Temp8 & 0x01;
1002
1003     /*
1004      * Decode
1005      */
1006     OutputStruct->Data.Address64.Decode = (Temp8 >> 1) & 0x01;
1007
1008     /*
1009      * Min Address Fixed
1010      */
1011     OutputStruct->Data.Address64.MinAddressFixed = (Temp8 >> 2) & 0x01;
1012
1013     /*
1014      * Max Address Fixed
1015      */
1016     OutputStruct->Data.Address64.MaxAddressFixed = (Temp8 >> 3) & 0x01;
1017
1018     /*
1019      * Get the Type Specific Flags (Byte5)
1020      */
1021     Buffer += 1;
1022     Temp8 = *Buffer;
1023
1024     if (ACPI_MEMORY_RANGE == OutputStruct->Data.Address64.ResourceType)
1025     {
1026         OutputStruct->Data.Address64.Attribute.Memory.ReadWriteAttribute =
1027                 (UINT16) (Temp8 & 0x01);
1028
1029         OutputStruct->Data.Address64.Attribute.Memory.CacheAttribute =
1030                 (UINT16) ((Temp8 >> 1) & 0x0F);
1031     }
1032     else
1033     {
1034         if (ACPI_IO_RANGE == OutputStruct->Data.Address64.ResourceType)
1035         {
1036             OutputStruct->Data.Address64.Attribute.Io.RangeAttribute =
1037                 (UINT16) (Temp8 & 0x03);
1038             OutputStruct->Data.Address64.Attribute.Io.TranslationAttribute =
1039                 (UINT16) ((Temp8 >> 4) & 0x03);
1040         }
1041         else
1042         {
1043             /* BUS_NUMBER_RANGE == OutputStruct->Data.Address64.ResourceType */
1044             /* Nothing needs to be filled in */
1045         }
1046     }
1047
1048     /*
1049      * Get Granularity (Bytes 6-13)
1050      */
1051     Buffer += 1;
1052     ACPI_MOVE_64_TO_64 (&OutputStruct->Data.Address64.Granularity, Buffer);
1053
1054     /*
1055      * Get MinAddressRange (Bytes 14-21)
1056      */
1057     Buffer += 8;
1058     ACPI_MOVE_64_TO_64 (&OutputStruct->Data.Address64.MinAddressRange, Buffer);
1059
1060     /*
1061      * Get MaxAddressRange (Bytes 22-29)
1062      */
1063     Buffer += 8;
1064     ACPI_MOVE_64_TO_64 (&OutputStruct->Data.Address64.MaxAddressRange, Buffer);
1065
1066     /*
1067      * Get AddressTranslationOffset (Bytes 30-37)
1068      */
1069     Buffer += 8;
1070     ACPI_MOVE_64_TO_64 (&OutputStruct->Data.Address64.AddressTranslationOffset, Buffer);
1071
1072     /*
1073      * Get AddressLength (Bytes 38-45)
1074      */
1075     Buffer += 8;
1076     ACPI_MOVE_64_TO_64 (&OutputStruct->Data.Address64.AddressLength, Buffer);
1077
1078     /*
1079      * Resource Source Index (if present)
1080      */
1081     Buffer += 8;
1082
1083     /*
1084      * This will leave us pointing to the Resource Source Index
1085      * If it is present, then save it off and calculate the
1086      * pointer to where the null terminated string goes:
1087      * Each Interrupt takes 32-bits + the 5 bytes of the
1088      * stream that are default.
1089      *
1090      * Note: Some resource descriptors will have an additional null, so
1091      * we add 1 to the length.
1092      */
1093     if (*BytesConsumed > (46 + 1))
1094     {
1095         /* Dereference the Index */
1096
1097         Temp8 = *Buffer;
1098         OutputStruct->Data.Address64.ResourceSource.Index =
1099                 (UINT32) Temp8;
1100
1101         /* Point to the String */
1102
1103         Buffer += 1;
1104
1105         /* Point the String pointer to the end of this structure */
1106
1107         OutputStruct->Data.Address64.ResourceSource.StringPtr =
1108                 (char *)((UINT8 *)OutputStruct + StructSize);
1109
1110         TempPtr = (UINT8 *) OutputStruct->Data.Address64.ResourceSource.StringPtr;
1111
1112         /* Copy the string into the buffer */
1113
1114         Index = 0;
1115         while (0x00 != *Buffer)
1116         {
1117             *TempPtr = *Buffer;
1118
1119             TempPtr += 1;
1120             Buffer += 1;
1121             Index += 1;
1122         }
1123
1124         /*
1125          * Add the terminating null
1126          */
1127         *TempPtr = 0x00;
1128         OutputStruct->Data.Address64.ResourceSource.StringLength = Index + 1;
1129
1130         /*
1131          * In order for the StructSize to fall on a 32-bit boundary,
1132          * calculate the length of the string and expand the
1133          * StructSize to the next 32-bit boundary.
1134          */
1135         Temp8 = (UINT8) (Index + 1);
1136         StructSize += ACPI_ROUND_UP_TO_32BITS (Temp8);
1137     }
1138     else
1139     {
1140         OutputStruct->Data.Address64.ResourceSource.Index = 0x00;
1141         OutputStruct->Data.Address64.ResourceSource.StringLength = 0;
1142         OutputStruct->Data.Address64.ResourceSource.StringPtr = NULL;
1143     }
1144
1145     /*
1146      * Set the Length parameter
1147      */
1148     OutputStruct->Length = (UINT32) StructSize;
1149
1150     /*
1151      * Return the final size of the structure
1152      */
1153     *StructureSize = StructSize;
1154     return_ACPI_STATUS (AE_OK);
1155 }
1156
1157
1158 /*******************************************************************************
1159  *
1160  * FUNCTION:    AcpiRsAddress64Stream
1161  *
1162  * PARAMETERS:  LinkedList              - Pointer to the resource linked list
1163  *              OutputBuffer            - Pointer to the user's return buffer
1164  *              BytesConsumed           - Pointer to where the number of bytes
1165  *                                        used in the OutputBuffer is returned
1166  *
1167  * RETURN:      Status
1168  *
1169  * DESCRIPTION: Take the linked list resource structure and fills in the
1170  *              the appropriate bytes in a byte stream
1171  *
1172  ******************************************************************************/
1173
1174 ACPI_STATUS
1175 AcpiRsAddress64Stream (
1176     ACPI_RESOURCE           *LinkedList,
1177     UINT8                   **OutputBuffer,
1178     ACPI_SIZE               *BytesConsumed)
1179 {
1180     UINT8                   *Buffer;
1181     UINT16                  *LengthField;
1182     UINT8                   Temp8;
1183     char                    *TempPointer;
1184
1185
1186     ACPI_FUNCTION_TRACE ("RsAddress64Stream");
1187
1188
1189     Buffer = *OutputBuffer;
1190
1191     /*
1192      * The descriptor field is static
1193      */
1194     *Buffer = 0x8A;
1195     Buffer += 1;
1196
1197     /*
1198      * Set a pointer to the Length field - to be filled in later
1199      */
1200     LengthField = ACPI_CAST_PTR (UINT16, Buffer);
1201     Buffer += 2;
1202
1203     /*
1204      * Set the Resource Type (Memory, Io, BusNumber)
1205      */
1206     Temp8 = (UINT8) (LinkedList->Data.Address64.ResourceType & 0x03);
1207
1208     *Buffer = Temp8;
1209     Buffer += 1;
1210
1211     /*
1212      * Set the general flags
1213      */
1214     Temp8 = (UINT8) (LinkedList->Data.Address64.ProducerConsumer & 0x01);
1215     Temp8 |= (LinkedList->Data.Address64.Decode & 0x01) << 1;
1216     Temp8 |= (LinkedList->Data.Address64.MinAddressFixed & 0x01) << 2;
1217     Temp8 |= (LinkedList->Data.Address64.MaxAddressFixed & 0x01) << 3;
1218
1219     *Buffer = Temp8;
1220     Buffer += 1;
1221
1222     /*
1223      * Set the type specific flags
1224      */
1225     Temp8 = 0;
1226
1227     if (ACPI_MEMORY_RANGE == LinkedList->Data.Address64.ResourceType)
1228     {
1229         Temp8 = (UINT8)
1230             (LinkedList->Data.Address64.Attribute.Memory.ReadWriteAttribute &
1231             0x01);
1232
1233         Temp8 |=
1234             (LinkedList->Data.Address64.Attribute.Memory.CacheAttribute &
1235              0x0F) << 1;
1236     }
1237     else if (ACPI_IO_RANGE == LinkedList->Data.Address64.ResourceType)
1238     {
1239         Temp8 = (UINT8)
1240             (LinkedList->Data.Address64.Attribute.Io.RangeAttribute &
1241              0x03);
1242         Temp8 |=
1243             (LinkedList->Data.Address64.Attribute.Io.RangeAttribute &
1244              0x03) << 4;
1245     }
1246
1247     *Buffer = Temp8;
1248     Buffer += 1;
1249
1250     /*
1251      * Set the address space granularity
1252      */
1253     ACPI_MOVE_64_TO_64 (Buffer, &LinkedList->Data.Address64.Granularity);
1254     Buffer += 8;
1255
1256     /*
1257      * Set the address range minimum
1258      */
1259     ACPI_MOVE_64_TO_64 (Buffer, &LinkedList->Data.Address64.MinAddressRange);
1260     Buffer += 8;
1261
1262     /*
1263      * Set the address range maximum
1264      */
1265     ACPI_MOVE_64_TO_64 (Buffer, &LinkedList->Data.Address64.MaxAddressRange);
1266     Buffer += 8;
1267
1268     /*
1269      * Set the address translation offset
1270      */
1271     ACPI_MOVE_64_TO_64 (Buffer, &LinkedList->Data.Address64.AddressTranslationOffset);
1272     Buffer += 8;
1273
1274     /*
1275      * Set the address length
1276      */
1277     ACPI_MOVE_64_TO_64 (Buffer, &LinkedList->Data.Address64.AddressLength);
1278     Buffer += 8;
1279
1280     /*
1281      * Resource Source Index and Resource Source are optional
1282      */
1283     if (0 != LinkedList->Data.Address64.ResourceSource.StringLength)
1284     {
1285         Temp8 = (UINT8) LinkedList->Data.Address64.ResourceSource.Index;
1286
1287         *Buffer = Temp8;
1288         Buffer += 1;
1289
1290         TempPointer = (char *) Buffer;
1291
1292         /*
1293          * Copy the string
1294          */
1295         ACPI_STRCPY (TempPointer, LinkedList->Data.Address64.ResourceSource.StringPtr);
1296
1297         /*
1298          * Buffer needs to be set to the length of the sting + one for the
1299          * terminating null
1300          */
1301         Buffer += (ACPI_SIZE)(ACPI_STRLEN (LinkedList->Data.Address64.ResourceSource.StringPtr) + 1);
1302     }
1303
1304     /*
1305      * Return the number of bytes consumed in this operation
1306      */
1307     *BytesConsumed = ACPI_PTR_DIFF (Buffer, *OutputBuffer);
1308
1309     /*
1310      * Set the length field to the number of bytes consumed
1311      * minus the header size (3 bytes)
1312      */
1313     *LengthField = (UINT16) (*BytesConsumed - 3);
1314     return_ACPI_STATUS (AE_OK);
1315 }
1316