static void extract_currdev(struct bootinfo *bootinfop) { const char *bootdev; /* * Pick up boot device information from boot2. * * XXXRW: Someday: device units. */ switch(bootinfop->bi_boot_dev_type) { case BOOTINFO_DEV_TYPE_DRAM: bootdev = "dram0"; break; case BOOTINFO_DEV_TYPE_CFI: bootdev = "cfi0"; break; case BOOTINFO_DEV_TYPE_SDCARD: bootdev = "sdcard0"; break; default: bootdev = NULL; } if (bootdev != NULL) { env_setenv("currdev", EV_VOLATILE, bootdev, NULL, env_nounset); env_setenv("loaddev", EV_VOLATILE, bootdev, env_noset, env_nounset); } }
static void cfe_setup_default_env(void) { char buffer[80]; xsprintf(buffer,"%d.%d.%d",CFE_VER_MAJOR,CFE_VER_MINOR,CFE_VER_BUILD); env_setenv("CFE_VERSION",buffer,ENV_FLG_BUILTIN | ENV_FLG_READONLY); if (cfe_boardname) { env_setenv("CFE_BOARDNAME",(char *) cfe_boardname, ENV_FLG_BUILTIN | ENV_FLG_READONLY); } xsprintf(buffer,"%d",mem_totalsize); env_setenv("CFE_MEMORYSIZE",buffer,ENV_FLG_BUILTIN | ENV_FLG_READONLY); }
/* * Select a console. * * XXX Note that the console system design allows for some extension * here (eg. multiple consoles, input/output only, etc.) */ static int cons_set(struct env_var *ev, int flags, void *value) { int cons, active; if ((value == NULL) || ((active = cons_find(value)) == -1)) { if (value != NULL) printf("no such console '%s'\n", (char *)value); printf("Available consoles:\n"); for (cons = 0; consoles[cons] != NULL; cons++) printf(" %s\n", consoles[cons]->c_name); return(CMD_ERROR); } /* disable all current consoles */ for (cons = 0; consoles[cons] != NULL; cons++) consoles[cons]->c_flags &= ~(C_ACTIVEIN | C_ACTIVEOUT); /* enable selected console */ consoles[active]->c_flags |= C_ACTIVEIN | C_ACTIVEOUT; consoles[active]->c_init(0); env_setenv(ev->ev_name, flags | EV_NOHOOK, value, NULL, NULL); return(CMD_OK); }
static void comc_probe(struct console *cp) { char speedbuf[16]; char *cons, *speedenv; int speed; /* XXX check the BIOS equipment list? */ cp->c_flags |= (C_PRESENTIN | C_PRESENTOUT); if (comc_curspeed == 0) { comc_curspeed = COMSPEED; /* * Assume that the speed was set by an earlier boot loader if * comconsole is already the preferred console. */ cons = getenv("console"); if ((cons != NULL && strcmp(cons, comconsole.c_name) == 0) || getenv("boot_multicons") != NULL) { comc_curspeed = comc_getspeed(); } speedenv = getenv("comconsole_speed"); if (speedenv != NULL) { speed = comc_parsespeed(speedenv); if (speed > 0) comc_curspeed = speed; } sprintf(speedbuf, "%d", comc_curspeed); unsetenv("comconsole_speed"); env_setenv("comconsole_speed", EV_VOLATILE, speedbuf, comc_speed_set, env_nounset); } }
/* * Set the 'current device' by (if possible) recovering the boot device as * supplied by the initial bootstrap. */ static void extract_currdev(void) { struct disk_devdesc dev; //bzero(&dev, sizeof(dev)); #if defined(USERBOOT_ZFS_SUPPORT) if (userboot_zfs_found) { struct zfs_devdesc zdev; /* Leave the pool/root guid's unassigned */ bzero(&zdev, sizeof(zdev)); zdev.d_dev = &zfs_dev; zdev.d_type = zdev.d_dev->dv_type; dev = *(struct disk_devdesc *)&zdev; init_zfs_bootenv(zfs_fmtdev(&dev)); } else #endif if (userboot_disk_maxunit > 0) { dev.d_dev = &userboot_disk; dev.d_type = dev.d_dev->dv_type; dev.d_unit = 0; dev.d_slice = 0; dev.d_partition = 0; /* * If we cannot auto-detect the partition type then * access the disk as a raw device. */ if (dev.d_dev->dv_open(NULL, &dev)) { dev.d_slice = -1; dev.d_partition = -1; } } else { dev.d_dev = &host_dev; dev.d_type = dev.d_dev->dv_type; dev.d_unit = 0; } env_setenv("currdev", EV_VOLATILE, userboot_fmtdev(&dev), userboot_setcurrdev, env_nounset); env_setenv("loaddev", EV_VOLATILE, userboot_fmtdev(&dev), env_noset, env_nounset); }
int setenv(const char *name, const char *value, int overwrite) { /* No guarantees about state, always assume volatile */ if (overwrite || (env_getenv(name) == NULL)) return(env_setenv(name, EV_VOLATILE, value, NULL, NULL)); return(0); }
/* * Set currdev to suit the value being supplied in (value) */ int ski_setcurrdev(struct env_var *ev, int flags, void *value) { struct ski_devdesc *ncurr; int rv; if ((rv = ski_parsedev(&ncurr, value, NULL)) != 0) return(rv); free(ncurr); env_setenv(ev->ev_name, flags | EV_NOHOOK, value, NULL, NULL); return(0); }
int ofw_setcurrdev(struct env_var *ev, int flags, const void *value) { struct ofw_devdesc *ncurr; int rv; if ((rv = ofw_parsedev(&ncurr, value, NULL)) != 0) return rv; free(ncurr); env_setenv(ev->ev_name, flags | EV_NOHOOK, value, NULL, NULL); return 0; }
/* * Set currdev to suit the value being supplied in (value) */ int ia64_setcurrdev(struct env_var *ev, int flags, const void *value) { struct devdesc *ncurr; int rv; rv = ia64_parsedev(&ncurr, value, NULL); if (rv != 0) return(rv); free(ncurr); env_setenv(ev->ev_name, flags | EV_NOHOOK, value, NULL, NULL); return (0); }
/* * Detect possible console(s) to use. If preferred console(s) have been * specified, mark them as active. Else, mark the first probed console * as active. Also create the console variable. */ void cons_probe(void) { int cons; int active; char *prefconsole; /* Do all console probes */ for (cons = 0; consoles[cons] != NULL; cons++) { consoles[cons]->c_flags = 0; consoles[cons]->c_probe(consoles[cons]); } /* Now find the first working one */ active = -1; for (cons = 0; consoles[cons] != NULL && active == -1; cons++) { consoles[cons]->c_flags = 0; consoles[cons]->c_probe(consoles[cons]); if (consoles[cons]->c_flags == (C_PRESENTIN | C_PRESENTOUT)) active = cons; } /* Force a console even if all probes failed */ if (active == -1) active = 0; /* Check to see if a console preference has already been registered */ prefconsole = getenv("console"); if (prefconsole != NULL) prefconsole = strdup(prefconsole); if (prefconsole != NULL) { unsetenv("console"); /* we want to replace this */ cons_change(prefconsole); } else { consoles[active]->c_flags |= C_ACTIVEIN | C_ACTIVEOUT; consoles[active]->c_init(0); prefconsole = strdup(consoles[active]->c_name); } printf("Consoles: "); for (cons = 0; consoles[cons] != NULL; cons++) if (consoles[cons]->c_flags & (C_ACTIVEIN | C_ACTIVEOUT)) printf("%s ", consoles[cons]->c_desc); printf("\n"); if (prefconsole != NULL) { env_setenv("console", EV_VOLATILE, prefconsole, cons_set, env_nounset); free(prefconsole); } }
static int comc_speed_set(struct env_var *ev, int flags, const void *value) { int speed; if (value == NULL || (speed = comc_parsespeed(value)) <= 0) { printf("Invalid speed\n"); return (CMD_ERROR); } if (comc_started && comc_curspeed != speed) comc_setup(speed); env_setenv(ev->ev_name, flags | EV_NOHOOK, value, NULL, NULL); return (CMD_OK); }
/* * Select one or more consoles. */ static int cons_set(struct env_var *ev, int flags, const void *value) { int cons; if ((value == NULL) || (cons_check(value) == -1)) { if (value != NULL) printf("no such console!\n"); printf("Available consoles:\n"); for (cons = 0; consoles[cons] != NULL; cons++) printf(" %s\n", consoles[cons]->c_name); return(CMD_ERROR); } cons_change(value); env_setenv(ev->ev_name, flags | EV_NOHOOK, value, NULL, NULL); return(CMD_OK); }
int cfe_set_console(char *name) { xprinthook = console_xprint; #if !CFG_MINIMAL_SIZE if (strcmp(name,CFE_BUFFER_CONSOLE) == 0) { console_buffer_flg = 1; return 0; } #endif if (name) { int res; res = env_setenv("BOOT_CONSOLE",name, ENV_FLG_BUILTIN | ENV_FLG_READONLY | ENV_FLG_ADMIN); return console_open(name); } return -1; }
/* * Detect possible console(s) to use. The first probed console * is marked active. Also create the console variable. * * XXX Add logic for multiple console support. */ void cons_probe(void) { int cons; int active; char *prefconsole; /* Do all console probes */ for (cons = 0; consoles[cons] != NULL; cons++) { consoles[cons]->c_flags = 0; consoles[cons]->c_probe(consoles[cons]); } /* Now find the first working one */ active = -1; for (cons = 0; consoles[cons] != NULL && active == -1; cons++) { consoles[cons]->c_flags = 0; consoles[cons]->c_probe(consoles[cons]); if (consoles[cons]->c_flags == (C_PRESENTIN | C_PRESENTOUT)) active = cons; } /* Check to see if a console preference has already been registered */ prefconsole = getenv("console"); if (prefconsole != NULL) prefconsole = strdup(prefconsole); if (prefconsole != NULL) { unsetenv("console"); /* we want to replace this */ for (cons = 0; consoles[cons] != NULL; cons++) /* look for the nominated console, use it if it's functional */ if (!strcmp(prefconsole, consoles[cons]->c_name) && (consoles[cons]->c_flags == (C_PRESENTIN | C_PRESENTOUT))) active = cons; free(prefconsole); } if (active == -1) active = 0; consoles[active]->c_flags |= (C_ACTIVEIN | C_ACTIVEOUT); consoles[active]->c_init(0); printf("Console: %s\n", consoles[active]->c_desc); env_setenv("console", EV_VOLATILE, consoles[active]->c_name, (ev_sethook_t *) cons_set, env_nounset); }
EFI_STATUS main(int argc, CHAR16 *argv[]) { char var[128]; EFI_LOADED_IMAGE *img; EFI_GUID *guid; int i, j, vargood, unit, howto; struct devsw *dev; uint64_t pool_guid; UINTN k; int has_kbd; archsw.arch_autoload = efi_autoload; archsw.arch_getdev = efi_getdev; archsw.arch_copyin = efi_copyin; archsw.arch_copyout = efi_copyout; archsw.arch_readin = efi_readin; #ifdef EFI_ZFS_BOOT /* Note this needs to be set before ZFS init. */ archsw.arch_zfs_probe = efi_zfs_probe; #endif has_kbd = has_keyboard(); /* * XXX Chicken-and-egg problem; we want to have console output * early, but some console attributes may depend on reading from * eg. the boot device, which we can't do yet. We can use * printf() etc. once this is done. */ cons_probe(); /* * Initialise the block cache. Set the upper limit. */ bcache_init(32768, 512); /* * Parse the args to set the console settings, etc * boot1.efi passes these in, if it can read /boot.config or /boot/config * or iPXE may be setup to pass these in. * * Loop through the args, and for each one that contains an '=' that is * not the first character, add it to the environment. This allows * loader and kernel env vars to be passed on the command line. Convert * args from UCS-2 to ASCII (16 to 8 bit) as they are copied. */ howto = 0; for (i = 1; i < argc; i++) { if (argv[i][0] == '-') { for (j = 1; argv[i][j] != 0; j++) { int ch; ch = argv[i][j]; switch (ch) { case 'a': howto |= RB_ASKNAME; break; case 'd': howto |= RB_KDB; break; case 'D': howto |= RB_MULTIPLE; break; case 'h': howto |= RB_SERIAL; break; case 'm': howto |= RB_MUTE; break; case 'p': howto |= RB_PAUSE; break; case 'P': if (!has_kbd) howto |= RB_SERIAL | RB_MULTIPLE; break; case 'r': howto |= RB_DFLTROOT; break; case 's': howto |= RB_SINGLE; break; case 'S': if (argv[i][j + 1] == 0) { if (i + 1 == argc) { setenv("comconsole_speed", "115200", 1); } else { cp16to8(&argv[i + 1][0], var, sizeof(var)); setenv("comconsole_speedspeed", var, 1); } i++; break; } else { cp16to8(&argv[i][j + 1], var, sizeof(var)); setenv("comconsole_speed", var, 1); break; } case 'v': howto |= RB_VERBOSE; break; } } } else { vargood = 0; for (j = 0; argv[i][j] != 0; j++) { if (j == sizeof(var)) { vargood = 0; break; } if (j > 0 && argv[i][j] == '=') vargood = 1; var[j] = (char)argv[i][j]; } if (vargood) { var[j] = 0; putenv(var); } } } for (i = 0; howto_names[i].ev != NULL; i++) if (howto & howto_names[i].mask) setenv(howto_names[i].ev, "YES", 1); if (howto & RB_MULTIPLE) { if (howto & RB_SERIAL) setenv("console", "comconsole efi" , 1); else setenv("console", "efi comconsole" , 1); } else if (howto & RB_SERIAL) { setenv("console", "comconsole" , 1); } if (efi_copy_init()) { printf("failed to allocate staging area\n"); return (EFI_BUFFER_TOO_SMALL); } /* * March through the device switch probing for things. */ for (i = 0; devsw[i] != NULL; i++) if (devsw[i]->dv_init != NULL) (devsw[i]->dv_init)(); /* Get our loaded image protocol interface structure. */ BS->HandleProtocol(IH, &imgid, (VOID**)&img); printf("Command line arguments:"); for (i = 0; i < argc; i++) { printf(" "); print_str16(argv[i]); } printf("\n"); printf("Image base: 0x%lx\n", (u_long)img->ImageBase); printf("EFI version: %d.%02d\n", ST->Hdr.Revision >> 16, ST->Hdr.Revision & 0xffff); printf("EFI Firmware: "); /* printf doesn't understand EFI Unicode */ ST->ConOut->OutputString(ST->ConOut, ST->FirmwareVendor); printf(" (rev %d.%02d)\n", ST->FirmwareRevision >> 16, ST->FirmwareRevision & 0xffff); printf("\n"); printf("%s, Revision %s\n", bootprog_name, bootprog_rev); printf("(%s, %s)\n", bootprog_maker, bootprog_date); /* * Disable the watchdog timer. By default the boot manager sets * the timer to 5 minutes before invoking a boot option. If we * want to return to the boot manager, we have to disable the * watchdog timer and since we're an interactive program, we don't * want to wait until the user types "quit". The timer may have * fired by then. We don't care if this fails. It does not prevent * normal functioning in any way... */ BS->SetWatchdogTimer(0, 0, 0, NULL); if (efi_handle_lookup(img->DeviceHandle, &dev, &unit, &pool_guid) != 0) return (EFI_NOT_FOUND); switch (dev->dv_type) { #ifdef EFI_ZFS_BOOT case DEVT_ZFS: { struct zfs_devdesc currdev; currdev.d_dev = dev; currdev.d_unit = unit; currdev.d_type = currdev.d_dev->dv_type; currdev.d_opendata = NULL; currdev.pool_guid = pool_guid; currdev.root_guid = 0; env_setenv("currdev", EV_VOLATILE, efi_fmtdev(&currdev), efi_setcurrdev, env_nounset); env_setenv("loaddev", EV_VOLATILE, efi_fmtdev(&currdev), env_noset, env_nounset); init_zfs_bootenv(zfs_fmtdev(&currdev)); break; } #endif default: { struct devdesc currdev; currdev.d_dev = dev; currdev.d_unit = unit; currdev.d_opendata = NULL; currdev.d_type = currdev.d_dev->dv_type; env_setenv("currdev", EV_VOLATILE, efi_fmtdev(&currdev), efi_setcurrdev, env_nounset); env_setenv("loaddev", EV_VOLATILE, efi_fmtdev(&currdev), env_noset, env_nounset); break; } } setenv("LINES", "24", 1); /* optional */ for (k = 0; k < ST->NumberOfTableEntries; k++) { guid = &ST->ConfigurationTable[k].VendorGuid; if (!memcmp(guid, &smbios, sizeof(EFI_GUID))) { smbios_detect(ST->ConfigurationTable[k].VendorTable); break; } } interact(NULL); /* doesn't return */ return (EFI_SUCCESS); /* keep compiler happy */ }
EFI_STATUS main(int argc, CHAR16 *argv[]) { char var[128]; EFI_LOADED_IMAGE *img; EFI_GUID *guid; int i, j, vargood; /* * XXX Chicken-and-egg problem; we want to have console output * early, but some console attributes may depend on reading from * eg. the boot device, which we can't do yet. We can use * printf() etc. once this is done. */ cons_probe(); /* * Loop through the args, and for each one that contains an '=' that is * not the first character, add it to the environment. This allows * loader and kernel env vars to be passed on the command line. Convert * args from UCS-2 to ASCII (16 to 8 bit) as they are copied. */ for (i = 1; i < argc; i++) { vargood = 0; for (j = 0; argv[i][j] != 0; j++) { if (j == sizeof(var)) { vargood = 0; break; } if (j > 0 && argv[i][j] == '=') vargood = 1; var[j] = (char)argv[i][j]; } if (vargood) { var[j] = 0; putenv(var); } } if (efi_copy_init()) { printf("failed to allocate staging area\n"); return (EFI_BUFFER_TOO_SMALL); } /* * March through the device switch probing for things. */ for (i = 0; devsw[i] != NULL; i++) if (devsw[i]->dv_init != NULL) (devsw[i]->dv_init)(); /* Get our loaded image protocol interface structure. */ BS->HandleProtocol(IH, &imgid, (VOID**)&img); printf("Image base: 0x%lx\n", (u_long)img->ImageBase); printf("EFI version: %d.%02d\n", ST->Hdr.Revision >> 16, ST->Hdr.Revision & 0xffff); printf("EFI Firmware: "); /* printf doesn't understand EFI Unicode */ ST->ConOut->OutputString(ST->ConOut, ST->FirmwareVendor); printf(" (rev %d.%02d)\n", ST->FirmwareRevision >> 16, ST->FirmwareRevision & 0xffff); printf("\n"); printf("%s, Revision %s\n", bootprog_name, bootprog_rev); printf("(%s, %s)\n", bootprog_maker, bootprog_date); efi_handle_lookup(img->DeviceHandle, &currdev.d_dev, &currdev.d_unit); currdev.d_type = currdev.d_dev->dv_type; /* * Disable the watchdog timer. By default the boot manager sets * the timer to 5 minutes before invoking a boot option. If we * want to return to the boot manager, we have to disable the * watchdog timer and since we're an interactive program, we don't * want to wait until the user types "quit". The timer may have * fired by then. We don't care if this fails. It does not prevent * normal functioning in any way... */ BS->SetWatchdogTimer(0, 0, 0, NULL); env_setenv("currdev", EV_VOLATILE, efi_fmtdev(&currdev), efi_setcurrdev, env_nounset); env_setenv("loaddev", EV_VOLATILE, efi_fmtdev(&currdev), env_noset, env_nounset); setenv("LINES", "24", 1); /* optional */ archsw.arch_autoload = efi_autoload; archsw.arch_getdev = efi_getdev; archsw.arch_copyin = efi_copyin; archsw.arch_copyout = efi_copyout; archsw.arch_readin = efi_readin; for (i = 0; i < ST->NumberOfTableEntries; i++) { guid = &ST->ConfigurationTable[i].VendorGuid; if (!memcmp(guid, &smbios, sizeof(EFI_GUID))) { smbios_detect(ST->ConfigurationTable[i].VendorTable); break; } } interact(NULL); /* doesn't return */ return (EFI_SUCCESS); /* keep compiler happy */ }
/* ********************************************************************* * cfe_boot(la) * * Bootstrap the system. * * Input parameters: * la - loader arguments * * Return value: * error, or does not return ********************************************************************* */ int cfe_boot(char *ldrname,cfe_loadargs_t *la) { int res; la->la_entrypt = 0; if (la->la_flags & LOADFLG_NOISY) { xprintf("Loading: "); } res = cfe_load_program(ldrname,la); if (res < 0) { if (la->la_flags & LOADFLG_NOISY) { xprintf("Failed.\n"); } return res; } /* * Special case: If loading a batch file, just do the commands here * and return. For batch files we don't want to set up the * environment variables. */ if (la->la_flags & LOADFLG_BATCH) { #if CFG_UI ui_docommands((char *) la->la_entrypt); #endif return 0; } /* * Otherwise set up for running a real program. */ if (la->la_flags & LOADFLG_NOISY) { xprintf("Entry at 0x%p\n",la->la_entrypt); } /* * Set up the environment variables for the bootstrap */ if (la->la_device) { env_setenv(bootvar_device,la->la_device,ENV_FLG_BUILTIN); } else { env_delenv(bootvar_device); } if (la->la_filename) { env_setenv(bootvar_file,la->la_filename,ENV_FLG_BUILTIN); } else { env_delenv(bootvar_file); } if (la->la_options) { env_setenv(bootvar_flags,la->la_options,ENV_FLG_BUILTIN); } else { env_delenv(bootvar_flags); } /* * Banzai! Run the program. */ if ((la->la_flags & LOADFLG_EXECUTE) && (la->la_entrypt != 0)) { cfe_go(la); } return 0; }
int main(void) { struct api_signature *sig = NULL; int i; struct open_file f; if (!api_search_sig(&sig)) return (-1); syscall_ptr = sig->syscall; if (syscall_ptr == NULL) return (-2); if (sig->version > API_SIG_VERSION) return (-3); /* Clear BSS sections */ bzero(__sbss_start, __sbss_end - __sbss_start); bzero(__bss_start, _end - __bss_start); /* * Set up console. */ cons_probe(); printf("Compatible API signature found @%x\n", (uint32_t)sig); dump_sig(sig); dump_addr_info(); /* * Initialise the heap as early as possible. Once this is done, * alloc() is usable. The stack is buried inside us, so this is * safe. */ setheap((void *)end, (void *)(end + 512 * 1024)); /* * Enumerate U-Boot devices */ if ((devs_no = ub_dev_enum()) == 0) panic("no U-Boot devices found"); printf("Number of U-Boot devices: %d\n", devs_no); printf("\n"); printf("%s, Revision %s\n", bootprog_name, bootprog_rev); printf("(%s, %s)\n", bootprog_maker, bootprog_date); meminfo(); /* * March through the device switch probing for things. */ for (i = 0; devsw[i] != NULL; i++) { if (devsw[i]->dv_init == NULL) continue; if ((devsw[i]->dv_init)() != 0) continue; printf("\nDevice: %s\n", devsw[i]->dv_name); currdev.d_dev = devsw[i]; currdev.d_type = currdev.d_dev->dv_type; currdev.d_unit = 0; if (strncmp(devsw[i]->dv_name, "disk", strlen(devsw[i]->dv_name)) == 0) { f.f_devdata = &currdev; currdev.d_disk.slice = 0; if (devsw[i]->dv_open(&f,&currdev) == 0) break; } if (strncmp(devsw[i]->dv_name, "net", strlen(devsw[i]->dv_name)) == 0) break; } if (devsw[i] == NULL) panic("No boot device found!"); env_setenv("currdev", EV_VOLATILE, uboot_fmtdev(&currdev), uboot_setcurrdev, env_nounset); env_setenv("loaddev", EV_VOLATILE, uboot_fmtdev(&currdev), env_noset, env_nounset); setenv("LINES", "24", 1); /* optional */ setenv("prompt", "loader>", 1); archsw.arch_getdev = uboot_getdev; archsw.arch_copyin = uboot_copyin; archsw.arch_copyout = uboot_copyout; archsw.arch_readin = uboot_readin; archsw.arch_autoload = uboot_autoload; interact(); /* doesn't return */ return (0); }
/* * board_final_init() * * Do any final initialization, such as adding commands to the * user interface. * * If you don't want a user interface, put the startup code here. * This routine is called just before CFE starts its user interface. * * Input parameters: * nothing * * Return value: * nothing */ void board_final_init(void) { char *addr, *mask, *wait_time; char buf[512], *cur = buf; #ifdef CFG_ROMBOOT char *laddr = NULL; #endif #if !CFG_SIM char *boot_cfg = NULL; char *go_cmd = "go;"; #endif int commit = 0; uint32 ncdl; #if CFG_WL && CFG_WLU && CFG_SIM char *ssid; #endif ui_init_bcm947xxcmds(); /* Force commit of embedded NVRAM */ commit = restore_defaults; /* Set the SDRAM NCDL value into NVRAM if not already done */ if ((getintvar(NULL, "sdram_ncdl") == 0) && ((ncdl = si_memc_get_ncdl(sih)) != 0)) { sprintf(buf, "0x%x", ncdl); nvram_set("sdram_ncdl", buf); commit = 1; } /* Set the bootloader version string if not already done */ sprintf(buf, "CFE %s", EPI_VERSION_STR); if (strcmp(nvram_safe_get("pmon_ver"), buf) != 0) { nvram_set("pmon_ver", buf); commit = 1; } /* Set the size of the nvram area if not already done */ sprintf(buf, "%d", MAX_NVRAM_SPACE); if (strcmp(nvram_safe_get("nvram_space"), buf) != 0) { nvram_set("nvram_space", buf); commit = 1; } #ifdef RTL8365MB int ret = -1, retry = 0; rtk_port_mac_ability_t pa; GPIO_INIT(); for(retry = 0; ret && retry < 10; ++retry) { ret = rtk_switch_init(); if(ret) cfe_usleep(10000); else break; } printf("rtl8354mb initialized(%d)(retry %d) %s\n", ret, retry, ret?"failed":""); ret = rtk_port_phyEnableAll_set(1); if(ret) printf("rtk port_phyEnableAll Failed!(%d)\n", ret); else printf("rtk port_phyEnableAll ok\n"); /* configure & set GMAC ports */ pa.forcemode = MAC_FORCE; pa.speed = SPD_1000M; pa.duplex = FULL_DUPLEX; pa.link = 1; pa.nway = 0; pa.rxpause = 0; pa.txpause = 0; ret = rtk_port_macForceLinkExt_set(EXT_PORT0, MODE_EXT_RGMII, &pa); if(ret) printf("rtk port_macForceLink_set ext_Port0 Failed!(%d)\n", ret); else printf("rtk port_macForceLink_set ext_Port0 ok\n"); /* asic chk */ rtk_uint32 retVal, retVal2; rtk_uint32 data, data2; if((retVal = rtl8367c_getAsicReg(0x1311, &data)) != RT_ERR_OK || (retVal2 = rtl8367c_getAsicReg(0x1305, &data2)) != RT_ERR_OK) { printf("get failed(%d)(%d). (%x)(supposed to be 0x1016)\n", retVal, retVal2, data); } else { /* get ok, then chk reg*/ printf("get ok, chk 0x1311:%x(0x1016), 0x1305:%x(b4~b7:0x1)\n", data, data2); if(data != 0x1016){ printf("\n!! rtl reg 0x1311 error: (%d)(get %x)\n", retVal, data); } if((data2 & 0xf0) != 0x10) { printf("\n!! rtl reg 0x1305 error: (%d)(get %x)\n", retVal, data2); } } /* reset tx/rx delay */ retVal = rtk_port_rgmiiDelayExt_set(EXT_PORT0, 1, 4); if (retVal != RT_ERR_OK) printf("\n!! rtl set delay failed (%d)\n", retVal); #endif #if CFG_FLASH || CFG_SFLASH || CFG_NFLASH #if !CFG_SIM /* Commit NVRAM only if in FLASH */ if ( #ifdef BCMNVRAMW !nvram_inotp() && #endif commit) { printf("Committing NVRAM..."); nvram_commit(); printf("done\n"); if (restore_defaults) { #ifdef BCM_DEVINFO /* devinfo nvram hash table sync */ devinfo_nvram_sync(); #endif printf("Waiting for wps button release..."); reset_release_wait(); printf("done\n"); } } /* Reboot after restoring defaults */ if (restore_defaults) si_watchdog(sih, 1); #endif /* !CFG_SIM */ #else if (commit) printf("Flash not configured, not commiting NVRAM...\n"); #endif /* CFG_FLASH || CFG_SFLASH || CFG_NFLASH */ /* * Read the wait_time NVRAM variable and set the tftp max retries. * Assumption: tftp_rrq_timeout & tftp_recv_timeout are set to 1sec. */ if ((wait_time = nvram_get("wait_time")) != NULL) { tftp_max_retries = atoi(wait_time); if (tftp_max_retries > MAX_WAIT_TIME) tftp_max_retries = MAX_WAIT_TIME; else if (tftp_max_retries < MIN_WAIT_TIME) tftp_max_retries = MIN_WAIT_TIME; } #ifdef CFG_ROMBOOT else if (board_bootdev_rom(sih)) { tftp_max_retries = 10; } #endif /* Configure network */ if (cfe_finddev("eth0")) { int res; if ((addr = nvram_get("lan_ipaddr")) && (mask = nvram_get("lan_netmask"))) sprintf(buf, "ifconfig eth0 -addr=%s -mask=%s", addr, mask); else sprintf(buf, "ifconfig eth0 -auto"); res = ui_docommand(buf); #ifdef CFG_ROMBOOT /* Try indefinite netboot only while booting from ROM * and we are sure that we dont have valid nvram in FLASH */ while (board_bootdev_rom(sih) && !addr) { char ch; cur = buf; /* Check if something typed at console */ if (console_status()) { console_read(&ch, 1); /* Check for Ctrl-C */ if (ch == 3) { if (laddr) MFREE(osh, laddr, MAX_SCRIPT_FSIZE); xprintf("Stopped auto netboot!!!\n"); return; } } if (!res) { char *bserver, *bfile, *load_ptr; if (!laddr) laddr = MALLOC(osh, MAX_SCRIPT_FSIZE); if (!laddr) { load_ptr = (char *) 0x00008000; xprintf("Failed malloc for boot_script, Using :0x%x\n", (unsigned int)laddr); } else { load_ptr = laddr; } bserver = (bserver = env_getenv("BOOT_SERVER")) ? bserver:"192.168.1.1"; if ((bfile = env_getenv("BOOT_FILE"))) { int len; if (((len = strlen(bfile)) > 5) && !strncmp((bfile + len - 5), "cfesh", 5)) { cur += sprintf(cur, "batch -raw -tftp -addr=0x%x -max=0x%x %s:%s;", (unsigned int)load_ptr, MAX_SCRIPT_FSIZE, bserver, bfile); } if (((len = strlen(bfile)) > 3)) { if (!strncmp((bfile + len - 3), "elf", 3)) { cur += sprintf(cur, "boot -elf -tftp -max=0x5000000 %s:%s;", bserver, bfile); } if (!strncmp((bfile + len - 3), "raw", 3)) { cur += sprintf(cur, "boot -raw -z -tftp -addr=0x00008000" " -max=0x5000000 %s:%s;", bserver, bfile); } } } else { /* Make last effort */ cur += sprintf(cur, "batch -raw -tftp -addr=0x%x -max=0x%x %s:%s;", (unsigned int)load_ptr, MAX_SCRIPT_FSIZE, bserver, "cfe_script.cfesh"); cur += sprintf(cur, "boot -elf -tftp -max=0x5000000 %s:%s;", bserver, "boot_file.elf"); cur += sprintf(cur, "boot -raw -z -tftp -addr=0x00008000" " -max=0x5000000 %s:%s;", bserver, "boot_file.raw"); } ui_docommand(buf); cfe_sleep(3*CFE_HZ); } sprintf(buf, "ifconfig eth0 -auto"); res = ui_docommand(buf); } #endif /* CFG_ROMBOOT */ } #if CFG_WL && CFG_WLU && CFG_SIM if ((ssid = nvram_get("wl0_ssid"))) { sprintf(buf, "wl join %s", ssid); ui_docommand(buf); } #endif #if !CFG_SIM /* Try to run boot_config command if configured. * make sure to leave space for "go" command. */ if ((boot_cfg = nvram_get("boot_config"))) { if (strlen(boot_cfg) < (sizeof(buf) - sizeof(go_cmd))) cur += sprintf(cur, "%s;", boot_cfg); else printf("boot_config too long, skipping to autoboot\n"); } /* Boot image */ cur += sprintf(cur, go_cmd); #endif /* !CFG_SIM */ /* Startup */ if (cur > buf) env_setenv("STARTUP", buf, ENV_FLG_NORMAL); }
EFI_STATUS main(int argc, CHAR16 *argv[]) { struct devdesc currdev; EFI_LOADED_IMAGE *img; char *dev; int i; /* * XXX Chicken-and-egg problem; we want to have console output * early, but some console attributes may depend on reading from * eg. the boot device, which we can't do yet. We can use * printf() etc. once this is done. */ cons_probe(); printf("\n%s, Revision %s\n", bootprog_name, bootprog_rev); find_pal_proc(); /* * March through the device switch probing for things. */ for (i = 0; devsw[i] != NULL; i++) if (devsw[i]->dv_init != NULL) (devsw[i]->dv_init)(); /* * Disable the watchdog timer. By default the boot manager sets * the timer to 5 minutes before invoking a boot option. If we * want to return to the boot manager, we have to disable the * watchdog timer and since we're an interactive program, we don't * want to wait until the user types "quit". The timer may have * fired by then. We don't care if this fails. It does not prevent * normal functioning in any way... */ BS->SetWatchdogTimer(0, 0, 0, NULL); /* Get our loaded image protocol interface structure. */ BS->HandleProtocol(IH, &imgid, (VOID**)&img); bzero(&currdev, sizeof(currdev)); efi_handle_lookup(img->DeviceHandle, &currdev.d_dev, &currdev.d_unit); currdev.d_type = currdev.d_dev->dv_type; env_setenv("loaddev", EV_VOLATILE, ia64_fmtdev(&currdev), env_noset, env_nounset); dev = get_dev_option(argc, argv); if (dev == NULL) dev = ia64_fmtdev(&currdev); env_setenv("currdev", EV_VOLATILE, dev, ia64_setcurrdev, env_nounset); setenv("LINES", "24", 1); /* optional */ archsw.arch_autoload = ia64_autoload; archsw.arch_copyin = ia64_copyin; archsw.arch_copyout = ia64_copyout; archsw.arch_getdev = ia64_getdev; archsw.arch_loadaddr = ia64_loadaddr; archsw.arch_loadseg = ia64_loadseg; archsw.arch_readin = ia64_readin; interact(); /* doesn't return */ return (EFI_SUCCESS); /* keep compiler happy */ }
int main(void) { uint64_t maxmem = 0; void *heapbase; int i, err; struct ps3_devdesc currdev; struct open_file f; lv1_get_physmem(&maxmem); ps3mmu_init(maxmem); /* * Set up console. */ cons_probe(); /* * Set the heap to one page after the end of the loader. */ heapbase = (void *)(maxmem - 0x80000); setheap(heapbase, maxmem); /* * March through the device switch probing for things. */ for (i = 0; devsw[i] != NULL; i++) { if (devsw[i]->dv_init != NULL) { err = (devsw[i]->dv_init)(); if (err) { printf("\n%s: initialization failed err=%d\n", devsw[i]->dv_name, err); continue; } } currdev.d_dev = devsw[i]; currdev.d_type = currdev.d_dev->dv_type; if (strcmp(devsw[i]->dv_name, "cd") == 0) { f.f_devdata = &currdev; currdev.d_unit = 0; if (devsw[i]->dv_open(&f, &currdev) == 0) break; } if (strcmp(devsw[i]->dv_name, "disk") == 0) { f.f_devdata = &currdev; currdev.d_unit = 3; currdev.d_disk.pnum = 1; currdev.d_disk.ptype = PTYPE_GPT; if (devsw[i]->dv_open(&f, &currdev) == 0) break; } if (strcmp(devsw[i]->dv_name, "net") == 0) break; } if (devsw[i] == NULL) panic("No boot device found!"); else printf("Boot device: %s\n", devsw[i]->dv_name); /* * Get timebase at boot. */ basetb = mftb(); archsw.arch_getdev = ps3_getdev; archsw.arch_copyin = ps3_copyin; archsw.arch_copyout = ps3_copyout; archsw.arch_readin = ps3_readin; archsw.arch_autoload = ps3_autoload; printf("\n"); printf("%s, Revision %s\n", bootprog_name, bootprog_rev); printf("(%s, %s)\n", bootprog_maker, bootprog_date); printf("Memory: %lldKB\n", maxmem / 1024); env_setenv("currdev", EV_VOLATILE, ps3_fmtdev(&currdev), ps3_setcurrdev, env_nounset); env_setenv("loaddev", EV_VOLATILE, ps3_fmtdev(&currdev), env_noset, env_nounset); setenv("LINES", "24", 1); setenv("hw.platform", "ps3", 1); interact(); /* doesn't return */ return (0); }
void ski_main(void) { static char malloc[512*1024]; int i; /* * initialise the heap as early as possible. Once this is done, * alloc() is usable. The stack is buried inside us, so this is * safe. */ setheap((void *)malloc, (void *)(malloc + 512*1024)); /* * XXX Chicken-and-egg problem; we want to have console output * early, but some console attributes may depend on reading from * eg. the boot device, which we can't do yet. We can use * printf() etc. once this is done. */ cons_probe(); /* * March through the device switch probing for things. */ for (i = 0; devsw[i] != NULL; i++) if (devsw[i]->dv_init != NULL) (devsw[i]->dv_init)(); printf("\n"); printf("%s, Revision %s\n", bootprog_name, bootprog_rev); printf("(%s, %s)\n", bootprog_maker, bootprog_date); #if 0 printf("Memory: %ld k\n", memsize() / 1024); #endif /* XXX presumes that biosdisk is first in devsw */ currdev.d_dev = devsw[0]; currdev.d_type = currdev.d_dev->dv_type; currdev.d_unit = 0; #if 0 /* Create arc-specific variables */ bootfile = GetEnvironmentVariable(ARCENV_BOOTFILE); if (bootfile) setenv("bootfile", bootfile, 1); #endif env_setenv("currdev", EV_VOLATILE, ia64_fmtdev(&currdev), ia64_setcurrdev, env_nounset); env_setenv("loaddev", EV_VOLATILE, ia64_fmtdev(&currdev), env_noset, env_nounset); setenv("LINES", "24", 1); /* optional */ archsw.arch_autoload = ia64_autoload; archsw.arch_copyin = ia64_copyin; archsw.arch_copyout = ia64_copyout; archsw.arch_getdev = ia64_getdev; archsw.arch_loadaddr = ia64_loadaddr; archsw.arch_loadseg = ia64_loadseg; archsw.arch_readin = ia64_readin; interact(); /* doesn't return */ exit(0); }
int main(int (*openfirm)(void *)) { phandle_t root; int i; char bootpath[64]; char *ch; int bargc; char **bargv; /* * Initialize the Open Firmware routines by giving them the entry point. */ OF_init(openfirm); root = OF_finddevice("/"); scells = acells = 1; OF_getprop(root, "#address-cells", &acells, sizeof(acells)); OF_getprop(root, "#size-cells", &scells, sizeof(scells)); /* * Initialise the heap as early as possible. Once this is done, * alloc() is usable. The stack is buried inside us, so this is * safe. */ init_heap(); /* * Set up console. */ cons_probe(); /* * March through the device switch probing for things. */ for (i = 0; devsw[i] != NULL; i++) if (devsw[i]->dv_init != NULL) (devsw[i]->dv_init)(); printf("\n"); printf("%s, Revision %s\n", bootprog_name, bootprog_rev); printf("(%s, %s)\n", bootprog_maker, bootprog_date); printf("Memory: %lldKB\n", memsize() / 1024); OF_getprop(chosen, "bootpath", bootpath, 64); ch = strchr(bootpath, ':'); *ch = '\0'; printf("Booted from: %s\n", bootpath); printf("\n"); /* * Only parse the first bootarg if present. It should * be simple to handle extra arguments */ OF_getprop(chosen, "bootargs", bootargs, sizeof(bootargs)); bargc = 0; parse(&bargc, &bargv, bootargs); if (bargc == 1) env_setenv("currdev", EV_VOLATILE, bargv[0], ofw_setcurrdev, env_nounset); else env_setenv("currdev", EV_VOLATILE, bootpath, ofw_setcurrdev, env_nounset); env_setenv("loaddev", EV_VOLATILE, bootpath, env_noset, env_nounset); setenv("LINES", "24", 1); /* optional */ archsw.arch_getdev = ofw_getdev; archsw.arch_copyin = ofw_copyin; archsw.arch_copyout = ofw_copyout; archsw.arch_readin = ofw_readin; archsw.arch_autoload = ofw_autoload; interact(NULL); /* doesn't return */ OF_exit(); return 0; }
EFI_STATUS main(int argc, CHAR16 *argv[]) { EFI_LOADED_IMAGE *img; int i; /* * XXX Chicken-and-egg problem; we want to have console output * early, but some console attributes may depend on reading from * eg. the boot device, which we can't do yet. We can use * printf() etc. once this is done. */ cons_probe(); /* * Initialise the block cache */ bcache_init(32, 512); /* 16k XXX tune this */ find_pal_proc(); /* * March through the device switch probing for things. */ for (i = 0; devsw[i] != NULL; i++) if (devsw[i]->dv_init != NULL) (devsw[i]->dv_init)(); efinet_init_driver(); /* Get our loaded image protocol interface structure. */ BS->HandleProtocol(IH, &imgid, (VOID**)&img); printf("Image base: 0x%016lx\n", (u_long)img->ImageBase); printf("\n"); printf("%s, Revision %s\n", bootprog_name, bootprog_rev); printf("(%s, %s)\n", bootprog_maker, bootprog_date); i = efifs_get_unit(img->DeviceHandle); if (i >= 0) { currdev.d_dev = devsw[0]; /* XXX disk */ currdev.d_kind.efidisk.unit = i; /* XXX should be able to detect this, default to autoprobe */ currdev.d_kind.efidisk.slice = -1; currdev.d_kind.efidisk.partition = 0; } else { currdev.d_dev = devsw[1]; /* XXX net */ currdev.d_kind.netif.unit = 0; /* XXX */ } currdev.d_type = currdev.d_dev->dv_type; /* * Disable the watchdog timer. By default the boot manager sets * the timer to 5 minutes before invoking a boot option. If we * want to return to the boot manager, we have to disable the * watchdog timer and since we're an interactive program, we don't * want to wait until the user types "quit". The timer may have * fired by then. We don't care if this fails. It does not prevent * normal functioning in any way... */ BS->SetWatchdogTimer(0, 0, 0, NULL); env_setenv("currdev", EV_VOLATILE, efi_fmtdev(&currdev), efi_setcurrdev, env_nounset); env_setenv("loaddev", EV_VOLATILE, efi_fmtdev(&currdev), env_noset, env_nounset); setenv("LINES", "24", 1); /* optional */ archsw.arch_autoload = efi_autoload; archsw.arch_getdev = efi_getdev; archsw.arch_copyin = efi_copyin; archsw.arch_copyout = efi_copyout; archsw.arch_readin = efi_readin; interact(); /* doesn't return */ return (EFI_SUCCESS); /* keep compiler happy */ }
int start_command(struct child_process *cmd) { int need_in, need_out, need_err; int fdin[2], fdout[2], fderr[2]; /* * In case of errors we must keep the promise to close FDs * that have been passed in via ->in and ->out. */ need_in = !cmd->no_stdin && cmd->in < 0; if (need_in) { if (pipe(fdin) < 0) { if (cmd->out > 0) close(cmd->out); return -ERR_RUN_COMMAND_PIPE; } cmd->in = fdin[1]; } need_out = !cmd->no_stdout && !cmd->stdout_to_stderr && cmd->out < 0; if (need_out) { if (pipe(fdout) < 0) { if (need_in) close_pair(fdin); else if (cmd->in) close(cmd->in); return -ERR_RUN_COMMAND_PIPE; } cmd->out = fdout[0]; } need_err = !cmd->no_stderr && cmd->err < 0; if (need_err) { if (pipe(fderr) < 0) { if (need_in) close_pair(fdin); else if (cmd->in) close(cmd->in); if (need_out) close_pair(fdout); else if (cmd->out) close(cmd->out); return -ERR_RUN_COMMAND_PIPE; } cmd->err = fderr[0]; } trace_argv_printf(cmd->argv, "trace: run_command:"); #ifndef __MINGW32__ cmd->pid = fork(); if (!cmd->pid) { if (cmd->no_stdin) dup_devnull(0); else if (need_in) { dup2(fdin[0], 0); close_pair(fdin); } else if (cmd->in) { dup2(cmd->in, 0); close(cmd->in); } if (cmd->no_stderr) dup_devnull(2); else if (need_err) { dup2(fderr[1], 2); close_pair(fderr); } if (cmd->no_stdout) dup_devnull(1); else if (cmd->stdout_to_stderr) dup2(2, 1); else if (need_out) { dup2(fdout[1], 1); close_pair(fdout); } else if (cmd->out > 1) { dup2(cmd->out, 1); close(cmd->out); } if (cmd->dir && chdir(cmd->dir)) die("exec %s: cd to %s failed (%s)", cmd->argv[0], cmd->dir, strerror(errno)); if (cmd->env) { for (; *cmd->env; cmd->env++) { if (strchr(*cmd->env, '=')) putenv((char*)*cmd->env); else unsetenv(*cmd->env); } } if (cmd->git_cmd) { execv_git_cmd(cmd->argv); } else { execvp(cmd->argv[0], (char *const*) cmd->argv); } die("exec %s failed.", cmd->argv[0]); } #else int s0 = -1, s1 = -1, s2 = -1; /* backups of stdin, stdout, stderr */ const char *sargv0 = cmd->argv[0]; char **env = environ; struct strbuf git_cmd; if (cmd->no_stdin) { s0 = dup(0); dup_devnull(0); } else if (need_in) { s0 = dup(0); dup2(fdin[0], 0); } else if (cmd->in) { s0 = dup(0); dup2(cmd->in, 0); } if (cmd->no_stderr) { s2 = dup(2); dup_devnull(2); } else if (need_err) { s2 = dup(2); dup2(fderr[1], 2); } if (cmd->no_stdout) { s1 = dup(1); dup_devnull(1); } else if (cmd->stdout_to_stderr) { s1 = dup(1); dup2(2, 1); } else if (need_out) { s1 = dup(1); dup2(fdout[1], 1); } else if (cmd->out > 1) { s1 = dup(1); dup2(cmd->out, 1); } if (cmd->dir) die("chdir in start_command() not implemented"); if (cmd->env) { env = copy_environ(); for (; *cmd->env; cmd->env++) env = env_setenv(env, *cmd->env); } if (cmd->git_cmd) { strbuf_init(&git_cmd, 0); strbuf_addf(&git_cmd, "git-%s", cmd->argv[0]); cmd->argv[0] = git_cmd.buf; } cmd->pid = mingw_spawnvpe(cmd->argv[0], cmd->argv, env); if (cmd->env) free_environ(env); if (cmd->git_cmd) strbuf_release(&git_cmd); cmd->argv[0] = sargv0; if (s0 >= 0) dup2(s0, 0), close(s0); if (s1 >= 0) dup2(s1, 1), close(s1); if (s2 >= 0) dup2(s2, 2), close(s2); #endif if (cmd->pid < 0) { if (need_in) close_pair(fdin); else if (cmd->in) close(cmd->in); if (need_out) close_pair(fdout); else if (cmd->out) close(cmd->out); if (need_err) close_pair(fderr); return -ERR_RUN_COMMAND_FORK; } if (need_in) close(fdin[0]); else if (cmd->in) close(cmd->in); if (need_out) close(fdout[1]); else if (cmd->out) close(cmd->out); if (need_err) close(fderr[1]); return 0; }
int main(void) { struct api_signature *sig = NULL; int load_type, load_unit, load_slice, load_partition; int i; const char * loaderdev; /* * If we can't find the magic signature and related info, exit with a * unique error code that U-Boot reports as "## Application terminated, * rc = 0xnnbadab1". Hopefully 'badab1' looks enough like "bad api" to * provide a clue. It's better than 0xffffffff anyway. */ if (!api_search_sig(&sig)) return (0x01badab1); syscall_ptr = sig->syscall; if (syscall_ptr == NULL) return (0x02badab1); if (sig->version > API_SIG_VERSION) return (0x03badab1); /* Clear BSS sections */ bzero(__sbss_start, __sbss_end - __sbss_start); bzero(__bss_start, _end - __bss_start); /* * Initialise the heap as early as possible. Once this is done, * alloc() is usable. The stack is buried inside us, so this is safe. */ uboot_heap_start = round_page((uintptr_t)end); uboot_heap_end = uboot_heap_start + 512 * 1024; setheap((void *)uboot_heap_start, (void *)uboot_heap_end); /* * Set up console. */ cons_probe(); printf("Compatible U-Boot API signature found @%x\n", (uint32_t)sig); printf("\n"); printf("%s, Revision %s\n", bootprog_name, bootprog_rev); printf("(%s, %s)\n", bootprog_maker, bootprog_date); printf("\n"); dump_sig(sig); dump_addr_info(); meminfo(); /* * Enumerate U-Boot devices */ if ((devs_no = ub_dev_enum()) == 0) panic("no U-Boot devices found"); printf("Number of U-Boot devices: %d\n", devs_no); get_load_device(&load_type, &load_unit, &load_slice, &load_partition); /* * March through the device switch probing for things. */ for (i = 0; devsw[i] != NULL; i++) { if (devsw[i]->dv_init == NULL) continue; if ((devsw[i]->dv_init)() != 0) continue; printf("Found U-Boot device: %s\n", devsw[i]->dv_name); currdev.d_dev = devsw[i]; currdev.d_type = currdev.d_dev->dv_type; currdev.d_unit = 0; if ((load_type == -1 || (load_type & DEV_TYP_STOR)) && strcmp(devsw[i]->dv_name, "disk") == 0) { if (probe_disks(i, load_type, load_unit, load_slice, load_partition) == 0) break; } if ((load_type == -1 || (load_type & DEV_TYP_NET)) && strcmp(devsw[i]->dv_name, "net") == 0) break; } /* * If we couldn't find a boot device, return an error to u-boot. * U-boot may be running a boot script that can try something different * so returning an error is better than forcing a reboot. */ if (devsw[i] == NULL) { printf("No boot device found!\n"); return (0xbadef1ce); } env_setenv("currdev", EV_VOLATILE, uboot_fmtdev(&currdev), uboot_setcurrdev, env_nounset); env_setenv("loaddev", EV_VOLATILE, uboot_fmtdev(&currdev), env_noset, env_nounset); setenv("LINES", "24", 1); /* optional */ setenv("prompt", "loader>", 1); archsw.arch_loadaddr = uboot_loadaddr; archsw.arch_getdev = uboot_getdev; archsw.arch_copyin = uboot_copyin; archsw.arch_copyout = uboot_copyout; archsw.arch_readin = uboot_readin; archsw.arch_autoload = uboot_autoload; interact(); /* doesn't return */ return (0); }
int main(void) { struct api_signature *sig = NULL; int diskdev, i, netdev, usedev; struct open_file f; const char * loaderdev; if (!api_search_sig(&sig)) return (-1); syscall_ptr = sig->syscall; if (syscall_ptr == NULL) return (-2); if (sig->version > API_SIG_VERSION) return (-3); /* Clear BSS sections */ bzero(__sbss_start, __sbss_end - __sbss_start); bzero(__bss_start, _end - __bss_start); /* * Set up console. */ cons_probe(); printf("Compatible API signature found @%x\n", (uint32_t)sig); dump_sig(sig); dump_addr_info(); /* * Initialise the heap as early as possible. Once this is done, * alloc() is usable. The stack is buried inside us, so this is * safe. */ setheap((void *)end, (void *)(end + 512 * 1024)); /* * Enumerate U-Boot devices */ if ((devs_no = ub_dev_enum()) == 0) panic("no U-Boot devices found"); printf("Number of U-Boot devices: %d\n", devs_no); printf("\n"); printf("%s, Revision %s\n", bootprog_name, bootprog_rev); printf("(%s, %s)\n", bootprog_maker, bootprog_date); meminfo(); /* * March through the device switch probing for things -- sort of. * * The devsw array will have one or two items in it. If * LOADER_DISK_SUPPORT is defined the first item will be a disk (which * may not actually work if u-boot didn't supply one). If * LOADER_NET_SUPPORT is defined the next item will be a network * interface. Again it may not actually work at the u-boot level. * * The original logic was to always use a disk if it could be * successfully opened, otherwise use the network interface. Now that * logic is amended to first check whether the u-boot environment * contains a loaderdev variable which tells us which device to use. If * it does, we use it and skip the original (second) loop which "probes" * for a device. We still loop over the devsw just in case it ever gets * expanded to hold more than 2 devices (but then unit numbers, which * don't currently exist, may come into play). If the device named by * loaderdev isn't found, fall back using to the old "probe" loop. * * The original probe loop still effectively behaves as it always has: * the first usable disk device is choosen, and a network device is used * only if no disk device is found. The logic has been reworked so that * it examines (and thus lists) every potential device along the way * instead of breaking out of the loop when the first device is found. */ loaderdev = ub_env_get("loaderdev"); usedev = -1; if (loaderdev != NULL) { for (i = 0; devsw[i] != NULL; i++) { if (strcmp(loaderdev, devsw[i]->dv_name) == 0) { if (devsw[i]->dv_init == NULL) continue; if ((devsw[i]->dv_init)() != 0) continue; usedev = i; goto have_device; } } printf("U-Boot env contains 'loaderdev=%s', " "device not found.\n", loaderdev); } printf("Probing for bootable devices...\n"); diskdev = -1; netdev = -1; for (i = 0; devsw[i] != NULL; i++) { if (devsw[i]->dv_init == NULL) continue; if ((devsw[i]->dv_init)() != 0) continue; printf("Bootable device: %s\n", devsw[i]->dv_name); if (strncmp(devsw[i]->dv_name, "disk", strlen(devsw[i]->dv_name)) == 0) { f.f_devdata = &currdev; currdev.d_dev = devsw[i]; currdev.d_type = currdev.d_dev->dv_type; currdev.d_unit = 0; currdev.d_disk.slice = 0; if (devsw[i]->dv_open(&f, &currdev) == 0) { devsw[i]->dv_close(&f); if (diskdev == -1) diskdev = i; } } else if (strncmp(devsw[i]->dv_name, "net", strlen(devsw[i]->dv_name)) == 0) { if (netdev == -1) netdev = i; } } if (diskdev != -1) usedev = diskdev; else if (netdev != -1) usedev = netdev; else panic("No bootable devices found!\n"); have_device: currdev.d_dev = devsw[usedev]; currdev.d_type = devsw[usedev]->dv_type; currdev.d_unit = 0; if (currdev.d_type == DEV_TYP_STOR) currdev.d_disk.slice = 0; printf("Current device: %s\n", currdev.d_dev->dv_name); env_setenv("currdev", EV_VOLATILE, uboot_fmtdev(&currdev), uboot_setcurrdev, env_nounset); env_setenv("loaddev", EV_VOLATILE, uboot_fmtdev(&currdev), env_noset, env_nounset); setenv("LINES", "24", 1); /* optional */ setenv("prompt", "loader>", 1); archsw.arch_getdev = uboot_getdev; archsw.arch_copyin = uboot_copyin; archsw.arch_copyout = uboot_copyout; archsw.arch_readin = uboot_readin; archsw.arch_autoload = uboot_autoload; interact(); /* doesn't return */ return (0); }
EFI_STATUS main(int argc, CHAR16 *argv[]) { char vendor[128]; EFI_LOADED_IMAGE *img; int i; /* * XXX Chicken-and-egg problem; we want to have console output * early, but some console attributes may depend on reading from * eg. the boot device, which we can't do yet. We can use * printf() etc. once this is done. */ cons_probe(); if (x86_efi_copy_init()) { printf("failed to allocate staging area\n"); return (EFI_BUFFER_TOO_SMALL); } /* * March through the device switch probing for things. */ for (i = 0; devsw[i] != NULL; i++) if (devsw[i]->dv_init != NULL) (devsw[i]->dv_init)(); /* Get our loaded image protocol interface structure. */ BS->HandleProtocol(IH, &imgid, (VOID**)&img); printf("Image base: 0x%lx\n", (u_long)img->ImageBase); printf("EFI version: %d.%02d\n", ST->Hdr.Revision >> 16, ST->Hdr.Revision & 0xffff); printf("EFI Firmware: "); /* printf doesn't understand EFI Unicode */ ST->ConOut->OutputString(ST->ConOut, ST->FirmwareVendor); printf(" (rev %d.%02d)\n", ST->FirmwareRevision >> 16, ST->FirmwareRevision & 0xffff); printf("\n"); printf("%s, Revision %s\n", bootprog_name, bootprog_rev); printf("(%s, %s)\n", bootprog_maker, bootprog_date); efi_handle_lookup(img->DeviceHandle, &currdev.d_dev, &currdev.d_unit); currdev.d_type = currdev.d_dev->dv_type; /* * Disable the watchdog timer. By default the boot manager sets * the timer to 5 minutes before invoking a boot option. If we * want to return to the boot manager, we have to disable the * watchdog timer and since we're an interactive program, we don't * want to wait until the user types "quit". The timer may have * fired by then. We don't care if this fails. It does not prevent * normal functioning in any way... */ BS->SetWatchdogTimer(0, 0, 0, NULL); env_setenv("currdev", EV_VOLATILE, x86_efi_fmtdev(&currdev), x86_efi_setcurrdev, env_nounset); env_setenv("loaddev", EV_VOLATILE, x86_efi_fmtdev(&currdev), env_noset, env_nounset); setenv("LINES", "24", 1); /* optional */ archsw.arch_autoload = x86_efi_autoload; archsw.arch_getdev = x86_efi_getdev; archsw.arch_copyin = x86_efi_copyin; archsw.arch_copyout = x86_efi_copyout; archsw.arch_readin = x86_efi_readin; interact(NULL); /* doesn't return */ return (EFI_SUCCESS); /* keep compiler happy */ }
int main(int (*openfirm)(void *)) { char bootpath[64]; struct devsw **dp; phandle_t chosenh; /* * Tell the OpenFirmware functions where they find the ofw gate. */ OF_init(openfirm); archsw.arch_getdev = ofw_getdev; archsw.arch_copyin = sparc64_copyin; archsw.arch_copyout = ofw_copyout; archsw.arch_readin = sparc64_readin; archsw.arch_autoload = sparc64_autoload; init_heap(); setheap((void *)heapva, (void *)(heapva + HEAPSZ)); /* * Probe for a console. */ cons_probe(); tlb_init(); bcache_init(32, 512); /* * Initialize devices. */ for (dp = devsw; *dp != 0; dp++) { if ((*dp)->dv_init != 0) (*dp)->dv_init(); } /* * Set up the current device. */ chosenh = OF_finddevice("/chosen"); OF_getprop(chosenh, "bootpath", bootpath, sizeof(bootpath)); /* * Sun compatible bootable CD-ROMs have a disk label placed * before the cd9660 data, with the actual filesystem being * in the first partition, while the other partitions contain * pseudo disk labels with embedded boot blocks for different * architectures, which may be followed by UFS filesystems. * The firmware will set the boot path to the partition it * boots from ('f' in the sun4u case), but we want the kernel * to be loaded from the cd9660 fs ('a'), so the boot path * needs to be altered. */ if (bootpath[strlen(bootpath) - 2] == ':' && bootpath[strlen(bootpath) - 1] == 'f') { bootpath[strlen(bootpath) - 1] = 'a'; printf("Boot path set to %s\n", bootpath); } env_setenv("currdev", EV_VOLATILE, bootpath, ofw_setcurrdev, env_nounset); env_setenv("loaddev", EV_VOLATILE, bootpath, env_noset, env_nounset); printf("\n"); printf("%s, Revision %s\n", bootprog_name, bootprog_rev); printf("(%s, %s)\n", bootprog_maker, bootprog_date); printf("bootpath=\"%s\"\n", bootpath); /* Give control to the machine independent loader code. */ interact(); return 1; }
/* * board_final_init() * * Do any final initialization, such as adding commands to the * user interface. * * If you don't want a user interface, put the startup code here. * This routine is called just before CFE starts its user interface. * * Input parameters: * nothing * * Return value: * nothing */ void board_final_init(void) { char *addr, *mask, *wait_time; char buf[512], *cur = buf; #ifdef CFG_ROMBOOT char *laddr = NULL; #endif #if !CFG_SIM char *boot_cfg = NULL; char *go_cmd = "go;"; #endif int commit = 0; uint32 ncdl; #if CFG_WL && CFG_WLU && CFG_SIM char *ssid; #endif ui_init_bcm947xxcmds(); /* Force commit of embedded NVRAM */ // commit = restore_defaults; commit = 0; /* Set the SDRAM NCDL value into NVRAM if not already done */ if ((getintvar(NULL, "sdram_ncdl") == 0) && ((ncdl = si_memc_get_ncdl(sih)) != 0)) { sprintf(buf, "0x%x", ncdl); nvram_set("sdram_ncdl", buf); commit = 1; } /* Set the bootloader version string if not already done */ sprintf(buf, "CFE %s", EPI_VERSION_STR); if (strcmp(nvram_safe_get("pmon_ver"), buf) != 0) { nvram_set("pmon_ver", buf); commit = 1; } /* Set the size of the nvram area if not already done */ sprintf(buf, "%d", MAX_NVRAM_SPACE); if (strcmp(nvram_safe_get("nvram_space"), buf) != 0) { nvram_set("nvram_space", buf); commit = 1; } #if CFG_FLASH || CFG_SFLASH || CFG_NFLASH #if !CFG_SIM /* Commit NVRAM only if in FLASH */ if ( #ifdef BCMNVRAMW !nvram_inotp() && #endif commit) { printf("Committing NVRAM..."); nvram_commit(); printf("done\n"); if (restore_defaults) { printf("Waiting for reset button release..."); reset_release_wait(); printf("done\n"); } } /* Reboot after restoring defaults */ if (restore_defaults) si_watchdog(sih, 1); #endif /* !CFG_SIM */ #else if (commit) printf("Flash not configured, not commiting NVRAM...\n"); #endif /* CFG_FLASH || CFG_SFLASH || CFG_NFLASH */ /* * Read the wait_time NVRAM variable and set the tftp max retries. * Assumption: tftp_rrq_timeout & tftp_recv_timeout are set to 1sec. */ if ((wait_time = nvram_get("wait_time")) != NULL) { tftp_max_retries = atoi(wait_time); if (tftp_max_retries > MAX_WAIT_TIME) tftp_max_retries = MAX_WAIT_TIME; else if (tftp_max_retries < MIN_WAIT_TIME) tftp_max_retries = MIN_WAIT_TIME; } #ifdef CFG_ROMBOOT else if (board_bootdev_rom(sih)) { tftp_max_retries = 10; } #endif /* Configure network */ if (cfe_finddev("eth0")) { int res; if ((addr = nvram_get("lan_ipaddr")) && (mask = nvram_get("lan_netmask"))) sprintf(buf, "ifconfig eth0 -addr=%s -mask=%s", addr, mask); else sprintf(buf, "ifconfig eth0 -auto"); res = ui_docommand(buf); #ifdef CFG_ROMBOOT /* Try indefinite netboot only while booting from ROM * and we are sure that we dont have valid nvram in FLASH */ while (board_bootdev_rom(sih) && !addr) { char ch; cur = buf; /* Check if something typed at console */ if (console_status()) { console_read(&ch, 1); /* Check for Ctrl-C */ if (ch == 3) { if (laddr) MFREE(osh, laddr, MAX_SCRIPT_FSIZE); xprintf("Stopped auto netboot!!!\n"); return; } } if (!res) { char *bserver, *bfile, *load_ptr; if (!laddr) laddr = MALLOC(osh, MAX_SCRIPT_FSIZE); if (!laddr) { load_ptr = (char *) 0x00008000; xprintf("Failed malloc for boot_script, Using :0x%x\n", (unsigned int)laddr); } else { load_ptr = laddr; } bserver = (bserver = env_getenv("BOOT_SERVER")) ? bserver:"192.168.1.1"; if ((bfile = env_getenv("BOOT_FILE"))) { int len; if (((len = strlen(bfile)) > 5) && !strncmp((bfile + len - 5), "cfesh", 5)) { cur += sprintf(cur, "batch -raw -tftp -addr=0x%x -max=0x%x %s:%s;", (unsigned int)load_ptr, MAX_SCRIPT_FSIZE, bserver, bfile); } if (((len = strlen(bfile)) > 3)) { if (!strncmp((bfile + len - 3), "elf", 3)) { cur += sprintf(cur, "boot -elf -tftp -max=0x5000000 %s:%s;", bserver, bfile); } if (!strncmp((bfile + len - 3), "raw", 3)) { cur += sprintf(cur, "boot -raw -z -tftp -addr=0x00008000" " -max=0x5000000 %s:%s;", bserver, bfile); } } } else { /* Make last effort */ cur += sprintf(cur, "batch -raw -tftp -addr=0x%x -max=0x%x %s:%s;", (unsigned int)load_ptr, MAX_SCRIPT_FSIZE, bserver, "cfe_script.cfesh"); cur += sprintf(cur, "boot -elf -tftp -max=0x5000000 %s:%s;", bserver, "boot_file.elf"); cur += sprintf(cur, "boot -raw -z -tftp -addr=0x00008000" " -max=0x5000000 %s:%s;", bserver, "boot_file.raw"); } ui_docommand(buf); cfe_sleep(3*CFE_HZ); } sprintf(buf, "ifconfig eth0 -auto"); res = ui_docommand(buf); } #endif /* CFG_ROMBOOT */ } #if CFG_WL && CFG_WLU && CFG_SIM if ((ssid = nvram_get("wl0_ssid"))) { sprintf(buf, "wl join %s", ssid); ui_docommand(buf); } #endif #if !CFG_SIM /* Try to run boot_config command if configured. * make sure to leave space for "go" command. */ if ((boot_cfg = nvram_get("boot_config"))) { if (strlen(boot_cfg) < (sizeof(buf) - sizeof(go_cmd))) cur += sprintf(cur, "%s;", boot_cfg); else printf("boot_config too long, skipping to autoboot\n"); } /* Boot image */ cur += sprintf(cur, go_cmd); #endif /* !CFG_SIM */ /* Startup */ if (cur > buf) env_setenv("STARTUP", buf, ENV_FLG_NORMAL); }