Changeset 48c1ef9 in mainline for arch/ppc64/src


Ignore:
Timestamp:
2006-05-21T20:38:18Z (20 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
040542aa
Parents:
bd55bbb
Message:

port ppc32 changes to ppc64 (raw)

Location:
arch/ppc64/src
Files:
9 edited
1 moved

Legend:

Unmodified
Added
Removed

  • arch/ppc64/src/asm.S

    rbd55bbb r48c1ef9  
    3131.text
    3232
     33.global userspace_asm
    3334.global iret
     35.global iret_syscall
    3436.global memsetb
    3537.global memcpy
     38.global memcpy_from_uspace
     39.global memcpy_to_uspace
     40.global memcpy_from_uspace_failover_address
     41.global memcpy_to_uspace_failover_address
     42
     43userspace_asm:
     44
     45        # r3 = uspace_uarg
     46        # r4 = stack
     47        # r5 = entry
     48       
     49        # disable interrupts
     50
     51        mfmsr r31
     52        rlwinm r31, r31, 0, 17, 15
     53        mtmsr r31
     54       
     55        # set entry point
     56       
     57        mtsrr0 r5
     58       
     59        # set problem state, enable interrupts
     60       
     61        ori r31, r31, msr_pr
     62        ori r31, r31, msr_ee
     63        mtsrr1 r31
     64       
     65        # set stack
     66       
     67        mr sp, r4
     68       
     69        # jump to userspace
     70       
     71        rfi
    3672
    3773iret:
    38         lwz r3, 144(sp)
    39         mtxer r3
    40        
    41         lwz r3, 140(sp)
    42         mtctr r3
    43        
    44         lwz r3, 136(sp)
    45         mtcr r3
    46        
    47         lwz r3, 132(sp)
    48         mtlr r3
    49        
    50         lwz r3, 128(sp)
    51         mtspr srr1, r3
    52        
    53         lwz r3, 124(sp)
    54         mtspr srr0, r3
    55        
    56         lwz r0, 0(sp)
    57         lwz r2, 4(sp)
    58         lwz r3, 8(sp)
    59         lwz r4, 12(sp)
    60         lwz r5, 16(sp)
    61         lwz r6, 20(sp)
    62         lwz r7, 24(sp)
    63         lwz r8, 28(sp)
    64         lwz r9, 32(sp)
    65         lwz r10, 36(sp)
    66         lwz r11, 40(sp)
    67         lwz r12, 44(sp)
    68         lwz r13, 48(sp)
    69         lwz r14, 52(sp)
    70         lwz r15, 56(sp)
    71         lwz r16, 60(sp)
    72         lwz r17, 64(sp)
    73         lwz r18, 68(sp)
    74         lwz r19, 72(sp)
    75         lwz r20, 76(sp)
    76         lwz r21, 80(sp)
    77         lwz r22, 84(sp)
    78         lwz r23, 88(sp)
    79         lwz r24, 92(sp)
    80         lwz r25, 96(sp)
    81         lwz r26, 100(sp)
    82         lwz r27, 104(sp)
    83         lwz r28, 108(sp)
    84         lwz r29, 112(sp)
    85         lwz r30, 116(sp)
    86         lwz r31, 120(sp)
    87        
    88         mfspr sp, sprg1
    89        
     74       
     75        # disable interrupts
     76       
     77        mfmsr r31
     78        rlwinm r31, r31, 0, 17, 15
     79        mtmsr r31
     80       
     81        lwz r0, 8(sp)
     82        lwz r2, 12(sp)
     83        lwz r3, 16(sp)
     84        lwz r4, 20(sp)
     85        lwz r5, 24(sp)
     86        lwz r6, 28(sp)
     87        lwz r7, 32(sp)
     88        lwz r8, 36(sp)
     89        lwz r9, 40(sp)
     90        lwz r10, 44(sp)
     91        lwz r11, 48(sp)
     92        lwz r13, 52(sp)
     93        lwz r14, 56(sp)
     94        lwz r15, 60(sp)
     95        lwz r16, 64(sp)
     96        lwz r17, 68(sp)
     97        lwz r18, 72(sp)
     98        lwz r19, 76(sp)
     99        lwz r20, 80(sp)
     100        lwz r21, 84(sp)
     101        lwz r22, 88(sp)
     102        lwz r23, 92(sp)
     103        lwz r24, 96(sp)
     104        lwz r25, 100(sp)
     105        lwz r26, 104(sp)
     106        lwz r27, 108(sp)
     107        lwz r28, 112(sp)
     108        lwz r29, 116(sp)
     109        lwz r30, 120(sp)
     110        lwz r31, 124(sp)
     111       
     112        lwz r12, 128(sp)
     113        mtcr r12
     114       
     115        lwz r12, 132(sp)
     116        mtsrr0 r12
     117       
     118        lwz r12, 136(sp)
     119        mtsrr1 r12
     120       
     121        lwz r12, 140(sp)
     122        mtlr r12
     123       
     124        lwz r12, 144(sp)
     125        mtctr r12
     126       
     127        lwz r12, 148(sp)
     128        mtxer r12
     129       
     130        lwz r12, 152(sp)
     131        lwz sp, 156(sp)
     132       
     133        rfi
     134
     135iret_syscall:
     136       
     137        # reset decrementer
     138
     139        li r31, 1000
     140        mtdec r31
     141       
     142        # disable interrupts
     143       
     144        mfmsr r31
     145        rlwinm r31, r31, 0, 17, 15
     146        mtmsr r31
     147       
     148        lwz r0, 8(sp)
     149        lwz r2, 12(sp)
     150        lwz r4, 20(sp)
     151        lwz r5, 24(sp)
     152        lwz r6, 28(sp)
     153        lwz r7, 32(sp)
     154        lwz r8, 36(sp)
     155        lwz r9, 40(sp)
     156        lwz r10, 44(sp)
     157        lwz r11, 48(sp)
     158        lwz r13, 52(sp)
     159        lwz r14, 56(sp)
     160        lwz r15, 60(sp)
     161        lwz r16, 64(sp)
     162        lwz r17, 68(sp)
     163        lwz r18, 72(sp)
     164        lwz r19, 76(sp)
     165        lwz r20, 80(sp)
     166        lwz r21, 84(sp)
     167        lwz r22, 88(sp)
     168        lwz r23, 92(sp)
     169        lwz r24, 96(sp)
     170        lwz r25, 100(sp)
     171        lwz r26, 104(sp)
     172        lwz r27, 108(sp)
     173        lwz r28, 112(sp)
     174        lwz r29, 116(sp)
     175        lwz r30, 120(sp)
     176        lwz r31, 124(sp)
     177       
     178        lwz r12, 128(sp)
     179        mtcr r12
     180       
     181        lwz r12, 132(sp)
     182        mtsrr0 r12
     183       
     184        lwz r12, 136(sp)
     185        mtsrr1 r12
     186       
     187        lwz r12, 140(sp)
     188        mtlr r12
     189       
     190        lwz r12, 144(sp)
     191        mtctr r12
     192       
     193        lwz r12, 148(sp)
     194        mtxer r12
     195       
     196        lwz r12, 152(sp)
     197        lwz sp, 156(sp)
     198
    90199        rfi
    91200       
    … …  
    134243
    135244memcpy:
     245memcpy_from_uspace:
     246memcpy_to_uspace:
     247
    136248        srwi. r7, r5, 3
    137249        addi r6, r3, -4
    … …  
    194306        mtctr r7
    195307        b 1b
     308
     309memcpy_from_uspace_failover_address:
     310memcpy_to_uspace_failover_address:
     311        b memcpy_from_uspace_failover_address

  • arch/ppc64/src/boot/boot.S

    rbd55bbb r48c1ef9  
    3535kernel_image_start:
    3636
    37         # load temporary stack
     37        # load temporal kernel stack
    3838       
    39         lis sp, end_stack@ha
    40         addi sp, sp, end_stack@l
     39        lis sp, kernel_stack@ha
     40        addi sp, sp, kernel_stack@l
     41       
     42        # set kernel stack for interrupt handling
     43       
     44        mr r31, sp
     45        subis r31, r31, 0x8000
     46        mtsprg0 r31
    4147       
    4248        # r3 contains physical address of bootinfo_t
    4349        # r4 contains size of bootinfo_t
    4450       
    45         lis r31, 0x80000000@ha
    46         addi r31, r31, 0x80000000@l
    47        
    48         add r3, r3, r31
     51        addis r3, r3, 0x8000
    4952
    5053        lis r31, bootinfo@ha
    … …  
    6871        bootinfo_end:
    6972       
     73        bl arch_pre_main
    7074        b main_bsp
    7175
    7276.section K_DATA_START, "aw", @progbits
    7377
     78.align 12
     79kernel_stack_bottom:
    7480        .space TEMP_STACK_SIZE
    75 end_stack:
     81kernel_stack:

  • arch/ppc64/src/dummy.s

    rbd55bbb r48c1ef9  
    2929.text
    3030
    31 .global cpu_halt
    3231.global asm_delay_loop
    33 .global userspace
    3432.global sys_tls_set
    35 .global tlb_invalidate_all
    36 .global tlb_invalidate_asid
    37 .global tlb_invalidate_pages
    38 
    39 cpu_halt:
    40         b cpu_halt
    41 
    42 tlb_invalidate_all:
    43         b tlb_invalidate_all
    44 
    45 tlb_invalidate_asid:
    46         b tlb_invalidate_asid
    47 
    48 tlb_invalidate_pages:
    49         b tlb_invalidate_pages
    50 
    51 userspace:
    52         b userspace
    5333
    5434sys_tls_set:

  • arch/ppc64/src/exception.S

    rbd55bbb r48c1ef9  
    3232.section K_UNMAPPED_TEXT_START, "ax"
    3333
     34.macro CONTEXT_STORE
     35       
     36        # save R12 in SPRG1, backup CR in R12
     37        # save SP in SPRG2
     38
     39        mtsprg1 r12
     40        mfcr r12
     41        mtsprg2 sp
     42       
     43        # check whether SP is in kernel
     44       
     45        andis. sp, sp, 0x8000
     46        bne 1f
     47       
     48                # stack is in user-space
     49               
     50                mfsprg0 sp
     51       
     52        b 2f
     53       
     54        1:
     55       
     56                # stack is in kernel
     57               
     58                mfsprg2 sp
     59                subis sp, sp, 0x8000
     60       
     61        2:
     62       
     63        subi sp, sp, 160
     64        stw r0, 8(sp)
     65        stw r2, 12(sp)
     66        stw r3, 16(sp)
     67        stw r4, 20(sp)
     68        stw r5, 24(sp)
     69        stw r6, 28(sp)
     70        stw r7, 32(sp)
     71        stw r8, 36(sp)
     72        stw r9, 40(sp)
     73        stw r10, 44(sp)
     74        stw r11, 48(sp)
     75        stw r13, 52(sp)
     76        stw r14, 56(sp)
     77        stw r15, 60(sp)
     78        stw r16, 64(sp)
     79        stw r17, 68(sp)
     80        stw r18, 72(sp)
     81        stw r19, 76(sp)
     82        stw r20, 80(sp)
     83        stw r21, 84(sp)
     84        stw r22, 88(sp)
     85        stw r23, 92(sp)
     86        stw r24, 96(sp)
     87        stw r25, 100(sp)
     88        stw r26, 104(sp)
     89        stw r27, 108(sp)
     90        stw r28, 112(sp)
     91        stw r29, 116(sp)
     92        stw r30, 120(sp)
     93        stw r31, 124(sp)
     94       
     95        stw r12, 128(sp)
     96       
     97        mfsrr0 r12
     98        stw r12, 132(sp)
     99       
     100        mfsrr1 r12
     101        stw r12, 136(sp)
     102       
     103        mflr r12
     104        stw r12, 140(sp)
     105       
     106        mfctr r12
     107        stw r12, 144(sp)
     108       
     109        mfxer r12
     110        stw r12, 148(sp)
     111       
     112        mfsprg1 r12
     113        stw r12, 152(sp)
     114       
     115        mfsprg2 r12
     116        stw r12, 156(sp)
     117.endm
     118
     119.org 0x060
     120jump_to_kernel:
     121        lis r12, iret@ha
     122        addi r12, r12, iret@l
     123        mtlr r12
     124
     125        mfmsr r12
     126        ori r12, r12, (msr_ir | msr_dr)@l
     127        mtsrr1 r12
     128       
     129        addis sp, sp, 0x8000
     130        mr r4, sp
     131        addi r4, r4, 8
     132       
     133        rfi
     134
     135jump_to_kernel_syscall:
     136        lis r12, syscall_handler@ha
     137        addi r12, r12, syscall_handler@l
     138        mtsrr0 r12
     139       
     140        lis r12, iret_syscall@ha
     141        addi r12, r12, iret_syscall@l
     142        mtlr r12
     143
     144        mfmsr r12
     145        ori r12, r12, (msr_ir | msr_dr)@l
     146        mtsrr1 r12
     147       
     148        addis sp, sp, 0x8000
     149        rfi
     150
    34151.org 0x100
    35152.global exc_system_reset
    … …  
    45162.global exc_data_storage
    46163exc_data_storage:
    47         b exc_data_storage
    48 
    49 .org 0x380
    50 .global exc_data_segment
    51 exc_data_segment:
    52         b exc_data_segment
     164        CONTEXT_STORE
     165       
     166        lis r12, pht_refill@ha
     167        addi r12, r12, pht_refill@l
     168        mtsrr0 r12
     169       
     170        li r3, 1
     171        b jump_to_kernel
    53172
    54173.org 0x400
    55174.global exc_instruction_storage
    56175exc_instruction_storage:
    57         b exc_instruction_storage
    58 
    59 .org 0x480
    60 .global exc_instruction_segment
    61 exc_instruction_segment:
    62         b exc_instruction_segment
     176        CONTEXT_STORE
     177       
     178        lis r12, pht_refill@ha
     179        addi r12, r12, pht_refill@l
     180        mtsrr0 r12
     181       
     182        li r3, 0
     183        b jump_to_kernel
    63184
    64185.org 0x500
    … …  
    85206.global exc_decrementer
    86207exc_decrementer:
    87         mtspr sprg1, sp
    88        
    89         subis sp, sp, 0x8000
    90        
    91         subi sp, sp, 144
    92         stw r0, 0(sp)
    93         stw r2, 4(sp)
    94         stw r3, 8(sp)
    95         stw r4, 12(sp)
    96         stw r5, 16(sp)
    97         stw r6, 20(sp)
    98         stw r7, 24(sp)
    99         stw r8, 28(sp)
    100         stw r9, 32(sp)
    101         stw r10, 36(sp)
    102         stw r11, 40(sp)
    103         stw r12, 44(sp)
    104         stw r13, 48(sp)
    105         stw r14, 52(sp)
    106         stw r15, 56(sp)
    107         stw r16, 60(sp)
    108         stw r17, 64(sp)
    109         stw r18, 68(sp)
    110         stw r19, 72(sp)
    111         stw r20, 76(sp)
    112         stw r21, 80(sp)
    113         stw r22, 84(sp)
    114         stw r23, 88(sp)
    115         stw r24, 92(sp)
    116         stw r25, 96(sp)
    117         stw r26, 100(sp)
    118         stw r27, 104(sp)
    119         stw r28, 108(sp)
    120         stw r29, 112(sp)
    121         stw r30, 116(sp)
    122         stw r31, 120(sp)
    123        
    124         mfspr r3, srr0
    125         stw r3, 124(sp)
    126        
    127         mfspr r3, srr1
    128         stw r3, 128(sp)
    129        
    130         mflr r3
    131         stw r3, 132(sp)
    132        
    133         mfcr r3
    134         stw r3, 136(sp)
    135        
    136         mfctr r3
    137         stw r3, 140(sp)
    138        
    139         mfxer r3
    140         stw r3, 144(sp)
    141 
    142         lis r3, exc_dispatch@ha
    143         addi r3, r3, exc_dispatch@l
    144         mtspr srr0, r3
    145        
    146         mfmsr r3
    147         ori r3, r3, (msr_ir | msr_dr)@l
    148         mtspr srr1, r3
    149        
    150         lis r3, iret@ha
    151         addi r3, r3, iret@l
    152         mtlr r3
    153        
    154         addis sp, sp, 0x8000
     208        CONTEXT_STORE
     209
     210        lis r12, exc_dispatch@ha
     211        addi r12, r12, exc_dispatch@l
     212        mtsrr0 r12
     213       
    155214        li r3, 10
    156         rfid
     215        b jump_to_kernel
    157216
    158217.org 0xa00
    … …  
    169228.global exc_syscall
    170229exc_syscall:
    171         b exc_syscall
     230        CONTEXT_STORE   
     231       
     232        b jump_to_kernel_syscall
    172233
    173234.org 0xd00

  • arch/ppc64/src/interrupt.c

    rbd55bbb r48c1ef9  
    3232#include <arch.h>
    3333#include <time/clock.h>
    34 #include <print.h>
     34#include <ipc/sysipc.h>
    3535
    3636
    … …  
    3939        asm volatile (
    4040                "mtdec %0\n"
    41                 :: "r" (1000)
     41                :
     42                : "r" (1000)
    4243        );
    4344}
    … …  
    5657        exc_register(VECTOR_DECREMENTER, "timer", exception_decrementer);
    5758}
     59
     60
     61/* Reregister irq to be IPC-ready */
     62void irq_ipc_bind_arch(__native irq)
     63{
     64        panic("not implemented\n");
     65        /* TODO */
     66}

  • arch/ppc64/src/mm/memory_init.c

    rbd55bbb r48c1ef9  
    4444       
    4545        for (i = 0; i < bootinfo.memmap.count; i++)
    46                 printf("base: %p size: %#x\n", bootinfo.memmap.zones[i].start, bootinfo.memmap.zones[i].size);
     46                printf("base: %#x size: %#x\n", bootinfo.memmap.zones[i].start, bootinfo.memmap.zones[i].size);
    4747}

  • arch/ppc64/src/mm/page.c

    rbd55bbb r48c1ef9  
    3030#include <genarch/mm/page_pt.h>
    3131#include <arch/mm/frame.h>
     32#include <arch/asm.h>
    3233#include <mm/frame.h>
    3334#include <mm/page.h>
     35#include <mm/as.h>
     36#include <arch.h>
    3437#include <arch/types.h>
     38#include <arch/exception.h>
     39#include <align.h>
     40#include <config.h>
     41#include <print.h>
     42#include <symtab.h>
     43
     44static phte_t *phte;
     45
     46
     47/** Try to find PTE for faulting address
     48 *
     49 * Try to find PTE for faulting address.
     50 * The as->lock must be held on entry to this function
     51 * if lock is true.
     52 *
     53 * @param as       Address space.
     54 * @param lock     Lock/unlock the address space.
     55 * @param badvaddr Faulting virtual address.
     56 * @param istate   Pointer to interrupted state.
     57 * @param pfrc     Pointer to variable where as_page_fault() return code will be stored.
     58 * @return         PTE on success, NULL otherwise.
     59 *
     60 */
     61static pte_t *find_mapping_and_check(as_t *as, bool lock, __address badvaddr, istate_t *istate, int *pfcr)
     62{
     63        /*
     64         * Check if the mapping exists in page tables.
     65         */     
     66        pte_t *pte = page_mapping_find(as, badvaddr);
     67        if ((pte) && (pte->p)) {
     68                /*
     69                 * Mapping found in page tables.
     70                 * Immediately succeed.
     71                 */
     72                return pte;
     73        } else {
     74                int rc;
     75       
     76                /*
     77                 * Mapping not found in page tables.
     78                 * Resort to higher-level page fault handler.
     79                 */
     80                page_table_unlock(as, lock);
     81                switch (rc = as_page_fault(badvaddr, istate)) {
     82                        case AS_PF_OK:
     83                                /*
     84                                 * The higher-level page fault handler succeeded,
     85                                 * The mapping ought to be in place.
     86                                 */
     87                                page_table_lock(as, lock);
     88                                pte = page_mapping_find(as, badvaddr);
     89                                ASSERT((pte) && (pte->p));
     90                                return pte;
     91                        case AS_PF_DEFER:
     92                                page_table_lock(as, lock);
     93                                *pfcr = rc;
     94                                return NULL;
     95                        case AS_PF_FAULT:
     96                                page_table_lock(as, lock);
     97                                printf("Page fault.\n");
     98                                *pfcr = rc;
     99                                return NULL;
     100                        default:
     101                                panic("unexpected rc (%d)\n", rc);
     102                }       
     103        }
     104}
     105
     106
     107static void pht_refill_fail(__address badvaddr, istate_t *istate)
     108{
     109        char *symbol = "";
     110        char *sym2 = "";
     111
     112        char *s = get_symtab_entry(istate->pc);
     113        if (s)
     114                symbol = s;
     115        s = get_symtab_entry(istate->lr);
     116        if (s)
     117                sym2 = s;
     118        panic("%p: PHT Refill Exception at %p (%s<-%s)\n", badvaddr, istate->pc, symbol, sym2);
     119}
     120
     121
     122static void pht_insert(const __address vaddr, const pfn_t pfn)
     123{
     124        __u32 page = (vaddr >> 12) & 0xffff;
     125        __u32 api = (vaddr >> 22) & 0x3f;
     126        __u32 vsid;
     127       
     128        asm volatile (
     129                "mfsrin %0, %1\n"
     130                : "=r" (vsid)
     131                : "r" (vaddr)
     132        );
     133       
     134        /* Primary hash (xor) */
     135        __u32 h = 0;
     136        __u32 hash = vsid ^ page;
     137        __u32 base = (hash & 0x3ff) << 3;
     138        __u32 i;
     139        bool found = false;
     140       
     141        /* Find unused or colliding
     142           PTE in PTEG */
     143        for (i = 0; i < 8; i++) {
     144                if ((!phte[base + i].v) || ((phte[base + i].vsid == vsid) && (phte[base + i].api == api))) {
     145                        found = true;
     146                        break;
     147                }
     148        }
     149       
     150        if (!found) {
     151                /* Secondary hash (not) */
     152                __u32 base2 = (~hash & 0x3ff) << 3;
     153               
     154                /* Find unused or colliding
     155                   PTE in PTEG */
     156                for (i = 0; i < 8; i++) {
     157                        if ((!phte[base2 + i].v) || ((phte[base2 + i].vsid == vsid) && (phte[base2 + i].api == api))) {
     158                                found = true;
     159                                base = base2;
     160                                h = 1;
     161                                break;
     162                        }
     163                }
     164               
     165                if (!found) {
     166                        // TODO: A/C precedence groups
     167                        i = page % 8;
     168                }
     169        }
     170       
     171        phte[base + i].v = 1;
     172        phte[base + i].vsid = vsid;
     173        phte[base + i].h = h;
     174        phte[base + i].api = api;
     175        phte[base + i].rpn = pfn;
     176        phte[base + i].r = 0;
     177        phte[base + i].c = 0;
     178        phte[base + i].pp = 2; // FIXME
     179}
     180
     181
     182/** Process Instruction/Data Storage Interrupt
     183 *
     184 * @param data   True if Data Storage Interrupt.
     185 * @param istate Interrupted register context.
     186 *
     187 */
     188void pht_refill(bool data, istate_t *istate)
     189{
     190        __address badvaddr;
     191        pte_t *pte;
     192        int pfcr;
     193        as_t *as;
     194        bool lock;
     195       
     196        if (AS == NULL) {
     197                as = AS_KERNEL;
     198                lock = false;
     199        } else {
     200                as = AS;
     201                lock = true;
     202        }
     203       
     204        if (data) {
     205                asm volatile (
     206                        "mfdar %0\n"
     207                        : "=r" (badvaddr)
     208                );
     209        } else
     210                badvaddr = istate->pc;
     211               
     212        page_table_lock(as, lock);
     213       
     214        pte = find_mapping_and_check(as, lock, badvaddr, istate, &pfcr);
     215        if (!pte) {
     216                switch (pfcr) {
     217                        case AS_PF_FAULT:
     218                                goto fail;
     219                                break;
     220                        case AS_PF_DEFER:
     221                                /*
     222                                 * The page fault came during copy_from_uspace()
     223                                 * or copy_to_uspace().
     224                                 */
     225                                page_table_unlock(as, lock);
     226                                return;
     227                        default:
     228                                panic("Unexpected pfrc (%d)\n", pfcr);
     229                }
     230        }
     231       
     232        pte->a = 1; /* Record access to PTE */
     233        pht_insert(badvaddr, pte->pfn);
     234       
     235        page_table_unlock(as, lock);
     236        return;
     237       
     238fail:
     239        page_table_unlock(as, lock);
     240        pht_refill_fail(badvaddr, istate);
     241}
     242
     243
     244void pht_init(void)
     245{
     246        memsetb((__address) phte, 1 << PHT_BITS, 0);
     247}
     248
    35249
    36250void page_arch_init(void)
    37251{
    38         page_mapping_operations = &pt_mapping_operations;
    39 }
     252        if (config.cpu_active == 1) {
     253                page_mapping_operations = &pt_mapping_operations;
     254               
     255                __address cur;
     256                int flags;
     257               
     258                /* Frames below 128 MB are mapped using BAT,
     259                   map rest of the physical memory */
     260                for (cur = 128 << 20; cur < last_frame; cur += FRAME_SIZE) {
     261                        flags = PAGE_CACHEABLE;
     262                        if ((PA2KA(cur) >= config.base) && (PA2KA(cur) < config.base + config.kernel_size))
     263                                flags |= PAGE_GLOBAL;
     264                        page_mapping_insert(AS_KERNEL, PA2KA(cur), cur, flags);
     265                }
     266               
     267                /* Allocate page hash table */
     268                phte_t *physical_phte = (phte_t *) PFN2ADDR(frame_alloc(PHT_ORDER, FRAME_KA | FRAME_PANIC));
     269                phte = (phte_t *) PA2KA((__address) physical_phte);
     270               
     271                ASSERT((__address) physical_phte % (1 << PHT_BITS) == 0);
     272                pht_init();
     273               
     274                asm volatile (
     275                        "mtsdr1 %0\n"
     276                        :
     277                        : "r" ((__address) physical_phte)
     278                );
     279        }
     280}
     281
     282
     283__address hw_map(__address physaddr, size_t size)
     284{
     285        if (last_frame + ALIGN_UP(size, PAGE_SIZE) > KA2PA(KERNEL_ADDRESS_SPACE_END_ARCH))
     286                panic("Unable to map physical memory %p (%d bytes)", physaddr, size)
     287       
     288        __address virtaddr = PA2KA(last_frame);
     289        pfn_t i;
     290        for (i = 0; i < ADDR2PFN(ALIGN_UP(size, PAGE_SIZE)); i++)
     291                page_mapping_insert(AS_KERNEL, virtaddr + PFN2ADDR(i), physaddr + PFN2ADDR(i), PAGE_NOT_CACHEABLE);
     292       
     293        last_frame = ALIGN_UP(last_frame + size, FRAME_SIZE);
     294       
     295        return virtaddr;
     296}

  • arch/ppc64/src/mm/tlb.c

    rbd55bbb r48c1ef9  
    11/*
    2  * Copyright (C) 2005 Jakub Jermar
     2 * Copyright (C) 2006 Martin Decky
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 #include <arch/boot/boot.h>
    30 #include <arch/console.h>
    31 #include <console/chardev.h>
    32 #include <console/console.h>
    33 #include <genarch/fb/fb.h>
     29#include <mm/tlb.h>
    3430
    3531
    36 /** Initialize console to use frame buffer. */
    37 void ppc64_console_init(void)
     32/** Initialize Page Hash Table.
     33 *
     34 * Setup the Page Hash Table with no entries.
     35 *
     36 */
     37void tlb_arch_init(void)
    3838{
    39         /* TODO: Framebuffer mapping */
    40         fb_init(0xf0000000 + (bootinfo.screen.addr & ((__address) ~0 >> 15)), bootinfo.screen.width, bootinfo.screen.height, bootinfo.screen.bpp, bootinfo.screen.scanline);
     39        tlb_invalidate_all();
    4140}
     41
     42
     43void tlb_invalidate_all(void)
     44{
     45        asm volatile (
     46                "tlbia\n"
     47                "tlbsync\n"
     48        );
     49}
     50
     51
     52/** Invalidate all entries in TLB that belong to specified address space.
     53 *
     54 * @param asid This parameter is ignored as the architecture doesn't support it.
     55 */
     56void tlb_invalidate_asid(asid_t asid)
     57{
     58        tlb_invalidate_all();
     59}
     60
     61/** Invalidate TLB entries for specified page range belonging to specified address space.
     62 *
     63 * @param asid This parameter is ignored as the architecture doesn't support it.
     64 * @param page Address of the first page whose entry is to be invalidated.
     65 * @param cnt Number of entries to invalidate.
     66 */
     67void tlb_invalidate_pages(asid_t asid, __address page, count_t cnt)
     68{
     69        tlb_invalidate_all();
     70}
     71
     72
     73
     74/** Print contents of Page Hash Table. */
     75void tlb_print(void)
     76{
     77}

  • arch/ppc64/src/ppc64.c

    rbd55bbb r48c1ef9  
    2929#include <arch.h>
    3030#include <arch/boot/boot.h>
    31 #include <arch/console.h>
    3231#include <arch/mm/memory_init.h>
    3332#include <arch/interrupt.h>
    34 #include <mm/frame.h>
     33#include <genarch/fb/fb.h>
     34#include <userspace.h>
     35#include <proc/uarg.h>
    3536
    3637bootinfo_t bootinfo;
     38
     39void arch_pre_main(void)
     40{
     41        /* Setup usermode */
     42        init.cnt = bootinfo.taskmap.count;
     43       
     44        __u32 i;
     45       
     46        for (i = 0; i < bootinfo.taskmap.count; i++) {
     47                init.tasks[i].addr = PA2KA(bootinfo.taskmap.tasks[i].addr);
     48                init.tasks[i].size = bootinfo.taskmap.tasks[i].size;
     49        }
     50}
    3751
    3852void arch_pre_mm_init(void)
    … …  
    4357        /* Start decrementer */
    4458        start_decrementer();
    45 
    46         ppc64_console_init();
    4759}
    4860
    … …  
    5062{
    5163        if (config.cpu_active == 1) {
     64                fb_init(bootinfo.screen.addr, bootinfo.screen.width, bootinfo.screen.height, bootinfo.screen.bpp, bootinfo.screen.scanline);   
     65       
    5266                /* Merge all zones to 1 big zone */
    5367                zone_merge_all();
    … …  
    6882}
    6983
     84void userspace(uspace_arg_t *kernel_uarg)
     85{
     86        userspace_asm((__address) kernel_uarg->uspace_uarg, (__address) kernel_uarg->uspace_stack + THREAD_STACK_SIZE - SP_DELTA, (__address) kernel_uarg->uspace_entry);
     87       
     88        /* Unreachable */
     89        for (;;)
     90                ;
     91}

  • arch/ppc64/src/proc/scheduler.c

    rbd55bbb r48c1ef9  
    2828
    2929#include <arch/mm/page.h>
     30#include <arch/boot/boot.h>
    3031#include <proc/scheduler.h>
    3132#include <proc/thread.h>
    3233#include <arch.h>
    33 
    34 __address supervisor_sp;
    35 __address supervisor_sp_physical;
    3634
    3735/** Perform ppc64 specific tasks needed before the new task is run. */
    … …  
    4341void before_thread_runs_arch(void)
    4442{
    45         supervisor_sp = (__address) &THREAD->kstack[THREAD_STACK_SIZE - SP_DELTA];
    46         supervisor_sp_physical = KA2PA(supervisor_sp_physical);
     43        pht_init();
     44        tlb_invalidate_all();
     45        asm volatile (
     46                "mtsprg0 %0\n"
     47                :
     48                : "r" (KA2PA(&THREAD->kstack[THREAD_STACK_SIZE - SP_DELTA]))
     49        );
    4750}
    4851
Note: See TracChangeset for help on using the changeset viewer.