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