scripts/slugimage.pl

   1 #!/usr/bin/perl
   2 #
   3 # SlugImage : Manipulate NSLU2 firmware images
   4 #             Dwayne Fontenot (jacques)
   5 #             Rod Whitby (rwhitby)
   6 #             www.nslu2-linux.org
   7 #
   8 # Copyright (c) 2004, 2006, Dwayne Fontenot & Rod Whitby
   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 #
  15 # Redistributions of source code must retain the above copyright
  16 # notice, this list of conditions and the following disclaimer.
  17 # Redistributions in binary form must reproduce the above copyright
  18 # notice, this list of conditions and the following disclaimer in the
  19 # documentation and/or other materials provided with the distribution.
  20 # Neither the name of the NSLU2-Linux Development Team nor the names
  21 # of its contributors may be used to endorse or promote products
  22 # derived from this software without specific prior written
  23 # permission.
  24 #
  25 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  26 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  27 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  28 # FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  29 # COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  30 # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  31 # BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  32 # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  33 # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  34 # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  35 # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  36 # POSSIBILITY OF SUCH DAMAGE.
  37 #
  38
  39 use strict;
  40 use warnings;
  41
  42 use Getopt::Long qw(:config no_ignore_case);
  43 use POSIX qw(tmpnam);
  44
  45 my($debug) = 0;
  46 my($quiet) = 0;
  47 my($flash_start)    = 0x50000000;
  48 my($flash_len)      = 0x00800000;
  49 my($block_size)     = 0x00020000;
  50 my($kernel_offset)  = 0x00060000;
  51 my($kernel_size)    = 0x00100000;
  52 my($ramdisk_offset) = 0x00160000;
  53 my(@cleanup);
  54
  55 # The last 70 bytes of the SercommRedBootTrailer (i.e. excluding MAC
  56 # address).  Needed to create an image with an empty RedBoot partition
  57 # since the Sercomm upgrade tool checks for this trailer.
  58 # http://www.nslu2-linux.org/wiki/Info/SercommRedBootTrailer
  59 my @sercomm_redboot_trailer = (0x4573, 0x4372, 0x4d6f, 0x006d, 0x0001,
  60        0x0400, 0x3170, 0x5895, 0x0010, 0x0000, 0x0000, 0x0000, 0x0000,
  61        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
  62        0x0000, 0x0000, 0x0001, 0x0000, 0x0000, 0x0000, 0x0003, 0x2300,
  63        0x0063, 0x0000, 0x7320, 0x7245, 0x6f43, 0x6d4d);
  64
  65 # There's a 16 byte Sercomm trailer at the end of the flash. It is used
  66 # by RedBoot to detect a Sercomm flash layout and to configure the
  67 # Sercomm upgrade system.
  68 # http://www.nslu2-linux.org/wiki/Info/SercommFlashTrailer
  69 my @sercomm_flash_trailer = (0x0100, 0x0000, 0x6323, 0xf790, 0x5265,
  70                              0x4f63, 0x4d6d, 0xb400);
  71
  72 # Take $data, and pad it out to $total_len bytes, appending 0xff's.
  73 sub padBytes {
  74     my($data,$total_len) = @_;
  75
  76     # 0xFF is used to pad, as it's the erase value of the flash.
  77     my($pad_char) = pack("C",0xff);
  78     my($pad_len) = $total_len - length($data);
  79
  80     # A request for negative padding is indicative of a logic error ...
  81     if (length($data) > $total_len) {
  82         die sprintf("padBytes error: data (%d) is longer than total_len (%d)", length($data), $total_len);
  83     }
  84
  85     return $data . ($pad_char x $pad_len);
  86 }
  87
  88 # Return the next multiple of block_size larger than or equal to $data_len.
  89 sub paddedSize {
  90     my($data_len) = @_;
  91
  92     use integer;
  93     return (($data_len - 1) / $block_size) * $block_size + $block_size;
  94 }
  95
  96 # Return the number of block_size blocks required to hold $data_len.
  97 sub numBlocks {
  98     my($data_len) = @_;
  99
 100     use integer;
 101     return (($data_len - 1) / $block_size) + 1;
 102 }
 103
 104 # Pack the name, address, size and optional skip regions of a partition entry into binary form.
 105 sub createPartitionEntry {
 106     my($name, $flash_base, $size, $skips) = @_;
 107     my $entry;
 108
 109     my($zero_long) = 0x0000;
 110
 111     # Pack the partition entry according to the format that RedBoot (and the MTD partition parsing code) requires.
 112     $entry = pack("a16N5x212N2",$name,$flash_base,$zero_long,$size,$zero_long,$zero_long,$zero_long,$zero_long);
 113
 114     # Optionally put a skip header into the padding area.
 115     if (defined $skips) {
 116         my $i = scalar(@$skips);
 117         foreach my $region (@$skips) {
 118             substr($entry, -8 - 12*$i, 12) =
 119                 pack("a4N2", "skip", $region->{'offset'}, $region->{'size'});
 120             $i--;
 121         }
 122     }
 123
 124     return $entry;
 125 }
 126
 127 # Parse partition entry and return anon array ref [$name, $offset, $size, $skip] or return 0 on partition terminator.
 128 sub parsePartitionEntry {
 129     my($partition_entry) = @_;
 130
 131     my($entry_len) = 0x100;
 132     length($partition_entry) eq $entry_len or die "parsePartitionEntry: partition entry length is not $entry_len!\n";
 133
 134     # Unpack the partition table entry, saving those values in which we are interested.
 135     my($name, $flash_base, $size, $dummy_long, $padding, $skips);
 136     ($name, $flash_base, $dummy_long, $size, $dummy_long, $dummy_long, $padding, $dummy_long, $dummy_long) =
 137         unpack("a16N5a212N2",$partition_entry);
 138
 139     # A partition entry starting with 0xFF terminates the table.
 140     if (unpack("C", $name) eq 0xff) {
 141         # %%% FIXME: This should only skip, not terminate. %%%
 142         $debug and print "Found terminator for <FIS directory>\n";
 143         return 0;
 144     }
 145
 146     # Remove trailing nulls from the partition name.
 147     $name =~ s/\000+//;
 148
 149     # Extract the skip regions out of the padding area.
 150     $padding =~ s/^\000+//;
 151     $padding =~ s/\000*skip(........)\000*/$1/g;
 152     $padding =~ s/\000+$//;
 153
 154     # Store the skip regions in an array for later use.
 155     while (length($padding)) {
 156         my $region = {};
 157         ($region->{'offset'}, $region->{'size'}) =
 158             unpack("N2", $padding);
 159         $debug and printf("Found skip region at 0x%05X, size 0x%05X\n",
 160                           $region->{'offset'}, $region->{'size'});
 161         push(@$skips, $region);
 162         $padding = substr($padding,8);
 163     }
 164
 165     return [$name, $flash_base - $flash_start, $size, $skips];
 166 }
 167
 168 # Return partition table from data is one exists, otherwise return 0.
 169 sub findPartitionTable {
 170     my($data_buf) = @_;
 171
 172     unpack("a7", $data_buf) eq 'RedBoot' or return 0;
 173     return substr($data_buf, 0, 0x1000)
 174 }
 175
 176 # Parse partition table and return array of anonymous array references ([$name, $offset, $size, $skips], ...).
 177 sub parsePartitionTable {
 178     my($partition_table) = @_;
 179
 180     my(@partitions, $fields_ref);
 181     my($entry_len) = 0x100;
 182     my($partition_count) = 0;
 183
 184     # Loop through the fixed size partition table entries, and store the entries in @partitions.
 185     # %%% FIXME: This doesn't handle the case of a completely full partition table. %%%
 186     while ($fields_ref = parsePartitionEntry(substr($partition_table, $partition_count * $entry_len, $entry_len))) {
 187         $debug and printf("Found <%s> at 0x%08X (%s)%s\n", $fields_ref->[0], $fields_ref->[1],
 188                           ($fields_ref->[2] >= $block_size ?
 189                            sprintf("%d blocks", numBlocks($fields_ref->[2])) :
 190                            sprintf("0x%05X bytes", $fields_ref->[2])),
 191                           (defined $fields_ref->[3] ?
 192                            sprintf(" [%s]",
 193                                    join(", ",
 194                                         map { sprintf("0x%05X/0x%05X", $_->{'offset'},$_->{'size'}) }
 195                                         @{$fields_ref->[3]})) :
 196                            ""));
 197         $partitions[$partition_count++] = $fields_ref;
 198     }
 199     return(@partitions);
 200 }
 201
 202 # Create an empty jffs2 block.
 203 sub jffs2Block {
 204     return padBytes(pack("N3", 0x19852003, 0x0000000c, 0xf060dc98), $block_size);
 205 }
 206
 207 # Write out $data to $filename,
 208 sub writeOut {
 209     my($data, $filename) = @_;
 210
 211     open FILE,">$filename" or die "Can't open file \"$filename\": $!\n";
 212
 213     if (defined($data)) { print FILE $data;}
 214
 215     close FILE or die "Can't close file \"$filename\": $!\n";
 216 }
 217
 218 # Not used at the moment.
 219 sub trailerData {
 220     my($product_id)       = 0x0001;
 221     my($protocol_id)      = 0x0000;
 222     my($firmware_version) = 0x2325;
 223     my($unknown1)         = 0x90f7;
 224     my($magic_number)     = 'eRcOmM';
 225     my($unknown2)         = 0x00b9;
 226
 227     return pack("n4a6n",$product_id,$protocol_id,$firmware_version,$unknown1,$magic_number,$unknown2);
 228 }
 229
 230 # Print the contents of the Sercomm RedBoot trailer.
 231 sub printRedbootTrailer {
 232     my($redboot_data) = @_;
 233
 234     my($correct_redboot_len) = 0x40000;
 235     my($redboot_data_len) = length($redboot_data);
 236
 237     if ($redboot_data_len != $correct_redboot_len) {
 238         printf("Redboot length (0x%08X) is not 0x%08X\n", $redboot_data_len, $correct_redboot_len);
 239         return;
 240     }
 241
 242     # The trailer is the last 80 bytes of the redboot partition.
 243     my($redboot_trailer) = substr($redboot_data, -80);
 244
 245     writeOut($redboot_trailer, 'RedbootTrailer');
 246
 247     my($mac_addr0, $mac_addr1, $mac_addr2, $unknown, $prefix, $ver_ctrl, $down_ctrl, $hid, $hver, $prodid, $prodidmask,
 248        $protid, $protidmask, $funcid, $funcidmask, $fver, $cseg, $csize, $postfix) =
 249            unpack("n3Na7n2a32n10a7",$redboot_trailer);
 250
 251     printf("MAC address is %04X%04X%04X\n", $mac_addr0, $mac_addr1, $mac_addr2);
 252     printf("unknown: %08X\n", $unknown);
 253     printf("%s:%04X:%04X:%s\n", $prefix, $ver_ctrl, $down_ctrl, $postfix);
 254     printf("VerControl: %04X\nDownControl: %04X\n", $ver_ctrl, $down_ctrl);
 255     printf("hid: %04X %04X %04X %04X %04X %04X %04X %04X %04X %04X %04X %04X %04X %04X %04X %04X\n", unpack("n16", $hid));
 256     printf("Hver: %04X\nProdID: %04X\nProtID: %04X\nFuncID: %04X\nFver: %04X\nCseg: %04X\nCsize: %04X\n",
 257            $hver, $prodid, $protid, $funcid, $fver, $cseg, $csize);
 258 }
 259
 260 # remove the optional Loader partition
 261 sub removeOptionalLoader {
 262     my($partitions_ref) = @_;
 263
 264     my $index;
 265     my $count = 0;
 266     map {
 267         if (not defined $index) {
 268             if ($_->{'name'} eq "Loader") {
 269                 $index = $count;
 270             }
 271             $count++;
 272         }
 273     } @$partitions_ref;
 274
 275     defined $index or die "Cannot find the Loader partition\n";
 276
 277     splice(@$partitions_ref, $index, 1);
 278
 279     # Set fixed offsets and sizes for Kernel and Ramdisk
 280     map {
 281         if ($_->{'name'} eq 'Kernel') {
 282             $_->{'offset'}   = $kernel_offset;
 283             $_->{'size'}     = $kernel_size;
 284             $_->{'variable'} = 0;
 285         }
 286         if ($_->{'name'} eq 'Ramdisk') {
 287             $_->{'offset'}   = $ramdisk_offset;
 288         }
 289     } @$partitions_ref;
 290
 291     return;
 292 }
 293
 294
 295 # populate @partitions based on the firmware's partition table
 296 sub spliceFirmwarePartitions {
 297     my($firmware_buf, $partitions_ref) = @_;
 298
 299     # we know that partition table, if it exists, begins at start of 'FIS directory' and has max length 0x1000
 300     my($partition_table);
 301     map {
 302         $_->{'name'} eq 'FIS directory' and
 303             $partition_table = findPartitionTable(substr($firmware_buf, $_->{'offset'}, $_->{'size'}));
 304     } @$partitions_ref;
 305
 306     # return 0 here if no partition table in FIS directory
 307     return if not $partition_table;
 308
 309     my @new_partitions = parsePartitionTable($partition_table);
 310
 311     # Remove the optional second stage bootloader if it is not found in the FIS directory.
 312     if (not grep { $_->[0] eq 'Loader' } @new_partitions) {
 313         removeOptionalLoader($partitions_ref);
 314     }
 315
 316     my($partition_count) = 0;
 317     my($splice) = 0;
 318     map {
 319
 320         # Skip pseudo partitions.
 321         while (($partition_count < scalar(@$partitions_ref)) and
 322                $partitions_ref->[$partition_count]->{'pseudo'}) {
 323             $debug and printf("Skipped <%s> (pseudo partition)\n", $partitions_ref->[$partition_count]->{'name'});
 324             $partition_count++;
 325         }
 326
 327         # If we are in a variable area, and we haven't reached the end of it,
 328         # then splice in another partition for use by the later code.
 329         if ($splice and ($partitions_ref->[$partition_count]->{'name'} ne $_->[0])) {
 330             $debug and printf("Splicing new partition <%s> before <%s>\n",
 331                               $_->[0], $partitions_ref->[$partition_count]->{'name'});
 332             splice(@{$partitions_ref}, $partition_count, 0, ({'name' => "",'variable'=>1,'header'=>0}));
 333         }
 334
 335         my $partition = $partitions_ref->[$partition_count];
 336
 337         # Variable partitions can be overridden by the real FIS directory
 338         if ($partition->{'variable'}) {
 339
 340             # Only override the filename if the partition name is not set or doesn't match
 341             if ($partition->{'name'} ne $_->[0]) {
 342
 343                 if (length($partition->{'name'})) {
 344                     $debug and printf("Overwriting <%s> with <%s>\n",
 345                                       $partitions_ref->[$partition_count]->{'name'}, $_->[0]);
 346                 }
 347
 348                 $partition->{'name'} = $_->[0];
 349                 $partition->{'file'} = $_->[0];
 350             }
 351
 352             # Set the offset, size and skips based on the real partition table
 353             $partition->{'offset'} = $_->[1];
 354             $partition->{'size'}   = $_->[2];
 355             $partition->{'skips'}  = $_->[3];
 356
 357             $debug and printf("Locating <%s> at 0x%08X (%s)\n",
 358                               $partition->{'name'}, $partition->{'offset'},
 359                               ($partition->{'size'} >= $block_size ?
 360                                sprintf("%d blocks", numBlocks($partition->{'size'})) :
 361                                sprintf("0x%05X bytes", $partition->{'size'})));
 362
 363             $splice = 1;
 364         }
 365
 366         # Fixed partitions cannot be overridden
 367         else {
 368             ($partition->{'name'} eq $_->[0]) or
 369                 die "Unexpected partition <",$_->[0],"> (expecting <",$partition->{'name'},">)\n";
 370
 371             $debug and printf("Locating <%s> at 0x%08X (%s)\n",
 372                               $partition->{'name'}, $partition->{'offset'},
 373                               ($partition->{'size'} >= $block_size ?
 374                                sprintf("%d blocks", numBlocks($partition->{'size'})) :
 375                                sprintf("0x%05X bytes", $partition->{'size'})));
 376
 377             $splice = 0;
 378         }
 379
 380         $partition_count++;
 381
 382     } @new_partitions;
 383
 384     return;
 385 }
 386
 387 # Read in an 8MB firmware file, and store the data into @partitions.
 388 # Note that the data is only stored in a partition if 'offset' and 'size' are defined,
 389 # and it does not already have data stored in it.
 390 sub readInFirmware {
 391     my($filename, $partitions_ref) = @_;
 392
 393     my($firmware_buf);
 394     my($total_length)   = 0x800000;
 395
 396     open FILE,$filename or die "Can't find firmware image \"$filename\": $!\n";
 397     read FILE,$firmware_buf,$total_length or die "Can't read $total_length bytes from \"$filename\": $!\n";
 398     close FILE or die "Can't close \"$filename\": $!\n";
 399
 400     $debug and printf("Read 0x%08X bytes from \"%s\"\n", length($firmware_buf), $filename);
 401
 402     spliceFirmwarePartitions($firmware_buf, $partitions_ref);
 403
 404     # Read the parts of the firmware file into the partitions table.
 405     map {
 406         if (defined $_->{'offset'} and defined $_->{'size'}) {
 407
 408             if (defined $_->{'data'}) {
 409                 $debug and printf("Not overwriting data in <%s>\n", $_->{'name'});
 410             }
 411             else {
 412
 413                 # Slurp up the data, based on whether a header is present or not
 414                 if ($_->{'header'}) {
 415
 416                     # Read the length, and grab the data based on the length.
 417                     my($data_len) = unpack("N", substr($firmware_buf, $_->{'offset'}));
 418
 419                     # A length of 0xFFFFFFFF means that the area is not initialised
 420                     if ($data_len != 0xFFFFFFFF) {
 421                         $debug and printf("Found header size of 0x%08X bytes for <%s>\n", $data_len, $_->{'name'});
 422                         $_->{'data'} = substr($firmware_buf, $_->{'offset'} + $_->{'header'}, $data_len);
 423                     }
 424                 }
 425                 else {
 426
 427                     # Grab the whole partition, using the maximum size.
 428                     $_->{'data'} = substr($firmware_buf, $_->{'offset'}, $_->{'size'});
 429                 }
 430
 431                 # If skip regions are defined, remove them from the data.
 432                 if (defined $_->{'skips'}) {
 433                     my $removed = 0;
 434                     foreach my $region (@{$_->{'skips'}}) {
 435                         if (($region->{'offset'} > 0) or
 436                             not ($_->{'header'} > 0)) {
 437                             $debug and printf("Removing 0x%05X bytes from offset 0x%05X\n",
 438                                               $region->{'size'}, $region->{'offset'});
 439                             $region->{'data'} = substr($_->{'data'}, $region->{'offset'} - $removed, $region->{'size'}, '');
 440                         }
 441                         $removed += $region->{'size'};
 442                     }
 443                 }
 444
 445                 $quiet or defined $_->{'data'} and printf("Read %s into <%s>\n",
 446                                                           (length($_->{'data'}) >= $block_size ?
 447                                                            sprintf("%d blocks", numBlocks(length($_->{'data'}))) :
 448                                                            sprintf("0x%05X bytes", length($_->{'data'}))), $_->{'name'});
 449             }
 450         }
 451     } @$partitions_ref;
 452 }
 453
 454 # Write the partition data stored in memory out into the files associated with each.
 455 sub writeOutFirmwareParts {
 456     my(@partitions) = @_;
 457
 458     # Write out the parts of the firmware file.
 459     map {
 460
 461         # We can only write if 'data' and 'file' are defined.
 462         if (defined $_->{'file'} and defined $_->{'data'} and length($_->{'data'})) {
 463             writeOut($_->{'data'}, $_->{'file'});
 464             $quiet or printf("Wrote 0x%08X bytes from <%s> into \"%s\"\n",
 465                               length($_->{'data'}), $_->{'name'}, $_->{'file'});
 466         }
 467         else {
 468             $debug and printf("Skipping <%s> (%s)\n", $_->{'name'},
 469                               (not defined $_->{'file'}) ?
 470                               "no filename specified" :
 471                               "no data to write");
 472         }
 473
 474     } @partitions;
 475
 476     return;
 477 }
 478
 479 # Read in the partition data from the files associated with each and store in memory.
 480 sub readInFirmwareParts {
 481     my(@partitions) = (@_);
 482
 483     undef $/; # we want to slurp
 484
 485     map {
 486
 487         my $file = $_->{'file'};
 488         if (defined $file) {
 489             open FILE,$file or die "Can't find firmware part \"$file\": $!\n";
 490
 491             # Slurp in the data
 492             $_->{'data'} = <FILE>;
 493
 494             # close the file
 495             close FILE or die "Can't close file \"$file\": $!\n";
 496
 497             # Optionally byteswap the data
 498             if ($_->{'byteswap'}) {
 499                 # Byte swap the data (which has to be padded to a multiple of 4 bytes).
 500                 $_->{'data'} = pack("N*", unpack("V*", $_->{'data'}.pack("CCC", 0)));
 501             }
 502
 503             # Keep track of the actual size.
 504             my $size;
 505
 506             if ($_->{'header'}) {
 507                 if ($_->{'pseudo'}) {
 508                     $size = $_->{'header'} + length($_->{'data'});
 509                 }
 510                 else {
 511                     $size = paddedSize($_->{'header'} + length($_->{'data'}));
 512                 }
 513             }
 514             elsif (not $_->{'pseudo'}) {
 515                 $size = paddedSize(length($_->{'data'}));
 516             }
 517             else {
 518                 $size = length($_->{'data'});
 519             }
 520
 521             # Check to make sure the file contents are not too large.
 522             if (defined $_->{'size'} and ($size > $_->{'size'})) {
 523                 die sprintf("Ran out of flash space in <%s> - %s too large.\n", $_->{'name'},
 524                             sprintf("0x%05X bytes", ($size - $_->{'size'})));
 525             }
 526
 527             # If the partition does not have a fixed size, the calculate the size.
 528             if (not defined $_->{'size'}) {
 529                 $_->{'size'} = $size;
 530             }
 531
 532             # Keep the user appraised ...
 533             $quiet or printf("Read 0x%08X bytes from \"%s\" into <%s> (%s / %s)%s\n",
 534                              length($_->{'data'}), $_->{'file'}, $_->{'name'},
 535                              ($size >= $block_size ?
 536                               sprintf("%d blocks", numBlocks($size)) :
 537                               sprintf("0x%05X bytes", $size)),
 538                              ($_->{'size'} >= $block_size ?
 539                               sprintf("%d blocks", numBlocks($_->{'size'})) :
 540                               sprintf("0x%05X bytes", $_->{'size'})),
 541                              ($_->{'byteswap'} ? " (byte-swapped)" : ""));
 542         }
 543
 544     } @partitions;
 545
 546     return;
 547 }
 548
 549 # layoutPartitions : this function must be ugly - it needs to verify RedBoot, SysConf, Kernel, Ramdisk, and
 550 #     FIS directory partitions exist, are in the correct order, and do not have more data than can fit in
 551 #     their lengths (fixed for all but Ramdisk, which has a minimum length of one block).
 552 #     If Rootdisk and/or Userdisk exist, it must also verify that their block padded lengths are not
 553 #     too great for the available space.
 554 # input : an array of hashes, some of which are populated with data
 555 # output: same reference with start and size (partition not data) also populated. this populated structure
 556 #         can then be passed to buildPartitionTable() to generate the actual partition table data
 557 sub layoutPartitions {
 558     my(@partitions) = @_;
 559
 560     # Find the last variable size partition, and save a pointer to it for later use
 561     my $lastdisk;
 562     my $directory_offset;
 563     my $curdisk = $partitions[0];
 564     map {
 565         if (not defined $lastdisk) {
 566             if ($_->{'name'} eq "FIS directory") {
 567                 $lastdisk = $curdisk;
 568                 $directory_offset = $_->{'offset'};
 569             }
 570             else {
 571                 $curdisk = $_;
 572             }
 573         }
 574     } @partitions;
 575
 576     $lastdisk or die "Couldn't find the last variable size partition\n";
 577
 578     $debug and printf("Last variable size partition is <%s>\n", $lastdisk->{'name'});
 579
 580     #
 581     # here we go through the $partitions array ref and fill in all the values
 582     #
 583
 584     # This points to where the next partition should be placed.
 585     my $pointer = $flash_start;
 586
 587     map {
 588
 589         $debug and printf("Pointer is 0x%08X\n", $pointer);
 590
 591         # If this is the last variable size partition, then fill the rest of the space.
 592         if ($_->{'name'} eq $lastdisk->{'name'}) {
 593             $_->{'size'} = paddedSize($directory_offset + $flash_start - $pointer);
 594             $debug and printf("Padding last variable partition <%s> to 0x%08X bytes\n", $_->{'name'}, $_->{'size'});
 595         }
 596
 597         # Handle requests for partition creation first.
 598         if (defined $_->{'size'} and not defined $_->{'data'} and ($_->{'name'} ne "FIS directory")) {
 599
 600             # A zero size is a request to fill all available space.
 601             if ($_->{'size'} == 0) {
 602                 # Grab the start of the FIS directory, and use all the space up to there.
 603                 $_->{'size'} = paddedSize($directory_offset + $flash_start - $pointer);
 604
 605                 # Create an empty partition of the requested size.
 606                 $_->{'data'} = padBytes("", $_->{'size'});
 607
 608                 $debug and printf("Creating empty partition <%s> of 0x%08X bytes\n", $_->{'name'}, $_->{'size'});
 609             }
 610
 611             if (not defined $_->{'offset'}) {
 612                 # Check to make sure that the requested size is not too large.
 613                 if (($pointer + $_->{'size'}) > ($flash_start + $directory_offset)) {
 614                     die "Ran out of flash space in <", $_->{'name'}, ">\n";
 615                 }
 616             }
 617             else {
 618                 # Check to make sure that the requested size is not too large.
 619                 if (($_->{'offset'} + $_->{'size'}) > ($flash_start + $directory_offset)) {
 620                     die "Ran out of flash space in <", $_->{'name'}, ">\n";
 621                 }
 622             }
 623         }
 624
 625         # Then handle known partitions, and allocate them.
 626         if (defined $_->{'size'}) {
 627
 628             # Determine the start and offset of the current partition.
 629             if (defined $_->{'offset'}) {
 630                 $_->{'start'} = $flash_start + $_->{'offset'};
 631             }
 632
 633             # If offset is not defined, then calculate it.
 634             else {
 635                 $_->{'start'} = $pointer;
 636                 $_->{'offset'} = $_->{'start'} - $flash_start;
 637             }
 638
 639             my $size = defined $_->{'data'} ? length($_->{'data'}) : 0;
 640
 641             # Add skip regions for the partitions with headers.
 642             if ($_->{'header'} > 0) {
 643                 # Define the skip region for the initial Sercomm header.
 644                 push(@{$_->{'skips'}},
 645                      { 'offset' => 0, 'size' => $_->{'header'}, 'data' => undef });
 646                 # Allow for the Sercomm header to be prepended to the data.
 647                 $size += $_->{'header'};
 648             }
 649
 650             # Determine if the partition requires a Sercomm skip region.
 651             if (($_->{'offset'} < $ramdisk_offset) and
 652                 (($_->{'offset'} + $size) > $ramdisk_offset)) {
 653                 # Define the skip region for the inline Sercomm header.
 654                 push(@{$_->{'skips'}},
 655                      { 'offset' => ($ramdisk_offset - $_->{'offset'}), 'size' => 16,
 656                        'data' => pack("N4", $block_size) });
 657                 # Allow for the Sercomm header to be inserted in the data.
 658                 $size += 16;
 659             }
 660
 661             # Extend to another block if required.
 662             if ($size > $_->{'size'}) {
 663                 $_->{'size'} = $size;
 664                 printf("Extending partition <%s> to 0x%08X bytes\n", $_->{'name'}, $_->{'size'});
 665             }
 666
 667             # Keep the user appraised ...
 668             $debug and printf("Allocated <%s> from 0x%08X to 0x%08X (%s / %s)\n",
 669                               $_->{'name'}, $_->{'start'}, $_->{'start'} + $_->{'size'},
 670                               ($size >= $block_size ?
 671                                sprintf("%d blocks", numBlocks($size)) :
 672                                sprintf("0x%05X bytes", $size)),
 673                               ($_->{'size'} >= $block_size ?
 674                                sprintf("%d blocks", numBlocks($_->{'size'})) :
 675                                sprintf("0x%05X bytes", $_->{'size'})));
 676
 677             # Check to make sure we have not run out of room.
 678             if (($_->{'start'} + $_->{'size'}) > ($flash_start + $flash_len)) {
 679                 die "Ran out of flash space in <", $_->{'name'}, ">\n";
 680             }
 681
 682             $debug and printf("Moving pointer from 0x%08X to 0x%08X (0x%08X + 0x%08X)\n",
 683                               $pointer, paddedSize($_->{'start'} + $_->{'size'}),
 684                               $_->{'start'}, $_->{'size'});
 685
 686             # Move the pointer up, in preparation for the next partition.
 687             $pointer = paddedSize($_->{'start'} + $_->{'size'});
 688
 689         }
 690
 691     } @partitions;
 692
 693     return;
 694 }
 695
 696 sub buildPartitionTable {
 697     my(@partitions) = @_;
 698
 699     my($flash_start) = 0x50000000;
 700     my($partition_data) = '';
 701
 702     map {
 703
 704         # Collate the partition data for all known partitions.
 705         if (not $_->{'pseudo'} and defined $_->{'offset'} and defined $_->{'size'}) {
 706
 707             # Pack and append the binary table entry for this partition.
 708             $partition_data .= createPartitionEntry($_->{'name'}, $_->{'offset'} + $flash_start,
 709                                                     $_->{'size'}, $_->{'skips'});
 710
 711             # If this is the FIS directory, then write the partition table data into it.
 712             if ($_->{'name'} eq "FIS directory") {
 713                 # Explicitly terminate the partition data.
 714                 $partition_data .= pack("C",0xff) x 0x100;
 715                 $_->{'data'} = padBytes($partition_data, $_->{'size'});
 716             }
 717
 718             my $size = length($_->{'data'});
 719
 720             # Keep the user appraised ...
 721             $debug and printf("Table entry <%s> from 0x%08X to 0x%08X (%s / %s)%s\n",
 722                               $_->{'name'}, $_->{'start'}, $_->{'start'} + $_->{'size'},
 723                               ($size >= $block_size ?
 724                                sprintf("%d blocks", numBlocks($size)) :
 725                                sprintf("0x%05X bytes", $size)),
 726                               ($_->{'size'} >= $block_size ?
 727                                sprintf("%d blocks", numBlocks($_->{'size'})) :
 728                                sprintf("0x%05X bytes", $_->{'size'})),
 729                               (defined $_->{'skips'} ?
 730                                sprintf("\nTable entry <%s> skip %s", $_->{'name'},
 731                                        join(", ",
 732                                             map { sprintf("0x%08X to 0x%08X", $_->{'offset'},
 733                                                           $_->{'offset'} + $_->{'size'} - 1) }
 734                                             @{$_->{'skips'}})) :
 735                                "")
 736                               );
 737         }
 738         else {
 739             $debug and print "No table entry required for <", $_->{'name'}, ">\n";
 740         }
 741
 742     } @partitions;
 743
 744     return;
 745 }
 746
 747 sub writeOutFirmware {
 748     my($filename, @partitions) = @_;
 749
 750     # Clear the image to start.
 751     my $image_buf = "";
 752
 753     map {
 754
 755         # We can only write a partition if it has an offset, a size, and some data to write.
 756         if (defined $_->{'offset'} and defined $_->{'size'} and defined $_->{'data'}) {
 757
 758             # Keep track of the end of the image.
 759             my $end_point = length($image_buf);
 760
 761             # If the next partition is well past the end of the current image, then pad it.
 762             if ($_->{'offset'} > $end_point) {
 763                 $image_buf .= padBytes("", $_->{'offset'} - $end_point);
 764                 $quiet or printf("Padded %s before <%s> in \"%s\"\n",
 765                                  ((length($image_buf) - $end_point) >= $block_size ?
 766                                   sprintf("%d blocks", numBlocks(length($image_buf) - $end_point)) :
 767                                   sprintf("0x%05X bytes", length($image_buf) - $end_point)),
 768                                  $_->{'name'}, $filename);
 769             }
 770
 771             # If the next parition is before the end of the current image, then rewind.
 772             elsif ($_->{'offset'} < $end_point) {
 773                 $debug and printf("Rewound %s before <%s> in \"%s\"\n",
 774                                   (($end_point - $_->{'offset'}) >= $block_size ?
 775                                    sprintf("%d blocks", numBlocks($end_point - $_->{'offset'})) :
 776                                    sprintf("0x%05X bytes", $end_point - $_->{'offset'})),
 777                                   $_->{'name'}, $filename);
 778 #               if (($end_point - $_->{'offset'}) >= $block_size) {
 779 #                   die "Allocation error: rewound a full block or more ...\n";
 780 #               }
 781             }
 782
 783             # If skip regions are defined, add them to the data.
 784             if (defined $_->{'skips'}) {
 785                 my $added = 0;
 786                 foreach my $region (@{$_->{'skips'}}) {
 787                     if (($region->{'offset'} > 0) or
 788                         not ($_->{'header'} > 0)) {
 789                         $debug and printf("Inserted 0x%05X bytes (at offset 0x%05X) into <%s>\n",
 790                                           $region->{'size'}, $region->{'offset'}, $_->{'name'});
 791                         substr($_->{'data'},
 792                                $region->{'offset'} + $added - $_->{'header'},
 793                                0, $region->{'data'});
 794                         $added += $region->{'size'};
 795                     }
 796                 }
 797             }
 798
 799             # Splice the data into the image at the appropriate place, padding as required.
 800             substr($image_buf, $_->{'offset'}, $_->{'size'},
 801                    $_->{'header'} ?
 802                    padBytes(pack("N4",length($_->{'data'})).$_->{'data'}, $_->{'size'}) :
 803                    padBytes($_->{'data'}, $_->{'size'}));
 804
 805             # Keep the user appraised ...
 806             $quiet or printf("Wrote %s (0x%08X to 0x%08X) from <%s> into \"%s\"\n",
 807                              ($_->{'size'} >= $block_size ?
 808                               sprintf("%2d blocks", numBlocks($_->{'size'})) :
 809                               sprintf("0x%05X bytes", $_->{'size'})),
 810                              $_->{'offset'}, $_->{'offset'}+$_->{'size'}, $_->{'name'}, $filename);
 811         }
 812
 813         # If we are not able to write a partition, then give debug information about why.
 814         else {
 815             $debug and printf("Skipping <%s> (%s)\n", $_->{'name'},
 816                               (not defined $_->{'offset'}) ? "no offset defined" :
 817                               ((not defined $_->{'size'}) ? "no size defined" :
 818                                "no data available"));
 819         }
 820
 821     } @partitions;
 822
 823     # Write the image to the specified file.
 824     writeOut($image_buf, $filename);
 825
 826     return;
 827 }
 828
 829 # checkPartitionTable: sanity check partition table - for testing but might evolve into setting @partitions
 830 #    so that we can write out jffs2 partitions from a read image
 831 #    currently not nearly paranoid enough
 832 sub checkPartitionTable {
 833     my($data) = @_;
 834
 835     my($pointer) = 0;
 836     my($entry);
 837
 838     my($name, $flash_base, $size, $done, $dummy_long, $padding);
 839     do {
 840         $entry = substr($data, $pointer, 0x100);
 841
 842         ($name,$flash_base,$dummy_long,$size,$dummy_long,$dummy_long,$padding,$dummy_long,$dummy_long) = unpack("a16N5x212N2",$entry);
 843         $name =~ s/\0//g;
 844         $debug and printf("pointer: %d\tname: %s%sflash_base: 0x%08X\tsize: 0x%08X\n",
 845                           $pointer, $name, (" " x (16 - length($name))), $flash_base, $size);
 846         $pointer += 0x100;
 847         $debug and printf("terminator: 0x%08X\n", unpack("C", substr($data, $pointer, 1)));
 848         if (unpack("C", substr($data, $pointer, 1)) eq 0xff) {
 849             $done = 1;
 850         }
 851     } until $done;
 852 }
 853
 854 sub printPartitions {
 855     my(@partitions) = @_;
 856
 857     my($offset, $size, $skips);
 858     map {
 859 #       defined $_->{'size'} ? $size = $_->{'size'} : $size = undef;
 860
 861         if (defined  $_->{'size'}) {
 862             $size = $_->{'size'};
 863         }
 864         else {
 865             $size = undef;
 866         }
 867         if (defined  $_->{'offset'}) {
 868             $offset = $_->{'offset'};
 869         }
 870         else {
 871             $offset = undef;
 872         }
 873         if (defined  $_->{'skips'}) {
 874             $skips = $_->{'skips'};
 875         }
 876         else {
 877             $skips = undef;
 878         }
 879         printf("%s%s", $_->{'name'}, (" " x (16 - length($_->{'name'}))));
 880         if (defined $offset) { printf("0x%08X\t", $offset); } else { printf("(undefined)\t");   };
 881         if (defined $size)   { printf("0x%08X", $size); } else { printf("(undefined)"); };
 882         if (defined $skips) {
 883             printf("\t[%s]",
 884                    join(", ",
 885                         map { sprintf("0x%05X/0x%05X", $_->{'offset'}, $_->{'size'}); }
 886                         @$skips));
 887         }
 888         printf("\n");
 889     } @partitions;
 890 }
 891
 892 sub defaultPartitions {
 893
 894     return ({'name'=>'RedBoot',          'file'=>'RedBoot',
 895              'offset'=>0x00000000,        'size'=>0x00040000,
 896              'variable'=>0, 'header'=>0,  'pseudo'=>0, 'data'=>undef, 'byteswap'=>0},
 897             {'name'=>'EthAddr',           'file'=>undef,
 898              'offset'=>0x0003ffb0,        'size'=>0x00000006,
 899              'variable'=>0, 'header'=>0,  'pseudo'=>1, 'data'=>undef, 'byteswap'=>0},
 900             {'name'=>'SysConf',           'file'=>'SysConf',
 901              'offset'=>0x00040000,        'size'=>0x00020000,
 902              'variable'=>0, 'header'=>0,  'pseudo'=>0, 'data'=>undef, 'byteswap'=>0},
 903             {'name'=>'Loader',            'file'=>'apex.bin',
 904              'offset'=>undef,             'size'=>undef,
 905              'variable'=>1, 'header'=>16, 'pseudo'=>0, 'data'=>undef, 'byteswap'=>0},
 906             {'name'=>'Kernel',            'file'=>'vmlinuz',
 907              'offset'=>undef,             'size'=>undef,
 908              'variable'=>1, 'header'=>16, 'pseudo'=>0, 'data'=>undef, 'byteswap'=>0},
 909             {'name'=>'Ramdisk',           'file'=>'ramdisk.gz',
 910              'offset'=>undef,             'size'=>undef,
 911              'variable'=>1, 'header'=>16, 'pseudo'=>0, 'data'=>undef, 'byteswap'=>0},
 912             {'name'=>'FIS directory',     'file'=>undef,
 913              'offset'=>0x007e0000,        'size'=>0x00020000,
 914              'variable'=>0, 'header'=>0,  'pseudo'=>0, 'data'=>undef, 'byteswap'=>0},
 915             {'name'=>'Loader config',     'file'=>undef,
 916              'offset'=>0x007f8000,        'size'=>0x00004000,
 917              'variable'=>0, 'header'=>0,  'pseudo'=>1, 'data'=>undef, 'byteswap'=>0},
 918             {'name'=>'Microcode',         'file'=>'NPE-B',
 919              'offset'=>0x007fc000,        'size'=>0x00003ff0,
 920              'variable'=>0, 'header'=>16, 'pseudo'=>1, 'data'=>undef, 'byteswap'=>0},
 921             {'name'=>'Trailer',           'file'=>'Trailer',
 922              'offset'=>0x007ffff0,        'size'=>0x00000010,
 923              'variable'=>0, 'header'=>0,  'pseudo'=>1, 'data'=>undef, 'byteswap'=>0});
 924 }
 925
 926 # Main routine starts here ...
 927
 928 my($unpack, $pack, $little, $input, $output, $redboot);
 929 my($kernel, $sysconf, $ramdisk, $fisdir);
 930 my($microcode, $trailer, $ethaddr, $loader);
 931
 932 END {
 933     # Remove temporary files
 934     for my $file (@cleanup) {
 935         unlink $file;
 936     }
 937 }
 938
 939 if (!GetOptions("d|debug"       => \$debug,
 940                 "q|quiet"       => \$quiet,
 941                 "u|unpack"      => \$unpack,
 942                 "p|pack"        => \$pack,
 943                 "l|little"      => \$little,
 944                 "i|input=s"     => \$input,
 945                 "o|output=s"    => \$output,
 946                 "b|redboot=s"   => \$redboot,
 947                 "k|kernel=s"    => \$kernel,
 948                 "s|sysconf=s"   => \$sysconf,
 949                 "r|ramdisk=s"   => \$ramdisk,
 950                 "f|fisdir=s"    => \$fisdir,
 951                 "m|microcode=s" => \$microcode,
 952                 "t|trailer=s"   => \$trailer,
 953                 "e|ethaddr=s"   => \$ethaddr,
 954                 "L|loader=s"    => \$loader,
 955                 ) or (not defined $pack and not defined $unpack)) {
 956     print "Usage: slugimage <options>\n";
 957     print "\n";
 958     print "  [-d|--debug]                       Turn on debugging output\n";
 959     print "  [-q|--quiet]                       Turn off status messages\n";
 960     print "  [-u|--unpack]                      Unpack a firmware image\n";
 961     print "  [-p|--pack]                        Pack a firmware image\n";
 962     print "  [-l|--little]                      Convert Kernel and Ramdisk to little-endian\n";
 963     print "  [-i|--input]     <file>            Input firmware image filename\n";
 964     print "  [-o|--output]    <file>            Output firmware image filename\n";
 965     print "  [-b|--redboot]   <file>            Input/Output RedBoot filename\n";
 966     print "  [-s|--sysconf]   <file>            Input/Output SysConf filename\n";
 967     print "  [-L|--loader]    <file>            Second stage boot loader filename\n";
 968     print "  [-k|--kernel]    <file>            Input/Ouptut Kernel filename\n";
 969     print "  [-r|--ramdisk]   <file>            Input/Output Ramdisk filename(s)\n";
 970     print "  [-f|--fisdir]    <file>            Input/Output FIS directory filename\n";
 971     print "  [-m|--microcode] <file>            Input/Output Microcode filename\n";
 972     print "  [-t|--trailer]   <file>            Input/Output Trailer filename\n";
 973     print "  [-e|--ethaddr]   <AABBCCDDEEFF>    Set the Ethernet address\n";
 974
 975     # %%% TODO %%% Document --ramdisk syntax
 976
 977     exit 1;
 978 }
 979
 980 my(@partitions) = defaultPartitions();
 981
 982 if ($pack) {
 983     die "Output filename must be specified\n" unless defined $output;
 984
 985     # If we're creating an image and no RedBoot, SysConf partition is
 986     # explicitly specified, simply write an empty one as the upgrade tools
 987     # don't touch RedBoot and SysConf anyway.  If no Trailer is specified,
 988     # put in one.
 989     if (not defined $redboot and not -e "RedBoot") {
 990         $redboot = tmpnam();
 991         open TMP, ">$redboot" or die "Cannot open file $redboot: $!";
 992         push @cleanup, $redboot;
 993         # The RedBoot partition is 256 * 1024 = 262144; the trailer we add
 994         # is 70 bytes.
 995         print TMP "\0"x(262144-70);
 996         # Upgrade tools check for an appropriate Sercomm trailer.
 997         for my $i (@sercomm_redboot_trailer) {
 998             print TMP pack "S", $i;
 999         }
1000         close TMP;
1001     }
1002     if (not defined $sysconf and not -e "SysConf") {
1003         $sysconf = tmpnam();
1004         open TMP, ">$sysconf" or die "Cannot open file $sysconf: $!";
1005         push @cleanup, $sysconf;
1006         # The SysConf partition is 128 * 1024 = 131072
1007         print TMP "\0"x131072;
1008         close TMP;
1009     }
1010     if (not defined $trailer and not -e "Trailer") {
1011         $trailer = tmpnam();
1012         open TMP, ">$trailer" or die "Cannot open file $trailer: $!";
1013         push @cleanup, $trailer;
1014         for my $i (@sercomm_flash_trailer) {
1015             print TMP pack "S", $i;
1016         }
1017         close TMP;
1018     }
1019
1020     # If the microcode was not specified, then don't complain that it's missing.
1021     if (not defined $microcode and not -e "NPE-B") {
1022         map { ($_->{'name'} eq 'Microcode') && ($_->{'file'} = undef);   } @partitions;
1023     }
1024 }
1025
1026 # Go through the partition options, and set the names and files in @partitions
1027 if (defined $redboot)   { map { ($_->{'name'} eq 'RedBoot')       && ($_->{'file'} = $redboot);   } @partitions; }
1028 if (defined $sysconf)   { map { ($_->{'name'} eq 'SysConf')       && ($_->{'file'} = $sysconf);   } @partitions; }
1029 if (defined $loader)    { map { ($_->{'name'} eq 'Loader')        && ($_->{'file'} = $loader);    } @partitions; }
1030 if (defined $kernel)    { map { ($_->{'name'} eq 'Kernel')        && ($_->{'file'} = $kernel);    } @partitions; }
1031 if (defined $fisdir)    { map { ($_->{'name'} eq 'FIS directory') && ($_->{'file'} = $fisdir);    } @partitions; }
1032 if (defined $microcode) { map { ($_->{'name'} eq 'Microcode')     && ($_->{'file'} = $microcode); } @partitions; }
1033 if (defined $trailer)   { map { ($_->{'name'} eq 'Trailer')       && ($_->{'file'} = $trailer);   } @partitions; }
1034
1035 if (defined $little)  {
1036     map {
1037         if (($_->{'name'} eq 'Loader') or
1038             ($_->{'name'} eq 'Kernel') or
1039             ($_->{'name'} eq 'Ramdisk')) {
1040             $_->{'byteswap'} = 1;
1041         }
1042     } @partitions;
1043 }
1044
1045 if (defined $ethaddr) {
1046     map {
1047         if ($_->{'name'} eq 'EthAddr') {
1048             $ethaddr =~ s/://g;
1049             if (($ethaddr !~ m/^[0-9A-Fa-f]+$/) or (length($ethaddr) != 12)) {
1050                 die "Invalid ethernet address specification: '".$ethaddr."'\n";
1051             }
1052             $_->{'data'} = pack("H12", $ethaddr);
1053         }
1054     } @partitions;
1055 }
1056
1057 if (defined $ramdisk) {
1058
1059     # A single filename is used for the ramdisk filename
1060     if ($ramdisk !~ m/[:,]/) {
1061         map { ($_->{'name'} eq 'Ramdisk') && ($_->{'file'} = $ramdisk); } @partitions;
1062     }
1063
1064     # otherwise, it's a list of name:file mappings
1065     else {
1066         my @mappings = split(',', $ramdisk);
1067
1068         # Find the index of the Ramdisk entry
1069         my $index;
1070         my $count = 0;
1071         map {
1072             if (not defined $index) {
1073                 if ($_->{'name'} eq "Ramdisk") {
1074                     $index = $count;
1075                 }
1076                 $count++;
1077             }
1078         } @partitions;
1079
1080         defined $index or die "Cannot find the Ramdisk partition\n";
1081
1082         # Replace the Ramdisk entry with the new mappings
1083         splice(@partitions, $index, 1, map {
1084
1085             # Preserve the information from the ramdisk entry
1086             my %entry = %{$partitions[$index]};
1087
1088             # Parse the mapping
1089             ($_ =~ m/^([^:]+):([^:]+)(:([^:]+))?$/) or die "Invalid syntax in --ramdisk\n";
1090             $entry{'name'} = $1; $entry{'file'} = $2; my $size = $4;
1091
1092             # If the mapping is not for the ramdisk, then undefine its attributes
1093             if ($entry{'name'} ne 'Ramdisk') {
1094                 $entry{'offset'} = undef;
1095                 $entry{'size'} = undef;
1096                 $entry{'variable'} = 1;
1097                 $entry{'header'} = 0;
1098                 $entry{'pseudo'} = 0;
1099                 $entry{'data'} = undef;
1100                 $entry{'byteswap'} = 0;
1101             }
1102
1103             # Support specification of the number of blocks for empty jffs2
1104             if ($entry{'file'} =~ m/^[0-9]+$/) {
1105                 $size = $entry{'file'};
1106                 $entry{'file'} = undef;
1107             }
1108
1109             # If the user has specified a size, then respect their wishes
1110             if (defined $size) {
1111                 $entry{'size'} = $size * $block_size;
1112                 # Create an empty partition of the requested size.
1113                 $entry{'data'} = padBytes("", $entry{'size'});
1114                 if ($entry{'header'}) {
1115                     $entry{'data'} = padBytes("", $entry{'size'} - $entry{'header'});
1116                 }
1117             }
1118
1119             \%entry;
1120
1121         } @mappings);
1122     }
1123 }
1124
1125 # Read in the firmware image
1126 if ($input) {
1127     if ($debug) {
1128         print "Initial partition map:\n";
1129         printPartitions(@partitions);
1130     }
1131
1132     my $result = readInFirmware($input, \@partitions);
1133
1134     if ($debug) {
1135         print "After reading firmware:\n";
1136         printPartitions(@partitions);
1137     }
1138 }
1139
1140 # Unpack the firmware if requested
1141 if ($unpack) {
1142     die "Input filename must be specified\n" unless defined $input;
1143
1144 #    map {
1145 #       ($_->{'name'} eq 'FIS directory') and @partitions = checkPartitionTable($_->{'data'});
1146 #    } @partitions;
1147
1148     writeOutFirmwareParts(@partitions);
1149
1150 }
1151
1152 # Pack the firmware if requested
1153 if ($pack) {
1154
1155     if (!defined $loader) {
1156         removeOptionalLoader(\@partitions);
1157     }
1158
1159     if ($debug) {
1160         print "Initial partition map:\n";
1161         printPartitions(@partitions);
1162     }
1163
1164     my $result = readInFirmwareParts(@partitions);
1165
1166     if ($debug) {
1167         print "after readInFirmwareParts():\n";
1168         printPartitions(@partitions);
1169 #       map {
1170 #           ($_->{'name'} eq 'RedBoot') && (printRedbootTrailer($_->{'data'}));
1171 #       } @partitions;
1172     }
1173
1174     layoutPartitions(@partitions);
1175
1176     if ($debug) {
1177         print "after layoutPartitions():\n";
1178         printPartitions(@partitions);
1179     }
1180
1181     buildPartitionTable(@partitions);
1182
1183     if ($debug) {
1184         print "after buildPartitionTable():\n";
1185         printPartitions(@partitions);
1186
1187 #       my($lastblock);
1188 #       map {
1189 #           if ($_->{'name'} eq 'FIS directory') {
1190 #               $lastblock = $_->{'data'};
1191 #           }
1192 #       } @partitions;
1193
1194 #       print "checkPartitionTable():\n";
1195 #       checkPartitionTable($lastblock);
1196     }
1197
1198     writeOutFirmware($output, @partitions);
1199
1200 }
1201
1202 exit 0;