Merge branch 'for-2.6.22' of git://git.kernel.org/pub/scm/linux/kernel/git/paulus/powerpc

* 'for-2.6.22' of git://git.kernel.org/pub/scm/linux/kernel/git/paulus/powerpc: (255 commits)
  [POWERPC] Remove dev_dbg redefinition in drivers/ps3/vuart.c
  [POWERPC] remove kernel module option for booke wdt
  [POWERPC] Avoid putting cpu node twice
  [POWERPC] Spinlock initializer cleanup
  [POWERPC] ppc4xx_sgdma needs dma-mapping.h
  [POWERPC] arch/powerpc/sysdev/timer.c build fix
  [POWERPC] get_property cleanups
  [POWERPC] Remove the unused HTDMSOUND driver
  [POWERPC] cell: cbe_cpufreq cleanup and crash fix
  [POWERPC] Declare enable_kernel_spe in a header
  [POWERPC] Add dt_xlate_addr() to bootwrapper
  [POWERPC] bootwrapper: CONFIG_ -> CONFIG_DEVICE_TREE
  [POWERPC] Don't define a custom bd_t for Xilixn Virtex based boards.
  [POWERPC] Add sane defaults for Xilinx EDK generated xparameters files
  [POWERPC] Add uartlite boot console driver for the zImage wrapper
  [POWERPC] Stop using ppc_sys for Xilinx Virtex boards
  [POWERPC] New registration for common Xilinx Virtex ppc405 platform devices
  [POWERPC] Merge common virtex header files
  [POWERPC] Rework Kconfig dependancies for Xilinx Virtex ppc405 platform
  [POWERPC] Clean up cpufreq Kconfig dependencies
  ...

1 files changed, 118 insertions, 251 deletions

diff --git a/arch/powerpc/boot/main.c b/arch/powerpc/boot/main.c
index 6f6b50d238b6..56b56a8d4b23 100644
--- a/arch/powerpc/boot/main.c
+++ b/arch/powerpc/boot/main.c
@@ -14,11 +14,10 @@
 #include "page.h"
 #include "string.h"
 #include "stdio.h"
-#include "zlib.h"
 #include "ops.h"
+#include "gunzip_util.h"
 #include "flatdevtree.h"
-
-extern void flush_cache(void *, unsigned long);
+#include "reg.h"
 
 extern char _start[];
 extern char __bss_start[];
@@ -30,304 +29,173 @@ extern char _initrd_end[];
 extern char _dtb_start[];
 extern char _dtb_end[];
 
+static struct gunzip_state gzstate;
+
 struct addr_range {
-        unsigned long addr;
+        void *addr;
         unsigned long size;
-        unsigned long memsize;
 };
-static struct addr_range vmlinux;
-static struct addr_range vmlinuz;
-static struct addr_range initrd;
-
-static unsigned long elfoffset;
-static int is_64bit;
-
-/* scratch space for gunzip; 46912 is from zlib_inflate_workspacesize() */
-static char scratch[46912];
-static char elfheader[256];
 
 typedef void (*kernel_entry_t)(unsigned long, unsigned long, void *);
 
 #undef DEBUG
 
