int bus_space_map(bus_space_tag_t bst, bus_addr_t addr, bus_size_t size, int flags __unused, bus_space_handle_t *bshp) { *bshp = (__predict_false(bst == IA64_BUS_SPACE_IO)) ? addr : (uintptr_t)pmap_mapdev(addr, size); return (0); }
static int grackle_attach(device_t dev) { struct grackle_softc *sc; sc = device_get_softc(dev); /* * The Grackle PCI config addr/data registers are actually in * PCI space, but since they are needed to actually probe the * PCI bus, use the fact that they are also available directly * on the processor bus and map them */ sc->sc_addr = (vm_offset_t)pmap_mapdev(GRACKLE_ADDR, PAGE_SIZE); sc->sc_data = (vm_offset_t)pmap_mapdev(GRACKLE_DATA, PAGE_SIZE); return (ofw_pci_attach(dev)); }
/* * Implementation of bus_space_map(), which effectively is a thin * wrapper around pmap_mapdev() for memory mapped I/O space. It's * implemented here and not in <x86/bus.h> to avoid pollution. */ int bus_space_map(bus_space_tag_t tag, bus_addr_t addr, bus_size_t size, int flags __unused, bus_space_handle_t *bshp) { *bshp = (tag == X86_BUS_SPACE_MEM) ? (uintptr_t)pmap_mapdev(addr, size) : addr; return (0); }
static void xbox_remap(void *unused) { struct fb_info *info; if (!arch_i386_is_xbox) return; info = &xboxfb_info; info->fb_vbase = (intptr_t)pmap_mapdev(info->fb_pbase, info->fb_size); }
static vm_offset_t s3lfb_map_buffer(u_int paddr, size_t size) { vm_offset_t vaddr; u_int off; off = paddr - trunc_page(paddr); vaddr = (vm_offset_t)pmap_mapdev(paddr - off, size + off); return (vaddr + off); }
int i80321_mem_bs_map(void *t, bus_addr_t bpa, bus_size_t size, int flags, bus_space_handle_t *bshp) { vm_paddr_t pa, endpa; pa = trunc_page(bpa); endpa = round_page(bpa + size); *bshp = (vm_offset_t)pmap_mapdev(pa, endpa - pa); return (0); }
static void bcm_fb_init(void *arg) { struct bcmsc_softc *sc = arg; struct video_adapter_softc *va_sc = &va_softc; int err; volatile struct bcm_fb_config* fb_config = sc->fb_config; /* TODO: replace it with FDT stuff */ fb_config->xres = FB_WIDTH; fb_config->yres = FB_HEIGHT; fb_config->vxres = 0; fb_config->vyres = 0; fb_config->xoffset = 0; fb_config->yoffset = 0; fb_config->bpp = 24; fb_config->base = 0; fb_config->pitch = 0; fb_config->screen_size = 0; bus_dmamap_sync(sc->dma_tag, sc->dma_map, BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD); bcm_mbox_write(BCM2835_MBOX_CHAN_FB, sc->fb_config_phys); bcm_mbox_read(BCM2835_MBOX_CHAN_FB, &err); bus_dmamap_sync(sc->dma_tag, sc->dma_map, BUS_DMASYNC_POSTREAD); if (err == 0) { device_printf(sc->dev, "%dx%d(%dx%d@%d,%d) %dbpp\n", fb_config->xres, fb_config->yres, fb_config->vxres, fb_config->vyres, fb_config->xoffset, fb_config->yoffset, fb_config->bpp); device_printf(sc->dev, "pitch %d, base 0x%08x, screen_size %d\n", fb_config->pitch, fb_config->base, fb_config->screen_size); if (fb_config->base) { va_sc->fb_addr = (intptr_t)pmap_mapdev(fb_config->base, fb_config->screen_size); va_sc->fb_size = fb_config->screen_size; va_sc->stride = fb_config->pitch; } } else device_printf(sc->dev, "Failed to set framebuffer info\n"); config_intrhook_disestablish(&sc->init_hook); }
static int uninorth_attach(device_t dev) { struct uninorth_softc *sc; const char *compatible; phandle_t node; uint32_t reg[3]; uint64_t regbase; cell_t acells; node = ofw_bus_get_node(dev); sc = device_get_softc(dev); if (OF_getprop(node, "reg", reg, sizeof(reg)) < 8) return (ENXIO); sc->sc_ver = 0; compatible = ofw_bus_get_compat(dev); if (strcmp(compatible, "u3-agp") == 0) sc->sc_ver = 3; if (strcmp(compatible, "u4-pcie") == 0) sc->sc_ver = 4; acells = 1; OF_getprop(OF_parent(node), "#address-cells", &acells, sizeof(acells)); regbase = reg[0]; if (acells == 2) { regbase <<= 32; regbase |= reg[1]; } sc->sc_addr = (vm_offset_t)pmap_mapdev(regbase + 0x800000, PAGE_SIZE); sc->sc_data = (vm_offset_t)pmap_mapdev(regbase + 0xc00000, PAGE_SIZE); return (ofw_pci_attach(dev)); }
static int pxa_smi_activate_resource(device_t dev, device_t child, int type, int rid, struct resource *r) { struct pxa_smi_softc *sc; sc = (struct pxa_smi_softc *)device_get_softc(dev); if (type == SYS_RES_IRQ) return (bus_activate_resource(dev, SYS_RES_IRQ, rid, r)); rman_set_bushandle(r, (bus_space_handle_t)pmap_mapdev(rman_get_start(r), rman_get_size(r))); return (rman_activate_resource(r)); }
static int nexus_activate_resource(device_t bus, device_t child, int type, int rid, struct resource *r) { int err; bus_addr_t paddr; bus_size_t psize; bus_space_handle_t vaddr; if ((err = rman_activate_resource(r)) != 0) return (err); /* * If this is a memory resource, map it into the kernel. */ if (type == SYS_RES_MEMORY || type == SYS_RES_IOPORT) { paddr = (bus_addr_t)rman_get_start(r); psize = (bus_size_t)rman_get_size(r); #ifdef FDT err = bus_space_map(fdtbus_bs_tag, paddr, psize, 0, &vaddr); if (err != 0) { rman_deactivate_resource(r); return (err); } rman_set_bustag(r, fdtbus_bs_tag); #else vaddr = (bus_space_handle_t)pmap_mapdev((vm_offset_t)paddr, (vm_size_t)psize); if (vaddr == 0) { rman_deactivate_resource(r); return (ENOMEM); } rman_set_bustag(r, (void *)1); #endif rman_set_virtual(r, (void *)vaddr); rman_set_bushandle(r, vaddr); return (0); } else if (type == SYS_RES_IRQ) { #ifdef INTRNG err = intr_activate_irq(child, r); if (err != 0) { rman_deactivate_resource(r); return (err); } #endif } return (0); }
int generic_bs_map(void *t, bus_addr_t bpa, bus_size_t size, int flags, bus_space_handle_t *bshp) { void *va; /* * We don't even examine the passed-in flags. For ARM, the CACHEABLE * flag doesn't make sense (we create PTE_DEVICE mappings), and the * LINEAR flag is just implied because we use kva_alloc(size). */ if ((va = pmap_mapdev(bpa, size)) == NULL) return (ENOMEM); *bshp = (bus_space_handle_t)va; return (0); }
/* * Initialize the local APIC on the BSP. */ static int madt_setup_local(void) { madt = pmap_mapdev(madt_physaddr, madt_length); lapic_init((uintptr_t)madt->LocalApicAddress); printf("ACPI APIC Table: <%.*s %.*s>\n", (int)sizeof(madt->Header.OemId), madt->Header.OemId, (int)sizeof(madt->Header.OemTableId), madt->Header.OemTableId); /* * We ignore 64-bit local APIC override entries. Should we * perhaps emit a warning here if we find one? */ return (0); }
static int nexus_activate_resource(device_t bus, device_t child, int type, int rid, struct resource *r) { #ifdef PC98 bus_space_handle_t bh; int error; #endif void *vaddr; /* * If this is a memory resource, map it into the kernel. */ switch (type) { case SYS_RES_IOPORT: #ifdef PC98 error = i386_bus_space_handle_alloc(X86_BUS_SPACE_IO, rman_get_start(r), rman_get_size(r), &bh); if (error) return (error); rman_set_bushandle(r, bh); #else rman_set_bushandle(r, rman_get_start(r)); #endif rman_set_bustag(r, X86_BUS_SPACE_IO); break; case SYS_RES_MEMORY: #ifdef PC98 error = i386_bus_space_handle_alloc(X86_BUS_SPACE_MEM, rman_get_start(r), rman_get_size(r), &bh); if (error) return (error); #endif vaddr = pmap_mapdev(rman_get_start(r), rman_get_size(r)); rman_set_virtual(r, vaddr); rman_set_bustag(r, X86_BUS_SPACE_MEM); #ifdef PC98 /* PC-98: the type of bus_space_handle_t is the structure. */ bh->bsh_base = (bus_addr_t) vaddr; rman_set_bushandle(r, bh); #else /* IBM-PC: the type of bus_space_handle_t is u_int */ rman_set_bushandle(r, (bus_space_handle_t) vaddr); #endif } return (rman_activate_resource(r)); }
static int at91_bs_map(void *t, bus_addr_t bpa, bus_size_t size, int flags, bus_space_handle_t *bshp) { vm_paddr_t pa, endpa; pa = trunc_page(bpa); if (pa >= 0xfff00000) { *bshp = pa - 0xf0000000 + 0xd0000000; return (0); } if (pa >= 0xdff00000) return (0); endpa = round_page(bpa + size); *bshp = (vm_offset_t)pmap_mapdev(pa, endpa - pa); return (0); }
/* * Collect the entry points for PAL and SAL. Be extra careful about NULL * pointer values. We're running pre-console, so it's better to return * error values than to cause panics, machine checks and other traps and * faults. Keep this minimal... */ int efi_boot_minimal(uint64_t systbl) { struct efi_md *md; efi_status status; if (systbl == 0) return (EINVAL); efi_systbl = (struct efi_systbl *)IA64_PHYS_TO_RR7(systbl); if (efi_systbl->st_hdr.th_sig != EFI_SYSTBL_SIG) { efi_systbl = NULL; return (EFAULT); } efi_cfgtbl = (efi_systbl->st_cfgtbl == 0) ? NULL : (struct efi_cfgtbl *)IA64_PHYS_TO_RR7(efi_systbl->st_cfgtbl); if (efi_cfgtbl == NULL) return (ENOENT); efi_runtime = (efi_systbl->st_rt == 0) ? NULL : (struct efi_rt *)IA64_PHYS_TO_RR7(efi_systbl->st_rt); if (efi_runtime == NULL) return (ENOENT); /* * Relocate runtime memory segments for firmware. */ md = efi_md_first(); while (md != NULL) { if (md->md_attr & EFI_MD_ATTR_RT) { if (md->md_attr & EFI_MD_ATTR_WB) md->md_virt = (void *)IA64_PHYS_TO_RR7(md->md_phys); else if (md->md_attr & EFI_MD_ATTR_UC) md->md_virt = pmap_mapdev(md->md_phys, md->md_pages * EFI_PAGE_SIZE); } md = efi_md_next(md); } status = ia64_call_efi_physical((uint64_t)efi_runtime->rt_setvirtual, bootinfo.bi_memmap_size, bootinfo.bi_memdesc_size, bootinfo.bi_memdesc_version, bootinfo.bi_memmap, 0); return ((status < 0) ? EFAULT : 0); }
int pcie_cfgregopen(uint64_t base, uint8_t minbus, uint8_t maxbus) { uint32_t val1, val2; int slot; if (!mcfg_enable) return (0); if (minbus != 0) return (0); if (bootverbose) printf("PCIe: Memory Mapped configuration base @ 0x%lx\n", base); /* XXX: We should make sure this really fits into the direct map. */ pcie_base = (vm_offset_t)pmap_mapdev(base, (maxbus + 1) << 20); pcie_minbus = minbus; pcie_maxbus = maxbus; cfgmech = CFGMECH_PCIE; /* * On some AMD systems, some of the devices on bus 0 are * inaccessible using memory-mapped PCI config access. Walk * bus 0 looking for such devices. For these devices, we will * fall back to using type 1 config access instead. */ if (pci_cfgregopen() != 0) { for (slot = 0; slot <= PCI_SLOTMAX; slot++) { val1 = pcireg_cfgread(0, slot, 0, 0, 4); if (val1 == 0xffffffff) continue; val2 = pciereg_cfgread(0, slot, 0, 0, 4); if (val2 != val1) pcie_badslots |= (1 << slot); } } return (1); }
static int uninorth_activate_resource(device_t bus, device_t child, int type, int rid, struct resource *res) { void *p; if (type == SYS_RES_IRQ) return (bus_activate_resource(bus, type, rid, res)); if (type == SYS_RES_MEMORY) { p = pmap_mapdev((vm_offset_t)rman_get_start(res), (vm_size_t)rman_get_size(res)); if (p == NULL) return (ENOMEM); rman_set_virtual(res, p); rman_set_bushandle(res, (u_long)p); } return (rman_activate_resource(res)); }
static int bs_gen_map(bus_addr_t addr, bus_size_t size __unused, int flags __unused, bus_space_handle_t *bshp) { /* * Record what we did if we haven't enabled the MMU yet. We * will need to remap it as soon as the MMU comes up. */ if (!pmap_bootstrapped) { KASSERT(earlyboot_map_idx < MAX_EARLYBOOT_MAPPINGS, ("%s: too many early boot mapping requests", __func__)); earlyboot_mappings[earlyboot_map_idx].addr = addr; earlyboot_mappings[earlyboot_map_idx].size = size; earlyboot_map_idx++; *bshp = addr; } else { *bshp = (bus_space_handle_t)pmap_mapdev(addr,size); } return (0); }
static int at91_bs_map(bus_space_tag_t tag, bus_addr_t bpa, bus_size_t size, int flags, bus_space_handle_t *bshp) { vm_paddr_t pa, endpa; pa = trunc_page(bpa); if (pa >= AT91_PA_BASE + 0xff00000) { *bshp = bpa - AT91_PA_BASE + AT91_BASE; return (0); } if (pa >= AT91_BASE + 0xff00000) { *bshp = bpa; return (0); } endpa = round_page(bpa + size); *bshp = (vm_offset_t)pmap_mapdev(pa, endpa - pa) + (bpa - pa); return (0); }
static int nexus_activate_resource(device_t bus, device_t child, int type, int rid, struct resource *r) { /* * If this is a memory resource, map it into the kernel. */ if (type == SYS_RES_MEMORY) { void *vaddr; vaddr = pmap_mapdev(rman_get_start(r), rman_get_size(r)); rman_set_virtual(r, vaddr); rman_set_bustag(r, AMD64_BUS_SPACE_MEM); rman_set_bushandle(r, (bus_space_handle_t) vaddr); } else if (type == SYS_RES_IOPORT) { rman_set_bustag(r, AMD64_BUS_SPACE_IO); rman_set_bushandle(r, rman_get_start(r)); } return (rman_activate_resource(r)); }
/* * General PCI based card dispatch routine. Right now * it only understands the CL-PD6832. */ static void pcic_pci_attach(pcici_t config_id, int unit) { u_long pcic_type; /* The vendor id of the PCI pcic */ pcic_type = pci_conf_read(config_id, PCI_ID_REG); switch (pcic_type) { case PCI_DEVICE_ID_PCIC_CLPD6832: pd6832_legacy_init(config_id, unit); break; } if (bootverbose) { int i, j; u_char *p; u_long *pl; printf("PCI Config space:\n"); for (j = 0; j < 0x98; j += 16) { printf("%02x: ", j); for (i = 0; i < 16; i += 4) printf(" %08lx", pci_conf_read(config_id, i+j)); printf("\n"); } p = (u_char *)pmap_mapdev(pci_conf_read(config_id, 0x10), 0x1000); pl = (u_long *)p; printf("Cardbus Socket registers:\n"); printf("00: "); for (i = 0; i < 4; i += 1) printf(" %08lx:", pl[i]); printf("\n10: "); for (i = 4; i < 8; i += 1) printf(" %08lx:", pl[i]); printf("\nExCa registers:\n"); for (i = 0; i < 0x40; i += 16) printf("%02x: %16D\n", i, p + 0x800 + i, " "); } }
static int nexus_activate_resource(device_t bus, device_t child, int type, int rid, struct resource *r) { /* * If this is a memory resource, map it into the kernel. */ if (rman_get_bustag(r) == (void*)ARM_BUS_SPACE_MEM) { caddr_t vaddr = 0; u_int32_t paddr; u_int32_t psize; u_int32_t poffs; paddr = rman_get_start(r); psize = rman_get_size(r); poffs = paddr - trunc_page(paddr); vaddr = (caddr_t) pmap_mapdev(paddr-poffs, psize+poffs) + poffs; rman_set_virtual(r, vaddr); rman_set_bushandle(r, (bus_space_handle_t) vaddr); } return (rman_activate_resource(r)); }
static void fsl_ocotp_devmap(void) { phandle_t child, root; u_long base, size; if ((root = OF_finddevice("/")) == 0) goto fatal; if ((child = fdt_depth_search_compatible(root, "fsl,imx6q-ocotp", 0)) == 0) goto fatal; if (fdt_regsize(child, &base, &size) != 0) goto fatal; ocotp_size = (vm_size_t)size; if ((ocotp_regs = pmap_mapdev((vm_offset_t)base, ocotp_size)) == NULL) goto fatal; return; fatal: panic("cannot find/map the ocotp registers"); }
static int grackle_activate_resource(device_t bus, device_t child, int type, int rid, struct resource *res) { struct grackle_softc *sc; void *p; sc = device_get_softc(bus); if (type == SYS_RES_IRQ) { return (bus_activate_resource(bus, type, rid, res)); } if (type == SYS_RES_MEMORY || type == SYS_RES_IOPORT) { vm_offset_t start; start = (vm_offset_t)rman_get_start(res); /* * For i/o-ports, convert the start address to the * MPC106 PCI i/o window */ if (type == SYS_RES_IOPORT) start += sc->sc_iostart; if (bootverbose) printf("grackle mapdev: start %zx, len %ld\n", start, rman_get_size(res)); p = pmap_mapdev(start, (vm_size_t)rman_get_size(res)); if (p == NULL) return (ENOMEM); rman_set_virtual(res, p); rman_set_bustag(res, &bs_le_tag); rman_set_bushandle(res, (u_long)p); } return (rman_activate_resource(res)); }
static int nexus_activate_resource(device_t bus __unused, device_t child __unused, int type, int rid __unused, struct resource *r) { if (type == SYS_RES_MEMORY) { vm_offset_t start; void *p; start = (vm_offset_t) rman_get_start(r); if (bootverbose) printf("nexus mapdev: start %zx, len %ld\n", start, rman_get_size(r)); p = pmap_mapdev(start, (vm_size_t) rman_get_size(r)); if (p == NULL) return (ENOMEM); rman_set_virtual(r, p); rman_set_bustag(r, &bs_be_tag); rman_set_bushandle(r, (u_long)p); } return (rman_activate_resource(r)); }
static int nexus_activate_resource(device_t bus, device_t child, int type, int rid, struct resource *r) { void *vaddr; vm_paddr_t paddr; vm_size_t psize; /* * If this is a memory resource, use pmap_mapdev to map it. */ if (type == SYS_RES_MEMORY) { paddr = rman_get_start(r); psize = rman_get_size(r); vaddr = pmap_mapdev(paddr, psize); rman_set_virtual(r, vaddr); rman_set_bustag(r, mips_bus_space_generic); rman_set_bushandle(r, (bus_space_handle_t)(uintptr_t)vaddr); } return (rman_activate_resource(r)); }
static int nexus_activate_resource(device_t bus, device_t child, int type, int rid, struct resource *r) { /* * If this is a memory resource, map it into the kernel. */ if (rman_get_bustag(r) == I386_BUS_SPACE_MEM) { caddr_t vaddr = 0; if (rman_get_end(r) < 1024 * 1024) { /* * The first 1Mb is mapped at KERNBASE. */ vaddr = (caddr_t)(uintptr_t)(KERNBASE + rman_get_start(r)); } else { u_int32_t paddr; u_int32_t psize; u_int32_t poffs; paddr = rman_get_start(r); psize = rman_get_size(r); poffs = paddr - trunc_page(paddr); vaddr = (caddr_t) pmap_mapdev(paddr-poffs, psize+poffs) + poffs; } rman_set_virtual(r, vaddr); #ifdef PC98 /* PC-98: the type of bus_space_handle_t is the structure. */ r->r_bushandle->bsh_base = (bus_addr_t) vaddr; #else /* IBM-PC: the type of bus_space_handle_t is u_int */ rman_set_bushandle(r, (bus_space_handle_t) vaddr); #endif } return (rman_activate_resource(r)); }
void * AcpiOsMapMemory(ACPI_PHYSICAL_ADDRESS Where, ACPI_SIZE Length) #endif { acpi_memtrack_t track; void *map; map = pmap_mapdev((vm_offset_t)Where, Length); if (map == NULL) return(NULL); else { #if ACPI_DEBUG_MEMMAP for (track = acpi_mapbase; track != NULL; track = track->next) { if (track->base == map) break; } #else track = NULL; #endif if (track == NULL) { track = kmalloc(sizeof(*track), M_ACPICA, M_INTWAIT); track->next = acpi_mapbase; track->base = map; } track->size = Length; #if ACPI_DEBUG_MEMMAP track->freed = 0; track->mapper.func = caller; track->mapper.line = line; track->unmapper.func = ""; track->unmapper.line = 0; #endif acpi_mapbase = track; } return(map); }
static int iobus_activate_resource(device_t bus, device_t child, int type, int rid, struct resource *res) { struct iobus_softc *sc; void *p; sc = device_get_softc(bus); if (type == SYS_RES_IRQ) return (bus_activate_resource(bus, type, rid, res)); if ((type == SYS_RES_MEMORY) || (type == SYS_RES_IOPORT)) { p = pmap_mapdev((vm_offset_t)rman_get_start(res) + sc->sc_addr, (vm_size_t)rman_get_size(res)); if (p == NULL) return (ENOMEM); rman_set_virtual(res, p); rman_set_bustag(res, &bs_le_tag); rman_set_bushandle(res, (u_long)p); } return (rman_activate_resource(res)); }
#define wr32(a, v) writel(a, v) #ifdef writeq #define wr64(a, v) writeq(a, v) #endif #endif /* generic bus_space tag */ bus_space_tag_t mips_bus_space_generic = &generic_space; int generic_bs_map(void *t __unused, bus_addr_t addr, bus_size_t size, int flags __unused, bus_space_handle_t *bshp) { *bshp = (bus_space_handle_t)pmap_mapdev((vm_paddr_t)addr, (vm_size_t)size); return (0); } void generic_bs_unmap(void *t __unused, bus_space_handle_t bh, bus_size_t size) { pmap_unmapdev((vm_offset_t)bh, (vm_size_t)size); } int generic_bs_subregion(void *t __unused, bus_space_handle_t handle, bus_size_t offset, bus_size_t size __unused, bus_space_handle_t *bshp)