v2.4.4.5 -> v2.4.4.6

  - Johannes Erdfelt: OHCI hash-chain corruption fix, USB updates
  - Richard Henderson, Ivan Kokshaysky: alpha PCI iommu fixes
  - Tim Waugh: parport changelogs and printk levels
  - Andrew Morton: vmalloc off-by-one (overly sensitive) test
  - Al Viro: VFS layer cleanups
  - Cort Dougan: PPC updates (big bootloader re-org)
  - Alan Cox: more merges, remove phillips camera conversion code
  - Andrea Arkangeli: alpha fixups
  - OGAWA Hirofumi: big-sector support with FAT
  - Neil Brown: more md fixes

14 files changed, 1668 insertions, 0 deletions

diff --git a/arch/ppc/boot/utils/Makefile b/arch/ppc/boot/utils/Makefile
new file mode 100644
index 000000000000..c90c9ea1c60a
--- /dev/null
+++ b/arch/ppc/boot/utils/Makefile
@@ -0,0 +1,19 @@
+#
+# arch/ppc/boot/utils/Makefile
+#
+# This file is subject to the terms and conditions of the GNU General Public
+# License.  See the file "COPYING" in the main directory of this archive
+# for more details.
+
+HOSTCFLAGS += -I$(TOPDIR)/arch/$(ARCH)/boot/include
+
+# Simple programs with 1 file and no extra CFLAGS
+UTILS = addnote hack-coff mkprep mksimage mknote piggyback mkpmon mkbugboot
+
+$(UTILS):
+	$(HOSTCC) $(HOSTCFLAGS) -o $@ $@.c
+
+clean:
+	rm -f $(UTILS)
+
+include $(TOPDIR)/Rules.make
diff --git a/arch/ppc/boot/utils/addnote.c b/arch/ppc/boot/utils/addnote.c
new file mode 100644
index 000000000000..e18d44709ec0
--- /dev/null
+++ b/arch/ppc/boot/utils/addnote.c
@@ -0,0 +1,177 @@
+/*
+ * BK Id: SCCS/s.addnote.c 1.7 05/18/01 15:17:23 cort
+ */
+/*
+ * Program to hack in a PT_NOTE program header entry in an ELF file.
+ * This is needed for OF on RS/6000s to load an image correctly.
+ * Note that OF needs a program header entry for the note, not an
+ * ELF section.
+ *
+ * Copyright 2000 Paul Mackerras.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ * Usage: addnote zImage
+ */
+#include <stdio.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+
+char arch[] = "PowerPC";
+
+#define N_DESCR	6
+unsigned int descr[N_DESCR] = {
+#if 1
+	/* values for IBM RS/6000 machines */
+	0xffffffff,		/* real-mode = true */
+	0x00c00000,		/* real-base, i.e. where we expect OF to be */
+	0xffffffff,		/* real-size */
+	0xffffffff,		/* virt-base */
+	0xffffffff,		/* virt-size */
+	0x4000,			/* load-base */
+#else
+	/* values for longtrail CHRP */
+	0,			/* real-mode = false */
+	0xffffffff,		/* real-base */
+	0xffffffff,		/* real-size */
+	0xffffffff,		/* virt-base */
+	0xffffffff,		/* virt-size */
+	0x00600000,		/* load-base */
+#endif
+};
+
+unsigned char buf[512];
+
+#define GET_16BE(off)	((buf[off] << 8) + (buf[(off)+1]))
+#define GET_32BE(off)	((GET_16BE(off) << 16) + GET_16BE((off)+2))
+
+#define PUT_16BE(off, v)	(buf[off] = ((v) >> 8) & 0xff, \
+				 buf[(off) + 1] = (v) & 0xff)
+#define PUT_32BE(off, v)	(PUT_16BE((off), (v) >> 16), \
+				 PUT_16BE((off) + 2, (v)))
+
+/* Structure of an ELF file */
+#define E_IDENT		0	/* ELF header */
+#define	E_PHOFF		28
+#define E_PHENTSIZE	42
+#define E_PHNUM		44
+#define E_HSIZE		52	/* size of ELF header */
+
+#define EI_MAGIC	0	/* offsets in E_IDENT area */
+#define EI_CLASS	4
+#define EI_DATA		5
+
+#define PH_TYPE		0	/* ELF program header */
+#define PH_OFFSET	4
+#define PH_FILESZ	16
+#define PH_HSIZE	32	/* size of program header */
+
+#define PT_NOTE		4	/* Program header type = note */
+
+#define ELFCLASS32	1
+#define ELFDATA2MSB	2
+
+unsigned char elf_magic[4] = { 0x7f, 'E', 'L', 'F' };
+
+int main(int ac, char **av)
+{
+	int fd, n, i;
+	int ph, ps, np;
+	int nnote, ns;
+
+	if (ac != 2) {
+		fprintf(stderr, "Usage: %s elf-file\n", av[0]);
+		exit(1);
+	}
+	fd = open(av[1], O_RDWR);
+	if (fd < 0) {
+		perror(av[1]);
+		exit(1);
+	}
+
+	nnote = strlen(arch) + 1 + (N_DESCR + 3) * 4;
+
+	n = read(fd, buf, sizeof(buf));
+	if (n < 0) {
+		perror("read");
+		exit(1);
+	}
+
+	if (n < E_HSIZE || memcmp(&buf[E_IDENT+EI_MAGIC], elf_magic, 4) != 0)
+		goto notelf;
+
+	if (buf[E_IDENT+EI_CLASS] != ELFCLASS32
+	    || buf[E_IDENT+EI_DATA] != ELFDATA2MSB) {
+		fprintf(stderr, "%s is not a big-endian 32-bit ELF image\n",
+			av[1]);
+		exit(1);
+	}
+
+	ph = GET_32BE(E_PHOFF);
+	ps = GET_16BE(E_PHENTSIZE);
+	np = GET_16BE(E_PHNUM);
+	if (ph < E_HSIZE || ps < PH_HSIZE || np < 1)
+		goto notelf;
+	if (ph + (np + 1) * ps + nnote > n)
+		goto nospace;
+
+	for (i = 0; i < np; ++i) {
+		if (GET_32BE(ph + PH_TYPE) == PT_NOTE) {
+			fprintf(stderr, "%s already has a note entry\n",
+				av[1]);
+			exit(0);
+		}
+		ph += ps;
+	}
+
+	/* XXX check that the area we want to use is all zeroes */
+	for (i = 0; i < ps + nnote; ++i)
+		if (buf[ph + i] != 0)
+			goto nospace;
+
+	/* fill in the program header entry */
+	ns = ph + ps;
+	PUT_32BE(ph + PH_TYPE, PT_NOTE);
+	PUT_32BE(ph + PH_OFFSET, ns);
+	PUT_32BE(ph + PH_FILESZ, nnote);
+
+	/* fill in the note area we point to */
+	/* XXX we should probably make this a proper section */
+	PUT_32BE(ns, strlen(arch) + 1);
+	PUT_32BE(ns + 4, N_DESCR * 4);
+	PUT_32BE(ns + 8, 0x1275);
+	strcpy(&buf[ns + 12], arch);
+	ns += 12 + strlen(arch) + 1;
+	for (i = 0; i < N_DESCR; ++i)
+		PUT_32BE(ns + i * 4, descr[i]);
+
+	/* Update the number of program headers */
+	PUT_16BE(E_PHNUM, np + 1);
+
+	/* write back */
+	lseek(fd, (long) 0, SEEK_SET);
+	i = write(fd, buf, n);
+	if (i < 0) {
+		perror("write");
+		exit(1);
+	}
+	if (i < n) {
+		fprintf(stderr, "%s: write truncated\n", av[1]);
+		exit(1);
+	}
+
+	exit(0);
+
+ notelf:
+	fprintf(stderr, "%s does not appear to be an ELF file\n", av[0]);
+	exit(1);
+
+ nospace:
+	fprintf(stderr, "sorry, I can't find space in %s to put the note\n",
+		av[0]);
+	exit(1);
+}
diff --git a/arch/ppc/boot/utils/elf.pl b/arch/ppc/boot/utils/elf.pl
new file mode 100644
index 000000000000..d3e9d9d5b84e
--- /dev/null
+++ b/arch/ppc/boot/utils/elf.pl
@@ -0,0 +1,33 @@
+#
+# ELF header field numbers
+#
+
+$e_ident	=  0;	# Identification bytes / magic number
+$e_type		=  1;	# ELF file type
+$e_machine	=  2;	# Target machine type
+$e_version	=  3;	# File version
+$e_entry	=  4;	# Start address
+$e_phoff	=  5;	# Program header file offset
+$e_shoff	=  6;	# Section header file offset
+$e_flags	=  7;	# File flags
+$e_ehsize	=  8;	# Size of ELF header
+$e_phentsize	=  9;	# Size of program header
+$e_phnum	= 10;	# Number of program header entries
+$e_shentsize	= 11;	# Size of section header
+$e_shnum	= 12;	# Number of section header entries
+$e_shstrndx	= 13;	# Section header table string index
+
+#
+# Section header field numbers
+#
+
+$sh_name	=  0;	# Section name
+$sh_type	=  1;	# Section header type
+$sh_flags	=  2;	# Section header flags
+$sh_addr	=  3;	# Virtual address
+$sh_offset	=  4;	# File offset
+$sh_size	=  5;	# Section size
+$sh_link	=  6;	# Miscellaneous info
+$sh_info	=  7;	# More miscellaneous info
+$sh_addralign	=  8;	# Memory alignment
+$sh_entsize	=  9;	# Entry size if this is a table
diff --git a/arch/ppc/boot/utils/hack-coff.c b/arch/ppc/boot/utils/hack-coff.c
new file mode 100644
index 000000000000..f6395d1899f5
--- /dev/null
+++ b/arch/ppc/boot/utils/hack-coff.c
@@ -0,0 +1,85 @@
+/*
+ * BK Id: SCCS/s.hack-coff.c 1.8 05/18/01 06:20:29 patch
+ */
+/*
+ * hack-coff.c - hack the header of an xcoff file to fill in
+ * a few fields needed by the Open Firmware xcoff loader on
+ * Power Macs but not initialized by objcopy.
+ *
+ * Copyright (C) Paul Mackerras 1997.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include "rs6000.h"
+
+#define AOUT_MAGIC	0x010b
+
+#define get_16be(x)	((((unsigned char *)(x))[0] << 8) \
+			 + ((unsigned char *)(x))[1])
+#define put_16be(x, v)	(((unsigned char *)(x))[0] = (v) >> 8, \
+			 ((unsigned char *)(x))[1] = (v) & 0xff)
+#define get_32be(x)	((((unsigned char *)(x))[0] << 24) \
+			 + (((unsigned char *)(x))[1] << 16) \
+			 + (((unsigned char *)(x))[2] << 8) \
+			 + ((unsigned char *)(x))[3])
+
+int
+main(int ac, char **av)
+{
+    int fd;
+    int i, nsect;
+    int aoutsz;
+    struct external_filehdr fhdr;
+    AOUTHDR aout;
+    struct external_scnhdr shdr;
+
+    if (ac != 2) {
+	fprintf(stderr, "Usage: hack-coff coff-file\n");
+	exit(1);
+    }
+    if ((fd = open(av[1], 2)) == -1) {
+	perror(av[2]);
+	exit(1);
+    }
+    if (read(fd, &fhdr, sizeof(fhdr)) != sizeof(fhdr))
+	goto readerr;
+    i = get_16be(fhdr.f_magic);
+    if (i != U802TOCMAGIC && i != U802WRMAGIC && i != U802ROMAGIC) {
+	fprintf(stderr, "%s: not an xcoff file\n", av[1]);
+	exit(1);
+    }
+    aoutsz = get_16be(fhdr.f_opthdr);
+    if (read(fd, &aout, aoutsz) != aoutsz)
+	goto readerr;
+    nsect = get_16be(fhdr.f_nscns);
+    for (i = 0; i < nsect; ++i) {
+	if (read(fd, &shdr, sizeof(shdr)) != sizeof(shdr))
+	    goto readerr;
+	if (strcmp(shdr.s_name, ".text") == 0) {
+	    put_16be(aout.o_snentry, i+1);
+	    put_16be(aout.o_sntext, i+1);
+	} else if (strcmp(shdr.s_name, ".data") == 0) {
+	    put_16be(aout.o_sndata, i+1);
+	} else if (strcmp(shdr.s_name, ".bss") == 0) {
+	    put_16be(aout.o_snbss, i+1);
+	}
+    }
+    put_16be(aout.magic, AOUT_MAGIC);
+    if (lseek(fd, (long) sizeof(struct external_filehdr), 0) == -1
+	|| write(fd, &aout, aoutsz) != aoutsz) {
+	fprintf(stderr, "%s: write error\n", av[1]);
+	exit(1);
+    }
+    close(fd);
+    exit(0);
+
+readerr:
+    fprintf(stderr, "%s: read error or file too short\n", av[1]);
+    exit(1);
+}
diff --git a/arch/ppc/boot/utils/mkevimg b/arch/ppc/boot/utils/mkevimg
new file mode 100644
index 000000000000..195fd37d4916
--- /dev/null
+++ b/arch/ppc/boot/utils/mkevimg
@@ -0,0 +1,437 @@
+#!/usr/bin/perl
+
+#
+#    Copyright (c) 1998-1999 TiVo, Inc.
+#    All rights reserved.
+#
+#    Copyright (c) 1999 Grant Erickson <grant@lcse.umn.edu>
+#      Major syntactic and usability rework.
+#
+#    Module name: mkevimg
+#
+#    Description:
+#      Converts an ELF output file from the linker into the format used by
+#      the IBM evaluation board ROM Monitor to load programs from a host
+#      onto the evaluation board. The ELF file must be an otherwise execut-
+#      able file (with the text and data addresses bound at link time) and
+#      have space reserved after the entry point for the load information
+#      block:
+#
+#      typedef struct boot_block {
+#        unsigned long magic;	        0x0052504F
+#	 unsigned long dest;	        Target address of the image
+#	 unsigned long num_512blocks;   Size, rounded-up, in 512 byte blocks
+#	 unsigned long debug_flag;      Run the debugger or image after load
+#        unsigned long entry_point;	The image address to jump to after load
+#	 unsigned long reserved[3];
+#      } boot_block_t;
+#
+#   
+
+use File::Basename;
+use Getopt::Std;
+
+#
+# usage()
+#
+# Description:
+#   This routine prints out the proper command line usage for this program
+#
+# Input(s):
+#   status - Flag determining what usage information will be printed and what
+#            the exit status of the program will be after the information is
+#            printed.
+#
+# Output(s):
+#   N/A
+#
+# Returns:
+#   This subroutine does not return.
+#
+
+sub usage {
+  my($status);
+  $status = $_[0];
+
+  printf("Usage: %s [-hlvV] <ELF input file> <Evaluation board output file>\n",
+	$program);
+
+  if ($status != 0) {
+    printf("Try `%s -h' for more information.\n", $program);
+  }
+
+  if ($status != 1) {
+    print("  -h         Print out this message and exit.\n");
+    print("  -l         Linux mode; if present, copy 'image' and 'initrd' sections.\n");
+    print("  -v         Verbose. Print out lots of ELF information.\n");
+    print("  -V         Print out version information and exit.\n");
+  }
+
+  exit($status);
+}
+
+#
+# version()
+#
+# Description:
+#   This routine prints out program version information
+#
+# Input(s):
+#   N/A
+#
+# Output(s):
+#   N/A
+#
+# Returns:
+#   This subroutine does not return.
+#
+
+sub version {
+  print("mkevimg Version 1.1.0\n");
+  print("Copyright (c) 1998-1999 TiVo, Inc.\n");
+  print("Copyright (c) 1999 Grant Erickson <grant\@lcse.umn.edu>\n");
+
+  exit (0);
+}
+
+#
+# file_check()
+#
+# Description:
+#   This routine checks an input file to ensure that it exists, is a
+#   regular file, and is readable.
+#
+# Input(s):
+#   file - Input file to be checked.
+#
+# Output(s):
+#   N/A
+#
+# Returns:
+#   0 if the file exists, is a regular file, and is readable, otherwise -1.
+#
+
+sub file_check {
+  my($file);
+  $file = $_[0];
+
+  if (!(-e $file)) {
+    printf("The file \"%s\" does not exist.\n", $file);
+    return (-1);
+  } elsif (!(-f $file)) {
+    printf("The file \"%s\" is not a regular file.\n", $file);
+    return (-1);
+  } elsif (!(-r $file)) {
+    printf("The file \"%s\" is not readable.\n", $file);
+    return (-1);
+  }
+
+  return (0);
+}
+
+#
+# decode_options()
+#
+# Description:
+#   This routine steps through the command-line arguments, parsing out
+#   recognzied options.
+#
+# Input(s):
+#   N/A
+#
+# Output(s):
+#   N/A
+#
+# Returns:
+#   N/A
+#
+
+sub decode_options {
+
+  if (!getopts("hlvV")) {
+    usage(1);
+  }
+
+  if ($opt_h) {
+    usage(0);
+  }
+
+  if ($opt_l) {
+    $linux = 1;
+  }
+
+  if ($opt_V) {
+    version();
+    exit (0);
+  }
+
+  if ($opt_v) {
+    $verbose = 1;
+  }
+
+  if (!($ifile = shift(@ARGV))) {
+    usage(1);
+  }
+
+  if (!($ofile = shift(@ARGV))) {
+    usage (1);
+  }
+
+  if (file_check($ifile)) {
+    exit(1);
+  }
+
+}
+
+#
+# ELF file and section header field numbers
+#
+
+require '../utils/elf.pl';
+
+#
+# Main program body
+#
+
+{
+  $program = basename($0);
+
+  decode_options();
+
+  open(ELF, "<$ifile") || die "Cannot open input file";
+
+  $ifilesize = (-s $ifile);
+
+  if ($verbose) {
+    print("Output file: $ofile\n");
+    print("Input file: $ifile, $ifilesize bytes.\n");
+  }
+
+  if (read(ELF, $ibuf, $ifilesize) != $ifilesize) {
+    print("Failed to read input file!\n");
+    exit(1);
+  }
+
+  # 
+  # Parse ELF header
+  #
+
+  @eh = unpack("a16n2N5n6", $ibuf);
+
+  #
+  # Make sure this is actually a PowerPC ELF file.
+  #
+
+  if (substr($eh[$e_ident], 0, 4) ne "\177ELF") {
+    printf("The file \"%s\" is not an ELF file.\n", $ifile);
+    exit (1);
+  } elsif ($eh[$e_machine] != 20) {
+    printf("The file \"%s\" is not a PowerPC ELF file.\n", $ifile);
+    exit (1);
+  }
+
+  if ($verbose) {
+    print("File header:\n");
+    printf("  Identifier:            %s\n",	$eh[$e_ident]);
+    printf("  Type:                  %d\n",	$eh[$e_type]);
+    printf("  Machine:               %d\n",	$eh[$e_machine]);
+    printf("  Version:               %d\n",	$eh[$e_version]);
+    printf("  Entry point:           0x%08x\n", $eh[$e_entry]);
+    printf("  Program header offset: 0x%x\n",	$eh[$e_phoff]);
+    printf("  Section header offset: 0x%x\n",	$eh[$e_shoff]);
+    printf("  Flags:                 0x%08x\n", $eh[$e_flags]);
+    printf("  Header size:           %d\n", $eh[$e_ehsize]);
+    printf("  Program entry size:    %d\n", $eh[$e_phentsize]);
+    printf("  Program table entries: %d\n", $eh[$e_phnum]);
+    printf("  Section header size:   %d\n", $eh[$e_shentsize]);
+    printf("  Section table entries: %d\n", $eh[$e_shnum]);
+    printf("  String table section:  %d\n", $eh[$e_shstrndx]);
+  }
+
+  #
+  # Find the section header for the string table.
+  #
+
+  $strtable_section_offset =  $eh[$e_shoff] +
+    $eh[$e_shstrndx] * $eh[$e_shentsize];
+
+  if ($verbose) {
+    printf("String table section header offset: 0x%x\n",
+	   $strtable_section_offset);
+  }
+  
+  #
+  # Find the start of the string table.
+  #
+
+  @strh = unpack("N10", substr($ibuf, $strtable_section_offset, 
+			       $eh[$e_shentsize]));
+
+  if ($verbose) {
+    printf("Section name strings start at: 0x%x, %d bytes.\n",
+	   $strh[$sh_offset], $strh[$sh_size]);
+  }
+
+  $names = substr($ibuf, $strh[$sh_offset], $strh[$sh_size]);
+
+  # Grab each section header and find '.text' and '.bss' sections in
+  # particular.
+
+  if ($verbose) {
+  print("Section headers:\n");
+  print("Idx  Name                      Size      Address   File off  Algn\n");
+  print("---  ------------------------  --------  --------  --------  ----\n");
+  }
+
+  $off = $eh[$e_shoff];
+
+  for($i = 0; $i < $eh[$e_shnum]; $i++, $off += $eh[$e_shentsize]) {
+    @sh = unpack("N10", substr($ibuf, $off, $eh[$e_shentsize]));
+
+    # Take the first section name from the array returned by split.
+
+    ($name) = split(/\000/, substr($names, $sh[$sh_name]));
+    
+    if ($verbose) {
+      printf("%3d  %-24s  %8x  %08x  %08x  %4d\n", 
+	     $i, $name, $sh[$sh_size], $sh[$sh_addr], 
+	     $sh[$sh_offset], $sh[$sh_addralign]);
+    }
+
+    # Attempt to find the .text and .bss sections
+
+    if ($name =~ /^\.bss$/) {
+      ($bss_addr, $bss_offset, $bss_size) =
+	($sh[$sh_addr], $sh[$sh_offset], $sh[$sh_size]);
+
+    } elsif ($name =~ /^\.text$/) {
+      ($text_addr, $text_offset, $text_size) = 
+	($sh[$sh_addr], $sh[$sh_offset], $sh[$sh_size]);
+
+    } elsif ($linux && ($name =~ /^\image$/)) {
+      $image_found = 1;
+
+      ($image_addr, $image_offset, $image_size) = 
+	($sh[$sh_addr], $sh[$sh_offset], $sh[$sh_size]);
+
+    } elsif ($linux && ($name =~ /^\initrd$/)) {
+      $initrd_found = 1;
+
+      ($initrd_addr, $initrd_offset, $initrd_size) = 
+	($sh[$sh_addr], $sh[$sh_offset], $sh[$sh_size]);
+
+    }
+  }
+
+  printf("Text section   - Address: 0x%08x, Size: 0x%08x\n",
+	 $text_addr, $text_size);
+  printf("Bss  section   - Address: 0x%08x, Size: 0x%08x\n",
+	 $bss_addr, $bss_size);
+
+  if ($linux) {
+    if ($image_found) {
+      printf("Image section  - Address: 0x%08x, Size: 0x%08x\n",
+	     $image_addr, $image_size);
+    }
+
+    if ($initrd_found) {
+      printf("Initrd section - Address: 0x%08x, Size: 0x%08x\n",
+	     $initrd_addr, $initrd_size);
+    }
+  }
+
+  #
+  # Open output file
+  #
+
+  open(BOOT, ">$ofile") || die "Cannot open output file";
+
+  #
+  # Compute image size
+  #
+
+  $output_size = $bss_offset - $text_offset + $bss_size;
+
+  if ($linux && $image_found) {
+    $output_size += $image_size;
+  }
+
+  if ($linux && $initrd_found) {
+    $output_size += $initrd_size;
+  }
+
+  $num_blocks = $output_size / 512 + 1;
+
+  #
+  # Write IBM PowerPC evaluation board boot_block_t header
+  #
+
+  $header = pack("H8N7", "0052504f", $text_addr, $num_blocks, 0,
+		 $text_addr, 0, 0, 0);
+
+  $bytes = length($header);
+  
+  if (($resid = syswrite(BOOT, $header, $bytes)) != $bytes) {
+    die("Could not write boot image header to output file.");
+  }
+
+  printf("Entry point = 0x%08x\n", $text_addr);
+  printf("Image size  = 0x%08x (%d bytes) (%d blocks).\n", 
+	 $output_size, $output_size, $num_blocks);
+
+  #
+  # Write image starting after ELF and program headers and 
+  # continuing to beginning of bss
+  #
+
+  $bytes = $bss_offset - $text_offset + $bss_size;
+
+  if (($resid = syswrite(BOOT, $ibuf, $bytes, $text_offset)) != $bytes) {
+    die("Could not write boot image to output file.\n");
+  }
+
+  #
+  # If configured, write out the image and initrd sections as well
+  #
+
+  if ($linux) {
+    if ($image_found) {
+      $bytes = $image_size;
+      if (($resid = syswrite(BOOT, $ibuf, $bytes, $image_offset)) != $bytes) {
+	die("Could not write boot image to output file.\n");
+      }
+    }
+
+    if ($initrd_found) {
+      $bytes = $initrd_size;
+      if (($resid = syswrite(BOOT, $ibuf, $bytes, $initrd_offset)) != $bytes) {
+	die("Could not write boot image to output file.\n");
+      }
+    }
+  }
+
+  #
+  # Pad to a multiple of 512 bytes
+  #
+
+  $pad_size = 512 - (length($header) + $output_size) % 512;
+
+  if ($verbose) {
+    print("Padding boot image by an additional $pad_size bytes.\n");
+  }
+
+  $pad_string = pack(("H8","deadbeef") x 128);
+
+  syswrite(BOOT, $pad_string, $pad_size) or
+    die "Could not pad boot image in output file.\n";
+
+  #
+  # Clean-up and leave
+  #
+
+  close(BOOT);
+
+  print("\nBoot image file \"$ofile\" built successfully.\n\n");
+
+  exit(0);
+}
diff --git a/arch/ppc/boot/utils/mkirimg b/arch/ppc/boot/utils/mkirimg
new file mode 100644
index 000000000000..fa1b5bbb0a5a
--- /dev/null
+++ b/arch/ppc/boot/utils/mkirimg
@@ -0,0 +1,367 @@
+#!/usr/bin/perl
+#
+#    Copyright (c) 1998-1999 TiVo, Inc.
+#      Original ELF parsing code.
+#
+#    Copyright (c) 1999 Grant Erickson <grant@lcse.umn.edu>
+#      Original code from 'mkevimg'.
+#
+#    Module name: mkirimg
+#
+#    Description:
+#      Reads an ELF file and assigns global variables 'imageSect_start',
+#      'imageSect_size', 'initrdSect_start', and 'initrdSect_size' from
+#      the "image" and "initrd" section header information. It then
+#      rewrites the input ELF file with assigned globals to an output
+#      file.
+#
+#      An input file, "irSectStart.txt" has the memory address of
+#      'irSectStart'. The irSectStart memory address is used to find
+#      the global variables in the ".data" section of the ELF file.
+#      The 'irSectStart' and the above global variables are defined
+#      in "irSect.c".
+#
+#
+
+use File::Basename;
+use Getopt::Std;
+
+#
+# usage()
+#
+# Description:
+#   This routine prints out the proper command line usage for this program
+#
+# Input(s):
+#   status - Flag determining what usage information will be printed and what
+#            the exit status of the program will be after the information is
+#            printed.
+#
+# Output(s):
+#   N/A
+#
+# Returns:
+#   This subroutine does not return.
+#
+
+sub usage {
+  my($status);
+  $status = $_[0];
+
+  printf("Usage: %s [-hvV] <ELF input file> <Evaluation board output file> <irSectStart.txt file>\n",
+	 $program);
+
+  if ($status != 0) {
+    printf("Try `%s -h' for more information.\n", $program);
+  }
+
+  if ($status != 1) {
+    print("  -h             Print out this message and exit.\n");
+    print("  -v             Verbose. Print out lots of ELF information.\n");
+    print("  -V             Print out version information and exit.\n");
+  }
+
+  exit($status);
+}
+
+#
+# version()
+#
+# Description:
+#   This routine prints out program version information
+#
+# Input(s):
+#   N/A
+#
+# Output(s):
+#   N/A
+#
+# Returns:
+#   This subroutine does not return.
+#
+
+sub version {
+  print("mkirimg Version 1.1.0\n");
+  print("Copyright (c) 1998-1999 TiVo, Inc.\n");
+  print("Copyright (c) 1999 Grant Erickson <grant\@lcse.umn.edu>\n");
+
+  exit (0);
+}
+
+#
+# file_check()
+#
+# Description:
+#   This routine checks an input file to ensure that it exists, is a
+#   regular file, and is readable.
+#
+# Input(s):
+#   file - Input file to be checked.
+#
+# Output(s):
+#   N/A
+#
+# Returns:
+#   0 if the file exists, is a regular file, and is readable, otherwise -1.
+#
+
+sub file_check {
+  my($file);
+  $file = $_[0];
+
+  if (!(-e $file)) {
+     printf("The file \"%s\" does not exist.\n", $file);
+     return (-1);
+  } elsif (!(-f $file)) {
+     printf("The file \"%s\" is not a regular file.\n", $file);
+     return (-1);
+  } elsif (!(-r $file)) {
+     printf("The file \"%s\" is not readable.\n", $file);
+     return (-1);
+  }
+
+  return (0);
+}
+
+#
+# decode_options()
+#
+# Description:
+#   This routine steps through the command-line arguments, parsing out
+#   recognzied options.
+#
+# Input(s):
+#   N/A
+#
+# Output(s):
+#   N/A
+#
+# Returns:
+#   N/A
+#
+
+sub decode_options {
+
+  if (!getopts("hvV")) {
+      usage(1);
+  }
+
+  if ($opt_h) {
+      usage(0);
+  }
+
+  if ($opt_V) {
+      version();
+      exit (0);
+  }
+
+  if ($opt_v) {
+      $verbose = 1;
+  }
+
+  if (!($ElfFile = shift(@ARGV))) {
+      usage(1);
+  }
+
+  if (!($OutputFile = shift(@ARGV))) {
+      usage (1);
+  }
+
+  if (!($IrFile = shift(@ARGV))) {
+      usage (1);
+  }
+
+  if (file_check($ElfFile)) {
+      exit(1);
+  }
+
+  if (file_check($IrFile)) {
+      exit(1);
+  }
+}
+
+#
+# ELF file and section header field numbers
+#
+
+require '../utils/elf.pl';
+
+#
+# Main program body
+#
+
+{
+  $program = basename($0);
+  decode_options();
+
+  open(ELF, "<$ElfFile") || die "Cannot open input file";
+  open(OUTPUT, ">$OutputFile") || die "Cannot open output file";
+  open(IR, "$IrFile") || die "Cannot open input file";
+
+  $ElfFilesize = (-s $ElfFile);
+
+  if (read(ELF, $ibuf, $ElfFilesize) != $ElfFilesize) {
+    print("Failed to read ELF input file!\n");
+    exit(1);
+  }
+
+  if (read(IR, $irbuf, 8) != 8) {
+      print("Failed to read Ir input file!\n");
+      exit(1);
+  }
+
+  #
+  # Parse ELF header
+  #
+
+  @eh = unpack("a16n2N5n6", $ibuf);
+
+  #
+  # Make sure this is actually a PowerPC ELF file.
+  #
+
+  if (substr($eh[$e_ident], 0, 4) ne "\177ELF") {
+      printf("The file \"%s\" is not an ELF file.\n", $ElfFile);
+      exit (1);
+  } elsif ($eh[$e_machine] != 20) {
+      printf("The file \"%s\" is not a PowerPC ELF file.\n", $ElfFile);
+      exit (1);
+  }
+
+  #
+  # Find the section header for the string table.
+  #
+
+  $strtable_section_offset =  $eh[$e_shoff] +
+
+  $eh[$e_shstrndx] * $eh[$e_shentsize];
+
+  if ($verbose) {
+     printf("String table section header offset: 0x%x\n",
+     $strtable_section_offset);
+  }
+
+  #
+  # Find the start of the string table.
+  #
+
+  @strh = unpack("N10", substr($ibuf, $strtable_section_offset,
+			       $eh[$e_shentsize]));
+
+  if ($verbose) {
+     printf("Section name strings start at: 0x%x, %d bytes.\n",
+     $strh[$sh_offset], $strh[$sh_size]);
+  }
+
+  $names = substr($ibuf, $strh[$sh_offset], $strh[$sh_size]);
+
+  # Grab each section header and find '.data', 'image', and 
+  # 'initrd' sections in particular.
+
+  $off = $eh[$e_shoff];
+  $imageFound = 0;
+  $initrdFound = 0;
+  
+  for($i = 0; $i < $eh[$e_shnum]; $i++, $off += $eh[$e_shentsize]) {
+    @sh = unpack("N10", substr($ibuf, $off, $eh[$e_shentsize]));
+
+    # Take the first section name from the array returned by split.
+
+    ($name) = split(/\000/, substr($names, $sh[$sh_name]));
+
+    # Attempt to find the .data, image, and initrd sections
+
+    if ($name =~ /^\image$/) {
+      ($image_addr, $image_offset, $image_size) =
+	($sh[$sh_addr], $sh[$sh_offset], $sh[$sh_size]);
+      $imageFound = 1;
+
+    } elsif ($name =~ /^\initrd$/) {
+      ($initrd_addr, $initrd_offset, $initrd_size) =
+	($sh[$sh_addr], $sh[$sh_offset], $sh[$sh_size]);
+      $initrdFound = 1;
+
+    } elsif ($name =~ /^\.data$/) {
+      ($data_addr, $data_offset, $data_size) =
+	($sh[$sh_addr], $sh[$sh_offset], $sh[$sh_size]);
+
+    } elsif ($name =~ /^\.bss$/) {
+      ($bss_addr, $bss_offset, $bss_size) =
+	($sh[$sh_addr], $sh[$sh_offset], $sh[$sh_size]);
+
+    }
+   }
+
+  if ($verbose) {
+    printf("Data section   - Address: 0x%08x, Size: 0x%08x, File Offset 0x%08x\n",
+	   $data_addr, $data_size, $data_offset);
+    printf("Bss  section   - Address: 0x%08x, Size: 0x%08x, File Offset 0x%08x\n",
+	 $bss_addr, $bss_size, $bss_offset);
+   }
+
+  if ($verbose) {
+    if ($imageFound) {
+      printf("Image section  - Address: 0x%08x, Size: 0x%08x\n",
+	     $image_addr, $image_size);
+    } else {
+      printf("Image section not found in file: $ElfFile\n");
+    }
+
+    if ($initrdFound) {
+      printf("Initrd section - Address: 0x%08x, Size: 0x%08x\n",
+	     $initrd_addr, $initrd_size);
+    } else {
+      printf("Initrd section not found in file: $ElfFile\n");
+    }
+  }
+
+  # get file offset of irSectStart
+
+  $irSectStartoffset = hex ($irbuf);
+
+  if ($verbose) {
+    printf("irSectStartOffset Address: 0x%08x\n", $irSectStartoffset);
+  }
+
+  # get the offset of global variables 
+
+  $initialOffset = ($irSectStartoffset - $data_addr) + $data_offset + 4;
+
+  # write modified values to OUTPUT file
+
+  syswrite(OUTPUT, $ibuf, $initialOffset);
+
+  if ($imageFound) {
+    $testN = pack ("N2", $bss_addr + $bss_size, $image_size);
+    syswrite(OUTPUT, $testN, length($testN));
+    printf("Updated symbol \"imageSect_start\" to 0x%08x\n",
+	   $bss_addr + $bss_size);
+    printf("Updated symbol \"imageSect_size\" to 0x%08x\n", $image_size);
+  } else {
+    syswrite(OUTPUT, $ibuf, 8, $initialOffset);
+  }
+
+  if ($initrdFound) {
+    $testN = pack ("N2", $bss_addr + $bss_size + $image_size, $initrd_size);
+    syswrite(OUTPUT, $testN, length($testN));
+    printf("Updated symbol \"initrdSect_start\" to 0x%08x\n",
+	   $bss_addr + $bss_size + $image_size);
+    printf("Updated symbol \"initrdSect_size\" to 0x%08x\n", $initrd_size);
+  } else {
+    syswrite(OUTPUT, $ibuf,8, $initialOffset + 8);
+  }
+
+  syswrite(OUTPUT, $ibuf, $ElfFilesize - ($initialOffset + 16),
+	   $initialOffset + 16);
+
+  #
+  # Clean-up and leave
+  #
+
+  close (ELF);
+  close (OUTPUT);
+  close (IR);
+
+  exit (0);
+}
+
diff --git a/arch/ppc/boot/utils/mknote.c b/arch/ppc/boot/utils/mknote.c
new file mode 100644
index 000000000000..608752e70004
--- /dev/null
+++ b/arch/ppc/boot/utils/mknote.c
@@ -0,0 +1,46 @@
+/*
+ * BK Id: SCCS/s.mknote.c 1.7 05/18/01 15:17:23 cort
+ */
+/*
+ * Copyright (C) Cort Dougan 1999.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ * Generate a note section as per the CHRP specification.
+ *
+ */
+
+#include <stdio.h>
+
+#define PL(x) printf("%c%c%c%c", ((x)>>24)&0xff, ((x)>>16)&0xff, ((x)>>8)&0xff, (x)&0xff );
+
+int main(void)
+{
+/* header */
+	/* namesz */
+	PL(strlen("PowerPC")+1);
+	/* descrsz */
+	PL(6*4);
+	/* type */
+	PL(0x1275);
+	/* name */
+	printf("PowerPC"); printf("%c", 0);
+	
+/* descriptor */
+	/* real-mode */
+	PL(0xffffffff);
+	/* real-base */
+	PL(0x00c00000);
+	/* real-size */
+	PL(0xffffffff);
+	/* virt-base */
+	PL(0xffffffff);
+	/* virt-size */
+	PL(0xffffffff);
+	/* load-base */
+	PL(0x4000);
+	return 0;
+}
diff --git a/arch/ppc/boot/utils/mkprep.c b/arch/ppc/boot/utils/mkprep.c
new file mode 100644
index 000000000000..3930f24aff04
--- /dev/null
+++ b/arch/ppc/boot/utils/mkprep.c
@@ -0,0 +1,292 @@
+/*
+ * BK Id: SCCS/s.mkprep.c 1.7 05/18/01 06:20:29 patch
+ */
+/*
+ * Makes a prep bootable image which can be dd'd onto
+ * a disk device to make a bootdisk.  Will take
+ * as input a elf executable, strip off the header
+ * and write out a boot image as:
+ * 1) default - strips elf header
+ *      suitable as a network boot image
+ * 2) -pbp - strips elf header and writes out prep boot partition image
+ *      cat or dd onto disk for booting
+ * 3) -asm - strips elf header and writes out as asm data
+ *      useful for generating data for a compressed image
+ *                  -- Cort
+ *
+ * Modified for x86 hosted builds by Matt Porter <porter@neta.com>
+ */
+
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#define cpu_to_le32(x) le32_to_cpu((x))
+unsigned long le32_to_cpu(unsigned long x)
+{
+     	return (((x & 0x000000ffU) << 24) |
+		((x & 0x0000ff00U) <<  8) |
+		((x & 0x00ff0000U) >>  8) |
+		((x & 0xff000000U) >> 24));
+}
+
+
+#define cpu_to_le16(x) le16_to_cpu((x))
+unsigned short le16_to_cpu(unsigned short x)
+{
+	return (((x & 0x00ff) << 8) |
+		((x & 0xff00) >> 8));
+}
+
+#define cpu_to_be32(x) (x)
+#define be32_to_cpu(x) (x)
+#define cpu_to_be16(x) (x)
+#define be16_to_cpu(x) (x)
+
+/* size of read buffer */
+#define SIZE 0x1000
+
+
+typedef unsigned long dword_t;
+typedef unsigned short word_t;
+typedef unsigned char byte_t;
+typedef byte_t block_t[512];
+typedef byte_t page_t[4096];
+
+
+/*
+ * Partition table entry
+ *  - from the PReP spec
+ */
+typedef struct partition_entry {
+  byte_t	boot_indicator;
+  byte_t	starting_head;
+  byte_t	starting_sector;
+  byte_t	starting_cylinder;
+
+  byte_t	system_indicator;
+  byte_t	ending_head;
+  byte_t	ending_sector;
+  byte_t	ending_cylinder;
+
+  dword_t	beginning_sector;
+  dword_t	number_of_sectors;
+} partition_entry_t;
+
+#define BootActive	0x80
+#define SystemPrep	0x41
+
+void copy_image(int , int);
+void write_prep_partition(int , int );
+void write_asm_data( int in, int out );
+
+unsigned int elfhdr_size = 65536;
+
+int main(int argc, char *argv[])
+{
+  int in_fd, out_fd;
+  int argptr = 1;
+  unsigned int prep = 0;
+  unsigned int asmoutput = 0;
+
+  if ( (argc < 3) || (argc > 4) )
+  {
+    fprintf(stderr, "usage: %s [-pbp] [-asm] <boot-file> <image>\n",argv[0]);
+    exit(-1);
+  }
+
+  /* needs to handle args more elegantly -- but this is a small/simple program */
+  
+  /* check for -pbp */
+  if ( !strcmp( argv[argptr], "-pbp" ) )
+  {
+    prep = 1;
+    argptr++;
+  }
+  
+  /* check for -asm */
+  if ( !strcmp( argv[argptr], "-asm" ) )
+  {
+    asmoutput = 1;
+    argptr++;
+  }
+
+  /* input file */
+  if ( !strcmp( argv[argptr], "-" ) )
+    in_fd = 0;			/* stdin */
+  else
+    if ((in_fd = open( argv[argptr] , 0)) < 0)
+      exit(-1);
+  argptr++;
+
+  /* output file */
+  if ( !strcmp( argv[argptr], "-" ) )
+    out_fd = 1;			/* stdout */
+  else
+    if ((out_fd = creat( argv[argptr] , 0755)) < 0)
+      exit(-1);
+  argptr++;
+
+  /* skip elf header in input file */
+  /*if ( !prep )*/
+  lseek(in_fd, elfhdr_size, SEEK_SET);
+  
+  /* write prep partition if necessary */
+  if ( prep )
+	  write_prep_partition( in_fd, out_fd );
+
+  /* write input image to bootimage */
+  if ( asmoutput )
+	  write_asm_data( in_fd, out_fd );
+  else
+	  copy_image(in_fd, out_fd);
+  
+  return 0;
+}
+
+void write_prep_partition(int in, int out)
+{
+  unsigned char block[512];
+  partition_entry_t *pe = (partition_entry_t *)&block[0x1BE];
+  dword_t *entry  = (dword_t *)&block[0];
+  dword_t *length = (dword_t *)&block[sizeof(long)];
+  struct stat info;
+  
+  if (fstat(in, &info) < 0)
+  {
+    fprintf(stderr,"info failed\n");
+    exit(-1);
+  }
+  
+  bzero( block, sizeof block );
+ 
+  /* set entry point and boot image size skipping over elf header */
+#ifdef __i386__
+  *entry = 0x400/*+65536*/;
+  *length = info.st_size-elfhdr_size+0x400;
+#else
+  *entry = cpu_to_le32(0x400/*+65536*/);
+  *length = cpu_to_le32(info.st_size-elfhdr_size+0x400);
+#endif /* __i386__ */
+
+  /* sets magic number for msdos partition (used by linux) */
+  block[510] = 0x55;
+  block[511] = 0xAA;
+  
+  /*
+   * Build a "PReP" partition table entry in the boot record
+   *  - "PReP" may only look at the system_indicator
+   */
+  pe->boot_indicator   = BootActive;
+  pe->system_indicator = SystemPrep;
+  /*
+   * The first block of the diskette is used by this "boot record" which
+   * actually contains the partition table. (The first block of the
+   * partition contains the boot image, but I digress...)  We'll set up
+   * one partition on the diskette and it shall contain the rest of the
+   * diskette.
+   */
+  pe->starting_head     = 0;	/* zero-based			     */
+  pe->starting_sector   = 2;	/* one-based			     */
+  pe->starting_cylinder = 0;	/* zero-based			     */
+  pe->ending_head       = 1;	/* assumes two heads		     */
+  pe->ending_sector     = 18;	/* assumes 18 sectors/track	     */
+  pe->ending_cylinder   = 79;	/* assumes 80 cylinders/diskette     */
+
+  /*
+   * The "PReP" software ignores the above fields and just looks at
+   * the next two.
+   *   - size of the diskette is (assumed to be)
+   *     (2 tracks/cylinder)(18 sectors/tracks)(80 cylinders/diskette)
+   *   - unlike the above sector numbers, the beginning sector is zero-based!
+   */
+#if 0
+  pe->beginning_sector  = cpu_to_le32(1);
+#else
+  /* This has to be 0 on the PowerStack? */   
+#ifdef __i386__
+  pe->beginning_sector  = 0;
+#else
+  pe->beginning_sector  = cpu_to_le32(0);
+#endif /* __i386__ */
+#endif    
+
+#ifdef __i386__
+  pe->number_of_sectors = 2*18*80-1;
+#else
+  pe->number_of_sectors = cpu_to_le32(2*18*80-1);
+#endif /* __i386__ */
+
+  write( out, block, sizeof(block) );
+  write( out, entry, sizeof(*entry) );
+  write( out, length, sizeof(*length) );  
+  /* set file position to 2nd sector where image will be written */
+  lseek( out, 0x400, SEEK_SET );
+}
+
+
+
+void
+copy_image(int in, int out)
+{
+  char buf[SIZE];
+  int n;
+
+  while ( (n = read(in, buf, SIZE)) > 0 )
+    write(out, buf, n);
+}
+
+
+void
+write_asm_data( int in, int out )
+{
+  int i, cnt, pos, len;
+  unsigned int cksum, val;
+  unsigned char *lp;
+  unsigned char buf[SIZE];
+  unsigned char str[256];
+  
+  write( out, "\t.data\n\t.globl input_data\ninput_data:\n",
+	 strlen( "\t.data\n\t.globl input_data\ninput_data:\n" ) );
+  pos = 0;
+  cksum = 0;
+  while ((len = read(in, buf, sizeof(buf))) > 0)
+  {
+    cnt = 0;
+    lp = (unsigned char *)buf;
+    len = (len + 3) & ~3;  /* Round up to longwords */
+    for (i = 0;  i < len;  i += 4)
+    {
+      if (cnt == 0)
+      {
+	write( out, "\t.long\t", strlen( "\t.long\t" ) );
+      }
+      sprintf( str, "0x%02X%02X%02X%02X", lp[0], lp[1], lp[2], lp[3]);
+      write( out, str, strlen(str) );
+      val = *(unsigned long *)lp;
+      cksum ^= val;
+      lp += 4;
+      if (++cnt == 4)
+      {
+	cnt = 0;
+	sprintf( str, " # %x \n", pos+i-12);
+	write( out, str, strlen(str) );
+      } else
+      {
+	write( out, ",", 1 );
+      }
+    }
+    if (cnt)
+    {
+      write( out, "0\n", 2 );
+    }
+    pos += len;
+  }
+  sprintf(str, "\t.globl input_len\ninput_len:\t.long\t0x%x\n", pos);
+  write( out, str, strlen(str) );
+
+  fprintf(stderr, "cksum = %x\n", cksum);
+}
diff --git a/arch/ppc/boot/utils/mksimage.c b/arch/ppc/boot/utils/mksimage.c
new file mode 100644
index 000000000000..721856a9b382
--- /dev/null
+++ b/arch/ppc/boot/utils/mksimage.c
@@ -0,0 +1,127 @@
+/*
+ * BK Id: SCCS/s.mksimage.c 1.6 05/18/01 15:16:42 cort
+ */
+/*
+ *
+ *
+ *
+ *
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+
+
+#define SIZE 1024
+#define BLOCK_ALIGN(x)  (((x)+SIZE-1)&(~(SIZE-1)))
+
+static void
+die(const char *fmt, ...)
+{
+	va_list args;
+	va_start(args, fmt);
+	vfprintf(stderr, fmt, args);
+	fputc('\n', stderr);
+	exit(1);
+}
+
+static void
+usage(void)
+{
+	printf("Usage: mkbinimg <bootstrap> <kernel> <ramdisk> -o <binary>\n");
+	exit(1);
+}
+
+static int
+copy_blocks(int ifd, int ofd, unsigned long *offset, unsigned long *size)
+{
+	off_t cur;
+	int amt;
+	unsigned long len = 0;
+	char buffer[SIZE];
+
+	cur = lseek(ofd, 0, SEEK_CUR);
+
+	if (cur % SIZE) {
+		cur = BLOCK_ALIGN(cur);
+		cur = lseek(ofd, cur, SEEK_SET);
+	}
+
+	*offset = (unsigned long) cur;
+	while((amt = read(ifd, buffer, SIZE)) > 0) {
+		write(ofd, buffer, amt);
+		len += amt;
+	}
+	*size = len;
+	return 0;
+}
+
+
+int
+main(int argc, char *argv[])
+{
+	char *kernel, *loader, *rdimage = NULL;
+	unsigned long ld_off, kern_off, rd_off;
+	unsigned long ld_size, kern_size, rd_size;
+	int fd, ofd, len;
+	char buffer[500];
+
+	if (argc < 5 && !strcmp(argv[argc-2], "-o"))
+		usage();
+
+	if (argc > 5)
+		rdimage = argv[3];
+
+	kernel = argv[2];
+	loader = argv[1];
+
+	ofd = open(argv[argc-1], (O_RDWR|O_CREAT), 0755);
+	if (ofd < 0) {
+		die("can't open %s: %s", argv[5], strerror(errno));
+	}
+
+	ld_off = kern_off = rd_off = 0;
+	ld_size = kern_size = rd_size = 0;
+	memset(buffer, 0, 500);
+	len = 0;
+
+	fd = open(loader, O_RDONLY);
+	if (fd < 0) 
+		die("can't open loader: %s", strerror(errno));
+
+	copy_blocks(fd, ofd, &ld_off, &ld_size);
+	len = sprintf(buffer, "bootloader: %x %x\n", ld_off, ld_size);
+	close(fd);
+
+	fd = open(kernel, O_RDONLY);
+	if (fd < 0)
+		die("can't open kernel: %s", strerror(errno));
+
+	copy_blocks(fd, ofd, &kern_off, &kern_size);
+	len += sprintf(buffer+len, "zimage: %x %x\n", kern_off, kern_size);
+	close(fd);
+	
+	if (rdimage) {
+		fd = open(rdimage, O_RDONLY);
+		if (fd < 0)
+			die("can't get ramdisk: %s", strerror(errno));
+		
+		copy_blocks(fd, ofd, &rd_off, &rd_size);
+		close(fd);
+	}
+
+	len += sprintf(buffer+len, "initrd: %x %x", rd_off, rd_size);
+
+	close(ofd);
+
+	printf("%s\n", buffer);
+
+	return 0;
+}
+
diff --git a/arch/ppc/boot/utils/offset b/arch/ppc/boot/utils/offset
new file mode 100644
index 000000000000..52a1b5546e6f
--- /dev/null
+++ b/arch/ppc/boot/utils/offset
@@ -0,0 +1,4 @@
+#!/bin/bash
+
+OFFSET=`$1 -h $2  | grep $3 | grep -v zvmlinux| awk '{print $6}'`
+echo "0x"$OFFSET
diff --git a/arch/ppc/boot/utils/piggyback.c b/arch/ppc/boot/utils/piggyback.c
new file mode 100644
index 000000000000..6edfbaaa092e
--- /dev/null
+++ b/arch/ppc/boot/utils/piggyback.c
@@ -0,0 +1,69 @@
+/*
+ * BK Id: SCCS/s.piggyback.c 1.7 05/18/01 15:17:23 cort
+ */
+#include <stdio.h>
+#include <unistd.h>
+
+extern long ce_exec_config[];
+
+int main(int argc, char *argv[])
+{
+	int i, cnt, pos, len;
+	unsigned int cksum, val;
+	unsigned char *lp;
+	unsigned char buf[8192];
+	if (argc != 2)
+	{
+		fprintf(stderr, "usage: %s name <in-file >out-file\n",
+			argv[0]);
+		exit(1);
+	}
+	fprintf(stdout, "#\n");
+	fprintf(stdout, "# Miscellaneous data structures:\n");
+	fprintf(stdout, "# WARNING - this file is automatically generated!\n");
+	fprintf(stdout, "#\n");
+	fprintf(stdout, "\n");
+	fprintf(stdout, "\t.data\n");
+	fprintf(stdout, "\t.globl %s_data\n", argv[1]);
+	fprintf(stdout, "%s_data:\n", argv[1]);
+	pos = 0;
+	cksum = 0;
+	while ((len = read(0, buf, sizeof(buf))) > 0)
+	{
+		cnt = 0;
+		lp = (unsigned char *)buf;
+		len = (len + 3) & ~3;  /* Round up to longwords */
+		for (i = 0;  i < len;  i += 4)
+		{
+			if (cnt == 0)
+			{
+				fprintf(stdout, "\t.long\t");
+			}
+			fprintf(stdout, "0x%02X%02X%02X%02X", lp[0], lp[1], lp[2], lp[3]);
+			val = *(unsigned long *)lp;
+			cksum ^= val;
+			lp += 4;
+			if (++cnt == 4)
+			{
+				cnt = 0;
+				fprintf(stdout, " # %x \n", pos+i-12);
+				fflush(stdout);
+			} else
+			{
+				fprintf(stdout, ",");
+			}
+		}
+		if (cnt)
+		{
+			fprintf(stdout, "0\n");
+		}
+		pos += len;
+	}
+	fprintf(stdout, "\t.globl %s_len\n", argv[1]);
+	fprintf(stdout, "%s_len:\t.long\t0x%x\n", argv[1], pos);
+	fflush(stdout);
+	fclose(stdout);
+	fprintf(stderr, "cksum = %x\n", cksum);
+	exit(0);
+}
+
diff --git a/arch/ppc/boot/utils/sioffset b/arch/ppc/boot/utils/sioffset
new file mode 100644
index 000000000000..b5245be6c7b1
--- /dev/null
+++ b/arch/ppc/boot/utils/sioffset
@@ -0,0 +1,4 @@
+#!/bin/bash
+
+OFFSET=`grep $1 sImage.map | awk '{print $2}'`
+echo "0x"$OFFSET
diff --git a/arch/ppc/boot/utils/sisize b/arch/ppc/boot/utils/sisize
new file mode 100644
index 000000000000..7e8180125dd4
--- /dev/null
+++ b/arch/ppc/boot/utils/sisize
@@ -0,0 +1,4 @@
+#!/bin/bash
+
+OFFSET=`grep $1 sImage.map | awk '{print $3}'`
+echo "0x"$OFFSET
diff --git a/arch/ppc/boot/utils/size b/arch/ppc/boot/utils/size
new file mode 100644
index 000000000000..6c48f8d1468d
--- /dev/null
+++ b/arch/ppc/boot/utils/size
@@ -0,0 +1,4 @@
+#!/bin/bash
+
+OFFSET=`$1 -h $2  | grep $3 | grep -v zvmlinux | awk '{print $3}'`
+echo "0x"$OFFSET