mirror of
https://github.com/openwrt/openwrt.git
synced 2024-12-22 15:02:32 +00:00
1218 lines
40 KiB
Perl
Executable File
1218 lines
40 KiB
Perl
Executable File
#!/usr/bin/env perl
|
|
#
|
|
# SlugImage : Manipulate NSLU2 firmware images
|
|
# Dwayne Fontenot (jacques)
|
|
# Rod Whitby (rwhitby)
|
|
# www.nslu2-linux.org
|
|
#
|
|
# Copyright (c) 2004, 2006, Dwayne Fontenot & Rod Whitby
|
|
# All rights reserved.
|
|
#
|
|
# Redistribution and use in source and binary forms, with or without
|
|
# modification, are permitted provided that the following conditions
|
|
# are met:
|
|
#
|
|
# Redistributions of source code must retain the above copyright
|
|
# notice, this list of conditions and the following disclaimer.
|
|
# Redistributions in binary form must reproduce the above copyright
|
|
# notice, this list of conditions and the following disclaimer in the
|
|
# documentation and/or other materials provided with the distribution.
|
|
# Neither the name of the NSLU2-Linux Development Team nor the names
|
|
# of its contributors may be used to endorse or promote products
|
|
# derived from this software without specific prior written
|
|
# permission.
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
|
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
# POSSIBILITY OF SUCH DAMAGE.
|
|
#
|
|
|
|
use strict;
|
|
use warnings;
|
|
|
|
use Getopt::Long qw(:config no_ignore_case);
|
|
use File::Temp qw(tempfile);
|
|
|
|
my($debug) = 0;
|
|
my($quiet) = 0;
|
|
my($flash_start) = 0x50000000;
|
|
my($flash_len) = 0x00800000;
|
|
my($block_size) = 0x00020000;
|
|
my($kernel_offset) = 0x00060000;
|
|
my($kernel_size) = 0x00100000;
|
|
my($ramdisk_offset) = 0x00160000;
|
|
my(@cleanup);
|
|
|
|
# The last 70 bytes of the SercommRedBootTrailer (i.e. excluding MAC
|
|
# address). Needed to create an image with an empty RedBoot partition
|
|
# since the Sercomm upgrade tool checks for this trailer.
|
|
# http://www.nslu2-linux.org/wiki/Info/SercommRedBootTrailer
|
|
my @sercomm_redboot_trailer = (0x4573, 0x4372, 0x4d6f, 0x006d, 0x0001,
|
|
0x0400, 0x3170, 0x5895, 0x0010, 0x0000, 0x0000, 0x0000, 0x0000,
|
|
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
|
0x0000, 0x0000, 0x0001, 0x0000, 0x0000, 0x0000, 0x0003, 0x2300,
|
|
0x0063, 0x0000, 0x7320, 0x7245, 0x6f43, 0x6d4d);
|
|
|
|
# There's a 16 byte Sercomm trailer at the end of the flash. It is used
|
|
# by RedBoot to detect a Sercomm flash layout and to configure the
|
|
# Sercomm upgrade system.
|
|
# http://www.nslu2-linux.org/wiki/Info/SercommFlashTrailer
|
|
my @sercomm_flash_trailer = (0x0100, 0x0000, 0x6323, 0xf790, 0x5265,
|
|
0x4f63, 0x4d6d, 0xb400);
|
|
|
|
# Take $data, and pad it out to $total_len bytes, appending 0xff's.
|
|
sub padBytes {
|
|
my($data,$total_len) = @_;
|
|
|
|
# 0xFF is used to pad, as it's the erase value of the flash.
|
|
my($pad_char) = pack("C",0xff);
|
|
my($pad_len) = $total_len - length($data);
|
|
|
|
# A request for negative padding is indicative of a logic error ...
|
|
if (length($data) > $total_len) {
|
|
die sprintf("padBytes error: data (%d) is longer than total_len (%d)", length($data), $total_len);
|
|
}
|
|
|
|
return $data . ($pad_char x $pad_len);
|
|
}
|
|
|
|
# Return the next multiple of block_size larger than or equal to $data_len.
|
|
sub paddedSize {
|
|
my($data_len) = @_;
|
|
|
|
use integer;
|
|
return (($data_len - 1) / $block_size) * $block_size + $block_size;
|
|
}
|
|
|
|
# Return the number of block_size blocks required to hold $data_len.
|
|
sub numBlocks {
|
|
my($data_len) = @_;
|
|
|
|
use integer;
|
|
return (($data_len - 1) / $block_size) + 1;
|
|
}
|
|
|
|
# Pack the name, address, size and optional skip regions of a partition entry into binary form.
|
|
sub createPartitionEntry {
|
|
my($name, $flash_base, $size, $skips) = @_;
|
|
my $entry;
|
|
|
|
my($zero_long) = 0x0000;
|
|
|
|
# Pack the partition entry according to the format that RedBoot (and the MTD partition parsing code) requires.
|
|
$entry = pack("a16N5x212N2",$name,$flash_base,$zero_long,$size,$zero_long,$zero_long,$zero_long,$zero_long);
|
|
|
|
# Optionally put a skip header into the padding area.
|
|
if (defined $skips) {
|
|
my $i = scalar(@$skips);
|
|
foreach my $region (@$skips) {
|
|
substr($entry, -8 - 12*$i, 12) =
|
|
pack("a4N2", "skip", $region->{'offset'}, $region->{'size'});
|
|
$i--;
|
|
}
|
|
}
|
|
|
|
return $entry;
|
|
}
|
|
|
|
# Parse partition entry and return anon array ref [$name, $offset, $size, $skip] or return 0 on partition terminator.
|
|
sub parsePartitionEntry {
|
|
my($partition_entry) = @_;
|
|
|
|
my($entry_len) = 0x100;
|
|
length($partition_entry) eq $entry_len or die "parsePartitionEntry: partition entry length is not $entry_len!\n";
|
|
|
|
# Unpack the partition table entry, saving those values in which we are interested.
|
|
my($name, $flash_base, $size, $dummy_long, $padding, $skips);
|
|
($name, $flash_base, $dummy_long, $size, $dummy_long, $dummy_long, $padding, $dummy_long, $dummy_long) =
|
|
unpack("a16N5a212N2",$partition_entry);
|
|
|
|
# A partition entry starting with 0xFF terminates the table.
|
|
if (unpack("C", $name) eq 0xff) {
|
|
# %%% FIXME: This should only skip, not terminate. %%%
|
|
$debug and print "Found terminator for <FIS directory>\n";
|
|
return 0;
|
|
}
|
|
|
|
# Remove trailing nulls from the partition name.
|
|
$name =~ s/\000+//;
|
|
|
|
# Extract the skip regions out of the padding area.
|
|
$padding =~ s/^\000+//;
|
|
$padding =~ s/\000*skip(........)\000*/$1/g;
|
|
$padding =~ s/\000+$//;
|
|
|
|
# Store the skip regions in an array for later use.
|
|
while (length($padding)) {
|
|
my $region = {};
|
|
($region->{'offset'}, $region->{'size'}) =
|
|
unpack("N2", $padding);
|
|
$debug and printf("Found skip region at 0x%05X, size 0x%05X\n",
|
|
$region->{'offset'}, $region->{'size'});
|
|
push(@$skips, $region);
|
|
$padding = substr($padding,8);
|
|
}
|
|
|
|
return [$name, $flash_base - $flash_start, $size, $skips];
|
|
}
|
|
|
|
# Return partition table from data is one exists, otherwise return 0.
|
|
sub findPartitionTable {
|
|
my($data_buf) = @_;
|
|
|
|
unpack("a7", $data_buf) eq 'RedBoot' or return 0;
|
|
return substr($data_buf, 0, 0x1000)
|
|
}
|
|
|
|
# Parse partition table and return array of anonymous array references ([$name, $offset, $size, $skips], ...).
|
|
sub parsePartitionTable {
|
|
my($partition_table) = @_;
|
|
|
|
my(@partitions, $fields_ref);
|
|
my($entry_len) = 0x100;
|
|
my($partition_count) = 0;
|
|
|
|
# Loop through the fixed size partition table entries, and store the entries in @partitions.
|
|
# %%% FIXME: This doesn't handle the case of a completely full partition table. %%%
|
|
while ($fields_ref = parsePartitionEntry(substr($partition_table, $partition_count * $entry_len, $entry_len))) {
|
|
$debug and printf("Found <%s> at 0x%08X (%s)%s\n", $fields_ref->[0], $fields_ref->[1],
|
|
($fields_ref->[2] >= $block_size ?
|
|
sprintf("%d blocks", numBlocks($fields_ref->[2])) :
|
|
sprintf("0x%05X bytes", $fields_ref->[2])),
|
|
(defined $fields_ref->[3] ?
|
|
sprintf(" [%s]",
|
|
join(", ",
|
|
map { sprintf("0x%05X/0x%05X", $_->{'offset'},$_->{'size'}) }
|
|
@{$fields_ref->[3]})) :
|
|
""));
|
|
$partitions[$partition_count++] = $fields_ref;
|
|
}
|
|
return(@partitions);
|
|
}
|
|
|
|
# Create an empty jffs2 block.
|
|
sub jffs2Block {
|
|
return padBytes(pack("N3", 0x19852003, 0x0000000c, 0xf060dc98), $block_size);
|
|
}
|
|
|
|
# Write out $data to $filename,
|
|
sub writeOut {
|
|
my($data, $filename) = @_;
|
|
|
|
open FILE,">$filename" or die "Can't open file \"$filename\": $!\n";
|
|
|
|
if (defined($data)) { print FILE $data;}
|
|
|
|
close FILE or die "Can't close file \"$filename\": $!\n";
|
|
}
|
|
|
|
# Not used at the moment.
|
|
sub trailerData {
|
|
my($product_id) = 0x0001;
|
|
my($protocol_id) = 0x0000;
|
|
my($firmware_version) = 0x2325;
|
|
my($unknown1) = 0x90f7;
|
|
my($magic_number) = 'eRcOmM';
|
|
my($unknown2) = 0x00b9;
|
|
|
|
return pack("n4a6n",$product_id,$protocol_id,$firmware_version,$unknown1,$magic_number,$unknown2);
|
|
}
|
|
|
|
# Print the contents of the Sercomm RedBoot trailer.
|
|
sub printRedbootTrailer {
|
|
my($redboot_data) = @_;
|
|
|
|
my($correct_redboot_len) = 0x40000;
|
|
my($redboot_data_len) = length($redboot_data);
|
|
|
|
if ($redboot_data_len != $correct_redboot_len) {
|
|
printf("Redboot length (0x%08X) is not 0x%08X\n", $redboot_data_len, $correct_redboot_len);
|
|
return;
|
|
}
|
|
|
|
# The trailer is the last 80 bytes of the redboot partition.
|
|
my($redboot_trailer) = substr($redboot_data, -80);
|
|
|
|
writeOut($redboot_trailer, 'RedbootTrailer');
|
|
|
|
my($mac_addr0, $mac_addr1, $mac_addr2, $unknown, $prefix, $ver_ctrl, $down_ctrl, $hid, $hver, $prodid, $prodidmask,
|
|
$protid, $protidmask, $funcid, $funcidmask, $fver, $cseg, $csize, $postfix) =
|
|
unpack("n3Na7n2a32n10a7",$redboot_trailer);
|
|
|
|
printf("MAC address is %04X%04X%04X\n", $mac_addr0, $mac_addr1, $mac_addr2);
|
|
printf("unknown: %08X\n", $unknown);
|
|
printf("%s:%04X:%04X:%s\n", $prefix, $ver_ctrl, $down_ctrl, $postfix);
|
|
printf("VerControl: %04X\nDownControl: %04X\n", $ver_ctrl, $down_ctrl);
|
|
printf("hid: %04X %04X %04X %04X %04X %04X %04X %04X %04X %04X %04X %04X %04X %04X %04X %04X\n", unpack("n16", $hid));
|
|
printf("Hver: %04X\nProdID: %04X\nProtID: %04X\nFuncID: %04X\nFver: %04X\nCseg: %04X\nCsize: %04X\n",
|
|
$hver, $prodid, $protid, $funcid, $fver, $cseg, $csize);
|
|
}
|
|
|
|
# remove the optional Loader partition
|
|
sub removeOptionalLoader {
|
|
my($partitions_ref) = @_;
|
|
|
|
my $index;
|
|
my $count = 0;
|
|
map {
|
|
if (not defined $index) {
|
|
if ($_->{'name'} eq "Loader") {
|
|
$index = $count;
|
|
}
|
|
$count++;
|
|
}
|
|
} @$partitions_ref;
|
|
|
|
defined $index or die "Cannot find the Loader partition\n";
|
|
|
|
splice(@$partitions_ref, $index, 1);
|
|
|
|
# Set fixed offsets and sizes for Kernel and Ramdisk
|
|
map {
|
|
if ($_->{'name'} eq 'Kernel') {
|
|
$_->{'offset'} = $kernel_offset;
|
|
$_->{'size'} = $kernel_size;
|
|
$_->{'variable'} = 0;
|
|
}
|
|
if ($_->{'name'} eq 'Ramdisk') {
|
|
$_->{'offset'} = $ramdisk_offset;
|
|
}
|
|
} @$partitions_ref;
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
# populate @partitions based on the firmware's partition table
|
|
sub spliceFirmwarePartitions {
|
|
my($firmware_buf, $partitions_ref) = @_;
|
|
|
|
# we know that partition table, if it exists, begins at start of 'FIS directory' and has max length 0x1000
|
|
my($partition_table);
|
|
map {
|
|
$_->{'name'} eq 'FIS directory' and
|
|
$partition_table = findPartitionTable(substr($firmware_buf, $_->{'offset'}, $_->{'size'}));
|
|
} @$partitions_ref;
|
|
|
|
# return 0 here if no partition table in FIS directory
|
|
return if not $partition_table;
|
|
|
|
my @new_partitions = parsePartitionTable($partition_table);
|
|
|
|
# Remove the optional second stage bootloader if it is not found in the FIS directory.
|
|
if (not grep { $_->[0] eq 'Loader' } @new_partitions) {
|
|
removeOptionalLoader($partitions_ref);
|
|
}
|
|
|
|
my($partition_count) = 0;
|
|
my($splice) = 0;
|
|
map {
|
|
|
|
# Skip pseudo partitions.
|
|
while (($partition_count < scalar(@$partitions_ref)) and
|
|
$partitions_ref->[$partition_count]->{'pseudo'}) {
|
|
$debug and printf("Skipped <%s> (pseudo partition)\n", $partitions_ref->[$partition_count]->{'name'});
|
|
$partition_count++;
|
|
}
|
|
|
|
# If we are in a variable area, and we haven't reached the end of it,
|
|
# then splice in another partition for use by the later code.
|
|
if ($splice and ($partitions_ref->[$partition_count]->{'name'} ne $_->[0])) {
|
|
$debug and printf("Splicing new partition <%s> before <%s>\n",
|
|
$_->[0], $partitions_ref->[$partition_count]->{'name'});
|
|
splice(@{$partitions_ref}, $partition_count, 0, ({'name' => "",'variable'=>1,'header'=>0}));
|
|
}
|
|
|
|
my $partition = $partitions_ref->[$partition_count];
|
|
|
|
# Variable partitions can be overridden by the real FIS directory
|
|
if ($partition->{'variable'}) {
|
|
|
|
# Only override the filename if the partition name is not set or doesn't match
|
|
if ($partition->{'name'} ne $_->[0]) {
|
|
|
|
if (length($partition->{'name'})) {
|
|
$debug and printf("Overwriting <%s> with <%s>\n",
|
|
$partitions_ref->[$partition_count]->{'name'}, $_->[0]);
|
|
}
|
|
|
|
$partition->{'name'} = $_->[0];
|
|
$partition->{'file'} = $_->[0];
|
|
}
|
|
|
|
# Set the offset, size and skips based on the real partition table
|
|
$partition->{'offset'} = $_->[1];
|
|
$partition->{'size'} = $_->[2];
|
|
$partition->{'skips'} = $_->[3];
|
|
|
|
$debug and printf("Locating <%s> at 0x%08X (%s)\n",
|
|
$partition->{'name'}, $partition->{'offset'},
|
|
($partition->{'size'} >= $block_size ?
|
|
sprintf("%d blocks", numBlocks($partition->{'size'})) :
|
|
sprintf("0x%05X bytes", $partition->{'size'})));
|
|
|
|
$splice = 1;
|
|
}
|
|
|
|
# Fixed partitions cannot be overridden
|
|
else {
|
|
($partition->{'name'} eq $_->[0]) or
|
|
die "Unexpected partition <",$_->[0],"> (expecting <",$partition->{'name'},">)\n";
|
|
|
|
$debug and printf("Locating <%s> at 0x%08X (%s)\n",
|
|
$partition->{'name'}, $partition->{'offset'},
|
|
($partition->{'size'} >= $block_size ?
|
|
sprintf("%d blocks", numBlocks($partition->{'size'})) :
|
|
sprintf("0x%05X bytes", $partition->{'size'})));
|
|
|
|
$splice = 0;
|
|
}
|
|
|
|
$partition_count++;
|
|
|
|
} @new_partitions;
|
|
|
|
return;
|
|
}
|
|
|
|
# Read in an 8MB firmware file, and store the data into @partitions.
|
|
# Note that the data is only stored in a partition if 'offset' and 'size' are defined,
|
|
# and it does not already have data stored in it.
|
|
sub readInFirmware {
|
|
my($filename, $partitions_ref) = @_;
|
|
|
|
my($firmware_buf);
|
|
|
|
open FILE,$filename or die "Can't find firmware image \"$filename\": $!\n";
|
|
read FILE,$firmware_buf,$flash_len or die "Can't read $flash_len bytes from \"$filename\": $!\n";
|
|
close FILE or die "Can't close \"$filename\": $!\n";
|
|
|
|
$debug and printf("Read 0x%08X bytes from \"%s\"\n", length($firmware_buf), $filename);
|
|
|
|
spliceFirmwarePartitions($firmware_buf, $partitions_ref);
|
|
|
|
# Read the parts of the firmware file into the partitions table.
|
|
map {
|
|
if (defined $_->{'offset'} and defined $_->{'size'}) {
|
|
|
|
if (defined $_->{'data'}) {
|
|
$debug and printf("Not overwriting data in <%s>\n", $_->{'name'});
|
|
}
|
|
else {
|
|
|
|
# Slurp up the data, based on whether a header and/or data is present or not
|
|
if ($_->{'header'}) {
|
|
|
|
# Read the length, and grab the data based on the length.
|
|
my($data_len) = unpack("N", substr($firmware_buf, $_->{'offset'}));
|
|
|
|
# A length of 0xFFFFFFFF means that the area is not initialised
|
|
if ($data_len != 0xFFFFFFFF) {
|
|
$debug and printf("Found header size of 0x%08X bytes for <%s>\n", $data_len, $_->{'name'});
|
|
$_->{'data'} = substr($firmware_buf, $_->{'offset'} + $_->{'header'}, $data_len);
|
|
}
|
|
}
|
|
elsif ($_->{'pseudo'} and not defined $_->{'file'} and
|
|
(substr($firmware_buf, $_->{'offset'}, $_->{'size'}) eq
|
|
(pack("C", 0xff) x $_->{'size'}))) {
|
|
$debug and printf("Skipping empty pseudo partition <%s>\n", $_->{'name'});
|
|
}
|
|
else {
|
|
|
|
# Grab the whole partition, using the maximum size.
|
|
$_->{'data'} = substr($firmware_buf, $_->{'offset'}, $_->{'size'});
|
|
}
|
|
|
|
# If skip regions are defined, remove them from the data.
|
|
if (defined $_->{'skips'}) {
|
|
my $removed = 0;
|
|
foreach my $region (@{$_->{'skips'}}) {
|
|
if (($region->{'offset'} > 0) or
|
|
not ($_->{'header'} > 0)) {
|
|
$debug and printf("Removing 0x%05X bytes from offset 0x%05X\n",
|
|
$region->{'size'}, $region->{'offset'});
|
|
$region->{'data'} = substr($_->{'data'}, $region->{'offset'} - $removed, $region->{'size'}, '');
|
|
}
|
|
$removed += $region->{'size'};
|
|
}
|
|
}
|
|
|
|
$quiet or defined $_->{'data'} and printf("Read %s into <%s>\n",
|
|
(length($_->{'data'}) >= $block_size ?
|
|
sprintf("%d blocks", numBlocks(length($_->{'data'}))) :
|
|
sprintf("0x%05X bytes", length($_->{'data'}))), $_->{'name'});
|
|
}
|
|
}
|
|
} @$partitions_ref;
|
|
}
|
|
|
|
# Write the partition data stored in memory out into the files associated with each.
|
|
sub writeOutFirmwareParts {
|
|
my(@partitions) = @_;
|
|
|
|
# Write out the parts of the firmware file.
|
|
map {
|
|
|
|
# We can only write if 'data' and 'file' are defined.
|
|
if (defined $_->{'file'} and defined $_->{'data'} and length($_->{'data'})) {
|
|
writeOut($_->{'data'}, $_->{'file'});
|
|
$quiet or printf("Wrote 0x%08X bytes from <%s> into \"%s\"\n",
|
|
length($_->{'data'}), $_->{'name'}, $_->{'file'});
|
|
}
|
|
else {
|
|
$debug and printf("Skipping <%s> (%s)\n", $_->{'name'},
|
|
(not defined $_->{'file'}) ?
|
|
"no filename specified" :
|
|
"no data to write");
|
|
}
|
|
|
|
} @partitions;
|
|
|
|
return;
|
|
}
|
|
|
|
# Read in the partition data from the files associated with each and store in memory.
|
|
sub readInFirmwareParts {
|
|
my(@partitions) = (@_);
|
|
|
|
undef $/; # we want to slurp
|
|
|
|
map {
|
|
|
|
my $file = $_->{'file'};
|
|
if (defined $file) {
|
|
open FILE,$file or die "Can't find firmware part \"$file\": $!\n";
|
|
|
|
# Slurp in the data
|
|
$_->{'data'} = <FILE>;
|
|
|
|
# close the file
|
|
close FILE or die "Can't close file \"$file\": $!\n";
|
|
|
|
# Optionally byteswap the data
|
|
if ($_->{'byteswap'}) {
|
|
# Byte swap the data (which has to be padded to a multiple of 4 bytes).
|
|
$_->{'data'} = pack("N*", unpack("V*", $_->{'data'}.pack("CCC", 0)));
|
|
}
|
|
|
|
# Keep track of the actual size.
|
|
my $size;
|
|
|
|
if ($_->{'header'}) {
|
|
if ($_->{'pseudo'}) {
|
|
$size = $_->{'header'} + length($_->{'data'});
|
|
}
|
|
else {
|
|
$size = paddedSize($_->{'header'} + length($_->{'data'}));
|
|
}
|
|
}
|
|
elsif (not $_->{'pseudo'}) {
|
|
$size = paddedSize(length($_->{'data'}));
|
|
}
|
|
else {
|
|
$size = length($_->{'data'});
|
|
}
|
|
|
|
# Check to make sure the file contents are not too large.
|
|
if (defined $_->{'size'} and ($size > $_->{'size'})) {
|
|
die sprintf("Ran out of flash space in <%s> - %s too large.\n", $_->{'name'},
|
|
sprintf("0x%05X bytes", ($size - $_->{'size'})));
|
|
}
|
|
|
|
# If the partition does not have a fixed size, the calculate the size.
|
|
if (not defined $_->{'size'}) {
|
|
$_->{'size'} = $size;
|
|
}
|
|
|
|
# Keep the user appraised ...
|
|
$quiet or printf("Read 0x%08X bytes from \"%s\" into <%s> (%s / %s)%s\n",
|
|
length($_->{'data'}), $_->{'file'}, $_->{'name'},
|
|
($size >= $block_size ?
|
|
sprintf("%d blocks", numBlocks($size)) :
|
|
sprintf("0x%05X bytes", $size)),
|
|
($_->{'size'} >= $block_size ?
|
|
sprintf("%d blocks", numBlocks($_->{'size'})) :
|
|
sprintf("0x%05X bytes", $_->{'size'})),
|
|
($_->{'byteswap'} ? " (byte-swapped)" : ""));
|
|
}
|
|
|
|
} @partitions;
|
|
|
|
return;
|
|
}
|
|
|
|
# layoutPartitions : this function must be ugly - it needs to verify RedBoot, SysConf, Kernel, Ramdisk, and
|
|
# FIS directory partitions exist, are in the correct order, and do not have more data than can fit in
|
|
# their lengths (fixed for all but Ramdisk, which has a minimum length of one block).
|
|
# If Rootdisk and/or Userdisk exist, it must also verify that their block padded lengths are not
|
|
# too great for the available space.
|
|
# input : an array of hashes, some of which are populated with data
|
|
# output: same reference with start and size (partition not data) also populated. this populated structure
|
|
# can then be passed to buildPartitionTable() to generate the actual partition table data
|
|
sub layoutPartitions {
|
|
my(@partitions) = @_;
|
|
|
|
# Find the kernel partition, and save a pointer to it for later use
|
|
my $kernel;
|
|
map { ($_->{'name'} eq "Kernel") && ($kernel = $_); } @partitions;
|
|
$kernel or die "Couldn't find the kernel partition\n";
|
|
|
|
# Find the last variable size partition, and save a pointer to it for later use
|
|
my $lastdisk;
|
|
my $directory_offset;
|
|
my $curdisk = $partitions[0];
|
|
map {
|
|
if (not defined $lastdisk) {
|
|
if ($_->{'name'} eq "FIS directory") {
|
|
$lastdisk = $curdisk;
|
|
$directory_offset = $_->{'offset'};
|
|
}
|
|
else {
|
|
$curdisk = $_;
|
|
}
|
|
}
|
|
} @partitions;
|
|
|
|
$lastdisk or die "Couldn't find the last variable size partition\n";
|
|
|
|
$debug and printf("Last variable size partition is <%s>\n", $lastdisk->{'name'});
|
|
|
|
#
|
|
# here we go through the $partitions array ref and fill in all the values
|
|
#
|
|
|
|
# This points to where the next partition should be placed.
|
|
my $pointer = $flash_start;
|
|
|
|
map {
|
|
|
|
$debug and printf("Pointer is 0x%08X\n", $pointer);
|
|
|
|
# Determine the start and offset of the current partition.
|
|
if (defined $_->{'offset'}) {
|
|
$_->{'start'} = $flash_start + $_->{'offset'};
|
|
# Check for running past the defined start of the partition.
|
|
if (($pointer > $_->{'start'}) and not $_->{'pseudo'}) {
|
|
die sprintf("Ran out of flash space before <%s> - %s too large.\n", $_->{'name'},
|
|
sprintf("0x%05X bytes", ($pointer - $_->{'start'})));
|
|
}
|
|
}
|
|
|
|
# If offset is not defined, then calculate it.
|
|
else {
|
|
$_->{'start'} = $pointer;
|
|
$_->{'offset'} = $_->{'start'} - $flash_start;
|
|
}
|
|
|
|
my $size = defined $_->{'data'} ? length($_->{'data'}) : 0;
|
|
|
|
# Add skip regions for the partitions with headers.
|
|
if ($_->{'header'} > 0) {
|
|
# Define the skip region for the initial Sercomm header.
|
|
push(@{$_->{'skips'}},
|
|
{ 'offset' => 0, 'size' => $_->{'header'}, 'data' => undef });
|
|
# Allow for the Sercomm header to be prepended to the data.
|
|
$size += $_->{'header'};
|
|
|
|
# Determine if the partition overlaps the ramdisk boundary.
|
|
if (($_->{'offset'} < $ramdisk_offset) and
|
|
(($_->{'offset'} + $size) > $ramdisk_offset)) {
|
|
# Define the skip region for the inline Sercomm header.
|
|
push(@{$_->{'skips'}},
|
|
{ 'offset' => ($ramdisk_offset - $_->{'offset'}), 'size' => 16,
|
|
'data' => pack("N4", $block_size) });
|
|
# Allow for the Sercomm header to be inserted in the data.
|
|
$size += 16;
|
|
}
|
|
}
|
|
|
|
# Partitions without headers cannot have skip regions.
|
|
elsif (($_->{'offset'} <= $ramdisk_offset) and
|
|
(($_->{'offset'} + $size) > $ramdisk_offset)) {
|
|
# Pad the kernel until it extends past the ramdisk offset.
|
|
push(@{$kernel->{'skips'}},
|
|
{ 'offset' => ($ramdisk_offset - $kernel->{'offset'}), 'size' => 16,
|
|
'data' => pack("N4", $block_size) });
|
|
$kernel->{'size'} = $ramdisk_offset - $kernel->{'offset'} + $block_size;
|
|
$kernel->{'data'} = padBytes($kernel->{'data'},
|
|
$kernel->{'size'} - $kernel->{'header'} - 16);
|
|
$_->{'offset'} = $ramdisk_offset + $block_size;
|
|
$_->{'start'} = $flash_start + $_->{'offset'};
|
|
$pointer = $_->{'start'};
|
|
$debug and printf("Extending kernel partition past ramdisk offset.\n");
|
|
}
|
|
|
|
# If this is the last variable size partition, then fill the rest of the space.
|
|
if ($_->{'name'} eq $lastdisk->{'name'}) {
|
|
$_->{'size'} = paddedSize($directory_offset + $flash_start - $pointer);
|
|
$debug and printf("Padding last variable partition <%s> to 0x%08X bytes\n", $_->{'name'}, $_->{'size'});
|
|
}
|
|
|
|
die sprintf("Partition size not defined in <%s>.\n", $_->{'name'})
|
|
unless defined $_->{'size'};
|
|
|
|
# Extend to another block if required.
|
|
if ($size > $_->{'size'}) {
|
|
if ($_->{'name'} eq $lastdisk->{'name'}) {
|
|
die sprintf("Ran out of flash space in <%s> - %s too large.\n", $_->{'name'},
|
|
sprintf("0x%05X bytes", ($size - $_->{'size'})));
|
|
}
|
|
$_->{'size'} = $size;
|
|
printf("Extending partition <%s> to 0x%08X bytes\n", $_->{'name'}, $_->{'size'});
|
|
}
|
|
|
|
# Keep the user appraised ...
|
|
$debug and printf("Allocated <%s> from 0x%08X to 0x%08X (%s / %s)\n",
|
|
$_->{'name'}, $_->{'start'}, $_->{'start'} + $_->{'size'},
|
|
($size >= $block_size ?
|
|
sprintf("%d blocks", numBlocks($size)) :
|
|
sprintf("0x%05X bytes", $size)),
|
|
($_->{'size'} >= $block_size ?
|
|
sprintf("%d blocks", numBlocks($_->{'size'})) :
|
|
sprintf("0x%05X bytes", $_->{'size'})));
|
|
|
|
# Check to make sure we have not run out of room.
|
|
if (($_->{'start'} + $_->{'size'}) > ($flash_start + $flash_len)) {
|
|
die "Ran out of flash space in <", $_->{'name'}, ">\n";
|
|
}
|
|
|
|
$debug and printf("Moving pointer from 0x%08X to 0x%08X (0x%08X + 0x%08X)\n",
|
|
$pointer, paddedSize($_->{'start'} + $_->{'size'}),
|
|
$_->{'start'}, $_->{'size'});
|
|
|
|
# Move the pointer up, in preparation for the next partition.
|
|
$pointer = paddedSize($_->{'start'} + $_->{'size'});
|
|
|
|
} @partitions;
|
|
|
|
return;
|
|
}
|
|
|
|
sub buildPartitionTable {
|
|
my(@partitions) = @_;
|
|
|
|
my($flash_start) = 0x50000000;
|
|
my($partition_data) = '';
|
|
|
|
map {
|
|
|
|
# Collate the partition data for all known partitions.
|
|
if (not $_->{'pseudo'} and defined $_->{'offset'} and defined $_->{'size'}) {
|
|
|
|
# Pack and append the binary table entry for this partition.
|
|
$partition_data .= createPartitionEntry($_->{'name'}, $_->{'offset'} + $flash_start,
|
|
$_->{'size'}, $_->{'skips'});
|
|
|
|
# If this is the FIS directory, then write the partition table data into it.
|
|
if ($_->{'name'} eq "FIS directory") {
|
|
# Explicitly terminate the partition data.
|
|
$partition_data .= pack("C",0xff) x 0x100;
|
|
$_->{'data'} = padBytes($partition_data, $_->{'size'});
|
|
}
|
|
|
|
my $size = length($_->{'data'});
|
|
|
|
# Keep the user appraised ...
|
|
$debug and printf("Table entry <%s> from 0x%08X to 0x%08X (%s / %s)%s\n",
|
|
$_->{'name'}, $_->{'start'}, $_->{'start'} + $_->{'size'},
|
|
($size >= $block_size ?
|
|
sprintf("%d blocks", numBlocks($size)) :
|
|
sprintf("0x%05X bytes", $size)),
|
|
($_->{'size'} >= $block_size ?
|
|
sprintf("%d blocks", numBlocks($_->{'size'})) :
|
|
sprintf("0x%05X bytes", $_->{'size'})),
|
|
(defined $_->{'skips'} ?
|
|
sprintf("\nTable entry <%s> skip %s", $_->{'name'},
|
|
join(", ",
|
|
map { sprintf("0x%08X to 0x%08X", $_->{'offset'},
|
|
$_->{'offset'} + $_->{'size'} - 1) }
|
|
@{$_->{'skips'}})) :
|
|
"")
|
|
);
|
|
}
|
|
else {
|
|
$debug and print "No table entry required for <", $_->{'name'}, ">\n";
|
|
}
|
|
|
|
} @partitions;
|
|
|
|
return;
|
|
}
|
|
|
|
sub writeOutFirmware {
|
|
my($filename, @partitions) = @_;
|
|
|
|
# Clear the image to start.
|
|
my $image_buf = "";
|
|
|
|
map {
|
|
|
|
# We can only write a partition if it has an offset, a size, and some data to write.
|
|
if (defined $_->{'offset'} and defined $_->{'size'} and defined $_->{'data'}) {
|
|
|
|
# Keep track of the end of the image.
|
|
my $end_point = length($image_buf);
|
|
|
|
# If the next partition is well past the end of the current image, then pad it.
|
|
if ($_->{'offset'} > $end_point) {
|
|
$image_buf .= padBytes("", $_->{'offset'} - $end_point);
|
|
$quiet or printf("Padded %s before <%s> in \"%s\"\n",
|
|
((length($image_buf) - $end_point) >= $block_size ?
|
|
sprintf("%d blocks", numBlocks(length($image_buf) - $end_point)) :
|
|
sprintf("0x%05X bytes", length($image_buf) - $end_point)),
|
|
$_->{'name'}, $filename);
|
|
}
|
|
|
|
# If the next parition is before the end of the current image, then rewind.
|
|
elsif ($_->{'offset'} < $end_point) {
|
|
$debug and printf("Rewound %s before <%s> in \"%s\"\n",
|
|
(($end_point - $_->{'offset'}) >= $block_size ?
|
|
sprintf("%d blocks", numBlocks($end_point - $_->{'offset'})) :
|
|
sprintf("0x%05X bytes", $end_point - $_->{'offset'})),
|
|
$_->{'name'}, $filename);
|
|
# if (($end_point - $_->{'offset'}) >= $block_size) {
|
|
# die "Allocation error: rewound a full block or more ...\n";
|
|
# }
|
|
}
|
|
|
|
# If skip regions are defined, add them to the data.
|
|
if (defined $_->{'skips'}) {
|
|
my $added = 0;
|
|
foreach my $region (@{$_->{'skips'}}) {
|
|
if (($region->{'offset'} > 0) or
|
|
not ($_->{'header'} > 0)) {
|
|
$debug and printf("Inserted 0x%05X bytes (at offset 0x%05X) into <%s>\n",
|
|
$region->{'size'}, $region->{'offset'}, $_->{'name'});
|
|
substr($_->{'data'},
|
|
$region->{'offset'} + $added - $_->{'header'},
|
|
0, $region->{'data'});
|
|
$added += $region->{'size'};
|
|
}
|
|
}
|
|
}
|
|
|
|
# Splice the data into the image at the appropriate place, padding as required.
|
|
substr($image_buf, $_->{'offset'}, $_->{'size'},
|
|
$_->{'header'} ?
|
|
padBytes(pack("N4",length($_->{'data'})).$_->{'data'}, $_->{'size'}) :
|
|
padBytes($_->{'data'}, $_->{'size'}));
|
|
|
|
# Keep the user appraised ...
|
|
$quiet or printf("Wrote %s (0x%08X to 0x%08X) from <%s> into \"%s\"\n",
|
|
($_->{'size'} >= $block_size ?
|
|
sprintf("%2d blocks", numBlocks($_->{'size'})) :
|
|
sprintf("0x%05X bytes", $_->{'size'})),
|
|
$_->{'offset'}, $_->{'offset'}+$_->{'size'}, $_->{'name'}, $filename);
|
|
}
|
|
|
|
# If we are not able to write a partition, then give debug information about why.
|
|
else {
|
|
$debug and printf("Skipping <%s> (%s)\n", $_->{'name'},
|
|
(not defined $_->{'offset'}) ? "no offset defined" :
|
|
((not defined $_->{'size'}) ? "no size defined" :
|
|
"no data available"));
|
|
}
|
|
|
|
} @partitions;
|
|
|
|
# Write the image to the specified file.
|
|
writeOut($image_buf, $filename);
|
|
|
|
return;
|
|
}
|
|
|
|
# checkPartitionTable: sanity check partition table - for testing but might evolve into setting @partitions
|
|
# so that we can write out jffs2 partitions from a read image
|
|
# currently not nearly paranoid enough
|
|
sub checkPartitionTable {
|
|
my($data) = @_;
|
|
|
|
my($pointer) = 0;
|
|
my($entry);
|
|
|
|
my($name, $flash_base, $size, $done, $dummy_long, $padding);
|
|
do {
|
|
$entry = substr($data, $pointer, 0x100);
|
|
|
|
($name,$flash_base,$dummy_long,$size,$dummy_long,$dummy_long,$padding,$dummy_long,$dummy_long) = unpack("a16N5x212N2",$entry);
|
|
$name =~ s/\0//g;
|
|
$debug and printf("pointer: %d\tname: %s%sflash_base: 0x%08X\tsize: 0x%08X\n",
|
|
$pointer, $name, (" " x (16 - length($name))), $flash_base, $size);
|
|
$pointer += 0x100;
|
|
$debug and printf("terminator: 0x%08X\n", unpack("C", substr($data, $pointer, 1)));
|
|
if (unpack("C", substr($data, $pointer, 1)) eq 0xff) {
|
|
$done = 1;
|
|
}
|
|
} until $done;
|
|
}
|
|
|
|
sub printPartitions {
|
|
my(@partitions) = @_;
|
|
|
|
my($offset, $size, $skips);
|
|
map {
|
|
# defined $_->{'size'} ? $size = $_->{'size'} : $size = undef;
|
|
|
|
if (defined $_->{'size'}) {
|
|
$size = $_->{'size'};
|
|
}
|
|
else {
|
|
$size = undef;
|
|
}
|
|
if (defined $_->{'offset'}) {
|
|
$offset = $_->{'offset'};
|
|
}
|
|
else {
|
|
$offset = undef;
|
|
}
|
|
if (defined $_->{'skips'}) {
|
|
$skips = $_->{'skips'};
|
|
}
|
|
else {
|
|
$skips = undef;
|
|
}
|
|
printf("%s%s", $_->{'name'}, (" " x (16 - length($_->{'name'}))));
|
|
if (defined $offset) { printf("0x%08X\t", $offset); } else { printf("(undefined)\t"); };
|
|
if (defined $size) { printf("0x%08X", $size); } else { printf("(undefined)"); };
|
|
if (defined $skips) {
|
|
printf("\t[%s]",
|
|
join(", ",
|
|
map { sprintf("0x%05X/0x%05X", $_->{'offset'}, $_->{'size'}); }
|
|
@$skips));
|
|
}
|
|
printf("\n");
|
|
} @partitions;
|
|
}
|
|
|
|
sub defaultPartitions {
|
|
|
|
return ({'name'=>'RedBoot', 'file'=>'RedBoot',
|
|
'offset'=>0x00000000, 'size'=>0x00040000,
|
|
'variable'=>0, 'header'=>0, 'pseudo'=>0, 'data'=>undef, 'byteswap'=>0},
|
|
{'name'=>'EthAddr', 'file'=>undef,
|
|
'offset'=>0x0003ffb0, 'size'=>0x00000006,
|
|
'variable'=>0, 'header'=>0, 'pseudo'=>1, 'data'=>undef, 'byteswap'=>0},
|
|
{'name'=>'SysConf', 'file'=>'SysConf',
|
|
'offset'=>0x00040000, 'size'=>0x00020000,
|
|
'variable'=>0, 'header'=>0, 'pseudo'=>0, 'data'=>undef, 'byteswap'=>0},
|
|
{'name'=>'Loader', 'file'=>'apex.bin',
|
|
'offset'=>undef, 'size'=>undef,
|
|
'variable'=>1, 'header'=>16, 'pseudo'=>0, 'data'=>undef, 'byteswap'=>0},
|
|
{'name'=>'Kernel', 'file'=>'vmlinuz',
|
|
'offset'=>undef, 'size'=>undef,
|
|
'variable'=>1, 'header'=>16, 'pseudo'=>0, 'data'=>undef, 'byteswap'=>0},
|
|
{'name'=>'Ramdisk', 'file'=>'ramdisk.gz',
|
|
'offset'=>undef, 'size'=>undef,
|
|
'variable'=>1, 'header'=>16, 'pseudo'=>0, 'data'=>undef, 'byteswap'=>0},
|
|
{'name'=>'FIS directory', 'file'=>undef,
|
|
'offset'=>0x007e0000, 'size'=>0x00020000,
|
|
'variable'=>0, 'header'=>0, 'pseudo'=>0, 'data'=>undef, 'byteswap'=>0},
|
|
{'name'=>'Loader config', 'file'=>undef,
|
|
'offset'=>0x007f8000, 'size'=>0x00004000,
|
|
'variable'=>0, 'header'=>0, 'pseudo'=>1, 'data'=>undef, 'byteswap'=>0},
|
|
{'name'=>'Microcode', 'file'=>'NPE-B',
|
|
'offset'=>0x007fc000, 'size'=>0x00003fe0,
|
|
'variable'=>0, 'header'=>16, 'pseudo'=>1, 'data'=>undef, 'byteswap'=>0},
|
|
{'name'=>'Trailer', 'file'=>'Trailer',
|
|
'offset'=>0x007ffff0, 'size'=>0x00000010,
|
|
'variable'=>0, 'header'=>0, 'pseudo'=>1, 'data'=>undef, 'byteswap'=>0});
|
|
}
|
|
|
|
# Main routine starts here ...
|
|
|
|
my($unpack, $pack, $little, $fatflash, $input, $output, $redboot);
|
|
my($kernel, $sysconf, $ramdisk, $fisdir);
|
|
my($microcode, $trailer, $ethaddr, $loader);
|
|
|
|
END {
|
|
# Remove temporary files
|
|
for my $file (@cleanup) {
|
|
unlink $file;
|
|
}
|
|
}
|
|
|
|
if (!GetOptions("d|debug" => \$debug,
|
|
"q|quiet" => \$quiet,
|
|
"u|unpack" => \$unpack,
|
|
"p|pack" => \$pack,
|
|
"l|little" => \$little,
|
|
"F|fatflash" => \$fatflash,
|
|
"i|input=s" => \$input,
|
|
"o|output=s" => \$output,
|
|
"b|redboot=s" => \$redboot,
|
|
"k|kernel=s" => \$kernel,
|
|
"s|sysconf=s" => \$sysconf,
|
|
"r|ramdisk=s" => \$ramdisk,
|
|
"f|fisdir=s" => \$fisdir,
|
|
"m|microcode=s" => \$microcode,
|
|
"t|trailer=s" => \$trailer,
|
|
"e|ethaddr=s" => \$ethaddr,
|
|
"L|loader=s" => \$loader,
|
|
) or (not defined $pack and not defined $unpack)) {
|
|
print "Usage: slugimage <options>\n";
|
|
print "\n";
|
|
print " [-d|--debug] Turn on debugging output\n";
|
|
print " [-q|--quiet] Turn off status messages\n";
|
|
print " [-u|--unpack] Unpack a firmware image\n";
|
|
print " [-p|--pack] Pack a firmware image\n";
|
|
print " [-l|--little] Convert Kernel and Ramdisk to little-endian\n";
|
|
print " [-F|--fatflash] Generate an image for 16MB flash\n";
|
|
print " [-i|--input] <file> Input firmware image filename\n";
|
|
print " [-o|--output] <file> Output firmware image filename\n";
|
|
print " [-b|--redboot] <file> Input/Output RedBoot filename\n";
|
|
print " [-s|--sysconf] <file> Input/Output SysConf filename\n";
|
|
print " [-L|--loader] <file> Second stage boot loader filename\n";
|
|
print " [-k|--kernel] <file> Input/Ouptut Kernel filename\n";
|
|
print " [-r|--ramdisk] <file> Input/Output Ramdisk filename(s)\n";
|
|
print " [-f|--fisdir] <file> Input/Output FIS directory filename\n";
|
|
print " [-m|--microcode] <file> Input/Output Microcode filename\n";
|
|
print " [-t|--trailer] <file> Input/Output Trailer filename\n";
|
|
print " [-e|--ethaddr] <AABBCCDDEEFF> Set the Ethernet address\n";
|
|
|
|
# %%% TODO %%% Document --ramdisk syntax
|
|
|
|
exit 1;
|
|
}
|
|
|
|
my(@partitions) = defaultPartitions();
|
|
|
|
if ($pack) {
|
|
die "Output filename must be specified\n" unless defined $output;
|
|
|
|
# If we're creating an image and no RedBoot, SysConf partition is
|
|
# explicitly specified, simply write an empty one as the upgrade tools
|
|
# don't touch RedBoot and SysConf anyway. If no Trailer is specified,
|
|
# put in one.
|
|
if (not defined $redboot and not -e "RedBoot") {
|
|
$redboot = tempfile();
|
|
open TMP, ">$redboot" or die "Cannot open file $redboot: $!";
|
|
push @cleanup, $redboot;
|
|
# The RedBoot partition is 256 * 1024 = 262144; the trailer we add
|
|
# is 70 bytes.
|
|
print TMP "\0"x(262144-70);
|
|
# Upgrade tools check for an appropriate Sercomm trailer.
|
|
for my $i (@sercomm_redboot_trailer) {
|
|
print TMP pack "S", $i;
|
|
}
|
|
close TMP;
|
|
}
|
|
if (not defined $sysconf and not -e "SysConf") {
|
|
$sysconf = tempfile();
|
|
open TMP, ">$sysconf" or die "Cannot open file $sysconf: $!";
|
|
push @cleanup, $sysconf;
|
|
# The SysConf partition is 128 * 1024 = 131072
|
|
print TMP "\0"x131072;
|
|
close TMP;
|
|
}
|
|
if (not defined $trailer and not -e "Trailer") {
|
|
$trailer = tempfile();
|
|
open TMP, ">$trailer" or die "Cannot open file $trailer: $!";
|
|
push @cleanup, $trailer;
|
|
for my $i (@sercomm_flash_trailer) {
|
|
print TMP pack "S", $i;
|
|
}
|
|
close TMP;
|
|
}
|
|
|
|
# If the microcode was not specified, then don't complain that it's missing.
|
|
if (not defined $microcode and not -e "NPE-B") {
|
|
map { ($_->{'name'} eq 'Microcode') && ($_->{'file'} = undef); } @partitions;
|
|
}
|
|
}
|
|
|
|
# Go through the partition options, and set the names and files in @partitions
|
|
if (defined $redboot) { map { ($_->{'name'} eq 'RedBoot') && ($_->{'file'} = $redboot); } @partitions; }
|
|
if (defined $sysconf) { map { ($_->{'name'} eq 'SysConf') && ($_->{'file'} = $sysconf); } @partitions; }
|
|
if (defined $loader) { map { ($_->{'name'} eq 'Loader') && ($_->{'file'} = $loader); } @partitions; }
|
|
if (defined $kernel) { map { ($_->{'name'} eq 'Kernel') && ($_->{'file'} = $kernel); } @partitions; }
|
|
if (defined $fisdir) { map { ($_->{'name'} eq 'FIS directory') && ($_->{'file'} = $fisdir); } @partitions; }
|
|
if (defined $microcode) { map { ($_->{'name'} eq 'Microcode') && ($_->{'file'} = $microcode); } @partitions; }
|
|
if (defined $trailer) { map { ($_->{'name'} eq 'Trailer') && ($_->{'file'} = $trailer); } @partitions; }
|
|
|
|
if (defined $little) {
|
|
map {
|
|
if (($_->{'name'} eq 'Loader') or
|
|
($_->{'name'} eq 'Kernel') or
|
|
($_->{'name'} eq 'Ramdisk')) {
|
|
$_->{'byteswap'} = 1;
|
|
}
|
|
} @partitions;
|
|
}
|
|
|
|
if (defined $fatflash) {
|
|
$flash_len = 0x01000000;
|
|
map {
|
|
if (($_->{'name'} eq 'FIS directory') or
|
|
($_->{'name'} eq 'Loader config') or
|
|
($_->{'name'} eq 'Microcode') or
|
|
($_->{'name'} eq 'Trailer')) {
|
|
$_->{'offset'} += 0x00800000;
|
|
}
|
|
} @partitions;
|
|
}
|
|
|
|
if (defined $ethaddr) {
|
|
map {
|
|
if ($_->{'name'} eq 'EthAddr') {
|
|
$ethaddr =~ s/://g;
|
|
if (($ethaddr !~ m/^[0-9A-Fa-f]+$/) or (length($ethaddr) != 12)) {
|
|
die "Invalid ethernet address specification: '".$ethaddr."'\n";
|
|
}
|
|
$_->{'data'} = pack("H12", $ethaddr);
|
|
}
|
|
} @partitions;
|
|
}
|
|
|
|
if (defined $ramdisk) {
|
|
|
|
# A single filename is used for the ramdisk filename
|
|
if ($ramdisk !~ m/[:,]/) {
|
|
map { ($_->{'name'} eq 'Ramdisk') && ($_->{'file'} = $ramdisk); } @partitions;
|
|
}
|
|
|
|
# otherwise, it's a list of name:file mappings
|
|
else {
|
|
my @mappings = split(',', $ramdisk);
|
|
|
|
# Find the index of the Ramdisk entry
|
|
my $index;
|
|
my $count = 0;
|
|
map {
|
|
if (not defined $index) {
|
|
if ($_->{'name'} eq "Ramdisk") {
|
|
$index = $count;
|
|
}
|
|
$count++;
|
|
}
|
|
} @partitions;
|
|
|
|
defined $index or die "Cannot find the Ramdisk partition\n";
|
|
|
|
# Replace the Ramdisk entry with the new mappings
|
|
splice(@partitions, $index, 1, map {
|
|
|
|
# Preserve the information from the ramdisk entry
|
|
my %entry = %{$partitions[$index]};
|
|
|
|
# Parse the mapping
|
|
($_ =~ m/^([^:]+):([^:]+)(:([^:]+))?$/) or die "Invalid syntax in --ramdisk\n";
|
|
$entry{'name'} = $1; $entry{'file'} = $2; my $size = $4;
|
|
|
|
# If the mapping is not for the ramdisk, then undefine its attributes
|
|
if ($entry{'name'} ne 'Ramdisk') {
|
|
$entry{'offset'} = undef;
|
|
$entry{'size'} = undef;
|
|
$entry{'variable'} = 1;
|
|
$entry{'header'} = 0;
|
|
$entry{'pseudo'} = 0;
|
|
$entry{'data'} = undef;
|
|
$entry{'byteswap'} = 0;
|
|
}
|
|
|
|
# Support specification of the number of blocks for empty jffs2
|
|
if ($entry{'file'} =~ m/^[0-9]+$/) {
|
|
$size = $entry{'file'};
|
|
$entry{'file'} = undef;
|
|
}
|
|
|
|
# If the user has specified a size, then respect their wishes
|
|
if (defined $size) {
|
|
$entry{'size'} = $size * $block_size;
|
|
# Create an empty partition of the requested size.
|
|
$entry{'data'} = padBytes("", $entry{'size'} - $entry{'header'});
|
|
}
|
|
|
|
\%entry;
|
|
|
|
} @mappings);
|
|
}
|
|
}
|
|
|
|
# Read in the firmware image
|
|
if ($input) {
|
|
if ($debug) {
|
|
print "Initial partition map:\n";
|
|
printPartitions(@partitions);
|
|
}
|
|
|
|
my $result = readInFirmware($input, \@partitions);
|
|
|
|
if ($debug) {
|
|
print "After reading firmware:\n";
|
|
printPartitions(@partitions);
|
|
}
|
|
}
|
|
|
|
# Unpack the firmware if requested
|
|
if ($unpack) {
|
|
die "Input filename must be specified\n" unless defined $input;
|
|
|
|
# map {
|
|
# ($_->{'name'} eq 'FIS directory') and @partitions = checkPartitionTable($_->{'data'});
|
|
# } @partitions;
|
|
|
|
writeOutFirmwareParts(@partitions);
|
|
|
|
}
|
|
|
|
# Pack the firmware if requested
|
|
if ($pack) {
|
|
|
|
if (!defined $loader) {
|
|
removeOptionalLoader(\@partitions);
|
|
}
|
|
|
|
if ($debug) {
|
|
print "Initial partition map:\n";
|
|
printPartitions(@partitions);
|
|
}
|
|
|
|
my $result = readInFirmwareParts(@partitions);
|
|
|
|
if ($debug) {
|
|
print "after readInFirmwareParts():\n";
|
|
printPartitions(@partitions);
|
|
# map {
|
|
# ($_->{'name'} eq 'RedBoot') && (printRedbootTrailer($_->{'data'}));
|
|
# } @partitions;
|
|
}
|
|
|
|
layoutPartitions(@partitions);
|
|
|
|
if ($debug) {
|
|
print "after layoutPartitions():\n";
|
|
printPartitions(@partitions);
|
|
}
|
|
|
|
buildPartitionTable(@partitions);
|
|
|
|
if ($debug) {
|
|
print "after buildPartitionTable():\n";
|
|
printPartitions(@partitions);
|
|
|
|
# my($lastblock);
|
|
# map {
|
|
# if ($_->{'name'} eq 'FIS directory') {
|
|
# $lastblock = $_->{'data'};
|
|
# }
|
|
# } @partitions;
|
|
|
|
# print "checkPartitionTable():\n";
|
|
# checkPartitionTable($lastblock);
|
|
}
|
|
|
|
writeOutFirmware($output, @partitions);
|
|
|
|
}
|
|
|
|
exit 0;
|