bmp_image_t *gunzip_bmp(unsigned long addr, unsigned long *lenp) { void *dst; unsigned long len; bmp_image_t *bmp; /* * Decompress bmp image */ len = CONFIG_SYS_VIDEO_LOGO_MAX_SIZE; dst = malloc(CONFIG_SYS_VIDEO_LOGO_MAX_SIZE); if (dst == NULL) { puts("Error: malloc in gunzip failed!\n"); return NULL; } if (gunzip(dst, CONFIG_SYS_VIDEO_LOGO_MAX_SIZE, (uchar *)addr, &len) != 0) { free(dst); return NULL; } if (len == CONFIG_SYS_VIDEO_LOGO_MAX_SIZE) puts("Image could be truncated" " (increase CONFIG_SYS_VIDEO_LOGO_MAX_SIZE)!\n"); bmp = dst; /* * Check for bmp mark 'BM' */ if (!((bmp->header.signature[0] == 'B') && (bmp->header.signature[1] == 'M'))) { free(dst); return NULL; } debug("Gzipped BMP image detected!\n"); return bmp; }
int bootm_decomp_image(int comp, ulong load, ulong image_start, int type, void *load_buf, void *image_buf, ulong image_len, uint unc_len, ulong *load_end) { int ret = 0; *load_end = load; print_decomp_msg(comp, type, load == image_start); /* * Load the image to the right place, decompressing if needed. After * this, image_len will be set to the number of uncompressed bytes * loaded, ret will be non-zero on error. */ switch (comp) { case IH_COMP_NONE: if (load == image_start) break; if (image_len <= unc_len) memmove_wd(load_buf, image_buf, image_len, CHUNKSZ); else ret = 1; break; #ifdef CONFIG_GZIP case IH_COMP_GZIP: { ret = gunzip(load_buf, unc_len, image_buf, &image_len); break; } #endif /* CONFIG_GZIP */ #ifdef CONFIG_BZIP2 case IH_COMP_BZIP2: { uint size = unc_len; /* * If we've got less than 4 MB of malloc() space, * use slower decompression algorithm which requires * at most 2300 KB of memory. */ ret = BZ2_bzBuffToBuffDecompress(load_buf, &size, image_buf, image_len, CONFIG_SYS_MALLOC_LEN < (4096 * 1024), 0); image_len = size; break; } #endif /* CONFIG_BZIP2 */ #ifdef CONFIG_LZMA case IH_COMP_LZMA: { SizeT lzma_len = unc_len; ret = lzmaBuffToBuffDecompress(load_buf, &lzma_len, image_buf, image_len); image_len = lzma_len; break; } #endif /* CONFIG_LZMA */ #ifdef CONFIG_LZO case IH_COMP_LZO: { size_t size = unc_len; ret = lzop_decompress(image_buf, image_len, load_buf, &size); image_len = size; break; } #endif /* CONFIG_LZO */ default: printf("Unimplemented compression type %d\n", comp); return BOOTM_ERR_UNIMPLEMENTED; } if (ret) return handle_decomp_error(comp, image_len, unc_len, ret); *load_end = load + image_len; puts("OK\n"); return 0; }
int lcd_bmp(uchar *logo_bmp) { int i; uchar *ptr; ushort *ptr2; ushort val; unsigned char *dst = NULL; int x, y; int width, height, bpp, colors, line_size; int header_size; unsigned char *bmp; unsigned char r, g, b; BITMAPINFOHEADER *bm_info; ulong len; /* * Check for bmp mark 'BM' */ if (*(ushort *)logo_bmp != 0x424d) { /* * Decompress bmp image */ len = CONFIG_SYS_VIDEO_LOGO_MAX_SIZE; dst = malloc(CONFIG_SYS_VIDEO_LOGO_MAX_SIZE); if (dst == NULL) { printf("Error: malloc for gunzip failed!\n"); return 1; } if (gunzip(dst, CONFIG_SYS_VIDEO_LOGO_MAX_SIZE, (uchar *)logo_bmp, &len) != 0) { free(dst); return 1; } if (len == CONFIG_SYS_VIDEO_LOGO_MAX_SIZE) { printf("Image could be truncated" " (increase CONFIG_SYS_VIDEO_LOGO_MAX_SIZE)!\n"); } /* * Check for bmp mark 'BM' */ if (*(ushort *)dst != 0x424d) { printf("LCD: Unknown image format!\n"); free(dst); return 1; } } else { /* * Uncompressed BMP image, just use this pointer */ dst = (uchar *)logo_bmp; } /* * Get image info from bmp-header */ bm_info = (BITMAPINFOHEADER *)(dst + 14); bpp = LOAD_SHORT(bm_info->biBitCount); width = LOAD_LONG(bm_info->biWidth); height = LOAD_LONG(bm_info->biHeight); switch (bpp) { case 1: colors = 1; line_size = width >> 3; break; case 4: colors = 16; line_size = width >> 1; break; case 8: colors = 256; line_size = width; break; case 24: colors = 0; line_size = width * 3; break; default: printf("LCD: Unknown bpp (%d) im image!\n", bpp); if ((dst != NULL) && (dst != (uchar *)logo_bmp)) free(dst); return 1; } printf(" (%d*%d, %dbpp)\n", width, height, bpp); /* * Write color palette */ if ((colors <= 256) && (lcd_depth <= 8)) { ptr = (unsigned char *)(dst + 14 + 40); for (i = 0; i < colors; i++) { b = *ptr++; g = *ptr++; r = *ptr++; ptr++; S1D_WRITE_PALETTE(glob_lcd_reg, i, r, g, b); } } /* * Write bitmap data into framebuffer */ ptr = glob_lcd_mem; ptr2 = (ushort *)glob_lcd_mem; header_size = 14 + 40 + 4*colors; /* skip bmp header */ for (y = 0; y < height; y++) { bmp = &dst[(height-1-y)*line_size + header_size]; if (lcd_depth == 16) { if (bpp == 24) { for (x = 0; x < width; x++) { /* * Generate epson 16bpp fb-format * from 24bpp image */ b = *bmp++ >> 3; g = *bmp++ >> 2; r = *bmp++ >> 3; val = ((r & 0x1f) << 11) | ((g & 0x3f) << 5) | (b & 0x1f); *ptr2++ = val; } } else if (bpp == 8) { for (x = 0; x < line_size; x++) { /* query rgb value from palette */ ptr = (unsigned char *)(dst + 14 + 40); ptr += (*bmp++) << 2; b = *ptr++ >> 3; g = *ptr++ >> 2; r = *ptr++ >> 3; val = ((r & 0x1f) << 11) | ((g & 0x3f) << 5) | (b & 0x1f); *ptr2++ = val; } } } else { for (x = 0; x < line_size; x++)
static int bootm_load_os(image_info_t os, ulong *load_end, int boot_progress) { uint8_t comp = os.comp; ulong load = os.load; ulong blob_start = os.start; ulong blob_end = os.end; ulong image_start = os.image_start; ulong image_len = os.image_len; uint unc_len = CONFIG_SYS_BOOTM_LEN; const char *type_name = genimg_get_type_name (os.type); switch (comp) { case IH_COMP_NONE: if (load == blob_start) { printf (" XIP %s ... ", type_name); } else { printf (" Loading %s ... ", type_name); if (load != image_start) { memmove_wd ((void *)load, (void *)image_start, image_len, CHUNKSZ); } } *load_end = load + image_len; puts("OK\n"); break; case IH_COMP_GZIP: printf (" Uncompressing %s ... ", type_name); if (gunzip ((void *)load, unc_len, (uchar *)image_start, &image_len) != 0) { puts ("GUNZIP: uncompress, out-of-mem or overwrite error " "- must RESET board to recover\n"); if (boot_progress) show_boot_progress (-6); return BOOTM_ERR_RESET; } *load_end = load + image_len; break; #ifdef CONFIG_BZIP2 case IH_COMP_BZIP2: printf (" Uncompressing %s ... ", type_name); /* * If we've got less than 4 MB of malloc() space, * use slower decompression algorithm which requires * at most 2300 KB of memory. */ int i = BZ2_bzBuffToBuffDecompress ((char*)load, &unc_len, (char *)image_start, image_len, CONFIG_SYS_MALLOC_LEN < (4096 * 1024), 0); if (i != BZ_OK) { printf ("BUNZIP2: uncompress or overwrite error %d " "- must RESET board to recover\n", i); if (boot_progress) show_boot_progress (-6); return BOOTM_ERR_RESET; } *load_end = load + unc_len; break; #endif /* CONFIG_BZIP2 */ #ifdef CONFIG_LZMA case IH_COMP_LZMA: printf (" Uncompressing %s ... ", type_name); int ret = lzmaBuffToBuffDecompress( (unsigned char *)load, &unc_len, (unsigned char *)image_start, image_len); if (ret != SZ_OK) { printf ("LZMA: uncompress or overwrite error %d " "- must RESET board to recover\n", ret); show_boot_progress (-6); return BOOTM_ERR_RESET; } *load_end = load + unc_len; break; #endif /* CONFIG_LZMA */ default: printf ("Unimplemented compression type %d\n", comp); return BOOTM_ERR_UNIMPLEMENTED; } puts ("OK\n"); debug (" kernel loaded at 0x%08lx, end = 0x%08lx\n", load, *load_end); if (boot_progress) show_boot_progress (7); if ((load < blob_end) && (*load_end > blob_start)) { debug ("images.os.start = 0x%lX, images.os.end = 0x%lx\n", blob_start, blob_end); debug ("images.os.load = 0x%lx, load_end = 0x%lx\n", load, *load_end); return BOOTM_ERR_OVERLAP; } return 0; }
void start(unsigned long a1, unsigned long a2, void *promptr) { unsigned long i; kernel_entry_t kernel_entry; Elf64_Ehdr *elf64; Elf64_Phdr *elf64ph; prom = (int (*)(void *)) promptr; chosen_handle = finddevice("/chosen"); if (chosen_handle == (void *) -1) exit(); if (getprop(chosen_handle, "stdout", &stdout, sizeof(stdout)) != 4) exit(); stderr = stdout; if (getprop(chosen_handle, "stdin", &stdin, sizeof(stdin)) != 4) exit(); printf("\n\rzImage starting: loaded at 0x%x\n\r", (unsigned)_start); /* * Now we try to claim some memory for the kernel itself * our "vmlinux_memsize" is the memory footprint in RAM, _HOWEVER_, what * our Makefile stuffs in is an image containing all sort of junk including * an ELF header. We need to do some calculations here to find the right * size... In practice we add 1Mb, that is enough, but we should really * consider fixing the Makefile to put a _raw_ kernel in there ! */ vmlinux_memsize += 0x100000; printf("Allocating 0x%lx bytes for kernel ...\n\r", vmlinux_memsize); vmlinux.addr = try_claim(vmlinux_memsize); if (vmlinux.addr == 0) { printf("Can't allocate memory for kernel image !\n\r"); exit(); } vmlinuz.addr = (unsigned long)_vmlinux_start; vmlinuz.size = (unsigned long)(_vmlinux_end - _vmlinux_start); vmlinux.size = PAGE_ALIGN(vmlinux_filesize); vmlinux.memsize = vmlinux_memsize; /* * Now we try to claim memory for the initrd (and copy it there) */ initrd.size = (unsigned long)(_initrd_end - _initrd_start); initrd.memsize = initrd.size; if ( initrd.size > 0 ) { printf("Allocating 0x%lx bytes for initrd ...\n\r", initrd.size); initrd.addr = try_claim(initrd.size); if (initrd.addr == 0) { printf("Can't allocate memory for initial ramdisk !\n\r"); exit(); } a1 = initrd.addr; a2 = initrd.size; 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)); } /* Eventually gunzip the kernel */ if (*(unsigned short *)vmlinuz.addr == 0x1f8b) { int len; avail_ram = scratch; begin_avail = avail_high = avail_ram; end_avail = scratch + sizeof(scratch); printf("gunzipping (0x%lx <- 0x%lx:0x%0lx)...", vmlinux.addr, vmlinuz.addr, vmlinuz.addr+vmlinuz.size); len = vmlinuz.size; gunzip((void *)vmlinux.addr, vmlinux.size, (unsigned char *)vmlinuz.addr, &len); printf("done 0x%lx bytes\n\r", len); printf("0x%x bytes of heap consumed, max in use 0x%x\n\r", (unsigned)(avail_high - begin_avail), heap_max); } else { memmove((void *)vmlinux.addr,(void *)vmlinuz.addr,vmlinuz.size); } /* Skip over the ELF header */ elf64 = (Elf64_Ehdr *)vmlinux.addr; 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 ) { printf("Error: not a valid PPC64 ELF file!\n\r"); exit(); } 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 && elf64ph->p_offset != 0) break; } #ifdef DEBUG printf("... skipping 0x%lx bytes of ELF header\n\r", (unsigned long)elf64ph->p_offset); #endif vmlinux.addr += (unsigned long)elf64ph->p_offset; vmlinux.size -= (unsigned long)elf64ph->p_offset; flush_cache((void *)vmlinux.addr, vmlinux.size); kernel_entry = (kernel_entry_t)vmlinux.addr; #ifdef DEBUG printf( "kernel:\n\r" " entry addr = 0x%lx\n\r" " a1 = 0x%lx,\n\r" " a2 = 0x%lx,\n\r" " prom = 0x%lx,\n\r" " bi_recs = 0x%lx,\n\r", (unsigned long)kernel_entry, a1, a2, (unsigned long)prom, NULL); #endif kernel_entry( a1, a2, prom, NULL ); printf("Error: Linux kernel returned to zImage bootloader!\n\r"); exit(); }
void ThemeManager::importTheme() { // Find file to import QSettings settings; QString path = settings.value("ThemeManager/Location").toString(); if (path.isEmpty() || !QFile::exists(path)) { path = QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation); } QString filename = QFileDialog::getOpenFileName(this, tr("Import Theme"), path, tr("Themes (%1)").arg("*.fwtz *.theme"), 0, QFileDialog::DontResolveSymlinks); if (filename.isEmpty()) { return; } settings.setValue("ThemeManager/Location", QFileInfo(filename).absolutePath()); QString id = Theme::createId(); // Uncompress theme QString theme_filename = Theme::filePath(id); QByteArray theme = gunzip(filename); { QFile file(theme_filename); if (file.open(QFile::WriteOnly)) { file.write(theme); file.close(); } } // Find theme name QSettings theme_ini(theme_filename, QSettings::IniFormat); QString name = theme_ini.value("Name", QFileInfo(filename).completeBaseName()).toString(); { QStringList values = splitStringAtLastNumber(name); int count = values.at(1).toInt(); while (Theme::exists(name)) { ++count; name = values.at(0) + QString::number(count); } theme_ini.setValue("Name", name); } // Extract and use background image QByteArray data = QByteArray::fromBase64(theme_ini.value("Data/Image").toByteArray()); QString image_file = theme_ini.value("Background/ImageFile").toString(); theme_ini.remove("Background/ImageFile"); theme_ini.remove("Data/Image"); theme_ini.sync(); if (!data.isEmpty()) { QTemporaryFile file(QDir::tempPath() + "/XXXXXX-" + image_file); if (file.open()) { file.write(data); file.close(); } Theme theme(id, false); theme.setBackgroundImage(file.fileName()); theme.saveChanges(); } theme_ini.sync(); theme_ini.remove("Background/Image"); QListWidgetItem* item = addItem(id, false, name); m_themes->setCurrentItem(item); }
/* command form: * fpga <op> <device number> <data addr> <datasize> * where op is 'load', 'dump', or 'info' * If there is no device number field, the fpga environment variable is used. * If there is no data addr field, the fpgadata environment variable is used. * The info command requires no data address field. */ int do_fpga(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) { int op, dev = FPGA_INVALID_DEVICE; size_t data_size = 0; void *fpga_data = NULL; char *devstr = getenv("fpga"); char *datastr = getenv("fpgadata"); int rc = FPGA_FAIL; int wrong_parms = 0; #if defined(CONFIG_FIT) const char *fit_uname = NULL; ulong fit_addr; #endif #if defined(CONFIG_CMD_FPGA_LOADFS) fpga_fs_info fpga_fsinfo; fpga_fsinfo.fstype = FS_TYPE_ANY; #endif if (devstr) dev = (int) simple_strtoul(devstr, NULL, 16); if (datastr) fpga_data = (void *)simple_strtoul(datastr, NULL, 16); switch (argc) { #if defined(CONFIG_CMD_FPGA_LOADFS) case 9: fpga_fsinfo.blocksize = (unsigned int) simple_strtoul(argv[5], NULL, 16); fpga_fsinfo.interface = argv[6]; fpga_fsinfo.dev_part = argv[7]; fpga_fsinfo.filename = argv[8]; #endif case 5: /* fpga <op> <dev> <data> <datasize> */ data_size = simple_strtoul(argv[4], NULL, 16); case 4: /* fpga <op> <dev> <data> */ #if defined(CONFIG_FIT) if (fit_parse_subimage(argv[3], (ulong)fpga_data, &fit_addr, &fit_uname)) { fpga_data = (void *)fit_addr; debug("* fpga: subimage '%s' from FIT image ", fit_uname); debug("at 0x%08lx\n", fit_addr); } else #endif { fpga_data = (void *)simple_strtoul(argv[3], NULL, 16); debug("* fpga: cmdline image address = 0x%08lx\n", (ulong)fpga_data); } debug("%s: fpga_data = 0x%lx\n", __func__, (ulong)fpga_data); case 3: /* fpga <op> <dev | data addr> */ dev = (int)simple_strtoul(argv[2], NULL, 16); debug("%s: device = %d\n", __func__, dev); /* FIXME - this is a really weak test */ if ((argc == 3) && (dev > fpga_count())) { /* must be buffer ptr */ debug("%s: Assuming buffer pointer in arg 3\n", __func__); #if defined(CONFIG_FIT) if (fit_parse_subimage(argv[2], (ulong)fpga_data, &fit_addr, &fit_uname)) { fpga_data = (void *)fit_addr; debug("* fpga: subimage '%s' from FIT image ", fit_uname); debug("at 0x%08lx\n", fit_addr); } else #endif { fpga_data = (void *)(uintptr_t)dev; debug("* fpga: cmdline image addr = 0x%08lx\n", (ulong)fpga_data); } debug("%s: fpga_data = 0x%lx\n", __func__, (ulong)fpga_data); dev = FPGA_INVALID_DEVICE; /* reset device num */ } case 2: /* fpga <op> */ op = (int)fpga_get_op(argv[1]); break; default: debug("%s: Too many or too few args (%d)\n", __func__, argc); op = FPGA_NONE; /* force usage display */ break; } if (dev == FPGA_INVALID_DEVICE) { puts("FPGA device not specified\n"); op = FPGA_NONE; } switch (op) { case FPGA_NONE: case FPGA_INFO: break; #if defined(CONFIG_CMD_FPGA_LOADFS) case FPGA_LOADFS: /* Blocksize can be zero */ if (!fpga_fsinfo.interface || !fpga_fsinfo.dev_part || !fpga_fsinfo.filename) wrong_parms = 1; #endif case FPGA_LOAD: case FPGA_LOADP: case FPGA_LOADB: case FPGA_LOADBP: case FPGA_DUMP: if (!fpga_data || !data_size) wrong_parms = 1; break; #if defined(CONFIG_CMD_FPGA_LOADMK) case FPGA_LOADMK: if (!fpga_data) wrong_parms = 1; break; #endif } if (wrong_parms) { puts("Wrong parameters for FPGA request\n"); op = FPGA_NONE; } switch (op) { case FPGA_NONE: return CMD_RET_USAGE; case FPGA_INFO: rc = fpga_info(dev); break; case FPGA_LOAD: rc = fpga_load(dev, fpga_data, data_size, BIT_FULL); break; #if defined(CONFIG_CMD_FPGA_LOADP) case FPGA_LOADP: rc = fpga_load(dev, fpga_data, data_size, BIT_PARTIAL); break; #endif case FPGA_LOADB: rc = fpga_loadbitstream(dev, fpga_data, data_size, BIT_FULL); break; #if defined(CONFIG_CMD_FPGA_LOADBP) case FPGA_LOADBP: rc = fpga_loadbitstream(dev, fpga_data, data_size, BIT_PARTIAL); break; #endif #if defined(CONFIG_CMD_FPGA_LOADFS) case FPGA_LOADFS: rc = fpga_fsload(dev, fpga_data, data_size, &fpga_fsinfo); break; #endif #if defined(CONFIG_CMD_FPGA_LOADMK) case FPGA_LOADMK: switch (genimg_get_format(fpga_data)) { #if defined(CONFIG_IMAGE_FORMAT_LEGACY) case IMAGE_FORMAT_LEGACY: { image_header_t *hdr = (image_header_t *)fpga_data; ulong data; uint8_t comp; comp = image_get_comp(hdr); if (comp == IH_COMP_GZIP) { #if defined(CONFIG_GZIP) ulong image_buf = image_get_data(hdr); data = image_get_load(hdr); ulong image_size = ~0UL; if (gunzip((void *)data, ~0UL, (void *)image_buf, &image_size) != 0) { puts("GUNZIP: error\n"); return 1; } data_size = image_size; #else puts("Gunzip image is not supported\n"); return 1; #endif } else { data = (ulong)image_get_data(hdr); data_size = image_get_data_size(hdr); } rc = fpga_load(dev, (void *)data, data_size, BIT_FULL); } break; #endif #if defined(CONFIG_FIT) case IMAGE_FORMAT_FIT: { const void *fit_hdr = (const void *)fpga_data; int noffset; const void *fit_data; if (fit_uname == NULL) { puts("No FIT subimage unit name\n"); return 1; } if (!fit_check_format(fit_hdr)) { puts("Bad FIT image format\n"); return 1; } /* get fpga component image node offset */ noffset = fit_image_get_node(fit_hdr, fit_uname); if (noffset < 0) { printf("Can't find '%s' FIT subimage\n", fit_uname); return 1; } /* verify integrity */ if (!fit_image_verify(fit_hdr, noffset)) { puts ("Bad Data Hash\n"); return 1; } /* get fpga subimage data address and length */ if (fit_image_get_data(fit_hdr, noffset, &fit_data, &data_size)) { puts("Fpga subimage data not found\n"); return 1; } rc = fpga_load(dev, fit_data, data_size, BIT_FULL); } break; #endif default: puts("** Unknown image type\n"); rc = FPGA_FAIL; break; } break; #endif case FPGA_DUMP: rc = fpga_dump(dev, fpga_data, data_size); break; default: printf("Unknown operation\n"); return CMD_RET_USAGE; } return rc; }
static int bootm_load_os(bootm_headers_t *images, unsigned long *load_end, int boot_progress) { image_info_t os = images->os; uint8_t comp = os.comp; ulong load = os.load; ulong blob_start = os.start; ulong blob_end = os.end; ulong image_start = os.image_start; ulong image_len = os.image_len; __maybe_unused uint unc_len = CONFIG_SYS_BOOTM_LEN; int no_overlap = 0; void *load_buf, *image_buf; #if defined(CONFIG_LZMA) || defined(CONFIG_LZO) int ret; #endif /* defined(CONFIG_LZMA) || defined(CONFIG_LZO) */ const char *type_name = genimg_get_type_name(os.type); load_buf = map_sysmem(load, unc_len); image_buf = map_sysmem(image_start, image_len); switch (comp) { case IH_COMP_NONE: if (load == image_start) { printf(" XIP %s ... ", type_name); no_overlap = 1; } else { printf(" Loading %s ... ", type_name); memmove_wd(load_buf, image_buf, image_len, CHUNKSZ); } *load_end = load + image_len; break; #ifdef CONFIG_GZIP case IH_COMP_GZIP: printf(" Uncompressing %s ... ", type_name); if (gunzip(load_buf, unc_len, image_buf, &image_len) != 0) { puts("GUNZIP: uncompress, out-of-mem or overwrite " "error - must RESET board to recover\n"); if (boot_progress) bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE); return BOOTM_ERR_RESET; } *load_end = load + image_len; break; #endif /* CONFIG_GZIP */ #ifdef CONFIG_BZIP2 case IH_COMP_BZIP2: printf(" Uncompressing %s ... ", type_name); /* * If we've got less than 4 MB of malloc() space, * use slower decompression algorithm which requires * at most 2300 KB of memory. */ int i = BZ2_bzBuffToBuffDecompress(load_buf, &unc_len, image_buf, image_len, CONFIG_SYS_MALLOC_LEN < (4096 * 1024), 0); if (i != BZ_OK) { printf("BUNZIP2: uncompress or overwrite error %d " "- must RESET board to recover\n", i); if (boot_progress) bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE); return BOOTM_ERR_RESET; } *load_end = load + unc_len; break; #endif /* CONFIG_BZIP2 */ #ifdef CONFIG_LZMA case IH_COMP_LZMA: { SizeT lzma_len = unc_len; printf(" Uncompressing %s ... ", type_name); ret = lzmaBuffToBuffDecompress(load_buf, &lzma_len, image_buf, image_len); unc_len = lzma_len; if (ret != SZ_OK) { printf("LZMA: uncompress or overwrite error %d " "- must RESET board to recover\n", ret); bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE); return BOOTM_ERR_RESET; } *load_end = load + unc_len; break; } #endif /* CONFIG_LZMA */ #ifdef CONFIG_LZO case IH_COMP_LZO: { size_t size = unc_len; printf(" Uncompressing %s ... ", type_name); ret = lzop_decompress(image_buf, image_len, load_buf, &size); if (ret != LZO_E_OK) { printf("LZO: uncompress or overwrite error %d " "- must RESET board to recover\n", ret); if (boot_progress) bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE); return BOOTM_ERR_RESET; } *load_end = load + size; break; } #endif /* CONFIG_LZO */ default: printf("Unimplemented compression type %d\n", comp); return BOOTM_ERR_UNIMPLEMENTED; } flush_cache(load, (*load_end - load) * sizeof(ulong)); puts("OK\n"); debug(" kernel loaded at 0x%08lx, end = 0x%08lx\n", load, *load_end); bootstage_mark(BOOTSTAGE_ID_KERNEL_LOADED); if (!no_overlap && (load < blob_end) && (*load_end > blob_start)) { debug("images.os.start = 0x%lX, images.os.end = 0x%lx\n", blob_start, blob_end); debug("images.os.load = 0x%lx, load_end = 0x%lx\n", load, *load_end); /* Check what type of image this is. */ if (images->legacy_hdr_valid) { if (image_get_type(&images->legacy_hdr_os_copy) == IH_TYPE_MULTI) puts("WARNING: legacy format multi component image overwritten\n"); return BOOTM_ERR_OVERLAP; } else { puts("ERROR: new format image overwritten - must RESET the board to recover\n"); bootstage_error(BOOTSTAGE_ID_OVERWRITTEN); return BOOTM_ERR_RESET; } } return 0; }
int misc_init_r(void) { u16 *fpga_mode = (u16 *)(CONFIG_SYS_FPGA_BASE_ADDR + CONFIG_SYS_FPGA_CTRL); u16 *fpga_ctrl2 =(u16 *)(CONFIG_SYS_FPGA_BASE_ADDR + CONFIG_SYS_FPGA_CTRL2); u8 *duart0_mcr = (u8 *)(DUART0_BA + 4); u8 *duart1_mcr = (u8 *)(DUART1_BA + 4); unsigned char *dst; ulong len = sizeof(fpgadata); int status; int index; int i; unsigned long CPC0_CR0Reg; char *str; uchar *logo_addr; ulong logo_size; ushort minb, maxb; int result; /* * Setup GPIO pins (CS6+CS7 as GPIO) */ CPC0_CR0Reg = mfdcr(CPC0_CR0); mtdcr(CPC0_CR0, CPC0_CR0Reg | 0x00300000); dst = malloc(CONFIG_SYS_FPGA_MAX_SIZE); if (gunzip(dst, CONFIG_SYS_FPGA_MAX_SIZE, (uchar *)fpgadata, &len) != 0) { printf("GUNZIP ERROR - must RESET board to recover\n"); do_reset(NULL, 0, 0, NULL); } status = fpga_boot(dst, len); if (status != 0) { printf("\nFPGA: Booting failed "); switch (status) { case ERROR_FPGA_PRG_INIT_LOW: printf("(Timeout: " "INIT not low after asserting PROGRAM*)\n "); break; case ERROR_FPGA_PRG_INIT_HIGH: printf("(Timeout: " "INIT not high after deasserting PROGRAM*)\n "); break; case ERROR_FPGA_PRG_DONE: printf("(Timeout: " "DONE not high after programming FPGA)\n "); break; } /* display infos on fpgaimage */ index = 15; for (i = 0; i < 4; i++) { len = dst[index]; printf("FPGA: %s\n", &(dst[index+1])); index += len + 3; } putc('\n'); /* delayed reboot */ for (i = 20; i > 0; i--) { printf("Rebooting in %2d seconds \r",i); for (index = 0; index < 1000; index++) udelay(1000); } putc('\n'); do_reset(NULL, 0, 0, NULL); } /* restore gpio/cs settings */ mtdcr(CPC0_CR0, CPC0_CR0Reg); puts("FPGA: "); /* display infos on fpgaimage */ index = 15; for (i = 0; i < 4; i++) { len = dst[index]; printf("%s ", &(dst[index + 1])); index += len + 3; } putc('\n'); free(dst); /* * Reset FPGA via FPGA_DATA pin */ SET_FPGA(FPGA_PRG | FPGA_CLK); udelay(1000); /* wait 1ms */ SET_FPGA(FPGA_PRG | FPGA_CLK | FPGA_DATA); udelay(1000); /* wait 1ms */ /* * Write board revision in FPGA */ out_be16(fpga_ctrl2, (in_be16(fpga_ctrl2) & 0xfff0) | (gd->board_type & 0x000f)); /* * Enable power on PS/2 interface (with reset) */ out_be16(fpga_mode, in_be16(fpga_mode) | CONFIG_SYS_FPGA_CTRL_PS2_RESET); for (i=0;i<100;i++) udelay(1000); udelay(1000); out_be16(fpga_mode, in_be16(fpga_mode) & ~CONFIG_SYS_FPGA_CTRL_PS2_RESET); /* * Enable interrupts in exar duart mcr[3] */ out_8(duart0_mcr, 0x08); out_8(duart1_mcr, 0x08); /* * Init lcd interface and display logo */ str = getenv("splashimage"); if (str) { logo_addr = (uchar *)simple_strtoul(str, NULL, 16); logo_size = CONFIG_SYS_VIDEO_LOGO_MAX_SIZE; } else { logo_addr = logo_bmp; logo_size = sizeof(logo_bmp); } if (gd->board_type >= 6) { result = lcd_init((uchar *)CONFIG_SYS_LCD_BIG_REG, (uchar *)CONFIG_SYS_LCD_BIG_MEM, regs_13505_640_480_16bpp, sizeof(regs_13505_640_480_16bpp) / sizeof(regs_13505_640_480_16bpp[0]), logo_addr, logo_size); if (result && str) { /* retry with internal image */ logo_addr = logo_bmp; logo_size = sizeof(logo_bmp); lcd_init((uchar *)CONFIG_SYS_LCD_BIG_REG, (uchar *)CONFIG_SYS_LCD_BIG_MEM, regs_13505_640_480_16bpp, sizeof(regs_13505_640_480_16bpp) / sizeof(regs_13505_640_480_16bpp[0]), logo_addr, logo_size); } } else { result = lcd_init((uchar *)CONFIG_SYS_LCD_BIG_REG, (uchar *)CONFIG_SYS_LCD_BIG_MEM, regs_13806_640_480_16bpp, sizeof(regs_13806_640_480_16bpp) / sizeof(regs_13806_640_480_16bpp[0]), logo_addr, logo_size); if (result && str) { /* retry with internal image */ logo_addr = logo_bmp; logo_size = sizeof(logo_bmp); lcd_init((uchar *)CONFIG_SYS_LCD_BIG_REG, (uchar *)CONFIG_SYS_LCD_BIG_MEM, regs_13806_640_480_16bpp, sizeof(regs_13806_640_480_16bpp) / sizeof(regs_13806_640_480_16bpp[0]), logo_addr, logo_size); } } /* * Reset microcontroller and setup backlight PWM controller */ out_be16(fpga_mode, in_be16(fpga_mode) | 0x0014); for (i=0;i<10;i++) udelay(1000); out_be16(fpga_mode, in_be16(fpga_mode) | 0x001c); minb = 0; maxb = 0xff; str = getenv("lcdbl"); if (str) { minb = (ushort)simple_strtoul(str, &str, 16) & 0x00ff; if (str && (*str=',')) { str++; maxb = (ushort)simple_strtoul(str, NULL, 16) & 0x00ff; } else minb = 0; out_be16((u16 *)(FUJI_BASE + LCDBL_PWMMIN), minb); out_be16((u16 *)(FUJI_BASE + LCDBL_PWMMAX), maxb); printf("LCDBL: min=0x%02x, max=0x%02x\n", minb, maxb); } out_be16((u16 *)(FUJI_BASE + LCDBL_PWM), 0xff); /* * fix environment for field updated units */ if (getenv("altbootcmd") == NULL) { setenv("usb_load", CONFIG_SYS_USB_LOAD_COMMAND); setenv("usbargs", CONFIG_SYS_USB_ARGS); setenv("bootcmd", CONFIG_BOOTCOMMAND); setenv("usb_self", CONFIG_SYS_USB_SELF_COMMAND); setenv("bootlimit", CONFIG_SYS_BOOTLIMIT); setenv("altbootcmd", CONFIG_SYS_ALT_BOOTCOMMAND); saveenv(); } return (0); }
int misc_init_r (void) { unsigned char *dst; ulong len = sizeof(fpgadata); int status; int index; int i; char *str; unsigned long contrast0 = 0xffffffff; dst = malloc(CONFIG_SYS_FPGA_MAX_SIZE); if (gunzip (dst, CONFIG_SYS_FPGA_MAX_SIZE, (uchar *)fpgadata, &len) != 0) { printf ("GUNZIP ERROR - must RESET board to recover\n"); do_reset (NULL, 0, 0, NULL); } status = fpga_boot(dst, len); if (status != 0) { printf("\nFPGA: Booting failed "); switch (status) { case ERROR_FPGA_PRG_INIT_LOW: printf("(Timeout: INIT not low after asserting PROGRAM*)\n "); break; case ERROR_FPGA_PRG_INIT_HIGH: printf("(Timeout: INIT not high after deasserting PROGRAM*)\n "); break; case ERROR_FPGA_PRG_DONE: printf("(Timeout: DONE not high after programming FPGA)\n "); break; } /* display infos on fpgaimage */ index = 15; for (i=0; i<4; i++) { len = dst[index]; printf("FPGA: %s\n", &(dst[index+1])); index += len+3; } putc ('\n'); /* delayed reboot */ for (i=20; i>0; i--) { printf("Rebooting in %2d seconds \r",i); for (index=0;index<1000;index++) udelay(1000); } putc ('\n'); do_reset(NULL, 0, 0, NULL); } puts("FPGA: "); /* display infos on fpgaimage */ index = 15; for (i=0; i<4; i++) { len = dst[index]; printf("%s ", &(dst[index+1])); index += len+3; } putc ('\n'); free(dst); /* * Reset FPGA via FPGA_INIT pin */ /* setup FPGA_INIT as output */ out_be32((void *)GPIO0_TCR, in_be32((void *)GPIO0_TCR) | FPGA_INIT); out_be32((void *)GPIO0_OR, in_be32((void *)GPIO0_OR) & ~FPGA_INIT); /* reset low */ udelay(1000); /* wait 1ms */ out_be32((void *)GPIO0_OR, in_be32((void *)GPIO0_OR) | FPGA_INIT); /* reset high */ udelay(1000); /* wait 1ms */ /* * Write Board revision into FPGA */ out_be16(FPGA_CTRL, in_be16(FPGA_CTRL) | (gd->board_type & 0x0003)); /* * Setup and enable EEPROM write protection */ out_be32((void *)GPIO0_OR, in_be32((void *)GPIO0_OR) | CONFIG_SYS_EEPROM_WP); /* * Reset touch-screen controller */ out_be32((void *)GPIO0_OR, in_be32((void *)GPIO0_OR) & ~CONFIG_SYS_TOUCH_RST); udelay(1000); out_be32((void *)GPIO0_OR, in_be32((void *)GPIO0_OR) | CONFIG_SYS_TOUCH_RST); /* * Enable power on PS/2 interface (with reset) */ out_be16(FPGA_CTRL, in_be16(FPGA_CTRL) & ~FPGA_CTRL_PS2_PWR); for (i=0;i<500;i++) udelay(1000); out_be16(FPGA_CTRL, in_be16(FPGA_CTRL) | FPGA_CTRL_PS2_PWR); /* * Get contrast value from environment variable */ str = getenv("contrast0"); if (str) { contrast0 = simple_strtol(str, NULL, 16); if (contrast0 > 255) { printf("ERROR: contrast0 value too high (0x%lx)!\n", contrast0); contrast0 = 0xffffffff; } } /* * Init lcd interface and display logo */ str = getenv("bd_type"); if (strcmp(str, "ppc230") == 0) { /* * Switch backlight on */ out_be16(FPGA_CTRL, in_be16(FPGA_CTRL) | FPGA_CTRL_VGA0_BL); out_be16(FPGA_BL, 0x0000); lcd_setup(1, 0); lcd_init((uchar *)CONFIG_SYS_LCD_BIG_REG, (uchar *)CONFIG_SYS_LCD_BIG_MEM, regs_13806_1024_768_8bpp, sizeof(regs_13806_1024_768_8bpp)/sizeof(regs_13806_1024_768_8bpp[0]), logo_bmp_1024, sizeof(logo_bmp_1024)); } else if (strcmp(str, "ppc220") == 0) { /* * Switch backlight on */ out_be16(FPGA_CTRL, in_be16(FPGA_CTRL) & ~FPGA_CTRL_VGA0_BL); out_be16(FPGA_BL, 0x0000); lcd_setup(1, 0); lcd_init((uchar *)CONFIG_SYS_LCD_BIG_REG, (uchar *)CONFIG_SYS_LCD_BIG_MEM, regs_13806_640_480_16bpp, sizeof(regs_13806_640_480_16bpp)/sizeof(regs_13806_640_480_16bpp[0]), logo_bmp_640, sizeof(logo_bmp_640)); } else if (strcmp(str, "ppc215") == 0) { /* * Set default display contrast voltage */ if (contrast0 == 0xffffffff) { out_be16(FPGA_CTR, 0x0082); } else { out_be16(FPGA_CTR, contrast0); } out_be16(FPGA_BL, 0xffff); /* * Switch backlight on */ out_be16(FPGA_CTRL, in_be16(FPGA_CTRL) | FPGA_CTRL_VGA0_BL | FPGA_CTRL_VGA0_BL_MODE); /* * Set lcd clock (small epson) */ out_be16(FPGA_CTRL, in_be16(FPGA_CTRL) | LCD_CLK_06250); udelay(100); /* wait for 100 us */ lcd_setup(0, 1); lcd_init((uchar *)CONFIG_SYS_LCD_SMALL_REG, (uchar *)CONFIG_SYS_LCD_SMALL_MEM, regs_13705_320_240_8bpp, sizeof(regs_13705_320_240_8bpp)/sizeof(regs_13705_320_240_8bpp[0]), logo_bmp_320_8bpp, sizeof(logo_bmp_320_8bpp)); } else if (strcmp(str, "ppc210") == 0) { /* * Set default display contrast voltage */ if (contrast0 == 0xffffffff) { out_be16(FPGA_CTR, 0x0060); } else { out_be16(FPGA_CTR, contrast0); } out_be16(FPGA_BL, 0xffff); /* * Switch backlight on */ out_be16(FPGA_CTRL, in_be16(FPGA_CTRL) | FPGA_CTRL_VGA0_BL | FPGA_CTRL_VGA0_BL_MODE); /* * Set lcd clock (small epson), enable 1-wire interface */ out_be16(FPGA_CTRL, in_be16(FPGA_CTRL) | LCD_CLK_08330 | FPGA_CTRL_OW_ENABLE); lcd_setup(0, 1); lcd_init((uchar *)CONFIG_SYS_LCD_SMALL_REG, (uchar *)CONFIG_SYS_LCD_SMALL_MEM, regs_13704_320_240_4bpp, sizeof(regs_13704_320_240_4bpp)/sizeof(regs_13704_320_240_4bpp[0]), logo_bmp_320, sizeof(logo_bmp_320)); #ifdef CONFIG_VIDEO_SM501 } else { pci_dev_t devbusfn; /* * Is SM501 connected (ppc221/ppc231)? */ devbusfn = pci_find_device(PCI_VENDOR_SM, PCI_DEVICE_SM501, 0); if (devbusfn != -1) { puts("VGA: SM501 with 8 MB "); if (strcmp(str, "ppc221") == 0) { printf("(800*600, %dbpp)\n", BPP); out_be16(FPGA_BL, 0x002d); /* max. allowed brightness */ } else if (strcmp(str, "ppc231") == 0) { printf("(1024*768, %dbpp)\n", BPP); out_be16(FPGA_BL, 0x0000); } else { printf("Unsupported bd_type defined (%s) -> No display configured!\n", str); return 0; } } else { printf("Unsupported bd_type defined (%s) -> No display configured!\n", str); return 0; } #endif /* CONFIG_VIDEO_SM501 */ } cf_enable(); return (0); }
int misc_init_r(void) { unsigned char *dst; unsigned char fctr; ulong len = sizeof(fpgadata); int status; int index; int i; /* adjust flash start and offset */ gd->bd->bi_flashstart = 0 - gd->bd->bi_flashsize; gd->bd->bi_flashoffset = 0; dst = malloc(CONFIG_SYS_FPGA_MAX_SIZE); if (gunzip(dst, CONFIG_SYS_FPGA_MAX_SIZE, (uchar *)fpgadata, &len) != 0) { printf("GUNZIP ERROR - must RESET board to recover\n"); do_reset(NULL, 0, 0, NULL); } status = fpga_boot(dst, len); if (status != 0) { printf("\nFPGA: Booting failed "); switch (status) { case ERROR_FPGA_PRG_INIT_LOW: printf("(Timeout: INIT not low " "after asserting PROGRAM*)\n"); break; case ERROR_FPGA_PRG_INIT_HIGH: printf("(Timeout: INIT not high " "after deasserting PROGRAM*)\n"); break; case ERROR_FPGA_PRG_DONE: printf("(Timeout: DONE not high " "after programming FPGA)\n"); break; } /* display infos on fpgaimage */ index = 15; for (i=0; i<4; i++) { len = dst[index]; printf("FPGA: %s\n", &(dst[index+1])); index += len+3; } putc ('\n'); /* delayed reboot */ for (i=20; i>0; i--) { printf("Rebooting in %2d seconds \r",i); for (index=0;index<1000;index++) udelay(1000); } putc('\n'); do_reset(NULL, 0, 0, NULL); } puts("FPGA: "); /* display infos on fpgaimage */ index = 15; for (i=0; i<4; i++) { len = dst[index]; printf("%s ", &(dst[index+1])); index += len+3; } putc('\n'); free(dst); /* * Reset FPGA via FPGA_DATA pin */ SET_FPGA(FPGA_PRG | FPGA_CLK); udelay(1000); /* wait 1ms */ SET_FPGA(FPGA_PRG | FPGA_CLK | FPGA_DATA); udelay(1000); /* wait 1ms */ /* * Reset external DUARTs */ out_be32((void*)GPIO0_OR, in_be32((void*)GPIO0_OR) | CONFIG_SYS_DUART_RST); udelay(10); out_be32((void*)GPIO0_OR, in_be32((void*)GPIO0_OR) & ~CONFIG_SYS_DUART_RST); udelay(1000); /* * Set NAND-FLASH GPIO signals to default */ out_be32((void*)GPIO0_OR, in_be32((void*)GPIO0_OR) & ~(CONFIG_SYS_NAND_CLE | CONFIG_SYS_NAND_ALE)); out_be32((void*)GPIO0_OR, in_be32((void*)GPIO0_OR) | CONFIG_SYS_NAND_CE); /* * Setup EEPROM write protection */ out_be32((void*)GPIO0_OR, in_be32((void*)GPIO0_OR) | CONFIG_SYS_EEPROM_WP); out_be32((void*)GPIO0_TCR, in_be32((void*)GPIO0_TCR) | CONFIG_SYS_EEPROM_WP); /* * Enable interrupts in exar duart mcr[3] */ out_8((void *)DUART0_BA + 4, 0x08); out_8((void *)DUART1_BA + 4, 0x08); /* * Enable auto RS485 mode in 2nd external uart */ out_8((void *)DUART1_BA + 3, 0xbf); /* write LCR */ fctr = in_8((void *)DUART1_BA + 1); /* read FCTR */ fctr |= 0x08; /* enable RS485 mode */ out_8((void *)DUART1_BA + 1, fctr); /* write FCTR */ out_8((void *)DUART1_BA + 3, 0); /* write LCR */ /* * Init magnetic couplers */ if (!getenv("noinitcoupler")) { init_coupler(CAN0_BA); init_coupler(CAN1_BA); } return 0; }
/** * spl_load_fit_image(): load the image described in a certain FIT node * @info: points to information about the device to load data from * @sector: the start sector of the FIT image on the device * @fit: points to the flattened device tree blob describing the FIT * image * @base_offset: the beginning of the data area containing the actual * image data, relative to the beginning of the FIT * @node: offset of the DT node describing the image to load (relative * to @fit) * @image_info: will be filled with information about the loaded image * If the FIT node does not contain a "load" (address) property, * the image gets loaded to the address pointed to by the * load_addr member in this struct. * * Return: 0 on success or a negative error number. */ static int spl_load_fit_image(struct spl_load_info *info, ulong sector, void *fit, ulong base_offset, int node, struct spl_image_info *image_info) { int offset; size_t length; int len; ulong size; ulong load_addr, load_ptr; void *src; ulong overhead; int nr_sectors; int align_len = ARCH_DMA_MINALIGN - 1; uint8_t image_comp = -1, type = -1; const void *data; if (IS_ENABLED(CONFIG_SPL_OS_BOOT) && IS_ENABLED(CONFIG_SPL_GZIP)) { if (fit_image_get_comp(fit, node, &image_comp)) puts("Cannot get image compression format.\n"); else debug("%s ", genimg_get_comp_name(image_comp)); if (fit_image_get_type(fit, node, &type)) puts("Cannot get image type.\n"); else debug("%s ", genimg_get_type_name(type)); } if (fit_image_get_load(fit, node, &load_addr)) load_addr = image_info->load_addr; if (!fit_image_get_data_offset(fit, node, &offset)) { /* External data */ offset += base_offset; if (fit_image_get_data_size(fit, node, &len)) return -ENOENT; load_ptr = (load_addr + align_len) & ~align_len; length = len; overhead = get_aligned_image_overhead(info, offset); nr_sectors = get_aligned_image_size(info, length, offset); if (info->read(info, sector + get_aligned_image_offset(info, offset), nr_sectors, (void *)load_ptr) != nr_sectors) return -EIO; debug("External data: dst=%lx, offset=%x, size=%lx\n", load_ptr, offset, (unsigned long)length); src = (void *)load_ptr + overhead; } else { /* Embedded data */ if (fit_image_get_data(fit, node, &data, &length)) { puts("Cannot get image data/size\n"); return -ENOENT; } debug("Embedded data: dst=%lx, size=%lx\n", load_addr, (unsigned long)length); src = (void *)data; } #ifdef CONFIG_SPL_FIT_IMAGE_POST_PROCESS board_fit_image_post_process(&src, &length); #endif if (IS_ENABLED(CONFIG_SPL_OS_BOOT) && IS_ENABLED(CONFIG_SPL_GZIP) && image_comp == IH_COMP_GZIP && type == IH_TYPE_KERNEL) { size = length; if (gunzip((void *)load_addr, CONFIG_SYS_BOOTM_LEN, src, &size)) { puts("Uncompressing error\n"); return -EIO; } length = size; } else { memcpy((void *)load_addr, src, length); } if (image_info) { image_info->load_addr = load_addr; image_info->size = length; image_info->entry_point = fdt_getprop_u32(fit, node, "entry"); } return 0; }
unsigned long decompress_kernel(unsigned long load_addr, int num_words, unsigned long cksum, RESIDUAL *residual, void *OFW_interface) { int timer; extern unsigned long start; char *cp, ch; unsigned long i; BATU *u; BATL *l; unsigned long TotalMemory; unsigned long orig_MSR; int dev_handle; int mem_info[2]; int res, size; unsigned char board_type; unsigned char base_mod; lines = 25; cols = 80; orig_x = 0; orig_y = 24; /* * IBM's have the MMU on, so we have to disable it or * things get really unhappy in the kernel when * trying to setup the BATs with the MMU on * -- Cort */ flush_instruction_cache(); _put_HID0(_get_HID0() & ~0x0000C000); _put_MSR((orig_MSR = _get_MSR()) & ~0x0030); #if defined(CONFIG_SERIAL_CONSOLE) com_port = (struct NS16550 *)NS16550_init(0); #endif /* CONFIG_SERIAL_CONSOLE */ vga_init(0xC0000000); if (residual) { /* Is this Motorola PPCBug? */ if ((1 & residual->VitalProductData.FirmwareSupports) && (1 == residual->VitalProductData.FirmwareSupplier)) { board_type = inb(0x800) & 0xF0; /* If this is genesis 2 board then check for no * keyboard controller and more than one processor. */ if (board_type == 0xe0) { base_mod = inb(0x803); /* if a MVME2300/2400 or a Sitka then no keyboard */ if((base_mod == 0xFA) || (base_mod == 0xF9) || (base_mod == 0xE1)) { keyb_present = 0; /* no keyboard */ } } } memcpy(hold_residual,residual,sizeof(RESIDUAL)); } else { /* Assume 32M in the absence of more info... */ TotalMemory = 0x02000000; /* * This is a 'best guess' check. We want to make sure * we don't try this on a PReP box without OF * -- Cort */ while (OFW_interface && ((unsigned long)OFW_interface < 0x10000000) ) { /* The MMU needs to be on when we call OFW */ _put_MSR(orig_MSR); of_init(OFW_interface); /* get handle to memory description */ res = of_finddevice("/memory@0", &dev_handle); // puthex(res); puts("\n"); if (res) break; /* get the info */ // puts("get info = "); res = of_getprop(dev_handle, "reg", mem_info, sizeof(mem_info), &size); // puthex(res); puts(", info = "); puthex(mem_info[0]); // puts(" "); puthex(mem_info[1]); puts("\n"); if (res) break; TotalMemory = mem_info[1]; break; } hold_residual->TotalMemory = TotalMemory; residual = hold_residual; /* Turn MMU back off */ _put_MSR(orig_MSR & ~0x0030); } /* assume the chunk below 8M is free */ end_avail = (char *)0x00800000; /* tell the user where we were loaded at and where we * were relocated to for debugging this process */ puts("loaded at: "); puthex(load_addr); puts(" "); puthex((unsigned long)(load_addr + (4*num_words))); puts("\n"); if ( (unsigned long)load_addr != (unsigned long)&start ) { puts("relocated to: "); puthex((unsigned long)&start); puts(" "); puthex((unsigned long)((unsigned long)&start + (4*num_words))); puts("\n"); } if ( residual ) { puts("board data at: "); puthex((unsigned long)residual); puts(" "); puthex((unsigned long)((unsigned long)residual + sizeof(RESIDUAL))); puts("\n"); puts("relocated to: "); puthex((unsigned long)hold_residual); puts(" "); puthex((unsigned long)((unsigned long)hold_residual + sizeof(RESIDUAL))); puts("\n"); } /* we have to subtract 0x10000 here to correct for objdump including the size of the elf header which we strip -- Cort */ zimage_start = (char *)(load_addr - 0x10000 + ZIMAGE_OFFSET); zimage_size = ZIMAGE_SIZE; if ( INITRD_OFFSET ) initrd_start = load_addr - 0x10000 + INITRD_OFFSET; else initrd_start = 0; initrd_end = INITRD_SIZE + initrd_start; /* * Find a place to stick the zimage and initrd and * relocate them if we have to. -- Cort */ avail_ram = (char *)PAGE_ALIGN((unsigned long)_end); puts("zimage at: "); puthex((unsigned long)zimage_start); puts(" "); puthex((unsigned long)(zimage_size+zimage_start)); puts("\n"); if ( (unsigned long)zimage_start <= 0x00800000 ) { memcpy( (void *)avail_ram, (void *)zimage_start, zimage_size ); zimage_start = (char *)avail_ram; puts("relocated to: "); puthex((unsigned long)zimage_start); puts(" "); puthex((unsigned long)zimage_size+(unsigned long)zimage_start); puts("\n"); avail_ram += zimage_size; } /* relocate initrd */ if ( initrd_start ) { puts("initrd at: "); puthex(initrd_start); puts(" "); puthex(initrd_end); puts("\n"); if ( (unsigned long)initrd_start <= 0x00800000 ) { memcpy( (void *)avail_ram, (void *)initrd_start, initrd_end-initrd_start ); puts("relocated to: "); initrd_end = (unsigned long) avail_ram + (initrd_end-initrd_start); initrd_start = (unsigned long)avail_ram; puthex((unsigned long)initrd_start); puts(" "); puthex((unsigned long)initrd_end); puts("\n"); } avail_ram = (char *)PAGE_ALIGN((unsigned long)initrd_end); } avail_ram = (char *)0x00400000; end_avail = (char *)0x00800000; puts("avail ram: "); puthex((unsigned long)avail_ram); puts(" "); puthex((unsigned long)end_avail); puts("\n"); if (keyb_present) CRT_tstc(); /* Forces keyboard to be initialized */ puts("\nLinux/PPC load: "); timer = 0; cp = cmd_line; memcpy (cmd_line, cmd_preset, sizeof(cmd_preset)); while ( *cp ) putc(*cp++); while (timer++ < 5*1000) { if (tstc()) { while ((ch = getc()) != '\n' && ch != '\r') { if (ch == '\b') { if (cp != cmd_line) { cp--; puts("\b \b"); } } else { *cp++ = ch; putc(ch); } } break; /* Exit 'timer' loop */ } udelay(1000); /* 1 msec */ } *cp = 0; puts("\n"); puts("Uncompressing Linux..."); gunzip(0, 0x400000, zimage_start, &zimage_size); puts("done.\n"); { struct bi_record *rec; rec = (struct bi_record *)PAGE_ALIGN(zimage_size); rec->tag = BI_FIRST; rec->size = sizeof(struct bi_record); rec = (struct bi_record *)((unsigned long)rec + rec->size); rec->tag = BI_BOOTLOADER_ID; memcpy( (void *)rec->data, "prepboot", 9); rec->size = sizeof(struct bi_record) + 8 + 1; rec = (struct bi_record *)((unsigned long)rec + rec->size); rec->tag = BI_MACHTYPE; rec->data[0] = _MACH_prep; rec->data[1] = 1; rec->size = sizeof(struct bi_record) + sizeof(unsigned long); rec = (struct bi_record *)((unsigned long)rec + rec->size); rec->tag = BI_CMD_LINE; memcpy( (char *)rec->data, cmd_line, strlen(cmd_line)+1); rec->size = sizeof(struct bi_record) + strlen(cmd_line) + 1; rec = (struct bi_record *)((ulong)rec + rec->size); rec->tag = BI_LAST; rec->size = sizeof(struct bi_record); rec = (struct bi_record *)((unsigned long)rec + rec->size); } puts("Now booting the kernel\n"); return (unsigned long)hold_residual; }
static int mpl_prg_image(uchar *ld_addr) { unsigned long len; uchar *data; image_header_t *hdr = (image_header_t *)ld_addr; int rc; #if defined(CONFIG_FIT) if (genimg_get_format ((void *)hdr) != IMAGE_FORMAT_LEGACY) { puts ("Non legacy image format not supported\n"); return -1; } #endif if (!image_check_magic (hdr)) { puts("Bad Magic Number\n"); return 1; } image_print_contents (hdr); if (!image_check_os (hdr, IH_OS_U_BOOT)) { puts("No U-Boot Image\n"); return 1; } if (!image_check_type (hdr, IH_TYPE_FIRMWARE)) { puts("No Firmware Image\n"); return 1; } if (!image_check_hcrc (hdr)) { puts("Bad Header Checksum\n"); return 1; } puts("Verifying Checksum ... "); if (!image_check_dcrc (hdr)) { puts("Bad Data CRC\n"); return 1; } puts("OK\n"); data = (uchar *)image_get_data (hdr); len = image_get_data_size (hdr); if (image_get_comp (hdr) != IH_COMP_NONE) { uchar *buf; /* reserve space for uncompressed image */ if ((buf = malloc(IMAGE_SIZE)) == NULL) { puts("Insufficient space for decompression\n"); return 1; } switch (image_get_comp (hdr)) { case IH_COMP_GZIP: puts("Uncompressing (GZIP) ... "); rc = gunzip ((void *)(buf), IMAGE_SIZE, data, &len); if (rc != 0) { puts("GUNZIP ERROR\n"); free(buf); return 1; } puts("OK\n"); break; #ifdef CONFIG_BZIP2 case IH_COMP_BZIP2: puts("Uncompressing (BZIP2) ... "); { uint retlen = IMAGE_SIZE; rc = BZ2_bzBuffToBuffDecompress ((char *)(buf), &retlen, (char *)data, len, 0, 0); len = retlen; } if (rc != BZ_OK) { printf ("BUNZIP2 ERROR: %d\n", rc); free(buf); return 1; } puts("OK\n"); break; #endif default: printf ("Unimplemented compression type %d\n", image_get_comp (hdr)); free(buf); return 1; } rc = mpl_prg(buf, len); free(buf); } else { rc = mpl_prg(data, len); } return(rc); }
void ATPAssetMigrator::loadEntityServerFile() { auto filename = QFileDialog::getOpenFileName(_dialogParent, "Select an entity-server content file to migrate", QString(), QString("Entity-Server Content (*.gz)")); if (!filename.isEmpty()) { qCDebug(asset_migrator) << "Selected filename for ATP asset migration: " << filename; static const QString MIGRATION_CONFIRMATION_TEXT { "The ATP Asset Migration process will scan the selected entity-server file, upload discovered resources to the"\ " current asset-server and then save a new entity-server file with the ATP URLs.\n\nAre you ready to"\ " continue?\n\nMake sure you are connected to the right domain." }; auto button = QMessageBox::question(_dialogParent, MESSAGE_BOX_TITLE, MIGRATION_CONFIRMATION_TEXT, QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes); if (button == QMessageBox::No) { return; } // try to open the file at the given filename QFile modelsFile { filename }; if (modelsFile.open(QIODevice::ReadOnly)) { QByteArray compressedJsonData = modelsFile.readAll(); QByteArray jsonData; if (!gunzip(compressedJsonData, jsonData)) { QMessageBox::warning(_dialogParent, "Error", "The file at" + filename + "was not in gzip format."); } QJsonDocument modelsJSON = QJsonDocument::fromJson(jsonData); _entitiesArray = modelsJSON.object()["Entities"].toArray(); for (auto jsonValue : _entitiesArray) { QJsonObject entityObject = jsonValue.toObject(); QString modelURLString = entityObject.value(MODEL_URL_KEY).toString(); if (!modelURLString.isEmpty()) { QUrl modelURL = QUrl(modelURLString); if (!_ignoredUrls.contains(modelURL) && (modelURL.scheme() == URL_SCHEME_HTTP || modelURL.scheme() == URL_SCHEME_HTTPS || modelURL.scheme() == URL_SCHEME_FILE || modelURL.scheme() == URL_SCHEME_FTP)) { if (_pendingReplacements.contains(modelURL)) { // we already have a request out for this asset, just store the QJsonValueRef // so we can do the hash replacement when the request comes back _pendingReplacements.insert(modelURL, jsonValue); } else if (_uploadedAssets.contains(modelURL)) { // we already have a hash for this asset // so just do the replacement immediately entityObject[MODEL_URL_KEY] = _uploadedAssets.value(modelURL).toString(); jsonValue = entityObject; } else if (wantsToMigrateResource(modelURL)) { auto request = ResourceManager::createResourceRequest(this, modelURL); if (request) { qCDebug(asset_migrator) << "Requesting" << modelURL << "for ATP asset migration"; // add this combination of QUrl and QJsonValueRef to our multi hash so we can change the URL // to an ATP one once ready _pendingReplacements.insert(modelURL, jsonValue); connect(request, &ResourceRequest::finished, this, [=]() { if (request->getResult() == ResourceRequest::Success) { migrateResource(request); } else { QMessageBox::warning(_dialogParent, "Error", QString("Could not retrieve asset at %1").arg(modelURL.toString())); } request->deleteLater(); }); request->send(); } else { QMessageBox::warning(_dialogParent, "Error", QString("Could not create request for asset at %1").arg(modelURL.toString())); } } else { _ignoredUrls.insert(modelURL); } } } } _doneReading = true; } else { QMessageBox::warning(_dialogParent, "Error", "There was a problem loading that entity-server file for ATP asset migration. Please try again"); } } }
static void prep_kernel(unsigned long a1, unsigned long a2) { 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 (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(); } /* * Now find the initrd * * First see if we have an image attached to us. If so * allocate memory for it and copy it there. */ initrd.size = (unsigned long)(_initrd_end - _initrd_start); initrd.memsize = initrd.size; if (initrd.size > 0) { 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); } /* 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); } /* Skip over the ELF header */ #ifdef DEBUG printf("... skipping 0x%lx bytes of ELF header\n\r", elfoffset); #endif vmlinux.addr += elfoffset; flush_cache((void *)vmlinux.addr, vmlinux.size); }
int misc_init_r (void) { volatile unsigned char *duart0_mcr = (unsigned char *)((ulong)DUART0_BA + 4); volatile unsigned char *duart1_mcr = (unsigned char *)((ulong)DUART1_BA + 4); volatile unsigned char *duart2_mcr = (unsigned char *)((ulong)DUART2_BA + 4); volatile unsigned char *duart3_mcr = (unsigned char *)((ulong)DUART3_BA + 4); unsigned char *dst; ulong len = sizeof(fpgadata); int status; int index; int i; dst = malloc(CONFIG_SYS_FPGA_MAX_SIZE); if (gunzip (dst, CONFIG_SYS_FPGA_MAX_SIZE, (uchar *)fpgadata, &len) != 0) { printf ("GUNZIP ERROR - must RESET board to recover\n"); do_reset (NULL, 0, 0, NULL); } status = fpga_boot(dst, len); if (status != 0) { printf("\nFPGA: Booting failed "); switch (status) { case ERROR_FPGA_PRG_INIT_LOW: printf("(Timeout: INIT not low after asserting PROGRAM*)\n "); break; case ERROR_FPGA_PRG_INIT_HIGH: printf("(Timeout: INIT not high after deasserting PROGRAM*)\n "); break; case ERROR_FPGA_PRG_DONE: printf("(Timeout: DONE not high after programming FPGA)\n "); break; } /* display infos on fpgaimage */ index = 15; for (i=0; i<4; i++) { len = dst[index]; printf("FPGA: %s\n", &(dst[index+1])); index += len+3; } putc ('\n'); /* delayed reboot */ for (i=20; i>0; i--) { printf("Rebooting in %2d seconds \r",i); for (index=0;index<1000;index++) udelay(1000); } putc ('\n'); do_reset(NULL, 0, 0, NULL); } puts("FPGA: "); /* display infos on fpgaimage */ index = 15; for (i=0; i<4; i++) { len = dst[index]; printf("%s ", &(dst[index+1])); index += len+3; } putc ('\n'); free(dst); /* * Reset FPGA via FPGA_DATA pin */ SET_FPGA(FPGA_PRG | FPGA_CLK); udelay(1000); /* wait 1ms */ SET_FPGA(FPGA_PRG | FPGA_CLK | FPGA_DATA); udelay(1000); /* wait 1ms */ /* * Reset external DUARTs */ out32(GPIO0_OR, in32(GPIO0_OR) | CONFIG_SYS_DUART_RST); /* set reset to high */ udelay(10); /* wait 10us */ out32(GPIO0_OR, in32(GPIO0_OR) & ~CONFIG_SYS_DUART_RST); /* set reset to low */ udelay(1000); /* wait 1ms */ /* * Enable interrupts in exar duart mcr[3] */ *duart0_mcr = 0x08; *duart1_mcr = 0x08; *duart2_mcr = 0x08; *duart3_mcr = 0x08; return (0); }
/* * We need a wrapper for gunzip() because the parameters are * incompatible with the lzo decompressor. */ static int gzip_decompress(const unsigned char *in, size_t in_len, unsigned char *out, size_t *out_len) { unsigned long len = in_len; return gunzip(out, *out_len, (unsigned char *)in, &len); }
static int bootm_load_os(image_info_t os, ulong *load_end, int boot_progress) { uint8_t comp = os.comp; ulong load = os.load; ulong blob_start = os.start; ulong blob_end = os.end; ulong image_start = os.image_start; ulong image_len = os.image_len; __maybe_unused uint unc_len = CONFIG_SYS_BOOTM_LEN; int no_overlap = 0; #if defined(CONFIG_LZMA) || defined(CONFIG_LZO) int ret; #endif /* defined(CONFIG_LZMA) || defined(CONFIG_LZO) */ const char *type_name = genimg_get_type_name(os.type); switch (comp) { case IH_COMP_NONE: if (load == blob_start || load == image_start) { printf(" XIP %s ... ", type_name); no_overlap = 1; } else { printf(" Loading %s ... ", type_name); memmove_wd((void *)load, (void *)image_start, image_len, CHUNKSZ); } *load_end = load + image_len; puts("OK\n"); break; #ifdef CONFIG_GZIP case IH_COMP_GZIP: printf(" Uncompressing %s ... ", type_name); if (gunzip((void *)load, unc_len, (uchar *)image_start, &image_len) != 0) { puts("GUNZIP: uncompress, out-of-mem or overwrite " "error - must RESET board to recover\n"); if (boot_progress) bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE); return BOOTM_ERR_RESET; } *load_end = load + image_len; break; #endif /* CONFIG_GZIP */ #ifdef CONFIG_BZIP2 case IH_COMP_BZIP2: printf(" Uncompressing %s ... ", type_name); /* * If we've got less than 4 MB of malloc() space, * use slower decompression algorithm which requires * at most 2300 KB of memory. */ int i = BZ2_bzBuffToBuffDecompress((char *)load, &unc_len, (char *)image_start, image_len, CONFIG_SYS_MALLOC_LEN < (4096 * 1024), 0); if (i != BZ_OK) { printf("BUNZIP2: uncompress or overwrite error %d " "- must RESET board to recover\n", i); if (boot_progress) bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE); return BOOTM_ERR_RESET; } *load_end = load + unc_len; break; #endif /* CONFIG_BZIP2 */ #ifdef CONFIG_LZMA case IH_COMP_LZMA: { SizeT lzma_len = unc_len; printf(" Uncompressing %s ... ", type_name); ret = lzmaBuffToBuffDecompress( (unsigned char *)load, &lzma_len, (unsigned char *)image_start, image_len); unc_len = lzma_len; if (ret != SZ_OK) { printf("LZMA: uncompress or overwrite error %d " "- must RESET board to recover\n", ret); bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE); return BOOTM_ERR_RESET; } *load_end = load + unc_len; break; } #endif /* CONFIG_LZMA */ #ifdef CONFIG_LZO case IH_COMP_LZO: printf(" Uncompressing %s ... ", type_name); ret = lzop_decompress((const unsigned char *)image_start, image_len, (unsigned char *)load, &unc_len); if (ret != LZO_E_OK) { printf("LZO: uncompress or overwrite error %d " "- must RESET board to recover\n", ret); if (boot_progress) bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE); return BOOTM_ERR_RESET; } *load_end = load + unc_len; break; #endif /* CONFIG_LZO */ default: printf("Unimplemented compression type %d\n", comp); return BOOTM_ERR_UNIMPLEMENTED; } flush_cache(load, (*load_end - load) * sizeof(ulong)); puts("OK\n"); debug(" kernel loaded at 0x%08lx, end = 0x%08lx\n", load, *load_end); bootstage_mark(BOOTSTAGE_ID_KERNEL_LOADED); if (!no_overlap && (load < blob_end) && (*load_end > blob_start)) { debug("images.os.start = 0x%lX, images.os.end = 0x%lx\n", blob_start, blob_end); debug("images.os.load = 0x%lx, load_end = 0x%lx\n", load, *load_end); return BOOTM_ERR_OVERLAP; } return 0; }
static int bootm_load_os(image_info_t os, ulong *load_end, int boot_progress) { uint8_t comp = os.comp; ulong load = os.load; ulong blob_start = os.start; ulong blob_end = os.end; ulong image_start = os.image_start; ulong image_len = os.image_len; #if defined(CONFIG_GZIP) || defined(CONFIG_BZIP2) \ || defined(CONFIG_LZMA) || defined(CONFIG_LZO) uint unc_len = CONFIG_SYS_BOOTM_LEN; #endif ulong image_end; const char *type_name = genimg_get_type_name (os.type); int boot_sp; __asm__ __volatile__( "mov %0, sp\n" :"=r"(boot_sp) : :"cc" ); /* Check whether kernel zImage overwrite uboot, * which will lead to kernel boot fail. */ image_end = load + image_len; /* leave at most 32KByte for move image stack */ boot_sp -= BOOTM_STACK_GUARD; if( !((load > _bss_end) || (image_end < boot_sp)) ) { printf("\nkernel image will overwrite uboot! kernel boot fail!\n"); return BOOTM_ERR_RESET; } switch (comp) { case IH_COMP_NONE: if (load == blob_start || load == image_start) { printf (" XIP %s ... ", type_name); } else { printf (" Loading %s ... ", type_name); memmove_wd ((void *)load, (void *)image_start, image_len, CHUNKSZ); } *load_end = load + image_len; puts("OK\n"); break; #ifdef CONFIG_GZIP case IH_COMP_GZIP: printf (" Uncompressing %s ... ", type_name); if (gunzip ((void *)load, unc_len, (uchar *)image_start, &image_len) != 0) { puts ("GUNZIP: uncompress, out-of-mem or overwrite error " "- must RESET board to recover\n"); if (boot_progress) show_boot_progress (-6); return BOOTM_ERR_RESET; } *load_end = load + image_len; break; #endif /* CONFIG_GZIP */ #ifdef CONFIG_BZIP2 case IH_COMP_BZIP2: printf (" Uncompressing %s ... ", type_name); /* * If we've got less than 4 MB of malloc() space, * use slower decompression algorithm which requires * at most 2300 KB of memory. */ int i = BZ2_bzBuffToBuffDecompress ((char*)load, &unc_len, (char *)image_start, image_len, CONFIG_SYS_MALLOC_LEN < (4096 * 1024), 0); if (i != BZ_OK) { printf ("BUNZIP2: uncompress or overwrite error %d " "- must RESET board to recover\n", i); if (boot_progress) show_boot_progress (-6); return BOOTM_ERR_RESET; } *load_end = load + unc_len; break; #endif /* CONFIG_BZIP2 */ #ifdef CONFIG_LZMA case IH_COMP_LZMA: printf (" Uncompressing %s ... ", type_name); int ret = lzmaBuffToBuffDecompress( (unsigned char *)load, &unc_len, (unsigned char *)image_start, image_len); if (ret != SZ_OK) { printf ("LZMA: uncompress or overwrite error %d " "- must RESET board to recover\n", ret); show_boot_progress (-6); return BOOTM_ERR_RESET; } *load_end = load + unc_len; break; #endif /* CONFIG_LZMA */ #ifdef CONFIG_LZO case IH_COMP_LZO: printf (" Uncompressing %s ... ", type_name); int ret = lzop_decompress((const unsigned char *)image_start, image_len, (unsigned char *)load, &unc_len); if (ret != LZO_E_OK) { printf ("LZO: uncompress or overwrite error %d " "- must RESET board to recover\n", ret); if (boot_progress) show_boot_progress (-6); return BOOTM_ERR_RESET; } *load_end = load + unc_len; break; #endif /* CONFIG_LZO */ default: printf ("Unimplemented compression type %d\n", comp); return BOOTM_ERR_UNIMPLEMENTED; } puts ("OK\n"); debug (" kernel loaded at 0x%08lx, end = 0x%08lx\n", load, *load_end); if (boot_progress) show_boot_progress (7); if ((load < blob_end) && (*load_end > blob_start)) { debug ("images.os.start = 0x%lX, images.os.end = 0x%lx\n", blob_start, blob_end); debug ("images.os.load = 0x%lx, load_end = 0x%lx\n", load, *load_end); return BOOTM_ERR_OVERLAP; } return 0; }
coffboot(int a1, int a2, void *prom) { void *options; unsigned loadbase; struct external_filehdr *eh; struct external_scnhdr *sp; struct external_scnhdr *isect, *rsect; int ns, oh, i; unsigned sa, len; void *dst; unsigned char *im; unsigned initrd_start, initrd_size; printf("coffboot starting\n"); options = finddevice("/options"); if (options == (void *) -1) exit(); if (getprop(options, "load-base", &loadbase, sizeof(loadbase)) != sizeof(loadbase)) { printf("error getting load-base\n"); exit(); } setup_bats(RAM_START); loadbase += RAM_START; eh = (struct external_filehdr *) loadbase; ns = get_16be(eh->f_nscns); oh = get_16be(eh->f_opthdr); sp = (struct external_scnhdr *) (loadbase + sizeof(struct external_filehdr) + oh); isect = rsect = NULL; for (i = 0; i < ns; ++i, ++sp) { if (strcmp(sp->s_name, "image") == 0) isect = sp; else if (strcmp(sp->s_name, "initrd") == 0) rsect = sp; } if (isect == NULL) { printf("image section not found\n"); exit(); } if (rsect != NULL && (initrd_size = get_32be(rsect->s_size)) != 0) { initrd_start = (RAM_END - initrd_size) & ~0xFFF; a1 = initrd_start; a2 = initrd_size; printf("initial ramdisk at %x (%u bytes)\n", initrd_start, initrd_size); memcpy((char *) initrd_start, (char *) (loadbase + get_32be(rsect->s_scnptr)), initrd_size); end_avail = (char *) initrd_start; } else { end_avail = (char *) RAM_END; } im = (unsigned char *)(loadbase + get_32be(isect->s_scnptr)); len = get_32be(isect->s_size); dst = (void *) PROG_START; if (im[0] == 0x1f && im[1] == 0x8b) { void *cp = (void *) RAM_FREE; avail_ram = (void *) (RAM_FREE + ((len + 7) & -8)); memcpy(cp, im, len); printf("gunzipping... "); gunzip(dst, 0x400000, cp, &len); printf("done\n"); } else { memmove(dst, im, len); } flush_cache(dst, len); sa = (unsigned long)dst; printf("start address = 0x%x\n", sa); #if 0 pause(); #endif { struct bi_record *rec; rec = (struct bi_record *)_ALIGN((unsigned long)dst+len+(1<<20)-1,(1<<20)); rec->tag = BI_FIRST; rec->size = sizeof(struct bi_record); rec = (struct bi_record *)((unsigned long)rec + rec->size); rec->tag = BI_BOOTLOADER_ID; sprintf( (char *)rec->data, "coffboot"); rec->size = sizeof(struct bi_record) + strlen("coffboot") + 1; rec = (struct bi_record *)((unsigned long)rec + rec->size); rec->tag = BI_MACHTYPE; rec->data[0] = _MACH_Pmac; rec->data[1] = 1; rec->size = sizeof(struct bi_record) + sizeof(unsigned long); rec = (struct bi_record *)((unsigned long)rec + rec->size); rec->tag = BI_LAST; rec->size = sizeof(struct bi_record); rec = (struct bi_record *)((unsigned long)rec + rec->size); } (*(void (*)())sa)(a1, a2, prom); printf("returned?\n"); pause(); }
int misc_init_r (void) { /* adjust flash start and size as well as the offset */ gd->bd->bi_flashstart = 0 - flash_info[0].size; gd->bd->bi_flashoffset= flash_info[0].size - CONFIG_SYS_MONITOR_LEN; #if 0 volatile unsigned short *fpga_mode = (unsigned short *)((ulong)CONFIG_SYS_FPGA_BASE_ADDR + CONFIG_SYS_FPGA_CTRL); volatile unsigned char *duart0_mcr = (unsigned char *)((ulong)DUART0_BA + 4); volatile unsigned char *duart1_mcr = (unsigned char *)((ulong)DUART1_BA + 4); bd_t *bd = gd->bd; char * tmp; /* Temporary char pointer */ unsigned char *dst; ulong len = sizeof(fpgadata); int status; int index; int i; unsigned long CPC0_CR0Reg; dst = malloc(CONFIG_SYS_FPGA_MAX_SIZE); if (gunzip (dst, CONFIG_SYS_FPGA_MAX_SIZE, (uchar *)fpgadata, &len) != 0) { printf ("GUNZIP ERROR - must RESET board to recover\n"); do_reset (NULL, 0, 0, NULL); } status = fpga_boot(dst, len); if (status != 0) { printf("\nFPGA: Booting failed "); switch (status) { case ERROR_FPGA_PRG_INIT_LOW: printf("(Timeout: INIT not low after asserting PROGRAM*)\n "); break; case ERROR_FPGA_PRG_INIT_HIGH: printf("(Timeout: INIT not high after deasserting PROGRAM*)\n "); break; case ERROR_FPGA_PRG_DONE: printf("(Timeout: DONE not high after programming FPGA)\n "); break; } /* display infos on fpgaimage */ index = 15; for (i=0; i<4; i++) { len = dst[index]; printf("FPGA: %s\n", &(dst[index+1])); index += len+3; } putc ('\n'); /* delayed reboot */ for (i=20; i>0; i--) { printf("Rebooting in %2d seconds \r",i); for (index=0;index<1000;index++) udelay(1000); } putc ('\n'); do_reset(NULL, 0, 0, NULL); } puts("FPGA: "); /* display infos on fpgaimage */ index = 15; for (i=0; i<4; i++) { len = dst[index]; printf("%s ", &(dst[index+1])); index += len+3; } putc ('\n'); free(dst); /* * Reset FPGA via FPGA_DATA pin */ SET_FPGA(FPGA_PRG | FPGA_CLK); udelay(1000); /* wait 1ms */ SET_FPGA(FPGA_PRG | FPGA_CLK | FPGA_DATA); udelay(1000); /* wait 1ms */ #endif #if 0 /* * Enable power on PS/2 interface */ *fpga_mode |= CONFIG_SYS_FPGA_CTRL_PS2_RESET; /* * Enable interrupts in exar duart mcr[3] */ *duart0_mcr = 0x08; *duart1_mcr = 0x08; #endif return (0); }
int misc_init_r (void) { DECLARE_GLOBAL_DATA_PTR; bd_t *bd = gd->bd; char * tmp; /* Temporary char pointer */ unsigned long cntrl0Reg; #ifdef CONFIG_CPCI405_VER2 unsigned char *dst; ulong len = sizeof(fpgadata); int status; int index; int i; /* * On CPCI-405 version 2 the environment is saved in eeprom! * FPGA can be gzip compressed (malloc) and booted this late. */ if (cpci405_version() >= 2) { /* * Setup GPIO pins (CS6+CS7 as GPIO) */ cntrl0Reg = mfdcr(cntrl0); mtdcr(cntrl0, cntrl0Reg | 0x00300000); dst = malloc(CFG_FPGA_MAX_SIZE); if (gunzip (dst, CFG_FPGA_MAX_SIZE, (uchar *)fpgadata, (int *)&len) != 0) { printf ("GUNZIP ERROR - must RESET board to recover\n"); do_reset (NULL, 0, 0, NULL); } status = fpga_boot(dst, len); if (status != 0) { printf("\nFPGA: Booting failed "); switch (status) { case ERROR_FPGA_PRG_INIT_LOW: printf("(Timeout: INIT not low after asserting PROGRAM*)\n "); break; case ERROR_FPGA_PRG_INIT_HIGH: printf("(Timeout: INIT not high after deasserting PROGRAM*)\n "); break; case ERROR_FPGA_PRG_DONE: printf("(Timeout: DONE not high after programming FPGA)\n "); break; } /* display infos on fpgaimage */ index = 15; for (i=0; i<4; i++) { len = dst[index]; printf("FPGA: %s\n", &(dst[index+1])); index += len+3; } putc ('\n'); /* delayed reboot */ for (i=20; i>0; i--) { printf("Rebooting in %2d seconds \r",i); for (index=0;index<1000;index++) udelay(1000); } putc ('\n'); do_reset(NULL, 0, 0, NULL); } /* restore gpio/cs settings */ mtdcr(cntrl0, cntrl0Reg); puts("FPGA: "); /* display infos on fpgaimage */ index = 15; for (i=0; i<4; i++) { len = dst[index]; printf("%s ", &(dst[index+1])); index += len+3; } putc ('\n'); free(dst); /* * Reset FPGA via FPGA_DATA pin */ SET_FPGA(FPGA_PRG | FPGA_CLK); udelay(1000); /* wait 1ms */ SET_FPGA(FPGA_PRG | FPGA_CLK | FPGA_DATA); udelay(1000); /* wait 1ms */ if (cpci405_version() == 3) { volatile unsigned short *fpga_mode = (unsigned short *)CFG_FPGA_BASE_ADDR; volatile unsigned char *leds = (unsigned char *)CFG_LED_ADDR; /* * Enable outputs in fpga on version 3 board */ *fpga_mode |= CFG_FPGA_MODE_ENABLE_OUTPUT; /* * Set outputs to 0 */ *leds = 0x00; /* * Reset external DUART */ *fpga_mode |= CFG_FPGA_MODE_DUART_RESET; udelay(100); *fpga_mode &= ~(CFG_FPGA_MODE_DUART_RESET); } } else { puts("\n*** U-Boot Version does not match Board Version!\n"); puts("*** CPCI-405 Version 1.x detected!\n"); puts("*** Please use correct U-Boot version (CPCI405 instead of CPCI4052)!\n\n"); } #else /* CONFIG_CPCI405_VER2 */ /* * Generate last byte of ip-addr from code-plug @ 0xf0000400 */ if (ctermm2()) { char str[32]; unsigned char ipbyte = *(unsigned char *)0xf0000400; /* * Only overwrite ip-addr with allowed values */ if ((ipbyte != 0x00) && (ipbyte != 0xff)) { bd->bi_ip_addr = (bd->bi_ip_addr & 0xffffff00) | ipbyte; sprintf(str, "%ld.%ld.%ld.%ld", (bd->bi_ip_addr & 0xff000000) >> 24, (bd->bi_ip_addr & 0x00ff0000) >> 16, (bd->bi_ip_addr & 0x0000ff00) >> 8, (bd->bi_ip_addr & 0x000000ff)); setenv("ipaddr", str); } }
void GeometryReader::run() { DependencyManager::get<StatTracker>()->decrementStat("PendingProcessing"); CounterStat counter("Processing"); PROFILE_RANGE_EX(resource_parse_geometry, "GeometryReader::run", 0xFF00FF00, 0, { { "url", _url.toString() } }); auto originalPriority = QThread::currentThread()->priority(); if (originalPriority == QThread::InheritPriority) { originalPriority = QThread::NormalPriority; } QThread::currentThread()->setPriority(QThread::LowPriority); Finally setPriorityBackToNormal([originalPriority]() { QThread::currentThread()->setPriority(originalPriority); }); if (!_resource.data()) { return; } try { if (_data.isEmpty()) { throw QString("reply is NULL"); } // Ensure the resource has not been deleted auto resource = _resource.toStrongRef(); if (!resource) { qCWarning(modelnetworking) << "Abandoning load of" << _url << "; could not get strong ref"; return; } if (_url.path().isEmpty()) { throw QString("url is invalid"); } HFMModel::Pointer hfmModel; QVariantHash serializerMapping = _mapping.second; serializerMapping["combineParts"] = _combineParts; serializerMapping["deduplicateIndices"] = true; if (_url.path().toLower().endsWith(".gz")) { QByteArray uncompressedData; if (!gunzip(_data, uncompressedData)) { throw QString("failed to decompress .gz model"); } // Strip the compression extension from the path, so the loader can infer the file type from what remains. // This is okay because we don't expect the serializer to be able to read the contents of a compressed model file. auto strippedUrl = _url; strippedUrl.setPath(_url.path().left(_url.path().size() - 3)); hfmModel = _modelLoader.load(uncompressedData, serializerMapping, strippedUrl, ""); } else { hfmModel = _modelLoader.load(_data, serializerMapping, _url, _webMediaType.toStdString()); } if (!hfmModel) { throw QString("unsupported format"); } if (hfmModel->meshes.empty() || hfmModel->joints.empty()) { throw QString("empty geometry, possibly due to an unsupported model version"); } // Add scripts to hfmModel if (!serializerMapping.value(SCRIPT_FIELD).isNull()) { QVariantList scripts = serializerMapping.values(SCRIPT_FIELD); for (auto &script : scripts) { hfmModel->scripts.push_back(script.toString()); } } // Do processing on the model baker::Baker modelBaker(hfmModel, _mapping.second, _mapping.first); modelBaker.run(); auto processedHFMModel = modelBaker.getHFMModel(); auto materialMapping = modelBaker.getMaterialMapping(); QMetaObject::invokeMethod(resource.data(), "setGeometryDefinition", Q_ARG(HFMModel::Pointer, processedHFMModel), Q_ARG(MaterialMapping, materialMapping)); } catch (const std::exception&) { auto resource = _resource.toStrongRef(); if (resource) { QMetaObject::invokeMethod(resource.data(), "finishedLoading", Q_ARG(bool, false)); } } catch (QString& e) { qCWarning(modelnetworking) << "Exception while loading model --" << e; auto resource = _resource.toStrongRef(); if (resource) { QMetaObject::invokeMethod(resource.data(), "finishedLoading", Q_ARG(bool, false)); } } }
int do_fpga_boot(unsigned char *fpgadata) { unsigned char *dst; int status; int index; int i; ulong len = CONFIG_SYS_MALLOC_LEN; /* * Setup GPIO's for FPGA programming */ GPIO_OUTPUT_CLEAR(CONFIG_SYS_GPIO_PRG); GPIO_OUTPUT_CLEAR(CONFIG_SYS_GPIO_CLK); GPIO_OUTPUT_CLEAR(CONFIG_SYS_GPIO_DATA); /* * Save value so no readback is required upon programming */ old_val = *IXP425_GPIO_GPOUTR; /* * First try to decompress fpga image (gzip compressed?) */ dst = malloc(CONFIG_SYS_FPGA_MAX_SIZE); if (gunzip(dst, CONFIG_SYS_FPGA_MAX_SIZE, (uchar *)fpgadata, &len) != 0) { printf("Error: Image has to be gzipp'ed!\n"); return -1; } status = fpga_boot(dst, len); if (status != 0) { printf("\nFPGA: Booting failed "); switch (status) { case ERROR_FPGA_PRG_INIT_LOW: printf("(Timeout: INIT not low after asserting PROGRAM*)\n "); break; case ERROR_FPGA_PRG_INIT_HIGH: printf("(Timeout: INIT not high after deasserting PROGRAM*)\n "); break; case ERROR_FPGA_PRG_DONE: printf("(Timeout: DONE not high after programming FPGA)\n "); break; } /* display infos on fpgaimage */ index = 15; for (i=0; i<4; i++) { len = dst[index]; printf("FPGA: %s\n", &(dst[index+1])); index += len+3; } putc ('\n'); /* delayed reboot */ for (i=5; i>0; i--) { printf("Rebooting in %2d seconds \r",i); for (index=0;index<1000;index++) udelay(1000); } putc('\n'); do_reset(NULL, 0, 0, NULL); } puts("FPGA: "); /* display infos on fpgaimage */ index = 15; for (i=0; i<4; i++) { len = dst[index]; printf("%s ", &(dst[index+1])); index += len+3; } putc('\n'); free(dst); /* * Reset FPGA */ GPIO_OUTPUT_CLEAR(CONFIG_SYS_GPIO_FPGA_RESET); udelay(10); GPIO_OUTPUT_SET(CONFIG_SYS_GPIO_FPGA_RESET); return (0); }
/** * decomp_image() - decompress the operating system * * @comp: Compression algorithm that is used (IH_COMP_...) * @load: Destination load address in U-Boot memory * @image_start Image start address (where we are decompressing from) * @type: OS type (IH_OS_...) * @load_bug: Place to decompress to * @image_buf: Address to decompress from * @return 0 if OK, -ve on error (BOOTM_ERR_...) */ static int decomp_image(int comp, ulong load, ulong image_start, int type, void *load_buf, void *image_buf, ulong image_len, ulong *load_end) { const char *type_name = genimg_get_type_name(type); __attribute__((unused)) uint unc_len = CONFIG_SYS_BOOTM_LEN; *load_end = load; switch (comp) { case IH_COMP_NONE: if (load == image_start) { printf(" XIP %s ... ", type_name); } else { printf(" Loading %s ... ", type_name); memmove_wd(load_buf, image_buf, image_len, CHUNKSZ); } *load_end = load + image_len; break; #ifdef CONFIG_GZIP case IH_COMP_GZIP: printf(" Uncompressing %s ... ", type_name); if (gunzip(load_buf, unc_len, image_buf, &image_len) != 0) { puts("GUNZIP: uncompress, out-of-mem or overwrite error - must RESET board to recover\n"); return BOOTM_ERR_RESET; } *load_end = load + image_len; break; #endif /* CONFIG_GZIP */ #ifdef CONFIG_BZIP2 case IH_COMP_BZIP2: printf(" Uncompressing %s ... ", type_name); /* * If we've got less than 4 MB of malloc() space, * use slower decompression algorithm which requires * at most 2300 KB of memory. */ int i = BZ2_bzBuffToBuffDecompress(load_buf, &unc_len, image_buf, image_len, CONFIG_SYS_MALLOC_LEN < (4096 * 1024), 0); if (i != BZ_OK) { printf("BUNZIP2: uncompress or overwrite error %d - must RESET board to recover\n", i); return BOOTM_ERR_RESET; } *load_end = load + unc_len; break; #endif /* CONFIG_BZIP2 */ #ifdef CONFIG_LZMA case IH_COMP_LZMA: { SizeT lzma_len = unc_len; int ret; printf(" Uncompressing %s ... ", type_name); ret = lzmaBuffToBuffDecompress(load_buf, &lzma_len, image_buf, image_len); unc_len = lzma_len; if (ret != SZ_OK) { printf("LZMA: uncompress or overwrite error %d - must RESET board to recover\n", ret); bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE); return BOOTM_ERR_RESET; } *load_end = load + unc_len; break; } #endif /* CONFIG_LZMA */ #ifdef CONFIG_LZO case IH_COMP_LZO: { size_t size = unc_len; int ret; printf(" Uncompressing %s ... ", type_name); ret = lzop_decompress(image_buf, image_len, load_buf, &size); if (ret != LZO_E_OK) { printf("LZO: uncompress or overwrite error %d - must RESET board to recover\n", ret); return BOOTM_ERR_RESET; } *load_end = load + size; break; } #endif /* CONFIG_LZO */ default: printf("Unimplemented compression type %d\n", comp); return BOOTM_ERR_UNIMPLEMENTED; } puts("OK\n"); return 0; }
struct bi_record * decompress_kernel(unsigned long load_addr, int num_words, unsigned long cksum) { #ifdef INTERACTIVE_CONSOLE int timer = 0; char ch; #endif char *cp; struct bi_record *rec; unsigned long initrd_loc = 0, TotalMemory = 0; #if defined(CONFIG_SERIAL_8250_CONSOLE) || defined(CONFIG_SERIAL_MPSC_CONSOLE) com_port = serial_init(0, NULL); #endif #if defined(PPC4xx_EMAC0_MR0) /* Reset MAL */ mtdcr(DCRN_MALCR(DCRN_MAL_BASE), MALCR_MMSR); /* Wait for reset */ while (mfdcr(DCRN_MALCR(DCRN_MAL_BASE)) & MALCR_MMSR) {}; /* Reset EMAC */ *(volatile unsigned long *)PPC4xx_EMAC0_MR0 = 0x20000000; __asm__ __volatile__("eieio"); #endif /* * Call get_mem_size(), which is memory controller dependent, * and we must have the correct file linked in here. */ TotalMemory = get_mem_size(); /* assume the chunk below 8M is free */ end_avail = (char *)0x00800000; /* * Reveal where we were loaded at and where we * were relocated to. */ puts("loaded at: "); puthex(load_addr); puts(" "); puthex((unsigned long)(load_addr + (4*num_words))); puts("\n"); if ( (unsigned long)load_addr != (unsigned long)&start ) { puts("relocated to: "); puthex((unsigned long)&start); puts(" "); puthex((unsigned long)((unsigned long)&start + (4*num_words))); puts("\n"); } /* * We link ourself to 0x00800000. When we run, we relocate * ourselves there. So we just need __image_begin for the * start. -- Tom */ zimage_start = (char *)(unsigned long)(&__image_begin); zimage_size = (unsigned long)(&__image_end) - (unsigned long)(&__image_begin); initrd_size = (unsigned long)(&__ramdisk_end) - (unsigned long)(&__ramdisk_begin); /* * The zImage and initrd will be between start and _end, so they've * already been moved once. We're good to go now. -- Tom */ avail_ram = (char *)PAGE_ALIGN((unsigned long)_end); puts("zimage at: "); puthex((unsigned long)zimage_start); puts(" "); puthex((unsigned long)(zimage_size+zimage_start)); puts("\n"); if ( initrd_size ) { puts("initrd at: "); puthex((unsigned long)(&__ramdisk_begin)); puts(" "); puthex((unsigned long)(&__ramdisk_end));puts("\n"); } #ifndef CONFIG_40x /* don't overwrite the 40x image located at 0x00400000! */ avail_ram = (char *)0x00400000; #endif end_avail = (char *)0x00800000; puts("avail ram: "); puthex((unsigned long)avail_ram); puts(" "); puthex((unsigned long)end_avail); puts("\n"); if (keyb_present) CRT_tstc(); /* Forces keyboard to be initialized */ /* Display standard Linux/PPC boot prompt for kernel args */ puts("\nLinux/PPC load: "); cp = cmd_line; memcpy (cmd_line, cmd_preset, sizeof(cmd_preset)); while ( *cp ) putc(*cp++); #ifdef INTERACTIVE_CONSOLE /* * If they have a console, allow them to edit the command line. * Otherwise, don't bother wasting the five seconds. */ while (timer++ < 5*1000) { if (tstc()) { while ((ch = getc()) != '\n' && ch != '\r') { /* Test for backspace/delete */ if (ch == '\b' || ch == '\177') { if (cp != cmd_line) { cp--; puts("\b \b"); } /* Test for ^x/^u (and wipe the line) */ } else if (ch == '\030' || ch == '\025') { while (cp != cmd_line) { cp--; puts("\b \b"); } } else { *cp++ = ch; putc(ch); } } break; /* Exit 'timer' loop */ } udelay(1000); /* 1 msec */ } *cp = 0; #endif puts("\n"); puts("Uncompressing Linux..."); gunzip(NULL, 0x400000, zimage_start, &zimage_size); puts("done.\n"); /* get the bi_rec address */ rec = bootinfo_addr(zimage_size); /* We need to make sure that the initrd and bi_recs do not * overlap. */ if ( initrd_size ) { unsigned long rec_loc = (unsigned long) rec; initrd_loc = (unsigned long)(&__ramdisk_begin); /* If the bi_recs are in the middle of the current * initrd, move the initrd to the next MB * boundary. */ if ((rec_loc > initrd_loc) && ((initrd_loc + initrd_size) > rec_loc)) { initrd_loc = _ALIGN((unsigned long)(zimage_size) + (2 << 20) - 1, (2 << 20)); memmove((void *)initrd_loc, &__ramdisk_begin, initrd_size); puts("initrd moved: "); puthex(initrd_loc); puts(" "); puthex(initrd_loc + initrd_size); puts("\n"); } } bootinfo_init(rec); if ( TotalMemory ) bootinfo_append(BI_MEMSIZE, sizeof(int), (void*)&TotalMemory); bootinfo_append(BI_CMD_LINE, strlen(cmd_line)+1, (void*)cmd_line); /* add a bi_rec for the initrd if it exists */ if (initrd_size) { unsigned long initrd[2]; initrd[0] = initrd_loc; initrd[1] = initrd_size; bootinfo_append(BI_INITRD, sizeof(initrd), &initrd); } puts("Now booting the kernel\n"); serial_close(com_port); return rec; }
void start(unsigned long a1, unsigned long a2, void *promptr) { unsigned long i, claim_addr, claim_size; extern char _start; struct bi_record *bi_recs; kernel_entry_t kernel_entry; Elf64_Ehdr *elf64; Elf64_Phdr *elf64ph; prom = (int (*)(void *)) promptr; chosen_handle = finddevice("/chosen"); if (chosen_handle == (void *) -1) exit(); if (getprop(chosen_handle, "stdout", &stdout, sizeof(stdout)) != 4) exit(); stderr = stdout; if (getprop(chosen_handle, "stdin", &stdin, sizeof(stdin)) != 4) exit(); printf("zImage starting: loaded at 0x%x\n\r", (unsigned)&_start); #if 0 sysmap.size = (unsigned long)(_sysmap_end - _sysmap_start); sysmap.memsize = sysmap.size; if ( sysmap.size > 0 ) { sysmap.addr = (RAM_END - sysmap.size) & ~0xFFF; claim(sysmap.addr, RAM_END - sysmap.addr, 0); printf("initial ramdisk moving 0x%lx <- 0x%lx (%lx bytes)\n\r", sysmap.addr, (unsigned long)_sysmap_start, sysmap.size); memcpy((void *)sysmap.addr, (void *)_sysmap_start, sysmap.size); } #endif initrd.size = (unsigned long)(_initrd_end - _initrd_start); initrd.memsize = initrd.size; if ( initrd.size > 0 ) { initrd.addr = (RAM_END - initrd.size) & ~0xFFF; a1 = a2 = 0; claim(initrd.addr, RAM_END - initrd.addr, 0); printf("initial ramdisk moving 0x%lx <- 0x%lx (%lx bytes)\n\r", initrd.addr, (unsigned long)_initrd_start, initrd.size); memcpy((void *)initrd.addr, (void *)_initrd_start, initrd.size); } vmlinuz.addr = (unsigned long)_vmlinux_start; vmlinuz.size = (unsigned long)(_vmlinux_end - _vmlinux_start); vmlinux.addr = (unsigned long)(void *)-1; vmlinux.size = PAGE_ALIGN(vmlinux_filesize); vmlinux.memsize = vmlinux_memsize; claim_size = vmlinux.memsize /* PPPBBB: + fudge for bi_recs */; for(claim_addr = PROG_START; claim_addr <= PROG_START * 8; claim_addr += 0x100000) { printf(" trying: 0x%08lx\n\r", claim_addr); vmlinux.addr = (unsigned long)claim(claim_addr, claim_size, 0); if ((void *)vmlinux.addr != (void *)-1) break; } if ((void *)vmlinux.addr == (void *)-1) { printf("claim error, can't allocate kernel memory\n\r"); exit(); } /* PPPBBB: should kernel always be gziped? */ if (*(unsigned short *)vmlinuz.addr == 0x1f8b) { avail_ram = scratch; begin_avail = avail_high = avail_ram; end_avail = scratch + sizeof(scratch); printf("gunzipping (0x%lx <- 0x%lx:0x%0lx)...", vmlinux.addr, vmlinuz.addr, vmlinuz.addr+vmlinuz.size); gunzip((void *)vmlinux.addr, vmlinux.size, (unsigned char *)vmlinuz.addr, (int *)&vmlinuz.size); printf("done %lu bytes\n\r", vmlinuz.size); printf("%u bytes of heap consumed, max in use %u\n\r", (unsigned)(avail_high - begin_avail), heap_max); } else { memmove((void *)vmlinux.addr,(void *)vmlinuz.addr,vmlinuz.size); } /* Skip over the ELF header */ elf64 = (Elf64_Ehdr *)vmlinux.addr; 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 ) { printf("Error: not a valid PPC64 ELF file!\n\r"); exit(); } 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 && elf64ph->p_offset != 0) break; } printf("... skipping 0x%lx bytes of ELF header\n\r", (unsigned long)elf64ph->p_offset); vmlinux.addr += (unsigned long)elf64ph->p_offset; vmlinux.size -= (unsigned long)elf64ph->p_offset; flush_cache((void *)vmlinux.addr, vmlinux.memsize); bi_recs = make_bi_recs(vmlinux.addr + vmlinux.memsize); kernel_entry = (kernel_entry_t)vmlinux.addr; printf( "kernel:\n\r" " entry addr = 0x%lx\n\r" " a1 = 0x%lx,\n\r" " a2 = 0x%lx,\n\r" " prom = 0x%lx,\n\r" " bi_recs = 0x%lx,\n\r", (unsigned long)kernel_entry, a1, a2, (unsigned long)prom, (unsigned long)bi_recs); kernel_entry( a1, a2, prom, bi_recs ); printf("Error: Linux kernel returned to zImage bootloader!\n\r"); exit(); }
FILE *gmx_ffopen(const char *file, const char *mode) { #ifdef SKIP_FFOPS return fopen(file, mode); #else FILE *ff = NULL; char buf[256], *bufsize = 0, *ptr; gmx_bool bRead; int bs; if (file == NULL) { return NULL; } if (mode[0] == 'w') { make_backup(file); } where(); bRead = (mode[0] == 'r' && mode[1] != '+'); strcpy(buf, file); if (!bRead || gmx_fexist(buf)) { if ((ff = fopen(buf, mode)) == NULL) { gmx_file(buf); } where(); /* Check whether we should be using buffering (default) or not * (for debugging) */ if (bUnbuffered || ((bufsize = getenv("GMX_LOG_BUFFER")) != NULL)) { /* Check whether to use completely unbuffered */ if (bUnbuffered) { bs = 0; } else { bs = strtol(bufsize, NULL, 10); } if (bs <= 0) { setbuf(ff, NULL); } else { snew(ptr, bs+8); if (setvbuf(ff, ptr, _IOFBF, bs) != 0) { gmx_file("Buffering File"); } } } where(); } else { sprintf(buf, "%s.Z", file); if (gmx_fexist(buf)) { ff = uncompress(buf, mode); } else { sprintf(buf, "%s.gz", file); if (gmx_fexist(buf)) { ff = gunzip(buf, mode); } else { gmx_file(file); } } } return ff; #endif }
unsigned long load_kernel(unsigned long load_addr, int num_words, unsigned long cksum, bd_t *bp) { char *cp, ch; int timer = 0, zimage_size; unsigned long initrd_size; /* First, capture the embedded board information. Then * initialize the serial console port. */ embed_config(&bp); #if defined(CONFIG_SERIAL_CPM_CONSOLE) || defined(CONFIG_SERIAL_8250_CONSOLE) com_port = serial_init(0, bp); #endif /* Grab some space for the command line and board info. Since * we no longer use the ELF header, but it was loaded, grab * that space. */ #ifdef CONFIG_MBX /* Because of the way the MBX loads the ELF image, we can't * tell where we started. We read a magic variable from the NVRAM * that gives us the intermediate buffer load address. */ load_addr = *(uint *)0xfa000020; load_addr += 0x10000; /* Skip ELF header */ #endif /* copy board data */ if (bp) memcpy(hold_residual,bp,sizeof(bd_t)); /* Set end of memory available to us. It is always the highest * memory address provided by the board information. */ end_avail = (char *)(bp->bi_memsize); puts("\nloaded at: "); puthex(load_addr); puts(" "); puthex((unsigned long)(load_addr + (4*num_words))); puts("\n"); if ( (unsigned long)load_addr != (unsigned long)&start ) { puts("relocated to: "); puthex((unsigned long)&start); puts(" "); puthex((unsigned long)((unsigned long)&start + (4*num_words))); puts("\n"); } if ( bp ) { puts("board data at: "); puthex((unsigned long)bp); puts(" "); puthex((unsigned long)((unsigned long)bp + sizeof(bd_t))); puts("\nrelocated to: "); puthex((unsigned long)hold_residual); puts(" "); puthex((unsigned long)((unsigned long)hold_residual + sizeof(bd_t))); puts("\n"); } /* * We link ourself to an arbitrary low address. When we run, we * relocate outself to that address. __image_being points to * the part of the image where the zImage is. -- Tom */ zimage_start = (char *)(unsigned long)(&__image_begin); zimage_size = (unsigned long)(&__image_end) - (unsigned long)(&__image_begin); initrd_size = (unsigned long)(&__ramdisk_end) - (unsigned long)(&__ramdisk_begin); /* * The zImage and initrd will be between start and _end, so they've * already been moved once. We're good to go now. -- Tom */ puts("zimage at: "); puthex((unsigned long)zimage_start); puts(" "); puthex((unsigned long)(zimage_size+zimage_start)); puts("\n"); if ( initrd_size ) { puts("initrd at: "); puthex((unsigned long)(&__ramdisk_begin)); puts(" "); puthex((unsigned long)(&__ramdisk_end));puts("\n"); } /* * setup avail_ram - this is the first part of ram usable * by the uncompress code. Anything after this program in RAM * is now fair game. -- Tom */ avail_ram = (char *)PAGE_ALIGN((unsigned long)_end); puts("avail ram: "); puthex((unsigned long)avail_ram); puts(" "); puthex((unsigned long)end_avail); puts("\n"); puts("\nLinux/PPC load: "); cp = cmd_line; /* This is where we try and pick the right command line for booting. * If we were given one at compile time, use it. It Is Right. * If we weren't, see if we have a ramdisk. If so, thats root. * When in doubt, give them the netroot (root=/dev/nfs rw) -- Tom */ #ifdef CONFIG_CMDLINE_BOOL memcpy (cmd_line, compiled_string, sizeof(compiled_string)); #else if ( initrd_size ) memcpy (cmd_line, ramroot_string, sizeof(ramroot_string)); else memcpy (cmd_line, netroot_string, sizeof(netroot_string)); #endif while ( *cp ) putc(*cp++); while (timer++ < 5*1000) { if (tstc()) { while ((ch = getc()) != '\n' && ch != '\r') { if (ch == '\b' || ch == '\177') { if (cp != cmd_line) { cp--; puts("\b \b"); } } else if (ch == '\030' /* ^x */ || ch == '\025') { /* ^u */ while (cp != cmd_line) { cp--; puts("\b \b"); } } else { *cp++ = ch; putc(ch); } } break; /* Exit 'timer' loop */ } udelay(1000); /* 1 msec */ } *cp = 0; puts("\nUncompressing Linux..."); gunzip(0, 0x400000, zimage_start, &zimage_size); flush_instruction_cache(); puts("done.\n"); { struct bi_record *rec; unsigned long initrd_loc; unsigned long rec_loc = _ALIGN((unsigned long)(zimage_size) + (1 << 20) - 1, (1 << 20)); rec = (struct bi_record *)rec_loc; /* We need to make sure that the initrd and bi_recs do not * overlap. */ if ( initrd_size ) { initrd_loc = (unsigned long)(&__ramdisk_begin); /* If the bi_recs are in the middle of the current * initrd, move the initrd to the next MB * boundary. */ if ((rec_loc > initrd_loc) && ((initrd_loc + initrd_size) > rec_loc)) { initrd_loc = _ALIGN((unsigned long)(zimage_size) + (2 << 20) - 1, (2 << 20)); memmove((void *)initrd_loc, &__ramdisk_begin, initrd_size); puts("initrd moved: "); puthex(initrd_loc); puts(" "); puthex(initrd_loc + initrd_size); puts("\n"); } } rec->tag = BI_FIRST; rec->size = sizeof(struct bi_record); rec = (struct bi_record *)((unsigned long)rec + rec->size); rec->tag = BI_CMD_LINE; memcpy( (char *)rec->data, cmd_line, strlen(cmd_line)+1); rec->size = sizeof(struct bi_record) + strlen(cmd_line) + 1; rec = (struct bi_record *)((unsigned long)rec + rec->size); if ( initrd_size ) { rec->tag = BI_INITRD; rec->data[0] = initrd_loc; rec->data[1] = initrd_size; rec->size = sizeof(struct bi_record) + 2 * sizeof(unsigned long); rec = (struct bi_record *)((unsigned long)rec + rec->size); } rec->tag = BI_LAST; rec->size = sizeof(struct bi_record); rec = (struct bi_record *)((unsigned long)rec + rec->size); } puts("Now booting the kernel\n"); #if defined(CONFIG_SERIAL_CPM_CONSOLE) || defined(CONFIG_SERIAL_8250_CONSOLE) serial_close(com_port); #endif return (unsigned long)hold_residual; }