Changes in / [9970a5a:d81eaf94] in mainline


Ignore:
Location:
kernel
Files:
31 edited

Legend:

Unmodified
Added
Removed

  • kernel/arch/arm32/src/arm32.c

    r9970a5a rd81eaf94  
    5757        size_t i;
    5858        for (i = 0; i < init.cnt; i++) {
    59                 init.tasks[i].paddr = KA2PA(bootinfo->tasks[i].addr);
     59                init.tasks[i].addr = (uintptr_t) bootinfo->tasks[i].addr;
    6060                init.tasks[i].size = bootinfo->tasks[i].size;
    6161                str_cpy(init.tasks[i].name, CONFIG_TASK_NAME_BUFLEN,

  • kernel/arch/arm32/src/mach/gta02/gta02.c

    r9970a5a rd81eaf94  
    3838#include <arch/mm/page.h>
    3939#include <mm/page.h>
    40 #include <mm/km.h>
    4140#include <genarch/fb/fb.h>
    4241#include <abi/fb/visuals.h>
    … …  
    102101        s3c24xx_irqc_regs_t *irqc_regs;
    103102
    104         gta02_timer = (void *) km_map(S3C24XX_TIMER_ADDRESS, PAGE_SIZE,
    105             PAGE_NOT_CACHEABLE);
    106         irqc_regs = (void *) km_map(S3C24XX_IRQC_ADDRESS, PAGE_SIZE,
    107             PAGE_NOT_CACHEABLE);
     103        gta02_timer = (void *) hw_map(S3C24XX_TIMER_ADDRESS, PAGE_SIZE);
     104        irqc_regs = (void *) hw_map(S3C24XX_IRQC_ADDRESS, PAGE_SIZE);
    108105
    109106        /* Initialize interrupt controller. */

  • kernel/arch/arm32/src/mach/integratorcp/integratorcp.c

    r9970a5a rd81eaf94  
    4545#include <mm/page.h>
    4646#include <mm/frame.h>
    47 #include <mm/km.h>
    4847#include <arch/mm/frame.h>
    4948#include <arch/mach/integratorcp/integratorcp.h>
    … …  
    129128void icp_init(void)
    130129{
    131         icp_hw_map.uart = km_map(ICP_UART, PAGE_SIZE,
    132             PAGE_WRITE | PAGE_NOT_CACHEABLE);
    133         icp_hw_map.kbd_ctrl = km_map(ICP_KBD, PAGE_SIZE, PAGE_NOT_CACHEABLE);
     130        icp_hw_map.uart = hw_map(ICP_UART, PAGE_SIZE);
     131        icp_hw_map.kbd_ctrl = hw_map(ICP_KBD, PAGE_SIZE);
    134132        icp_hw_map.kbd_stat = icp_hw_map.kbd_ctrl + ICP_KBD_STAT;
    135133        icp_hw_map.kbd_data = icp_hw_map.kbd_ctrl + ICP_KBD_DATA;
    136134        icp_hw_map.kbd_intstat = icp_hw_map.kbd_ctrl + ICP_KBD_INTR_STAT;
    137         icp_hw_map.rtc = km_map(ICP_RTC, PAGE_SIZE,
    138             PAGE_WRITE | PAGE_NOT_CACHEABLE);
     135        icp_hw_map.rtc = hw_map(ICP_RTC, PAGE_SIZE);
    139136        icp_hw_map.rtc1_load = icp_hw_map.rtc + ICP_RTC1_LOAD_OFFSET;
    140137        icp_hw_map.rtc1_read = icp_hw_map.rtc + ICP_RTC1_READ_OFFSET;
    … …  
    144141        icp_hw_map.rtc1_intrstat = icp_hw_map.rtc + ICP_RTC1_INTRSTAT_OFFSET;
    145142
    146         icp_hw_map.irqc = km_map(ICP_IRQC, PAGE_SIZE,
    147             PAGE_WRITE | PAGE_NOT_CACHEABLE);
     143        icp_hw_map.irqc = hw_map(ICP_IRQC, PAGE_SIZE);
    148144        icp_hw_map.irqc_mask = icp_hw_map.irqc + ICP_IRQC_MASK_OFFSET;
    149145        icp_hw_map.irqc_unmask = icp_hw_map.irqc + ICP_IRQC_UNMASK_OFFSET;
    150         icp_hw_map.cmcr = km_map(ICP_CMCR, PAGE_SIZE,
    151             PAGE_WRITE | PAGE_NOT_CACHEABLE);
     146        icp_hw_map.cmcr = hw_map(ICP_CMCR, PAGE_SIZE);
    152147        icp_hw_map.sdramcr = icp_hw_map.cmcr + ICP_SDRAMCR_OFFSET;
    153         icp_hw_map.vga = km_map(ICP_VGA, PAGE_SIZE,
    154             PAGE_WRITE | PAGE_NOT_CACHEABLE);
     148        icp_hw_map.vga = hw_map(ICP_VGA, PAGE_SIZE);
    155149
    156150        hw_map_init_called = true;

  • kernel/arch/arm32/src/mach/testarm/testarm.c

    r9970a5a rd81eaf94  
    3737#include <arch/mach/testarm/testarm.h>
    3838#include <mm/page.h>
    39 #include <mm/km.h>
    4039#include <genarch/fb/fb.h>
    4140#include <abi/fb/visuals.h>
    … …  
    7271void gxemul_init(void)
    7372{
    74         gxemul_kbd = (void *) km_map(GXEMUL_KBD_ADDRESS, PAGE_SIZE,
    75             PAGE_WRITE | PAGE_NOT_CACHEABLE);
    76         gxemul_rtc = (void *) km_map(GXEMUL_RTC_ADDRESS, PAGE_SIZE,
    77             PAGE_WRITE | PAGE_NOT_CACHEABLE);
    78         gxemul_irqc = (void *) km_map(GXEMUL_IRQC_ADDRESS, PAGE_SIZE,
    79             PAGE_WRITE | PAGE_NOT_CACHEABLE);
     73        gxemul_kbd = (void *) hw_map(GXEMUL_KBD_ADDRESS, PAGE_SIZE);
     74        gxemul_rtc = (void *) hw_map(GXEMUL_RTC_ADDRESS, PAGE_SIZE);
     75        gxemul_irqc = (void *) hw_map(GXEMUL_IRQC_ADDRESS, PAGE_SIZE);
    8076}
    8177

  • kernel/arch/ia32/src/smp/smp.c

    r9970a5a rd81eaf94  
    4747#include <debug.h>
    4848#include <arch/asm.h>
     49#include <mm/frame.h>
    4950#include <mm/page.h>
    50 #include <mm/frame.h>
    51 #include <mm/km.h>
    5251#include <mm/slab.h>
    5352#include <mm/as.h>
    … …  
    7372       
    7473        if (config.cpu_count > 1) {
    75                 l_apic = (uint32_t *) km_map((uintptr_t) l_apic, PAGE_SIZE,
    76                     PAGE_WRITE | PAGE_NOT_CACHEABLE);
    77                 io_apic = (uint32_t *) km_map((uintptr_t) io_apic, PAGE_SIZE,
    78                     PAGE_WRITE | PAGE_NOT_CACHEABLE);
     74                l_apic = (uint32_t *) hw_map((uintptr_t) l_apic, PAGE_SIZE);
     75                io_apic = (uint32_t *) hw_map((uintptr_t) io_apic, PAGE_SIZE);
    7976        }
    8077}

  • kernel/arch/ia64/src/ia64.c

    r9970a5a rd81eaf94  
    5353#include <genarch/srln/srln.h>
    5454#include <mm/page.h>
    55 #include <mm/km.h>
    5655
    5756#ifdef MACHINE_ski
    … …  
    7069void arch_pre_main(void)
    7170{
    72         init.cnt = min3(bootinfo->taskmap.cnt, TASKMAP_MAX_RECORDS,
    73             CONFIG_INIT_TASKS);
     71        init.cnt = min3(bootinfo->taskmap.cnt, TASKMAP_MAX_RECORDS, CONFIG_INIT_TASKS);
    7472        size_t i;
    75 
    7673        for (i = 0; i < init.cnt; i++) {
    77                 init.tasks[i].paddr =
    78                     (uintptr_t) bootinfo->taskmap.tasks[i].addr;
     74                init.tasks[i].addr =
     75                    ((unsigned long) bootinfo->taskmap.tasks[i].addr) |
     76                    VRN_MASK;
    7977                init.tasks[i].size = bootinfo->taskmap.tasks[i].size;
    8078                str_cpy(init.tasks[i].name, CONFIG_TASK_NAME_BUFLEN,
    … …  
    8987static void iosapic_init(void)
    9088{
    91         uintptr_t IOSAPIC = km_map(iosapic_base, PAGE_SIZE,
    92             PAGE_WRITE | PAGE_NOT_CACHEABLE);
     89        uintptr_t IOSAPIC = hw_map(iosapic_base, PAGE_SIZE);
    9390        int i;
    9491       
    … …  
    118115        if (config.cpu_active == 1) {
    119116                /* Map the page with legacy I/O. */
    120                 legacyio_virt_base = km_map(LEGACYIO_PHYS_BASE, LEGACYIO_SIZE,
    121                     PAGE_WRITE | PAGE_NOT_CACHEABLE);
     117                legacyio_virt_base = hw_map(LEGACYIO_PHYS_BASE, LEGACYIO_SIZE);
    122118
    123119                iosapic_init();

  • kernel/arch/mips32/src/mips32.c

    r9970a5a rd81eaf94  
    7878        size_t i;
    7979        for (i = 0; i < init.cnt; i++) {
    80                 init.tasks[i].paddr = KA2PA(bootinfo->tasks[i].addr);
     80                init.tasks[i].addr = (uintptr_t) bootinfo->tasks[i].addr;
    8181                init.tasks[i].size = bootinfo->tasks[i].size;
    8282                str_cpy(init.tasks[i].name, CONFIG_TASK_NAME_BUFLEN,

  • kernel/arch/mips32/src/mm/frame.c

    r9970a5a rd81eaf94  
    123123        for (i = 0; i < init.cnt; i++)
    124124                if (overlaps(frame << ZERO_PAGE_WIDTH, ZERO_PAGE_SIZE,
    125                     init.tasks[i].paddr, init.tasks[i].size)) {
     125                    KA2PA(init.tasks[i].addr), init.tasks[i].size)) {
    126126                        safe = false;
    127127                        break;

  • kernel/arch/mips64/src/mips64.c

    r9970a5a rd81eaf94  
    7878        size_t i;
    7979        for (i = 0; i < init.cnt; i++) {
    80                 init.tasks[i].paddr = KA2PA(bootinfo->tasks[i].addr);
     80                init.tasks[i].addr = (uintptr_t) bootinfo->tasks[i].addr;
    8181                init.tasks[i].size = bootinfo->tasks[i].size;
    8282                str_cpy(init.tasks[i].name, CONFIG_TASK_NAME_BUFLEN,

  • kernel/arch/mips64/src/mm/frame.c

    r9970a5a rd81eaf94  
    115115        for (i = 0; i < init.cnt; i++)
    116116                if (overlaps(frame << ZERO_PAGE_WIDTH, ZERO_PAGE_SIZE,
    117                     init.tasks[i].paddr, init.tasks[i].size)) {
     117                    KA2PA(init.tasks[i].addr), init.tasks[i].size)) {
    118118                        safe = false;
    119119                        break;

  • kernel/arch/ppc32/src/drivers/pic.c

    r9970a5a rd81eaf94  
    3434
    3535#include <arch/drivers/pic.h>
    36 #include <mm/km.h>
     36#include <mm/page.h>
    3737#include <byteorder.h>
    3838#include <bitops.h>
    … …  
    4242void pic_init(uintptr_t base, size_t size, cir_t *cir, void **cir_arg)
    4343{
    44         pic = (uint32_t *) km_map(base, size, PAGE_WRITE | PAGE_NOT_CACHEABLE);
     44        pic = (uint32_t *) hw_map(base, size);
    4545        *cir = pic_ack_interrupt;
    4646        *cir_arg = NULL;

  • kernel/arch/ppc32/src/ppc32.c

    r9970a5a rd81eaf94  
    4646#include <userspace.h>
    4747#include <mm/page.h>
    48 #include <mm/km.h>
    4948#include <abi/proc/uarg.h>
    5049#include <console/console.h>
    … …  
    7271        size_t i;
    7372        for (i = 0; i < init.cnt; i++) {
    74                 init.tasks[i].paddr = KA2PA(bootinfo->taskmap.tasks[i].addr);
     73                init.tasks[i].addr = (uintptr_t) bootinfo->taskmap.tasks[i].addr;
    7574                init.tasks[i].size = bootinfo->taskmap.tasks[i].size;
    7675                str_cpy(init.tasks[i].name, CONFIG_TASK_NAME_BUFLEN,
    … …  
    209208                size_t size = 2 * PAGE_SIZE;
    210209               
    211                 cuda_t *cuda = (cuda_t *) (km_map(aligned_addr, offset + size,
    212                     PAGE_WRITE | PAGE_NOT_CACHEABLE) + offset);
     210                cuda_t *cuda = (cuda_t *)
     211                    (hw_map(aligned_addr, offset + size) + offset);
    213212               
    214213                /* Initialize I/O controller */

  • kernel/arch/sparc64/src/drivers/kbd.c

    r9970a5a rd81eaf94  
    4040#include <mm/page.h>
    4141#include <arch/mm/page.h>
    42 #include <mm/km.h>
    4342#include <typedefs.h>
    4443#include <align.h>
    … …  
    114113        size_t offset = pa - aligned_addr;
    115114       
    116         ns16550_t *ns16550 = (ns16550_t *) (km_map(aligned_addr, offset + size,
    117             PAGE_WRITE | PAGE_NOT_CACHEABLE) + offset);
     115        ns16550_t *ns16550 = (ns16550_t *)
     116           (hw_map(aligned_addr, offset + size) + offset);
    118117       
    119118        ns16550_instance_t *ns16550_instance = ns16550_init(ns16550, inr, cir, cir_arg);

  • kernel/arch/sparc64/src/drivers/pci.c

    r9970a5a rd81eaf94  
    3939#include <genarch/ofw/upa.h>
    4040#include <arch/trap/interrupt.h>
    41 #include <mm/km.h>
     41#include <mm/page.h>
    4242#include <mm/slab.h>
    4343#include <typedefs.h>
    … …  
    109109        pci->model = PCI_SABRE;
    110110        pci->op = &pci_sabre_ops;
    111         pci->reg = (uint64_t *) km_map(paddr, reg[SABRE_INTERNAL_REG].size,
    112             PAGE_WRITE | PAGE_NOT_CACHEABLE);
     111        pci->reg = (uint64_t *) hw_map(paddr, reg[SABRE_INTERNAL_REG].size);
    113112
    114113        /*
    … …  
    157156        pci->model = PCI_PSYCHO;
    158157        pci->op = &pci_psycho_ops;
    159         pci->reg = (uint64_t *) km_map(paddr, reg[PSYCHO_INTERNAL_REG].size,
    160             PAGE_WRITE | PAGE_NOT_CACHEABLE);
     158        pci->reg = (uint64_t *) hw_map(paddr, reg[PSYCHO_INTERNAL_REG].size);
    161159
    162160        /*

  • kernel/arch/sparc64/src/sun4u/sparc64.c

    r9970a5a rd81eaf94  
    6262        size_t i;
    6363        for (i = 0; i < init.cnt; i++) {
    64                 init.tasks[i].paddr = KA2PA(bootinfo->taskmap.tasks[i].addr);
     64                init.tasks[i].addr = (uintptr_t) bootinfo->taskmap.tasks[i].addr;
    6565                init.tasks[i].size = bootinfo->taskmap.tasks[i].size;
    6666                str_cpy(init.tasks[i].name, CONFIG_TASK_NAME_BUFLEN,

  • kernel/arch/sparc64/src/sun4v/sparc64.c

    r9970a5a rd81eaf94  
    6464        size_t i;
    6565        for (i = 0; i < init.cnt; i++) {
    66                 init.tasks[i].paddr = KA2PA(bootinfo->taskmap.tasks[i].addr);
     66                init.tasks[i].addr = (uintptr_t) bootinfo->taskmap.tasks[i].addr;
    6767                init.tasks[i].size = bootinfo->taskmap.tasks[i].size;
    6868                str_cpy(init.tasks[i].name, CONFIG_TASK_NAME_BUFLEN,

  • kernel/genarch/src/drivers/ega/ega.c

    r9970a5a rd81eaf94  
    3737#include <genarch/drivers/ega/ega.h>
    3838#include <putchar.h>
    39 #include <mm/km.h>
     39#include <mm/page.h>
    4040#include <mm/as.h>
    4141#include <mm/slab.h>
     42#include <arch/mm/page.h>
    4243#include <typedefs.h>
    4344#include <arch/asm.h>
    … …  
    597598       
    598599        instance->base = base;
    599         instance->addr = (uint8_t *) km_map(addr, EGA_VRAM_SIZE,
    600             PAGE_WRITE | PAGE_NOT_CACHEABLE);
     600        instance->addr = (uint8_t *) hw_map(addr, EGA_VRAM_SIZE);
    601601        if (!instance->addr) {
    602602                LOG("Unable to EGA video memory.");

  • kernel/genarch/src/drivers/s3c24xx_uart/s3c24xx_uart.c

    r9970a5a rd81eaf94  
    4545#include <mm/slab.h>
    4646#include <mm/page.h>
    47 #include <mm/km.h>
    4847#include <sysinfo/sysinfo.h>
    4948#include <str.h>
    … …  
    114113        uart_dev->data = uart;
    115114
    116         uart->io = (s3c24xx_uart_io_t *) km_map(paddr, PAGE_SIZE,
    117             PAGE_WRITE | PAGE_NOT_CACHEABLE);
     115        uart->io = (s3c24xx_uart_io_t *) hw_map(paddr, PAGE_SIZE);
    118116        uart->indev = NULL;
    119117

  • kernel/genarch/src/fb/fb.c

    r9970a5a rd81eaf94  
    4040#include <console/console.h>
    4141#include <sysinfo/sysinfo.h>
    42 #include <mm/km.h>
     42#include <mm/page.h>
    4343#include <mm/slab.h>
    4444#include <align.h>
    … …  
    587587        size_t glyphsize = FONT_GLYPHS * instance->glyphbytes;
    588588       
    589         instance->addr = (uint8_t *) km_map((uintptr_t) props->addr, fbsize,
    590             PAGE_WRITE | PAGE_NOT_CACHEABLE);
     589        instance->addr = (uint8_t *) hw_map((uintptr_t) props->addr, fbsize);
    591590        if (!instance->addr) {
    592591                LOG("Unable to map framebuffer.");

  • kernel/genarch/src/multiboot/multiboot.c

    r9970a5a rd81eaf94  
    7777                        break;
    7878               
    79                 init.tasks[init.cnt].paddr = mods[i].start;
     79                init.tasks[init.cnt].addr = PA2KA(mods[i].start);
    8080                init.tasks[init.cnt].size = mods[i].end - mods[i].start;
    8181               

  • kernel/genarch/src/multiboot/multiboot2.c

    r9970a5a rd81eaf94  
    4545{
    4646        if (init.cnt < CONFIG_INIT_TASKS) {
    47                 init.tasks[init.cnt].paddr = module->start;
     47                init.tasks[init.cnt].addr = PA2KA(module->start);
    4848                init.tasks[init.cnt].size = module->end - module->start;
    4949                multiboot_extract_command(init.tasks[init.cnt].name,

  • kernel/generic/include/config.h

    r9970a5a rd81eaf94  
    5353
    5454typedef struct {
    55         uintptr_t paddr;
     55        uintptr_t addr;
    5656        size_t size;
    5757        char name[CONFIG_TASK_NAME_BUFLEN];

  • kernel/generic/include/mm/km.h

    r9970a5a rd81eaf94  
    4949extern bool km_is_non_identity(uintptr_t);
    5050
    51 extern uintptr_t km_map(uintptr_t, size_t, unsigned int);
    52 
    5351extern uintptr_t km_temporary_page_get(uintptr_t *, frame_flags_t);
    5452extern void km_temporary_page_put(uintptr_t);

  • kernel/generic/include/mm/page.h

    r9970a5a rd81eaf94  
    6666extern void map_structure(uintptr_t, size_t);
    6767
     68extern uintptr_t hw_map(uintptr_t, size_t);
     69
    6870extern int page_find_mapping(uintptr_t, void **);
    6971extern sysarg_t sys_page_find_mapping(uintptr_t, void *);

  • kernel/generic/src/lib/rd.c

    r9970a5a rd81eaf94  
    5454void init_rd(void *data, size_t size)
    5555{
    56         uintptr_t base = (uintptr_t) data;
     56        uintptr_t base = KA2PA((uintptr_t) data);
    5757        ASSERT((base % FRAME_SIZE) == 0);
    5858       

  • kernel/generic/src/main/kinit.c

    r9970a5a rd81eaf94  
    5757#include <mm/as.h>
    5858#include <mm/frame.h>
    59 #include <mm/km.h>
    6059#include <print.h>
    6160#include <memstr.h>
    … …  
    6968#include <str.h>
    7069#include <sysinfo/stats.h>
    71 #include <align.h>
    7270
    7371#ifdef CONFIG_SMP
    … …  
    180178       
    181179        for (i = 0; i < init.cnt; i++) {
    182                 if (init.tasks[i].paddr % FRAME_SIZE) {
     180                if (init.tasks[i].addr % FRAME_SIZE) {
    183181                        printf("init[%zu]: Address is not frame aligned\n", i);
    184182                        programs[i].task = NULL;
    … …  
    201199                str_cpy(namebuf + INIT_PREFIX_LEN,
    202200                    TASK_NAME_BUFLEN - INIT_PREFIX_LEN, name);
    203 
    204                 /*
    205                  * Create virtual memory mappings for init task images.
    206                  */
    207                 uintptr_t page = km_map(init.tasks[i].paddr,
    208                     init.tasks[i].size,
    209                     PAGE_READ | PAGE_WRITE | PAGE_CACHEABLE);
    210                 ASSERT(page);
    211                
    212                 int rc = program_create_from_image((void *) page, namebuf,
    213                     &programs[i]);
     201               
     202                int rc = program_create_from_image((void *) init.tasks[i].addr,
     203                    namebuf, &programs[i]);
    214204               
    215205                if (rc == 0) {
    … …  
    234224                         * Assume the last task is the RAM disk.
    235225                         */
    236                         init_rd((void *) init.tasks[i].paddr, init.tasks[i].size);
     226                        init_rd((void *) init.tasks[i].addr, init.tasks[i].size);
    237227                } else
    238228                        printf("init[%zu]: Init binary load failed (error %d)\n", i, rc);

  • kernel/generic/src/main/main.c

    r9970a5a rd81eaf94  
    151151        size_t i;
    152152        for (i = 0; i < init.cnt; i++) {
    153                 if (overlaps(KA2PA(config.stack_base), config.stack_size,
    154                     init.tasks[i].paddr, init.tasks[i].size)) {
    155                         /*
    156                          * The init task overlaps with the memory behind the
    157                          * kernel image so it must be in low memory and we can
    158                          * use PA2KA on the init task's physical address.
    159                          */
    160                         config.stack_base = ALIGN_UP(
    161                             PA2KA(init.tasks[i].paddr) + init.tasks[i].size,
    162                             config.stack_size);
    163                 }
     153                if (PA_OVERLAPS(config.stack_base, config.stack_size,
     154                    init.tasks[i].addr, init.tasks[i].size))
     155                        config.stack_base = ALIGN_UP(init.tasks[i].addr +
     156                            init.tasks[i].size, config.stack_size);
    164157        }
    165158       

  • kernel/generic/src/mm/backend_elf.c

    r9970a5a rd81eaf94  
    318318                        dirty = true;
    319319                } else {
    320                         pte_t *pte = page_mapping_find(AS_KERNEL,
    321                             base + i * FRAME_SIZE, true);
    322 
    323                         ASSERT(pte);
    324                         ASSERT(PTE_PRESENT(pte));
    325 
    326                         frame = PTE_GET_FRAME(pte);
     320                        frame = KA2PA(base + i * FRAME_SIZE);
    327321                }       
    328322        } else if (upage >= start_anon) {

  • kernel/generic/src/mm/frame.c

    r9970a5a rd81eaf94  
    924924                                for (i = 0; i < init.cnt; i++)
    925925                                        if (overlaps(addr, PFN2ADDR(confcount),
    926                                             init.tasks[i].paddr,
     926                                            KA2PA(init.tasks[i].addr),
    927927                                            init.tasks[i].size)) {
    928928                                                overlap = true;
    … …  
    12511251                size_t i;
    12521252                for (i = 0; i < init.cnt; i++) {
    1253                         pfn_t pfn = ADDR2PFN(init.tasks[i].paddr);
     1253                        pfn_t pfn = ADDR2PFN(KA2PA(init.tasks[i].addr));
    12541254                        frame_mark_unavailable(pfn,
    12551255                            SIZE2FRAMES(init.tasks[i].size));

  • kernel/generic/src/mm/km.c

    r9970a5a rd81eaf94  
    4646#include <debug.h>
    4747#include <arch.h>
    48 #include <align.h>
    49 #include <macros.h>
    50 #include <bitops.h>
    5148
    5249static ra_arena_t *km_ni_arena;
    … …  
    123120        ra_free(km_ni_arena, page, size);
    124121}
    125 
    126 uintptr_t km_map(uintptr_t paddr, size_t size, unsigned int flags)
    127 {
    128         uintptr_t vaddr;
    129         size_t asize;
    130         size_t align;
    131         uintptr_t offs;
    132 
    133         asize = ALIGN_UP(size, PAGE_SIZE);
    134         align = ispwr2(size) ? size : (1U << (fnzb(size) + 1));
    135         vaddr = km_page_alloc(asize, max(PAGE_SIZE, align));
    136 
    137         page_table_lock(AS_KERNEL, true);
    138         for (offs = 0; offs < asize; offs += PAGE_SIZE) {
    139                 page_mapping_insert(AS_KERNEL, vaddr + offs, paddr + offs,
    140                     flags);
    141         }
    142         page_table_unlock(AS_KERNEL, true);
    143        
    144         return vaddr;
    145 }
    146 
    147122
    148123/** Unmap kernen non-identity page.
    … …  
    190165            FRAME_HIGHMEM | FRAME_ATOMIC | flags);
    191166        if (frame) {
    192                 page = km_map(frame, PAGE_SIZE,
    193                     PAGE_READ | PAGE_WRITE | PAGE_CACHEABLE);
     167                page = km_page_alloc(PAGE_SIZE, PAGE_SIZE);
    194168                ASSERT(page);   // FIXME
     169                page_table_lock(AS_KERNEL, true);
     170                page_mapping_insert(AS_KERNEL, page, frame,
     171                    PAGE_CACHEABLE | PAGE_READ | PAGE_WRITE);
     172                page_table_unlock(AS_KERNEL, true);
    195173        } else {
    196174                frame = (uintptr_t) frame_alloc_noreserve(ONE_FRAME,

  • kernel/generic/src/mm/page.c

    r9970a5a rd81eaf94  
    6565#include <arch/mm/asid.h>
    6666#include <mm/as.h>
     67#include <mm/km.h>
    6768#include <mm/frame.h>
    6869#include <arch/barrier.h>
    … …  
    7576#include <errno.h>
    7677#include <align.h>
     78#include <macros.h>
     79#include <bitops.h>
    7780
    7881/** Virtual operations for page subsystem. */
    … …  
    190193}
    191194
     195uintptr_t hw_map(uintptr_t physaddr, size_t size)
     196{
     197        uintptr_t virtaddr;
     198        size_t asize;
     199        size_t align;
     200        pfn_t i;
     201
     202        asize = ALIGN_UP(size, PAGE_SIZE);
     203        align = ispwr2(size) ? size : (1U << (fnzb(size) + 1));
     204        virtaddr = km_page_alloc(asize, max(PAGE_SIZE, align));
     205
     206        page_table_lock(AS_KERNEL, true);
     207        for (i = 0; i < ADDR2PFN(asize); i++) {
     208                uintptr_t addr = PFN2ADDR(i);
     209                page_mapping_insert(AS_KERNEL, virtaddr + addr, physaddr + addr,
     210                    PAGE_NOT_CACHEABLE | PAGE_WRITE);
     211        }
     212        page_table_unlock(AS_KERNEL, true);
     213       
     214        return virtaddr;
     215}
     216
    192217int page_find_mapping(uintptr_t virt, void **phys)
    193218{
Note: See TracChangeset for help on using the changeset viewer.