Changeset b7068da in mainline for kernel/arch


Ignore:
Timestamp:
2012-02-09T20:35:12Z (14 years ago)
Author:
Maurizio Lombardi <m.lombardi85@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
591762c6
Parents:
7cede12c (diff), 3d4750f (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:
22 added
75 edited

Legend:

Unmodified
Added
Removed

  • kernel/arch/abs32le/Makefile.inc

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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/interrupt.h

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    3434
    3535#include <arch.h>
    36 
    3736#include <typedefs.h>
    38 
    39 #include <config.h>
    40 
    41 #include <proc/thread.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>
     46#include <arch/drivers/i8254.h>
     47#include <arch/drivers/i8259.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>
    4255#include <genarch/multiboot/multiboot.h>
    4356#include <genarch/multiboot/multiboot2.h>
    44 #include <genarch/drivers/legacy/ia32/io.h>
    45 #include <genarch/drivers/ega/ega.h>
    46 #include <genarch/fb/bfb.h>
    47 #include <genarch/drivers/i8042/i8042.h>
    48 #include <genarch/kbrd/kbrd.h>
    49 #include <arch/drivers/i8254.h>
    50 #include <arch/drivers/i8259.h>
    51 #include <arch/boot/boot.h>
    5257
    5358#ifdef CONFIG_SMP
    5459#include <arch/smp/apic.h>
    5560#endif
    56 
    57 #include <arch/bios/bios.h>
    58 #include <arch/cpu.h>
    59 #include <print.h>
    60 #include <arch/cpuid.h>
    61 #include <genarch/acpi/acpi.h>
    62 #include <panic.h>
    63 #include <interrupt.h>
    64 #include <arch/syscall.h>
    65 #include <arch/debugger.h>
    66 #include <syscall/syscall.h>
    67 #include <console/console.h>
    68 #include <ddi/irq.h>
    69 #include <sysinfo/sysinfo.h>
    70 #include <memstr.h>
    7161
    7262/** Disable I/O on non-privileged levels
    … …  
    224214                }
    225215        }
    226        
    227         /*
    228          * This is the necessary evil until the userspace driver is entirely
    229          * self-sufficient.
    230          */
    231         sysinfo_set_item_val("i8042", NULL, true);
    232         sysinfo_set_item_val("i8042.inr_a", NULL, IRQ_KBD);
    233         sysinfo_set_item_val("i8042.inr_b", NULL, IRQ_MOUSE);
    234         sysinfo_set_item_val("i8042.address.physical", NULL,
    235             (uintptr_t) I8042_BASE);
    236         sysinfo_set_item_val("i8042.address.kernel", NULL,
    237             (uintptr_t) I8042_BASE);
    238216#endif
    239217       
    240218        if (irqs_info != NULL)
    241219                sysinfo_set_item_val(irqs_info, NULL, true);
    242        
    243         sysinfo_set_item_val("netif.ne2000.inr", NULL, IRQ_NE2000);
    244220}
    245221
    … …  
    264240 * we need not to go to CPL0 to read it.
    265241 */
    266 sysarg_t sys_tls_set(sysarg_t addr)
     242sysarg_t sys_tls_set(uintptr_t addr)
    267243{
    268244        THREAD->arch.tls = addr;
    269245        write_msr(AMD_MSR_FS, addr);
    270246       
    271         return 0;
     247        return EOK;
    272248}
    273249

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

    r7cede12c rb7068da  
    5555                .long MULTIBOOT2_TAG_MODULE
    5656                .long MULTIBOOT2_TAG_MEMMAP
     57#ifdef CONFIG_FB
    5758                .long MULTIBOOT2_TAG_FBINFO
     59#endif
    5860        tag_info_req_end:
    5961       
    … …  
    8587        tag_flags_end:
    8688       
     89#ifdef CONFIG_FB
    8790        /* Framebuffer tag */
    8891        tag_framebuffer_start:
    … …  
    9497                .long CONFIG_BFB_BPP
    9598        tag_framebuffer_end:
     99#endif
    96100       
    97101        /* Module alignment tag */

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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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;

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

    r7cede12c rb7068da  
    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
    … …  
    202206 * @param size          Place to store memory size.
    203207 */
    204 void gxemul_get_memory_extents(uintptr_t *start, uintptr_t *size)
     208void gxemul_get_memory_extents(uintptr_t *start, size_t *size)
    205209{
    206210        *start = 0;
    207         *size = *((uintptr_t *) (GXEMUL_MP_ADDRESS + GXEMUL_MP_MEMSIZE_OFFSET));
     211        *size = *((uintptr_t *) (GXEMUL_MP_ADDRESS + GXEMUL_MP_MEMSIZE_OFFSET));
    208212}
    209213

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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

  • kernel/arch/ia32/Makefile.inc

    r7cede12c rb7068da  
    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 \

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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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/multiboot2.S

    r7cede12c rb7068da  
    5353                .long MULTIBOOT2_TAG_MODULE
    5454                .long MULTIBOOT2_TAG_MEMMAP
     55#ifdef CONFIG_FB
    5556                .long MULTIBOOT2_TAG_FBINFO
     57#endif
    5658        tag_info_req_end:
    5759       
    … …  
    8385        tag_flags_end:
    8486       
     87#ifdef CONFIG_FB
    8588        /* Framebuffer tag */
    8689        tag_framebuffer_start:
    … …  
    9295                .long CONFIG_BFB_BPP
    9396        tag_framebuffer_end:
     97#endif
    9498       
    9599        /* Module alignment tag */

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

    r7cede12c rb7068da  
    374374                xor %ebx, %ebx
    375375                xor %edx, %edx
    376                 mov $0xffffffff, %edi
     376                xor %edi, %edi
    377377               
    378378                jz vesa_leave_real  /* force relative jump */

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

    r7cede12c rb7068da  
    3636
    3737#include <arch.h>
    38 
    3938#include <typedefs.h>
    40 
    41 #include <arch/pm.h>
    42 
     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>
     48#include <arch/drivers/i8254.h>
     49#include <arch/drivers/i8259.h>
     50#include <genarch/acpi/acpi.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>
    4356#include <genarch/multiboot/multiboot.h>
    4457#include <genarch/multiboot/multiboot2.h>
    45 #include <genarch/drivers/legacy/ia32/io.h>
    46 #include <genarch/drivers/ega/ega.h>
    47 #include <genarch/fb/bfb.h>
    48 #include <genarch/drivers/i8042/i8042.h>
    49 #include <genarch/kbrd/kbrd.h>
    50 #include <arch/drivers/i8254.h>
    51 #include <arch/drivers/i8259.h>
    52 
    53 #include <arch/context.h>
    54 
    55 #include <config.h>
    56 
    57 #include <arch/interrupt.h>
    58 #include <arch/asm.h>
    59 #include <genarch/acpi/acpi.h>
    60 
    61 #include <arch/bios/bios.h>
    62 
    63 #include <interrupt.h>
    64 #include <ddi/irq.h>
    65 #include <arch/debugger.h>
    66 #include <proc/thread.h>
    67 #include <syscall/syscall.h>
    68 #include <console/console.h>
    69 #include <sysinfo/sysinfo.h>
    70 #include <arch/boot/boot.h>
    71 #include <memstr.h>
    7258
    7359#ifdef CONFIG_SMP
    … …  
    182168                }
    183169        }
    184        
    185         /*
    186          * This is the necessary evil until the userspace driver is entirely
    187          * self-sufficient.
    188          */
    189         sysinfo_set_item_val("i8042", NULL, true);
    190         sysinfo_set_item_val("i8042.inr_a", NULL, IRQ_KBD);
    191         sysinfo_set_item_val("i8042.inr_b", NULL, IRQ_MOUSE);
    192         sysinfo_set_item_val("i8042.address.physical", NULL,
    193             (uintptr_t) I8042_BASE);
    194         sysinfo_set_item_val("i8042.address.kernel", NULL,
    195             (uintptr_t) I8042_BASE);
    196170#endif
    197171       
    198172        if (irqs_info != NULL)
    199173                sysinfo_set_item_val(irqs_info, NULL, true);
    200        
    201         sysinfo_set_item_val("netif.ne2000.inr", NULL, IRQ_NE2000);
    202174}
    203175
    … …  
    219191 * selector, and the descriptor->base is the correct address.
    220192 */
    221 sysarg_t sys_tls_set(sysarg_t addr)
     193sysarg_t sys_tls_set(uintptr_t addr)
    222194{
    223195        THREAD->arch.tls = addr;
    224196        set_tls_desc(addr);
    225197       
    226         return 0;
     198        return EOK;
    227199}
    228200

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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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/smp.c

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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/ia64.c

    r7cede12c rb7068da  
    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,
    … …  
    9789static void iosapic_init(void)
    9890{
    99         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);
    10093        int i;
    10194       
    … …  
    124117{
    125118        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
    126123                iosapic_init();
    127124                irq_init(INR_COUNT, INR_COUNT);
    … …  
    196193       
    197194#ifdef CONFIG_I8042
    198         i8042_instance_t *i8042_instance = i8042_init((i8042_t *) I8042_BASE, IRQ_KBD);
     195        i8042_instance_t *i8042_instance = i8042_init((i8042_t *) I8042_BASE,
     196            IRQ_KBD);
    199197        if (i8042_instance) {
    200198                kbrd_instance_t *kbrd_instance = kbrd_init();
    … …  
    205203                }
    206204        }
    207        
    208         sysinfo_set_item_val("i8042", NULL, true);
    209         sysinfo_set_item_val("i8042.inr_a", NULL, IRQ_KBD);
    210         sysinfo_set_item_val("i8042.inr_b", NULL, IRQ_MOUSE);
    211         sysinfo_set_item_val("i8042.address.physical", NULL,
    212             (uintptr_t) I8042_BASE);
    213         sysinfo_set_item_val("i8042.address.kernel", NULL,
    214             (uintptr_t) I8042_BASE);
    215 #endif
    216 
    217         sysinfo_set_item_val("netif.ne2000.inr", NULL, IRQ_NE2000);
    218 
     205#endif
     206       
    219207        sysinfo_set_item_val("ia64_iospace", NULL, true);
    220208        sysinfo_set_item_val("ia64_iospace.address", NULL, true);
    221         sysinfo_set_item_val("ia64_iospace.address.virtual", NULL, IO_OFFSET);
     209        sysinfo_set_item_val("ia64_iospace.address.virtual", NULL, LEGACYIO_USER_BASE);
    222210}
    223211
    … …  
    262250 * We use r13 (a.k.a. tp) for this purpose.
    263251 */
    264 sysarg_t sys_tls_set(sysarg_t addr)
    265 {
    266         return 0;
     252sysarg_t sys_tls_set(uintptr_t addr)
     253{
     254        return EOK;
    267255}
    268256
    … …  
    270258{
    271259        pio_write_8((ioport8_t *)0x64, 0xfe);
    272         while (1)
    273                 ;
     260        while (1);
    274261}
    275262

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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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)
    … …  
    174137        mov ar.bspstore = r8
    175138        loadrs
    176 
     139       
    177140        #
    178141        # Initialize memory stack to some sane value and allocate a scratch area
    … …  
    196159        srlz.i
    197160        srlz.d ;;
    198 
     161       
    199162        br.call.sptk.many b0 = arch_pre_main
    2001630:

  • kernel/arch/mips32/Makefile.inc

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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,
    … …  
    248238 * possible to have it separately in the future.
    249239 */
    250 sysarg_t sys_tls_set(sysarg_t addr)
    251 {
    252         return 0;
     240sysarg_t sys_tls_set(uintptr_t addr)
     241{
     242        return EOK;
    253243}
    254244

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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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 */

  • kernel/arch/sparc64/Makefile.inc

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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);

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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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

    r7cede12c rb7068da  
    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.