Utility for creating installable image for the NSLU2.
[openwrt/svn-archive/archive.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 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;