Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /******************************************************************************* |
2 | * | |
3 | * Module Name: rscalc - Calculate stream and list lengths | |
4 | * | |
5 | ******************************************************************************/ | |
6 | ||
7 | /* | |
8 | * Copyright (C) 2000 - 2005, R. Byron Moore | |
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 | ||
1da177e4 LT |
44 | #include <acpi/acpi.h> |
45 | #include <acpi/acresrc.h> | |
46 | #include <acpi/amlcode.h> | |
47 | #include <acpi/acnamesp.h> | |
48 | ||
49 | #define _COMPONENT ACPI_RESOURCES | |
4be44fcd | 50 | ACPI_MODULE_NAME("rscalc") |
1da177e4 | 51 | |
bda663d3 | 52 | /* Local prototypes */ |
bda663d3 RM |
53 | static u8 acpi_rs_count_set_bits(u16 bit_field); |
54 | ||
bda663d3 RM |
55 | static acpi_size |
56 | acpi_rs_struct_option_length(struct acpi_resource_source *resource_source); | |
57 | ||
58 | static u32 | |
59 | acpi_rs_stream_option_length(u32 resource_length, u32 minimum_total_length); | |
60 | ||
1da177e4 LT |
61 | /******************************************************************************* |
62 | * | |
bda663d3 | 63 | * FUNCTION: acpi_rs_count_set_bits |
1da177e4 | 64 | * |
bda663d3 | 65 | * PARAMETERS: bit_field - Field in which to count bits |
1da177e4 | 66 | * |
bda663d3 | 67 | * RETURN: Number of bits set within the field |
1da177e4 | 68 | * |
bda663d3 RM |
69 | * DESCRIPTION: Count the number of bits set in a resource field. Used for |
70 | * (Short descriptor) interrupt and DMA lists. | |
1da177e4 LT |
71 | * |
72 | ******************************************************************************/ | |
1da177e4 | 73 | |
bda663d3 RM |
74 | static u8 acpi_rs_count_set_bits(u16 bit_field) |
75 | { | |
76 | u8 bits_set; | |
44f6c012 | 77 | |
bda663d3 | 78 | ACPI_FUNCTION_ENTRY(); |
1da177e4 | 79 | |
bda663d3 RM |
80 | for (bits_set = 0; bit_field; bits_set++) { |
81 | /* Zero the least significant bit that is set */ | |
1da177e4 | 82 | |
bda663d3 RM |
83 | bit_field &= (bit_field - 1); |
84 | } | |
1da177e4 | 85 | |
bda663d3 RM |
86 | return (bits_set); |
87 | } | |
1da177e4 | 88 | |
1da177e4 LT |
89 | /******************************************************************************* |
90 | * | |
bda663d3 | 91 | * FUNCTION: acpi_rs_struct_option_length |
1da177e4 | 92 | * |
bda663d3 | 93 | * PARAMETERS: resource_source - Pointer to optional descriptor field |
1da177e4 LT |
94 | * |
95 | * RETURN: Status | |
96 | * | |
bda663d3 RM |
97 | * DESCRIPTION: Common code to handle optional resource_source_index and |
98 | * resource_source fields in some Large descriptors. Used during | |
99 | * list-to-stream conversion | |
1da177e4 LT |
100 | * |
101 | ******************************************************************************/ | |
102 | ||
bda663d3 RM |
103 | static acpi_size |
104 | acpi_rs_struct_option_length(struct acpi_resource_source *resource_source) | |
1da177e4 | 105 | { |
bda663d3 RM |
106 | ACPI_FUNCTION_ENTRY(); |
107 | ||
108 | /* | |
109 | * If the resource_source string is valid, return the size of the string | |
110 | * (string_length includes the NULL terminator) plus the size of the | |
111 | * resource_source_index (1). | |
112 | */ | |
113 | if (resource_source->string_ptr) { | |
114 | return ((acpi_size) resource_source->string_length + 1); | |
115 | } | |
1da177e4 | 116 | |
bda663d3 RM |
117 | return (0); |
118 | } | |
1da177e4 | 119 | |
bda663d3 RM |
120 | /******************************************************************************* |
121 | * | |
122 | * FUNCTION: acpi_rs_stream_option_length | |
123 | * | |
124 | * PARAMETERS: resource_length - Length from the resource header | |
125 | * minimum_total_length - Minimum length of this resource, before | |
126 | * any optional fields. Includes header size | |
127 | * | |
128 | * RETURN: Length of optional string (0 if no string present) | |
129 | * | |
130 | * DESCRIPTION: Common code to handle optional resource_source_index and | |
131 | * resource_source fields in some Large descriptors. Used during | |
132 | * stream-to-list conversion | |
133 | * | |
134 | ******************************************************************************/ | |
1da177e4 | 135 | |
bda663d3 | 136 | static u32 |
50eca3eb BM |
137 | acpi_rs_stream_option_length(u32 resource_length, |
138 | u32 minimum_aml_resource_length) | |
bda663d3 RM |
139 | { |
140 | u32 string_length = 0; | |
1da177e4 | 141 | |
bda663d3 | 142 | ACPI_FUNCTION_ENTRY(); |
1da177e4 | 143 | |
bda663d3 RM |
144 | /* |
145 | * The resource_source_index and resource_source are optional elements of some | |
146 | * Large-type resource descriptors. | |
147 | */ | |
44f6c012 | 148 | |
bda663d3 RM |
149 | /* |
150 | * If the length of the actual resource descriptor is greater than the ACPI | |
151 | * spec-defined minimum length, it means that a resource_source_index exists | |
152 | * and is followed by a (required) null terminated string. The string length | |
153 | * (including the null terminator) is the resource length minus the minimum | |
154 | * length, minus one byte for the resource_source_index itself. | |
155 | */ | |
50eca3eb | 156 | if (resource_length > minimum_aml_resource_length) { |
bda663d3 | 157 | /* Compute the length of the optional string */ |
1da177e4 | 158 | |
50eca3eb BM |
159 | string_length = |
160 | resource_length - minimum_aml_resource_length - 1; | |
bda663d3 | 161 | } |
1da177e4 | 162 | |
bda663d3 | 163 | /* Round up length to 32 bits for internal structure alignment */ |
1da177e4 | 164 | |
bda663d3 RM |
165 | return (ACPI_ROUND_UP_to_32_bITS(string_length)); |
166 | } | |
1da177e4 | 167 | |
bda663d3 RM |
168 | /******************************************************************************* |
169 | * | |
50eca3eb | 170 | * FUNCTION: acpi_rs_get_aml_length |
bda663d3 RM |
171 | * |
172 | * PARAMETERS: Resource - Pointer to the resource linked list | |
173 | * size_needed - Where the required size is returned | |
174 | * | |
175 | * RETURN: Status | |
176 | * | |
177 | * DESCRIPTION: Takes a linked list of internal resource descriptors and | |
178 | * calculates the size buffer needed to hold the corresponding | |
179 | * external resource byte stream. | |
180 | * | |
181 | ******************************************************************************/ | |
1da177e4 | 182 | |
bda663d3 | 183 | acpi_status |
50eca3eb | 184 | acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed) |
bda663d3 | 185 | { |
50eca3eb | 186 | acpi_size aml_size_needed = 0; |
bda663d3 | 187 | acpi_size segment_size; |
1da177e4 | 188 | |
50eca3eb | 189 | ACPI_FUNCTION_TRACE("rs_get_aml_length"); |
1da177e4 | 190 | |
bda663d3 | 191 | /* Traverse entire list of internal resource descriptors */ |
1da177e4 | 192 | |
bda663d3 RM |
193 | while (resource) { |
194 | /* Validate the descriptor type */ | |
1da177e4 | 195 | |
50eca3eb | 196 | if (resource->type > ACPI_RESOURCE_TYPE_MAX) { |
bda663d3 RM |
197 | return_ACPI_STATUS(AE_AML_INVALID_RESOURCE_TYPE); |
198 | } | |
44f6c012 | 199 | |
bda663d3 | 200 | /* Get the base size of the (external stream) resource descriptor */ |
1da177e4 | 201 | |
50eca3eb | 202 | segment_size = acpi_gbl_aml_resource_sizes[resource->type]; |
1da177e4 | 203 | |
bda663d3 RM |
204 | /* |
205 | * Augment the base size for descriptors with optional and/or | |
206 | * variable-length fields | |
207 | */ | |
208 | switch (resource->type) { | |
50eca3eb | 209 | case ACPI_RESOURCE_TYPE_VENDOR: |
1da177e4 | 210 | /* |
bda663d3 RM |
211 | * Vendor Defined Resource: |
212 | * For a Vendor Specific resource, if the Length is between 1 and 7 | |
213 | * it will be created as a Small Resource data type, otherwise it | |
214 | * is a Large Resource data type. | |
1da177e4 | 215 | */ |
50eca3eb | 216 | if (resource->data.vendor.byte_length > 7) { |
bda663d3 | 217 | /* Base size of a Large resource descriptor */ |
1da177e4 | 218 | |
50eca3eb BM |
219 | segment_size = |
220 | sizeof(struct aml_resource_large_header); | |
1da177e4 LT |
221 | } |
222 | ||
bda663d3 | 223 | /* Add the size of the vendor-specific data */ |
44f6c012 | 224 | |
50eca3eb | 225 | segment_size += resource->data.vendor.byte_length; |
1da177e4 LT |
226 | break; |
227 | ||
50eca3eb | 228 | case ACPI_RESOURCE_TYPE_END_TAG: |
1da177e4 | 229 | /* |
bda663d3 RM |
230 | * End Tag: |
231 | * We are done -- return the accumulated total size. | |
1da177e4 | 232 | */ |
50eca3eb | 233 | *size_needed = aml_size_needed + segment_size; |
1da177e4 | 234 | |
bda663d3 | 235 | /* Normal exit */ |
1da177e4 | 236 | |
bda663d3 | 237 | return_ACPI_STATUS(AE_OK); |
1da177e4 | 238 | |
50eca3eb | 239 | case ACPI_RESOURCE_TYPE_ADDRESS16: |
1da177e4 | 240 | /* |
bda663d3 RM |
241 | * 16-Bit Address Resource: |
242 | * Add the size of the optional resource_source info | |
1da177e4 | 243 | */ |
bda663d3 RM |
244 | segment_size += |
245 | acpi_rs_struct_option_length(&resource->data. | |
246 | address16. | |
247 | resource_source); | |
1da177e4 LT |
248 | break; |
249 | ||
50eca3eb | 250 | case ACPI_RESOURCE_TYPE_ADDRESS32: |
1da177e4 | 251 | /* |
bda663d3 RM |
252 | * 32-Bit Address Resource: |
253 | * Add the size of the optional resource_source info | |
1da177e4 | 254 | */ |
bda663d3 RM |
255 | segment_size += |
256 | acpi_rs_struct_option_length(&resource->data. | |
257 | address32. | |
258 | resource_source); | |
1da177e4 LT |
259 | break; |
260 | ||
50eca3eb | 261 | case ACPI_RESOURCE_TYPE_ADDRESS64: |
1da177e4 | 262 | /* |
bda663d3 RM |
263 | * 64-Bit Address Resource: |
264 | * Add the size of the optional resource_source info | |
1da177e4 | 265 | */ |
bda663d3 RM |
266 | segment_size += |
267 | acpi_rs_struct_option_length(&resource->data. | |
268 | address64. | |
269 | resource_source); | |
1da177e4 LT |
270 | break; |
271 | ||
50eca3eb | 272 | case ACPI_RESOURCE_TYPE_EXTENDED_IRQ: |
1da177e4 | 273 | /* |
bda663d3 RM |
274 | * Extended IRQ Resource: |
275 | * Add the size of each additional optional interrupt beyond the | |
276 | * required 1 (4 bytes for each u32 interrupt number) | |
1da177e4 | 277 | */ |
bda663d3 RM |
278 | segment_size += (((acpi_size) |
279 | resource->data.extended_irq. | |
50eca3eb | 280 | interrupt_count - 1) * 4); |
1da177e4 | 281 | |
bda663d3 | 282 | /* Add the size of the optional resource_source info */ |
1da177e4 | 283 | |
bda663d3 RM |
284 | segment_size += |
285 | acpi_rs_struct_option_length(&resource->data. | |
286 | extended_irq. | |
287 | resource_source); | |
288 | break; | |
1da177e4 | 289 | |
bda663d3 | 290 | default: |
1da177e4 | 291 | break; |
bda663d3 | 292 | } |
1da177e4 | 293 | |
bda663d3 | 294 | /* Update the total */ |
1da177e4 | 295 | |
50eca3eb | 296 | aml_size_needed += segment_size; |
1da177e4 | 297 | |
bda663d3 | 298 | /* Point to the next object */ |
1da177e4 | 299 | |
bda663d3 RM |
300 | resource = ACPI_PTR_ADD(struct acpi_resource, |
301 | resource, resource->length); | |
302 | } | |
1da177e4 | 303 | |
bda663d3 | 304 | /* Did not find an END_TAG descriptor */ |
1da177e4 | 305 | |
bda663d3 RM |
306 | return_ACPI_STATUS(AE_AML_INVALID_RESOURCE_TYPE); |
307 | } | |
1da177e4 | 308 | |
bda663d3 RM |
309 | /******************************************************************************* |
310 | * | |
311 | * FUNCTION: acpi_rs_get_list_length | |
312 | * | |
50eca3eb BM |
313 | * PARAMETERS: aml_buffer - Pointer to the resource byte stream |
314 | * aml_buffer_length - Size of aml_buffer | |
315 | * size_needed - Where the size needed is returned | |
bda663d3 RM |
316 | * |
317 | * RETURN: Status | |
318 | * | |
319 | * DESCRIPTION: Takes an external resource byte stream and calculates the size | |
320 | * buffer needed to hold the corresponding internal resource | |
321 | * descriptor linked list. | |
322 | * | |
323 | ******************************************************************************/ | |
324 | ||
325 | acpi_status | |
50eca3eb BM |
326 | acpi_rs_get_list_length(u8 * aml_buffer, |
327 | u32 aml_buffer_length, acpi_size * size_needed) | |
bda663d3 RM |
328 | { |
329 | u8 *buffer; | |
50eca3eb | 330 | struct acpi_resource_info *resource_info; |
bda663d3 RM |
331 | u32 buffer_size = 0; |
332 | u32 bytes_parsed = 0; | |
333 | u8 resource_type; | |
334 | u16 temp16; | |
335 | u16 resource_length; | |
336 | u16 header_length; | |
337 | u32 extra_struct_bytes; | |
1da177e4 | 338 | |
bda663d3 | 339 | ACPI_FUNCTION_TRACE("rs_get_list_length"); |
1da177e4 | 340 | |
50eca3eb | 341 | while (bytes_parsed < aml_buffer_length) { |
bda663d3 | 342 | /* The next byte in the stream is the resource descriptor type */ |
44f6c012 | 343 | |
50eca3eb | 344 | resource_type = acpi_rs_get_resource_type(*aml_buffer); |
1da177e4 | 345 | |
bda663d3 | 346 | /* Get the base stream size and structure sizes for the descriptor */ |
1da177e4 | 347 | |
50eca3eb | 348 | resource_info = acpi_rs_get_resource_info(resource_type); |
bda663d3 | 349 | if (!resource_info) { |
4be44fcd | 350 | return_ACPI_STATUS(AE_AML_INVALID_RESOURCE_TYPE); |
1da177e4 LT |
351 | } |
352 | ||
bda663d3 RM |
353 | /* Get the Length field from the input resource descriptor */ |
354 | ||
355 | resource_length = | |
50eca3eb BM |
356 | acpi_rs_get_resource_length(ACPI_CAST_PTR |
357 | (union aml_resource, | |
358 | aml_buffer)); | |
bda663d3 RM |
359 | |
360 | /* Augment the size for descriptors with optional fields */ | |
361 | ||
362 | extra_struct_bytes = 0; | |
363 | ||
50eca3eb | 364 | if (!(resource_type & ACPI_RESOURCE_NAME_LARGE)) { |
bda663d3 RM |
365 | /* |
366 | * Small resource descriptors | |
367 | */ | |
50eca3eb BM |
368 | header_length = |
369 | sizeof(struct aml_resource_small_header); | |
370 | buffer = aml_buffer + header_length; | |
bda663d3 RM |
371 | |
372 | switch (resource_type) { | |
50eca3eb | 373 | case ACPI_RESOURCE_NAME_IRQ: |
bda663d3 RM |
374 | /* |
375 | * IRQ Resource: | |
376 | * Get the number of bits set in the IRQ word | |
377 | */ | |
378 | ACPI_MOVE_16_TO_16(&temp16, buffer); | |
bda663d3 RM |
379 | extra_struct_bytes = |
380 | (acpi_rs_count_set_bits(temp16) * | |
381 | sizeof(u32)); | |
382 | break; | |
383 | ||
50eca3eb | 384 | case ACPI_RESOURCE_NAME_DMA: |
bda663d3 RM |
385 | /* |
386 | * DMA Resource: | |
387 | * Get the number of bits set in the DMA channels byte | |
388 | */ | |
50eca3eb | 389 | ACPI_MOVE_16_TO_16(&temp16, buffer); |
bda663d3 | 390 | extra_struct_bytes = |
50eca3eb | 391 | (acpi_rs_count_set_bits(temp16) * |
bda663d3 RM |
392 | sizeof(u32)); |
393 | break; | |
394 | ||
50eca3eb | 395 | case ACPI_RESOURCE_NAME_VENDOR_SMALL: |
bda663d3 RM |
396 | /* |
397 | * Vendor Specific Resource: | |
398 | * Ensure a 32-bit boundary for the structure | |
399 | */ | |
400 | extra_struct_bytes = | |
401 | ACPI_ROUND_UP_to_32_bITS(resource_length); | |
402 | break; | |
403 | ||
50eca3eb | 404 | case ACPI_RESOURCE_NAME_END_TAG: |
bda663d3 RM |
405 | /* |
406 | * End Tag: | |
407 | * Terminate the loop now | |
408 | */ | |
50eca3eb | 409 | aml_buffer_length = bytes_parsed; |
bda663d3 RM |
410 | break; |
411 | ||
412 | default: | |
413 | break; | |
414 | } | |
415 | } else { | |
416 | /* | |
417 | * Large resource descriptors | |
418 | */ | |
50eca3eb BM |
419 | header_length = |
420 | sizeof(struct aml_resource_large_header); | |
421 | buffer = aml_buffer + header_length; | |
bda663d3 RM |
422 | |
423 | switch (resource_type) { | |
50eca3eb | 424 | case ACPI_RESOURCE_NAME_VENDOR_LARGE: |
bda663d3 RM |
425 | /* |
426 | * Vendor Defined Resource: | |
427 | * Add vendor data and ensure a 32-bit boundary for the structure | |
428 | */ | |
429 | extra_struct_bytes = | |
430 | ACPI_ROUND_UP_to_32_bITS(resource_length); | |
431 | break; | |
432 | ||
50eca3eb BM |
433 | case ACPI_RESOURCE_NAME_ADDRESS32: |
434 | case ACPI_RESOURCE_NAME_ADDRESS16: | |
bda663d3 RM |
435 | /* |
436 | * 32-Bit or 16-bit Address Resource: | |
437 | * Add the size of any optional data (resource_source) | |
438 | */ | |
439 | extra_struct_bytes = | |
440 | acpi_rs_stream_option_length | |
441 | (resource_length, | |
50eca3eb BM |
442 | resource_info-> |
443 | minimum_aml_resource_length); | |
bda663d3 RM |
444 | break; |
445 | ||
50eca3eb | 446 | case ACPI_RESOURCE_NAME_EXTENDED_IRQ: |
bda663d3 RM |
447 | /* |
448 | * Extended IRQ: | |
449 | * Point past the interrupt_vector_flags to get the | |
450 | * interrupt_table_length. | |
451 | */ | |
452 | buffer++; | |
453 | ||
454 | /* | |
455 | * Add 4 bytes for each additional interrupt. Note: at least one | |
456 | * interrupt is required and is included in the minimum | |
457 | * descriptor size | |
458 | */ | |
459 | extra_struct_bytes = | |
460 | ((*buffer - 1) * sizeof(u32)); | |
461 | ||
462 | /* Add the size of any optional data (resource_source) */ | |
463 | ||
464 | extra_struct_bytes += | |
465 | acpi_rs_stream_option_length(resource_length | |
466 | - | |
467 | extra_struct_bytes, | |
468 | resource_info-> | |
50eca3eb | 469 | minimum_aml_resource_length); |
bda663d3 RM |
470 | break; |
471 | ||
50eca3eb | 472 | case ACPI_RESOURCE_NAME_ADDRESS64: |
bda663d3 RM |
473 | /* |
474 | * 64-Bit Address Resource: | |
475 | * Add the size of any optional data (resource_source) | |
476 | * Ensure a 64-bit boundary for the structure | |
477 | */ | |
478 | extra_struct_bytes = | |
479 | ACPI_ROUND_UP_to_64_bITS | |
480 | (acpi_rs_stream_option_length | |
481 | (resource_length, | |
50eca3eb BM |
482 | resource_info-> |
483 | minimum_aml_resource_length)); | |
bda663d3 RM |
484 | break; |
485 | ||
486 | default: | |
487 | break; | |
488 | } | |
489 | } | |
44f6c012 | 490 | |
bda663d3 | 491 | /* Update the required buffer size for the internal descriptor structs */ |
1da177e4 | 492 | |
bda663d3 | 493 | temp16 = |
50eca3eb | 494 | (u16) (resource_info->minimum_internal_struct_length + |
bda663d3 RM |
495 | extra_struct_bytes); |
496 | buffer_size += (u32) ACPI_ALIGN_RESOURCE_SIZE(temp16); | |
44f6c012 | 497 | |
bda663d3 RM |
498 | /* |
499 | * Update byte count and point to the next resource within the stream | |
500 | * using the size of the header plus the length contained in the header | |
501 | */ | |
502 | temp16 = (u16) (header_length + resource_length); | |
503 | bytes_parsed += temp16; | |
50eca3eb | 504 | aml_buffer += temp16; |
1da177e4 LT |
505 | } |
506 | ||
44f6c012 RM |
507 | /* This is the data the caller needs */ |
508 | ||
1da177e4 | 509 | *size_needed = buffer_size; |
4be44fcd | 510 | return_ACPI_STATUS(AE_OK); |
1da177e4 LT |
511 | } |
512 | ||
1da177e4 LT |
513 | /******************************************************************************* |
514 | * | |
515 | * FUNCTION: acpi_rs_get_pci_routing_table_length | |
516 | * | |
517 | * PARAMETERS: package_object - Pointer to the package object | |
518 | * buffer_size_needed - u32 pointer of the size buffer | |
519 | * needed to properly return the | |
520 | * parsed data | |
521 | * | |
522 | * RETURN: Status | |
523 | * | |
524 | * DESCRIPTION: Given a package representing a PCI routing table, this | |
525 | * calculates the size of the corresponding linked list of | |
526 | * descriptions. | |
527 | * | |
528 | ******************************************************************************/ | |
529 | ||
530 | acpi_status | |
4be44fcd LB |
531 | acpi_rs_get_pci_routing_table_length(union acpi_operand_object *package_object, |
532 | acpi_size * buffer_size_needed) | |
1da177e4 | 533 | { |
4be44fcd LB |
534 | u32 number_of_elements; |
535 | acpi_size temp_size_needed = 0; | |
536 | union acpi_operand_object **top_object_list; | |
537 | u32 index; | |
538 | union acpi_operand_object *package_element; | |
539 | union acpi_operand_object **sub_object_list; | |
540 | u8 name_found; | |
541 | u32 table_index; | |
1da177e4 | 542 | |
4be44fcd | 543 | ACPI_FUNCTION_TRACE("rs_get_pci_routing_table_length"); |
1da177e4 LT |
544 | |
545 | number_of_elements = package_object->package.count; | |
546 | ||
547 | /* | |
548 | * Calculate the size of the return buffer. | |
549 | * The base size is the number of elements * the sizes of the | |
550 | * structures. Additional space for the strings is added below. | |
551 | * The minus one is to subtract the size of the u8 Source[1] | |
552 | * member because it is added below. | |
553 | * | |
554 | * But each PRT_ENTRY structure has a pointer to a string and | |
555 | * the size of that string must be found. | |
556 | */ | |
557 | top_object_list = package_object->package.elements; | |
558 | ||
559 | for (index = 0; index < number_of_elements; index++) { | |
44f6c012 RM |
560 | /* Dereference the sub-package */ |
561 | ||
1da177e4 LT |
562 | package_element = *top_object_list; |
563 | ||
564 | /* | |
565 | * The sub_object_list will now point to an array of the | |
566 | * four IRQ elements: Address, Pin, Source and source_index | |
567 | */ | |
568 | sub_object_list = package_element->package.elements; | |
569 | ||
44f6c012 RM |
570 | /* Scan the irq_table_elements for the Source Name String */ |
571 | ||
1da177e4 LT |
572 | name_found = FALSE; |
573 | ||
4be44fcd LB |
574 | for (table_index = 0; table_index < 4 && !name_found; |
575 | table_index++) { | |
44f6c012 | 576 | if ((ACPI_TYPE_STRING == |
4be44fcd LB |
577 | ACPI_GET_OBJECT_TYPE(*sub_object_list)) |
578 | || | |
579 | ((ACPI_TYPE_LOCAL_REFERENCE == | |
580 | ACPI_GET_OBJECT_TYPE(*sub_object_list)) | |
581 | && ((*sub_object_list)->reference.opcode == | |
582 | AML_INT_NAMEPATH_OP))) { | |
1da177e4 | 583 | name_found = TRUE; |
4be44fcd | 584 | } else { |
44f6c012 RM |
585 | /* Look at the next element */ |
586 | ||
1da177e4 LT |
587 | sub_object_list++; |
588 | } | |
589 | } | |
590 | ||
4be44fcd | 591 | temp_size_needed += (sizeof(struct acpi_pci_routing_table) - 4); |
1da177e4 | 592 | |
44f6c012 RM |
593 | /* Was a String type found? */ |
594 | ||
1da177e4 | 595 | if (name_found) { |
4be44fcd LB |
596 | if (ACPI_GET_OBJECT_TYPE(*sub_object_list) == |
597 | ACPI_TYPE_STRING) { | |
1da177e4 LT |
598 | /* |
599 | * The length String.Length field does not include the | |
600 | * terminating NULL, add 1 | |
601 | */ | |
44f6c012 | 602 | temp_size_needed += ((acpi_size) |
4be44fcd LB |
603 | (*sub_object_list)->string. |
604 | length + 1); | |
605 | } else { | |
50eca3eb | 606 | temp_size_needed += acpi_ns_get_pathname_length((*sub_object_list)->reference.node); |
1da177e4 | 607 | } |
4be44fcd | 608 | } else { |
1da177e4 LT |
609 | /* |
610 | * If no name was found, then this is a NULL, which is | |
611 | * translated as a u32 zero. | |
612 | */ | |
4be44fcd | 613 | temp_size_needed += sizeof(u32); |
1da177e4 LT |
614 | } |
615 | ||
616 | /* Round up the size since each element must be aligned */ | |
617 | ||
4be44fcd | 618 | temp_size_needed = ACPI_ROUND_UP_to_64_bITS(temp_size_needed); |
1da177e4 | 619 | |
44f6c012 RM |
620 | /* Point to the next union acpi_operand_object */ |
621 | ||
1da177e4 LT |
622 | top_object_list++; |
623 | } | |
624 | ||
625 | /* | |
44f6c012 RM |
626 | * Adding an extra element to the end of the list, essentially a |
627 | * NULL terminator | |
1da177e4 | 628 | */ |
4be44fcd LB |
629 | *buffer_size_needed = |
630 | temp_size_needed + sizeof(struct acpi_pci_routing_table); | |
631 | return_ACPI_STATUS(AE_OK); | |
1da177e4 | 632 | } |