Some laptops return other values for working toucpads. Allow test_aux_port to
[dragonfly.git] / sys / contrib / dev / acpica-unix-20031203 / resources / rscreate.c
1 /*******************************************************************************
2  *
3  * Module Name: rscreate - Create resource lists/tables
4  *              $Revision: 65 $
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
118 #define __RSCREATE_C__
119
120 #include "acpi.h"
121 #include "acresrc.h"
122 #include "amlcode.h"
123 #include "acnamesp.h"
124
125 #define _COMPONENT          ACPI_RESOURCES
126         ACPI_MODULE_NAME    ("rscreate")
127
128
129 /*******************************************************************************
130  *
131  * FUNCTION:    AcpiRsCreateResourceList
132  *
133  * PARAMETERS:  ByteStreamBuffer        - Pointer to the resource byte stream
134  *              OutputBuffer            - Pointer to the user's buffer
135  *
136  * RETURN:      Status  - AE_OK if okay, else a valid ACPI_STATUS code
137  *              If OutputBuffer is not large enough, OutputBufferLength
138  *              indicates how large OutputBuffer should be, else it
139  *              indicates how may UINT8 elements of OutputBuffer are valid.
140  *
141  * DESCRIPTION: Takes the byte stream returned from a _CRS, _PRS control method
142  *              execution and parses the stream to create a linked list
143  *              of device resources.
144  *
145  ******************************************************************************/
146
147 ACPI_STATUS
148 AcpiRsCreateResourceList (
149     ACPI_OPERAND_OBJECT     *ByteStreamBuffer,
150     ACPI_BUFFER             *OutputBuffer)
151 {
152
153     ACPI_STATUS             Status;
154     UINT8                   *ByteStreamStart;
155     ACPI_SIZE               ListSizeNeeded = 0;
156     UINT32                  ByteStreamBufferLength;
157
158
159     ACPI_FUNCTION_TRACE ("RsCreateResourceList");
160
161
162     ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "ByteStreamBuffer = %p\n",
163         ByteStreamBuffer));
164
165     /*
166      * Params already validated, so we don't re-validate here
167      */
168     ByteStreamBufferLength = ByteStreamBuffer->Buffer.Length;
169     ByteStreamStart = ByteStreamBuffer->Buffer.Pointer;
170
171     /*
172      * Pass the ByteStreamBuffer into a module that can calculate
173      * the buffer size needed for the linked list
174      */
175     Status = AcpiRsGetListLength (ByteStreamStart, ByteStreamBufferLength,
176                 &ListSizeNeeded);
177
178     ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Status=%X ListSizeNeeded=%X\n",
179         Status, (UINT32) ListSizeNeeded));
180     if (ACPI_FAILURE (Status))
181     {
182         return_ACPI_STATUS (Status);
183     }
184
185     /* Validate/Allocate/Clear caller buffer */
186
187     Status = AcpiUtInitializeBuffer (OutputBuffer, ListSizeNeeded);
188     if (ACPI_FAILURE (Status))
189     {
190         return_ACPI_STATUS (Status);
191     }
192
193     /* Do the conversion */
194
195     Status = AcpiRsByteStreamToList (ByteStreamStart, ByteStreamBufferLength,
196                     OutputBuffer->Pointer);
197     if (ACPI_FAILURE (Status))
198     {
199         return_ACPI_STATUS (Status);
200     }
201
202     ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "OutputBuffer %p Length %X\n",
203             OutputBuffer->Pointer, (UINT32) OutputBuffer->Length));
204     return_ACPI_STATUS (AE_OK);
205 }
206
207
208 /*******************************************************************************
209  *
210  * FUNCTION:    AcpiRsCreatePciRoutingTable
211  *
212  * PARAMETERS:  PackageObject           - Pointer to an ACPI_OPERAND_OBJECT
213  *                                        package
214  *              OutputBuffer            - Pointer to the user's buffer
215  *
216  * RETURN:      Status  AE_OK if okay, else a valid ACPI_STATUS code.
217  *              If the OutputBuffer is too small, the error will be
218  *              AE_BUFFER_OVERFLOW and OutputBuffer->Length will point
219  *              to the size buffer needed.
220  *
221  * DESCRIPTION: Takes the ACPI_OPERAND_OBJECT  package and creates a
222  *              linked list of PCI interrupt descriptions
223  *
224  * NOTE: It is the caller's responsibility to ensure that the start of the
225  * output buffer is aligned properly (if necessary).
226  *
227  ******************************************************************************/
228
229 ACPI_STATUS
230 AcpiRsCreatePciRoutingTable (
231     ACPI_OPERAND_OBJECT     *PackageObject,
232     ACPI_BUFFER             *OutputBuffer)
233 {
234     UINT8                   *Buffer;
235     ACPI_OPERAND_OBJECT     **TopObjectList;
236     ACPI_OPERAND_OBJECT     **SubObjectList;
237     ACPI_OPERAND_OBJECT     *ObjDesc;
238     ACPI_SIZE               BufferSizeNeeded = 0;
239     UINT32                  NumberOfElements;
240     UINT32                  Index;
241     ACPI_PCI_ROUTING_TABLE  *UserPrt;
242     ACPI_NAMESPACE_NODE     *Node;
243     ACPI_STATUS             Status;
244     ACPI_BUFFER             PathBuffer;
245
246
247     ACPI_FUNCTION_TRACE ("RsCreatePciRoutingTable");
248
249
250     /* Params already validated, so we don't re-validate here */
251
252     /*
253      * Get the required buffer length
254      */
255     Status = AcpiRsGetPciRoutingTableLength (PackageObject,
256                 &BufferSizeNeeded);
257     if (ACPI_FAILURE (Status))
258     {
259         return_ACPI_STATUS (Status);
260     }
261
262     ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "BufferSizeNeeded = %X\n",
263         (UINT32) BufferSizeNeeded));
264
265     /* Validate/Allocate/Clear caller buffer */
266
267     Status = AcpiUtInitializeBuffer (OutputBuffer, BufferSizeNeeded);
268     if (ACPI_FAILURE (Status))
269     {
270         return_ACPI_STATUS (Status);
271     }
272
273     /*
274      * Loop through the ACPI_INTERNAL_OBJECTS - Each object
275      * should be a package that in turn contains an
276      * ACPI_INTEGER Address, a UINT8 Pin, a Name and a UINT8 SourceIndex.
277      */
278     TopObjectList    = PackageObject->Package.Elements;
279     NumberOfElements = PackageObject->Package.Count;
280     Buffer           = OutputBuffer->Pointer;
281     UserPrt          = ACPI_CAST_PTR (ACPI_PCI_ROUTING_TABLE, Buffer);
282
283     for (Index = 0; Index < NumberOfElements; Index++)
284     {
285         /*
286          * Point UserPrt past this current structure
287          *
288          * NOTE: On the first iteration, UserPrt->Length will
289          * be zero because we cleared the return buffer earlier
290          */
291         Buffer += UserPrt->Length;
292         UserPrt = ACPI_CAST_PTR (ACPI_PCI_ROUTING_TABLE, Buffer);
293
294         /*
295          * Fill in the Length field with the information we have at this point.
296          * The minus four is to subtract the size of the UINT8 Source[4] member
297          * because it is added below.
298          */
299         UserPrt->Length = (sizeof (ACPI_PCI_ROUTING_TABLE) - 4);
300
301         /*
302          * Each element of the top-level package must also be a package
303          */
304         if (ACPI_GET_OBJECT_TYPE (*TopObjectList) != ACPI_TYPE_PACKAGE)
305         {
306             ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
307                 "(PRT[%X]) Need sub-package, found %s\n",
308                 Index, AcpiUtGetObjectTypeName (*TopObjectList)));
309             return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
310         }
311
312         /* Each sub-package must be of length 4 */
313
314         if ((*TopObjectList)->Package.Count != 4)
315         {
316             ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
317                 "(PRT[%X]) Need package of length 4, found length %d\n",
318                 Index, (*TopObjectList)->Package.Count));
319             return_ACPI_STATUS (AE_AML_PACKAGE_LIMIT);
320         }
321
322         /*
323          * Dereference the sub-package.
324          * The SubObjectList will now point to an array of the four IRQ
325          * elements: [Address, Pin, Source, SourceIndex]
326          */
327         SubObjectList = (*TopObjectList)->Package.Elements;
328
329         /*
330          * 1) First subobject: Dereference the PRT.Address
331          */
332         ObjDesc = SubObjectList[0];
333         if (ACPI_GET_OBJECT_TYPE (ObjDesc) == ACPI_TYPE_INTEGER)
334         {
335             UserPrt->Address = ObjDesc->Integer.Value;
336         }
337         else
338         {
339             ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
340                 "(PRT[%X].Address) Need Integer, found %s\n",
341                 Index, AcpiUtGetObjectTypeName (ObjDesc)));
342             return_ACPI_STATUS (AE_BAD_DATA);
343         }
344
345         /*
346          * 2) Second subobject: Dereference the PRT.Pin
347          */
348         ObjDesc = SubObjectList[1];
349         if (ACPI_GET_OBJECT_TYPE (ObjDesc) == ACPI_TYPE_INTEGER)
350         {
351             UserPrt->Pin = (UINT32) ObjDesc->Integer.Value;
352         }
353         else
354         {
355             ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
356                 "(PRT[%X].Pin) Need Integer, found %s\n",
357                 Index, AcpiUtGetObjectTypeName (ObjDesc)));
358             return_ACPI_STATUS (AE_BAD_DATA);
359         }
360
361         /*
362          * 3) Third subobject: Dereference the PRT.SourceName
363          */
364         ObjDesc = SubObjectList[2];
365         switch (ACPI_GET_OBJECT_TYPE (ObjDesc))
366         {
367         case ACPI_TYPE_LOCAL_REFERENCE:
368
369             if (ObjDesc->Reference.Opcode != AML_INT_NAMEPATH_OP)
370             {
371                 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
372                     "(PRT[%X].Source) Need name, found reference op %X\n",
373                     Index, ObjDesc->Reference.Opcode));
374                 return_ACPI_STATUS (AE_BAD_DATA);
375             }
376
377             Node = ObjDesc->Reference.Node;
378
379             /* Use *remaining* length of the buffer as max for pathname */
380
381             PathBuffer.Length = OutputBuffer->Length -
382                                 (UINT32) ((UINT8 *) UserPrt->Source -
383                                 (UINT8 *) OutputBuffer->Pointer);
384             PathBuffer.Pointer = UserPrt->Source;
385
386             Status = AcpiNsHandleToPathname ((ACPI_HANDLE) Node, &PathBuffer);
387
388             UserPrt->Length += (UINT32) ACPI_STRLEN (UserPrt->Source) + 1; /* include null terminator */
389             break;
390
391
392         case ACPI_TYPE_STRING:
393
394             ACPI_STRCPY (UserPrt->Source, ObjDesc->String.Pointer);
395
396             /* Add to the Length field the length of the string (add 1 for terminator) */
397
398             UserPrt->Length += ObjDesc->String.Length + 1;
399             break;
400
401
402         case ACPI_TYPE_INTEGER:
403             /*
404              * If this is a number, then the Source Name is NULL, since the
405              * entire buffer was zeroed out, we can leave this alone.
406              *
407              * Add to the Length field the length of the UINT32 NULL
408              */
409             UserPrt->Length += sizeof (UINT32);
410             break;
411
412
413         default:
414
415            ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
416                "(PRT[%X].Source) Need Ref/String/Integer, found %s\n",
417                 Index, AcpiUtGetObjectTypeName (ObjDesc)));
418            return_ACPI_STATUS (AE_BAD_DATA);
419         }
420
421         /* Now align the current length */
422
423         UserPrt->Length = (UINT32) ACPI_ROUND_UP_TO_64BITS (UserPrt->Length);
424
425         /*
426          * 4) Fourth subobject: Dereference the PRT.SourceIndex
427          */
428         ObjDesc = SubObjectList[3];
429         if (ACPI_GET_OBJECT_TYPE (ObjDesc) == ACPI_TYPE_INTEGER)
430         {
431             UserPrt->SourceIndex = (UINT32) ObjDesc->Integer.Value;
432         }
433         else
434         {
435             ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
436                 "(PRT[%X].SourceIndex) Need Integer, found %s\n",
437                 Index, AcpiUtGetObjectTypeName (ObjDesc)));
438             return_ACPI_STATUS (AE_BAD_DATA);
439         }
440
441         /* Point to the next ACPI_OPERAND_OBJECT in the top level package */
442
443         TopObjectList++;
444     }
445
446     ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "OutputBuffer %p Length %X\n",
447             OutputBuffer->Pointer, (UINT32) OutputBuffer->Length));
448     return_ACPI_STATUS (AE_OK);
449 }
450
451
452 /*******************************************************************************
453  *
454  * FUNCTION:    AcpiRsCreateByteStream
455  *
456  * PARAMETERS:  LinkedListBuffer        - Pointer to the resource linked list
457  *              OutputBuffer            - Pointer to the user's buffer
458  *
459  * RETURN:      Status  AE_OK if okay, else a valid ACPI_STATUS code.
460  *              If the OutputBuffer is too small, the error will be
461  *              AE_BUFFER_OVERFLOW and OutputBuffer->Length will point
462  *              to the size buffer needed.
463  *
464  * DESCRIPTION: Takes the linked list of device resources and
465  *              creates a bytestream to be used as input for the
466  *              _SRS control method.
467  *
468  ******************************************************************************/
469
470 ACPI_STATUS
471 AcpiRsCreateByteStream (
472     ACPI_RESOURCE           *LinkedListBuffer,
473     ACPI_BUFFER             *OutputBuffer)
474 {
475     ACPI_STATUS             Status;
476     ACPI_SIZE               ByteStreamSizeNeeded = 0;
477
478
479     ACPI_FUNCTION_TRACE ("RsCreateByteStream");
480
481
482     ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "LinkedListBuffer = %p\n",
483         LinkedListBuffer));
484
485     /*
486      * Params already validated, so we don't re-validate here
487      *
488      * Pass the LinkedListBuffer into a module that calculates
489      * the buffer size needed for the byte stream.
490      */
491     Status = AcpiRsGetByteStreamLength (LinkedListBuffer,
492                 &ByteStreamSizeNeeded);
493
494     ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "ByteStreamSizeNeeded=%X, %s\n",
495         (UINT32) ByteStreamSizeNeeded, AcpiFormatException (Status)));
496     if (ACPI_FAILURE (Status))
497     {
498         return_ACPI_STATUS (Status);
499     }
500
501     /* Validate/Allocate/Clear caller buffer */
502
503     Status = AcpiUtInitializeBuffer (OutputBuffer, ByteStreamSizeNeeded);
504     if (ACPI_FAILURE (Status))
505     {
506         return_ACPI_STATUS (Status);
507     }
508
509     /* Do the conversion */
510
511     Status = AcpiRsListToByteStream (LinkedListBuffer, ByteStreamSizeNeeded,
512                     OutputBuffer->Pointer);
513     if (ACPI_FAILURE (Status))
514     {
515         return_ACPI_STATUS (Status);
516     }
517
518     ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "OutputBuffer %p Length %X\n",
519             OutputBuffer->Pointer, (UINT32) OutputBuffer->Length));
520     return_ACPI_STATUS (AE_OK);
521 }
522