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)