-#define HEAD_CRC        2
-#define EXTRA_FIELD     4
-#define ORIG_NAME       8
-#define COMMENT         0x10
-#define RESERVED        0xe0
-
-static void gunzip(void *dst, int dstlen, unsigned char *src, int *lenp)
+static struct addr_range prep_kernel(void)
 {
-        z_stream s;
-        int r, i, flags;
-
-        /* skip header */
-        i = 10;
-        flags = src[3];
-        if (src[2] != Z_DEFLATED || (flags & RESERVED) != 0) {
-                printf("bad gzipped data\n\r");
-                exit();
-        }
-        if ((flags & EXTRA_FIELD) != 0)
-                i = 12 + src[10] + (src[11] << 8);
-        if ((flags & ORIG_NAME) != 0)
-                while (src[i++] != 0)
-                        ;
-        if ((flags & COMMENT) != 0)
-                while (src[i++] != 0)
-                        ;
-        if ((flags & HEAD_CRC) != 0)
-                i += 2;
-        if (i >= *lenp) {
-                printf("gunzip: ran out of data in header\n\r");
-                exit();
-        }
+        char elfheader[256];
+        void *vmlinuz_addr = _vmlinux_start;
+        unsigned long vmlinuz_size = _vmlinux_end - _vmlinux_start;
+        void *addr = 0;
+        struct elf_info ei;
+        int len;
 
-        if (zlib_inflate_workspacesize() > sizeof(scratch)) {
-                printf("gunzip needs more mem\n");
-                exit();
-        }
-        memset(&s, 0, sizeof(s));
-        s.workspace = scratch;
-        r = zlib_inflateInit2(&s, -MAX_WBITS);
-        if (r != Z_OK) {
-                printf("inflateInit2 returned %d\n\r", r);
-                exit();
-        }
-        s.next_in = src + i;
-        s.avail_in = *lenp - i;
-        s.next_out = dst;
-        s.avail_out = dstlen;
-        r = zlib_inflate(&s, Z_FULL_FLUSH);
-        if (r != Z_OK && r != Z_STREAM_END) {
-                printf("inflate returned %d msg: %s\n\r", r, s.msg);
-                exit();
+        /* gunzip the ELF header of the kernel */
+        gunzip_start(&gzstate, vmlinuz_addr, vmlinuz_size);
+        gunzip_exactly(&gzstate, elfheader, sizeof(elfheader));
+
+        if (!parse_elf64(elfheader, &ei) && !parse_elf32(elfheader, &ei))
+                fatal("Error: not a valid PPC32 or PPC64 ELF file!\n\r");
+
+        if (platform_ops.image_hdr)
+                platform_ops.image_hdr(elfheader);
+
+        /* We need to alloc the memsize: gzip will expand the kernel
+         * text/data, then possible rubbish we don't care about. But
+         * the kernel bss must be claimed (it will be zero'd by the
+         * kernel itself)
+         */
+        printf("Allocating 0x%lx bytes for kernel ...\n\r", ei.memsize);
+
+        if (platform_ops.vmlinux_alloc) {
+                addr = platform_ops.vmlinux_alloc(ei.memsize);
+        } else {
+                if ((unsigned long)_start < ei.memsize)
+                        fatal("Insufficient memory for kernel at address 0!"
+                               " (_start=%p)\n\r", _start);
         }
-        *lenp = s.next_out - (unsigned char *) dst;
-        zlib_inflateEnd(&s);
-}
 
-static int is_elf64(void *hdr)
-{
-        Elf64_Ehdr *elf64 = hdr;
-        Elf64_Phdr *elf64ph;
-        unsigned int i;
-
-        if (!(elf64->e_ident[EI_MAG0]  == ELFMAG0       &&
-              elf64->e_ident[EI_MAG1]  == ELFMAG1       &&
-              elf64->e_ident[EI_MAG2]  == ELFMAG2       &&
-              elf64->e_ident[EI_MAG3]  == ELFMAG3       &&
-              elf64->e_ident[EI_CLASS] == ELFCLASS64    &&
-              elf64->e_ident[EI_DATA]  == ELFDATA2MSB   &&
-              elf64->e_type            == ET_EXEC       &&
-              elf64->e_machine         == EM_PPC64))
-                return 0;
-
-        elf64ph = (Elf64_Phdr *)((unsigned long)elf64 +
-                                 (unsigned long)elf64->e_phoff);
-        for (i = 0; i < (unsigned int)elf64->e_phnum; i++, elf64ph++)
-                if (elf64ph->p_type == PT_LOAD)
-                        break;
-        if (i >= (unsigned int)elf64->e_phnum)
-                return 0;
-
-        elfoffset = (unsigned long)elf64ph->p_offset;
-        vmlinux.size = (unsigned long)elf64ph->p_filesz + elfoffset;
-        vmlinux.memsize = (unsigned long)elf64ph->p_memsz + elfoffset;
-
-        is_64bit = 1;
-        return 1;
-}
+        /* Finally, gunzip the kernel */
+        printf("gunzipping (0x%p <- 0x%p:0x%p)...", addr,
+               vmlinuz_addr, vmlinuz_addr+vmlinuz_size);
+        /* discard up to the actual load data */
+        gunzip_discard(&gzstate, ei.elfoffset - sizeof(elfheader));
+        len = gunzip_finish(&gzstate, addr, ei.loadsize);
+        if (len != ei.loadsize)
+                fatal("ran out of data!  only got 0x%x of 0x%lx bytes.\n\r",
+                                len, ei.loadsize);
+        printf("done 0x%x bytes\n\r", len);
 
-static int is_elf32(void *hdr)
-{
-        Elf32_Ehdr *elf32 = hdr;
-        Elf32_Phdr *elf32ph;
-        unsigned int i;
-
-        if (!(elf32->e_ident[EI_MAG0]  == ELFMAG0       &&
-              elf32->e_ident[EI_MAG1]  == ELFMAG1       &&
-              elf32->e_ident[EI_MAG2]  == ELFMAG2       &&
-              elf32->e_ident[EI_MAG3]  == ELFMAG3       &&
-              elf32->e_ident[EI_CLASS] == ELFCLASS32    &&
-              elf32->e_ident[EI_DATA]  == ELFDATA2MSB   &&
-              elf32->e_type            == ET_EXEC       &&
-              elf32->e_machine         == EM_PPC))
-                return 0;
-
-        elf32 = (Elf32_Ehdr *)elfheader;
-        elf32ph = (Elf32_Phdr *) ((unsigned long)elf32 + elf32->e_phoff);
-        for (i = 0; i < elf32->e_phnum; i++, elf32ph++)
-                if (elf32ph->p_type == PT_LOAD)
-                        break;
-        if (i >= elf32->e_phnum)
-                return 0;
-
-        elfoffset = elf32ph->p_offset;
-        vmlinux.size = elf32ph->p_filesz + elf32ph->p_offset;
-        vmlinux.memsize = elf32ph->p_memsz + elf32ph->p_offset;
-        return 1;
+        flush_cache(addr, ei.loadsize);
+
+        return (struct addr_range){addr, ei.memsize};
 }
 
-static void prep_kernel(unsigned long a1, unsigned long a2)
+static struct addr_range prep_initrd(struct addr_range vmlinux, void *chosen,
+                                     unsigned long initrd_addr,
+                                     unsigned long initrd_size)
 {
-        int len;
-
-        vmlinuz.addr = (unsigned long)_vmlinux_start;
-        vmlinuz.size = (unsigned long)(_vmlinux_end - _vmlinux_start);
-
-        /* gunzip the ELF header of the kernel */
-        if (*(unsigned short *)vmlinuz.addr == 0x1f8b) {
-                len = vmlinuz.size;
-                gunzip(elfheader, sizeof(elfheader),
-                                (unsigned char *)vmlinuz.addr, &len);
-        } else
-                memcpy(elfheader, (const void *)vmlinuz.addr,
-                       sizeof(elfheader));
-
-        if (!is_elf64(elfheader) && !is_elf32(elfheader)) {
-                printf("Error: not a valid PPC32 or PPC64 ELF file!\n\r");
-                exit();
+        /* If we have an image attached to us, it overrides anything
+         * supplied by the loader. */
+        if (_initrd_end > _initrd_start) {
+                printf("Attached initrd image at 0x%p-0x%p\n\r",
+                       _initrd_start, _initrd_end);
+                initrd_addr = (unsigned long)_initrd_start;
+                initrd_size = _initrd_end - _initrd_start;
+        } else if (initrd_size > 0) {
+                printf("Using loader supplied ramdisk at 0x%lx-0x%lx\n\r",
+                       initrd_addr, initrd_addr + initrd_size);
         }
-        if (platform_ops.image_hdr)
-                platform_ops.image_hdr(elfheader);
 
-        /* We need to alloc the memsize plus the file offset since gzip
-         * will expand the header (file offset), then the kernel, then
-         * possible rubbish we don't care about. But the kernel bss must
-         * be claimed (it will be zero'd by the kernel itself)
-         */
-        printf("Allocating 0x%lx bytes for kernel ...\n\r", vmlinux.memsize);
-        vmlinux.addr = (unsigned long)malloc(vmlinux.memsize);
-        if (vmlinux.addr == 0) {
-                printf("Can't allocate memory for kernel image !\n\r");
-                exit();
-        }
+        /* If there's no initrd at all, we're done */
+        if (! initrd_size)
+                return (struct addr_range){0, 0};
 
         /*
-         * Now find the initrd
-         *
-         * First see if we have an image attached to us.  If so
-         * allocate memory for it and copy it there.
+         * If the initrd is too low it will be clobbered when the
+         * kernel relocates to its final location.  In this case,
+         * allocate a safer place and move it.
          */
-        initrd.size = (unsigned long)(_initrd_end - _initrd_start);
-        initrd.memsize = initrd.size;
-        if (initrd.size > 0) {
+        if (initrd_addr < vmlinux.size) {
+                void *old_addr = (void *)initrd_addr;
+
                 printf("Allocating 0x%lx bytes for initrd ...\n\r",
-                       initrd.size);
-                initrd.addr = (unsigned long)malloc((u32)initrd.size);
-                if (initrd.addr == 0) {
-                        printf("Can't allocate memory for initial "
-                                        "ramdisk !\n\r");
-                        exit();
-                }
-                printf("initial ramdisk moving 0x%lx <- 0x%lx "
-                        "(0x%lx bytes)\n\r", initrd.addr,
-                        (unsigned long)_initrd_start, initrd.size);
-                memmove((void *)initrd.addr, (void *)_initrd_start,
-                        initrd.size);
-                printf("initrd head: 0x%lx\n\r",
-                                *((unsigned long *)initrd.addr));
-        } else if (a2 != 0) {
-                /* Otherwise, see if yaboot or another loader gave us an initrd */
-                initrd.addr = a1;
-                initrd.memsize = initrd.size = a2;
-                printf("Using loader supplied initrd at 0x%lx (0x%lx bytes)\n\r",
-                       initrd.addr, initrd.size);
+                       initrd_size);
+                initrd_addr = (unsigned long)malloc(initrd_size);
+                if (! initrd_addr)
+                        fatal("Can't allocate memory for initial "
+                               "ramdisk !\n\r");
+                printf("Relocating initrd 0x%lx <- 0x%p (0x%lx bytes)\n\r",
+                       initrd_addr, old_addr, initrd_size);
+                memmove((void *)initrd_addr, old_addr, initrd_size);
         }
 
-        /* Eventually gunzip the kernel */
-        if (*(unsigned short *)vmlinuz.addr == 0x1f8b) {
-                printf("gunzipping (0x%lx <- 0x%lx:0x%0lx)...",
-                       vmlinux.addr, vmlinuz.addr, vmlinuz.addr+vmlinuz.size);
-                len = vmlinuz.size;
-                gunzip((void *)vmlinux.addr, vmlinux.memsize,
-                        (unsigned char *)vmlinuz.addr, &len);
-                printf("done 0x%lx bytes\n\r", len);
-        } else {
-                memmove((void *)vmlinux.addr,(void *)vmlinuz.addr,
-                        vmlinuz.size);
-        }
+        printf("initrd head: 0x%lx\n\r", *((unsigned long *)initrd_addr));
 
-        /* Skip over the ELF header */
-#ifdef DEBUG
-        printf("... skipping 0x%lx bytes of ELF header\n\r",
-                        elfoffset);
-#endif
-        vmlinux.addr += elfoffset;
+        /* Tell the kernel initrd address via device tree */
+        setprop_val(chosen, "linux,initrd-start", (u32)(initrd_addr));
+        setprop_val(chosen, "linux,initrd-end", (u32)(initrd_addr+initrd_size));
 
-        flush_cache((void *)vmlinux.addr, vmlinux.size);
+        return (struct addr_range){(void *)initrd_addr, initrd_size};
 }
 
 /* A buffer that may be edited by tools operating on a zImage binary so as to
  * edit the command line passed to vmlinux (by setting /chosen/bootargs).
  * The buffer is put in it's own section so that tools may locate it easier.
  */
-static char builtin_cmdline[COMMAND_LINE_SIZE]
+static char cmdline[COMMAND_LINE_SIZE]
         __attribute__((__section__("__builtin_cmdline")));
 
-static void get_cmdline(char *buf, int size)
+static void prep_cmdline(void *chosen)
 {
-        void *devp;
-        int len = strlen(builtin_cmdline);
-
-        buf[0] = '\0';
-
-        if (len > 0) { /* builtin_cmdline overrides dt's /chosen/bootargs */
-                len = min(len, size-1);
-                strncpy(buf, builtin_cmdline, len);
-                buf[len] = '\0';
-        }
-        else if ((devp = finddevice("/chosen")))
-                getprop(devp, "bootargs", buf, size);
-}
+        if (cmdline[0] == '\0')
+                getprop(chosen, "bootargs", cmdline, COMMAND_LINE_SIZE-1);
 
-static void set_cmdline(char *buf)
-{
-        void *devp;
+        printf("\n\rLinux/PowerPC load: %s", cmdline);
+        /* If possible, edit the command line */
+        if (console_ops.edit_cmdline)
+                console_ops.edit_cmdline(cmdline, COMMAND_LINE_SIZE);
+        printf("\n\r");
 
-        if ((devp = finddevice("/chosen")))
-                setprop(devp, "bootargs", buf, strlen(buf) + 1);
+        /* Put the command line back into the devtree for the kernel */
+        setprop_str(chosen, "bootargs", cmdline);
 }
 
 struct platform_ops platform_ops;
 struct dt_ops dt_ops;
 struct console_ops console_ops;
+struct loader_info loader_info;
 
-void start(unsigned long a1, unsigned long a2, void *promptr, void *sp)
+void start(void)
 {
+        struct addr_range vmlinux, initrd;
         kernel_entry_t kentry;
-        char cmdline[COMMAND_LINE_SIZE];
         unsigned long ft_addr = 0;
+        void *chosen;
 
-        memset(__bss_start, 0, _end - __bss_start);
-        memset(&platform_ops, 0, sizeof(platform_ops));
-        memset(&dt_ops, 0, sizeof(dt_ops));
-        memset(&console_ops, 0, sizeof(console_ops));
+        /* Do this first, because malloc() could clobber the loader's
+         * command line.  Only use the loader command line if a
+         * built-in command line wasn't set by an external tool */
+        if ((loader_info.cmdline_len > 0) && (cmdline[0] == '\0'))
+                memmove(cmdline, loader_info.cmdline,
+                        min(loader_info.cmdline_len, COMMAND_LINE_SIZE-1));
 
-        if (platform_init(promptr, _dtb_start, _dtb_end))
-                exit();
         if (console_ops.open && (console_ops.open() < 0))
                 exit();
         if (platform_ops.fixups)
                 platform_ops.fixups();
 
         printf("\n\rzImage starting: loaded at 0x%p (sp: 0x%p)\n\r",
-               _start, sp);
+               _start, get_sp());
 
-        prep_kernel(a1, a2);
+        /* Ensure that the device tree has a /chosen node */
+        chosen = finddevice("/chosen");
+        if (!chosen)
+                chosen = create_node(NULL, "chosen");
 
-        /* If cmdline came from zimage wrapper or if we can edit the one
-         * in the dt, print it out and edit it, if possible.
-         */
-        if ((strlen(builtin_cmdline) > 0) || console_ops.edit_cmdline) {
-                get_cmdline(cmdline, COMMAND_LINE_SIZE);
-                printf("\n\rLinux/PowerPC load: %s", cmdline);
-                if (console_ops.edit_cmdline)
-                        console_ops.edit_cmdline(cmdline, COMMAND_LINE_SIZE);
-                printf("\n\r");
-                set_cmdline(cmdline);
-        }
+        vmlinux = prep_kernel();
+        initrd = prep_initrd(vmlinux, chosen,
+                             loader_info.initrd_addr, loader_info.initrd_size);
+        prep_cmdline(chosen);
 
         printf("Finalizing device tree...");
         if (dt_ops.finalize)
@@ -335,7 +203,7 @@ void start(unsigned long a1, unsigned long a2, void *promptr, void *sp)
         if (ft_addr)
                 printf(" flat tree at 0x%lx\n\r", ft_addr);
         else
-                printf(" using OF tree (promptr=%p)\n\r", promptr);
+                printf(" using OF tree (promptr=%p)\n\r", loader_info.promptr);
 
         if (console_ops.close)
                 console_ops.close();
@@ -344,10 +212,9 @@ void start(unsigned long a1, unsigned long a2, void *promptr, void *sp)
         if (ft_addr)
                 kentry(ft_addr, 0, NULL);
         else
-                /* XXX initrd addr/size should be passed in properties */
-                kentry(initrd.addr, initrd.size, promptr);
+                kentry((unsigned long)initrd.addr, initrd.size,
+                       loader_info.promptr);
 
-        /* console closed so printf below may not work */
-        printf("Error: Linux kernel returned to zImage boot wrapper!\n\r");
-        exit();
+        /* console closed so printf in fatal below may not work */
+        fatal("Error: Linux kernel returned to zImage boot wrapper!\n\r");
 }