/* * Try to detect a device supported by the legacy int13 BIOS */ static int bd_int13probe(struct bdinfo *bd) { int addr; if (bd->bd_flags & BD_FLOPPY) { addr = 0xa155c; } else { if ((bd->bd_unit & 0xf0) == 0x80) addr = 0xa155d; else addr = 0xa1482; } if ( *(u_char *)PTOV(addr) & (1<<(bd->bd_unit & 0x0f))) { bd->bd_flags |= BD_MODEINT13; return(1); } if ((bd->bd_unit & 0xF0) == 0xA0) { int media = ((unsigned *)PTOV(0xA1460))[bd->bd_unit & 0x0F] & 0x1F; if (media == 7) { /* MO */ bd->bd_flags |= BD_MODEINT13 | BD_OPTICAL; return(1); } } return(0); }
static int vidc_init(int arg) { int i, hw_cursor; if (vidc_started && arg == 0) return (0); vidc_started = 1; Crtat = (unsigned short *)PTOV(0xA0000); while ((inb(0x60) & 0x04) == 0) ; outb(0x62, 0xe0); while ((inb(0x60) & 0x01) == 0) ; hw_cursor = inb(0x62); hw_cursor |= (inb(0x62) << 8); inb(0x62); inb(0x62); inb(0x62); crtat = Crtat + hw_cursor; #ifdef TERM_EMU /* Init terminal emulator */ end_term(); get_pos(); curs_move(curx, cury); fg_c = DEFAULT_FGCOLOR; bg_c = DEFAULT_BGCOLOR; #endif for (i = 0; i < 10 && vidc_ischar(); i++) (void)vidc_getchar(); return (0); /* XXX reinit? */ }
static void fw_probe(int index, struct fwohci_softc *sc) { int err; sc->state = FWOHCI_STATE_INIT; err = biospci_find_devclass( 0x0c0010 /* Serial:FireWire:OHCI */, index /* index */, &sc->locator); if (err != 0) { sc->state = FWOHCI_STATE_DEAD; return; } biospci_write_config(sc->locator, 0x4 /* command */, 0x6 /* enable bus master and memory mapped I/O */, 1 /* word */); biospci_read_config(sc->locator, 0x00 /*devid*/, 2 /*dword*/, &sc->devid); biospci_read_config(sc->locator, 0x10 /*base_addr*/, 2 /*dword*/, &sc->base_addr); sc->handle = (uint32_t)PTOV(sc->base_addr); sc->bus_id = OREAD(sc, OHCI_BUS_ID); return; }
static void smbios_probe(const caddr_t addr) { caddr_t saddr, info; uintptr_t paddr; if (smbios.probed) return; smbios.probed = 1; /* Search signatures and validate checksums. */ saddr = smbios_sigsearch(addr ? addr : PTOV(SMBIOS_START), SMBIOS_LENGTH); if (saddr == NULL) return; smbios.length = SMBIOS_GET16(saddr, 0x16); /* Structure Table Length */ paddr = SMBIOS_GET32(saddr, 0x18); /* Structure Table Address */ smbios.count = SMBIOS_GET16(saddr, 0x1c); /* No of SMBIOS Structures */ smbios.ver = SMBIOS_GET8(saddr, 0x1e); /* SMBIOS BCD Revision */ if (smbios.ver != 0) { smbios.major = smbios.ver >> 4; smbios.minor = smbios.ver & 0x0f; if (smbios.major > 9 || smbios.minor > 9) smbios.ver = 0; }
void *atari_stram_alloc( long size, unsigned long *start_mem ) { static int kernel_in_stram = -1; void *adr = 0; if (kernel_in_stram < 0) kernel_in_stram = (PTOV( 0 ) == 0); if (kernel_in_stram) { /* Get memory from kernel data space */ adr = (void *) *start_mem; *start_mem += size; } else { /* Get memory from rsvd_stram_beg */ if (rsvd_stram_end + size < stram_end) { adr = (void *) rsvd_stram_end; rsvd_stram_end += size; } } return( adr ); }
void smbios_detect(void) { char buf[16]; caddr_t addr, dmi, smbios; size_t count, length; uint32_t paddr; int i, major, minor, ver; /* Search signatures and validate checksums. */ smbios = smbios_sigsearch(PTOV(SMBIOS_START), SMBIOS_LENGTH); if (smbios == NULL) return; length = SMBIOS_GET16(smbios, 0x16); /* Structure Table Length */ paddr = SMBIOS_GET32(smbios, 0x18); /* Structure Table Address */ count = SMBIOS_GET16(smbios, 0x1c); /* No of SMBIOS Structures */ ver = SMBIOS_GET8(smbios, 0x1e); /* SMBIOS BCD Revision */ if (ver != 0) { major = ver >> 4; minor = ver & 0x0f; if (major > 9 || minor > 9) ver = 0; }
static ACPI_TABLE_RSDP * biosacpi_search_rsdp(char *base, int length) { ACPI_TABLE_RSDP *rsdp; u_int8_t *cp, sum; int ofs, idx; /* search on 16-byte boundaries */ for (ofs = 0; ofs < length; ofs += 16) { rsdp = (ACPI_TABLE_RSDP *)PTOV(base + ofs); /* compare signature, validate checksum */ if (!strncmp(rsdp->Signature, ACPI_SIG_RSDP, strlen(ACPI_SIG_RSDP))) { cp = (u_int8_t *)rsdp; sum = 0; for (idx = 0; idx < RSDP_CHECKSUM_LENGTH; idx++) sum += *(cp + idx); if (sum != 0) { printf("acpi: bad RSDP checksum (%d)\n", sum); continue; } return(rsdp); } } return(NULL); }
static void scsi_falcon_intr (int irq, struct pt_regs *fp, void *dummy) { #ifdef REAL_DMA int dma_stat; /* Turn off DMA and select sector counter register before * accessing the status register (Atari recommendation!) */ st_dma.dma_mode_status = 0x90; dma_stat = st_dma.dma_mode_status; /* Bit 0 indicates some error in the DMA process... don't know * what happened exactly (no further docu). */ if (!(dma_stat & 0x01)) { /* DMA error */ printk(KERN_CRIT "SCSI DMA error near 0x%08lx!\n", SCSI_DMA_GETADR()); } /* If the DMA was active, but now bit 1 is not clear, it is some * other 5380 interrupt that finishes the DMA transfer. We have to * calculate the number of residual bytes and give a warning if * bytes are stuck in the ST-DMA fifo (there's no way to reach them!) */ if (atari_dma_active && (dma_stat & 0x02)) { unsigned long transferred; transferred = SCSI_DMA_GETADR() - atari_dma_startaddr; /* The ST-DMA address is incremented in 2-byte steps, but the * data are written only in 16-byte chunks. If the number of * transferred bytes is not divisible by 16, the remainder is * lost somewhere in outer space. */ if (transferred & 15) printk(KERN_ERR "SCSI DMA error: %ld bytes lost in " "ST-DMA fifo\n", transferred & 15); atari_dma_residual = HOSTDATA_DMALEN - transferred; DMA_PRINTK("SCSI DMA: There are %ld residual bytes.\n", atari_dma_residual); } else atari_dma_residual = 0; atari_dma_active = 0; if (atari_dma_orig_addr) { /* If the dribble buffer was used on a read operation, copy the DMA-ed * data to the original destination address. */ memcpy( atari_dma_orig_addr, (void *)PTOV(atari_dma_startaddr), HOSTDATA_DMALEN - atari_dma_residual ); atari_dma_orig_addr = NULL; } #endif /* REAL_DMA */ NCR5380_intr (0, 0, 0); }
/* * Initialisation: locate the PnP BIOS, test that we can call it. * Returns nonzero if the PnP BIOS is not usable on this system. */ static int biospnp_init(void) { struct pnp_isaConfiguration icfg; char *sigptr; int result; /* Search for the $PnP signature */ pnp_Icheck = NULL; for (sigptr = PTOV(0xf0000); sigptr < PTOV(0xfffff); sigptr += 16) if (!bcmp(sigptr, "$PnP", 4)) { pnp_Icheck = (struct pnp_ICstructure *)sigptr; break; } /* No signature, no BIOS */ if (pnp_Icheck == NULL) return(1); /* * Fetch the system table parameters as a test of the BIOS */ result = biospnp_f00(vsegofs(&pnp_NumNodes), vsegofs(&pnp_NodeSize)); if (result != PNP_SUCCESS) { return(1); } /* * Look for the PnP ISA configuration table */ result = biospnp_f40(vsegofs(&icfg)); switch (result) { case PNP_SUCCESS: /* If the BIOS found some PnP devices, take its hint for the read port */ if ((icfg.ic_revision == 1) && (icfg.ic_nCSN > 0)) isapnp_readport = icfg.ic_rdport; break; case PNP_FUNCTION_NOT_SUPPORTED: /* The BIOS says there is no ISA bus (should we trust that this works?) */ printf("PnP BIOS claims no ISA bus\n"); isapnp_readport = -1; break; } return(0); }
U32 test_isp_regs() { U16 *sptr = (U16 *)PTOV(get_isp_base(0)); U32 *lptr = (U32 *)PTOV(get_isp_base(0)); int i; for(i=0; i < 20; i++) { if ( sptr[i] != isp_regvals[i]) return(0); } for(i=0; i < 20; i++) { if ( lptr[i] != 0xFFFFFFFF) return(0); } return(1); }
/* * Quiz the BIOS for disk devices, save a little info about them. */ static int bd_init(void) { int base, unit; int da_drive=0, n=-0x10; /* sequence 0x90, 0x80, 0xa0 */ for (base = 0x90; base <= 0xa0; base += n, n += 0x30) { for (unit = base; (nbdinfo < MAXBDDEV) || ((unit & 0x0f) < 4); unit++) { bdinfo[nbdinfo].bd_open = 0; bdinfo[nbdinfo].bd_bcache = NULL; bdinfo[nbdinfo].bd_unit = unit; bdinfo[nbdinfo].bd_flags = (unit & 0xf0) == 0x90 ? BD_FLOPPY : 0; if (!bd_int13probe(&bdinfo[nbdinfo])){ if (((unit & 0xf0) == 0x90 && (unit & 0x0f) < 4) || ((unit & 0xf0) == 0xa0 && (unit & 0x0f) < 6)) continue; /* Target IDs are not contiguous. */ else break; } if (bdinfo[nbdinfo].bd_flags & BD_FLOPPY){ /* available 1.44MB access? */ if (*(u_char *)PTOV(0xA15AE) & (1<<(unit & 0xf))) { /* boot media 1.2MB FD? */ if ((*(u_char *)PTOV(0xA1584) & 0xf0) != 0x90) bdinfo[nbdinfo].bd_unit = 0x30 + (unit & 0xf); } } else { if ((unit & 0xF0) == 0xA0) /* SCSI HD or MO */ bdinfo[nbdinfo].bd_da_unit = da_drive++; } /* XXX we need "disk aliases" to make this simpler */ printf("BIOS drive %c: is disk%d\n", 'A' + nbdinfo, nbdinfo); nbdinfo++; } } bcache_add_dev(nbdinfo); return(0); }
ssize_t i386_readin(const int fd, vm_offset_t dest, const size_t len) { if (dest + len >= memtop_copyin) { errno = EFBIG; return(-1); } return (read(fd, PTOV(dest), len)); }
/* * Find the MP Floating Pointer Structure. See the MP spec section 4.1. */ static mpfps_t biosmptable_find_mpfps(void) { mpfps_t mpfps; uint16_t addr; /* EBDA is the 1 KB addressed by the 16 bit pointer at 0x40E. */ if (!memread(PTOV(0x40E), &addr, sizeof(addr))) return (NULL); mpfps = biosmptable_search_mpfps(PTOV(addr << 4), 0x400); if (mpfps != NULL) return (mpfps); /* Check the BIOS. */ mpfps = biosmptable_search_mpfps(PTOV(0xf0000), 0x10000); if (mpfps != NULL) return (mpfps); return (NULL); }
ssize_t i386_copyout(const vm_offset_t src, void *dest, const size_t len) { if (src + len >= memtop) { errno = EFBIG; return(-1); } bcopy(PTOV(src), dest, len); return(len); }
static void fw_cleanup() { struct dcons_buf *db; /* invalidate dcons buffer */ if (dcons_paddr) { db = (struct dcons_buf *)PTOV(dcons_paddr); db->magic = 0; } }
ssize_t i386_copyin(const void *src, vm_offset_t dest, const size_t len) { if (dest + len >= memtop) { errno = EFBIG; return(-1); } bcopy(src, PTOV(dest), len); return(len); }
void bios_getmem(void) { bios_basemem = ((*(u_char *)PTOV(0xA1501) & 0x07) + 1) * 128 * 1024; bios_extmem = *(u_char *)PTOV(0xA1401) * 128 * 1024 + *(u_int16_t *)PTOV(0xA1594) * 1024 * 1024; /* Set memtop to actual top of memory */ memtop = memtop_copyin = 0x100000 + bios_extmem; /* * If we have extended memory, use the last 3MB of 'extended' memory * as a high heap candidate. */ if (bios_extmem >= HEAP_MIN) { high_heap_size = HEAP_MIN; high_heap_base = memtop - HEAP_MIN; } }
/* * Set machine type to PC98_SYSTEM_PARAMETER. */ void set_machine_type(void) { int i; u_long ret, data; /* PC98_SYSTEM_PARAMETER (0x501) */ ret = ((*(u_char *)PTOV(0xA1501)) & 0x08) >> 3; /* Wait V-SYNC */ while (inb(0x60) & 0x20) {} while (!(inb(0x60) & 0x20)) {} /* ANK 'A' font */ outb(0xa1, 0x00); outb(0xa3, 0x41); /* M_NORMAL, use CG window (all NEC OK) */ for (i = data = 0; i < 4; i++) data += *((u_long *)PTOV(0xA4000) + i); /* 0xa4000 */ if (data == 0x6efc58fc) /* DA data */ ret |= M_NEC_PC98; else ret |= M_EPSON_PC98; ret |= (inb(0x42) & 0x20) ? M_8M : 0; /* PC98_SYSTEM_PARAMETER(0x400) */ if ((*(u_char *)PTOV(0xA1400)) & 0x80) ret |= M_NOTE; if (ret & M_NEC_PC98) { /* PC98_SYSTEM_PARAMETER(0x458) */ if ((*(u_char *)PTOV(0xA1458)) & 0x80) ret |= M_H98; else ret |= M_NOT_H98; } else ret |= M_NOT_H98; (*(u_long *)PTOV(0xA1620)) = ret; }
void atari_stram_init( void ) { int i; for( i = 0; i < boot_info.num_memory; ++i ) { if (boot_info.memory[i].addr == 0) { rsvd_stram_beg = PTOV( 0x800 ); /* skip super-only first 2 KB! */ rsvd_stram_end = rsvd_stram_beg; stram_end = rsvd_stram_beg - 0x800 + boot_info.memory[i].size; return; } } /* Should never come here! (There is always ST-Ram!) */ }
/* * Find the RSDP in low memory. See section 5.2.2 of the ACPI spec. */ static ACPI_TABLE_RSDP * biosacpi_find_rsdp(void) { ACPI_TABLE_RSDP *rsdp; uint16_t *addr; /* EBDA is the 1 KB addressed by the 16 bit pointer at 0x40E. */ addr = (uint16_t *)PTOV(0x40E); if ((rsdp = biosacpi_search_rsdp((char *)(*addr << 4), 0x400)) != NULL) return (rsdp); /* Check the upper memory BIOS space, 0xe0000 - 0xfffff. */ if ((rsdp = biosacpi_search_rsdp((char *)0xe0000, 0x20000)) != NULL) return (rsdp); return (NULL); }
static void atari_scsi_fetch_restbytes( void ) { int nr; char *src, *dst; /* fetch rest bytes in the DMA register */ dst = (char *)SCSI_DMA_READ_P( dma_addr ); if ((nr = ((long)dst & 3))) { /* there are 'nr' bytes left for the last long address before the DMA pointer */ dst = (char *)( (unsigned long)dst & ~3 ); DMA_PRINTK("SCSI DMA: there are %d rest bytes for phys addr 0x%08lx", nr, (long)dst); dst = (char *)PTOV(dst); /* The content of the DMA pointer * is a physical address! */ DMA_PRINTK(" = virt addr 0x%08lx\n", (long)dst); for( src = (char *)&tt_scsi_dma.dma_restdata; nr > 0; --nr ) *dst++ = *src++; } }
int keyhit(unsigned int secs) { uint32_t t0, t1; if (OPT_CHECK(RBX_NOINTR)) return (0); secs *= SECOND; t0 = 0; for (;;) { if (xgetc(1)) return (1); if (secs > 0) { t1 = *(uint32_t *)PTOV(0x46c); if (!t0) t0 = t1; if (t1 < t0 || t1 >= t0 + secs) return (0); } } /* NOTREACHED */ }
static void cpu_initialize_context(unsigned int cpu) { /* vcpu_guest_context_t is too large to allocate on the stack. * Hence we allocate statically and protect it with a lock */ vm_page_t m[NPGPTD + 2]; static vcpu_guest_context_t ctxt; vm_offset_t boot_stack; vm_offset_t newPTD; vm_paddr_t ma[NPGPTD]; int i; /* * Page 0,[0-3] PTD * Page 1, [4] boot stack * Page [5] PDPT * */ for (i = 0; i < NPGPTD + 2; i++) { m[i] = vm_page_alloc(NULL, 0, VM_ALLOC_NORMAL | VM_ALLOC_NOOBJ | VM_ALLOC_WIRED | VM_ALLOC_ZERO); pmap_zero_page(m[i]); } boot_stack = kmem_alloc_nofault(kernel_map, PAGE_SIZE); newPTD = kmem_alloc_nofault(kernel_map, NPGPTD * PAGE_SIZE); ma[0] = VM_PAGE_TO_MACH(m[0])|PG_V; #ifdef PAE pmap_kenter(boot_stack, VM_PAGE_TO_PHYS(m[NPGPTD + 1])); for (i = 0; i < NPGPTD; i++) { ((vm_paddr_t *)boot_stack)[i] = ma[i] = VM_PAGE_TO_MACH(m[i])|PG_V; } #endif /* * Copy cpu0 IdlePTD to new IdlePTD - copying only * kernel mappings */ pmap_qenter(newPTD, m, 4); memcpy((uint8_t *)newPTD + KPTDI*sizeof(vm_paddr_t), (uint8_t *)PTOV(IdlePTD) + KPTDI*sizeof(vm_paddr_t), nkpt*sizeof(vm_paddr_t)); pmap_qremove(newPTD, 4); kmem_free(kernel_map, newPTD, 4 * PAGE_SIZE); /* * map actual idle stack to boot_stack */ pmap_kenter(boot_stack, VM_PAGE_TO_PHYS(m[NPGPTD])); xen_pgdpt_pin(VM_PAGE_TO_MACH(m[NPGPTD + 1])); rw_wlock(&pvh_global_lock); for (i = 0; i < 4; i++) { int pdir = (PTDPTDI + i) / NPDEPG; int curoffset = (PTDPTDI + i) % NPDEPG; xen_queue_pt_update((vm_paddr_t) ((ma[pdir] & ~PG_V) + (curoffset*sizeof(vm_paddr_t))), ma[i]); } PT_UPDATES_FLUSH(); rw_wunlock(&pvh_global_lock); memset(&ctxt, 0, sizeof(ctxt)); ctxt.flags = VGCF_IN_KERNEL; ctxt.user_regs.ds = GSEL(GDATA_SEL, SEL_KPL); ctxt.user_regs.es = GSEL(GDATA_SEL, SEL_KPL); ctxt.user_regs.fs = GSEL(GPRIV_SEL, SEL_KPL); ctxt.user_regs.gs = GSEL(GDATA_SEL, SEL_KPL); ctxt.user_regs.cs = GSEL(GCODE_SEL, SEL_KPL); ctxt.user_regs.ss = GSEL(GDATA_SEL, SEL_KPL); ctxt.user_regs.eip = (unsigned long)init_secondary; ctxt.user_regs.eflags = PSL_KERNEL | 0x1000; /* IOPL_RING1 */ memset(&ctxt.fpu_ctxt, 0, sizeof(ctxt.fpu_ctxt)); smp_trap_init(ctxt.trap_ctxt); ctxt.ldt_ents = 0; ctxt.gdt_frames[0] = (uint32_t)((uint64_t)vtomach(bootAPgdt) >> PAGE_SHIFT); ctxt.gdt_ents = 512; #ifdef __i386__ ctxt.user_regs.esp = boot_stack + PAGE_SIZE; ctxt.kernel_ss = GSEL(GDATA_SEL, SEL_KPL); ctxt.kernel_sp = boot_stack + PAGE_SIZE; ctxt.event_callback_cs = GSEL(GCODE_SEL, SEL_KPL); ctxt.event_callback_eip = (unsigned long)Xhypervisor_callback; ctxt.failsafe_callback_cs = GSEL(GCODE_SEL, SEL_KPL); ctxt.failsafe_callback_eip = (unsigned long)failsafe_callback; ctxt.ctrlreg[3] = VM_PAGE_TO_MACH(m[NPGPTD + 1]); #else /* __x86_64__ */ ctxt.user_regs.esp = idle->thread.rsp0 - sizeof(struct pt_regs); ctxt.kernel_ss = GSEL(GDATA_SEL, SEL_KPL); ctxt.kernel_sp = idle->thread.rsp0; ctxt.event_callback_eip = (unsigned long)hypervisor_callback; ctxt.failsafe_callback_eip = (unsigned long)failsafe_callback; ctxt.syscall_callback_eip = (unsigned long)system_call; ctxt.ctrlreg[3] = xen_pfn_to_cr3(virt_to_mfn(init_level4_pgt)); ctxt.gs_base_kernel = (unsigned long)(cpu_pda(cpu)); #endif printf("gdtpfn=%lx pdptpfn=%lx\n", ctxt.gdt_frames[0], ctxt.ctrlreg[3] >> PAGE_SHIFT); PANIC_IF(HYPERVISOR_vcpu_op(VCPUOP_initialise, cpu, &ctxt)); DELAY(3000); PANIC_IF(HYPERVISOR_vcpu_op(VCPUOP_up, cpu, NULL)); }
static int parse() { char *arg = cmd; char *p, *q; unsigned int drv; int c, i; while ((c = *arg++)) { if (c == ' ' || c == '\t' || c == '\n') continue; for (p = arg; *p && *p != '\n' && *p != ' ' && *p != '\t'; p++); if (*p) *p++ = 0; if (c == '-') { while ((c = *arg++)) { for (i = 0; c != optstr[i]; i++) if (i == NOPT - 1) return -1; opts ^= 1 << flags[i]; } if (opts & 1 << RBX_PROBEKBD) { i = *(uint8_t *)PTOV(0x496) & 0x10; printf("Keyboard: %s\n", i ? "yes" : "no"); if (!i) opts |= 1 << RBX_DUAL | 1 << RBX_SERIAL; opts &= ~(1 << RBX_PROBEKBD); } ioctrl = opts & 1 << RBX_DUAL ? (IO_SERIAL|IO_KEYBOARD) : opts & 1 << RBX_SERIAL ? IO_SERIAL : IO_KEYBOARD; if (ioctrl & IO_SERIAL) sio_init(); } else { for (q = arg--; *q && *q != '('; q++); if (*q) { drv = -1; if (arg[1] == ':') { drv = *arg - '0'; if (drv > 9) return (-1); arg += 2; } if (q - arg != 2) return -1; for (i = 0; arg[0] != dev_nm[i][0] || arg[1] != dev_nm[i][1]; i++) if (i == NDEV - 1) return -1; dsk.type = i; arg += 3; dsk.unit = *arg - '0'; if (arg[1] != ',' || dsk.unit > 9) return -1; arg += 2; dsk.slice = WHOLE_DISK_SLICE; if (arg[1] == ',') { dsk.slice = *arg - '0' + 1; if (dsk.slice > NDOSPART) return -1; arg += 2; } if (arg[1] != ')') return -1; dsk.part = *arg - 'a'; if (dsk.part > 7) return (-1); arg += 2; if (drv == -1) drv = dsk.unit; dsk.drive = (dsk.type <= TYPE_MAXHARD ? DRV_HARD : 0) + drv; dsk_meta = 0; } if ((i = p - arg - !*(p - 1))) { if ((size_t)i >= sizeof(kname)) return -1; memcpy(kname, arg, i + 1); } } arg = p; } return 0; }
static void load(void) { union { struct exec ex; Elf32_Ehdr eh; } hdr; Elf32_Phdr ep[2]; Elf32_Shdr es[2]; caddr_t p; ino_t ino; uint32_t addr, x; int fmt, i, j; if (!(ino = lookup(kname))) { if (!ls) printf("No %s\n", kname); return; } if (xfsread(ino, &hdr, sizeof(hdr))) return; if (N_GETMAGIC(hdr.ex) == ZMAGIC) fmt = 0; else if (IS_ELF(hdr.eh)) fmt = 1; else { printf("Invalid %s\n", "format"); return; } if (fmt == 0) { addr = hdr.ex.a_entry & 0xffffff; p = PTOV(addr); fs_off = PAGE_SIZE; if (xfsread(ino, p, hdr.ex.a_text)) return; p += roundup2(hdr.ex.a_text, PAGE_SIZE); if (xfsread(ino, p, hdr.ex.a_data)) return; p += hdr.ex.a_data + roundup2(hdr.ex.a_bss, PAGE_SIZE); bootinfo.bi_symtab = VTOP(p); memcpy(p, &hdr.ex.a_syms, sizeof(hdr.ex.a_syms)); p += sizeof(hdr.ex.a_syms); if (hdr.ex.a_syms) { if (xfsread(ino, p, hdr.ex.a_syms)) return; p += hdr.ex.a_syms; if (xfsread(ino, p, sizeof(int))) return; x = *(uint32_t *)p; p += sizeof(int); x -= sizeof(int); if (xfsread(ino, p, x)) return; p += x; } } else { fs_off = hdr.eh.e_phoff; for (j = i = 0; i < hdr.eh.e_phnum && j < 2; i++) { if (xfsread(ino, ep + j, sizeof(ep[0]))) return; if (ep[j].p_type == PT_LOAD) j++; } for (i = 0; i < 2; i++) { p = PTOV(ep[i].p_paddr & 0xffffff); fs_off = ep[i].p_offset; if (xfsread(ino, p, ep[i].p_filesz)) return; } p += roundup2(ep[1].p_memsz, PAGE_SIZE); bootinfo.bi_symtab = VTOP(p); if (hdr.eh.e_shnum == hdr.eh.e_shstrndx + 3) { fs_off = hdr.eh.e_shoff + sizeof(es[0]) * (hdr.eh.e_shstrndx + 1); if (xfsread(ino, &es, sizeof(es))) return; for (i = 0; i < 2; i++) { memcpy(p, &es[i].sh_size, sizeof(es[i].sh_size)); p += sizeof(es[i].sh_size); fs_off = es[i].sh_offset; if (xfsread(ino, p, es[i].sh_size)) return; p += es[i].sh_size; } } addr = hdr.eh.e_entry & 0xffffff; } bootinfo.bi_esymtab = VTOP(p); bootinfo.bi_kernelname = VTOP(kname); bootinfo.bi_bios_dev = dsk.drive; __exec((caddr_t)addr, opts & RBX_MASK, MAKEBOOTDEV(dev_maj[dsk.type], 0, dsk.slice, dsk.unit, dsk.part), 0, 0, 0, VTOP(&bootinfo)); }
int main(void) { int autoboot; ino_t ino; dmadat = (void *)(roundup2(__base + (int32_t)&_end, 0x10000) - __base); v86.ctl = V86_FLAGS; dsk.drive = *(uint8_t *)PTOV(ARGS); dsk.type = dsk.drive & DRV_HARD ? TYPE_AD : TYPE_FD; dsk.unit = dsk.drive & DRV_MASK; dsk.slice = *(uint8_t *)PTOV(ARGS + 1) + 1; bootinfo.bi_version = BOOTINFO_VERSION; bootinfo.bi_size = sizeof(bootinfo); bootinfo.bi_basemem = 0; /* XXX will be filled by loader or kernel */ bootinfo.bi_extmem = memsize(); bootinfo.bi_memsizes_valid++; /* Process configuration file */ autoboot = 1; if ((ino = lookup(PATH_CONFIG))) fsread(ino, cmd, sizeof(cmd)); if (*cmd) { printf("%s: %s", PATH_CONFIG, cmd); if (parse()) autoboot = 0; /* Do not process this command twice */ *cmd = 0; } /* * Try to exec stage 3 boot loader. If interrupted by a keypress, * or in case of failure, try to load a kernel directly instead. */ if (autoboot && !*kname) { memcpy(kname, PATH_BOOT3, sizeof(PATH_BOOT3)); if (!keyhit(3*SECOND)) { load(); memcpy(kname, PATH_KERNEL, sizeof(PATH_KERNEL)); } } /* Present the user with the boot2 prompt. */ for (;;) { printf("\nFreeBSD/i386 boot\n" "Default: %u:%s(%u,%c)%s\n" "boot: ", dsk.drive & DRV_MASK, dev_nm[dsk.type], dsk.unit, 'a' + dsk.part, kname); if (ioctrl & IO_SERIAL) sio_flush(); if (!autoboot || keyhit(5*SECOND)) getstr(); else putchar('\n'); autoboot = 0; if (parse()) putchar('\a'); else load(); } }
static void slm_test_ready( unsigned long dummy ) { #ifdef SLM_CONT_CNT_REPROG /* program for 255*512 bytes again */ dma_wd.fdc_acces_seccount = SLM_DMA_AMOUNT; START_TIMER( DMA_TIME_FOR(0) ); #ifdef DEBUG printk( "SLM: reprogramming timer for %d jiffies, addr=%#lx\n", DMA_TIME_FOR(0), get_dma_addr() ); #endif #else /* !SLM_CONT_CNT_REPROG */ unsigned long flags, addr; int d, ti; #ifdef DEBUG struct timeval start_tm, end_tm; int did_wait = 0; #endif save_flags(flags); cli(); addr = get_dma_addr(); if ((d = SLMEndAddr - addr) > 0) { restore_flags(flags); /* slice not yet finished, decide whether to start another timer or to * busy-wait */ ti = DMA_TIME_FOR( d ); if (ti > 0) { #ifdef DEBUG printk( "SLM: reprogramming timer for %d jiffies, rest %d bytes\n", ti, d ); #endif START_TIMER( ti ); return; } /* wait for desired end address to be reached */ #ifdef DEBUG do_gettimeofday( &start_tm ); did_wait = 1; #endif cli(); while( get_dma_addr() < SLMEndAddr ) barrier(); } /* slice finished, start next one */ SLMCurAddr += SLMSliceSize; #ifdef SLM_CONTINUOUS_DMA /* program for 255*512 bytes again */ dma_wd.fdc_acces_seccount = SLM_DMA_AMOUNT; #else /* set DMA address; * add 2 bytes for the ones in the SLM controller FIFO! */ set_dma_addr( SLMCurAddr + 2 ); /* toggle DMA to write and select sector counter reg */ dma_wd.dma_mode_status = 0x92; MFPDELAY(); dma_wd.dma_mode_status = 0x192; MFPDELAY(); /* program for 255*512 bytes and start DMA */ DMA_LONG_WRITE( SLM_DMA_AMOUNT, 0x112 ); #endif restore_flags(flags); #ifdef DEBUG if (did_wait) { int ms; do_gettimeofday( &end_tm ); ms = (end_tm.tv_sec*1000000+end_tm.tv_usec) - (start_tm.tv_sec*1000000+start_tm.tv_usec); printk( "SLM: did %ld.%ld ms busy waiting for %d bytes\n", ms/1000, ms%1000, d ); } else printk( "SLM: didn't wait (!)\n" ); #endif if ((unsigned char *)PTOV( SLMCurAddr + SLMSliceSize ) >= BufferP) { /* will be last slice, no timer necessary */ #ifdef DEBUG printk( "SLM: CurAddr=%#lx EndAddr=%#lx last slice -> no timer\n", SLMCurAddr, SLMEndAddr ); #endif } else { /* not last slice */ SLMEndAddr = SLMCurAddr + SLMSliceSize + SLM_DMA_INT_OFFSET; START_TIMER( DMA_TIME_FOR( SLMSliceSize )); #ifdef DEBUG printk( "SLM: CurAddr=%#lx EndAddr=%#lx timer=%ld\n", SLMCurAddr, SLMEndAddr, DMA_TIME_FOR( SLMSliceSize ) ); #endif } #endif /* SLM_CONT_CNT_REPROG */ }
unsigned long mm_phys_to_virt (unsigned long addr) { return PTOV (addr); }
static int parse() { char *arg = cmd; char *ep, *p, *q; const char *cp; unsigned int drv; int c, i, j; size_t k; while ((c = *arg++)) { if (c == ' ' || c == '\t' || c == '\n') continue; for (p = arg; *p && *p != '\n' && *p != ' ' && *p != '\t'; p++); ep = p; if (*p) *p++ = 0; if (c == '-') { while ((c = *arg++)) { if (c == 'P') { if (*(uint8_t *)PTOV(0x496) & 0x10) { cp = "yes"; } else { opts |= OPT_SET(RBX_DUAL) | OPT_SET(RBX_SERIAL); cp = "no"; } printf("Keyboard: %s\n", cp); continue; #if SERIAL } else if (c == 'S') { j = 0; while ((unsigned int)(i = *arg++ - '0') <= 9) j = j * 10 + i; if (j > 0 && i == -'0') { comspeed = j; break; } /* Fall through to error below ('S' not in optstr[]). */ #endif } for (i = 0; c != optstr[i]; i++) if (i == NOPT - 1) return -1; opts ^= OPT_SET(flags[i]); } #if SERIAL ioctrl = OPT_CHECK(RBX_DUAL) ? (IO_SERIAL|IO_KEYBOARD) : OPT_CHECK(RBX_SERIAL) ? IO_SERIAL : IO_KEYBOARD; if (DO_SIO) { if (sio_init(115200 / comspeed) != 0) ioctrl &= ~IO_SERIAL; } #endif } else { for (q = arg--; *q && *q != '('; q++); if (*q) { drv = -1; if (arg[1] == ':') { drv = *arg - '0'; if (drv > 9) return (-1); arg += 2; } if (q - arg != 2) return -1; for (i = 0; arg[0] != dev_nm[i][0] || arg[1] != dev_nm[i][1]; i++) if (i == NDEV - 1) return -1; dsk.type = i; arg += 3; dsk.unit = *arg - '0'; if (arg[1] != ',' || dsk.unit > 9) return -1; arg += 2; dsk.slice = WHOLE_DISK_SLICE; if (arg[1] == ',') { dsk.slice = *arg - '0' + 1; if (dsk.slice > NDOSPART + 1) return -1; arg += 2; } if (arg[1] != ')') return -1; dsk.part = *arg - 'a'; if (dsk.part > 7) return (-1); arg += 2; if (drv == -1) drv = dsk.unit; dsk.drive = (dsk.type <= TYPE_MAXHARD ? DRV_HARD : 0) + drv; dsk_meta = 0; } k = ep - arg; if (k > 0) { if (k >= sizeof(knamebuf)) return -1; memcpy(knamebuf, arg, k + 1); kname = knamebuf; } } arg = p; } return 0; }
int main(void) { uint8_t autoboot; ufs_ino_t ino; size_t nbyte; dmadat = (void *)(roundup2(__base + (int32_t)&_end, 0x10000) - __base); v86.ctl = V86_FLAGS; v86.efl = PSL_RESERVED_DEFAULT | PSL_I; dsk.drive = *(uint8_t *)PTOV(ARGS); dsk.type = dsk.drive & DRV_HARD ? TYPE_AD : TYPE_FD; dsk.unit = dsk.drive & DRV_MASK; dsk.slice = *(uint8_t *)PTOV(ARGS + 1) + 1; bootinfo.bi_version = BOOTINFO_VERSION; bootinfo.bi_size = sizeof(bootinfo); /* Process configuration file */ autoboot = 1; if ((ino = lookup(PATH_CONFIG)) || (ino = lookup(PATH_DOTCONFIG))) { nbyte = fsread(ino, cmd, sizeof(cmd) - 1); cmd[nbyte] = '\0'; } if (*cmd) { memcpy(cmddup, cmd, sizeof(cmd)); if (parse()) autoboot = 0; if (!OPT_CHECK(RBX_QUIET)) printf("%s: %s", PATH_CONFIG, cmddup); /* Do not process this command twice */ *cmd = 0; } /* * Try to exec stage 3 boot loader. If interrupted by a keypress, * or in case of failure, try to load a kernel directly instead. */ if (!kname) { kname = PATH_BOOT3; if (autoboot && !keyhit(3*SECOND)) { load(); kname = PATH_KERNEL; } } /* Present the user with the boot2 prompt. */ for (;;) { if (!autoboot || !OPT_CHECK(RBX_QUIET)) printf("\nFreeBSD/x86 boot\n" "Default: %u:%s(%u,%c)%s\n" "boot: ", dsk.drive & DRV_MASK, dev_nm[dsk.type], dsk.unit, 'a' + dsk.part, kname); if (DO_SIO) sio_flush(); if (!autoboot || keyhit(3*SECOND)) getstr(); else if (!autoboot || !OPT_CHECK(RBX_QUIET)) putchar('\n'); autoboot = 0; if (parse()) putchar('\a'); else load(); } }