Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 208b5f5 in mainline


Ignore:
Timestamp:
2013-12-29T14:32:55Z (8 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master
Children:
4c14b88, 6fa9a99d, 9be30cdf, aacdb8e
Parents:
2a13328
Message:

cherrypick important fixes and updates from lp:~jceel/helenos/leon3

Files:
13 added
15 edited

Legend:

Unmodified
Added
Removed
  • boot/arch/sparc32/src/ambapp.c

    r2a13328 r208b5f5  
    110110        amba_devices[0].device_id = GAISLER_APBUART;
    111111        amba_devices[0].version = 1;
    112         amba_devices[0].irq = 2;
     112        amba_devices[0].irq = 3;
    113113        amba_devices[0].bars[0].start = 0x80000100;
    114114        amba_devices[0].bars[0].size = 0x100;
  • boot/arch/sparc32/src/asm.S

    r2a13328 r208b5f5  
    4646boot_pt:
    4747        .space PTL0_ENTRIES * PTL0_ENTRY_SIZE
     48
    4849boot_ctx_table:
    4950        .space 4
  • kernel/arch/sparc32/include/arch/asm.h

    r2a13328 r208b5f5  
    161161        pil = psr.pil;
    162162       
     163        psr.pil = 0x00;
     164        psr_write(psr.value);
     165       
     166        return pil;
     167}
     168
     169NO_TRACE static inline ipl_t interrupts_disable(void)
     170{
     171        psr_reg_t psr;
     172        psr.value = psr_read();
     173       
     174        ipl_t pil;
     175        pil = psr.pil;
     176       
    163177        psr.pil = 0x0f;
    164178        psr_write(psr.value);
     
    167181}
    168182
    169 NO_TRACE static inline ipl_t interrupts_disable(void)
    170 {
    171         psr_reg_t psr;
    172         psr.value = psr_read();
    173        
    174         ipl_t pil;
    175         pil = psr.pil;
    176        
    177         psr.pil = 0;
    178         psr_write(psr.value);
    179        
    180         return pil;
    181 }
    182 
    183183NO_TRACE static inline void interrupts_restore(ipl_t ipl)
    184184{
     
    200200        psr_reg_t psr;
    201201        psr.value = psr_read();
    202         return psr.pil == 0;
     202        return (psr.pil == 0x0f);
    203203}
    204204
  • kernel/arch/sparc32/include/arch/atomic.h

    r2a13328 r208b5f5  
    3737
    3838#include <typedefs.h>
     39#include <arch/asm.h>
    3940#include <arch/barrier.h>
    4041#include <preemption.h>
     
    4748    REQUIRES(val->count < ATOMIC_COUNT_MAX)
    4849{
    49         // FIXME TODO
     50        // FIXME: Isn't there any intrinsic atomic operation?
     51        ipl_t ipl = interrupts_disable();
    5052        val->count++;
     53        interrupts_restore(ipl);
    5154}
    5255
     
    5659    REQUIRES(val->count > ATOMIC_COUNT_MIN)
    5760{
    58         // FIXME TODO
     61        // FIXME: Isn't there any intrinsic atomic operation?
     62        ipl_t ipl = interrupts_disable();
    5963        val->count--;
     64        interrupts_restore(ipl);
    6065}
    6166
     
    6570    REQUIRES(val->count < ATOMIC_COUNT_MAX)
    6671{
    67         // FIXME TODO
     72        // FIXME: Isn't there any intrinsic atomic operation?
    6873       
     74        ipl_t ipl = interrupts_disable();
    6975        atomic_count_t prev = val->count;
    7076       
    7177        val->count++;
     78        interrupts_restore(ipl);
    7279        return prev;
    7380}
     
    7885    REQUIRES(val->count > ATOMIC_COUNT_MIN)
    7986{
    80         // FIXME TODO
     87        // FIXME: Isn't there any intrinsic atomic operation?
    8188       
     89        ipl_t ipl = interrupts_disable();
    8290        atomic_count_t prev = val->count;
    8391       
    8492        val->count--;
     93        interrupts_restore(ipl);
    8594        return prev;
    8695}
     
    93102    REQUIRES_EXTENT_MUTABLE(val)
    94103{
    95         // FIXME TODO
     104        atomic_count_t prev;
     105        volatile uintptr_t ptr = (uintptr_t) &val->count;
    96106       
    97         atomic_count_t prev = val->count;
    98         val->count = 1;
     107        asm volatile (
     108                "ldstub [%[ptr]] %[prev]\n"
     109                : [prev] "=r" (prev)
     110                : [ptr] "r" (ptr)
     111                : "memory"
     112        );
     113       
    99114        return prev;
    100115}
     
    104119    REQUIRES_EXTENT_MUTABLE(val)
    105120{
    106         // FIXME TODO
     121        atomic_count_t tmp1 = 0;
    107122       
    108         do {
    109                 while (val->count);
    110         } while (test_and_set(val));
     123        volatile uintptr_t ptr = (uintptr_t) &val->count;
     124       
     125        preemption_disable();
     126       
     127        asm volatile (
     128                "0:\n"
     129                        "ldstub %0, %1\n"
     130                        "tst %1\n"
     131                        "be 2f\n"
     132                        "nop\n"
     133                "1:\n"
     134                        "ldub %0, %1\n"
     135                        "tst %1\n"
     136                        "bne 1b\n"
     137                        "nop\n"
     138                        "ba,a 0b\n"
     139                "2:\n"
     140                : "+m" (*((atomic_count_t *) ptr)),
     141                  "+r" (tmp1)
     142                : "r" (0)
     143        );
     144       
     145        /*
     146         * Prevent critical section code from bleeding out this way up.
     147         */
     148        CS_ENTER_BARRIER();
    111149}
    112150
  • kernel/arch/sparc32/include/arch/barrier.h

    r2a13328 r208b5f5  
    3636#define KERN_sparc32_BARRIER_H_
    3737
    38 // FIXME TODO
     38/*
     39 * Provisions are made to prevent compiler from reordering instructions itself.
     40 */
    3941
    40 #define CS_ENTER_BARRIER()
    41 #define CS_LEAVE_BARRIER()
     42#define CS_ENTER_BARRIER() \
     43        asm volatile ( \
     44                "stbar\n" \
     45                ::: "memory" \
     46        )
    4247
    43 #define memory_barrier()
    44 #define read_barrier()
    45 #define write_barrier()
     48#define CS_LEAVE_BARRIER() \
     49        asm volatile ( \
     50                "stbar\n" \
     51                ::: "memory" \
     52        )
     53
     54#define memory_barrier() \
     55        asm volatile ( \
     56                "stbar\n" \
     57                ::: "memory" \
     58        )
     59
     60#define read_barrier() \
     61        asm volatile ( \
     62                "stbar\n" \
     63                ::: "memory" \
     64        )
     65
     66#define write_barrier() \
     67        asm volatile ( \
     68                "stbar\n" \
     69                ::: "memory" \
     70        )
    4671
    4772#define smc_coherence(addr)
  • kernel/arch/sparc32/include/arch/mm/page.h

    r2a13328 r208b5f5  
    7171/* Page table sizes for each level. */
    7272#define PTL0_FRAMES_ARCH  1
    73 #define PTL1_FRAMES_ARCH  0
     73#define PTL1_FRAMES_ARCH  1
    7474#define PTL2_FRAMES_ARCH  1
    7575#define PTL3_FRAMES_ARCH  1
  • kernel/arch/sparc32/src/context.S

    r2a13328 r208b5f5  
    5151                subcc %g1, 1, %g1
    5252                bg 1b
    53        
    54         save %sp, -64, %sp
     53                save %sp, -64, %sp
    5554       
    5655        mov 7, %g1
     
    5857                subcc %g1, 1, %g1
    5958                bg 1b
    60        
    61         restore
     59                restore
    6260       
    6361        CONTEXT_SAVE_ARCH_CORE %o0
     
    8886                subcc %g1, 1, %g1
    8987                bg 1b
    90        
    91         save %sp, -64, %sp
     88                save %sp, -64, %sp
    9289       
    9390        mov 7, %g1
     
    9592                subcc %g1, 1, %g1
    9693                bg 1b
    97        
    98         restore
     94                restore
    9995       
    10096        CONTEXT_RESTORE_ARCH_CORE %o0
  • kernel/arch/sparc32/src/debug/stacktrace.c

    r2a13328 r208b5f5  
    6565bool kernel_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
    6666{
    67         uint64_t *stack = (void *) ctx->fp;
     67        uint32_t *stack = (void *) ctx->fp;
    6868        alloc_window_and_flush();
    6969        *prev = stack[FRAME_OFFSET_FP_PREV];
     
    7373bool kernel_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
    7474{
    75         uint64_t *stack = (void *) ctx->fp;
     75        uint32_t *stack = (void *) ctx->fp;
    7676        alloc_window_and_flush();
    7777        *ra = stack[FRAME_OFFSET_RA];
  • kernel/arch/sparc32/src/machine/leon3/leon3.c

    r2a13328 r208b5f5  
    120120        grlib_irqmp_clear(&machine.irqmp, irqnum);
    121121       
    122         irq_t *irq = irq_dispatch_and_lock(irqnum);
     122        irq_t *irq = irq_dispatch_and_lock(exc);
    123123        if (irq) {
    124124                irq->handler(irq);
     
    140140static void leon3_input_init(void)
    141141{
    142 #if 0
    143142        grlib_uart_t *scons_inst;
    144143       
     
    158157                }
    159158        }
    160 #endif
    161159}
    162160
  • kernel/arch/sparc32/src/mm/tlb.c

    r2a13328 r208b5f5  
    3232
    3333#include <mm/tlb.h>
     34#include <arch/arch.h>
    3435#include <arch/mm/asid.h>
     36#include <arch/mm/as.h>
     37#include <arch/mm/page.h>
    3538#include <arch/asm.h>
    3639#include <typedefs.h>
     
    3841void tlb_invalidate_all(void)
    3942{
     43        asi_u32_write(ASI_MMUCACHE, 0, 1);
     44        asi_u32_write(ASI_MMUFLUSH, 0x400, 1);
    4045}
    4146
  • kernel/arch/sparc32/src/sparc32.c

    r2a13328 r208b5f5  
    5555char memcpy_from_uspace_failover_address;
    5656char memcpy_to_uspace_failover_address;
     57
    5758static bootinfo_t machine_bootinfo;
    5859
     
    104105void arch_post_smp_init(void)
    105106{
     107        machine_input_init();
    106108}
    107109
  • kernel/arch/sparc32/src/trap_table.S

    r2a13328 r208b5f5  
    165165        save
    166166       
    167         ldd [%sp +  0], %l0
    168         ldd [%sp +  8], %l2
     167        ldd [%sp + 0], %l0
     168        ldd [%sp + 8], %l2
    169169        ldd [%sp + 16], %l4
    170170        ldd [%sp + 24], %l6
     
    430430        nop
    431431       
    432        
    433432        1:
    434433                /* Rotate WIM on bit LEFT, we have 8 windows */
     
    442441                mov %g0, %wim
    443442                nop; nop; nop
    444                
     443       
    445444        /* Kernel: */
    446445        restore
     
    563562                mov %psr, %l0
    564563                or %l0, (1 << 5), %l0
     564                or %l0, 0xf00, %l0
    565565                mov %l0, %psr
    566566                nop
     
    568568                nop
    569569                nop
    570                
    571                 /* Get UWB address */
    572                 ##      switch_to_invalid %g5, %g6
    573                 ##      mov %l6, %g1
    574                 ##      switch_back %g5, %g6
    575570               
    576571                /* Flush windows to stack */
     
    582577                add %sp, 128, %o1
    583578               
    584                 /* Return from handler */
     579                /* Return from handler (leave PIL disabled) */
    585580                ld [%sp + 92], %l1
    586581                ld [%sp + 96], %l2
    587582                ld [%sp + 100], %l0
     583                or %l0, 0xf00, %l0
    588584                mov %l0, %psr
    589585                nop
     
    653649                ld [%sp + 116], %g4
    654650                ld [%sp + 120], %g7
     651               
    655652                mov %l3, %sp
    656653                b 10f
     
    659656        9:
    660657                inline_restore_kernel
     658               
    661659                ld [%sp + 104], %g1
    662660                ld [%sp + 108], %g2
     
    664662                ld [%sp + 116], %g4
    665663                ld [%sp + 120], %g7
     664       
     665                /* Restore old sp */
     666                add %sp, 128, %sp
    666667       
    667668        10:
     
    716717                switch_back %g5, %g6
    717718                mov %g7, %sp
    718                 ##      mov %sp, %fp
    719719       
    720720        5:
     
    733733                st %l0, [%sp + 120]
    734734               
    735                 /* Enable traps */
     735                /* Enable traps (without PIL) */
    736736                mov %psr, %l0
    737737                or %l0, (1 << 5), %l0
     738                or %l0, 0xf00, %l0
    738739                mov %l0, %psr
    739740                nop
     
    747748               
    748749                /* Jump to actual subroutine */
    749                 mov %g2, %o0
    750750                call irq_exception
    751751                add %sp, 128, %o1
    752752               
    753                 /* Return from handler */
     753                /* Return from handler (leave PIL disabled) */
    754754                ld [%sp + 92], %l1
    755755                ld [%sp + 96], %l2
    756756                ld [%sp + 100], %l0
     757                or %l0, 0xf00, %l0
    757758                mov %l0, %psr
    758759                nop
     
    766767                 * and save uwb address for future use.
    767768                 */
    768                 if_from_kernel 6f
     769                if_from_kernel 9f
    769770                switch_to_invalid %g5, %g6
    770771                clr %l7
     
    797798                ba 0b
    798799                nop
    799                
     800       
    800801        /*
    801802         * We've restored all user space windows. Now time to
     
    815816                switch_back %g5, %g6
    816817               
    817                 /* If next window is invalid, do inline restore */
    818         6:
    819                 get_wim_number %g6
    820                 get_cwp %g7
    821                 inc %g7
    822                 and %g7, 0x7, %g7
    823                 cmp %g6, %g7
    824                 bne 8f
    825                
    826                 if_from_kernel 7f
    827                
    828                 inline_restore_uspace %g1
    829                 switch_to_invalid %g5, %g6
    830                 mov %g1, %l6
    831                 switch_back %g5, %g6
    832                 b 8f
    833                 nop
    834        
    835         7:
    836                 inline_restore_kernel
    837        
    838         8:
     818                mov %sp, %l3
     819                sub %g2, 128, %sp
    839820                ld [%sp + 104], %g1
    840821                ld [%sp + 108], %g2
     
    842823                ld [%sp + 116], %g4
    843824                ld [%sp + 120], %g7
     825               
     826                mov %l3, %sp
     827                b 10f
     828                nop
     829       
     830        9:
     831                inline_restore_kernel
     832               
     833                ld [%sp + 104], %g1
     834                ld [%sp + 108], %g2
     835                ld [%sp + 112], %g3
     836                ld [%sp + 116], %g4
     837                ld [%sp + 120], %g7
     838               
     839                /* Restore old sp */
     840                add %sp, 128, %sp
     841       
     842        10:
    844843                jmp %l1
    845844                rett %l2
     
    892891                switch_back %g5, %g6
    893892                mov %g7, %sp
    894                 ##      mov %sp, %fp
     893                ## mov %sp, %fp
    895894               
    896895        5:
     
    909908                st %l0, [%sp + 120]
    910909               
    911                 /* Enable traps */
     910                /* Enable traps (without PIL) */
    912911                mov %psr, %l0
    913912                or %l0, (1 << 5), %l0
     913                or %l0, 0xf00, %l0
    914914                mov %l0, %psr
    915915                nop
     
    933933                mov %i5, %o5
    934934               
    935                 /* Return from handler */
     935                /* Return from handler (with PIL disabled) */
    936936                ld [%sp + 92], %l1
    937937                ld [%sp + 96], %l2
     
    940940                mov %psr, %l1
    941941                and %l1, 0xf, %l1
     942                or %l1, 0x00000f00, %l1
    942943                and %l0, 0xfffffff0, %l0
    943944                or %l0, %l1, %l0
     
    10091010                ld [%sp + 116], %g4
    10101011                ld [%sp + 120], %g7
     1012               
    10111013                mov %l1, %sp
     1014                nop
     1015                nop
     1016                nop
     1017               
    10121018                jmp %l2
    10131019                rett %l2 + 4
     
    10351041#define INTERRUPT(_vector, _priority) \
    10361042        .org trap_table + _vector * TRAP_ENTRY_SIZE; \
    1037         mov %psr, %l0 ; \
    1038         mov _priority, %g2 ; \
     1043        mov _priority, %o0 ; \
    10391044        b interrupt_trap ; \
     1045        nop ;
    10401046        nop ;
    10411047
  • kernel/genarch/src/drivers/grlib/irqmp.c

    r2a13328 r208b5f5  
    4444            PAGE_NOT_CACHEABLE);
    4545       
     46        /* Clear all pending interrupts */
     47        pio_write_32(&irqc->regs->clear, 0xffffffff);
     48       
    4649        /* Mask all interrupts */
    47         pio_write_32((void *) irqc->regs + GRLIB_IRQMP_MASK_OFFSET, 0x8);
     50        pio_write_32((void *) irqc->regs + GRLIB_IRQMP_MASK_OFFSET, 0);
    4851}
    4952
     
    6265void grlib_irqmp_clear(grlib_irqmp_t *irqc, unsigned int inum)
    6366{
    64         inum++;
    6567        pio_write_32(&irqc->regs->clear, (1 << inum));
    6668}
     
    7173            GRLIB_IRQMP_MASK_OFFSET);
    7274       
    73         src++;
    7475        mask &= ~(1 << src);
    75        
    7676        pio_write_32((void *) irqc->regs + GRLIB_IRQMP_MASK_OFFSET, mask);
    7777}
     
    8282            GRLIB_IRQMP_MASK_OFFSET);
    8383       
    84         src++;
    8584        mask |= (1 << src);
    86        
    8785        pio_write_32((void *) irqc->regs + GRLIB_IRQMP_MASK_OFFSET, mask);
    8886}
  • uspace/lib/c/arch/sparc32/include/libarch/tls.h

    r2a13328 r208b5f5  
    4747static inline void __tcb_set(tcb_t *tcb)
    4848{
    49         asm volatile(
     49        asm volatile (
    5050                "mov %0, %%g7\n"
    5151                :: "r" (tcb)
     
    5858        void *retval;
    5959       
    60         asm volatile(
     60        asm volatile (
    6161                "mov %%g7, %0\n"
    6262                : "=r" (retval)
  • uspace/lib/c/arch/sparc32/src/entry.s

    r2a13328 r208b5f5  
    4949                subcc %g1, 1, %g1
    5050                bg 1b
    51         save %sp, -64, %sp
     51                save %sp, -64, %sp
    5252       
    5353        mov 7, %g1
Note: See TracChangeset for help on using the changeset viewer.