path: root/target/linux/etrax/image/boot_linux

#!/usr/bin/perl -w

#*****************************************************************************
#!
#! FILE NAME  : boot_linux
#!
#! PARAMETERS : -b <bootimage>     the name of the boot image to use
#!              -d <device>        the interface to use, e.g., eth1
#!                                 (defaults is eth0)
#!              -f                 save it in flash memory at address 0x10000
#!              -F                 save it in flash memory at address 0
#!              -h                 show some help
#!              -i <image>         name of the image to use (default is fimage)
#!              -o <offset>        the offset in the flash where the flashing
#!                                 starts
#!              -O <offset>        the offset in the image file where the
#!                                 flashing starts from
#!              -p                 print the resulting etrax100boot command
#!                                 instead of executing it
#!              -s <size>          how much to flash (default is the size of
#!                                 the flash minus the offset specified using
#!                                 -o or -f)
#!              -S <size>          the size of the flash
#!
#!              All sizes and offsets above can be specified as decimal
#!              numbers, or as hexadecimal numbers by prefixing them with 0x.
#!              It is also possible to use the suffixes k and M to specify
#!              kilo (1024) or mega (1048576).
#!
#! DESCRIPTION: Extract the start of the image and any registers that should
#!              be set from the kimage or fimage file, and then boot it.
#!
#! FUNCTIONS  : convert_size
#!              extract_hw_settings
#!              get_dword
#!              calculate_sdram_init
#!              sdram_command
#!              print_help
#!
#!----------------------------------------------------------------------------
#! HISTORY
#!
#! $Log: boot_linux,v $
#! Revision 1.16  2004/11/01 16:32:27  starvik
#! Corrected help text to avoid confusion
#!
#! Revision 1.15  2003/01/29 11:48:57  pkj
#! Calculate a flash size large enough for the given image if the
#! -S option is not specified.
#!
#! Revision 1.14  2002/11/18 14:40:09  pkj
#! Make use of the --loop option to etrax100boot when initialising
#! SDRAM memories. This requires a lot fewer options to be passed
#! to the boot loader.
#!
#! Revision 1.13  2002/08/15 16:29:02  pkj
#! * The -S option now accepts the size in bytes (just like the -s option).
#!   For backwards compatibility it still assumes sizes of 16 and less to
#!   be specified in MB.
#! * The suffixes k and M can now be used with all sizes and offsets to
#!   specify them in kilo or mega.
#!
#! Revision 1.12  2002/08/15 15:27:34  pkj
#! Use $opts{'x'} instead of $opt_x.
#!
#! Revision 1.11  2002/07/04 17:06:39  pkj
#! * No longer specifies a bootfile by default (not needed any longer).
#! * Implemented option -b to specify a bootfile.
#! * Removed references to option -l (it was never implemented).
#!
#! Revision 1.10  2002/06/04 11:50:23  starvik
#! Check if mrs_data is specified in kernelconfig (necessary for MCM)
#!
#! Revision 1.9  2002/01/29 10:38:26  pkj
#! Change illegal to invalid.
#!
#! Revision 1.8  2001/09/13 12:32:10  pkj
#! * Added option -S to specify the size of the flash (in MB),  as -s
#!   is used to specify how much to flash nowadays.
#! * Made the default size of the flash depend on the size of the image
#!   file. If it is bigger than 0x200100 then the flash is assumed to
#!   be 4 MB, otherwise it is assumed to be 2 MB.
#! * Added verification of various options.
#!
#! Revision 1.7  2001/09/13 10:25:11  pkj
#! Minor clean-up.
#!
#! Revision 1.6  2001/06/29 10:05:16  pkj
#! Corrected check for SDRAM.
#!
#! Revision 1.5  2001/06/29 09:11:55  pkj
#! Synchronised boot_elinux and boot_linux.
#!
#!----------------------------------------------------------------------------
#! (C) Copyright 2001, Axis Communications AB, LUND, SWEDEN
#!****************************************************************************

#****************** INCLUDE FILES SECTION ************************************

use strict;

use Getopt::Std;
use File::Basename;

#****************** VARIABLE DECLARATION SECTION *****************************

use vars qw($my_name %opts);
use vars qw($text_start $cmd);
use vars qw($image_name $image_size);
use vars qw($offset $source_offset $flash_size $flashing_size);
use vars qw($sdram_timing_address $sdram_config_address);
use vars qw($sdram_precharge $sdram_nop $sdram_refresh $sdram_mrs);

#****************** CONSTANT SECTION *****************************************

# Register addresses
$sdram_timing_address = "b0000008";
$sdram_config_address = "b000000c";

# SDRAM commands
$sdram_precharge = 3;
$sdram_nop = 0;
$sdram_refresh = 2;
$sdram_mrs = 1;

#****************** MAIN PROGRAM SECTION *************************************

# The name of this program.
$my_name = basename($0);

# Get options
getopts('b:d:fFhi:o:O:ps:S:', \%opts);

&print_help if ($opts{'h'});

# Name and existance of the image
$image_name = ($opts{'i'} ? $opts{'i'} : 'fimage');
die "Could not find the image $image_name!\n" unless (-s $image_name);

