move x86 lzma loader patch from generic patches into rdc-2.6 - it's causing problems...
[librecmc/librecmc.git] / 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 and/or data 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                 elsif ($_->{'pseudo'} and not defined $_->{'file'} and
426                        (substr($firmware_buf, $_->{'offset'}, $_->{'size'}) eq
427                         (pack("C", 0xff) x $_->{'size'}))) {
428                     $debug and printf("Skipping empty pseudo partition <%s>\n", $_->{'name'});
429                 }
430                 else {
431
432                     # Grab the whole partition, using the maximum size.
433                     $_->{'data'} = substr($firmware_buf, $_->{'offset'}, $_->{'size'});
434                 }
435
436                 # If skip regions are defined, remove them from the data.
437                 if (defined $_->{'skips'}) {
438                     my $removed = 0;
439                     foreach my $region (@{$_->{'skips'}}) {
440                         if (($region->{'offset'} > 0) or
441                             not ($_->{'header'} > 0)) {
442                             $debug and printf("Removing 0x%05X bytes from offset 0x%05X\n",
443                                               $region->{'size'}, $region->{'offset'});
444                             $region->{'data'} = substr($_->{'data'}, $region->{'offset'} - $removed, $region->{'size'}, '');
445                         }
446                         $removed += $region->{'size'};
447                     }
448                 }
449
450                 $quiet or defined $_->{'data'} and printf("Read %s into <%s>\n",
451                                                           (length($_->{'data'}) >= $block_size ?
452                                                            sprintf("%d blocks", numBlocks(length($_->{'data'}))) :
453                                                            sprintf("0x%05X bytes", length($_->{'data'}))), $_->{'name'});
454             }
455         }
456     } @$partitions_ref;
457 }
458
459 # Write the partition data stored in memory out into the files associated with each.
460 sub writeOutFirmwareParts {
461     my(@partitions) = @_;
462
463     # Write out the parts of the firmware file.
464     map {
465
466         # We can only write if 'data' and 'file' are defined.
467         if (defined $_->{'file'} and defined $_->{'data'} and length($_->{'data'})) {
468             writeOut($_->{'data'}, $_->{'file'});
469             $quiet or printf("Wrote 0x%08X bytes from <%s> into \"%s\"\n",
470                               length($_->{'data'}), $_->{'name'}, $_->{'file'});
471         }
472         else {
473             $debug and printf("Skipping <%s> (%s)\n", $_->{'name'},
474                               (not defined $_->{'file'}) ?
475                               "no filename specified" :
476                               "no data to write");
477         }
478
479     } @partitions;
480
481     return;
482 }
483
484 # Read in the partition data from the files associated with each and store in memory.
485 sub readInFirmwareParts {
486     my(@partitions) = (@_);
487     
488     undef $/; # we want to slurp
489
490     map {
491
492         my $file = $_->{'file'};
493         if (defined $file) {
494             open FILE,$file or die "Can't find firmware part \"$file\": $!\n";
495
496             # Slurp in the data
497             $_->{'data'} = <FILE>;
498
499             # close the file
500             close FILE or die "Can't close file \"$file\": $!\n";
501
502             # Optionally byteswap the data
503             if ($_->{'byteswap'}) {
504                 # Byte swap the data (which has to be padded to a multiple of 4 bytes).
505                 $_->{'data'} = pack("N*", unpack("V*", $_->{'data'}.pack("CCC", 0)));
506             }
507
508             # Keep track of the actual size.
509             my $size;
510
511             if ($_->{'header'}) {
512                 if ($_->{'pseudo'}) {
513                     $size = $_->{'header'} + length($_->{'data'});
514                 }
515                 else {
516                     $size = paddedSize($_->{'header'} + length($_->{'data'}));
517                 }
518             }
519             elsif (not $_->{'pseudo'}) {
520                 $size = paddedSize(length($_->{'data'}));
521             }
522             else {
523                 $size = length($_->{'data'});
524             }
525
526             # Check to make sure the file contents are not too large.
527             if (defined $_->{'size'} and ($size > $_->{'size'})) {
528                 die sprintf("Ran out of flash space in <%s> - %s too large.\n", $_->{'name'},
529                             sprintf("0x%05X bytes", ($size - $_->{'size'})));
530             }
531
532             # If the partition does not have a fixed size, the calculate the size.
533             if (not defined $_->{'size'}) {
534                 $_->{'size'} = $size;
535             }
536
537             # Keep the user appraised ...
538             $quiet or printf("Read 0x%08X bytes from \"%s\" into <%s> (%s / %s)%s\n",
539                              length($_->{'data'}), $_->{'file'}, $_->{'name'},
540                              ($size >= $block_size ?
541                               sprintf("%d blocks", numBlocks($size)) :
542                               sprintf("0x%05X bytes", $size)),
543                              ($_->{'size'} >= $block_size ?
544                               sprintf("%d blocks", numBlocks($_->{'size'})) :
545                               sprintf("0x%05X bytes", $_->{'size'})),
546                              ($_->{'byteswap'} ? " (byte-swapped)" : ""));
547         }
548
549     } @partitions;
550
551     return;
552 }
553
554 # layoutPartitions : this function must be ugly - it needs to verify RedBoot, SysConf, Kernel, Ramdisk, and
555 #     FIS directory partitions exist, are in the correct order, and do not have more data than can fit in
556 #     their lengths (fixed for all but Ramdisk, which has a minimum length of one block).
557 #     If Rootdisk and/or Userdisk exist, it must also verify that their block padded lengths are not
558 #     too great for the available space.
559 # input : an array of hashes, some of which are populated with data
560 # output: same reference with start and size (partition not data) also populated. this populated structure
561 #         can then be passed to buildPartitionTable() to generate the actual partition table data
562 sub layoutPartitions {
563     my(@partitions) = @_;
564
565     # Find the kernel partition, and save a pointer to it for later use
566     my $kernel;
567     map { ($_->{'name'} eq "Kernel") && ($kernel = $_); } @partitions;
568     $kernel or die "Couldn't find the kernel partition\n";
569
570     # Find the last variable size partition, and save a pointer to it for later use
571     my $lastdisk;
572     my $directory_offset;
573     my $curdisk = $partitions[0];
574     map {
575         if (not defined $lastdisk) {
576             if ($_->{'name'} eq "FIS directory") {
577                 $lastdisk = $curdisk;
578                 $directory_offset = $_->{'offset'};
579             }
580             else {
581                 $curdisk = $_;
582             }
583         }
584     } @partitions;
585
586     $lastdisk or die "Couldn't find the last variable size partition\n";
587
588     $debug and printf("Last variable size partition is <%s>\n", $lastdisk->{'name'});
589
590     #
591     # here we go through the $partitions array ref and fill in all the values
592     #
593
594     # This points to where the next partition should be placed.
595     my $pointer = $flash_start;
596
597     map {
598
599         $debug and printf("Pointer is 0x%08X\n", $pointer);
600
601         # Determine the start and offset of the current partition.
602         if (defined $_->{'offset'}) {
603             $_->{'start'} = $flash_start + $_->{'offset'};
604             # Check for running past the defined start of the partition.
605             if (($pointer > $_->{'start'}) and not $_->{'pseudo'}) {
606                 die sprintf("Ran out of flash space before <%s> - %s too large.\n", $_->{'name'},
607                             sprintf("0x%05X bytes", ($pointer - $_->{'start'})));
608             }
609         }
610
611         # If offset is not defined, then calculate it.
612         else {
613             $_->{'start'} = $pointer;
614             $_->{'offset'} = $_->{'start'} - $flash_start;
615         }
616
617         my $size = defined $_->{'data'} ? length($_->{'data'}) : 0;
618
619         # Add skip regions for the partitions with headers.
620         if ($_->{'header'} > 0) {
621             # Define the skip region for the initial Sercomm header.
622             push(@{$_->{'skips'}},
623                  { 'offset' => 0, 'size' => $_->{'header'}, 'data' => undef });
624             # Allow for the Sercomm header to be prepended to the data.
625             $size += $_->{'header'};
626
627             # Determine if the partition overlaps the ramdisk boundary.
628             if (($_->{'offset'} < $ramdisk_offset) and
629                 (($_->{'offset'} + $size) > $ramdisk_offset)) {
630                 # Define the skip region for the inline Sercomm header.
631                 push(@{$_->{'skips'}},
632                      { 'offset' => ($ramdisk_offset - $_->{'offset'}), 'size' => 16,
633                        'data' => pack("N4", $block_size) });
634                 # Allow for the Sercomm header to be inserted in the data.
635                 $size += 16;
636             }
637         }
638
639         # Partitions without headers cannot have skip regions.
640         elsif (($_->{'offset'} <= $ramdisk_offset) and
641                (($_->{'offset'} + $size) > $ramdisk_offset)) {
642             # Pad the kernel until it extends past the ramdisk offset.
643             push(@{$kernel->{'skips'}},
644                  { 'offset' => ($ramdisk_offset - $kernel->{'offset'}), 'size' => 16,
645                    'data' => pack("N4", $block_size) });
646             $kernel->{'size'} = $ramdisk_offset - $kernel->{'offset'} + $block_size;
647             $kernel->{'data'} = padBytes($kernel->{'data'},
648                                          $kernel->{'size'} - $kernel->{'header'} - 16);
649             $_->{'offset'} = $ramdisk_offset + $block_size;
650             $_->{'start'} = $flash_start + $_->{'offset'};
651             $pointer = $_->{'start'};
652             $debug and printf("Extending kernel partition past ramdisk offset.\n");
653         }
654
655         # If this is the last variable size partition, then fill the rest of the space.
656         if ($_->{'name'} eq $lastdisk->{'name'}) {
657             $_->{'size'} = paddedSize($directory_offset + $flash_start - $pointer);
658             $debug and printf("Padding last variable partition <%s> to 0x%08X bytes\n", $_->{'name'}, $_->{'size'});
659         }
660
661         die sprintf("Partition size not defined in <%s>.\n", $_->{'name'})
662             unless defined $_->{'size'};
663
664         # Extend to another block if required.
665         if ($size > $_->{'size'}) {
666             if ($_->{'name'} eq $lastdisk->{'name'}) {
667                 die sprintf("Ran out of flash space in <%s> - %s too large.\n", $_->{'name'},
668                             sprintf("0x%05X bytes", ($size - $_->{'size'})));
669             }
670             $_->{'size'} = $size;
671             printf("Extending partition <%s> to 0x%08X bytes\n", $_->{'name'}, $_->{'size'});
672         }
673
674         # Keep the user appraised ...
675         $debug and printf("Allocated <%s> from 0x%08X to 0x%08X (%s / %s)\n",
676                           $_->{'name'}, $_->{'start'}, $_->{'start'} + $_->{'size'},
677                           ($size >= $block_size ?
678                            sprintf("%d blocks", numBlocks($size)) :
679                            sprintf("0x%05X bytes", $size)),
680                           ($_->{'size'} >= $block_size ?
681                            sprintf("%d blocks", numBlocks($_->{'size'})) :
682                            sprintf("0x%05X bytes", $_->{'size'})));
683
684         # Check to make sure we have not run out of room.
685         if (($_->{'start'} + $_->{'size'}) > ($flash_start + $flash_len)) {
686             die "Ran out of flash space in <", $_->{'name'}, ">\n";
687         }
688
689         $debug and printf("Moving pointer from 0x%08X to 0x%08X (0x%08X + 0x%08X)\n",
690                           $pointer, paddedSize($_->{'start'} + $_->{'size'}),
691                           $_->{'start'}, $_->{'size'});
692
693         # Move the pointer up, in preparation for the next partition.
694         $pointer = paddedSize($_->{'start'} + $_->{'size'});
695
696     } @partitions;
697
698     return;
699 }
700
701 sub buildPartitionTable {
702     my(@partitions) = @_;
703
704     my($flash_start) = 0x50000000;
705     my($partition_data) = '';
706
707     map {
708
709         # Collate the partition data for all known partitions.
710         if (not $_->{'pseudo'} and defined $_->{'offset'} and defined $_->{'size'}) {
711
712             # Pack and append the binary table entry for this partition.
713             $partition_data .= createPartitionEntry($_->{'name'}, $_->{'offset'} + $flash_start,
714                                                     $_->{'size'}, $_->{'skips'});
715
716             # If this is the FIS directory, then write the partition table data into it.
717             if ($_->{'name'} eq "FIS directory") {
718                 # Explicitly terminate the partition data.
719                 $partition_data .= pack("C",0xff) x 0x100;
720                 $_->{'data'} = padBytes($partition_data, $_->{'size'});
721             }
722
723             my $size = length($_->{'data'});
724
725             # Keep the user appraised ...
726             $debug and printf("Table entry <%s> from 0x%08X to 0x%08X (%s / %s)%s\n",
727                               $_->{'name'}, $_->{'start'}, $_->{'start'} + $_->{'size'},
728                               ($size >= $block_size ?
729                                sprintf("%d blocks", numBlocks($size)) :
730                                sprintf("0x%05X bytes", $size)),
731                               ($_->{'size'} >= $block_size ?
732                                sprintf("%d blocks", numBlocks($_->{'size'})) :
733                                sprintf("0x%05X bytes", $_->{'size'})),
734                               (defined $_->{'skips'} ?
735                                sprintf("\nTable entry <%s> skip %s", $_->{'name'},
736                                        join(", ",
737                                             map { sprintf("0x%08X to 0x%08X", $_->{'offset'},
738                                                           $_->{'offset'} + $_->{'size'} - 1) }
739                                             @{$_->{'skips'}})) :
740                                "")
741                               );
742         }
743         else {
744             $debug and print "No table entry required for <", $_->{'name'}, ">\n";
745         }
746
747     } @partitions;
748
749     return;
750 }
751
752 sub writeOutFirmware {
753     my($filename, @partitions) = @_;
754
755     # Clear the image to start.
756     my $image_buf = "";
757
758     map {
759
760         # We can only write a partition if it has an offset, a size, and some data to write.
761         if (defined $_->{'offset'} and defined $_->{'size'} and defined $_->{'data'}) {
762
763             # Keep track of the end of the image.
764             my $end_point = length($image_buf);
765
766             # If the next partition is well past the end of the current image, then pad it.
767             if ($_->{'offset'} > $end_point) {
768                 $image_buf .= padBytes("", $_->{'offset'} - $end_point);
769                 $quiet or printf("Padded %s before <%s> in \"%s\"\n",
770                                  ((length($image_buf) - $end_point) >= $block_size ?
771                                   sprintf("%d blocks", numBlocks(length($image_buf) - $end_point)) :
772                                   sprintf("0x%05X bytes", length($image_buf) - $end_point)),
773                                  $_->{'name'}, $filename);
774             }
775
776             # If the next parition is before the end of the current image, then rewind.
777             elsif ($_->{'offset'} < $end_point) {
778                 $debug and printf("Rewound %s before <%s> in \"%s\"\n",
779                                   (($end_point - $_->{'offset'}) >= $block_size ?
780                                    sprintf("%d blocks", numBlocks($end_point - $_->{'offset'})) :
781                                    sprintf("0x%05X bytes", $end_point - $_->{'offset'})),
782                                   $_->{'name'}, $filename);
783 #               if (($end_point - $_->{'offset'}) >= $block_size) {
784 #                   die "Allocation error: rewound a full block or more ...\n";
785 #               }
786             }
787
788             # If skip regions are defined, add them to the data.
789             if (defined $_->{'skips'}) {
790                 my $added = 0;
791                 foreach my $region (@{$_->{'skips'}}) {
792                     if (($region->{'offset'} > 0) or
793                         not ($_->{'header'} > 0)) {
794                         $debug and printf("Inserted 0x%05X bytes (at offset 0x%05X) into <%s>\n",
795                                           $region->{'size'}, $region->{'offset'}, $_->{'name'});
796                         substr($_->{'data'},
797                                $region->{'offset'} + $added - $_->{'header'},
798                                0, $region->{'data'});
799                         $added += $region->{'size'};
800                     }
801                 }
802             }
803
804             # Splice the data into the image at the appropriate place, padding as required.
805             substr($image_buf, $_->{'offset'}, $_->{'size'},
806                    $_->{'header'} ?
807                    padBytes(pack("N4",length($_->{'data'})).$_->{'data'}, $_->{'size'}) :
808                    padBytes($_->{'data'}, $_->{'size'}));
809             
810             # Keep the user appraised ...
811             $quiet or printf("Wrote %s (0x%08X to 0x%08X) from <%s> into \"%s\"\n",
812                              ($_->{'size'} >= $block_size ?
813                               sprintf("%2d blocks", numBlocks($_->{'size'})) :
814                               sprintf("0x%05X bytes", $_->{'size'})),
815                              $_->{'offset'}, $_->{'offset'}+$_->{'size'}, $_->{'name'}, $filename);
816         }
817
818         # If we are not able to write a partition, then give debug information about why.
819         else {
820             $debug and printf("Skipping <%s> (%s)\n", $_->{'name'},
821                               (not defined $_->{'offset'}) ? "no offset defined" :
822                               ((not defined $_->{'size'}) ? "no size defined" :
823                                "no data available"));
824         }
825
826     } @partitions;
827
828     # Write the image to the specified file.
829     writeOut($image_buf, $filename);
830
831     return;
832 }
833
834 # checkPartitionTable: sanity check partition table - for testing but might evolve into setting @partitions
835 #    so that we can write out jffs2 partitions from a read image
836 #    currently not nearly paranoid enough
837 sub checkPartitionTable {
838     my($data) = @_;
839
840     my($pointer) = 0;
841     my($entry);
842
843     my($name, $flash_base, $size, $done, $dummy_long, $padding);
844     do {
845         $entry = substr($data, $pointer, 0x100);
846
847         ($name,$flash_base,$dummy_long,$size,$dummy_long,$dummy_long,$padding,$dummy_long,$dummy_long) = unpack("a16N5x212N2",$entry);
848         $name =~ s/\0//g;
849         $debug and printf("pointer: %d\tname: %s%sflash_base: 0x%08X\tsize: 0x%08X\n",
850                           $pointer, $name, (" " x (16 - length($name))), $flash_base, $size);
851         $pointer += 0x100;
852         $debug and printf("terminator: 0x%08X\n", unpack("C", substr($data, $pointer, 1)));
853         if (unpack("C", substr($data, $pointer, 1)) eq 0xff) {
854             $done = 1;
855         }
856     } until $done;
857 }
858
859 sub printPartitions {
860     my(@partitions) = @_;
861
862     my($offset, $size, $skips);
863     map {
864 #       defined $_->{'size'} ? $size = $_->{'size'} : $size = undef;
865
866         if (defined  $_->{'size'}) {
867             $size = $_->{'size'};
868         }
869         else {
870             $size = undef;
871         }
872         if (defined  $_->{'offset'}) {
873             $offset = $_->{'offset'};
874         }
875         else {
876             $offset = undef;
877         }
878         if (defined  $_->{'skips'}) {
879             $skips = $_->{'skips'};
880         }
881         else {
882             $skips = undef;
883         }
884         printf("%s%s", $_->{'name'}, (" " x (16 - length($_->{'name'}))));
885         if (defined $offset) { printf("0x%08X\t", $offset); } else { printf("(undefined)\t");   };
886         if (defined $size)   { printf("0x%08X", $size); } else { printf("(undefined)"); };
887         if (defined $skips) {
888             printf("\t[%s]",
889                    join(", ",
890                         map { sprintf("0x%05X/0x%05X", $_->{'offset'}, $_->{'size'}); }
891                         @$skips));
892         }
893         printf("\n");
894     } @partitions;
895 }
896
897 sub defaultPartitions {
898
899     return ({'name'=>'RedBoot',          'file'=>'RedBoot',
900              'offset'=>0x00000000,        'size'=>0x00040000,
901              'variable'=>0, 'header'=>0,  'pseudo'=>0, 'data'=>undef, 'byteswap'=>0},
902             {'name'=>'EthAddr',           'file'=>undef,
903              'offset'=>0x0003ffb0,        'size'=>0x00000006,
904              'variable'=>0, 'header'=>0,  'pseudo'=>1, 'data'=>undef, 'byteswap'=>0},
905             {'name'=>'SysConf',           'file'=>'SysConf',
906              'offset'=>0x00040000,        'size'=>0x00020000,
907              'variable'=>0, 'header'=>0,  'pseudo'=>0, 'data'=>undef, 'byteswap'=>0},
908             {'name'=>'Loader',            'file'=>'apex.bin',
909              'offset'=>undef,             'size'=>undef,
910              'variable'=>1, 'header'=>16, 'pseudo'=>0, 'data'=>undef, 'byteswap'=>0},
911             {'name'=>'Kernel',            'file'=>'vmlinuz',
912              'offset'=>undef,             'size'=>undef,
913              'variable'=>1, 'header'=>16, 'pseudo'=>0, 'data'=>undef, 'byteswap'=>0},
914             {'name'=>'Ramdisk',           'file'=>'ramdisk.gz',
915              'offset'=>undef,             'size'=>undef,
916              'variable'=>1, 'header'=>16, 'pseudo'=>0, 'data'=>undef, 'byteswap'=>0},
917             {'name'=>'FIS directory',     'file'=>undef,
918              'offset'=>0x007e0000,        'size'=>0x00020000,
919              'variable'=>0, 'header'=>0,  'pseudo'=>0, 'data'=>undef, 'byteswap'=>0},
920             {'name'=>'Loader config',     'file'=>undef,
921              'offset'=>0x007f8000,        'size'=>0x00004000,
922              'variable'=>0, 'header'=>0,  'pseudo'=>1, 'data'=>undef, 'byteswap'=>0},
923             {'name'=>'Microcode',         'file'=>'NPE-B',
924              'offset'=>0x007fc000,        'size'=>0x00003000,
925              'variable'=>0, 'header'=>16, 'pseudo'=>1, 'data'=>undef, 'byteswap'=>0},
926             {'name'=>'Trailer',           'file'=>'Trailer',
927              'offset'=>0x007ffff0,        'size'=>0x00000010,
928              'variable'=>0, 'header'=>0,  'pseudo'=>1, 'data'=>undef, 'byteswap'=>0});
929 }
930
931 # Main routine starts here ...
932
933 my($unpack, $pack, $little, $input, $output, $redboot);
934 my($kernel, $sysconf, $ramdisk, $fisdir);
935 my($microcode, $trailer, $ethaddr, $loader);
936
937 END {
938     # Remove temporary files
939     for my $file (@cleanup) {
940         unlink $file;
941     }
942 }
943
944 if (!GetOptions("d|debug"       => \$debug,
945                 "q|quiet"       => \$quiet,
946                 "u|unpack"      => \$unpack,
947                 "p|pack"        => \$pack,
948                 "l|little"      => \$little,
949                 "i|input=s"     => \$input,
950                 "o|output=s"    => \$output,
951                 "b|redboot=s"   => \$redboot,
952                 "k|kernel=s"    => \$kernel,
953                 "s|sysconf=s"   => \$sysconf,
954                 "r|ramdisk=s"   => \$ramdisk,
955                 "f|fisdir=s"    => \$fisdir,
956                 "m|microcode=s" => \$microcode,
957                 "t|trailer=s"   => \$trailer,
958                 "e|ethaddr=s"   => \$ethaddr,
959                 "L|loader=s"    => \$loader,
960                 ) or (not defined $pack and not defined $unpack)) {
961     print "Usage: slugimage <options>\n";
962     print "\n";
963     print "  [-d|--debug]                       Turn on debugging output\n";
964     print "  [-q|--quiet]                       Turn off status messages\n";
965     print "  [-u|--unpack]                      Unpack a firmware image\n";
966     print "  [-p|--pack]                        Pack a firmware image\n";
967     print "  [-l|--little]                      Convert Kernel and Ramdisk to little-endian\n";
968     print "  [-i|--input]     <file>            Input firmware image filename\n";
969     print "  [-o|--output]    <file>            Output firmware image filename\n";
970     print "  [-b|--redboot]   <file>            Input/Output RedBoot filename\n";
971     print "  [-s|--sysconf]   <file>            Input/Output SysConf filename\n";
972     print "  [-L|--loader]    <file>            Second stage boot loader filename\n";
973     print "  [-k|--kernel]    <file>            Input/Ouptut Kernel filename\n";
974     print "  [-r|--ramdisk]   <file>            Input/Output Ramdisk filename(s)\n";
975     print "  [-f|--fisdir]    <file>            Input/Output FIS directory filename\n";
976     print "  [-m|--microcode] <file>            Input/Output Microcode filename\n";
977     print "  [-t|--trailer]   <file>            Input/Output Trailer filename\n";
978     print "  [-e|--ethaddr]   <AABBCCDDEEFF>    Set the Ethernet address\n";
979
980     # %%% TODO %%% Document --ramdisk syntax
981
982     exit 1;
983 }
984
985 my(@partitions) = defaultPartitions();
986
987 if ($pack) {
988     die "Output filename must be specified\n" unless defined $output;
989
990     # If we're creating an image and no RedBoot, SysConf partition is
991     # explicitly specified, simply write an empty one as the upgrade tools
992     # don't touch RedBoot and SysConf anyway.  If no Trailer is specified,
993     # put in one.
994     if (not defined $redboot and not -e "RedBoot") {
995         $redboot = tmpnam();
996         open TMP, ">$redboot" or die "Cannot open file $redboot: $!";
997         push @cleanup, $redboot;
998         # The RedBoot partition is 256 * 1024 = 262144; the trailer we add
999         # is 70 bytes.
1000         print TMP "\0"x(262144-70);
1001         # Upgrade tools check for an appropriate Sercomm trailer.
1002         for my $i (@sercomm_redboot_trailer) {
1003             print TMP pack "S", $i;
1004         }
1005         close TMP;
1006     }
1007     if (not defined $sysconf and not -e "SysConf") {
1008         $sysconf = tmpnam();
1009         open TMP, ">$sysconf" or die "Cannot open file $sysconf: $!";
1010         push @cleanup, $sysconf;
1011         # The SysConf partition is 128 * 1024 = 131072
1012         print TMP "\0"x131072;
1013         close TMP;
1014     }
1015     if (not defined $trailer and not -e "Trailer") {
1016         $trailer = tmpnam();
1017         open TMP, ">$trailer" or die "Cannot open file $trailer: $!";
1018         push @cleanup, $trailer;
1019         for my $i (@sercomm_flash_trailer) {
1020             print TMP pack "S", $i;
1021         }
1022         close TMP;
1023     }
1024
1025     # If the microcode was not specified, then don't complain that it's missing.
1026     if (not defined $microcode and not -e "NPE-B") {
1027         map { ($_->{'name'} eq 'Microcode') && ($_->{'file'} = undef);   } @partitions;
1028     }
1029 }
1030
1031 # Go through the partition options, and set the names and files in @partitions
1032 if (defined $redboot)   { map { ($_->{'name'} eq 'RedBoot')       && ($_->{'file'} = $redboot);   } @partitions; }
1033 if (defined $sysconf)   { map { ($_->{'name'} eq 'SysConf')       && ($_->{'file'} = $sysconf);   } @partitions; }
1034 if (defined $loader)    { map { ($_->{'name'} eq 'Loader')        && ($_->{'file'} = $loader);    } @partitions; }
1035 if (defined $kernel)    { map { ($_->{'name'} eq 'Kernel')        && ($_->{'file'} = $kernel);    } @partitions; }
1036 if (defined $fisdir)    { map { ($_->{'name'} eq 'FIS directory') && ($_->{'file'} = $fisdir);    } @partitions; }
1037 if (defined $microcode) { map { ($_->{'name'} eq 'Microcode')     && ($_->{'file'} = $microcode); } @partitions; }
1038 if (defined $trailer)   { map { ($_->{'name'} eq 'Trailer')       && ($_->{'file'} = $trailer);   } @partitions; }
1039
1040 if (defined $little)  {
1041     map {
1042         if (($_->{'name'} eq 'Loader') or
1043             ($_->{'name'} eq 'Kernel') or
1044             ($_->{'name'} eq 'Ramdisk')) {
1045             $_->{'byteswap'} = 1;
1046         }
1047     } @partitions;
1048 }
1049
1050 if (defined $ethaddr) {
1051     map {
1052         if ($_->{'name'} eq 'EthAddr') {
1053             $ethaddr =~ s/://g;
1054             if (($ethaddr !~ m/^[0-9A-Fa-f]+$/) or (length($ethaddr) != 12)) {
1055                 die "Invalid ethernet address specification: '".$ethaddr."'\n";
1056             }
1057             $_->{'data'} = pack("H12", $ethaddr);
1058         }
1059     } @partitions;
1060 }
1061
1062 if (defined $ramdisk) {
1063
1064     # A single filename is used for the ramdisk filename
1065     if ($ramdisk !~ m/[:,]/) {
1066         map { ($_->{'name'} eq 'Ramdisk') && ($_->{'file'} = $ramdisk); } @partitions;
1067     }
1068
1069     # otherwise, it's a list of name:file mappings
1070     else {
1071         my @mappings = split(',', $ramdisk);
1072
1073         # Find the index of the Ramdisk entry
1074         my $index;
1075         my $count = 0;
1076         map {
1077             if (not defined $index) {
1078                 if ($_->{'name'} eq "Ramdisk") {
1079                     $index = $count;
1080                 }
1081                 $count++;
1082             }
1083         } @partitions;
1084
1085         defined $index or die "Cannot find the Ramdisk partition\n";
1086
1087         # Replace the Ramdisk entry with the new mappings
1088         splice(@partitions, $index, 1, map {
1089
1090             # Preserve the information from the ramdisk entry
1091             my %entry = %{$partitions[$index]};
1092
1093             # Parse the mapping
1094             ($_ =~ m/^([^:]+):([^:]+)(:([^:]+))?$/) or die "Invalid syntax in --ramdisk\n";
1095             $entry{'name'} = $1; $entry{'file'} = $2; my $size = $4;
1096
1097             # If the mapping is not for the ramdisk, then undefine its attributes
1098             if ($entry{'name'} ne 'Ramdisk') {
1099                 $entry{'offset'} = undef;
1100                 $entry{'size'} = undef;
1101                 $entry{'variable'} = 1;
1102                 $entry{'header'} = 0;
1103                 $entry{'pseudo'} = 0;
1104                 $entry{'data'} = undef;
1105                 $entry{'byteswap'} = 0;
1106             }
1107
1108             # Support specification of the number of blocks for empty jffs2
1109             if ($entry{'file'} =~ m/^[0-9]+$/) {
1110                 $size = $entry{'file'};
1111                 $entry{'file'} = undef;
1112             }
1113
1114             # If the user has specified a size, then respect their wishes
1115             if (defined $size) {
1116                 $entry{'size'} = $size * $block_size;
1117                 # Create an empty partition of the requested size.
1118                 $entry{'data'} = padBytes("", $entry{'size'} - $entry{'header'});
1119             }
1120
1121             \%entry;
1122
1123         } @mappings);
1124     }
1125 }
1126
1127 # Read in the firmware image
1128 if ($input) {
1129     if ($debug) {
1130         print "Initial partition map:\n";
1131         printPartitions(@partitions);
1132     }
1133     
1134     my $result = readInFirmware($input, \@partitions);
1135
1136     if ($debug) {
1137         print "After reading firmware:\n";
1138         printPartitions(@partitions);
1139     }
1140 }
1141
1142 # Unpack the firmware if requested
1143 if ($unpack) {
1144     die "Input filename must be specified\n" unless defined $input;
1145
1146 #    map {
1147 #       ($_->{'name'} eq 'FIS directory') and @partitions = checkPartitionTable($_->{'data'});
1148 #    } @partitions;
1149
1150     writeOutFirmwareParts(@partitions);
1151
1152 }
1153
1154 # Pack the firmware if requested
1155 if ($pack) {
1156
1157     if (!defined $loader) {
1158         removeOptionalLoader(\@partitions);
1159     }
1160
1161     if ($debug) {
1162         print "Initial partition map:\n";
1163         printPartitions(@partitions);
1164     }
1165     
1166     my $result = readInFirmwareParts(@partitions);
1167
1168     if ($debug) {
1169         print "after readInFirmwareParts():\n";
1170         printPartitions(@partitions);
1171 #       map {
1172 #           ($_->{'name'} eq 'RedBoot') && (printRedbootTrailer($_->{'data'}));
1173 #       } @partitions;
1174     }
1175     
1176     layoutPartitions(@partitions);
1177
1178     if ($debug) {
1179         print "after layoutPartitions():\n";
1180         printPartitions(@partitions);
1181     }
1182     
1183     buildPartitionTable(@partitions);
1184
1185     if ($debug) {
1186         print "after buildPartitionTable():\n";
1187         printPartitions(@partitions);
1188
1189 #       my($lastblock);
1190 #       map {
1191 #           if ($_->{'name'} eq 'FIS directory') {
1192 #               $lastblock = $_->{'data'};
1193 #           }
1194 #       } @partitions;
1195
1196 #       print "checkPartitionTable():\n";
1197 #       checkPartitionTable($lastblock);
1198     }
1199     
1200     writeOutFirmware($output, @partitions);
1201
1202 }
1203
1204 exit 0;