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