if ($opts{'f'} || $opts{'F'})
{
  $image_size = -s $image_name;

  $offset = ($opts{'f'} ? 0x10000 : 0);

  $offset = &convert_size($opts{'o'}) if (defined($opts{'o'}));

  die("$my_name: Invalid destination offset\n") if ($offset !~ /^\d+$/);

  my $base_name = basename($image_name);
  if ($base_name eq 'timage' || $base_name eq 'flash1.img')
  {
    $source_offset = 0;
  }
  else
  {
    $source_offset = $offset;
  }

  $source_offset = &convert_size($opts{'O'}) if (defined($opts{'O'}));

  die("$my_name: Invalid source offset\n") if ($source_offset !~ /^\d+$/);
  die("$my_name: Source offset > image size\n") if ($source_offset > $image_size);

  if (defined($opts{'S'}))
  {
    # Backwards compatibility to allow specifying the flash size in MB
    # without using an M suffix
    $opts{'S'} .= 'M' if ($opts{'S'} =~ /^\d+$/ && $opts{'S'} <= 16);

    $flash_size = &convert_size($opts{'S'});
  }
  else
  {
    # Calculate a flash size large enough for the image without the checksum
    # and HWID.
    $flash_size = ($image_size - $source_offset + $offset) & 0xFFFF0000;
  }

  die("$my_name: Invalid flash size\n") if ($flash_size !~ /^\d+$/);
  die("$my_name: Destination offset > flash size\n") if ($offset > $flash_size);
  if (defined($opts{'s'}))
  {
    $flashing_size = &convert_size($opts{'s'});
  }
  else
  {
    $flashing_size = $flash_size - $offset;
  }

  die("$my_name: Invalid size to flash\n") if ($flashing_size !~ /^\d+$/);

  if ($flashing_size > $flash_size - $offset)
  {
    $flashing_size = $flash_size - $offset;
    printf("Warning: Flashing size limited to 0x%lx due to the offset (0x%lx) and flash size (0x%lx).\n", $flashing_size, $offset, $flash_size);
  }

  if ($flashing_size > $image_size - $source_offset)
  {
    $flashing_size = $image_size - $source_offset;
    printf("Warning: Flashing size limited to 0x%lx due to the offset (0x%lx) and image size (0x%lx).\n", $flashing_size, $source_offset, $image_size);
  }
}

# Create the command line to boot the image
if (system('./etrax100boot --help > /dev/null') == 0)
{
  $cmd = './etrax100boot';
}
elsif (system('svinto_boot --help > /dev/null') == 0)
{
  $cmd = 'svinto_boot';
}
else
{
  die("Cannot find e100boot program in your PATH!\n");
}

$cmd .= " --device $opts{'d'}" if ($opts{'d'});

$cmd .= &extract_hw_settings;

$cmd .= " --bootfile $opts{'b'}" if ($opts{'b'});
$cmd .= " --file $image_name $text_start";

if ($opts{'f'} || $opts{'F'})
{
  $cmd .= sprintf(" --flash %lx %lx %lx --jump 0",
		  hex($text_start) + $source_offset, $offset, $flashing_size);
}
else
{
  $cmd .= " --jump $text_start";
}

if ($opts{'p'})
{
  print "Command:\n$cmd\n";
}
else
{
  system($cmd);
}

exit 0;

#****************** FUNCTION DEFINITION SECTION ******************************

#*****************************************************************************
##
## FUNCTION NAME: convert_size
##
##****************************************************************************

sub convert_size
{
  my($arg) = @_;
  my $size;

  if ($arg =~ /^0x([\da-fA-F]+)([kM])?$/)
  {
    $size = hex($1);
  }
  elsif ($arg =~ /^(\d+)([kM])?$/)
  {
    $size = $1;
  }
  else
  {
    return -1;
  }

  if (!defined($2))
  {
    return $size;
  }
  elsif ($2 eq 'k')
  {
    return $size * 1024;
  }
  elsif ($2 eq 'M')
  {
    return $size * 1048576;
  }
}

#*****************************************************************************
##
## FUNCTION NAME: extract_hw_settings
##
##****************************************************************************

sub extract_hw_settings
{
  my $data;
  my $dbg_port;
  my $sdram_enabled;
  my $return_value = "";
  my $sdram_config;

  # The hw information table has the following format
  #
  # "HW_PARAM_MAGIC"
  # text_start (dword)
  # serial debg port (dword)
  # sdram enabled (dword)
  # register address (dword)
  # register value (dword)
  # ...
  # 0

  open(FILE, "$image_name") || die("Could not open '$image_name'");

  while (<FILE>)
  {
    if (m/HW_PARAM_MAGIC/g)
    {
      # Seek to first byte after magic
      seek(FILE, -length($_) + pos($_), 1);
      last;
    }
  }

  $text_start = &get_dword;
  $dbg_port = &get_dword;
  $sdram_enabled = int(&get_dword);

  while (1)
  {
    my $register = &get_dword;
    my $value = &get_dword;

    last if ($register eq "00000000");

    if ($sdram_enabled)
    {
      if ($register eq $sdram_config_address)
      {
	$sdram_config = $value;
      }
      elsif ($register eq $sdram_timing_address)
      {
	$return_value .= &calculate_sdram_init($value, $sdram_config);
	next;
      }
    }

    $return_value .= " --setreg $register $value";
  }

  close(FILE);

  return $return_value;
}

