GNU Linux-libre 4.14.266-gnu1
[releases.git] / arch / powerpc / boot / wrapper
1 #!/bin/sh
2
3 # Copyright (C) 2006 Paul Mackerras, IBM Corporation <paulus@samba.org>
4 # This program may be used under the terms of version 2 of the GNU
5 # General Public License.
6
7 # This script takes a kernel binary and optionally an initrd image
8 # and/or a device-tree blob, and creates a bootable zImage for a
9 # given platform.
10
11 # Options:
12 # -o zImage     specify output file
13 # -p platform   specify platform (links in $platform.o)
14 # -i initrd     specify initrd file
15 # -d devtree    specify device-tree blob
16 # -s tree.dts   specify device-tree source file (needs dtc installed)
17 # -c            cache $kernel.strip.gz (use if present & newer, else make)
18 # -C prefix     specify command prefix for cross-building tools
19 #               (strip, objcopy, ld)
20 # -D dir        specify directory containing data files used by script
21 #               (default ./arch/powerpc/boot)
22 # -W dir        specify working directory for temporary files (default .)
23 # -z            use gzip (legacy)
24 # -Z zsuffix    compression to use (gz, xz or none)
25
26 # Stop execution if any command fails
27 set -e
28
29 # Allow for verbose output
30 if [ "$V" = 1 ]; then
31     set -x
32 fi
33
34 # defaults
35 kernel=
36 ofile=zImage
37 platform=of
38 initrd=
39 dtb=
40 dts=
41 cacheit=
42 binary=
43 compression=.gz
44 pie=
45 format=
46
47 # cross-compilation prefix
48 CROSS=
49
50 # mkimage wrapper script
51 MKIMAGE=$srctree/scripts/mkuboot.sh
52
53 # directory for object and other files used by this script
54 object=arch/powerpc/boot
55 objbin=$object
56 dtc=scripts/dtc/dtc
57
58 # directory for working files
59 tmpdir=.
60
61 usage() {
62     echo 'Usage: wrapper [-o output] [-p platform] [-i initrd]' >&2
63     echo '       [-d devtree] [-s tree.dts] [-c] [-C cross-prefix]' >&2
64     echo '       [-D datadir] [-W workingdir] [-Z (gz|xz|none)]' >&2
65     echo '       [--no-compression] [vmlinux]' >&2
66     exit 1
67 }
68
69 run_cmd() {
70     if [ "$V" = 1 ]; then
71         $* 2>&1
72     else
73         local msg
74
75         set +e
76         msg=$($* 2>&1)
77
78         if [ $? -ne "0" ]; then
79                 echo $msg
80                 exit 1
81         fi
82         set -e
83     fi
84 }
85
86 while [ "$#" -gt 0 ]; do
87     case "$1" in
88     -o)
89         shift
90         [ "$#" -gt 0 ] || usage
91         ofile="$1"
92         ;;
93     -p)
94         shift
95         [ "$#" -gt 0 ] || usage
96         platform="$1"
97         ;;
98     -i)
99         shift
100         [ "$#" -gt 0 ] || usage
101         initrd="$1"
102         ;;
103     -d)
104         shift
105         [ "$#" -gt 0 ] || usage
106         dtb="$1"
107         ;;
108     -s)
109         shift
110         [ "$#" -gt 0 ] || usage
111         dts="$1"
112         ;;
113     -c)
114         cacheit=y
115         ;;
116     -C)
117         shift
118         [ "$#" -gt 0 ] || usage
119         CROSS="$1"
120         ;;
121     -D)
122         shift
123         [ "$#" -gt 0 ] || usage
124         object="$1"
125         objbin="$1"
126         ;;
127     -W)
128         shift
129         [ "$#" -gt 0 ] || usage
130         tmpdir="$1"
131         ;;
132     -z)
133         compression=.gz
134         ;;
135     -Z)
136         shift
137         [ "$#" -gt 0 ] || usage
138         [ "$1" != "gz" -o "$1" != "xz" -o "$1" != "none" ] || usage
139
140         compression=".$1"
141
142         if [ $compression = ".none" ]; then
143                 compression=
144         fi
145         ;;
146     --no-gzip)
147         # a "feature" of the the wrapper script is that it can be used outside
148         # the kernel tree. So keeping this around for backwards compatibility.
149         compression=
150         ;;
151     -?)
152         usage
153         ;;
154     *)
155         [ -z "$kernel" ] || usage
156         kernel="$1"
157         ;;
158     esac
159     shift
160 done
161
162
163 if [ -n "$dts" ]; then
164     if [ ! -r "$dts" -a -r "$object/dts/$dts" ]; then
165         dts="$object/dts/$dts"
166     fi
167     if [ -z "$dtb" ]; then
168         dtb="$platform.dtb"
169     fi
170     $dtc -O dtb -o "$dtb" -b 0 "$dts"
171 fi
172
173 if [ -z "$kernel" ]; then
174     kernel=vmlinux
175 fi
176
177 LANG=C elfformat="`${CROSS}objdump -p "$kernel" | grep 'file format' | awk '{print $4}'`"
178 case "$elfformat" in
179     elf64-powerpcle)    format=elf64lppc        ;;
180     elf64-powerpc)      format=elf32ppc ;;
181     elf32-powerpc)      format=elf32ppc ;;
182 esac
183
184 ld_version()
185 {
186     # Poached from scripts/ld-version.sh, but we don't want to call that because
187     # this script (wrapper) is distributed separately from the kernel source.
188     # Extract linker version number from stdin and turn into single number.
189     awk '{
190         gsub(".*\\)", "");
191         gsub(".*version ", "");
192         gsub("-.*", "");
193         split($1,a, ".");
194         print a[1]*100000000 + a[2]*1000000 + a[3]*10000;
195         exit
196     }'
197 }
198
199 # Do not include PT_INTERP segment when linking pie. Non-pie linking
200 # just ignores this option.
201 LD_VERSION=$(${CROSS}ld --version | ld_version)
202 LD_NO_DL_MIN_VERSION=$(echo 2.26 | ld_version)
203 if [ "$LD_VERSION" -ge "$LD_NO_DL_MIN_VERSION" ] ; then
204         nodl="--no-dynamic-linker"
205 fi
206
207 platformo=$object/"$platform".o
208 lds=$object/zImage.lds
209 ext=strip
210 objflags=-S
211 tmp=$tmpdir/zImage.$$.o
212 ksection=.kernel:vmlinux.strip
213 isection=.kernel:initrd
214 link_address='0x400000'
215 make_space=y
216
217 case "$platform" in
218 of)
219     platformo="$object/of.o $object/epapr.o"
220     make_space=n
221     ;;
222 pseries)
223     platformo="$object/pseries-head.o $object/of.o $object/epapr.o"
224     link_address='0x4000000'
225     if [ "$format" != "elf32ppc" ]; then
226         link_address=
227         pie=-pie
228     fi
229     make_space=n
230     ;;
231 maple)
232     platformo="$object/of.o $object/epapr.o"
233     link_address='0x400000'
234     make_space=n
235     ;;
236 pmac|chrp)
237     platformo="$object/of.o $object/epapr.o"
238     make_space=n
239     ;;
240 coff)
241     platformo="$object/crt0.o $object/of.o $object/epapr.o"
242     lds=$object/zImage.coff.lds
243     link_address='0x500000'
244     make_space=n
245     pie=
246     ;;
247 miboot|uboot*)
248     # miboot and U-boot want just the bare bits, not an ELF binary
249     ext=bin
250     objflags="-O binary"
251     tmp="$ofile"
252     ksection=image
253     isection=initrd
254     ;;
255 cuboot*)
256     binary=y
257     compression=
258     case "$platform" in
259     *-mpc866ads|*-mpc885ads|*-adder875*|*-ep88xc)
260         platformo=$object/cuboot-8xx.o
261         ;;
262     *5200*|*-motionpro)
263         platformo=$object/cuboot-52xx.o
264         ;;
265     *-pq2fads|*-ep8248e|*-mpc8272*|*-storcenter)
266         platformo=$object/cuboot-pq2.o
267         ;;
268     *-mpc824*)
269         platformo=$object/cuboot-824x.o
270         ;;
271     *-mpc83*|*-asp834x*)
272         platformo=$object/cuboot-83xx.o
273         ;;
274     *-tqm8541|*-mpc8560*|*-tqm8560|*-tqm8555|*-ksi8560*)
275         platformo=$object/cuboot-85xx-cpm2.o
276         ;;
277     *-mpc85*|*-tqm85*|*-sbc85*)
278         platformo=$object/cuboot-85xx.o
279         ;;
280     *-amigaone)
281         link_address='0x800000'
282         ;;
283     esac
284     ;;
285 ps3)
286     platformo="$object/ps3-head.o $object/ps3-hvcall.o $object/ps3.o"
287     lds=$object/zImage.ps3.lds
288     compression=
289     ext=bin
290     objflags="-O binary --set-section-flags=.bss=contents,alloc,load,data"
291     ksection=.kernel:vmlinux.bin
292     isection=.kernel:initrd
293     link_address=''
294     make_space=n
295     pie=
296     ;;
297 ep88xc|ep405|ep8248e)
298     platformo="$object/fixed-head.o $object/$platform.o"
299     binary=y
300     ;;
301 adder875-redboot)
302     platformo="$object/fixed-head.o $object/redboot-8xx.o"
303     binary=y
304     ;;
305 simpleboot-virtex405-*)
306     platformo="$object/virtex405-head.o $object/simpleboot.o $object/virtex.o"
307     binary=y
308     ;;
309 simpleboot-virtex440-*)
310     platformo="$object/fixed-head.o $object/simpleboot.o $object/virtex.o"
311     binary=y
312     ;;
313 simpleboot-*)
314     platformo="$object/fixed-head.o $object/simpleboot.o"
315     binary=y
316     ;;
317 asp834x-redboot)
318     platformo="$object/fixed-head.o $object/redboot-83xx.o"
319     binary=y
320     ;;
321 xpedite52*)
322     link_address='0x1400000'
323     platformo=$object/cuboot-85xx.o
324     ;;
325 gamecube|wii)
326     link_address='0x600000'
327     platformo="$object/$platform-head.o $object/$platform.o"
328     ;;
329 treeboot-currituck)
330     link_address='0x1000000'
331     ;;
332 treeboot-akebono)
333     link_address='0x1000000'
334     ;;
335 treeboot-iss4xx-mpic)
336     platformo="$object/treeboot-iss4xx.o"
337     ;;
338 epapr)
339     platformo="$object/pseries-head.o $object/epapr.o $object/epapr-wrapper.o"
340     link_address='0x20000000'
341     pie=-pie
342     ;;
343 mvme5100)
344     platformo="$object/fixed-head.o $object/mvme5100.o"
345     binary=y
346     ;;
347 mvme7100)
348     platformo="$object/motload-head.o $object/mvme7100.o"
349     link_address='0x4000000'
350     binary=y
351     ;;
352 esac
353
354 vmz="$tmpdir/`basename \"$kernel\"`.$ext"
355
356 # Calculate the vmlinux.strip size
357 ${CROSS}objcopy $objflags "$kernel" "$vmz.$$"
358 strip_size=$(stat -c %s $vmz.$$)
359
360 if [ -z "$cacheit" -o ! -f "$vmz$compression" -o "$vmz$compression" -ot "$kernel" ]; then
361     # recompress the image if we need to
362     case $compression in
363     .xz)
364         xz --check=crc32 -f -6 "$vmz.$$"
365         ;;
366     .gz)
367         gzip -n -f -9 "$vmz.$$"
368         ;;
369     *)
370         # drop the compression suffix so the stripped vmlinux is used
371         compression=
372         ;;
373     esac
374
375     if [ -n "$cacheit" ]; then
376         mv -f "$vmz.$$$compression" "$vmz$compression"
377     else
378         vmz="$vmz.$$"
379     fi
380 else
381     rm -f $vmz.$$
382 fi
383
384 vmz="$vmz$compression"
385
386 if [ "$make_space" = "y" ]; then
387         # Round the size to next higher MB limit
388         round_size=$(((strip_size + 0xfffff) & 0xfff00000))
389
390         round_size=0x$(printf "%x" $round_size)
391         link_addr=$(printf "%d" $link_address)
392
393         if [ $link_addr -lt $strip_size ]; then
394             echo "INFO: Uncompressed kernel (size 0x$(printf "%x\n" $strip_size))" \
395                         "overlaps the address of the wrapper($link_address)"
396             echo "INFO: Fixing the link_address of wrapper to ($round_size)"
397             link_address=$round_size
398         fi
399 fi
400
401 # Extract kernel version information, some platforms want to include
402 # it in the image header
403 version=`${CROSS}strings "$kernel" | grep '^Linux version [-0-9.]' | \
404     cut -d' ' -f3`
405 if [ -n "$version" ]; then
406     uboot_version="-n Linux-$version"
407 fi
408
409 # physical offset of kernel image
410 membase=`${CROSS}objdump -p "$kernel" | grep -m 1 LOAD | awk '{print $7}'`
411
412 case "$platform" in
413 uboot)
414     rm -f "$ofile"
415     ${MKIMAGE} -A ppc -O linux -T kernel -C gzip -a $membase -e $membase \
416         $uboot_version -d "$vmz" "$ofile"
417     if [ -z "$cacheit" ]; then
418         rm -f "$vmz"
419     fi
420     exit 0
421     ;;
422 uboot-obs600)
423     rm -f "$ofile"
424     # obs600 wants a multi image with an initrd, so we need to put a fake
425     # one in even when building a "normal" image.
426     if [ -n "$initrd" ]; then
427         real_rd="$initrd"
428     else
429         real_rd=`mktemp`
430         echo "\0" >>"$real_rd"
431     fi
432     ${MKIMAGE} -A ppc -O linux -T multi -C gzip -a $membase -e $membase \
433         $uboot_version -d "$vmz":"$real_rd":"$dtb" "$ofile"
434     if [ -z "$initrd" ]; then
435         rm -f "$real_rd"
436     fi
437     if [ -z "$cacheit" ]; then
438         rm -f "$vmz"
439     fi
440     exit 0
441     ;;
442 esac
443
444 addsec() {
445     ${CROSS}objcopy $4 $1 \
446         --add-section=$3="$2" \
447         --set-section-flags=$3=contents,alloc,load,readonly,data
448 }
449
450 addsec $tmp "$vmz" $ksection $object/empty.o
451 if [ -z "$cacheit" ]; then
452     rm -f "$vmz"
453 fi
454
455 if [ -n "$initrd" ]; then
456     addsec $tmp "$initrd" $isection
457 fi
458
459 if [ -n "$dtb" ]; then
460     addsec $tmp "$dtb" .kernel:dtb
461     if [ -n "$dts" ]; then
462         rm $dtb
463     fi
464 fi
465
466 if [ "$platform" != "miboot" ]; then
467     if [ -n "$link_address" ] ; then
468         text_start="-Ttext $link_address"
469     fi
470 #link everything
471     ${CROSS}ld -m $format -T $lds $text_start $pie $nodl -o "$ofile" \
472         $platformo $tmp $object/wrapper.a
473     rm $tmp
474 fi
475
476 # Some platforms need the zImage's entry point and base address
477 base=0x`${CROSS}nm "$ofile" | grep ' _start$' | cut -d' ' -f1`
478 entry=`${CROSS}objdump -f "$ofile" | grep '^start address ' | cut -d' ' -f3`
479
480 if [ -n "$binary" ]; then
481     mv "$ofile" "$ofile".elf
482     ${CROSS}objcopy -O binary "$ofile".elf "$ofile"
483 fi
484
485 # post-processing needed for some platforms
486 case "$platform" in
487 pseries|chrp|maple)
488     $objbin/addnote "$ofile"
489     ;;
490 coff)
491     ${CROSS}objcopy -O aixcoff-rs6000 --set-start "$entry" "$ofile"
492     $objbin/hack-coff "$ofile"
493     ;;
494 cuboot*)
495     gzip -n -f -9 "$ofile"
496     ${MKIMAGE} -A ppc -O linux -T kernel -C gzip -a "$base" -e "$entry" \
497             $uboot_version -d "$ofile".gz "$ofile"
498     ;;
499 treeboot*)
500     mv "$ofile" "$ofile.elf"
501     $objbin/mktree "$ofile.elf" "$ofile" "$base" "$entry"
502     if [ -z "$cacheit" ]; then
503         rm -f "$ofile.elf"
504     fi
505     exit 0
506     ;;
507 ps3)
508     # The ps3's loader supports loading a gzipped binary image from flash
509     # rom to ram addr zero. The loader then enters the system reset
510     # vector at addr 0x100.  A bootwrapper overlay is used to arrange for
511     # a binary image of the kernel to be at addr zero, and yet have a
512     # suitable bootwrapper entry at 0x100.  To construct the final rom
513     # image 512 bytes from offset 0x100 is copied to the bootwrapper
514     # place holder at symbol __system_reset_kernel.  The 512 bytes of the
515     # bootwrapper entry code at symbol __system_reset_overlay is then
516     # copied to offset 0x100.  At runtime the bootwrapper program copies
517     # the data at __system_reset_kernel back to addr 0x100.
518
519     system_reset_overlay=0x`${CROSS}nm "$ofile" \
520         | grep ' __system_reset_overlay$'       \
521         | cut -d' ' -f1`
522     system_reset_overlay=`printf "%d" $system_reset_overlay`
523     system_reset_kernel=0x`${CROSS}nm "$ofile" \
524         | grep ' __system_reset_kernel$'       \
525         | cut -d' ' -f1`
526     system_reset_kernel=`printf "%d" $system_reset_kernel`
527     overlay_dest="256"
528     overlay_size="512"
529
530     ${CROSS}objcopy -O binary "$ofile" "$ofile.bin"
531
532     run_cmd dd if="$ofile.bin" of="$ofile.bin" conv=notrunc   \
533         skip=$overlay_dest seek=$system_reset_kernel          \
534         count=$overlay_size bs=1
535
536     run_cmd dd if="$ofile.bin" of="$ofile.bin" conv=notrunc   \
537         skip=$system_reset_overlay seek=$overlay_dest         \
538         count=$overlay_size bs=1
539
540     odir="$(dirname "$ofile.bin")"
541     rm -f "$odir/otheros.bld"
542     gzip -n --force -9 --stdout "$ofile.bin" > "$odir/otheros.bld"
543     ;;
544 esac