115 			/* Should we merge with previous? */  in fdt_find_regions()
155  * The region is added if there is space, but in any case we increment the
156  * count. If permitted, and the new region overlaps the last one, we merge
197  * fdt_add_alias_regions() - Add regions covering the aliases that we want
201  * aliases are special in that we generally want to include those which
204  * In fact we want to include only aliases for those nodes still included in
208  * This function scans the aliases and adds regions for those which we want
217  * @return number of regions after processing, or -FDT_ERR_NOSPACE if we did
218  * not have enough room in the regions table for the regions we wanted to add.
232 	 * Find the next node so that we know where the /aliases node ends. We  in fdt_add_alias_regions()
284  * When we decided to include a node or property which is not at the top
293  * If we decide to include testing then we need the root node to have a valid
303 	 * Work down the stack looking for supernodes that we didn't include.  in fdt_include_supernodes()
304 	 * The algortihm here is actually pretty simple, since we know that  in fdt_include_supernodes()
305 	 * no previous subnode had to include these nodes, or if it did, we  in fdt_include_supernodes()
376  * marks the start of the region we want to include.
378  * Once info->start is set to the start (i.e. not -1), we continue
379  * scanning until we find something that we don't want included. This
380  * will be the end of a region. At this point we can close off the
381  * region and add it to the list. So we do so, and reset info->start
384  * One complication here is that we want to merge regions. So when we
385  * come to add another region later, we may in fact merge it with the
389  * region, because we already have a region ready to be returned, and
390  * the new one cannot be merged in with it. In this case, we must return
391  * the region we found, and wait for another call to this function.
392  * When it comes, we will repeat the processing of the tag and again
396  * in a ptrs member. At the start of every loop iteration we make a copy
397  * of it.  The copy is then updated as the tag is processed. Only if we
399  * fdt_add_region() if we need to) can we commit the changes we have
400  * made to these pointers. For example, if we see an FDT_END_NODE tag,
401  * we will decrement the depth value. But if we need to add a region
403  * FDT_END_NODE tag is not included) then we will only commit the result
404  * if we were able to add the region. That allows us to retry again next
407  * We keep track of a variable called 'want' which tells us what we want
413  * FDT_REG_DIRECT_SUBNODES feature also makes use of 'want'. While we
417  * selected, then we will just rely on what the h_include() function
420  * Using 'want' we work out 'include', which tells us whether this
422  * value of 'include' changes, that means we are on a boundary between
423  * nodes to include and nodes to exclude. At this point we either close
427  * Apart from the nodes, we have mem_rsvmap, the FDT_END tag and the
428  * string list. Each of these dealt with as a whole (i.e. we create a
429  * region for each if it is to be included). For mem_rsvmap we don't
431  * we don't allow it to merge with the last struct region (which
462 	 * be included or not. We set the variable 'include' to indicate our  in fdt_next_region()
463 	 * decision. 'want' is used to track what we want to include - it  in fdt_next_region()
479 		 * Make a copy of our pointers. If we make it to the end of  in fdt_next_region()
480 		 * this block then we will commit them back to info->ptrs.  in fdt_next_region()
481 		 * Otherwise we can try again from the same starting state  in fdt_next_region()
482 		 * next time we are called.  in fdt_next_region()
487 		 * Find the tag, and the offset of the next one. If we need to  in fdt_next_region()
488 		 * stop including tags, then by default we stop *after*  in fdt_next_region()
507 				 * Make sure we include the } for this block.  in fdt_next_region()
510 				 * the case where it adds the node we are  in fdt_next_region()
544 			 * If we are not intending to include this node unless  in fdt_next_region()
545 			 * it matches, make sure we stop *before* its tag.  in fdt_next_region()
587 			 * If we don't want this node, stop right away, unless  in fdt_next_region()
588 			 * we are including subnodes  in fdt_next_region()
600 			/* We always include the end tag */  in fdt_next_region()
628 		/* If we have made it this far, we can commit our pointers */  in fdt_next_region()