arch/sparc32/boot.c

   1 /*
   2  *
   3  */
   4 #undef BOOTSTRAP
   5 #include "config.h"
   6 #include "libopenbios/bindings.h"
   7 #include "arch/common/nvram.h"
   8 #include "drivers/drivers.h"
   9 #include "libc/diskio.h"
  10 #include "libc/vsprintf.h"
  11 #include "libopenbios/sys_info.h"
  12 #include "libopenbios/elf_load.h"
  13 #include "libopenbios/aout_load.h"
  14 #include "openprom.h"
  15 #include "boot.h"
  16
  17 struct sys_info sys_info;
  18 uint32_t kernel_image;
  19 uint32_t kernel_size;
  20 uint32_t qemu_cmdline;
  21 uint32_t cmdline_size;
  22 char boot_device;
  23 static int (*entry)(const void *romvec_ptr, int p2, int p3, int p4, int p5);
  24
  25 static int try_path(const char *path, char *param, const void *romvec)
  26 {
  27         void *boot_notes = NULL;
  28         ucell valid, address, type, size;
  29         int image_retval = 0;
  30
  31         push_str(path);
  32         fword("pathres-resolve-aliases");
  33         bootpath = pop_fstr_copy();
  34         printk("Trying %s (%s)\n", path, bootpath);
  35
  36         /* ELF Boot loader */
  37         elf_load(&sys_info, path, param, &boot_notes);
  38         feval("state-valid @");
  39         valid = POP();
  40         if (valid)
  41                 goto start_image;
  42
  43         /* Linux loader (not using Forth) */
  44         linux_load(&sys_info, path, param);
  45
  46         /* a.out loader */
  47         aout_load(&sys_info, path);
  48         feval("state-valid @");
  49         valid = POP();
  50         if (valid)
  51                 goto start_image;
  52
  53         return 0;
  54
  55
  56 start_image:
  57         /* Get the entry point and the type (see forth/debugging/client.fs) */
  58         feval("saved-program-state >sps.entry @");
  59         address = POP();
  60         feval("saved-program-state >sps.file-type @");
  61         type = POP();
  62         feval("saved-program-state >sps.file-size @");
  63         size = POP();
  64
  65         printk("Jumping to entry point " FMT_ucellx " for type " FMT_ucellx "...\n", address, type);
  66
  67         switch (type) {
  68                 case 0x0:
  69                         /* Start ELF boot image */
  70                         entry = (void *) address;
  71                         image_retval = entry(romvec, 0, 0, 0, 0);
  72
  73                         break;
  74
  75                 case 0x5:
  76                         /* Start a.out image */
  77                         entry = (void *) address;
  78                         image_retval = entry(romvec, 0, 0, 0, 0);
  79
  80                         break;
  81         }
  82
  83         printk("Image returned with return value %#x\n", image_retval);
  84
  85         return -1;
  86 }
  87
  88
  89 void boot(void)
  90 {
  91         char *path = pop_fstr_copy(), *param, altpath[256];
  92         const char *oldpath = path;
  93         int unit = 0;
  94         const void *romvec;
  95         int result;
  96
  97         if(!path) {
  98             push_str("boot-device");
  99             push_str("/options");
 100             fword("(find-dev)");
 101             POP();
 102             fword("get-package-property");
 103             if (!POP()) {
 104                 path = pop_fstr_copy();
 105             } else {
 106                 switch (boot_device) {
 107                 case 'a':
 108                     path = strdup("/obio/SUNW,fdtwo");
 109                     oldpath = "fd()";
 110                     break;
 111                 case 'c':
 112                     path = strdup("disk");
 113                     oldpath = "sd(0,0,0):d";
 114                     break;
 115                 default:
 116                 case 'd':
 117                     path = strdup("cdrom");
 118                     // FIXME: hardcoding this looks almost definitely wrong.
 119                     // With sd(0,2,0):b we get to see the solaris kernel though
 120                     //oldpath = "sd(0,2,0):d";
 121                     oldpath = "sd(0,2,0):b";
 122                     unit = 2;
 123                     break;
 124                 case 'n':
 125                     path = strdup("net");
 126                     oldpath = "le()";
 127                     break;
 128                 }
 129             }
 130         }
 131
 132         obp_arg.boot_dev_ctrl = 0;
 133         obp_arg.boot_dev_unit = unit;
 134         obp_arg.dev_partition = 0;
 135         obp_arg.boot_dev[0] = oldpath[0];
 136         obp_arg.boot_dev[1] = oldpath[1];
 137         obp_arg.argv[0] = oldpath;
 138         obp_arg.argv[1] = (void *)(long)qemu_cmdline;
 139
 140         param = strchr(path, ' ');
 141         if(param) {
 142                 *param = '\0';
 143                 param++;
 144         } else if (cmdline_size) {
 145             param = (char *)qemu_cmdline;
 146         } else {
 147             push_str("boot-args");
 148             push_str("/options");
 149             fword("(find-dev)");
 150             POP();
 151             fword("get-package-property");
 152             POP();
 153             param = pop_fstr_copy();
 154             obp_arg.argv[1] = param;
 155         }
 156
 157         romvec = init_openprom();
 158
 159         if (kernel_size) {
 160             printk("[sparc] Kernel already loaded\n");
 161             entry = (void *) kernel_image;
 162             entry(romvec, 0, 0, 0, 0);
 163         }
 164
 165         printk("[sparc] Booting file '%s' ", path);
 166         if (param)
 167                 printk("with parameters '%s'\n", param);
 168         else
 169                 printk("without parameters.\n");
 170
 171         result = try_path(path, param, romvec);
 172         if (!result) {
 173                 push_str(path);
 174                 PUSH(':');
 175                 fword("left-split");
 176                 snprintf(altpath, sizeof(altpath), "%s:d", pop_fstr_copy());
 177                 POP();
 178                 POP();
 179
 180                 try_path(altpath, param, romvec);
 181         }
 182
 183         printk("Unsupported image format\n");
 184
 185         free(path);
 186 }