Changeset 8565a42 in mainline for kernel/arch/ia64/src


Ignore:
Timestamp:
2018-03-02T20:34:50Z (8 years ago)
Author:
GitHub <noreply@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
a1a81f69, d5e5fd1
Parents:
3061bc1 (diff), 34e1206 (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.
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:34:50)
git-committer:
GitHub <noreply@…> (2018-03-02 20:34:50)
Message:

Remove all trailing whitespace, everywhere.

See individual commit messages for details.

Location:
kernel/arch/ia64/src
Files:
17 edited

Legend:

Unmodified
Added
Removed

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

    r3061bc1 r8565a42  
    4646FUNCTION_BEGIN(memcpy_to_uspace)
    4747        alloc loc0 = ar.pfs, 3, 1, 0, 0
    48        
     48
    4949        adds r14 = 7, in1
    5050        mov r2 = ar.lc
    … …  
    5353        cmp.ne p6, p7 = r14, in1
    5454        (p7) br.cond.dpnt 3f ;;
    55        
     55
    5656        0:
    57        
     57
    5858                cmp.ne p6, p7 = 0, in2
    5959                (p7) br.cond.dpnt 2f ;;
    … …  
    6262                (p6) mov r17 = r0 ;;
    6363                (p6) mov ar.lc = r14
    64        
     64
    6565        1:
    66        
     66
    6767                add r14 = r16, in1
    6868                add r15 = r16, in0
    … …  
    7272                st1 [r15] = r14
    7373                br.cloop.sptk.few 1b ;;
    74        
     74
    7575        2:
    76        
     76
    7777                mov ar.lc = r2
    7878                mov ar.pfs = loc0
    7979                br.ret.sptk.many rp
    80        
     80
    8181        3:
    82        
     82
    8383                adds r14 = 7, in0 ;;
    8484                and r14 = -8, r14 ;;
    … …  
    9292                (p6) mov r17 = r0 ;;
    9393                (p6) mov ar.lc = r14
    94        
     94
    9595        4:
    96        
     96
    9797                shladd r14 = r16, 3, r0
    9898                adds r16 = 1, r17 ;;
    … …  
    103103                st8 [r14] = r15
    104104                br.cloop.sptk.few 4b
    105        
     105
    106106        5:
    107        
     107
    108108                and r15 = 7, in2
    109109                shladd r14 = r18, 3, r0
    … …  
    116116                (p6) br.cond.dpnt 2b ;;
    117117                mov ar.lc = r15
    118        
     118
    119119        6:
    120        
     120
    121121                add r14 = r16, r17
    122122                add r15 = r16, in0
    … …  
    155155FUNCTION_BEGIN(switch_to_userspace)
    156156        alloc loc0 = ar.pfs, 6, 3, 0, 0
    157        
     157
    158158        /* Disable interruption collection and interrupts */
    159159        rsm (PSR_IC_MASK | PSR_I_MASK)
    160160        srlz.d ;;
    161161        srlz.i ;;
    162        
     162
    163163        mov cr.ipsr = in4
    164164        mov cr.iip = in0
    165165        mov r12 = in1
    166        
     166
    167167        xor r1 = r1, r1
    168        
     168
    169169        /* r2 is defined to hold pcb_ptr - set it to 0 */
    170170        xor r2 = r2, r2
    171        
     171
    172172        mov loc1 = cr.ifs
    173173        movl loc2 = PFM_MASK ;;
    174174        and loc1 = loc2, loc1 ;;
    175175        mov cr.ifs = loc1 ;;  /* prevent decrementing BSP by rfi */
    176        
     176
    177177        invala
    178        
     178
    179179        mov loc1 = ar.rsc ;;
    180180        and loc1 = ~3, loc1 ;;
    181181        mov ar.rsc = loc1 ;;  /* put RSE into enforced lazy mode */
    182        
     182
    183183        flushrs ;;
    184        
     184
    185185        mov ar.bspstore = in2 ;;
    186186        mov ar.rsc = in5 ;;
    187        
     187
    188188        mov r8 = in3
    189        
     189
    190190        rfi ;;
    191191FUNCTION_END(switch_to_userspace)

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

    r3061bc1 r8565a42  
    4545        flushrs
    4646        mov loc4 = ar.bsp
    47        
     47
    4848        /*
    4949         * Put RSE to enforced lazy mode.
    … …  
    117117
    118118        mov loc2 = ar.unat
    119        
     119
    120120        /*
    121121         * Save application registers
    … …  
    177177
    178178        mov ar.unat = loc1
    179        
     179
    180180        add r8 = r0, r0, 1      /* context_save returns 1 */
    181181        br.ret.sptk.many b0
    … …  
    239239        ld8 loc5 = [loc14]      /* load ar.rnat */
    240240        ld8 loc6 = [loc15]      /* load ar.lc */
    241        
     241
    242242        .auto
    243243
    … …  
    274274        mov ar.unat = loc2 ;;
    275275        mov ar.lc = loc6
    276        
     276
    277277        /*
    278278         * Restore general registers including NaT bits
    … …  
    332332        ldf.fill f30 = [loc48]
    333333        ldf.fill f31 = [loc49]
    334        
     334
    335335        mov ar.unat = loc1
    336        
     336
    337337        mov r8 = r0                     /* context_restore returns 0 */
    338338        br.ret.sptk.many b0

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

    r3061bc1 r8565a42  
    5454        const char *family_str;
    5555        char vendor[2 * sizeof(uint64_t) + 1];
    56        
     56
    5757        memcpy(vendor, &CPU->arch.cpuid0, 8);
    5858        memcpy(vendor + 8, &CPU->arch.cpuid1, 8);
    5959        vendor[sizeof(vendor) - 1] = 0;
    60        
     60
    6161        switch (m->arch.cpuid3.family) {
    6262        case FAMILY_ITANIUM:
    … …  
    7070                break;
    7171        }
    72        
     72
    7373        printf("cpu%d: %s (%s), archrev=%d, model=%d, revision=%d\n", CPU->id,
    7474            family_str, vendor, CPU->arch.cpuid3.archrev,

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

    r3061bc1 r8565a42  
    5959                if (task->arch.iomap == NULL)
    6060                        return ENOMEM;
    61                
     61
    6262                void *store = malloc(bitmap_size(IO_MEMMAP_PAGES), 0);
    6363                if (store == NULL)
    6464                        return ENOMEM;
    65                
     65
    6666                bitmap_initialize(task->arch.iomap, IO_MEMMAP_PAGES, store);
    6767                bitmap_clear_range(task->arch.iomap, 0, IO_MEMMAP_PAGES);
    6868        }
    69        
     69
    7070        uintptr_t iopage = ioaddr / PORTS_PER_PAGE;
    7171        size = ALIGN_UP(size + ioaddr - 4 * iopage, PORTS_PER_PAGE);
    7272        bitmap_set_range(task->arch.iomap, iopage, size / 4);
    73        
     73
    7474        return EOK;
    7575}
    … …  
    9393        size = ALIGN_UP(size + ioaddr - 4 * iopage, PORTS_PER_PAGE);
    9494        bitmap_clear_range(task->arch.iomap, iopage, size / 4);
    95        
     95
    9696        return EOK;
    9797}

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

    r3061bc1 r8565a42  
    6868                it_irq.handler = it_interrupt;
    6969                irq_register(&it_irq);
    70                
     70
    7171                uint64_t base_freq;
    7272                base_freq  = ((bootinfo->freq_scale) & FREQ_NUMERATOR_MASK) >>
    … …  
    7575                base_freq /= ((bootinfo->freq_scale) & FREQ_DENOMINATOR_MASK) >>
    7676                    FREQ_DENOMINATOR_SHIFT;
    77                
     77
    7878                it_delta = base_freq / HZ;
    7979        }
    80        
     80
    8181        /* Initialize Interval Timer external interrupt vector */
    8282        cr_itv_t itv;
    83        
     83
    8484        itv.value = itv_read();
    8585        itv.vector = INTERRUPT_TIMER;
    8686        itv.m = 0;
    8787        itv_write(itv.value);
    88        
     88
    8989        /* Set Interval Timer Counter to zero */
    9090        itc_write(0);
    91        
     91
    9292        /* Generate first Interval Timer interrupt in IT_DELTA ticks */
    9393        itm_write(IT_DELTA);
    94        
     94
    9595        /* Propagate changes */
    9696        srlz_d();
    … …  
    113113{
    114114        eoi_write(EOI);
    115        
     115
    116116        int64_t itm = itm_read();
    117        
     117
    118118        while (true) {
    119119                int64_t itc = itc_read();
    120120                itc += IT_SERVICE_CLOCKS;
    121                
     121
    122122                itm += IT_DELTA;
    123123                if (itm - itc < 0)
    … …  
    126126                        break;
    127127        }
    128        
     128
    129129        itm_write(itm);
    130130        srlz_d();  /* Propagate changes */
    131        
     131
    132132        /*
    133133         * We are holding a lock which prevents preemption.

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

    r3061bc1 r8565a42  
    4949        /** Interval between polling in microseconds */
    5050        POLL_INTERVAL = 10000,  /* 0.01 s */
    51        
     51
    5252        /** Max. number of characters to pull out at a time */
    5353        POLL_LIMIT = 30,
    54        
     54
    5555        SKI_INIT_CONSOLE = 20,
    5656        SKI_GETCHAR      = 21,
    … …  
    8282{
    8383        uint64_t ch;
    84        
     84
    8585        asm volatile (
    8686                "mov r15 = %1\n"
    8787                "break 0x80000;;\n"  /* modifies r8 */
    8888                "mov %0 = r8;;\n"
    89                
     89
    9090                : "=r" (ch)
    9191                : "i" (SKI_GETCHAR)
    9292                : "r15", "r8"
    9393        );
    94        
     94
    9595        return (wchar_t) ch;
    9696}
    … …  
    103103{
    104104        int count = POLL_LIMIT;
    105        
     105
    106106        while (count > 0) {
    107107                wchar_t ch = ski_getchar();
    108                
     108
    109109                if (ch == '\0')
    110110                        break;
    111                
     111
    112112                indev_push_character(instance->srlnin, ch);
    113113                --count;
    … …  
    119119{
    120120        ski_instance_t *instance = (ski_instance_t *) arg;
    121        
     121
    122122        while (true) {
    123123                // TODO FIXME:
    … …  
    126126                if (console_override)
    127127                        poll_keyboard(instance);
    128                
     128
    129129                thread_usleep(POLL_INTERVAL);
    130130        }
    … …  
    141141        if (instance)
    142142                return;
    143        
     143
    144144        asm volatile (
    145145                "mov r15 = %0\n"
    … …  
    149149                : "r15", "r8"
    150150        );
    151        
     151
    152152        instance = malloc(sizeof(ski_instance_t), FRAME_ATOMIC);
    153        
     153
    154154        if (instance) {
    155155                instance->thread = thread_create(kskipoll, instance, TASK,
    156156                    THREAD_FLAG_UNCOUNTED, "kskipoll");
    157                
     157
    158158                if (!instance->thread) {
    159159                        free(instance);
    … …  
    161161                        return;
    162162                }
    163                
     163
    164164                instance->srlnin = NULL;
    165165        }
    … …  
    196196                        if (ch == '\n')
    197197                                ski_do_putchar('\r');
    198                        
     198
    199199                        ski_do_putchar(ch);
    200200                } else
    … …  
    208208        if (!instance)
    209209                return NULL;
    210        
     210
    211211        outdev_t *skidev = malloc(sizeof(outdev_t), FRAME_ATOMIC);
    212212        if (!skidev)
    213213                return NULL;
    214        
     214
    215215        outdev_initialize("skidev", skidev, &skidev_ops);
    216216        skidev->data = instance;
    217        
     217
    218218        if (!fb_exported) {
    219219                /*
    … …  
    224224                sysinfo_set_item_val("fb", NULL, true);
    225225                sysinfo_set_item_val("fb.kind", NULL, 6);
    226                
     226
    227227                fb_exported = true;
    228228        }
    229        
     229
    230230        return skidev;
    231231}
    … …  
    241241        assert(instance);
    242242        assert(srlnin);
    243        
     243
    244244        instance->srlnin = srlnin;
    245245        thread_ready(instance->thread);
    246        
     246
    247247        sysinfo_set_item_val("kbd", NULL, true);
    248248        sysinfo_set_item_val("kbd.type", NULL, KBD_SKI);

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

    r3061bc1 r8565a42  
    103103                [f61] "=m" (fctx->fr[29])
    104104        );
    105        
     105
    106106        asm volatile (
    107107                "stf.spill %[f62] = f62\n"
    … …  
    314314                [f61] "m" (fctx->fr[29])
    315315        );
    316        
     316
    317317        asm volatile (
    318318                "ldf.fill f62 = %[f62]\n"

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

    r3061bc1 r8565a42  
    108108            PAGE_WRITE | PAGE_NOT_CACHEABLE);
    109109        int i;
    110        
     110
    111111        int myid, myeid;
    112        
     112
    113113        myid = ia64_get_cpu_id();
    114114        myeid = ia64_get_cpu_eid();
    … …  
    167167                }
    168168        }
    169        
     169
    170170        outdev_t *skidev = skiout_init();
    171171        if (skidev)
    172172                stdout_wire(skidev);
    173173#endif
    174        
     174
    175175#ifdef CONFIG_EGA
    176176        outdev_t *egadev = ega_init(EGA_BASE, EGA_VIDEORAM);
    … …  
    178178                stdout_wire(egadev);
    179179#endif
    180        
     180
    181181#ifdef CONFIG_NS16550
    182182        ns16550_instance_t *ns16550_instance
    … …  
    191191                }
    192192        }
    193        
     193
    194194        sysinfo_set_item_val("kbd", NULL, true);
    195195        sysinfo_set_item_val("kbd.inr", NULL, NS16550_IRQ);
    … …  
    198198            (uintptr_t) NS16550_BASE);
    199199#endif
    200        
     200
    201201#ifdef CONFIG_I8042
    202202        i8042_instance_t *i8042_instance = i8042_init((i8042_t *) I8042_BASE,
    … …  
    211211        }
    212212#endif
    213        
     213
    214214        sysinfo_set_item_val("ia64_iospace", NULL, true);
    215215        sysinfo_set_item_val("ia64_iospace.address", NULL, true);
    … …  
    251251            kernel_uarg->uspace_stack_size / 2,
    252252            (uintptr_t) kernel_uarg->uspace_uarg, psr.value, rsc.value);
    253        
     253
    254254        while (1);
    255255}
    … …  
    274274        fptr->fnc = (sysarg_t) addr;
    275275        fptr->gp = ((sysarg_t *) caller)[1];
    276        
     276
    277277        return (void *) fptr;
    278278}

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

    r3061bc1 r8565a42  
    124124{
    125125        assert(n <= VECTOR_MAX);
    126        
     126
    127127        if (n >= VECTORS_16_BUNDLE_START)
    128128                return vector_names_16_bundle[n - VECTORS_16_BUNDLE_START];
    … …  
    141141        printf("cr.isr=%#0" PRIx64 "\tcr.ipsr=%#0" PRIx64 "\n",
    142142            istate->cr_isr.value, istate->cr_ipsr.value);
    143        
     143
    144144        printf("cr.iip=%#0" PRIxPTR ", #%u\t(%s)\n",
    145145            istate->cr_iip, istate->cr_isr.ei,
    … …  
    154154{
    155155        const char *desc;
    156        
     156
    157157        switch (istate->cr_isr.ge_code) {
    158158        case GE_ILLEGALOP:
    … …  
    178178                break;
    179179        }
    180        
     180
    181181        fault_if_from_uspace(istate, "General Exception (%s).", desc);
    182182        panic_badtrap(istate, n, "General Exception (%s).", desc);
    … …  
    209209                istate->cr_ipsr.ri++;
    210210        }
    211        
     211
    212212        interrupts_enable();
    213213        ret = syscall_handler(istate->in0, istate->in1, istate->in2,
    … …  
    236236{
    237237        cr_ivr_t ivr;
    238        
     238
    239239        ivr.value = ivr_read();
    240240        srlz_d();
    241        
     241
    242242        irq_t *irq;
    243        
     243
    244244        switch (ivr.vector) {
    245245        case INTERRUPT_SPURIOUS:
    … …  
    248248#endif
    249249                break;
    250        
     250
    251251#ifdef CONFIG_SMP
    252252        case VECTOR_TLB_SHOOTDOWN_IPI:
    … …  
    255255                break;
    256256#endif
    257        
     257
    258258        case INTERRUPT_TIMER:
    259259                irq = irq_dispatch_and_lock(ivr.vector);

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

    r3061bc1 r8565a42  
    5757        mov r19 = cr.ipsr
    5858        mov r20 = cr.isr ;;
    59        
     59
    6060    /* 2. Move IIP to IIPA. */
    6161        mov cr.iipa = r18
    62        
     62
    6363    /* 3. Sign extend IIM[20:0], shift left by 4 and add to IIP. */
    6464        shl r17 = r17, 43 ;;    /* shift bit 20 to bit 63 */
    … …  
    6666        add r18 = r18, r17 ;;
    6767        mov cr.iip = r18
    68        
     68
    6969    /* 4. Set IPSR.ri to 0. */
    7070        dep r19 = 0, r19, PSR_RI_SHIFT, PSR_RI_LEN ;;
    7171        mov cr.ipsr = r19
    72        
     72
    7373    /* 5. Check whether IPSR.tb or IPSR.ss is set. */
    7474
    … …  
    7676         * Implement this when Taken Branch and Single Step traps can occur.
    7777         */
    78    
     78
    7979    /* 6. Restore predicates and return from interruption. */
    8080        mov pr = r16 ;;
    … …  
    104104SYMBOL(heavyweight_handler)
    105105    /* 1. copy interrupt registers into bank 0 */
    106    
     106
    107107        /*
    108108         * Note that r24-r31 from bank 0 can be used only as long as PSR.ic = 0.
    109109         */
    110        
     110
    111111        /* Set up FPU as in interrupted context. */
    112112        mov r24 = psr
    … …  
    126126        mov r27 = cr.isr
    127127        mov r28 = cr.ifa
    128        
     128
    129129    /* 2. preserve predicate register into bank 0 */
    130130        mov r29 = pr ;;
    131        
     131
    132132    /* 3. switch to kernel memory stack */
    133133        mov r30 = cr.ipsr
    … …  
    149149         */
    150150(p3)    cmp.eq p3, p4 = VRN_KERNEL, r31 ;;
    151        
     151
    152152        /*
    153153         * Now, p4 is true iff the stack needs to be switched to kernel stack.
    … …  
    155155        mov r30 = r12
    156156(p4)    mov r12 = R_KSTACK ;;
    157        
     157
    158158        add r12 = -STACK_FRAME_SIZE, r12 ;;
    159159        add r31 = STACK_SCRATCH_AREA_SIZE + ISTATE_OFFSET_IN6, r12
    … …  
    166166         */
    167167        cmp.eq p6, p5 = EXC_BREAK_INSTRUCTION, R_VECTOR ;;
    168        
     168
    169169        /*
    170170         * From now on, if this is break_instruction handler, p6 is true and p5
    … …  
    181181(p6)    st8 [r31] = r32, -STACK_ITEM_SIZE ;;    /* save in0 */
    182182(p5)    add r31 = -(7 * STACK_ITEM_SIZE), r31 ;;
    183    
     183
    184184        st8 [r31] = r30, -STACK_ITEM_SIZE ;;    /* save old stack pointer */
    185        
     185
    186186        st8 [r31] = r29, -STACK_ITEM_SIZE ;;    /* save predicate registers */
    187187
    … …  
    197197        cover
    198198        mov r26 = cr.ifs
    199        
     199
    200200        st8 [r31] = r24, -STACK_ITEM_SIZE ;;    /* save ar.rsc */
    201201        st8 [r31] = r25, -STACK_ITEM_SIZE ;;    /* save ar.pfs */
    202202        st8 [r31] = r26, -STACK_ITEM_SIZE       /* save ar.ifs */
    203        
     203
    204204        and r24 = ~(RSC_PL_MASK), r24 ;;
    205205        and r30 = ~(RSC_MODE_MASK), r24 ;;
    206206        mov ar.rsc = r30 ;;             /* update RSE state */
    207        
     207
    208208        mov r27 = ar.rnat
    209209        mov r28 = ar.bspstore ;;
    210        
     210
    211211        /*
    212212         * Inspect BSPSTORE to figure out whether it is necessary to switch to
    … …  
    215215(p1)    shr.u r30 = r28, VRN_SHIFT ;;
    216216(p1)    cmp.eq p1, p2 = VRN_KERNEL, r30 ;;
    217        
     217
    218218        /*
    219219         * If BSPSTORE needs to be switched, p1 is false and p2 is true.
    … …  
    222222(p2)    mov r30 = R_KSTACK_BSP ;;
    223223(p2)    mov ar.bspstore = r30 ;;
    224        
     224
    225225        mov r29 = ar.bsp
    226        
     226
    227227        st8 [r31] = r27, -STACK_ITEM_SIZE ;;    /* save ar.rnat */
    228228        st8 [r31] = r30, -STACK_ITEM_SIZE ;;    /* save new value written to ar.bspstore */
    229229        st8 [r31] = r28, -STACK_ITEM_SIZE ;;    /* save ar.bspstore */
    230230        st8 [r31] = r29, -STACK_ITEM_SIZE       /* save ar.bsp */
    231        
     231
    232232        mov ar.rsc = r24                /* restore RSE's setting + kernel privileges */
    233        
     233
    234234    /* steps 6 - 15 are done by heavyweight_handler_inner() */
    235235        mov R_RET = b0                  /* save b0 belonging to interrupted context */
    … …  
    292292        ld8 r29 = [r31], +STACK_ITEM_SIZE ;;    /* load predicate registers */
    293293        mov pr = r29
    294        
     294
    295295    /* 19. return from interruption */
    296296        ld8 r12 = [r31]                         /* load stack pointer */
    … …  
    303303         */
    304304        alloc loc0 = ar.pfs, 0, 48, 2, 0 ;;
    305        
     305
    306306        /* bank 0 is going to be shadowed, copy essential data from there */
    307307        mov loc1 = R_RET        /* b0 belonging to interrupted context */
    308308        mov loc2 = R_HANDLER
    309309        mov out0 = R_VECTOR
    310        
     310
    311311        add out1 = STACK_SCRATCH_AREA_SIZE, r12
    312312
    … …  
    315315        bsw.1 ;;
    316316        srlz.d
    317        
     317
    318318    /* 7. preserve branch and application registers */
    319319        mov loc3 = ar.unat
    … …  
    323323        mov loc7 = ar.csd
    324324        mov loc8 = ar.ssd
    325        
     325
    326326        mov loc9 = b0
    327327        mov loc10 = b1
    … …  
    332332        mov loc15 = b6
    333333        mov loc16 = b7
    334        
     334
    335335    /* 8. preserve general and floating-point registers */
    336336        mov loc17 = r1
    … …  
    374374        add r30 = ISTATE_OFFSET_F6 + STACK_SCRATCH_AREA_SIZE, r12
    375375        add r31 = ISTATE_OFFSET_F7 + STACK_SCRATCH_AREA_SIZE, r12 ;;
    376        
     376
    377377        stf.spill [r26] = f2, 8 * FLOAT_ITEM_SIZE
    378378        stf.spill [r27] = f3, 8 * FLOAT_ITEM_SIZE
    … …  
    410410
    411411        mov loc47 = ar.fpsr     /* preserve floating point status register */
    412    
     412
    413413    /* 9. skipped (will not enable interrupts) */
    414414        /*
    … …  
    420420    /* 10. call handler */
    421421        movl r1 = __gp
    422    
     422
    423423        mov b1 = loc2
    424424        br.call.sptk.many b0 = b1
    … …  
    426426    /* 11. return from handler */
    4274270:
    428        
     428
    429429    /* 12. skipped (will not disable interrupts) */
    430430        /*
    … …  
    477477        ldf.fill f30 = [r30]
    478478        ldf.fill f31 = [r31] ;;
    479        
     479
    480480        mov r1 = loc17
    481481        mov r2 = loc18
    … …  
    511511
    512512        mov ar.fpsr = loc47     /* restore floating point status register */
    513        
     513
    514514    /* 14. restore branch and application registers */
    515515        mov ar.unat = loc3
    … …  
    519519        mov ar.csd = loc7
    520520        mov ar.ssd = loc8
    521        
     521
    522522        mov b0 = loc9
    523523        mov b1 = loc10
    … …  
    528528        mov b6 = loc15
    529529        mov b7 = loc16
    530        
     530
    531531    /* 15. disable PSR.ic and switch to bank 0 */
    532532        rsm PSR_IC_MASK
    … …  
    578578        HEAVYWEIGHT_HANDLER 0x5e
    579579        HEAVYWEIGHT_HANDLER 0x5f
    580        
     580
    581581        HEAVYWEIGHT_HANDLER 0x60
    582582        HEAVYWEIGHT_HANDLER 0x61

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

    r3061bc1 r8565a42  
    5858        region_register_t rr;
    5959        int i;
    60        
     60
    6161        assert(as->asid != ASID_INVALID);
    62        
     62
    6363        /*
    6464         * Load respective ASID (7 consecutive RIDs) to
    … …  
    6868                if (i == VRN_KERNEL)
    6969                        continue;
    70                
     70
    7171                rr.word = rr_read(i);
    7272                rr.map.ve = false;              /* disable VHPT walker */

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

    r3061bc1 r8565a42  
    9292        if (config.cpu_active > 1)
    9393                return;
    94        
     94
    9595        frame_common_arch_init(true);
    96        
     96
    9797        /*
    9898         * Blacklist ROM regions.
    … …  
    112112        if (config.cpu_active > 1)
    113113                return;
    114        
     114
    115115        frame_common_arch_init(false);
    116116}

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

    r3061bc1 r8565a42  
    124124        vrn = page >> VRN_SHIFT;
    125125        rid = ASID2RID(asid, vrn);
    126        
     126
    127127        rr_save.word = rr_read(vrn);
    128128        if (rr_save.map.rid == rid) {
    … …  
    133133                return v;
    134134        }
    135        
     135
    136136        /*
    137137         * The RID must be written to some region register.
    … …  
    171171        vrn = page >> VRN_SHIFT;
    172172        rid = ASID2RID(asid, vrn);
    173        
     173
    174174        rr_save.word = rr_read(vrn);
    175175        if (rr_save.map.rid == rid) {
    … …  
    179179                return ttag(page) == v->present.tag.tag_word;
    180180        }
    181        
     181
    182182        /*
    183183         * The RID must be written to some region register.
    … …  
    218218        vrn = page >> VRN_SHIFT;
    219219        rid = ASID2RID(asid, vrn);
    220        
     220
    221221        /*
    222222         * Compute ttag.
    … …  
    231231        srlz_i();
    232232        srlz_d();
    233        
     233
    234234        /*
    235235         * Clear the entry.
    … …  
    239239        v->word[2] = 0;
    240240        v->word[3] = 0;
    241        
     241
    242242        v->present.p = true;
    243243        v->present.ma = (flags & PAGE_CACHEABLE) ?

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

    r3061bc1 r8565a42  
    6161        uintptr_t adr;
    6262        uint32_t count1, count2, stride1, stride2;
    63        
     63
    6464        unsigned int i, j;
    65        
     65
    6666        adr = PAL_PTCE_INFO_BASE();
    6767        count1 = PAL_PTCE_INFO_COUNT1();
    … …  
    6969        stride1 = PAL_PTCE_INFO_STRIDE1();
    7070        stride2 = PAL_PTCE_INFO_STRIDE2();
    71        
     71
    7272        ipl = interrupts_disable();
    73        
     73
    7474        for (i = 0; i < count1; i++) {
    7575                for (j = 0; j < count2; j++) {
    … …  
    8282                adr += stride1;
    8383        }
    84        
     84
    8585        interrupts_restore(ipl);
    86        
     86
    8787        srlz_d();
    8888        srlz_i();
    89        
     89
    9090#ifdef CONFIG_VHPT
    9191        vhpt_invalidate_all();
    … …  
    110110        int b = 0;
    111111        int c = cnt;
    112        
     112
    113113        uintptr_t va;
    114114        va = page;
    115        
     115
    116116        rr.word = rr_read(VA2VRN(page));
    117117        if ((restore_rr = (rr.map.rid != ASID2RID(asid, VA2VRN(page))))) {
    … …  
    121121                 */
    122122                region_register_t rr0;
    123                
     123
    124124                rr0 = rr;
    125125                rr0.map.rid = ASID2RID(asid, VA2VRN(page));
    … …  
    128128                srlz_i();
    129129        }
    130        
     130
    131131        while (c >>= 1)
    132132                b++;
    133133        b >>= 1;
    134134        uint64_t ps;
    135        
     135
    136136        switch (b) {
    137137        case 0: /* cnt 1 - 3 */
    … …  
    172172                break;
    173173        }
    174        
     174
    175175        for (; va < (page + cnt * PAGE_SIZE); va += (1UL << ps))
    176176                asm volatile (
    … …  
    179179                           [ps] "r" (ps << 2)
    180180                );
    181        
     181
    182182        srlz_d();
    183183        srlz_i();
    184        
     184
    185185        if (restore_rr) {
    186186                rr_write(VA2VRN(page), rr.word);
    … …  
    229229        region_register_t rr;
    230230        bool restore_rr = false;
    231        
     231
    232232        rr.word = rr_read(VA2VRN(va));
    233233        if ((restore_rr = (rr.map.rid != ASID2RID(asid, VA2VRN(va))))) {
    … …  
    237237                 */
    238238                region_register_t rr0;
    239                
     239
    240240                rr0 = rr;
    241241                rr0.map.rid = ASID2RID(asid, VA2VRN(va));
    … …  
    244244                srlz_i();
    245245        }
    246        
     246
    247247        asm volatile (
    248248                "mov r8 = psr ;;\n"
    … …  
    264264                : "p6", "p7", "r8"
    265265        );
    266        
     266
    267267        if (restore_rr) {
    268268                rr_write(VA2VRN(va), rr.word);
    … …  
    316316        region_register_t rr;
    317317        bool restore_rr = false;
    318        
     318
    319319        rr.word = rr_read(VA2VRN(va));
    320320        if ((restore_rr = (rr.map.rid != ASID2RID(asid, VA2VRN(va))))) {
    … …  
    324324                 */
    325325                region_register_t rr0;
    326                
     326
    327327                rr0 = rr;
    328328                rr0.map.rid = ASID2RID(asid, VA2VRN(va));
    … …  
    331331                srlz_i();
    332332        }
    333        
     333
    334334        asm volatile (
    335335                "mov r8 = psr ;;\n"
    … …  
    352352                : "p6", "p7", "r8"
    353353        );
    354        
     354
    355355        if (restore_rr) {
    356356                rr_write(VA2VRN(va), rr.word);
    … …  
    373373{
    374374        tlb_entry_t entry;
    375        
     375
    376376        entry.word[0] = 0;
    377377        entry.word[1] = 0;
    378        
     378
    379379        entry.p = true;           /* present */
    380380        entry.ma = MA_WRITEBACK;
    … …  
    385385        entry.ppn = frame >> PPN_SHIFT;
    386386        entry.ps = PAGE_WIDTH;
    387        
     387
    388388        if (dtr)
    389389                dtr_mapping_insert(page, ASID_KERNEL, entry, tr);
    … …  
    418418{
    419419        tlb_entry_t entry;
    420        
     420
    421421        entry.word[0] = 0;
    422422        entry.word[1] = 0;
    423        
     423
    424424        entry.p = t->p;
    425425        entry.ma = t->c ? MA_WRITEBACK : MA_UNCACHEABLE;
    … …  
    430430        entry.ppn = t->frame >> PPN_SHIFT;
    431431        entry.ps = PAGE_WIDTH;
    432        
     432
    433433        dtc_mapping_insert(t->page, t->as->asid, entry);
    434        
     434
    435435#ifdef CONFIG_VHPT
    436436        vhpt_mapping_insert(t->page, t->as->asid, entry);
    … …  
    446446{
    447447        tlb_entry_t entry;
    448        
     448
    449449        entry.word[0] = 0;
    450450        entry.word[1] = 0;
    451        
     451
    452452        assert(t->x);
    453        
     453
    454454        entry.p = t->p;
    455455        entry.ma = t->c ? MA_WRITEBACK : MA_UNCACHEABLE;
    … …  
    459459        entry.ppn = t->frame >> PPN_SHIFT;
    460460        entry.ps = PAGE_WIDTH;
    461        
     461
    462462        itc_mapping_insert(t->page, t->as->asid, entry);
    463        
     463
    464464#ifdef CONFIG_VHPT
    465465        vhpt_mapping_insert(t->page, t->as->asid, entry);
    … …  
    486486        uintptr_t va;
    487487        pte_t t;
    488        
     488
    489489        va = istate->cr_ifa; /* faulting address */
    490        
     490
    491491        assert(!is_kernel_fault(va));
    492492
    … …  
    532532                        uint64_t io_page = (va & ((1 << LEGACYIO_PAGE_WIDTH) - 1)) >>
    533533                            LEGACYIO_SINGLE_PAGE_WIDTH;
    534                        
     534
    535535                        if (is_io_page_accessible(io_page)) {
    536536                                uint64_t page, frame;
    537                                
     537
    538538                                page = LEGACYIO_USER_BASE +
    539539                                    (1 << LEGACYIO_SINGLE_PAGE_WIDTH) * io_page;
    540540                                frame = LEGACYIO_PHYS_BASE +
    541541                                    (1 << LEGACYIO_SINGLE_PAGE_WIDTH) * io_page;
    542                                
     542
    543543                                tlb_entry_t entry;
    544                                
     544
    545545                                entry.word[0] = 0;
    546546                                entry.word[1] = 0;
    547                                
     547
    548548                                entry.p = true;             /* present */
    549549                                entry.ma = MA_UNCACHEABLE;
    … …  
    554554                                entry.ppn = frame >> PPN_SHIFT;
    555555                                entry.ps = LEGACYIO_SINGLE_PAGE_WIDTH;
    556                                
     556
    557557                                dtc_mapping_insert(page, TASK->as->asid, entry);
    558558                                return 1;
    … …  
    563563                }
    564564        }
    565        
     565
    566566        return 0;
    567567}
    … …  
    586586                return;
    587587        }
    588        
     588
    589589        uintptr_t va = istate->cr_ifa;  /* faulting address */
    590590        as_t *as = AS;
    591        
     591
    592592        if (is_kernel_fault(va)) {
    593593                if (va < end_of_identity) {
    … …  
    601601                }
    602602        }
    603        
    604        
     603
     604
    605605        pte_t t;
    606606        bool found = page_mapping_find(as, va, true, &t);
    … …  
    616616                if (try_memmap_io_insertion(va, istate))
    617617                        return;
    618                
     618
    619619                /*
    620620                 * Forward the page fault to the address space page fault
    … …  
    649649        pte_t t;
    650650        as_t *as = AS;
    651        
     651
    652652        va = istate->cr_ifa;  /* faulting address */
    653        
     653
    654654        if (is_kernel_fault(va))
    655655                as = AS_KERNEL;
    … …  
    683683        uintptr_t va;
    684684        pte_t t;
    685        
     685
    686686        va = istate->cr_ifa;  /* faulting address */
    687687
    688688        assert(!is_kernel_fault(va));
    689        
     689
    690690        bool found = page_mapping_find(AS, va, true, &t);
    691691
    … …  
    717717        pte_t t;
    718718        as_t *as = AS;
    719        
     719
    720720        va = istate->cr_ifa;  /* faulting address */
    721        
     721
    722722        if (is_kernel_fault(va))
    723723                as = AS_KERNEL;
    … …  
    755755        uintptr_t va;
    756756        pte_t t;
    757        
     757
    758758        va = istate->cr_ifa;  /* faulting address */
    759759
    760760        assert(!is_kernel_fault(va));
    761        
     761
    762762        /*
    763763         * Assume a write to a read-only page.
    … …  
    782782        uintptr_t va;
    783783        pte_t t;
    784        
     784
    785785        va = istate->cr_ifa;  /* faulting address */
    786        
     786
    787787        assert(!is_kernel_fault(va));
    788788
    … …  
    790790
    791791        assert(found);
    792        
     792
    793793        if (t.p) {
    794794                /*

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

    r3061bc1 r8565a42  
    4646        if (!vhpt_frame)
    4747                panic("Kernel configured with VHPT but no memory for table.");
    48        
     48
    4949        vhpt_base = (vhpt_entry_t *) PA2KA(vhpt_frame);
    5050        vhpt_invalidate_all();
    … …  
    5959        rid_t rid;
    6060        uint64_t tag;
    61        
     61
    6262        vhpt_entry_t *ventry;
    63        
     63
    6464        vrn = va >> VRN_SHIFT;
    6565        rid = ASID2RID(asid, vrn);
    66        
     66
    6767        rr_save.word = rr_read(vrn);
    6868        rr.word = rr_save.word;
    … …  
    7070        rr_write(vrn, rr.word);
    7171        srlz_i();
    72        
     72
    7373        ventry = (vhpt_entry_t *) thash(va);
    7474        tag = ttag(va);
    … …  
    7676        srlz_i();
    7777        srlz_d();
    78        
     78
    7979        ventry->word[0] = entry.word[0];
    8080        ventry->word[1] = entry.word[1];

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

    r3061bc1 r8565a42  
    5454{
    5555        uintptr_t base;
    56        
     56
    5757        base = ALIGN_DOWN(config.base, 1 << KERNEL_PAGE_WIDTH);
    5858
    … …  
    6363                 * Use DTR[TR_KSTACK1] and DTR[TR_KSTACK2] to map it.
    6464                 */
    65                  
     65
    6666                /* purge DTR[TR_STACK1] and DTR[TR_STACK2] */
    6767                dtr_purge((uintptr_t) THREAD->kstack, PAGE_WIDTH+1);
    68                
     68
    6969                /* insert DTR[TR_STACK1] and DTR[TR_STACK2] */
    7070                dtlb_kernel_mapping_insert((uintptr_t) THREAD->kstack,
    … …  
    7474                    DTR_KSTACK2);
    7575        }
    76        
     76
    7777        /*
    7878         * Record address of kernel backing store to bank 0 r22.

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

    r3061bc1 r8565a42  
    5454SYMBOL(kernel_image_start)
    5555        .auto
    56        
     56
    5757        mov psr.l = r0
    5858        srlz.i
    5959        srlz.d
    60        
     60
    6161        # Fill TR.i and TR.d using Region Register #VRN_KERNEL
    62        
     62
    6363        movl r8 = (VRN_KERNEL << VRN_SHIFT)
    6464        mov r9 = rr[r8]
    65        
     65
    6666        movl r10 = (RR_MASK)
    6767        and r9 = r10, r9
    6868        movl r10 = (((RID_KERNEL7) << RID_SHIFT) | (KERNEL_PAGE_WIDTH << PS_SHIFT))
    6969        or r9 = r10, r9
    70        
     70
    7171        mov rr[r8] = r9
    72        
     72
    7373        movl r8 = (VRN_KERNEL << VRN_SHIFT)
    7474        mov cr.ifa = r8
    75        
     75
    7676        mov r11 = cr.itir
    7777        movl r10 = (KERNEL_PAGE_WIDTH << PS_SHIFT)
    7878        or r10 = r10, r11
    7979        mov cr.itir = r10
    80        
     80
    8181        movl r10 = (KERNEL_TRANSLATION_I)
    8282        itr.i itr[r0] = r10
    8383        movl r10 = (KERNEL_TRANSLATION_D)
    8484        itr.d dtr[r0] = r10
    85        
     85
    8686        # Initialize DCR
    87        
     87
    8888        movl r10 = (DCR_DP_MASK | DCR_DK_MASK | DCR_DX_MASK | DCR_DR_MASK | DCR_DA_MASK | DCR_DD_MASK | DCR_LC_MASK)
    8989        mov r9 = cr.dcr
    9090        or r10 = r10, r9
    9191        mov cr.dcr = r10
    92        
     92
    9393        # Initialize PSR
    94        
     94
    9595        movl r10 = (PSR_DT_MASK | PSR_RT_MASK | PSR_IT_MASK | PSR_IC_MASK)  /* Enable paging */
    9696        mov r9 = psr
    97        
     97
    9898        or r10 = r10, r9
    9999        mov cr.ipsr = r10
    … …  
    103103        srlz.d
    104104        srlz.i
    105        
     105
    106106        .explicit
    107        
     107
    108108        /*
    109109         * Return From Interrupt is the only way to
    … …  
    113113
    114114paging_start:
    115        
     115
    116116        /*
    117117         * Now we are paging.
    … …  
    126126        srlz.d ;;
    127127
    128        
     128
    129129        # Switch to register bank 1
    130130        bsw.1
    131        
     131
    132132        # Initialize register stack
    133133        mov ar.rsc = r0
    … …  
    135135        mov ar.bspstore = r8
    136136        loadrs
    137        
     137
    138138        #
    139139        # Initialize memory stack to some sane value and allocate a scratch area
    … …  
    142142        movl sp = stack0 ;;
    143143        add sp = -16, sp
    144        
     144
    145145        # Initialize gp (Global Pointer) register
    146146        movl gp = __gp
    147        
     147
    148148        #
    149149        # Initialize bootinfo on BSP.
    … …  
    153153        addl r21 = @gprel(bootinfo), gp ;;
    154154        st8 [r21] = r20
    155        
     155
    156156        ssm (1 << 19) ;; /* Disable f32 - f127 */
    157157        srlz.i
    158158        srlz.d ;;
    159        
     159
    160160        br.call.sptk.many b0 = ia64_pre_main
    1611610:
Note: See TracChangeset for help on using the changeset viewer.