1 /*******************************************************************************
3 * Module Name: rscreate - Create resource lists/tables
5 ******************************************************************************/
8 * Copyright (C) 2000 - 2006, R. Byron Moore
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
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.
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.
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.
44 #include <acpi/acpi.h>
45 #include <acpi/acresrc.h>
46 #include <acpi/amlcode.h>
47 #include <acpi/acnamesp.h>
49 #define _COMPONENT ACPI_RESOURCES
50 ACPI_MODULE_NAME("rscreate")
52 /*******************************************************************************
54 * FUNCTION: acpi_rs_create_resource_list
56 * PARAMETERS: aml_buffer - Pointer to the resource byte stream
57 * output_buffer - Pointer to the user's buffer
59 * RETURN: Status: AE_OK if okay, else a valid acpi_status code
60 * If output_buffer is not large enough, output_buffer_length
61 * indicates how large output_buffer should be, else it
62 * indicates how may u8 elements of output_buffer are valid.
64 * DESCRIPTION: Takes the byte stream returned from a _CRS, _PRS control method
65 * execution and parses the stream to create a linked list
66 * of device resources.
68 ******************************************************************************/
70 acpi_rs_create_resource_list(union acpi_operand_object
*aml_buffer
,
71 struct acpi_buffer
*output_buffer
)
76 acpi_size list_size_needed
= 0;
77 u32 aml_buffer_length
;
80 ACPI_FUNCTION_TRACE(rs_create_resource_list
);
82 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "AmlBuffer = %p\n", aml_buffer
));
84 /* Params already validated, so we don't re-validate here */
86 aml_buffer_length
= aml_buffer
->buffer
.length
;
87 aml_start
= aml_buffer
->buffer
.pointer
;
90 * Pass the aml_buffer into a module that can calculate
91 * the buffer size needed for the linked list
93 status
= acpi_rs_get_list_length(aml_start
, aml_buffer_length
,
96 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "Status=%X ListSizeNeeded=%X\n",
97 status
, (u32
) list_size_needed
));
98 if (ACPI_FAILURE(status
)) {
99 return_ACPI_STATUS(status
);
102 /* Validate/Allocate/Clear caller buffer */
104 status
= acpi_ut_initialize_buffer(output_buffer
, list_size_needed
);
105 if (ACPI_FAILURE(status
)) {
106 return_ACPI_STATUS(status
);
109 /* Do the conversion */
111 resource
= output_buffer
->pointer
;
112 status
= acpi_ut_walk_aml_resources(aml_start
, aml_buffer_length
,
113 acpi_rs_convert_aml_to_resources
,
115 if (ACPI_FAILURE(status
)) {
116 return_ACPI_STATUS(status
);
119 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "OutputBuffer %p Length %X\n",
120 output_buffer
->pointer
, (u32
) output_buffer
->length
));
121 return_ACPI_STATUS(AE_OK
);
124 /*******************************************************************************
126 * FUNCTION: acpi_rs_create_pci_routing_table
128 * PARAMETERS: package_object - Pointer to an union acpi_operand_object
130 * output_buffer - Pointer to the user's buffer
132 * RETURN: Status AE_OK if okay, else a valid acpi_status code.
133 * If the output_buffer is too small, the error will be
134 * AE_BUFFER_OVERFLOW and output_buffer->Length will point
135 * to the size buffer needed.
137 * DESCRIPTION: Takes the union acpi_operand_object package and creates a
138 * linked list of PCI interrupt descriptions
140 * NOTE: It is the caller's responsibility to ensure that the start of the
141 * output buffer is aligned properly (if necessary).
143 ******************************************************************************/
146 acpi_rs_create_pci_routing_table(union acpi_operand_object
*package_object
,
147 struct acpi_buffer
*output_buffer
)
150 union acpi_operand_object
**top_object_list
;
151 union acpi_operand_object
**sub_object_list
;
152 union acpi_operand_object
*obj_desc
;
153 acpi_size buffer_size_needed
= 0;
154 u32 number_of_elements
;
156 struct acpi_pci_routing_table
*user_prt
;
157 struct acpi_namespace_node
*node
;
159 struct acpi_buffer path_buffer
;
161 ACPI_FUNCTION_TRACE(rs_create_pci_routing_table
);
163 /* Params already validated, so we don't re-validate here */
165 /* Get the required buffer length */
167 status
= acpi_rs_get_pci_routing_table_length(package_object
,
168 &buffer_size_needed
);
169 if (ACPI_FAILURE(status
)) {
170 return_ACPI_STATUS(status
);
173 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "BufferSizeNeeded = %X\n",
174 (u32
) buffer_size_needed
));
176 /* Validate/Allocate/Clear caller buffer */
178 status
= acpi_ut_initialize_buffer(output_buffer
, buffer_size_needed
);
179 if (ACPI_FAILURE(status
)) {
180 return_ACPI_STATUS(status
);
184 * Loop through the ACPI_INTERNAL_OBJECTS - Each object
185 * should be a package that in turn contains an
186 * acpi_integer Address, a u8 Pin, a Name and a u8 source_index.
188 top_object_list
= package_object
->package
.elements
;
189 number_of_elements
= package_object
->package
.count
;
190 buffer
= output_buffer
->pointer
;
191 user_prt
= ACPI_CAST_PTR(struct acpi_pci_routing_table
, buffer
);
193 for (index
= 0; index
< number_of_elements
; index
++) {
195 * Point user_prt past this current structure
197 * NOTE: On the first iteration, user_prt->Length will
198 * be zero because we cleared the return buffer earlier
200 buffer
+= user_prt
->length
;
201 user_prt
= ACPI_CAST_PTR(struct acpi_pci_routing_table
, buffer
);
204 * Fill in the Length field with the information we have at this point.
205 * The minus four is to subtract the size of the u8 Source[4] member
206 * because it is added below.
208 user_prt
->length
= (sizeof(struct acpi_pci_routing_table
) - 4);
210 /* Each element of the top-level package must also be a package */
212 if (ACPI_GET_OBJECT_TYPE(*top_object_list
) != ACPI_TYPE_PACKAGE
) {
214 "(PRT[%X]) Need sub-package, found %s",
216 acpi_ut_get_object_type_name
217 (*top_object_list
)));
218 return_ACPI_STATUS(AE_AML_OPERAND_TYPE
);
221 /* Each sub-package must be of length 4 */
223 if ((*top_object_list
)->package
.count
!= 4) {
225 "(PRT[%X]) Need package of length 4, found length %d",
226 index
, (*top_object_list
)->package
.count
));
227 return_ACPI_STATUS(AE_AML_PACKAGE_LIMIT
);
231 * Dereference the sub-package.
232 * The sub_object_list will now point to an array of the four IRQ
233 * elements: [Address, Pin, Source, source_index]
235 sub_object_list
= (*top_object_list
)->package
.elements
;
237 /* 1) First subobject: Dereference the PRT.Address */
239 obj_desc
= sub_object_list
[0];
240 if (ACPI_GET_OBJECT_TYPE(obj_desc
) == ACPI_TYPE_INTEGER
) {
241 user_prt
->address
= obj_desc
->integer
.value
;
244 "(PRT[%X].Address) Need Integer, found %s",
246 acpi_ut_get_object_type_name(obj_desc
)));
247 return_ACPI_STATUS(AE_BAD_DATA
);
250 /* 2) Second subobject: Dereference the PRT.Pin */
252 obj_desc
= sub_object_list
[1];
253 if (ACPI_GET_OBJECT_TYPE(obj_desc
) == ACPI_TYPE_INTEGER
) {
254 user_prt
->pin
= (u32
) obj_desc
->integer
.value
;
257 "(PRT[%X].Pin) Need Integer, found %s",
259 acpi_ut_get_object_type_name(obj_desc
)));
260 return_ACPI_STATUS(AE_BAD_DATA
);
264 * 3) Third subobject: Dereference the PRT.source_name
265 * The name may be unresolved (slack mode), so allow a null object
267 obj_desc
= sub_object_list
[2];
269 switch (ACPI_GET_OBJECT_TYPE(obj_desc
)) {
270 case ACPI_TYPE_LOCAL_REFERENCE
:
272 if (obj_desc
->reference
.opcode
!=
273 AML_INT_NAMEPATH_OP
) {
275 "(PRT[%X].Source) Need name, found reference op %X",
279 return_ACPI_STATUS(AE_BAD_DATA
);
282 node
= obj_desc
->reference
.node
;
284 /* Use *remaining* length of the buffer as max for pathname */
286 path_buffer
.length
= output_buffer
->length
-
287 (u32
) ((u8
*) user_prt
->source
-
288 (u8
*) output_buffer
->pointer
);
289 path_buffer
.pointer
= user_prt
->source
;
292 acpi_ns_handle_to_pathname((acpi_handle
)
296 /* +1 to include null terminator */
299 (u32
) ACPI_STRLEN(user_prt
->source
) + 1;
302 case ACPI_TYPE_STRING
:
304 ACPI_STRCPY(user_prt
->source
,
305 obj_desc
->string
.pointer
);
308 * Add to the Length field the length of the string
309 * (add 1 for terminator)
311 user_prt
->length
+= obj_desc
->string
.length
+ 1;
314 case ACPI_TYPE_INTEGER
:
316 * If this is a number, then the Source Name is NULL, since the
317 * entire buffer was zeroed out, we can leave this alone.
319 * Add to the Length field the length of the u32 NULL
321 user_prt
->length
+= sizeof(u32
);
327 "(PRT[%X].Source) Need Ref/String/Integer, found %s",
329 acpi_ut_get_object_type_name
331 return_ACPI_STATUS(AE_BAD_DATA
);
335 /* Now align the current length */
338 (u32
) ACPI_ROUND_UP_TO_64BIT(user_prt
->length
);
340 /* 4) Fourth subobject: Dereference the PRT.source_index */
342 obj_desc
= sub_object_list
[3];
343 if (ACPI_GET_OBJECT_TYPE(obj_desc
) == ACPI_TYPE_INTEGER
) {
344 user_prt
->source_index
= (u32
) obj_desc
->integer
.value
;
347 "(PRT[%X].SourceIndex) Need Integer, found %s",
349 acpi_ut_get_object_type_name(obj_desc
)));
350 return_ACPI_STATUS(AE_BAD_DATA
);
353 /* Point to the next union acpi_operand_object in the top level package */
358 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "OutputBuffer %p Length %X\n",
359 output_buffer
->pointer
, (u32
) output_buffer
->length
));
360 return_ACPI_STATUS(AE_OK
);
363 /*******************************************************************************
365 * FUNCTION: acpi_rs_create_aml_resources
367 * PARAMETERS: linked_list_buffer - Pointer to the resource linked list
368 * output_buffer - Pointer to the user's buffer
370 * RETURN: Status AE_OK if okay, else a valid acpi_status code.
371 * If the output_buffer is too small, the error will be
372 * AE_BUFFER_OVERFLOW and output_buffer->Length will point
373 * to the size buffer needed.
375 * DESCRIPTION: Takes the linked list of device resources and
376 * creates a bytestream to be used as input for the
377 * _SRS control method.
379 ******************************************************************************/
382 acpi_rs_create_aml_resources(struct acpi_resource
*linked_list_buffer
,
383 struct acpi_buffer
*output_buffer
)
386 acpi_size aml_size_needed
= 0;
388 ACPI_FUNCTION_TRACE(rs_create_aml_resources
);
390 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "LinkedListBuffer = %p\n",
391 linked_list_buffer
));
394 * Params already validated, so we don't re-validate here
396 * Pass the linked_list_buffer into a module that calculates
397 * the buffer size needed for the byte stream.
399 status
= acpi_rs_get_aml_length(linked_list_buffer
, &aml_size_needed
);
401 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "AmlSizeNeeded=%X, %s\n",
402 (u32
) aml_size_needed
,
403 acpi_format_exception(status
)));
404 if (ACPI_FAILURE(status
)) {
405 return_ACPI_STATUS(status
);
408 /* Validate/Allocate/Clear caller buffer */
410 status
= acpi_ut_initialize_buffer(output_buffer
, aml_size_needed
);
411 if (ACPI_FAILURE(status
)) {
412 return_ACPI_STATUS(status
);
415 /* Do the conversion */
418 acpi_rs_convert_resources_to_aml(linked_list_buffer
,
420 output_buffer
->pointer
);
421 if (ACPI_FAILURE(status
)) {
422 return_ACPI_STATUS(status
);
425 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "OutputBuffer %p Length %X\n",
426 output_buffer
->pointer
, (u32
) output_buffer
->length
));
427 return_ACPI_STATUS(AE_OK
);