#*****************************************************************************
##
## FUNCTION NAME: get_dword
##
##****************************************************************************

sub get_dword
{
  my $data;

  read(FILE, $data, 4);
  return unpack("H8", pack("V", unpack("N", $data)));
}

#*****************************************************************************
##
## FUNCTION NAME: calculate_sdram_init
##
##****************************************************************************

sub calculate_sdram_init
{
  # Refer to ETRAX 100LX Designers Reference for a description of SDRAM
  # initialization
  my $sdram_init_val = hex($_[0]);
  my $sdram_config_val = hex($_[1]);
  my $bus_width = $sdram_config_val & 0x00800000;
  my $speed;
  my $cas_latency;
  my $mrs_data;
  my $temp;
  my $return_value;
  my $value;

  $mrs_data = ($sdram_init_val & 0x00ff0000) >> 16;
  $sdram_init_val &= 0x8000ffff; # Make sure mrs data is 0
  $sdram_init_val |= 0x80000000; # Make sure sdram is enabled
  $speed = $sdram_init_val & 0x1000;
  $cas_latency = $sdram_init_val & 0x3;
  if ($speed) # 100 MHz
  {
    $cas_latency += 2;
  }
  else # 50 MHz
  {
    $cas_latency += 1;
  }

  # Calculate value of mrs_data
  # CAS latency = 2 && bus_width = 32 => 0x40
  # CAS latency = 3 && bus_width = 32 => 0x60
  # CAS latency = 2 && bus_width = 16 => 0x20
  # CAS latency = 3 && bus_width = 16 => 0x30
  if ($mrs_data == 0)
  {
    if ($bus_width == 0) # 16 bits
    {
      $mrs_data = $cas_latency == 2 ? 0x20 : 0x30;
    }
    else # 32 bits
    {
      $mrs_data = $cas_latency == 2 ? 0x40 : 0x60;
    }
  }

  $temp = $sdram_init_val | 0x0000c000; # Disable refresh
  $return_value .= &sdram_command($temp);
  $return_value .= " --pause 20000";

  $return_value .= &sdram_command($temp, $sdram_precharge);
  $return_value .= &sdram_command($temp, $sdram_nop);

  $return_value .= " --setreg +0 7";
  $return_value .= " --label label1";
  $return_value .= &sdram_command($temp, $sdram_refresh);
  $return_value .= &sdram_command($temp, $sdram_nop);
  $return_value .= " --loop +0 label1";

  $return_value .= &sdram_command($temp, $sdram_mrs, $mrs_data);
  $return_value .= &sdram_command($temp, $sdram_nop);

  $return_value .= &sdram_command($sdram_init_val);

  return $return_value;
}

#*****************************************************************************
##
## FUNCTION NAME: sdram_command
##
##****************************************************************************

sub sdram_command
{
  my($temp, $value, $mrs_data) = @_;

  $value ||= 0;
  if ($value == $sdram_mrs)
  {
    $value = sprintf("%lx", $temp | ($value << 9) | ($mrs_data << 16));
  }
  else
  {
    $value = sprintf("%lx", $temp | ($value << 9));
  }

  return " --setreg $sdram_timing_address $value";
}

#*****************************************************************************
##
## FUNCTION NAME: print_help
##
##****************************************************************************

sub print_help
{
  print "\nAXIS $my_name, ", '$Revision: 1.16 $ $Date: 2004/11/01 16:32:27 $ ', "\n";
  die <<EOT;
Copyright (C) 2001-2002 Axis Communications AB

DESCRIPTION:
  This program is used to boot (and flash) a linux image to a box.
  It tries to extract the required ETRAX 100 settings from the image file.

SYNTAX:
  $my_name [options]

OPTIONS:
  -b <bootfile>           : The boot image to use.
  -d <device>             : The network interface to use, default is eth0.
  -f                      : Save the image in the flash memory starting at
                            address 0x10000.
  -F                      : Save the image in the flash memory starting at
                            address 0.
  -h                      : Print this help text.
  -i <image>              : The path and name of the image to use, default
                            is fimage.
  -o <offset>             : The offset in the flash where the flashing starts.
  -O <offset>             : The offset in the image file where the flashing
                            starts from.
  -p                      : Print the resulting etrax100boot command instead
                            of executing it.
  -s <size>               : How much to flash (default is the size of the
			    flash minus the offset specified using -o or -f).
  -S <size>               : The size of the flash.

  All sizes and offsets above can be specified as decimal numbers, or as
  hexadecimal numbers by prefixing them with 0x. It is also possible to use
  the suffixes k and M to specify kilo (1024) or mega (1048576).

EOT
}

#****************** END OF FILE boot_linux ***********************************