text: #include <gpxe/io.h>
  #include <registers.h>
  #include <gpxe/memmap.h>
  
  /*
   * Originally by Eric Biederman
   *
   * Heavily modified by Michael Brown 
   *
   */
  
  FILE_LICENCE ( GPL2_OR_LATER );
  
  /*
   * The linker passes in the symbol _max_align, which is the alignment
   * that we must preserve, in bytes.
   *
   */
  extern char _max_align[];
  #define max_align ( ( unsigned int ) _max_align )
  
  /* Linker symbols */
  extern char _textdata[];
  extern char _etextdata[];
  
  /* within 1MB of 4GB is too close. 
   * MAX_ADDR is the maximum address we can easily do DMA to.
   *
   * Not sure where this constraint comes from, but kept it from Eric's
   * old code - mcb30
   */
  #define MAX_ADDR (0xfff00000UL)
  
  /**
   * Relocate Etherboot
   *
   * @v ix86		x86 register dump from prefix
   * @ret ix86		x86 registers to return to prefix
   *
   * This finds a suitable location for Etherboot near the top of 32-bit
   * address space, and returns the physical address of the new location
   * to the prefix in %edi.
   */
  __asmcall void relocate ( struct i386_all_regs *ix86 ) {
  	struct memory_map memmap;
  	unsigned long start, end, size, padded_size;
  	unsigned long new_start, new_end;
  	unsigned i;
  
  	/* Get memory map and current location */
  	get_memmap ( &memmap );
  	start = virt_to_phys ( _textdata );
  	end = virt_to_phys ( _etextdata );
  	size = ( end - start );
  	padded_size = ( size + max_align - 1 );
  
  	DBG ( "Relocate: currently at [%lx,%lx)\n"
  	      "...need %lx bytes for %d-byte alignment\n",
  	      start, end, padded_size, max_align );
  
  	/* Walk through the memory map and find the highest address
  	 * below 4GB that etherboot will fit into.  Ensure etherboot
  	 * lies entirely within a range with A20=0.  This means that
  	 * even if something screws up the state of the A20 line, the
  	 * etherboot code is still visible and we have a chance to
  	 * diagnose the problem.
  	 */
  	new_end = end;
  	for ( i = 0 ; i < memmap.count ; i++ ) {
  		struct memory_region *region = &memmap.regions[i];
  		unsigned long r_start, r_end;
  
  		DBG ( "Considering [%llx,%llx)\n", region->start, region->end);
  		
  		/* Truncate block to MAX_ADDR.  This will be less than
  		 * 4GB, which means that we can get away with using
  		 * just 32-bit arithmetic after this stage.
  		 */
  		if ( region->start > MAX_ADDR ) {
  			DBG ( "...starts after MAX_ADDR=%lx\n", MAX_ADDR );
  			continue;
  		}
  		r_start = region->start;
  		if ( region->end > MAX_ADDR ) {
  			DBG ( "...end truncated to MAX_ADDR=%lx\n", MAX_ADDR );
  			r_end = MAX_ADDR;
  		} else {
  			r_end = region->end;
  		}
  		
  		/* Shrink the range down to use only even megabytes
  		 * (i.e. A20=0).
  		 */
  		if ( ( r_end - 1 ) & 0x100000 ) {
  			/* If last byte that might be used (r_end-1)
  			 * is in an odd megabyte, round down r_end to
  			 * the top of the next even megabyte.
  			 *
  			 * Make sure that we don't accidentally wrap
  			 * r_end below 0.
  			 */
  			if ( r_end >= 1 ) {
  				r_end = ( r_end - 1 ) & ~0xfffff;
  				DBG ( "...end truncated to %lx "
  				      "(avoid ending in odd megabyte)\n",
  				      r_end );
  			}
  		} else if ( ( r_end - size ) & 0x100000 ) {
  			/* If the last byte that might be used
  			 * (r_end-1) is in an even megabyte, but the
  			 * first byte that might be used (r_end-size)
  			 * is an odd megabyte, round down to the top
  			 * of the next even megabyte.
  			 * 
  			 * Make sure that we don't accidentally wrap
  			 * r_end below 0.
  			 */
  			if ( r_end >= 0x100000 ) {
  				r_end = ( r_end - 0x100000 ) & ~0xfffff;
  				DBG ( "...end truncated to %lx "
  				      "(avoid starting in odd megabyte)\n",
  				      r_end );
  			}
  		}
  
  		DBG ( "...usable portion is [%lx,%lx)\n", r_start, r_end );
  
  		/* If we have rounded down r_end below r_ start, skip
  		 * this block.
  		 */
  		if ( r_end < r_start ) {
  			DBG ( "...truncated to negative size\n" );
  			continue;
  		}
  
  		/* Check that there is enough space to fit in Etherboot */
  		if ( ( r_end - r_start ) < size ) {
  			DBG ( "...too small (need %lx bytes)\n", size );
  			continue;
  		}
  
  		/* If the start address of the Etherboot we would
  		 * place in this block is higher than the end address
  		 * of the current highest block, use this block.
  		 *
  		 * Note that this avoids overlaps with the current
  		 * Etherboot, as well as choosing the highest of all
  		 * viable blocks.
  		 */
  		if ( ( r_end - size ) > new_end ) {
  			new_end = r_end;
  			DBG ( "...new best block found.\n" );
  		}
  	}
  
  	/* Calculate new location of Etherboot, and align it to the
  	 * required alignemnt.
  	 */
  	new_start = new_end - padded_size;
  	new_start += ( start - new_start ) & ( max_align - 1 );
  	new_end = new_start + size;
  
  	DBG ( "Relocating from [%lx,%lx) to [%lx,%lx)\n",
  	      start, end, new_start, new_end );
  	
  	/* Let prefix know what to copy */
  	ix86->regs.esi = start;
  	ix86->regs.edi = new_start;
  	ix86->regs.ecx = size;
  }
  