lib_sparc/bootm.c

   1 /* SPARC code for booting linux 2.6
   2  *
   3  * (C) Copyright 2007
   4  * Daniel Hellstrom, Gaisler Research, daniel@gaisler.com.
   5  *
   6  * See file CREDITS for list of people who contributed to this
   7  * project.
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License as
  11  * published by the Free Software Foundation; either version 2 of
  12  * the License, or (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  22  * MA 02111-1307 USA
  23  */
  24
  25 #include <common.h>
  26 #include <command.h>
  27 #include <asm/byteorder.h>
  28 #include <asm/prom.h>
  29 #include <asm/cache.h>
  30
  31 #define PRINT_KERNEL_HEADER
  32
  33 extern image_header_t header;
  34 extern void srmmu_init_cpu(unsigned int entry);
  35 extern void prepare_bootargs(char *bootargs);
  36 extern int do_reset(cmd_tbl_t * cmdtp, int flag, int argc, char *argv[]);
  37
  38 #ifdef CONFIG_USB_UHCI
  39 extern int usb_lowlevel_stop(void);
  40 #endif
  41
  42 /* sparc kernel argument (the ROM vector) */
  43 struct linux_romvec *kernel_arg_promvec;
  44
  45 /* page szie is 4k */
  46 #define PAGE_SIZE 0x1000
  47 #define RAMDISK_IMAGE_START_MASK        0x07FF
  48 #define RAMDISK_PROMPT_FLAG             0x8000
  49 #define RAMDISK_LOAD_FLAG               0x4000
  50 struct __attribute__ ((packed)) {
  51         char traptable[PAGE_SIZE];
  52         char swapper_pg_dir[PAGE_SIZE];
  53         char pg0[PAGE_SIZE];
  54         char pg1[PAGE_SIZE];
  55         char pg2[PAGE_SIZE];
  56         char pg3[PAGE_SIZE];
  57         char empty_bad_page[PAGE_SIZE];
  58         char empty_bad_page_table[PAGE_SIZE];
  59         char empty_zero_page[PAGE_SIZE];
  60         unsigned char hdr[4];   /* ascii "HdrS" */
  61         /* 00.02.06.0b is for Linux kernel 2.6.11 */
  62         unsigned char linuxver_mega_major;
  63         unsigned char linuxver_major;
  64         unsigned char linuxver_minor;
  65         unsigned char linuxver_revision;
  66         /* header version 0x0203 */
  67         unsigned short hdr_ver;
  68         union __attribute__ ((packed)) {
  69                 struct __attribute__ ((packed)) {
  70                         unsigned short root_flags;
  71                         unsigned short root_dev;
  72                         unsigned short ram_flags;
  73                         unsigned int sparc_ramdisk_image;
  74                         unsigned int sparc_ramdisk_size;
  75                         unsigned int reboot_command;
  76                         unsigned int resv[3];
  77                         unsigned int end;
  78                 } ver_0203;
  79         } hdr_input;
  80 } *linux_hdr;
  81
  82 /* temporary initrd image holder */
  83 image_header_t ihdr;
  84
  85 /* boot the linux kernel */
  86 void do_bootm_linux(cmd_tbl_t * cmdtp, int flag, int argc, char *argv[],
  87                     bootm_headers_t * images)
  88 {
  89         char *bootargs;
  90         ulong load;
  91         ulong initrd_start, initrd_end;
  92         ulong rd_data_start, rd_data_end, rd_len;
  93         unsigned int data, len, checksum;
  94         unsigned int initrd_addr, kernend;
  95         void (*kernel) (struct linux_romvec *, void *);
  96         struct lmb *lmb = images->lmb;
  97         int ret;
  98
  99         if (images->legacy_hdr_valid) {
 100                 load = image_get_load(images->legacy_hdr_os);
 101 #if defined(CONFIG_FIT)
 102         } else if (images->fit_uname_os) {
 103                 ret = fit_image_get_load(images->fit_hdr_os,
 104                                          images->fit_noffset_os, &load);
 105                 if (ret) {
 106                         puts("Can't get load address property!\n");
 107                         goto error;
 108                 }
 109 #endif
 110         } else {
 111                 puts("Could not find kernel entry point!\n");
 112                 goto error;
 113         }
 114
 115         /* Get virtual address of kernel start */
 116         linux_hdr = (void *)load;
 117
 118         /* */
 119         kernel = (void (*)(struct linux_romvec *, void *))images->ep;
 120
 121         /* check for a SPARC kernel */
 122         if ((linux_hdr->hdr[0] != 'H') ||
 123             (linux_hdr->hdr[1] != 'd') ||
 124             (linux_hdr->hdr[2] != 'r') || (linux_hdr->hdr[3] != 'S')) {
 125                 puts("Error reading header of SPARC Linux kernel, aborting\n");
 126                 goto error;
 127         }
 128 #ifdef PRINT_KERNEL_HEADER
 129         printf("## Found SPARC Linux kernel %d.%d.%d ...\n",
 130                linux_hdr->linuxver_major,
 131                linux_hdr->linuxver_minor, linux_hdr->linuxver_revision);
 132 #endif
 133
 134 #ifdef CONFIG_USB_UHCI
 135         usb_lowlevel_stop();
 136 #endif
 137
 138         /* set basic boot params in kernel header now that it has been
 139          * extracted and is writeable.
 140          */
 141
 142         /*
 143          * Are we going to use an initrd image?
 144          */
 145         ret = boot_get_ramdisk(argc, argv, images, IH_ARCH_SPARC,
 146                                &rd_data_start, &rd_data_end);
 147         if (ret) {
 148                 /* RAM disk found but was corrupt */
 149                 puts("RAM Disk corrupt\n");
 150                 goto error;
 151         }
 152
 153         /* Calc length of RAM disk, if zero no ramdisk available */
 154         rd_len = rd_data_end - rd_data_start;
 155
 156         if (rd_len) {
 157
 158                 /* Reserve the space used by PROM and stack. This is done
 159                  * to avoid that the RAM image is copied over stack or
 160                  * PROM.
 161                  */
 162                 lmb_reserve(lmb, CFG_RELOC_MONITOR_BASE, CFG_RAM_END);
 163
 164                 ret = boot_ramdisk_high(lmb, rd_data_start, rd_len,
 165                                         &initrd_start, &initrd_end);
 166                 if (ret) {
 167                         puts("### Failed to relocate RAM disk\n");
 168                         goto error;
 169                 }
 170
 171                 /* Update SPARC kernel header so that Linux knows
 172                  * what is going on and where to find RAM disk.
 173                  *
 174                  * Set INITRD Image address relative to RAM Start
 175                  */
 176                 linux_hdr->hdr_input.ver_0203.sparc_ramdisk_image =
 177                     initrd_start - CFG_RAM_BASE;
 178                 linux_hdr->hdr_input.ver_0203.sparc_ramdisk_size = rd_len;
 179                 /* Clear READ ONLY flag if set to non-zero */
 180                 linux_hdr->hdr_input.ver_0203.root_flags = 1;
 181                 /* Set root device to: Root_RAM0 */
 182                 linux_hdr->hdr_input.ver_0203.root_dev = 0x100;
 183                 linux_hdr->hdr_input.ver_0203.ram_flags = 0;
 184         } else {
 185                 /* NOT using RAMDISK image, overwriting kernel defaults */
 186                 linux_hdr->hdr_input.ver_0203.sparc_ramdisk_image = 0;
 187                 linux_hdr->hdr_input.ver_0203.sparc_ramdisk_size = 0;
 188                 /* Leave to kernel defaults
 189                    linux_hdr->hdr_input.ver_0203.root_flags = 1;
 190                    linux_hdr->hdr_input.ver_0203.root_dev = 0;
 191                    linux_hdr->hdr_input.ver_0203.ram_flags = 0;
 192                  */
 193         }
 194
 195         /* Copy bootargs from bootargs variable to kernel readable area */
 196         bootargs = getenv("bootargs");
 197         prepare_bootargs(bootargs);
 198
 199         /* turn on mmu & setup context table & page table for process 0 (kernel) */
 200         srmmu_init_cpu((unsigned int)kernel);
 201
 202         /* Enter SPARC Linux kernel
 203          * From now on the only code in u-boot that will be
 204          * executed is the PROM code.
 205          */
 206         kernel(kernel_arg_promvec, (void *)ep);
 207
 208         /* It will never come to this... */
 209         while (1) ;
 210
 211       error:
 212         do_reset(cmdtp, flag, argc, argv);
 213         return;
 214 }