Changeset 00aece0 in mainline for kernel/arch


Ignore:
Timestamp:
2012-02-18T16:47:38Z (14 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
4449c6c
Parents:
bd5f3b7 (diff), f943dd3 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes.

Location:
kernel/arch
Files:
24 added
1 deleted
82 edited
2 moved

Legend:

Unmodified
Added
Removed

  • kernel/arch/abs32le/Makefile.inc

    rbd5f3b7 r00aece0  
    5757        arch/$(KARCH)/src/smp/smp.c \
    5858        arch/$(KARCH)/src/smp/ipi.c \
     59        arch/$(KARCH)/src/mm/km.c \
    5960        arch/$(KARCH)/src/mm/as.c \
    6061        arch/$(KARCH)/src/mm/frame.c \

  • kernel/arch/abs32le/include/mm/frame.h

    rbd5f3b7 r00aece0  
    4141#include <typedefs.h>
    4242
    43 extern void frame_arch_init(void);
     43extern void frame_low_arch_init(void);
     44extern void frame_high_arch_init(void);
    4445extern void physmem_print(void);
    4546

  • kernel/arch/abs32le/src/abs32le.c

    rbd5f3b7 r00aece0  
    4949#include <syscall/syscall.h>
    5050#include <console/console.h>
    51 #include <sysinfo/sysinfo.h>
    5251#include <memstr.h>
    5352
    … …  
    8685}
    8786
    88 sysarg_t sys_tls_set(sysarg_t addr)
     87sysarg_t sys_tls_set(uintptr_t addr)
    8988{
    9089        return EOK;

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

    rbd5f3b7 r00aece0  
    5050
    5151
    52 void frame_arch_init(void)
     52void frame_low_arch_init(void)
     53{
     54}
     55
     56void frame_high_arch_init(void)
    5357{
    5458}

  • kernel/arch/abs32le/src/mm/page.c

    rbd5f3b7 r00aece0  
    5656}
    5757
    58 
    59 uintptr_t hw_map(uintptr_t physaddr, size_t size)
    60 {
    61         return physaddr;
    62 }
    63 
    6458void page_fault(unsigned int n __attribute__((unused)), istate_t *istate)
    6559{

  • kernel/arch/amd64/Makefile.inc

    rbd5f3b7 r00aece0  
    7272ARCH_SOURCES = \
    7373        arch/$(KARCH)/src/fpu_context.c \
    74         arch/$(KARCH)/src/boot/boot.S \
     74        arch/$(KARCH)/src/boot/multiboot.S \
     75        arch/$(KARCH)/src/boot/multiboot2.S \
    7576        arch/$(KARCH)/src/boot/memmap.c \
    7677        arch/$(KARCH)/src/debug/stacktrace.c \
    … …  
    7980        arch/$(KARCH)/src/context.S \
    8081        arch/$(KARCH)/src/ddi/ddi.c \
    81         arch/$(KARCH)/src/drivers/vesa.c \
    8282        arch/$(KARCH)/src/drivers/i8254.c \
    8383        arch/$(KARCH)/src/drivers/i8259.c \
    … …  
    8686        arch/$(KARCH)/src/bios/bios.c \
    8787        arch/$(KARCH)/src/interrupt.c \
     88        arch/$(KARCH)/src/mm/km.c \
    8889        arch/$(KARCH)/src/mm/as.c \
    8990        arch/$(KARCH)/src/mm/frame.c \

  • kernel/arch/amd64/include/arch.h

    rbd5f3b7 r00aece0  
    3838#include <genarch/multiboot/multiboot.h>
    3939
    40 extern void arch_pre_main(uint32_t, const multiboot_info_t *);
     40extern void arch_pre_main(uint32_t, void *);
    4141
    4242#endif

  • kernel/arch/amd64/include/boot/boot.h

    rbd5f3b7 r00aece0  
    4040#define BOOT_STACK_SIZE  0x000400
    4141
    42 #define MULTIBOOT_HEADER_MAGIC  0x1BADB002
    43 #define MULTIBOOT_HEADER_FLAGS  0x00010003
    44 
    4542#ifndef __ASM__
    4643

  • kernel/arch/amd64/include/interrupt.h

    rbd5f3b7 r00aece0  
    5555#define IRQ_PIC_SPUR  7
    5656#define IRQ_MOUSE     12
    57 #define IRQ_NE2000    9
    5857
    5958/* This one must have four least significant bits set to ones */

  • kernel/arch/amd64/include/mm/frame.h

    rbd5f3b7 r00aece0  
    4343#include <typedefs.h>
    4444
    45 extern uintptr_t last_frame;
    46 extern void frame_arch_init(void);
     45extern void frame_low_arch_init(void);
     46extern void frame_high_arch_init(void);
    4747extern void physmem_print(void);
    4848

  • kernel/arch/amd64/src/amd64.c

    rbd5f3b7 r00aece0  
    3434
    3535#include <arch.h>
    36 
    3736#include <typedefs.h>
    38 
    39 #include <config.h>
    40 
    41 #include <proc/thread.h>
    42 #include <genarch/multiboot/multiboot.h>
    43 #include <genarch/drivers/legacy/ia32/io.h>
    44 #include <genarch/drivers/ega/ega.h>
    45 #include <arch/drivers/vesa.h>
    46 #include <genarch/drivers/i8042/i8042.h>
    47 #include <genarch/kbrd/kbrd.h>
     37#include <errno.h>
     38#include <memstr.h>
     39#include <interrupt.h>
     40#include <console/console.h>
     41#include <syscall/syscall.h>
     42#include <sysinfo/sysinfo.h>
     43#include <arch/bios/bios.h>
     44#include <arch/boot/boot.h>
     45#include <arch/debugger.h>
    4846#include <arch/drivers/i8254.h>
    4947#include <arch/drivers/i8259.h>
    50 #include <arch/boot/boot.h>
     48#include <arch/syscall.h>
     49#include <genarch/acpi/acpi.h>
     50#include <genarch/drivers/ega/ega.h>
     51#include <genarch/drivers/i8042/i8042.h>
     52#include <genarch/drivers/legacy/ia32/io.h>
     53#include <genarch/fb/bfb.h>
     54#include <genarch/kbrd/kbrd.h>
     55#include <genarch/multiboot/multiboot.h>
     56#include <genarch/multiboot/multiboot2.h>
    5157
    5258#ifdef CONFIG_SMP
    5359#include <arch/smp/apic.h>
    5460#endif
    55 
    56 #include <arch/bios/bios.h>
    57 #include <arch/cpu.h>
    58 #include <print.h>
    59 #include <arch/cpuid.h>
    60 #include <genarch/acpi/acpi.h>
    61 #include <panic.h>
    62 #include <interrupt.h>
    63 #include <arch/syscall.h>
    64 #include <arch/debugger.h>
    65 #include <syscall/syscall.h>
    66 #include <console/console.h>
    67 #include <ddi/irq.h>
    68 #include <sysinfo/sysinfo.h>
    69 #include <memstr.h>
    7061
    7162/** Disable I/O on non-privileged levels
    … …  
    10192/** Perform amd64-specific initialization before main_bsp() is called.
    10293 *
    103  * @param signature Should contain the multiboot signature.
    104  * @param mi        Pointer to the multiboot information structure.
    105  */
    106 void arch_pre_main(uint32_t signature, const multiboot_info_t *mi)
     94 * @param signature Multiboot signature.
     95 * @param info      Multiboot information structure.
     96 *
     97 */
     98void arch_pre_main(uint32_t signature, void *info)
    10799{
    108100        /* Parse multiboot information obtained from the bootloader. */
    109         multiboot_info_parse(signature, mi);
     101        multiboot_info_parse(signature, (multiboot_info_t *) info);
     102        multiboot2_info_parse(signature, (multiboot2_info_t *) info);
    110103       
    111104#ifdef CONFIG_SMP
    … …  
    153146               
    154147#if (defined(CONFIG_FB) || defined(CONFIG_EGA))
    155                 bool vesa = false;
     148                bool bfb = false;
    156149#endif
    157150               
    158151#ifdef CONFIG_FB
    159                 vesa = vesa_init();
     152                bfb = bfb_init();
    160153#endif
    161154               
    162155#ifdef CONFIG_EGA
    163                 if (!vesa) {
     156                if (!bfb) {
    164157                        outdev_t *egadev = ega_init(EGA_BASE, EGA_VIDEORAM);
    165158                        if (egadev)
    … …  
    221214                }
    222215        }
    223        
    224         /*
    225          * This is the necessary evil until the userspace driver is entirely
    226          * self-sufficient.
    227          */
    228         sysinfo_set_item_val("i8042", NULL, true);
    229         sysinfo_set_item_val("i8042.inr_a", NULL, IRQ_KBD);
    230         sysinfo_set_item_val("i8042.inr_b", NULL, IRQ_MOUSE);
    231         sysinfo_set_item_val("i8042.address.physical", NULL,
    232             (uintptr_t) I8042_BASE);
    233         sysinfo_set_item_val("i8042.address.kernel", NULL,
    234             (uintptr_t) I8042_BASE);
    235216#endif
    236217       
    237218        if (irqs_info != NULL)
    238219                sysinfo_set_item_val(irqs_info, NULL, true);
    239        
    240         sysinfo_set_item_val("netif.ne2000.inr", NULL, IRQ_NE2000);
    241220}
    242221
    … …  
    261240 * we need not to go to CPL0 to read it.
    262241 */
    263 sysarg_t sys_tls_set(sysarg_t addr)
     242sysarg_t sys_tls_set(uintptr_t addr)
    264243{
    265244        THREAD->arch.tls = addr;
    266245        write_msr(AMD_MSR_FS, addr);
    267246       
    268         return 0;
     247        return EOK;
    269248}
    270249

  • kernel/arch/amd64/src/boot/memmap.c

    rbd5f3b7 r00aece0  
    3535#include <arch/boot/memmap.h>
    3636
    37 uint8_t e820counter = 0xffU;
     37uint8_t e820counter = 0;
    3838e820memmap_t e820table[MEMMAP_E820_MAX_RECORDS];
    3939

  • kernel/arch/amd64/src/boot/multiboot.S

    rbd5f3b7 r00aece0  
    3030
    3131#include <arch/boot/boot.h>
    32 #include <arch/boot/memmap.h>
    3332#include <arch/mm/page.h>
    3433#include <arch/mm/ptl.h>
    3534#include <arch/pm.h>
     35#include <genarch/multiboot/multiboot.h>
     36#include <arch/cpuid.h>
    3637#include <arch/cpu.h>
    37 #include <arch/cpuid.h>
    3838
    3939#define START_STACK  (BOOT_OFFSET - BOOT_STACK_SIZE)
    … …  
    101101        multiboot_meeting_point:
    102102       
    103         /* Save GRUB arguments */
    104         movl %eax, grub_eax
    105         movl %ebx, grub_ebx
     103        /*
     104         * Protected 32-bit. We want to reuse the code-seg descriptor,
     105         * the Default operand size must not be 1 when entering long mode.
     106         */
     107       
     108        /* Save multiboot arguments */
     109        movl %eax, multiboot_eax
     110        movl %ebx, multiboot_ebx
    106111       
    107112        pm_status $status_prot
    … …  
    149154       
    150155#include "vesa_prot.inc"
    151        
    152         /*
    153          * Protected 32-bit. We want to reuse the code-seg descriptor,
    154          * the Default operand size must not be 1 when entering long mode.
    155          */
    156156       
    157157        pm2_status $status_prot2
    … …  
    422422        long_status $status_long
    423423       
    424         /* Call arch_pre_main(grub_eax, grub_ebx) */
     424        /* Call arch_pre_main(multiboot_eax, multiboot_ebx) */
    425425        xorq %rdi, %rdi
    426         movl grub_eax, %edi
     426        movl multiboot_eax, %edi
    427427        xorq %rsi, %rsi
    428         movl grub_ebx, %esi
     428        movl multiboot_ebx, %esi
    429429       
    430430        movabsq $arch_pre_main, %rax
    … …  
    645645.section K_DATA_START, "aw", @progbits
    646646
     647.global bootstrap_gdtr
    647648bootstrap_gdtr:
    648649        .word GDT_SELECTOR(GDT_ITEMS)
    649650        .long KA2PA(gdt)
    650651
    651 grub_eax:
     652.global multiboot_eax
     653multiboot_eax:
    652654        .long 0
    653655
    654 grub_ebx:
     656.global multiboot_ebx
     657multiboot_ebx:
    655658        .long 0
    656659
    … …  
    670673status_vesa_copy:
    671674        .asciz "[vesa_copy] "
    672 status_grub_cmdline:
    673         .asciz "[grub_cmdline] "
     675status_multiboot_cmdline:
     676        .asciz "[multiboot_cmdline] "
    674677status_vesa_real:
    675678        .asciz "[vesa_real] "

  • kernel/arch/amd64/src/mm/page.c

    rbd5f3b7 r00aece0  
    4646#include <panic.h>
    4747#include <align.h>
     48#include <macros.h>
    4849
    4950void page_arch_init(void)
    5051{
    51         if (config.cpu_active == 1) {
    52                 uintptr_t cur;
    53                 unsigned int identity_flags =
    54                     PAGE_CACHEABLE | PAGE_EXEC | PAGE_GLOBAL | PAGE_WRITE;
     52        if (config.cpu_active > 1) {
     53                write_cr3((uintptr_t) AS_KERNEL->genarch.page_table);
     54                return;
     55        }
     56
     57        uintptr_t cur;
     58        unsigned int identity_flags =
     59            PAGE_CACHEABLE | PAGE_EXEC | PAGE_GLOBAL | PAGE_WRITE;
    5560               
    56                 page_mapping_operations = &pt_mapping_operations;
     61        page_mapping_operations = &pt_mapping_operations;
    5762               
    58                 page_table_lock(AS_KERNEL, true);
     63        page_table_lock(AS_KERNEL, true);
    5964               
    60                 /*
    61                  * PA2KA(identity) mapping for all frames.
    62                  */
    63                 for (cur = 0; cur < last_frame; cur += FRAME_SIZE)
    64                         page_mapping_insert(AS_KERNEL, PA2KA(cur), cur, identity_flags);
     65        /*
     66         * PA2KA(identity) mapping for all low-memory frames.
     67         */
     68        for (cur = 0; cur < min(config.identity_size, config.physmem_end);
     69            cur += FRAME_SIZE)
     70                page_mapping_insert(AS_KERNEL, PA2KA(cur), cur, identity_flags);
    6571               
    66                 page_table_unlock(AS_KERNEL, true);
     72        page_table_unlock(AS_KERNEL, true);
    6773               
    68                 exc_register(14, "page_fault", true, (iroutine_t) page_fault);
    69                 write_cr3((uintptr_t) AS_KERNEL->genarch.page_table);
    70         } else
    71                 write_cr3((uintptr_t) AS_KERNEL->genarch.page_table);
     74        exc_register(14, "page_fault", true, (iroutine_t) page_fault);
     75        write_cr3((uintptr_t) AS_KERNEL->genarch.page_table);
    7276}
    7377
    … …  
    9498}
    9599
    96 uintptr_t hw_map(uintptr_t physaddr, size_t size)
    97 {
    98         if (last_frame + ALIGN_UP(size, PAGE_SIZE) > KA2PA(KERNEL_ADDRESS_SPACE_END_ARCH))
    99                 panic("Unable to map physical memory %p (%zu bytes).",
    100                     (void *) physaddr, size);
    101        
    102         uintptr_t virtaddr = PA2KA(last_frame);
    103         pfn_t i;
    104        
    105         page_table_lock(AS_KERNEL, true);
    106        
    107         for (i = 0; i < ADDR2PFN(ALIGN_UP(size, PAGE_SIZE)); i++)
    108                 page_mapping_insert(AS_KERNEL, virtaddr + PFN2ADDR(i), physaddr + PFN2ADDR(i), PAGE_NOT_CACHEABLE | PAGE_WRITE);
    109        
    110         page_table_unlock(AS_KERNEL, true);
    111        
    112         last_frame = ALIGN_UP(last_frame + size, FRAME_SIZE);
    113        
    114         return virtaddr;
    115 }
    116 
    117100/** @}
    118101 */

  • kernel/arch/arm32/Makefile.inc

    rbd5f3b7 r00aece0  
    5353        arch/$(KARCH)/src/debug/stacktrace.c \
    5454        arch/$(KARCH)/src/debug/stacktrace_asm.S \
     55        arch/$(KARCH)/src/mm/km.c \
    5556        arch/$(KARCH)/src/mm/as.c \
    5657        arch/$(KARCH)/src/mm/frame.c \

  • kernel/arch/arm32/include/mach/integratorcp/integratorcp.h

    rbd5f3b7 r00aece0  
    103103extern void icp_cpu_halt(void);
    104104extern void icp_irq_exception(unsigned int, istate_t *);
    105 extern void icp_get_memory_extents(uintptr_t *, uintptr_t *);
     105extern void icp_get_memory_extents(uintptr_t *, size_t *);
    106106extern void icp_frame_init(void);
    107107extern size_t icp_get_irq_count(void);

  • kernel/arch/arm32/include/mach/testarm/testarm.h

    rbd5f3b7 r00aece0  
    7171extern void gxemul_cpu_halt(void);
    7272extern void gxemul_irq_exception(unsigned int, istate_t *);
    73 extern void gxemul_get_memory_extents(uintptr_t *, uintptr_t *);
     73extern void gxemul_get_memory_extents(uintptr_t *, size_t *);
    7474extern void gxemul_frame_init(void);
    7575extern size_t gxemul_get_irq_count(void);

  • kernel/arch/arm32/include/machine_func.h

    rbd5f3b7 r00aece0  
    5050        void (*machine_timer_irq_start)(void);
    5151        void (*machine_cpu_halt)(void);
    52         void (*machine_get_memory_extents)(uintptr_t *, uintptr_t *);
     52        void (*machine_get_memory_extents)(uintptr_t *, size_t *);
    5353        void (*machine_irq_exception)(unsigned int, istate_t *);
    5454        void (*machine_frame_init)(void);
    … …  
    8181 * @param size          Place to store memory size.
    8282 */
    83 extern void machine_get_memory_extents(uintptr_t *start, uintptr_t *size);
     83extern void machine_get_memory_extents(uintptr_t *start, size_t *size);
    8484
    8585/** Interrupt exception handler.

  • kernel/arch/arm32/include/mm/frame.h

    rbd5f3b7 r00aece0  
    6161#endif
    6262
    63 extern uintptr_t last_frame;
    64 
    65 extern void frame_arch_init(void);
     63extern void frame_low_arch_init(void);
     64extern void frame_high_arch_init(void);
    6665extern void boot_page_table_free(void);
    6766#define physmem_print()

  • kernel/arch/arm32/include/mm/page.h

    rbd5f3b7 r00aece0  
    5454
    5555/* Number of entries in each level. */
    56 #define PTL0_ENTRIES_ARCH       (2 << 12)       /* 4096 */
     56#define PTL0_ENTRIES_ARCH       (1 << 12)       /* 4096 */
    5757#define PTL1_ENTRIES_ARCH       0
    5858#define PTL2_ENTRIES_ARCH       0
    5959/* coarse page tables used (256 * 4 = 1KB per page) */
    60 #define PTL3_ENTRIES_ARCH       (2 << 8)        /* 256 */
     60#define PTL3_ENTRIES_ARCH       (1 << 8)        /* 256 */
    6161
    6262/* Page table sizes for each level. */

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

    rbd5f3b7 r00aece0  
    3838#include <genarch/fb/fb.h>
    3939#include <abi/fb/visuals.h>
    40 #include <sysinfo/sysinfo.h>
    4140#include <console/console.h>
    4241#include <ddi/irq.h>
    … …  
    5857        size_t i;
    5958        for (i = 0; i < init.cnt; i++) {
    60                 init.tasks[i].addr = (uintptr_t) bootinfo->tasks[i].addr;
     59                init.tasks[i].paddr = KA2PA(bootinfo->tasks[i].addr);
    6160                init.tasks[i].size = bootinfo->tasks[i].size;
    6261                str_cpy(init.tasks[i].name, CONFIG_TASK_NAME_BUFLEN,

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

    rbd5f3b7 r00aece0  
    3838#include <arch/mm/page.h>
    3939#include <mm/page.h>
     40#include <mm/km.h>
    4041#include <genarch/fb/fb.h>
    4142#include <abi/fb/visuals.h>
    … …  
    6566static void gta02_timer_irq_start(void);
    6667static void gta02_cpu_halt(void);
    67 static void gta02_get_memory_extents(uintptr_t *start, uintptr_t *size);
     68static void gta02_get_memory_extents(uintptr_t *start, size_t *size);
    6869static void gta02_irq_exception(unsigned int exc_no, istate_t *istate);
    6970static void gta02_frame_init(void);
    … …  
    101102        s3c24xx_irqc_regs_t *irqc_regs;
    102103
    103         gta02_timer = (void *) hw_map(S3C24XX_TIMER_ADDRESS, PAGE_SIZE);
    104         irqc_regs = (void *) hw_map(S3C24XX_IRQC_ADDRESS, PAGE_SIZE);
     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);
    105108
    106109        /* Initialize interrupt controller. */
    … …  
    123126 * @param size          Place to store memory size.
    124127 */
    125 static void gta02_get_memory_extents(uintptr_t *start, uintptr_t *size)
     128static void gta02_get_memory_extents(uintptr_t *start, size_t *size)
    126129{
    127130        *start = GTA02_MEMORY_START + GTA02_MEMORY_SKIP;

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

    rbd5f3b7 r00aece0  
    4545#include <mm/page.h>
    4646#include <mm/frame.h>
     47#include <mm/km.h>
    4748#include <arch/mm/frame.h>
    4849#include <arch/mach/integratorcp/integratorcp.h>
    … …  
    128129void icp_init(void)
    129130{
    130         icp_hw_map.uart = hw_map(ICP_UART, PAGE_SIZE);
    131         icp_hw_map.kbd_ctrl = hw_map(ICP_KBD, PAGE_SIZE);
     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);
    132134        icp_hw_map.kbd_stat = icp_hw_map.kbd_ctrl + ICP_KBD_STAT;
    133135        icp_hw_map.kbd_data = icp_hw_map.kbd_ctrl + ICP_KBD_DATA;
    134136        icp_hw_map.kbd_intstat = icp_hw_map.kbd_ctrl + ICP_KBD_INTR_STAT;
    135         icp_hw_map.rtc = hw_map(ICP_RTC, PAGE_SIZE);
     137        icp_hw_map.rtc = km_map(ICP_RTC, PAGE_SIZE,
     138            PAGE_WRITE | PAGE_NOT_CACHEABLE);
    136139        icp_hw_map.rtc1_load = icp_hw_map.rtc + ICP_RTC1_LOAD_OFFSET;
    137140        icp_hw_map.rtc1_read = icp_hw_map.rtc + ICP_RTC1_READ_OFFSET;
    … …  
    141144        icp_hw_map.rtc1_intrstat = icp_hw_map.rtc + ICP_RTC1_INTRSTAT_OFFSET;
    142145
    143         icp_hw_map.irqc = hw_map(ICP_IRQC, PAGE_SIZE);
     146        icp_hw_map.irqc = km_map(ICP_IRQC, PAGE_SIZE,
     147            PAGE_WRITE | PAGE_NOT_CACHEABLE);
    144148        icp_hw_map.irqc_mask = icp_hw_map.irqc + ICP_IRQC_MASK_OFFSET;
    145149        icp_hw_map.irqc_unmask = icp_hw_map.irqc + ICP_IRQC_UNMASK_OFFSET;
    146         icp_hw_map.cmcr = hw_map(ICP_CMCR, PAGE_SIZE);
     150        icp_hw_map.cmcr = km_map(ICP_CMCR, PAGE_SIZE,
     151            PAGE_WRITE | PAGE_NOT_CACHEABLE);
    147152        icp_hw_map.sdramcr = icp_hw_map.cmcr + ICP_SDRAMCR_OFFSET;
    148         icp_hw_map.vga = hw_map(ICP_VGA, PAGE_SIZE);
     153        icp_hw_map.vga = km_map(ICP_VGA, PAGE_SIZE,
     154            PAGE_WRITE | PAGE_NOT_CACHEABLE);
    149155
    150156        hw_map_init_called = true;
    … …  
    220226 * @param size          Place to store memory size.
    221227 */
    222 void icp_get_memory_extents(uintptr_t *start, uintptr_t *size)
     228void icp_get_memory_extents(uintptr_t *start, size_t *size)
    223229{
    224230        *start = 0;
    … …  
    326332        sysinfo_set_item_val("kbd", NULL, true);
    327333        sysinfo_set_item_val("kbd.inr", NULL, ICP_KBD_IRQ);
    328         sysinfo_set_item_val("kbd.address.status", NULL,
    329             (uintptr_t) icp_hw_map.kbd_stat);
    330         sysinfo_set_item_val("kbd.address.data", NULL,
    331             (uintptr_t) icp_hw_map.kbd_data);
     334        sysinfo_set_item_val("kbd.address.physical", NULL,
     335            ICP_KBD);
    332336
    333337}

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

    rbd5f3b7 r00aece0  
    3737#include <arch/mach/testarm/testarm.h>
    3838#include <mm/page.h>
     39#include <mm/km.h>
    3940#include <genarch/fb/fb.h>
    4041#include <abi/fb/visuals.h>
    … …  
    7172void gxemul_init(void)
    7273{
    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);
     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);
    7680}
    7781
    … …  
    124128        sysinfo_set_item_val("kbd", NULL, true);
    125129        sysinfo_set_item_val("kbd.inr", NULL, GXEMUL_KBD_IRQ);
    126         sysinfo_set_item_val("kbd.address.virtual", NULL, (sysarg_t) gxemul_kbd);
     130        sysinfo_set_item_val("kbd.address.physical", NULL,
     131            GXEMUL_KBD_ADDRESS);
    127132#endif
    128133}
    … …  
    202207 * @param size          Place to store memory size.
    203208 */
    204 void gxemul_get_memory_extents(uintptr_t *start, uintptr_t *size)
     209void gxemul_get_memory_extents(uintptr_t *start, size_t *size)
    205210{
    206211        *start = 0;
    207         *size = *((uintptr_t *) (GXEMUL_MP_ADDRESS + GXEMUL_MP_MEMSIZE_OFFSET));
     212        *size = *((uintptr_t *) (GXEMUL_MP_ADDRESS + GXEMUL_MP_MEMSIZE_OFFSET));
    208213}
    209214

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

    rbd5f3b7 r00aece0  
    8585 * @param size          Place to store memory size.
    8686 */
    87 void machine_get_memory_extents(uintptr_t *start, uintptr_t *size)
     87void machine_get_memory_extents(uintptr_t *start, size_t *size)
    8888{
    8989        (machine_ops->machine_get_memory_extents)(start, size);

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

    rbd5f3b7 r00aece0  
    3939#include <config.h>
    4040#include <align.h>
     41#include <macros.h>
    4142
    42 /** Address of the last frame in the memory. */
    43 uintptr_t last_frame = 0;
     43static void frame_common_arch_init(bool low)
     44{
     45        uintptr_t base;
     46        size_t size;
    4447
    45 /** Creates memory zones. */
    46 void frame_arch_init(void)
     48        machine_get_memory_extents(&base, &size);
     49        base = ALIGN_UP(base, FRAME_SIZE);
     50        size = ALIGN_DOWN(size, FRAME_SIZE);
     51       
     52        if (!frame_adjust_zone_bounds(low, &base, &size))
     53                return;
     54
     55        if (low) {
     56                zone_create(ADDR2PFN(base), SIZE2FRAMES(size),
     57                    BOOT_PAGE_TABLE_START_FRAME +
     58                    BOOT_PAGE_TABLE_SIZE_IN_FRAMES,
     59                    ZONE_AVAILABLE | ZONE_LOWMEM);
     60        } else {
     61                pfn_t conf = zone_external_conf_alloc(SIZE2FRAMES(size));
     62                if (conf != 0)
     63                        zone_create(ADDR2PFN(base), SIZE2FRAMES(size), conf,
     64                            ZONE_AVAILABLE | ZONE_HIGHMEM);
     65        }
     66       
     67}
     68
     69/** Create low memory zones. */
     70void frame_low_arch_init(void)
    4771{
    48         uintptr_t mem_start, mem_size;
    49         uintptr_t first_frame;
    50         uintptr_t num_frames;
     72        frame_common_arch_init(true);
    5173
    52         machine_get_memory_extents(&mem_start, &mem_size);
    53         first_frame = ALIGN_UP(mem_start, FRAME_SIZE);
    54         last_frame = ALIGN_DOWN(mem_start + mem_size, FRAME_SIZE);
    55         num_frames = (last_frame - first_frame) >> FRAME_WIDTH;
    56        
    57         /* All memory as one zone */
    58         zone_create(first_frame >> FRAME_WIDTH, num_frames,
    59             BOOT_PAGE_TABLE_START_FRAME + BOOT_PAGE_TABLE_SIZE_IN_FRAMES, 0);
    60        
    6174        /* blacklist boot page table */
    6275        frame_mark_unavailable(BOOT_PAGE_TABLE_START_FRAME,
    … …  
    6477
    6578        machine_frame_init();
     79}
     80
     81/** Create high memory zones. */
     82void frame_high_arch_init(void)
     83{
     84        frame_common_arch_init(false);
    6685}
    6786

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

    rbd5f3b7 r00aece0  
    3737#include <genarch/mm/page_pt.h>
    3838#include <mm/page.h>
     39#include <arch/mm/frame.h>
    3940#include <align.h>
    4041#include <config.h>
    … …  
    4243#include <typedefs.h>
    4344#include <interrupt.h>
    44 #include <arch/mm/frame.h>
     45#include <macros.h>
    4546
    4647/** Initializes page tables.
    … …  
    5758       
    5859        uintptr_t cur;
     60
    5961        /* Kernel identity mapping */
    60         for (cur = PHYSMEM_START_ADDR; cur < last_frame; cur += FRAME_SIZE)
     62        for (cur = PHYSMEM_START_ADDR;
     63            cur < min(config.identity_size, config.physmem_end);
     64            cur += FRAME_SIZE)
    6165                page_mapping_insert(AS_KERNEL, PA2KA(cur), cur, flags);
    6266       
     67#ifdef HIGH_EXCEPTION_VECTORS
    6368        /* Create mapping for exception table at high offset */
    64 #ifdef HIGH_EXCEPTION_VECTORS
    65         void *virtaddr = frame_alloc(ONE_FRAME, FRAME_KA);
    66         page_mapping_insert(AS_KERNEL, EXC_BASE_ADDRESS, KA2PA(virtaddr), flags);
     69        uintptr_t ev_frame = (uintptr_t) frame_alloc(ONE_FRAME, FRAME_NONE);
     70        page_mapping_insert(AS_KERNEL, EXC_BASE_ADDRESS, ev_frame, flags);
    6771#else
    6872#error "Only high exception vector supported now"
    6973#endif
    70         cur = ALIGN_DOWN(0x50008010, FRAME_SIZE);
    71         page_mapping_insert(AS_KERNEL, PA2KA(cur), cur, flags);
    7274
    7375        page_table_unlock(AS_KERNEL, true);
    … …  
    7880}
    7981
    80 /** Maps device into the kernel space.
    81  *
    82  * Maps physical address of device into kernel virtual address space (so it can
    83  * be accessed only by kernel through virtual address).
    84  *
    85  * @param physaddr Physical address where device is connected.
    86  * @param size Length of area where device is present.
    87  *
    88  * @return Virtual address where device will be accessible.
    89  */
    90 uintptr_t hw_map(uintptr_t physaddr, size_t size)
    91 {
    92         if (last_frame + ALIGN_UP(size, PAGE_SIZE) >
    93             KA2PA(KERNEL_ADDRESS_SPACE_END_ARCH)) {
    94                 panic("Unable to map physical memory %p (%d bytes).",
    95                     (void *) physaddr, size);
    96         }
    97        
    98         uintptr_t virtaddr = PA2KA(last_frame);
    99         pfn_t i;
    100 
    101         page_table_lock(AS_KERNEL, true);
    102         for (i = 0; i < ADDR2PFN(ALIGN_UP(size, PAGE_SIZE)); i++) {
    103                 page_mapping_insert(AS_KERNEL, virtaddr + PFN2ADDR(i),
    104                     physaddr + PFN2ADDR(i),
    105                     PAGE_NOT_CACHEABLE | PAGE_READ | PAGE_WRITE | PAGE_KERNEL);
    106         }
    107         page_table_unlock(AS_KERNEL, true);
    108        
    109         last_frame = ALIGN_UP(last_frame + size, FRAME_SIZE);
    110         return virtaddr;
    111 }
    112 
    11382/** @}
    11483 */

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

    rbd5f3b7 r00aece0  
    3838#include <mm/frame.h>
    3939#include <mm/page.h>
     40#include <mm/km.h>
    4041#include <mm/tlb.h>
    4142#include <mm/asid.h>
    … …  
    5051void ras_init(void)
    5152{
    52         ras_page = frame_alloc(ONE_FRAME, FRAME_KA);
    53         memsetb(ras_page, FRAME_SIZE, 0);
     53        uintptr_t frame;
     54
     55        frame = (uintptr_t) frame_alloc(ONE_FRAME,
     56            FRAME_ATOMIC | FRAME_HIGHMEM);
     57        if (!frame)
     58                frame = (uintptr_t) frame_alloc(ONE_FRAME, FRAME_LOWMEM);
     59        ras_page = (uintptr_t *) km_map(frame,
     60            PAGE_SIZE, PAGE_READ | PAGE_WRITE | PAGE_USER | PAGE_CACHEABLE);
     61
     62        memsetb(ras_page, PAGE_SIZE, 0);
    5463        ras_page[RAS_START] = 0;
    5564        ras_page[RAS_END] = 0xffffffff;
    56         /*
    57          * Userspace needs to be able to write to this page. The page is
    58          * cached in TLB as PAGE_KERNEL. Purge it from TLB and map it
    59          * read/write PAGE_USER.
    60          */
    61         tlb_invalidate_pages(ASID_KERNEL, (uintptr_t)ras_page, 1);
    62         page_table_lock(AS, true);
    63         page_mapping_insert(AS, (uintptr_t)ras_page, (uintptr_t)KA2PA(ras_page),
    64             PAGE_READ | PAGE_WRITE | PAGE_USER);
    65         page_table_unlock(AS, true);
    6665}
    6766
    … …  
    8685}
    8786
     87/** @}
     88 */

  • kernel/arch/ia32/Makefile.inc

    rbd5f3b7 r00aece0  
    9999        arch/$(KARCH)/src/userspace.c \
    100100        arch/$(KARCH)/src/cpu/cpu.c \
     101        arch/$(KARCH)/src/mm/km.c \
    101102        arch/$(KARCH)/src/mm/as.c \
    102103        arch/$(KARCH)/src/mm/frame.c \
    … …  
    106107        arch/$(KARCH)/src/drivers/i8254.c \
    107108        arch/$(KARCH)/src/drivers/i8259.c \
    108         arch/$(KARCH)/src/drivers/vesa.c \
    109         arch/$(KARCH)/src/boot/boot.S \
     109        arch/$(KARCH)/src/boot/multiboot.S \
     110        arch/$(KARCH)/src/boot/multiboot2.S \
    110111        arch/$(KARCH)/src/boot/memmap.c \
    111112        arch/$(KARCH)/src/fpu_context.c \

  • kernel/arch/ia32/include/arch.h

    rbd5f3b7 r00aece0  
    3636#define KERN_ia32_ARCH_H_
    3737
    38 #include <genarch/multiboot/multiboot.h>
     38#include <typedefs.h>
    3939
    40 extern void arch_pre_main(uint32_t, const multiboot_info_t *);
     40extern void arch_pre_main(uint32_t, void *);
    4141
    4242#endif

  • kernel/arch/ia32/include/boot/boot.h

    rbd5f3b7 r00aece0  
    4040#define BOOT_STACK_SIZE  0x0400
    4141
    42 #define MULTIBOOT_HEADER_MAGIC  0x1BADB002
    43 #define MULTIBOOT_HEADER_FLAGS  0x00010003
    44 
    45 #define MULTIBOOT_LOADER_MAGIC  0x2BADB002
    46 
    4742#ifndef __ASM__
    4843

  • kernel/arch/ia32/include/interrupt.h

    rbd5f3b7 r00aece0  
    5555#define IRQ_PIC_SPUR  7
    5656#define IRQ_MOUSE     12
    57 #define IRQ_NE2000    5
    5857
    5958/* This one must have four least significant bits set to ones */

  • kernel/arch/ia32/include/mm/frame.h

    rbd5f3b7 r00aece0  
    4343#include <typedefs.h>
    4444
    45 extern uintptr_t last_frame;
    46 
    47 extern void frame_arch_init(void);
     45extern void frame_low_arch_init(void);
     46extern void frame_high_arch_init(void);
    4847extern void physmem_print(void);
    4948

  • kernel/arch/ia32/src/boot/memmap.c

    rbd5f3b7 r00aece0  
    3535#include <arch/boot/memmap.h>
    3636
    37 uint8_t e820counter = 0xffU;
     37uint8_t e820counter = 0;
    3838e820memmap_t e820table[MEMMAP_E820_MAX_RECORDS];
    3939

  • kernel/arch/ia32/src/boot/multiboot.S

    rbd5f3b7 r00aece0  
    22 * Copyright (c) 2001 Jakub Jermar
    33 * Copyright (c) 2005 Martin Decky
     4 * Copyright (c) 2011 Martin Sucha
    45 * All rights reserved.
    56 *
    … …  
    2930
    3031#include <arch/boot/boot.h>
    31 #include <arch/boot/memmap.h>
    3232#include <arch/mm/page.h>
    3333#include <arch/pm.h>
     34#include <genarch/multiboot/multiboot.h>
    3435#include <arch/cpuid.h>
    3536
    … …  
    9192        multiboot_meeting_point:
    9293       
    93         /* Save GRUB arguments */
    94         movl %eax, grub_eax
    95         movl %ebx, grub_ebx
     94        /* Save multiboot arguments */
     95        movl %eax, multiboot_eax
     96        movl %ebx, multiboot_ebx
    9697       
    9798        pm_status $status_prot
    … …  
    124125                /* Map kernel and turn paging on */
    125126                pm_status $status_non_pse
    126                 call map_kernel
     127                call map_kernel_non_pse
    127128       
    128129        stack_init:
    … …  
    134135        pm2_status $status_prot3
    135136       
    136         /* Call arch_pre_main(grub_eax, grub_ebx) */
    137         pushl grub_ebx
    138         pushl grub_eax
     137        /* Call arch_pre_main(multiboot_eax, multiboot_ebx) */
     138        pushl multiboot_ebx
     139        pushl multiboot_eax
    139140        call arch_pre_main
    140141       
    … …  
    195196 *
    196197 */
    197 .global map_kernel
    198 map_kernel:
     198.global map_kernel_non_pse
     199map_kernel_non_pse:
    199200        /* Paging features */
    200201        movl %cr4, %ecx
    … …  
    299300find_mem_for_pt:
    300301        /* Check if multiboot info is present */
    301         cmpl $MULTIBOOT_LOADER_MAGIC, grub_eax
     302        cmpl $MULTIBOOT_LOADER_MAGIC, multiboot_eax
    302303        je check_multiboot_map
    303304               
    … …  
    307308               
    308309                /* Copy address of the multiboot info to ebx */
    309                 movl grub_ebx, %ebx
     310                movl multiboot_ebx, %ebx
    310311               
    311312                /* Check if memory map flag is present */
    … …  
    701702        .space 4096, 0
    702703
     704.global bootstrap_gdtr
    703705bootstrap_gdtr:
    704706        .word GDT_SELECTOR(GDT_ITEMS)
    705707        .long KA2PA(gdt)
    706708
    707 grub_eax:
     709.global multiboot_eax
     710multiboot_eax:
    708711        .long 0
    709 grub_ebx:
     712
     713.global multiboot_ebx
     714multiboot_ebx:
    710715        .long 0
    711716
    … …  
    725730status_vesa_copy:
    726731        .asciz "[vesa_copy] "
    727 status_grub_cmdline:
    728         .asciz "[grub_cmdline] "
     732status_multiboot_cmdline:
     733        .asciz "[multiboot_cmdline] "
    729734status_vesa_real:
    730735        .asciz "[vesa_real] "

  • kernel/arch/ia32/src/boot/vesa_prot.inc

    rbd5f3b7 r00aece0  
    11#ifdef CONFIG_FB
    22
    3 #define MULTIBOOT_LOADER_MAGIC  0x2BADB002
    43#define MBINFO_BIT_CMDLINE      2
    54#define MBINFO_OFFSET_CMDLINE   16
    … …  
    1413        rep movsb
    1514       
    16         /* Check for GRUB command line */
     15        /* Check for multiboot command line */
    1716       
    18         pm_status $status_grub_cmdline
     17        pm_status $status_multiboot_cmdline
    1918       
    20         mov grub_eax, %eax
     19        mov multiboot_eax, %eax
    2120        cmp $MULTIBOOT_LOADER_MAGIC, %eax
    2221        jne no_cmdline
    2322       
    24         mov grub_ebx, %ebx
     23        mov multiboot_ebx, %ebx
    2524        mov (%ebx), %eax
    2625        bt $MBINFO_BIT_CMDLINE, %eax
    … …  
    8988                /* Returned back to protected mode */
    9089               
    91                 mov %ax, KA2PA(vesa_scanline)
     90                movzx %ax, %ecx
     91                mov %ecx, KA2PA(bfb_scanline)
     92               
    9293                shr $16, %eax
    93                 mov %ax, KA2PA(vesa_bpp)
     94                mov %ax, KA2PA(bfb_bpp)
    9495               
    95                 mov %bx, KA2PA(vesa_height)
     96                movzx %bx, %ecx
     97                mov %ecx, KA2PA(bfb_height)
     98               
    9699                shr $16, %ebx
    97                 mov %bx, KA2PA(vesa_width)
     100                mov %ebx, KA2PA(bfb_width)
    98101               
    99                 mov %dl, KA2PA(vesa_green_pos)
     102                mov %dl, KA2PA(bfb_green_pos)
     103               
    100104                shr $8, %edx
    101                 mov %dl, KA2PA(vesa_green_mask)
     105                mov %dl, KA2PA(bfb_green_size)
     106               
    102107                shr $8, %edx
    103                 mov %dl, KA2PA(vesa_red_pos)
     108                mov %dl, KA2PA(bfb_red_pos)
     109               
    104110                shr $8, %edx
    105                 mov %dl, KA2PA(vesa_red_mask)
     111                mov %dl, KA2PA(bfb_red_size)
    106112               
    107113                mov %esi, %edx
    108                 mov %dl, KA2PA(vesa_blue_pos)
     114                mov %dl, KA2PA(bfb_blue_pos)
     115               
    109116                shr $8, %edx
    110                 mov %dl, KA2PA(vesa_blue_mask)
     117                mov %dl, KA2PA(bfb_blue_size)
    111118               
    112                 mov %edi, KA2PA(vesa_ph_addr)
     119                mov %edi, KA2PA(bfb_addr)
    113120#endif

  • kernel/arch/ia32/src/boot/vesa_real.inc

    rbd5f3b7 r00aece0  
    304304                /*
    305305                 * Store mode parameters:
    306                  *  eax = bpp[8] scanline[16]
     306                 *  eax = bpp[16] scanline[16]
    307307                 *  ebx = width[16]  height[16]
    308308                 *  edx = red_mask[8] red_pos[8] green_mask[8] green_pos[8]
    … …  
    328328                shl $8, %edx
    329329                mov VESA_MODE_RED_POS_OFFSET(%di), %dl
     330               
    330331                shl $8, %edx
    331332                mov VESA_MODE_GREEN_MASK_OFFSET(%di), %dl
    … …  
    369370                mov $0x0003, %ax
    370371                int $0x10
    371                 mov $0xffffffff, %edi
    372                 xor %ax, %ax
     372               
     373                xor %eax, %eax
     374                xor %ebx, %ebx
     375                xor %edx, %edx
     376                xor %edi, %edi
     377               
    373378                jz vesa_leave_real  /* force relative jump */
    374379
    … …  
    386391
    387392default_mode:
    388         .ascii STRING(CONFIG_VESA_MODE)
     393        .ascii STRING(CONFIG_BFB_MODE)
    389394        .ascii "-"
    390         .asciz STRING(CONFIG_VESA_BPP)
     395        .asciz STRING(CONFIG_BFB_BPP)
    391396        .fill 24
    392397

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

    rbd5f3b7 r00aece0  
    3636
    3737#include <arch.h>
    38 
    3938#include <typedefs.h>
    40 
    41 #include <arch/pm.h>
    42 
    43 #include <genarch/multiboot/multiboot.h>
    44 #include <genarch/drivers/legacy/ia32/io.h>
    45 #include <genarch/drivers/ega/ega.h>
    46 #include <arch/drivers/vesa.h>
    47 #include <genarch/drivers/i8042/i8042.h>
    48 #include <genarch/kbrd/kbrd.h>
     39#include <errno.h>
     40#include <memstr.h>
     41#include <interrupt.h>
     42#include <console/console.h>
     43#include <syscall/syscall.h>
     44#include <sysinfo/sysinfo.h>
     45#include <arch/bios/bios.h>
     46#include <arch/boot/boot.h>
     47#include <arch/debugger.h>
    4948#include <arch/drivers/i8254.h>
    5049#include <arch/drivers/i8259.h>
    51 
    52 #include <arch/context.h>
    53 
    54 #include <config.h>
    55 
    56 #include <arch/interrupt.h>
    57 #include <arch/asm.h>
    5850#include <genarch/acpi/acpi.h>
    59 
    60 #include <arch/bios/bios.h>
    61 
    62 #include <interrupt.h>
    63 #include <ddi/irq.h>
    64 #include <arch/debugger.h>
    65 #include <proc/thread.h>
    66 #include <syscall/syscall.h>
    67 #include <console/console.h>
    68 #include <sysinfo/sysinfo.h>
    69 #include <arch/boot/boot.h>
    70 #include <memstr.h>
     51#include <genarch/drivers/ega/ega.h>
     52#include <genarch/drivers/i8042/i8042.h>
     53#include <genarch/drivers/legacy/ia32/io.h>
     54#include <genarch/fb/bfb.h>
     55#include <genarch/kbrd/kbrd.h>
     56#include <genarch/multiboot/multiboot.h>
     57#include <genarch/multiboot/multiboot2.h>
    7158
    7259#ifdef CONFIG_SMP
    … …  
    7663/** Perform ia32-specific initialization before main_bsp() is called.
    7764 *
    78  * @param signature Should contain the multiboot signature.
    79  * @param mi        Pointer to the multiboot information structure.
    80  */
    81 void arch_pre_main(uint32_t signature, const multiboot_info_t *mi)
     65 * @param signature Multiboot signature.
     66 * @param info      Multiboot information structure.
     67 *
     68 */
     69void arch_pre_main(uint32_t signature, void *info)
    8270{
    8371        /* Parse multiboot information obtained from the bootloader. */
    84         multiboot_info_parse(signature, mi);
     72        multiboot_info_parse(signature, (multiboot_info_t *) info);
     73        multiboot2_info_parse(signature, (multiboot2_info_t *) info);
    8574       
    8675#ifdef CONFIG_SMP
    … …  
    114103               
    115104#if (defined(CONFIG_FB) || defined(CONFIG_EGA))
    116                 bool vesa = false;
     105                bool bfb = false;
    117106#endif
    118107               
    119108#ifdef CONFIG_FB
    120                 vesa = vesa_init();
     109                bfb = bfb_init();
    121110#endif
    122111               
    123112#ifdef CONFIG_EGA
    124                 if (!vesa) {
     113                if (!bfb) {
    125114                        outdev_t *egadev = ega_init(EGA_BASE, EGA_VIDEORAM);
    126115                        if (egadev)
    … …  
    179168                }
    180169        }
    181        
    182         /*
    183          * This is the necessary evil until the userspace driver is entirely
    184          * self-sufficient.
    185          */
    186         sysinfo_set_item_val("i8042", NULL, true);
    187         sysinfo_set_item_val("i8042.inr_a", NULL, IRQ_KBD);
    188         sysinfo_set_item_val("i8042.inr_b", NULL, IRQ_MOUSE);
    189         sysinfo_set_item_val("i8042.address.physical", NULL,
    190             (uintptr_t) I8042_BASE);
    191         sysinfo_set_item_val("i8042.address.kernel", NULL,
    192             (uintptr_t) I8042_BASE);
    193170#endif
    194171       
    195172        if (irqs_info != NULL)
    196173                sysinfo_set_item_val(irqs_info, NULL, true);
    197        
    198         sysinfo_set_item_val("netif.ne2000.inr", NULL, IRQ_NE2000);
    199174}
    200175
    … …  
    216191 * selector, and the descriptor->base is the correct address.
    217192 */
    218 sysarg_t sys_tls_set(sysarg_t addr)
     193sysarg_t sys_tls_set(uintptr_t addr)
    219194{
    220195        THREAD->arch.tls = addr;
    221196        set_tls_desc(addr);
    222197       
    223         return 0;
     198        return EOK;
    224199}
    225200

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

    rbd5f3b7 r00aece0  
    4646#include <print.h>
    4747
    48 #define PHYSMEM_LIMIT32  UINT64_C(0x07c000000)
    49 #define PHYSMEM_LIMIT64  UINT64_C(0x200000000)
     48#define PHYSMEM_LIMIT32  UINT64_C(0x100000000)
    5049
    5150size_t hardcoded_unmapped_ktext_size = 0;
    5251size_t hardcoded_unmapped_kdata_size = 0;
    5352
    54 uintptr_t last_frame = 0;
    55 
    56 static void init_e820_memory(pfn_t minconf)
     53static void init_e820_memory(pfn_t minconf, bool low)
    5754{
    5855        unsigned int i;
    5956       
    6057        for (i = 0; i < e820counter; i++) {
    61                 uint64_t base = e820table[i].base_address;
    62                 uint64_t size = e820table[i].size;
     58                uint64_t base64 = e820table[i].base_address;
     59                uint64_t size64 = e820table[i].size;
    6360               
    64 #ifdef __32_BITS__
     61#ifdef KARCH_ia32
    6562                /*
    66                  * XXX FIXME:
    67                  *
    68                  * Ignore zones which start above PHYSMEM_LIMIT32
    69                  * or clip zones which go beyond PHYSMEM_LIMIT32.
    70                  *
    71                  * The PHYSMEM_LIMIT32 (2 GB - 64 MB) is a rather
    72                  * arbitrary constant which allows to have at
    73                  * least 64 MB in the kernel address space to
    74                  * map hardware resources.
    75                  *
    76                  * The kernel uses fixed 1:1 identity mapping
    77                  * of the physical memory with 2:2 GB split.
    78                  * This is a severe limitation of the current
    79                  * kernel memory management.
    80                  *
     63                 * Restrict the e820 table entries to 32-bits.
    8164                 */
    82                
    83                 if (base > PHYSMEM_LIMIT32)
     65                if (base64 >= PHYSMEM_LIMIT32)
    8466                        continue;
    8567               
    86                 if (base + size > PHYSMEM_LIMIT32)
    87                         size = PHYSMEM_LIMIT32 - base;
     68                if (base64 + size64 > PHYSMEM_LIMIT32)
     69                        size64 = PHYSMEM_LIMIT32 - base64;
    8870#endif
    8971               
    90 #ifdef __64_BITS__
    91                 /*
    92                  * XXX FIXME:
    93                  *
    94                  * Ignore zones which start above PHYSMEM_LIMIT64
    95                  * or clip zones which go beyond PHYSMEM_LIMIT64.
    96                  *
    97                  * The PHYSMEM_LIMIT64 (8 GB) is the size of the
    98                  * fixed 1:1 identically mapped physical memory
    99                  * accessible during the bootstrap process.
    100                  * This is a severe limitation of the current
    101                  * kernel memory management.
    102                  *
    103                  */
     72                uintptr_t base = (uintptr_t) base64;
     73                size_t size = (size_t) size64;
    10474               
    105                 if (base > PHYSMEM_LIMIT64)
     75                if (!frame_adjust_zone_bounds(low, &base, &size))
    10676                        continue;
    107                
    108                 if (base + size > PHYSMEM_LIMIT64)
    109                         size = PHYSMEM_LIMIT64 - base;
    110 #endif
    11177               
    11278                if (e820table[i].type == MEMMAP_MEMORY_AVAILABLE) {
    … …  
    11682                            FRAME_SIZE);
    11783                       
     84                        size_t count = SIZE2FRAMES(new_size);
    11885                        pfn_t pfn = ADDR2PFN(new_base);
    119                         size_t count = SIZE2FRAMES(new_size);
     86                        pfn_t conf;
    12087                       
    121                         pfn_t conf;
    122                         if ((minconf < pfn) || (minconf >= pfn + count))
    123                                 conf = pfn;
    124                         else
    125                                 conf = minconf;
    126                        
    127                         zone_create(pfn, count, conf, ZONE_AVAILABLE);
    128                        
    129                         // XXX this has to be removed
    130                         if (last_frame < ALIGN_UP(new_base + new_size, FRAME_SIZE))
    131                                 last_frame = ALIGN_UP(new_base + new_size, FRAME_SIZE);
     88                        if (low) {
     89                                if ((minconf < pfn) || (minconf >= pfn + count))
     90                                        conf = pfn;
     91                                else
     92                                        conf = minconf;
     93                                zone_create(pfn, count, conf,
     94                                    ZONE_AVAILABLE | ZONE_LOWMEM);
     95                        } else {
     96                                conf = zone_external_conf_alloc(count);
     97                                if (conf != 0)
     98                                        zone_create(pfn, count, conf,
     99                                            ZONE_AVAILABLE | ZONE_HIGHMEM);
     100                        }
    132101                } else if ((e820table[i].type == MEMMAP_MEMORY_ACPI) ||
    133102                    (e820table[i].type == MEMMAP_MEMORY_NVS)) {
    … …  
    179148
    180149
    181 void frame_arch_init(void)
     150void frame_low_arch_init(void)
    182151{
    183152        pfn_t minconf;
    … …  
    192161#endif
    193162               
    194                 init_e820_memory(minconf);
     163                init_e820_memory(minconf, true);
    195164               
    196165                /* Reserve frame 0 (BIOS data) */
    … …  
    206175}
    207176
     177void frame_high_arch_init(void)
     178{
     179        if (config.cpu_active == 1)
     180                init_e820_memory(0, false);
     181}
     182
    208183/** @}
    209184 */

  • kernel/arch/ia32/src/mm/page.c

    rbd5f3b7 r00aece0  
    4949#include <print.h>
    5050#include <interrupt.h>
     51#include <macros.h>
    5152
    5253void page_arch_init(void)
    … …  
    5556        int flags;
    5657       
    57         if (config.cpu_active == 1) {
    58                 page_mapping_operations = &pt_mapping_operations;
     58        if (config.cpu_active > 1) {
     59                /* Fast path for non-boot CPUs */
     60                write_cr3((uintptr_t) AS_KERNEL->genarch.page_table);
     61                paging_on();
     62                return;
     63        }
     64
     65        page_mapping_operations = &pt_mapping_operations;
    5966       
    60                 /*
    61                  * PA2KA(identity) mapping for all frames until last_frame.
    62                  */
    63                 page_table_lock(AS_KERNEL, true);
    64                 for (cur = 0; cur < last_frame; cur += FRAME_SIZE) {
    65                         flags = PAGE_CACHEABLE | PAGE_WRITE;
    66                         if ((PA2KA(cur) >= config.base) && (PA2KA(cur) < config.base + config.kernel_size))
    67                                 flags |= PAGE_GLOBAL;
    68                         page_mapping_insert(AS_KERNEL, PA2KA(cur), cur, flags);
    69                 }
    70                 page_table_unlock(AS_KERNEL, true);
     67        /*
     68         * PA2KA(identity) mapping for all low-memory frames.
     69         */
     70        page_table_lock(AS_KERNEL, true);
     71        for (cur = 0; cur < min(config.identity_size, config.physmem_end);
     72            cur += FRAME_SIZE) {
     73                flags = PAGE_CACHEABLE | PAGE_WRITE;
     74                if ((PA2KA(cur) >= config.base) &&
     75                    (PA2KA(cur) < config.base + config.kernel_size))
     76                        flags |= PAGE_GLOBAL;
     77                page_mapping_insert(AS_KERNEL, PA2KA(cur), cur, flags);
     78        }
     79        page_table_unlock(AS_KERNEL, true);
    7180               
    72                 exc_register(14, "page_fault", true, (iroutine_t) page_fault);
    73                 write_cr3((uintptr_t) AS_KERNEL->genarch.page_table);
    74         } else
    75                 write_cr3((uintptr_t) AS_KERNEL->genarch.page_table);
     81        exc_register(14, "page_fault", true, (iroutine_t) page_fault);
     82        write_cr3((uintptr_t) AS_KERNEL->genarch.page_table);
    7683       
    7784        paging_on();
    78 }
    79 
    80 
    81 uintptr_t hw_map(uintptr_t physaddr, size_t size)
    82 {
    83         if (last_frame + ALIGN_UP(size, PAGE_SIZE) > KA2PA(KERNEL_ADDRESS_SPACE_END_ARCH))
    84                 panic("Unable to map physical memory %p (%zu bytes).",
    85                     (void *) physaddr, size);
    86        
    87         uintptr_t virtaddr = PA2KA(last_frame);
    88         pfn_t i;
    89         page_table_lock(AS_KERNEL, true);
    90         for (i = 0; i < ADDR2PFN(ALIGN_UP(size, PAGE_SIZE)); i++) {
    91                 uintptr_t addr = PFN2ADDR(i);
    92                 page_mapping_insert(AS_KERNEL, virtaddr + addr, physaddr + addr, PAGE_NOT_CACHEABLE | PAGE_WRITE);
    93         }
    94         page_table_unlock(AS_KERNEL, true);
    95        
    96         last_frame = ALIGN_UP(last_frame + size, FRAME_SIZE);
    97        
    98         return virtaddr;
    9985}
    10086

  • kernel/arch/ia32/src/smp/ap.S

    rbd5f3b7 r00aece0  
    2828#
    2929
    30 #
    31 # Init code for application processors.
    32 #
     30/*
     31 * Init code for application processors.
     32 */
    3333
    3434#include <arch/boot/boot.h>
    … …  
    4646KDATA=16
    4747
    48 # This piece of code is real-mode and is meant to be aligned at 4K boundary.
    49 # The requirement for such an alignment comes from MP Specification's STARTUP IPI
    50 # requirements.
     48/*
     49 * This piece of code is real-mode and is meant to be aligned at 4K boundary.
     50 * The requirement for such an alignment comes from MP Specification's
     51 * STARTUP IPI requirements.
     52 */
    5153
    5254.align 4096
    … …  
    5759        movw %ax, %ds
    5860
    59         lgdtl ap_gdtr           # initialize Global Descriptor Table register
     61        /* initialize Global Descriptor Table register */
     62        lgdtl ap_gdtr
    6063       
     64        /* switch to protected mode */
    6165        movl %cr0, %eax
    6266        orl $1, %eax
    63         movl %eax, %cr0                         # switch to protected mode
     67        movl %eax, %cr0
    6468        jmpl $KTEXT, $jump_to_kernel - BOOT_OFFSET + AP_BOOT_OFFSET
    6569       
    … …  
    7074        movw %ax, %es
    7175        movw %ax, %ss
    72         movl $KA2PA(ctx), %eax                  # KA2PA((uintptr_t) &ctx)
     76        movl $KA2PA(ctx), %eax  /* KA2PA((uintptr_t) &ctx) */
    7377        movl (%eax), %esp
    74         subl $0x80000000, %esp                  # KA2PA(ctx.sp)
     78        subl $0x80000000, %esp  /* KA2PA(ctx.sp) */
    7579
    76         call map_kernel                                 # map kernel and turn paging on
     80        /*
     81         * Map kernel and turn paging on.
     82         * We assume that when using SMP, PSE is always available
     83         */
     84        call map_kernel_pse
    7785       
    78         addl $0x80000000, %esp                  # PA2KA(ctx.sp)
     86        addl $0x80000000, %esp  /*  PA2KA(ctx.sp) */
    7987       
    80         pushl $0                                # create the first stack frame
     88        /* create the first stack frame */
     89        pushl $0
    8190        movl %esp, %ebp
    8291

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

    rbd5f3b7 r00aece0  
    4747#include <debug.h>
    4848#include <arch/asm.h>
     49#include <mm/page.h>
    4950#include <mm/frame.h>
    50 #include <mm/page.h>
     51#include <mm/km.h>
    5152#include <mm/slab.h>
    5253#include <mm/as.h>
    … …  
    7273       
    7374        if (config.cpu_count > 1) {
    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);
     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);
    7679        }
    7780}

  • kernel/arch/ia64/Makefile.inc

    rbd5f3b7 r00aece0  
    5252        arch/$(KARCH)/src/ivt.S \
    5353        arch/$(KARCH)/src/interrupt.c \
     54        arch/$(KARCH)/src/mm/km.c \
    5455        arch/$(KARCH)/src/mm/as.c \
    5556        arch/$(KARCH)/src/mm/frame.c \

  • kernel/arch/ia64/include/arch.h

    rbd5f3b7 r00aece0  
    3636#define KERN_ia64_ARCH_H_
    3737
    38 #include <arch/drivers/ski.h>
    39 
    4038extern void arch_pre_main(void);
    4139

  • kernel/arch/ia64/include/asm.h

    rbd5f3b7 r00aece0  
    3838#include <config.h>
    3939#include <typedefs.h>
    40 #include <typedefs.h>
    4140#include <arch/register.h>
     41#include <arch/legacyio.h>
    4242#include <trace.h>
    4343
    44 #define IA64_IOSPACE_ADDRESS  0xE001000000000000ULL
    45 
    4644#define IO_SPACE_BOUNDARY       ((void *) (64 * 1024))
    4745
     46/** Map the I/O port address to a legacy I/O address. */
     47NO_TRACE static inline uintptr_t p2a(volatile void *p)
     48{
     49        uintptr_t prt = (uintptr_t) p;
     50
     51        return legacyio_virt_base + (((prt >> 2) << 12) | (prt & 0xfff));
     52}
     53       
    4854NO_TRACE static inline void pio_write_8(ioport8_t *port, uint8_t v)
    4955{
    50         if (port < (ioport8_t *) IO_SPACE_BOUNDARY) {
    51                 uintptr_t prt = (uintptr_t) port;
    52        
    53                 *((ioport8_t *) (IA64_IOSPACE_ADDRESS +
    54                     ((prt & 0xfff) | ((prt >> 2) << 12)))) = v;
    55         } else {
     56        if (port < (ioport8_t *) IO_SPACE_BOUNDARY)
     57                *((ioport8_t *) p2a(port)) = v;
     58        else
    5659                *port = v;
    57         }
    5860       
    5961        asm volatile (
    … …  
    6567NO_TRACE static inline void pio_write_16(ioport16_t *port, uint16_t v)
    6668{
    67         if (port < (ioport16_t *) IO_SPACE_BOUNDARY) {
    68                 uintptr_t prt = (uintptr_t) port;
    69        
    70                 *((ioport16_t *) (IA64_IOSPACE_ADDRESS +
    71                     ((prt & 0xfff) | ((prt >> 2) << 12)))) = v;
    72         } else {
     69        if (port < (ioport16_t *) IO_SPACE_BOUNDARY)
     70                *((ioport16_t *) p2a(port)) = v;
     71        else
    7372                *port = v;
    74         }
    7573       
    7674        asm volatile (
    … …  
    8280NO_TRACE static inline void pio_write_32(ioport32_t *port, uint32_t v)
    8381{
    84         if (port < (ioport32_t *) IO_SPACE_BOUNDARY) {
    85                 uintptr_t prt = (uintptr_t) port;
    86        
    87                 *((ioport32_t *) (IA64_IOSPACE_ADDRESS +
    88                     ((prt & 0xfff) | ((prt >> 2) << 12)))) = v;
    89         } else {
     82        if (port < (ioport32_t *) IO_SPACE_BOUNDARY)
     83                *((ioport32_t *) p2a(port)) = v;
     84        else
    9085                *port = v;
    91         }
    9286       
    9387        asm volatile (
    … …  
    106100        );
    107101
    108         if (port < (ioport8_t *) IO_SPACE_BOUNDARY) {
    109                 uintptr_t prt = (uintptr_t) port;
    110 
    111                 v = *((ioport8_t *) (IA64_IOSPACE_ADDRESS +
    112                     ((prt & 0xfff) | ((prt >> 2) << 12))));
    113         } else {
     102        if (port < (ioport8_t *) IO_SPACE_BOUNDARY)
     103                v = *((ioport8_t *) p2a(port));
     104        else
    114105                v = *port;
    115         }
    116106       
    117107        return v;
    … …  
    127117        );
    128118
    129         if (port < (ioport16_t *) IO_SPACE_BOUNDARY) {
    130                 uintptr_t prt = (uintptr_t) port;
    131 
    132                 v = *((ioport16_t *) (IA64_IOSPACE_ADDRESS +
    133                     ((prt & 0xfff) | ((prt >> 2) << 12))));
    134         } else {
     119        if (port < (ioport16_t *) IO_SPACE_BOUNDARY)
     120                v = *((ioport16_t *) p2a(port));
     121        else
    135122                v = *port;
    136         }
    137123       
    138124        return v;
    … …  
    148134        );
    149135       
    150         if (port < (ioport32_t *) IO_SPACE_BOUNDARY) {
    151                 uintptr_t prt = (uintptr_t) port;
    152                
    153                 v = *((ioport32_t *) (IA64_IOSPACE_ADDRESS +
    154                     ((prt & 0xfff) | ((prt >> 2) << 12))));
    155         } else {
     136        if (port < (ioport32_t *) IO_SPACE_BOUNDARY)
     137                v = *((ioport32_t *) p2a(port));
     138        else
    156139                v = *port;
    157         }
    158140
    159141        return v;

  • kernel/arch/ia64/include/interrupt.h

    rbd5f3b7 r00aece0  
    6161#define IRQ_KBD    (0x01 + LEGACY_INTERRUPT_BASE)
    6262#define IRQ_MOUSE  (0x0c + LEGACY_INTERRUPT_BASE)
    63 #define IRQ_NE2000 (0x09 + LEGACY_INTERRUPT_BASE)
    6463
    6564/** General Exception codes. */

  • kernel/arch/ia64/include/mm/frame.h

    rbd5f3b7 r00aece0  
    4343#include <typedefs.h>
    4444
    45 extern uintptr_t last_frame;
     45extern uintptr_t end_of_identity;
    4646
    47 extern void frame_arch_init(void);
     47extern void frame_low_arch_init(void);
     48extern void frame_high_arch_init(void);
    4849#define physmem_print()
    4950

  • kernel/arch/ia64/include/mm/page.h

    rbd5f3b7 r00aece0  
    4343
    4444/** Bit width of the TLB-locked portion of kernel address space. */
    45 #define KERNEL_PAGE_WIDTH  28  /* 256M */
    46 #define IO_PAGE_WIDTH      26  /* 64M */
    47 #define FW_PAGE_WIDTH      28  /* 256M */
    48 
    49 #define USPACE_IO_PAGE_WIDTH  12  /* 4K */
    50 
    51 
    52 /*
    53  * Statically mapped IO spaces - offsets to 0xe...00 of virtual addresses
    54  * because of "minimal virtual bits implemented is 51" it is possible to
    55  * have values up to 0x0007000000000000
    56  */
    57 
    58 /* Firmware area (bellow 4GB in phys mem) */
    59 #define FW_OFFSET   0x00000000F0000000
    60 /* Legacy IO space */
    61 #define IO_OFFSET   0x0001000000000000
    62 /* Videoram - now mapped to 0 as VGA text mode vram on 0xb8000 */
    63 #define VIO_OFFSET  0x0002000000000000
    64 
     45#define KERNEL_PAGE_WIDTH       28      /* 256M */
    6546
    6647#define PPN_SHIFT  12

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

    rbd5f3b7 r00aece0  
    219219                 * self-sufficient.
    220220                 */
     221                sysinfo_set_item_val("fb", NULL, true);
    221222                sysinfo_set_item_val("fb.kind", NULL, 6);
    222223               

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

    rbd5f3b7 r00aece0  
    3434
    3535#include <arch.h>
    36 #include <arch/drivers/ski.h>
    37 #include <arch/drivers/it.h>
    38 #include <arch/interrupt.h>
    39 #include <arch/barrier.h>
    40 #include <arch/asm.h>
    41 #include <arch/register.h>
    4236#include <typedefs.h>
    43 #include <arch/context.h>
    44 #include <arch/stack.h>
    45 #include <arch/mm/page.h>
     37#include <errno.h>
    4638#include <interrupt.h>
    47 #include <mm/as.h>
    48 #include <config.h>
    4939#include <macros.h>
     40#include <str.h>
    5041#include <userspace.h>
    5142#include <console/console.h>
    52 #include <abi/proc/uarg.h>
    5343#include <syscall/syscall.h>
    54 #include <ddi/irq.h>
    55 #include <arch/bootinfo.h>
     44#include <sysinfo/sysinfo.h>
     45#include <arch/drivers/it.h>
     46#include <arch/drivers/kbd.h>
     47#include <arch/legacyio.h>
     48#include <genarch/drivers/ega/ega.h>
     49#include <genarch/drivers/i8042/i8042.h>
     50#include <genarch/drivers/ns16550/ns16550.h>
    5651#include <genarch/drivers/legacy/ia32/io.h>
    57 #include <genarch/drivers/ega/ega.h>
    5852#include <genarch/kbrd/kbrd.h>
    5953#include <genarch/srln/srln.h>
    60 #include <genarch/drivers/i8042/i8042.h>
    61 #include <genarch/drivers/ns16550/ns16550.h>
    62 #include <arch/drivers/kbd.h>
    63 #include <smp/smp.h>
    64 #include <smp/ipi.h>
    65 #include <arch/atomic.h>
    66 #include <panic.h>
    67 #include <print.h>
    68 #include <sysinfo/sysinfo.h>
    69 #include <str.h>
     54#include <mm/page.h>
     55#include <mm/km.h>
     56
     57#ifdef MACHINE_ski
     58#include <arch/drivers/ski.h>
     59#endif
    7060
    7161/* NS16550 as a COM 1 */
    … …  
    7565
    7666static uint64_t iosapic_base = 0xfec00000;
     67uintptr_t legacyio_virt_base = 0;
    7768
    7869/** Performs ia64-specific initialization before main_bsp() is called. */
    7970void arch_pre_main(void)
    8071{
    81         init.cnt = min3(bootinfo->taskmap.cnt, TASKMAP_MAX_RECORDS, CONFIG_INIT_TASKS);
     72        init.cnt = min3(bootinfo->taskmap.cnt, TASKMAP_MAX_RECORDS,
     73            CONFIG_INIT_TASKS);
    8274        size_t i;
     75
    8376        for (i = 0; i < init.cnt; i++) {
    84                 init.tasks[i].addr =
    85                     ((unsigned long) bootinfo->taskmap.tasks[i].addr) |
    86                     VRN_MASK;
     77                init.tasks[i].paddr =
     78                    (uintptr_t) bootinfo->taskmap.tasks[i].addr;
    8779                init.tasks[i].size = bootinfo->taskmap.tasks[i].size;
    8880                str_cpy(init.tasks[i].name, CONFIG_TASK_NAME_BUFLEN,
    … …  
    9385void arch_pre_mm_init(void)
    9486{
    95         /*
    96          * Set Interruption Vector Address (i.e. location of interruption vector
    97          * table).
    98          */
    99         iva_write((uintptr_t) &ivt);
    100         srlz_d();
    101        
    10287}
    10388
    10489static void iosapic_init(void)
    10590{
    106         uint64_t IOSAPIC = PA2KA((sysarg_t)(iosapic_base)) | FW_OFFSET;
     91        uintptr_t IOSAPIC = km_map(iosapic_base, PAGE_SIZE,
     92            PAGE_WRITE | PAGE_NOT_CACHEABLE);
    10793        int i;
    10894       
    … …  
    131117{
    132118        if (config.cpu_active == 1) {
     119                /* Map the page with legacy I/O. */
     120                legacyio_virt_base = km_map(LEGACYIO_PHYS_BASE, LEGACYIO_SIZE,
     121                    PAGE_WRITE | PAGE_NOT_CACHEABLE);
     122
    133123                iosapic_init();
    134124                irq_init(INR_COUNT, INR_COUNT);
    … …  
    198188        sysinfo_set_item_val("kbd.address.physical", NULL,
    199189            (uintptr_t) NS16550_BASE);
    200         sysinfo_set_item_val("kbd.address.kernel", NULL,
    201             (uintptr_t) NS16550_BASE);
    202190#endif
    203191       
    204192#ifdef CONFIG_I8042
    205         i8042_instance_t *i8042_instance = i8042_init((i8042_t *) I8042_BASE, IRQ_KBD);
     193        i8042_instance_t *i8042_instance = i8042_init((i8042_t *) I8042_BASE,
     194            IRQ_KBD);
    206195        if (i8042_instance) {
    207196                kbrd_instance_t *kbrd_instance = kbrd_init();
    … …  
    212201                }
    213202        }
    214        
    215         sysinfo_set_item_val("i8042", NULL, true);
    216         sysinfo_set_item_val("i8042.inr_a", NULL, IRQ_KBD);
    217         sysinfo_set_item_val("i8042.inr_b", NULL, IRQ_MOUSE);
    218         sysinfo_set_item_val("i8042.address.physical", NULL,
    219             (uintptr_t) I8042_BASE);
    220         sysinfo_set_item_val("i8042.address.kernel", NULL,
    221             (uintptr_t) I8042_BASE);
    222 #endif
    223 
    224         sysinfo_set_item_val("netif.ne2000.inr", NULL, IRQ_NE2000);
    225 
     203#endif
     204       
    226205        sysinfo_set_item_val("ia64_iospace", NULL, true);
    227206        sysinfo_set_item_val("ia64_iospace.address", NULL, true);
    228         sysinfo_set_item_val("ia64_iospace.address.virtual", NULL, IO_OFFSET);
     207        sysinfo_set_item_val("ia64_iospace.address.virtual", NULL, LEGACYIO_USER_BASE);
    229208}
    230209
    … …  
    269248 * We use r13 (a.k.a. tp) for this purpose.
    270249 */
    271 sysarg_t sys_tls_set(sysarg_t addr)
    272 {
    273         return 0;
     250sysarg_t sys_tls_set(uintptr_t addr)
     251{
     252        return EOK;
    274253}
    275254
    … …  
    277256{
    278257        pio_write_8((ioport8_t *)0x64, 0xfe);
    279         while (1)
    280                 ;
     258        while (1);
    281259}
    282260

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

    rbd5f3b7 r00aece0  
    5151#define MINCONF 1
    5252
    53 uintptr_t last_frame = 0;
     53uintptr_t end_of_identity = -1ULL;
    5454
    55 void frame_arch_init(void)
     55static void frame_common_arch_init(bool low)
    5656{
    57         if (config.cpu_active == 1) {
    58                 unsigned int i;
    59                 for (i = 0; i < bootinfo->memmap_items; i++) {
    60                         if (bootinfo->memmap[i].type == MEMMAP_FREE_MEM) {
    61                                 uint64_t base = bootinfo->memmap[i].base;
    62                                 uint64_t size = bootinfo->memmap[i].size;
    63                                 uint64_t abase = ALIGN_UP(base, FRAME_SIZE);
     57        unsigned int i;
    6458
    65                                 if (size > FRAME_SIZE)
    66                                         size -= abase - base;
     59        for (i = 0; i < bootinfo->memmap_items; i++) {
     60                if (bootinfo->memmap[i].type != MEMMAP_FREE_MEM)
     61                        continue;
    6762
    68                                 if (size > MIN_ZONE_SIZE) {
    69                                         zone_create(abase >> FRAME_WIDTH,
    70                                             size >> FRAME_WIDTH,
    71                                             max(MINCONF, abase >> FRAME_WIDTH),
    72                                             0);
    73                                 }
    74                                 if (abase + size > last_frame)
    75                                         last_frame = abase + size;
     63                uintptr_t base = bootinfo->memmap[i].base;
     64                size_t size = bootinfo->memmap[i].size;
     65                uintptr_t abase = ALIGN_UP(base, FRAME_SIZE);
     66
     67                if (size > FRAME_SIZE)
     68                        size -= abase - base;
     69
     70                if (!frame_adjust_zone_bounds(low, &abase, &size))
     71                        continue;
     72
     73                if (size > MIN_ZONE_SIZE) {
     74                        pfn_t pfn = ADDR2PFN(abase);
     75                        size_t count = SIZE2FRAMES(size);
     76
     77                        if (low) {
     78                                zone_create(pfn, count, max(MINCONF, pfn),
     79                                    ZONE_AVAILABLE | ZONE_LOWMEM);
     80                        } else {
     81                                pfn_t conf = zone_external_conf_alloc(count);
     82                                if (conf != 0)
     83                                        zone_create(pfn, count, conf,
     84                                            ZONE_AVAILABLE | ZONE_HIGHMEM);
    7685                        }
    7786                }
    78                
    79                 /*
    80                  * Blacklist ROM regions.
    81                  */
    82                 frame_mark_unavailable(ADDR2PFN(ROM_BASE),
    83                     SIZE2FRAMES(ROM_SIZE));
     87        }
     88}
    8489
    85                 frame_mark_unavailable(ADDR2PFN(KERNEL_RESERVED_AREA_BASE),
    86                     SIZE2FRAMES(KERNEL_RESERVED_AREA_SIZE));
    87         }       
     90void frame_low_arch_init(void)
     91{
     92        if (config.cpu_active > 1)
     93                return;
     94       
     95        frame_common_arch_init(true);
     96       
     97        /*
     98         * Blacklist ROM regions.
     99         */
     100        frame_mark_unavailable(ADDR2PFN(ROM_BASE),
     101            SIZE2FRAMES(ROM_SIZE));
     102
     103        frame_mark_unavailable(ADDR2PFN(KERNEL_RESERVED_AREA_BASE),
     104            SIZE2FRAMES(KERNEL_RESERVED_AREA_SIZE));
     105
     106        /* PA2KA will work only on low-memory. */
     107        end_of_identity = PA2KA(config.physmem_end - FRAME_SIZE) + PAGE_SIZE;
     108}
     109
     110void frame_high_arch_init(void)
     111{
     112        if (config.cpu_active > 1)
     113                return;
     114       
     115        frame_common_arch_init(false);
    88116}
    89117

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

    rbd5f3b7 r00aece0  
    255255}
    256256
    257 uintptr_t hw_map(uintptr_t physaddr, size_t size __attribute__ ((unused)))
    258 {
    259         /* THIS is a dirty hack. */
    260         return (uintptr_t)((uint64_t)(PA2KA(physaddr)) + VIO_OFFSET);
    261 }
    262 
    263257/** @}
    264258 */

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

    rbd5f3b7 r00aece0  
    5252#include <arch.h>
    5353#include <interrupt.h>
    54 
    55 #define IO_FRAME_BASE 0xFFFFC000000
     54#include <arch/legacyio.h>
    5655
    5756/** Invalidate all TLB entries. */
    … …  
    467466}
    468467
     468static bool is_kernel_fault(uintptr_t va)
     469{
     470        region_register_t rr;
     471
     472        rr.word = rr_read(VA2VRN(va));
     473        rid_t rid = rr.map.rid;
     474        return (RID2ASID(rid) == ASID_KERNEL) && (VA2VRN(va) == VRN_KERNEL);
     475}
     476
    469477/** Instruction TLB fault handler for faults with VHPT turned off.
    470478 *
    … …  
    480488        va = istate->cr_ifa; /* faulting address */
    481489       
    482         page_table_lock(AS, true);
     490        ASSERT(!is_kernel_fault(va));
     491
    483492        t = page_mapping_find(AS, va, true);
    484493        if (t) {
    … …  
    488497                 */
    489498                itc_pte_copy(t);
    490                 page_table_unlock(AS, true);
    491499        } else {
    492500                /*
    493501                 * Forward the page fault to address space page fault handler.
    494502                 */
    495                 page_table_unlock(AS, true);
    496503                if (as_page_fault(va, PF_ACCESS_EXEC, istate) == AS_PF_FAULT) {
    497504                        fault_if_from_uspace(istate, "Page fault at %p.",
    … …  
    522529static int try_memmap_io_insertion(uintptr_t va, istate_t *istate)
    523530{
    524         if ((va >= IO_OFFSET ) && (va < IO_OFFSET + (1 << IO_PAGE_WIDTH))) {
     531        if ((va >= LEGACYIO_USER_BASE) && (va < LEGACYIO_USER_BASE + (1 << LEGACYIO_PAGE_WIDTH))) {
    525532                if (TASK) {
    526                         uint64_t io_page = (va & ((1 << IO_PAGE_WIDTH) - 1)) >>
    527                             USPACE_IO_PAGE_WIDTH;
     533                        uint64_t io_page = (va & ((1 << LEGACYIO_PAGE_WIDTH) - 1)) >>
     534                            LEGACYIO_SINGLE_PAGE_WIDTH;
    528535                       
    529536                        if (is_io_page_accessible(io_page)) {
    530537                                uint64_t page, frame;
    531538                               
    532                                 page = IO_OFFSET +
    533                                     (1 << USPACE_IO_PAGE_WIDTH) * io_page;
    534                                 frame = IO_FRAME_BASE +
    535                                     (1 << USPACE_IO_PAGE_WIDTH) * io_page;
     539                                page = LEGACYIO_USER_BASE +
     540                                    (1 << LEGACYIO_SINGLE_PAGE_WIDTH) * io_page;
     541                                frame = LEGACYIO_PHYS_BASE +
     542                                    (1 << LEGACYIO_SINGLE_PAGE_WIDTH) * io_page;
    536543                               
    537544                                tlb_entry_t entry;
    … …  
    547554                                entry.ar = AR_READ | AR_WRITE;
    548555                                entry.ppn = frame >> PPN_SHIFT;
    549                                 entry.ps = USPACE_IO_PAGE_WIDTH;
     556                                entry.ps = LEGACYIO_SINGLE_PAGE_WIDTH;
    550557                               
    551558                                dtc_mapping_insert(page, TASK->as->asid, entry);
    … …  
    570577{
    571578        if (istate->cr_isr.sp) {
    572                 /* Speculative load. Deffer the exception
    573                    until a more clever approach can be used.
    574                   
    575                    Currently if we try to find the mapping
    576                    for the speculative load while in the kernel,
    577                    we might introduce a livelock because of
    578                    the possibly invalid values of the address. */
     579                /*
     580                 * Speculative load. Deffer the exception until a more clever
     581                 * approach can be used. Currently if we try to find the
     582                 * mapping for the speculative load while in the kernel, we
     583                 * might introduce a livelock because of the possibly invalid
     584                 * values of the address.
     585                 */
    579586                istate->cr_ipsr.ed = true;
    580587                return;
    … …  
    582589       
    583590        uintptr_t va = istate->cr_ifa;  /* faulting address */
    584        
    585         region_register_t rr;
    586         rr.word = rr_read(VA2VRN(va));
    587         rid_t rid = rr.map.rid;
    588         if (RID2ASID(rid) == ASID_KERNEL) {
    589                 if (VA2VRN(va) == VRN_KERNEL) {
     591        as_t *as = AS;
     592       
     593        if (is_kernel_fault(va)) {
     594                if (va < end_of_identity) {
    590595                        /*
    591                          * Provide KA2PA(identity) mapping for faulting piece of
    592                          * kernel address space.
     596                         * Create kernel identity mapping for low memory.
    593597                         */
    594598                        dtlb_kernel_mapping_insert(va, KA2PA(va), false, 0);
    595599                        return;
     600                } else {
     601                        as = AS_KERNEL;
    596602                }
    597603        }
    598604       
    599605       
    600         page_table_lock(AS, true);
    601         pte_t *entry = page_mapping_find(AS, va, true);
     606        pte_t *entry = page_mapping_find(as, va, true);
    602607        if (entry) {
    603608                /*
    … …  
    606611                 */
    607612                dtc_pte_copy(entry);
    608                 page_table_unlock(AS, true);
    609613        } else {
    610                 page_table_unlock(AS, true);
    611614                if (try_memmap_io_insertion(va, istate))
    612615                        return;
    … …  
    647650        uintptr_t va;
    648651        pte_t *t;
     652        as_t *as = AS;
    649653       
    650654        va = istate->cr_ifa;  /* faulting address */
    651655       
    652         page_table_lock(AS, true);
    653         t = page_mapping_find(AS, va, true);
     656        if (is_kernel_fault(va))
     657                as = AS_KERNEL;
     658
     659        t = page_mapping_find(as, va, true);
    654660        ASSERT((t) && (t->p));
    655661        if ((t) && (t->p) && (t->w)) {
    … …  
    667673                }
    668674        }
    669         page_table_unlock(AS, true);
    670675}
    671676
    … …  
    682687       
    683688        va = istate->cr_ifa;  /* faulting address */
    684        
    685         page_table_lock(AS, true);
     689
     690        ASSERT(!is_kernel_fault(va));
     691       
    686692        t = page_mapping_find(AS, va, true);
    687693        ASSERT((t) && (t->p));
    … …  
    700706                }
    701707        }
    702         page_table_unlock(AS, true);
    703708}
    704709
    … …  
    713718        uintptr_t va;
    714719        pte_t *t;
     720        as_t *as = AS;
    715721       
    716722        va = istate->cr_ifa;  /* faulting address */
    717723       
    718         page_table_lock(AS, true);
    719         t = page_mapping_find(AS, va, true);
     724        if (is_kernel_fault(va))
     725                as = AS_KERNEL;
     726
     727        t = page_mapping_find(as, va, true);
    720728        ASSERT((t) && (t->p));
    721729        if ((t) && (t->p)) {
    … …  
    733741                }
    734742        }
    735         page_table_unlock(AS, true);
    736743}
    737744
    … …  
    748755       
    749756        va = istate->cr_ifa;  /* faulting address */
     757
     758        ASSERT(!is_kernel_fault(va));
    750759       
    751760        /*
    752761         * Assume a write to a read-only page.
    753762         */
    754         page_table_lock(AS, true);
    755763        t = page_mapping_find(AS, va, true);
    756764        ASSERT((t) && (t->p));
    … …  
    761769                panic_memtrap(istate, PF_ACCESS_WRITE, va, NULL);
    762770        }
    763         page_table_unlock(AS, true);
    764771}
    765772
    … …  
    777784        va = istate->cr_ifa;  /* faulting address */
    778785       
    779         page_table_lock(AS, true);
     786        ASSERT(!is_kernel_fault(va));
     787
    780788        t = page_mapping_find(AS, va, true);
    781789        ASSERT(t);
    … …  
    790798                else
    791799                        dtc_pte_copy(t);
    792                 page_table_unlock(AS, true);
    793800        } else {
    794                 page_table_unlock(AS, true);
    795801                if (as_page_fault(va, PF_ACCESS_READ, istate) == AS_PF_FAULT) {
    796802                        fault_if_from_uspace(istate, "Page fault at %p.",

  • kernel/arch/ia64/src/start.S

    rbd5f3b7 r00aece0  
    3838#define KERNEL_TRANSLATION_I    0x0010000000000661
    3939#define KERNEL_TRANSLATION_D    0x0010000000000661
    40 #define KERNEL_TRANSLATION_VIO  0x0010000000000671
    41 #define KERNEL_TRANSLATION_IO   0x00100FFFFC000671
    42 #define KERNEL_TRANSLATION_FW   0x00100000F0000671
    4340
    4441.section K_TEXT_START, "ax"
    … …  
    8885        itr.d dtr[r0] = r10
    8986       
    90         movl r7 = 1
    91         movl r8 = (VRN_KERNEL << VRN_SHIFT) | VIO_OFFSET
    92         mov cr.ifa = r8
    93         movl r10 = (KERNEL_TRANSLATION_VIO)
    94         itr.d dtr[r7] = r10
    95        
    96         mov r11 = cr.itir
    97         movl r10 = ~0xfc
    98         and r10 = r10, r11
    99         movl r11 = (IO_PAGE_WIDTH << PS_SHIFT)
    100         or r10 = r10, r11
    101         mov cr.itir = r10
    102        
    103         movl r7 = 2
    104         movl r8 = (VRN_KERNEL << VRN_SHIFT) | IO_OFFSET
    105         mov cr.ifa = r8
    106         movl r10 = (KERNEL_TRANSLATION_IO)
    107         itr.d dtr[r7] = r10
    108        
    109         # Setup mapping for firmware area (also SAPIC)
    110        
    111         mov r11 = cr.itir
    112         movl r10 = ~0xfc
    113         and r10 = r10, r11
    114         movl r11 = (FW_PAGE_WIDTH << PS_SHIFT)
    115         or r10 = r10, r11
    116         mov cr.itir = r10
    117        
    118         movl r7 = 3
    119         movl r8 = (VRN_KERNEL << VRN_SHIFT) | FW_OFFSET
    120         mov cr.ifa = r8
    121         movl r10 = (KERNEL_TRANSLATION_FW)
    122         itr.d dtr[r7] = r10
    123        
    124         # Initialize DSR
     87        # Initialize DCR
    12588       
    12689        movl r10 = (DCR_DP_MASK | DCR_DK_MASK | DCR_DX_MASK | DCR_DR_MASK | DCR_DA_MASK | DCR_DD_MASK | DCR_LC_MASK)
    … …  
    156119         * Now we are paging.
    157120         */
     121
     122        #
     123        # Set Interruption Vector Address
     124        # (i.e. location of interruption vector table)
     125        #
     126        movl r8 = ivt ;;
     127        mov cr.iva = r8
     128        srlz.d ;;       
     129
    158130       
    159131        # Switch to register bank 1
    … …  
    167139       
    168140        #
    169         # Initialize memory stack to some sane value and allocate a scratch are
     141        # Initialize memory stack to some sane value and allocate a scratch area
    170142        # on it.
    171143        #

  • kernel/arch/mips32/Makefile.inc

    rbd5f3b7 r00aece0  
    6363        arch/$(KARCH)/src/debug/stacktrace.c \
    6464        arch/$(KARCH)/src/debug/stacktrace_asm.S \
     65        arch/$(KARCH)/src/mm/km.c \
    6566        arch/$(KARCH)/src/mm/frame.c \
    6667        arch/$(KARCH)/src/mm/page.c \

  • kernel/arch/mips32/include/mm/as.h

    rbd5f3b7 r00aece0  
    3939
    4040#define KERNEL_ADDRESS_SPACE_START_ARCH  UINT32_C(0x80000000)
    41 #define KERNEL_ADDRESS_SPACE_END_ARCH    UINT32_C(0x9fffffff)
     41#define KERNEL_ADDRESS_SPACE_END_ARCH    UINT32_C(0xffffffff)
    4242#define USER_ADDRESS_SPACE_START_ARCH    UINT32_C(0x00000000)
    4343#define USER_ADDRESS_SPACE_END_ARCH      UINT32_C(0x7fffffff)

  • kernel/arch/mips32/include/mm/frame.h

    rbd5f3b7 r00aece0  
    4141#ifndef __ASM__
    4242
    43 extern void frame_arch_init(void);
     43extern void frame_low_arch_init(void);
     44extern void frame_high_arch_init(void);
    4445extern void physmem_print(void);
    4546

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

    rbd5f3b7 r00aece0  
    3434
    3535#include <arch.h>
    36 #include <arch/cp0.h>
    37 #include <arch/exception.h>
    38 #include <arch/debug.h>
    39 #include <mm/as.h>
     36#include <typedefs.h>
     37#include <errno.h>
     38#include <interrupt.h>
     39#include <macros.h>
     40#include <str.h>
     41#include <memstr.h>
    4042#include <userspace.h>
    41 #include <memstr.h>
    42 #include <proc/thread.h>
    43 #include <abi/proc/uarg.h>
    44 #include <print.h>
    4543#include <console/console.h>
    4644#include <syscall/syscall.h>
    4745#include <sysinfo/sysinfo.h>
    48 #include <arch/interrupt.h>
    49 #include <interrupt.h>
    50 #include <console/chardev.h>
    51 #include <arch/barrier.h>
     46#include <arch/debug.h>
    5247#include <arch/debugger.h>
     48#include <arch/drivers/msim.h>
    5349#include <genarch/fb/fb.h>
    54 #include <abi/fb/visuals.h>
    5550#include <genarch/drivers/dsrln/dsrlnin.h>
    5651#include <genarch/drivers/dsrln/dsrlnout.h>
    5752#include <genarch/srln/srln.h>
    58 #include <macros.h>
    59 #include <config.h>
    60 #include <str.h>
    61 #include <arch/drivers/msim.h>
    62 #include <arch/asm/regname.h>
    6353
    6454/* Size of the code jumping to the exception handler code
    … …  
    8878        size_t i;
    8979        for (i = 0; i < init.cnt; i++) {
    90                 init.tasks[i].addr = (uintptr_t) bootinfo->tasks[i].addr;
     80                init.tasks[i].paddr = KA2PA(bootinfo->tasks[i].addr);
    9181                init.tasks[i].size = bootinfo->tasks[i].size;
    9282                str_cpy(init.tasks[i].name, CONFIG_TASK_NAME_BUFLEN,
    … …  
    206196        sysinfo_set_item_val("kbd", NULL, true);
    207197        sysinfo_set_item_val("kbd.inr", NULL, MSIM_KBD_IRQ);
    208         sysinfo_set_item_val("kbd.address.virtual", NULL, MSIM_KBD_ADDRESS);
     198        sysinfo_set_item_val("kbd.address.physical", NULL,
     199            PA2KA(MSIM_KBD_ADDRESS));
    209200#endif
    210201}
    … …  
    248239 * possible to have it separately in the future.
    249240 */
    250 sysarg_t sys_tls_set(sysarg_t addr)
    251 {
    252         return 0;
     241sysarg_t sys_tls_set(uintptr_t addr)
     242{
     243        return EOK;
    253244}
    254245

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

    rbd5f3b7 r00aece0  
    123123        for (i = 0; i < init.cnt; i++)
    124124                if (overlaps(frame << ZERO_PAGE_WIDTH, ZERO_PAGE_SIZE,
    125                     KA2PA(init.tasks[i].addr), init.tasks[i].size)) {
     125                    init.tasks[i].paddr, init.tasks[i].size)) {
    126126                        safe = false;
    127127                        break;
    … …  
    131131}
    132132
    133 static void frame_add_region(pfn_t start_frame, pfn_t end_frame)
    134 {
    135         if (end_frame > start_frame) {
    136                 /* Convert 1M frames to 16K frames */
    137                 pfn_t first = ADDR2PFN(start_frame << ZERO_PAGE_WIDTH);
    138                 pfn_t count = ADDR2PFN((end_frame - start_frame) << ZERO_PAGE_WIDTH);
    139                
     133static void frame_add_region(pfn_t start_frame, pfn_t end_frame, bool low)
     134{
     135        if (end_frame <= start_frame)
     136                return;
     137
     138        uintptr_t base = start_frame << ZERO_PAGE_WIDTH;
     139        size_t size = (end_frame - start_frame) << ZERO_PAGE_WIDTH;
     140
     141        if (!frame_adjust_zone_bounds(low, &base, &size))
     142                return;
     143
     144        pfn_t first = ADDR2PFN(base);
     145        size_t count = SIZE2FRAMES(size);
     146        pfn_t conf_frame;
     147
     148        if (low) {
    140149                /* Interrupt vector frame is blacklisted */
    141                 pfn_t conf_frame;
    142150                if (first == 0)
    143151                        conf_frame = 1;
    144152                else
    145153                        conf_frame = first;
    146                
    147                 zone_create(first, count, conf_frame, 0);
    148                
    149                 if (phys_regions_count < MAX_REGIONS) {
    150                         phys_regions[phys_regions_count].start = first;
    151                         phys_regions[phys_regions_count].count = count;
    152                         phys_regions_count++;
    153                 }
     154                zone_create(first, count, conf_frame,
     155                    ZONE_AVAILABLE | ZONE_LOWMEM);
     156        } else {
     157                conf_frame = zone_external_conf_alloc(count);
     158                if (conf_frame != 0)
     159                        zone_create(first, count, conf_frame,
     160                            ZONE_AVAILABLE | ZONE_HIGHMEM);
     161        }
     162       
     163        if (phys_regions_count < MAX_REGIONS) {
     164                phys_regions[phys_regions_count].start = first;
     165                phys_regions[phys_regions_count].count = count;
     166                phys_regions_count++;
    154167        }
    155168}
    … …  
    165178 *
    166179 */
    167 void frame_arch_init(void)
     180void frame_low_arch_init(void)
    168181{
    169182        ipl_t ipl = interrupts_disable();
    … …  
    224237               
    225238                if (!avail) {
    226                         frame_add_region(start_frame, frame);
     239                        frame_add_region(start_frame, frame, true);
    227240                        start_frame = frame + 1;
    228241                        avail = true;
    … …  
    230243        }
    231244       
    232         frame_add_region(start_frame, frame);
     245        frame_add_region(start_frame, frame, true);
    233246       
    234247        /* Blacklist interrupt vector frame */
    … …  
    246259}
    247260
     261void frame_high_arch_init(void)
     262{
     263}
    248264
    249265void physmem_print(void)

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

    rbd5f3b7 r00aece0  
    4141{
    4242        page_mapping_operations = &pt_mapping_operations;
    43 }
    44 
    45 /** Map device into kernel space
    46  * - on mips, all devices are already mapped into kernel space,
    47  *   translate the physical address to uncached area
    48  */
    49 uintptr_t hw_map(uintptr_t physaddr, size_t size)
    50 {
    51         return physaddr + 0xa0000000;
     43        as_switch(NULL, AS_KERNEL);
    5244}
    5345

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

    rbd5f3b7 r00aece0  
    9595       
    9696        badvaddr = cp0_badvaddr_read();
    97        
    98         mutex_lock(&AS->lock);
    9997        asid = AS->asid;
    100         mutex_unlock(&AS->lock);
    10198       
    10299        pte = find_mapping_and_check(badvaddr, PF_ACCESS_READ, istate, &pfrc);

  • kernel/arch/mips64/Makefile.inc

    rbd5f3b7 r00aece0  
    5555        arch/$(KARCH)/src/debug/stacktrace.c \
    5656        arch/$(KARCH)/src/debug/stacktrace_asm.S \
     57        arch/$(KARCH)/src/mm/km.c \
    5758        arch/$(KARCH)/src/mm/frame.c \
    5859        arch/$(KARCH)/src/mm/page.c \

  • kernel/arch/mips64/include/mm/frame.h

    rbd5f3b7 r00aece0  
    4141#ifndef __ASM__
    4242
    43 extern void frame_arch_init(void);
     43extern void frame_low_arch_init(void);
     44extern void frame_high_arch_init(void);
    4445extern void physmem_print(void);
    4546

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

    rbd5f3b7 r00aece0  
    3434
    3535#include <arch.h>
    36 #include <arch/cp0.h>
    37 #include <arch/exception.h>
    38 #include <arch/debug.h>
    39 #include <mm/as.h>
     36#include <typedefs.h>
     37#include <errno.h>
     38#include <interrupt.h>
     39#include <macros.h>
     40#include <str.h>
     41#include <memstr.h>
    4042#include <userspace.h>
    41 #include <memstr.h>
    42 #include <proc/thread.h>
    43 #include <abi/proc/uarg.h>
    44 #include <print.h>
    4543#include <console/console.h>
    4644#include <syscall/syscall.h>
    4745#include <sysinfo/sysinfo.h>
    48 #include <arch/interrupt.h>
    49 #include <interrupt.h>
    50 #include <console/chardev.h>
    51 #include <arch/barrier.h>
     46#include <arch/debug.h>
    5247#include <arch/debugger.h>
     48#include <arch/drivers/msim.h>
    5349#include <genarch/fb/fb.h>
    54 #include <abi/fb/visuals.h>
    5550#include <genarch/drivers/dsrln/dsrlnin.h>
    5651#include <genarch/drivers/dsrln/dsrlnout.h>
    5752#include <genarch/srln/srln.h>
    58 #include <macros.h>
    59 #include <config.h>
    60 #include <str.h>
    61 #include <arch/drivers/msim.h>
    62 #include <arch/asm/regname.h>
    6353
    6454/* Size of the code jumping to the exception handler code
    … …  
    8878        size_t i;
    8979        for (i = 0; i < init.cnt; i++) {
    90                 init.tasks[i].addr = (uintptr_t) bootinfo->tasks[i].addr;
     80                init.tasks[i].paddr = KA2PA(bootinfo->tasks[i].addr);
    9181                init.tasks[i].size = bootinfo->tasks[i].size;
    9282                str_cpy(init.tasks[i].name, CONFIG_TASK_NAME_BUFLEN,
    … …  
    226216 * possible to have it separately in the future.
    227217 */
    228 sysarg_t sys_tls_set(sysarg_t addr)
    229 {
    230         return 0;
     218sysarg_t sys_tls_set(uintptr_t addr)
     219{
     220        return EOK;
    231221}
    232222

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

    rbd5f3b7 r00aece0  
    115115        for (i = 0; i < init.cnt; i++)
    116116                if (overlaps(frame << ZERO_PAGE_WIDTH, ZERO_PAGE_SIZE,
    117                     KA2PA(init.tasks[i].addr), init.tasks[i].size)) {
     117                    init.tasks[i].paddr, init.tasks[i].size)) {
    118118                        safe = false;
    119119                        break;
    … …  
    123123}
    124124
    125 static void frame_add_region(pfn_t start_frame, pfn_t end_frame)
    126 {
    127         if (end_frame > start_frame) {
    128                 /* Convert 1M frames to 16K frames */
    129                 pfn_t first = ADDR2PFN(start_frame << ZERO_PAGE_WIDTH);
    130                 pfn_t count = ADDR2PFN((end_frame - start_frame) << ZERO_PAGE_WIDTH);
    131                
     125static void frame_add_region(pfn_t start_frame, pfn_t end_frame, bool low)
     126{
     127        if (end_frame <= start_frame)
     128                return;
     129
     130        uintptr_t base = start_frame << ZERO_PAGE_WIDTH;
     131        size_t size = (end_frame - start_frame) << ZERO_PAGE_WIDTH;
     132
     133        if (!frame_adjust_zone_bounds(low, &base, &size))
     134                return;
     135
     136        pfn_t first = ADDR2PFN(base);
     137        size_t count = SIZE2FRAMES(size);
     138        pfn_t conf_frame;
     139
     140        if (low) {
    132141                /* Interrupt vector frame is blacklisted */
    133                 pfn_t conf_frame;
    134142                if (first == 0)
    135143                        conf_frame = 1;
    136144                else
    137145                        conf_frame = first;
    138                
    139                 zone_create(first, count, conf_frame, 0);
    140                
    141                 if (phys_regions_count < MAX_REGIONS) {
    142                         phys_regions[phys_regions_count].start = first;
    143                         phys_regions[phys_regions_count].count = count;
    144                         phys_regions_count++;
    145                 }
     146                zone_create(first, count, conf_frame,
     147                    ZONE_AVAILABLE | ZONE_LOWMEM);
     148        } else {
     149                conf_frame = zone_external_conf_alloc(count);
     150                if (conf_frame != 0)
     151                        zone_create(first, count, conf_frame,
     152                            ZONE_AVAILABLE | ZONE_HIGHMEM);
     153        }
     154       
     155        if (phys_regions_count < MAX_REGIONS) {
     156                phys_regions[phys_regions_count].start = first;
     157                phys_regions[phys_regions_count].count = count;
     158                phys_regions_count++;
    146159        }
    147160}
    … …  
    156169 *
    157170 */
    158 void frame_arch_init(void)
     171void frame_low_arch_init(void)
    159172{
    160173        ipl_t ipl = interrupts_disable();
    … …  
    207220               
    208221                if (!avail) {
    209                         frame_add_region(start_frame, frame);
     222                        frame_add_region(start_frame, frame, true);
    210223                        start_frame = frame + 1;
    211224                        avail = true;
    … …  
    213226        }
    214227       
    215         frame_add_region(start_frame, frame);
     228        frame_add_region(start_frame, frame, true);
    216229       
    217230        /* Blacklist interrupt vector frame */
    … …  
    229242}
    230243
     244void frame_high_arch_init(void)
     245{
     246}
     247
    231248void physmem_print(void)
    232249{

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

    rbd5f3b7 r00aece0  
    4343}
    4444
    45 /** Map device into kernel space
    46  * - on mips, all devices are already mapped into kernel space,
    47  *   translate the physical address to uncached area
    48  */
    49 uintptr_t hw_map(uintptr_t physaddr, size_t size)
    50 {
    51         return physaddr + 0xffffffffa0000000;
    52 }
    53 
    5445/** @}
    5546 */

  • kernel/arch/ppc32/Makefile.inc

    rbd5f3b7 r00aece0  
    5252        arch/$(KARCH)/src/proc/scheduler.c \
    5353        arch/$(KARCH)/src/ddi/ddi.c \
     54        arch/$(KARCH)/src/mm/km.c \
    5455        arch/$(KARCH)/src/mm/as.c \
    5556        arch/$(KARCH)/src/mm/frame.c \

  • kernel/arch/ppc32/include/mm/frame.h

    rbd5f3b7 r00aece0  
    4444#include <trace.h>
    4545
    46 extern uintptr_t last_frame;
    47 
    4846NO_TRACE static inline uint32_t physmem_top(void)
    4947{
    … …  
    5856}
    5957
    60 extern void frame_arch_init(void);
     58extern void frame_low_arch_init(void);
     59extern void frame_high_arch_init(void);
    6160extern void physmem_print(void);
    6261

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

    rbd5f3b7 r00aece0  
    3434
    3535#include <arch/drivers/pic.h>
    36 #include <mm/page.h>
     36#include <mm/km.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 *) hw_map(base, size);
     44        pic = (uint32_t *) km_map(base, size, PAGE_WRITE | PAGE_NOT_CACHEABLE);
    4545        *cir = pic_ack_interrupt;
    4646        *cir_arg = NULL;

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

    rbd5f3b7 r00aece0  
    4040#include <print.h>
    4141
    42 uintptr_t last_frame = 0;
    4342memmap_t memmap;
    4443
    … …  
    5453}
    5554
    56 void frame_arch_init(void)
     55static void frame_common_arch_init(bool low)
    5756{
    5857        pfn_t minconf = 2;
    … …  
    6160        for (i = 0; i < memmap.cnt; i++) {
    6261                /* To be safe, make the available zone possibly smaller */
    63                 uintptr_t new_start = ALIGN_UP((uintptr_t) memmap.zones[i].start,
     62                uintptr_t base = ALIGN_UP((uintptr_t) memmap.zones[i].start,
    6463                    FRAME_SIZE);
    65                 size_t new_size = ALIGN_DOWN(memmap.zones[i].size -
    66                     (new_start - ((uintptr_t) memmap.zones[i].start)), FRAME_SIZE);
     64                size_t size = ALIGN_DOWN(memmap.zones[i].size -
     65                    (base - ((uintptr_t) memmap.zones[i].start)), FRAME_SIZE);
    6766               
    68                 pfn_t pfn = ADDR2PFN(new_start);
    69                 size_t count = SIZE2FRAMES(new_size);
    70                
     67                if (!frame_adjust_zone_bounds(low, &base, &size))
     68                        return;
     69
     70                pfn_t pfn = ADDR2PFN(base);
     71                size_t count = SIZE2FRAMES(size);
    7172                pfn_t conf;
    72                 if ((minconf < pfn) || (minconf >= pfn + count))
    73                         conf = pfn;
    74                 else
    75                         conf = minconf;
    76                
    77                 zone_create(pfn, count, conf, 0);
    78                
    79                 if (last_frame < ALIGN_UP(new_start + new_size, FRAME_SIZE))
    80                         last_frame = ALIGN_UP(new_start + new_size, FRAME_SIZE);
     73
     74                if (low) {
     75                        if ((minconf < pfn) || (minconf >= pfn + count))
     76                                conf = pfn;
     77                        else
     78                                conf = minconf;
     79                        zone_create(pfn, count, conf,
     80                            ZONE_AVAILABLE | ZONE_LOWMEM);
     81                } else {
     82                        conf = zone_external_conf_alloc(count);
     83                        if (conf != 0)
     84                                zone_create(pfn, count, conf,
     85                                    ZONE_AVAILABLE | ZONE_HIGHMEM);
     86                }
    8187        }
     88       
     89}
     90
     91void frame_low_arch_init(void)
     92{
     93        frame_common_arch_init(true);
    8294       
    8395        /* First is exception vector, second is 'implementation specific',
    … …  
    92104}
    93105
     106void frame_high_arch_init(void)
     107{
     108        frame_common_arch_init(false);
     109}
     110
    94111/** @}
    95112 */

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

    rbd5f3b7 r00aece0  
    4646}
    4747
    48 uintptr_t hw_map(uintptr_t physaddr, size_t size)
    49 {
    50         if (last_frame + ALIGN_UP(size, PAGE_SIZE) >
    51             KA2PA(KERNEL_ADDRESS_SPACE_END_ARCH))
    52                 panic("Unable to map physical memory %p (%zu bytes).",
    53                     (void *) physaddr, size);
    54        
    55         uintptr_t virtaddr = PA2KA(last_frame);
    56         pfn_t i;
    57         page_table_lock(AS_KERNEL, true);
    58         for (i = 0; i < ADDR2PFN(ALIGN_UP(size, PAGE_SIZE)); i++)
    59                 page_mapping_insert(AS_KERNEL, virtaddr + PFN2ADDR(i),
    60                     physaddr + PFN2ADDR(i), PAGE_NOT_CACHEABLE | PAGE_WRITE);
    61         page_table_unlock(AS_KERNEL, true);
    62        
    63         last_frame = ALIGN_UP(last_frame + size, FRAME_SIZE);
    64        
    65         return virtaddr;
    66 }
    67 
    6848/** @}
    6949 */

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

    rbd5f3b7 r00aece0  
    4646#include <userspace.h>
    4747#include <mm/page.h>
     48#include <mm/km.h>
    4849#include <abi/proc/uarg.h>
    4950#include <console/console.h>
    … …  
    7172        size_t i;
    7273        for (i = 0; i < init.cnt; i++) {
    73                 init.tasks[i].addr = (uintptr_t) bootinfo->taskmap.tasks[i].addr;
     74                init.tasks[i].paddr = KA2PA(bootinfo->taskmap.tasks[i].addr);
    7475                init.tasks[i].size = bootinfo->taskmap.tasks[i].size;
    7576                str_cpy(init.tasks[i].name, CONFIG_TASK_NAME_BUFLEN,
    … …  
    208209                size_t size = 2 * PAGE_SIZE;
    209210               
    210                 cuda_t *cuda = (cuda_t *)
    211                     (hw_map(aligned_addr, offset + size) + offset);
     211                cuda_t *cuda = (cuda_t *) (km_map(aligned_addr, offset + size,
     212                    PAGE_WRITE | PAGE_NOT_CACHEABLE) + offset);
    212213               
    213214                /* Initialize I/O controller */
    … …  
    231232                sysinfo_set_item_val("cuda.inr", NULL, IRQ_CUDA);
    232233                sysinfo_set_item_val("cuda.address.physical", NULL, pa);
    233                 sysinfo_set_item_val("cuda.address.kernel", NULL,
    234                     (uintptr_t) cuda);
    235234#endif
    236235        }

  • kernel/arch/sparc64/Makefile.inc

    rbd5f3b7 r00aece0  
    6868        arch/$(KARCH)/src/fpu_context.c \
    6969        arch/$(KARCH)/src/dummy.s \
     70        arch/$(KARCH)/src/mm/$(USARCH)/km.c \
    7071        arch/$(KARCH)/src/mm/$(USARCH)/as.c \
    7172        arch/$(KARCH)/src/mm/$(USARCH)/frame.c \

  • kernel/arch/sparc64/include/mm/sun4u/frame.h

    rbd5f3b7 r00aece0  
    7272typedef union frame_address frame_address_t;
    7373
    74 extern uintptr_t last_frame;
    7574extern uintptr_t end_of_identity;
    7675
    77 extern void frame_arch_init(void);
     76extern void frame_low_arch_init(void);
     77extern void frame_high_arch_init(void);
    7878#define physmem_print()
    7979

  • kernel/arch/sparc64/include/mm/sun4v/frame.h

    rbd5f3b7 r00aece0  
    4646#include <typedefs.h>
    4747
    48 extern uintptr_t last_frame;
    49 extern void frame_arch_init(void);
     48extern void frame_low_arch_init(void);
     49extern void frame_high_arch_init(void);
    5050#define physmem_print()
    5151

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

    rbd5f3b7 r00aece0  
    4040#include <mm/page.h>
    4141#include <arch/mm/page.h>
     42#include <mm/km.h>
    4243#include <typedefs.h>
    4344#include <align.h>
    … …  
    113114        size_t offset = pa - aligned_addr;
    114115       
    115         ns16550_t *ns16550 = (ns16550_t *)
    116            (hw_map(aligned_addr, offset + size) + offset);
     116        ns16550_t *ns16550 = (ns16550_t *) (km_map(aligned_addr, offset + size,
     117            PAGE_WRITE | PAGE_NOT_CACHEABLE) + offset);
    117118       
    118119        ns16550_instance_t *ns16550_instance = ns16550_init(ns16550, inr, cir, cir_arg);
    … …  
    132133        sysinfo_set_item_val("kbd", NULL, true);
    133134        sysinfo_set_item_val("kbd.inr", NULL, inr);
    134         sysinfo_set_item_val("kbd.address.kernel", NULL,
    135             (uintptr_t) ns16550);
    136135        sysinfo_set_item_val("kbd.address.physical", NULL, pa);
    137136        sysinfo_set_item_val("kbd.type.ns16550", NULL, true);

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

    rbd5f3b7 r00aece0  
    3939#include <genarch/ofw/upa.h>
    4040#include <arch/trap/interrupt.h>
    41 #include <mm/page.h>
     41#include <mm/km.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 *) hw_map(paddr, reg[SABRE_INTERNAL_REG].size);
     111        pci->reg = (uint64_t *) km_map(paddr, reg[SABRE_INTERNAL_REG].size,
     112            PAGE_WRITE | PAGE_NOT_CACHEABLE);
    112113
    113114        /*
    … …  
    156157        pci->model = PCI_PSYCHO;
    157158        pci->op = &pci_psycho_ops;
    158         pci->reg = (uint64_t *) hw_map(paddr, reg[PSYCHO_INTERNAL_REG].size);
     159        pci->reg = (uint64_t *) km_map(paddr, reg[PSYCHO_INTERNAL_REG].size,
     160            PAGE_WRITE | PAGE_NOT_CACHEABLE);
    159161
    160162        /*

  • kernel/arch/sparc64/src/mm/page.c

    rbd5f3b7 r00aece0  
    5151}
    5252
    53 /** Map memory-mapped device into virtual memory.
    54  *
    55  * We are currently using identity mapping for mapping device registers.
    56  *
    57  * @param physaddr Physical address of the page where the device is
    58  *                 located.
    59  * @param size     Size of the device's registers.
    60  *
    61  * @return Virtual address of the page where the device is mapped.
    62  *
    63  */
    64 uintptr_t hw_map(uintptr_t physaddr, size_t size)
    65 {
    66         return PA2KA(physaddr);
    67 }
    68 
    6953/** @}
    7054 */

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

    rbd5f3b7 r00aece0  
    4141#include <macros.h>
    4242
    43 uintptr_t last_frame = (uintptr_t) NULL;
    44 
    4543/** Create memory zones according to information stored in memmap.
    4644 *
    4745 * Walk the memory map and create frame zones according to it.
    4846 */
    49 void frame_arch_init(void)
     47static void frame_common_arch_init(bool low)
    5048{
    51         if (config.cpu_active == 1) {
    52                 unsigned int i;
     49        unsigned int i;
     50       
     51        for (i = 0; i < memmap.cnt; i++) {
     52                uintptr_t base;
     53                size_t size;
     54
     55                /*
     56                 * The memmap is created by HelenOS boot loader.
     57                 * It already contains no holes.
     58                 */
     59
     60                /* To be safe, make the available zone possibly smaller */
     61                base = ALIGN_UP((uintptr_t) memmap.zones[i].start, FRAME_SIZE);
     62                size = ALIGN_DOWN(memmap.zones[i].size -
     63                    (base - ((uintptr_t) memmap.zones[i].start)), FRAME_SIZE);
    5364               
    54                 for (i = 0; i < memmap.cnt; i++) {
    55                         /* To be safe, make the available zone possibly smaller */
    56                         uintptr_t new_start = ALIGN_UP((uintptr_t) memmap.zones[i].start,
    57                             FRAME_SIZE);
    58                         size_t new_size = ALIGN_DOWN(memmap.zones[i].size -
    59                             (new_start - ((uintptr_t) memmap.zones[i].start)), FRAME_SIZE);
    60                        
    61                         /*
    62                          * The memmap is created by HelenOS boot loader.
    63                          * It already contains no holes.
    64                          */
    65                        
    66                         pfn_t confdata = ADDR2PFN(new_start);
    67                        
     65                if (!frame_adjust_zone_bounds(low, &base, &size))
     66                        continue;
     67 
     68                pfn_t confdata;
     69                pfn_t pfn = ADDR2PFN(base);
     70                size_t count = SIZE2FRAMES(size);
     71
     72                if (low) {
     73                        confdata = pfn;
    6874                        if (confdata == ADDR2PFN(KA2PA(PFN2ADDR(0))))
    6975                                confdata = ADDR2PFN(KA2PA(PFN2ADDR(2)));
    7076                       
    71                         zone_create(ADDR2PFN(new_start), SIZE2FRAMES(new_size),
    72                             confdata, 0);
    73                        
    74                         last_frame = max(last_frame, new_start + new_size);
     77                        zone_create(pfn, count, confdata,
     78                            ZONE_AVAILABLE | ZONE_LOWMEM);
     79                } else {
     80                        confdata = zone_external_conf_alloc(count);
     81                        if (confdata != 0)
     82                                zone_create(pfn, count, confdata,
     83                                    ZONE_AVAILABLE | ZONE_HIGHMEM);
    7584                }
    76                
    77                 /*
    78                  * On sparc64, physical memory can start on a non-zero address.
    79                  * The generic frame_init() only marks PFN 0 as not free, so we
    80                  * must mark the physically first frame not free explicitly
    81                  * here, no matter what is its address.
    82                  */
    83                 frame_mark_unavailable(ADDR2PFN(KA2PA(PFN2ADDR(0))), 1);
    8485        }
     86}
     87
     88void frame_low_arch_init(void)
     89{
     90        if (config.cpu_active > 1)
     91                return;
    8592       
    86         end_of_identity = PA2KA(last_frame);
     93        frame_common_arch_init(true);
     94       
     95        /*
     96         * On sparc64, physical memory can start on a non-zero address.
     97         * The generic frame_init() only marks PFN 0 as not free, so we
     98         * must mark the physically first frame not free explicitly
     99         * here, no matter what is its address.
     100         */
     101        frame_mark_unavailable(ADDR2PFN(KA2PA(PFN2ADDR(0))), 1);
     102
     103        /* PA2KA will work only on low-memory. */
     104        end_of_identity = PA2KA(config.physmem_end - FRAME_SIZE) + PAGE_SIZE;
     105}
     106
     107void frame_high_arch_init(void)
     108{
     109        if (config.cpu_active > 1)
     110                return;
     111
     112        frame_common_arch_init(false);
    87113}
    88114

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

    rbd5f3b7 r00aece0  
    206206        pte_t *t;
    207207
    208         page_table_lock(AS, true);
    209208        t = page_mapping_find(AS, page_16k, true);
    210209        if (t && PTE_EXECUTABLE(t)) {
    … …  
    218217                itsb_pte_copy(t, index);
    219218#endif
    220                 page_table_unlock(AS, true);
    221219        } else {
    222220                /*
    … …  
    224222                 * handler.
    225223                 */
    226                 page_table_unlock(AS, true);
    227224                if (as_page_fault(page_16k, PF_ACCESS_EXEC, istate) ==
    228225                    AS_PF_FAULT) {
    … …  
    250247        size_t index;
    251248        pte_t *t;
     249        as_t *as = AS;
    252250
    253251        page_8k = (uint64_t) tag.vpn << MMU_PAGE_WIDTH;
    … …  
    261259                            "Dereferencing NULL pointer.");
    262260                } else if (page_8k >= end_of_identity) {
    263                         /*
    264                          * The kernel is accessing the I/O space.
    265                          * We still do identity mapping for I/O,
    266                          * but without caching.
    267                          */
    268                         dtlb_insert_mapping(page_8k, KA2PA(page_8k),
    269                             PAGESIZE_8K, false, false);
    270                         return;
     261                        /* Kernel non-identity. */
     262                        as = AS_KERNEL;
     263                } else {
     264                        do_fast_data_access_mmu_miss_fault(istate, tag,
     265                    "Unexpected kernel page fault.");
    271266                }
    272                 do_fast_data_access_mmu_miss_fault(istate, tag, "Unexpected "
    273                     "kernel page fault.");
    274         }
    275 
    276         page_table_lock(AS, true);
    277         t = page_mapping_find(AS, page_16k, true);
     267        }
     268
     269        t = page_mapping_find(as, page_16k, true);
    278270        if (t) {
    279271                /*
    … …  
    286278                dtsb_pte_copy(t, index, true);
    287279#endif
    288                 page_table_unlock(AS, true);
    289280        } else {
    290281                /*
    291282                 * Forward the page fault to the address space page fault
    292283                 * handler.
    293                  */             
    294                 page_table_unlock(AS, true);
     284                 */
    295285                if (as_page_fault(page_16k, PF_ACCESS_READ, istate) ==
    296286                    AS_PF_FAULT) {
    … …  
    314304        size_t index;
    315305        pte_t *t;
     306        as_t *as = AS;
    316307
    317308        page_16k = ALIGN_DOWN((uint64_t) tag.vpn << MMU_PAGE_WIDTH, PAGE_SIZE);
    318309        index = tag.vpn % MMU_PAGES_PER_PAGE;   /* 16K-page emulation */
    319310
    320         page_table_lock(AS, true);
    321         t = page_mapping_find(AS, page_16k, true);
     311        if (tag.context == ASID_KERNEL)
     312                as = AS_KERNEL;
     313
     314        t = page_mapping_find(as, page_16k, true);
    322315        if (t && PTE_WRITABLE(t)) {
    323316                /*
    … …  
    334327                dtsb_pte_copy(t, index, false);
    335328#endif
    336                 page_table_unlock(AS, true);
    337329        } else {
    338330                /*
    … …  
    340332                 * handler.
    341333                 */             
    342                 page_table_unlock(AS, true);
    343334                if (as_page_fault(page_16k, PF_ACCESS_WRITE, istate) ==
    344335                    AS_PF_FAULT) {

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

    rbd5f3b7 r00aece0  
    4545 * Walk the memory map and create frame zones according to it.
    4646 */
    47 void frame_arch_init(void)
     47static void frame_common_arch_init(bool low)
    4848{
    49         if (config.cpu_active == 1) {
    50                 unsigned int i;
     49        unsigned int i;
    5150               
    52                 for (i = 0; i < memmap.cnt; i++) {
    53                         /* To be safe, make the available zone possibly smaller */
    54                         uintptr_t new_start = ALIGN_UP((uintptr_t) memmap.zones[i].start,
    55                             FRAME_SIZE);
    56                         size_t new_size = ALIGN_DOWN(memmap.zones[i].size -
    57                             (new_start - ((uintptr_t) memmap.zones[i].start)), FRAME_SIZE);
    58                        
    59                         /*
    60                          * The memmap is created by HelenOS boot loader.
    61                          * It already contains no holes.
    62                          */
    63                        
    64                         pfn_t confdata = ADDR2PFN(new_start);
    65                        
     51        for (i = 0; i < memmap.cnt; i++) {
     52                uintptr_t base;
     53                size_t size;
     54
     55                /*
     56                 * The memmap is created by HelenOS boot loader.
     57                 * It already contains no holes.
     58                 */
     59
     60                /* To be safe, make the available zone possibly smaller */
     61                base = ALIGN_UP((uintptr_t) memmap.zones[i].start, FRAME_SIZE);
     62                size = ALIGN_DOWN(memmap.zones[i].size -
     63                    (base - ((uintptr_t) memmap.zones[i].start)), FRAME_SIZE);
     64               
     65                if (!frame_adjust_zone_bounds(low, &base, &size))
     66                        continue;
     67
     68                pfn_t confdata;
     69                pfn_t pfn = ADDR2PFN(base);
     70                size_t count = SIZE2FRAMES(size);
     71
     72                if (low) {
     73                        confdata = pfn;
    6674                        if (confdata == ADDR2PFN(KA2PA(PFN2ADDR(0))))
    6775                                confdata = ADDR2PFN(KA2PA(PFN2ADDR(2)));
    6876                       
    69                         zone_create(ADDR2PFN(new_start), SIZE2FRAMES(new_size),
    70                             confdata, 0);
     77                        zone_create(pfn, count, confdata,
     78                            ZONE_AVAILABLE | ZONE_LOWMEM);
     79                } else {
     80                        confdata = zone_external_conf_alloc(count);
     81                        if (confdata != 0)
     82                                zone_create(pfn, count, confdata,
     83                                    ZONE_AVAILABLE | ZONE_HIGHMEM);
    7184                }
    72                
    73                 /*
    74                  * On sparc64, physical memory can start on a non-zero address.
    75                  * The generic frame_init() only marks PFN 0 as not free, so we
    76                  * must mark the physically first frame not free explicitly
    77                  * here, no matter what is its address.
    78                  */
    79                 frame_mark_unavailable(ADDR2PFN(KA2PA(PFN2ADDR(0))), 1);
    8085        }
     86}
     87
     88
     89void frame_low_arch_init(void)
     90{
     91        if (config.cpu_active > 1)
     92                return;
     93
     94        frame_common_arch_init(true);
     95
     96        /*
     97         * On sparc64, physical memory can start on a non-zero address.
     98         * The generic frame_init() only marks PFN 0 as not free, so we
     99         * must mark the physically first frame not free explicitly
     100         * here, no matter what is its address.
     101         */
     102        frame_mark_unavailable(ADDR2PFN(KA2PA(PFN2ADDR(0))), 1);
     103}
     104
     105void frame_high_arch_init(void)
     106{
     107        if (config.cpu_active > 1)
     108                return;
     109
     110        frame_common_arch_init(false);
    81111}
    82112

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

    rbd5f3b7 r00aece0  
    218218        pte_t *t;
    219219
    220         page_table_lock(AS, true);
    221220        t = page_mapping_find(AS, va, true);
    222221
    … …  
    231230                itsb_pte_copy(t);
    232231#endif
    233                 page_table_unlock(AS, true);
    234232        } else {
    235233                /*
    … …  
    237235                 * handler.
    238236                 */
    239                 page_table_unlock(AS, true);
    240237                if (as_page_fault(va, PF_ACCESS_EXEC, istate) == AS_PF_FAULT) {
    241238                        do_fast_instruction_access_mmu_miss_fault(istate,
    … …  
    274271        }
    275272
    276         page_table_lock(AS, true);
    277273        t = page_mapping_find(AS, va, true);
    278274        if (t) {
    … …  
    286282                dtsb_pte_copy(t, true);
    287283#endif
    288                 page_table_unlock(AS, true);
    289284        } else {
    290285                /*
    … …  
    292287                 * handler.
    293288                 */             
    294                 page_table_unlock(AS, true);
    295289                if (as_page_fault(va, PF_ACCESS_READ, istate) == AS_PF_FAULT) {
    296290                        do_fast_data_access_mmu_miss_fault(istate, page_and_ctx,
    … …  
    316310        uint16_t ctx = DMISS_CONTEXT(page_and_ctx);
    317311
    318         page_table_lock(AS, true);
    319312        t = page_mapping_find(AS, va, true);
    320313        if (t && PTE_WRITABLE(t)) {
    … …  
    331324                dtsb_pte_copy(t, false);
    332325#endif
    333                 page_table_unlock(AS, true);
    334326        } else {
    335327                /*
    … …  
    337329                 * handler.
    338330                 */             
    339                 page_table_unlock(AS, true);
    340331                if (as_page_fault(va, PF_ACCESS_WRITE, istate) == AS_PF_FAULT) {
    341332                        do_fast_data_access_protection_fault(istate, page_and_ctx,

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

    rbd5f3b7 r00aece0  
    6262        size_t i;
    6363        for (i = 0; i < init.cnt; i++) {
    64                 init.tasks[i].addr = (uintptr_t) bootinfo->taskmap.tasks[i].addr;
     64                init.tasks[i].paddr = KA2PA(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

    rbd5f3b7 r00aece0  
    6464        size_t i;
    6565        for (i = 0; i < init.cnt; i++) {
    66                 init.tasks[i].addr = (uintptr_t) bootinfo->taskmap.tasks[i].addr;
     66                init.tasks[i].paddr = KA2PA(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,
Note: See TracChangeset for help on using the changeset viewer.