Changeset 26e7d6d in mainline for kernel/arch


Ignore:
Timestamp:
2011-09-19T16:31:00Z (14 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
a347a11
Parents:
3842a955 (diff), 086290d (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes

Location:
kernel/arch
Files:
45 added
4 deleted
90 edited
7 moved

Legend:

Unmodified
Added
Removed

  • kernel/arch/abs32le/include/istate.h

    r3842a955 r26e7d6d  
    3636#define KERN_abs32le_ISTATE_H_
    3737
     38#include <trace.h>
     39
    3840#ifdef KERNEL
    3941
    40 #include <typedefs.h>
    4142#include <verify.h>
    42 #include <trace.h>
    4343
    4444#else /* KERNEL */
    4545
    46 #include <sys/types.h>
    47 
    48 #define NO_TRACE
    4946#define REQUIRES_EXTENT_MUTABLE(arg)
    5047#define WRITES(arg)

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

    r3842a955 r26e7d6d  
    3939#define FRAME_SIZE   (1 << FRAME_WIDTH)
    4040
    41 #ifdef KERNEL
    42 
    4341#include <typedefs.h>
    4442
    … …  
    4644extern void physmem_print(void);
    4745
    48 #endif /* KERNEL */
    49 
    5046#endif
    5147

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

    r3842a955 r26e7d6d  
    4141#define PAGE_WIDTH  FRAME_WIDTH
    4242#define PAGE_SIZE   FRAME_SIZE
    43 
    44 #ifdef KERNEL
    4543
    4644#define KA2PA(x)  (((uintptr_t) (x)) - UINT32_C(0x80000000))
    … …  
    178176extern void page_fault(unsigned int, istate_t *);
    179177
    180 #endif /* KERNEL */
    181 
    182178#endif
    183179

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

    r3842a955 r26e7d6d  
    3636#include <typedefs.h>
    3737#include <arch.h>
    38 #include <proc/uarg.h>
     38#include <abi/proc/uarg.h>
    3939#include <mm/as.h>
    40 
    4140
    4241void userspace(uspace_arg_t *kernel_uarg)

  • kernel/arch/amd64/Makefile.inc

    r3842a955 r26e7d6d  
    4141# is fixed.
    4242#
    43 # If GCC generates a code for tail call, instead of generating ..
     43# When GCC generates a code for tail call, instead of generating ..
    4444#
    4545#   jmp *fnc
    … …  
    4848#
    4949#   jmp *$fnc
     50#
     51# See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=48385 for reference.
    5052#
    5153

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

    r3842a955 r26e7d6d  
    4141#include <trace.h>
    4242
     43#define IO_SPACE_BOUNDARY       ((void *) (64 * 1024))
     44
    4345/** Return base address of current stack.
    4446 *
    … …  
    8789NO_TRACE static inline uint8_t pio_read_8(ioport8_t *port)
    8890{
    89         uint8_t val;
    90        
    91         asm volatile (
    92                 "inb %w[port], %b[val]\n"
    93                 : [val] "=a" (val)
    94                 : [port] "d" (port)
    95         );
    96        
    97         return val;
     91        if (port < (ioport8_t *) IO_SPACE_BOUNDARY) {
     92                uint8_t val;
     93               
     94                asm volatile (
     95                        "inb %w[port], %b[val]\n"
     96                        : [val] "=a" (val)
     97                        : [port] "d" (port)
     98                );
     99               
     100                return val;
     101        } else
     102                return (uint8_t) *port;
    98103}
    99104
    … …  
    108113NO_TRACE static inline uint16_t pio_read_16(ioport16_t *port)
    109114{
    110         uint16_t val;
    111        
    112         asm volatile (
    113                 "inw %w[port], %w[val]\n"
    114                 : [val] "=a" (val)
    115                 : [port] "d" (port)
    116         );
    117        
    118         return val;
     115        if (port < (ioport16_t *) IO_SPACE_BOUNDARY) {
     116                uint16_t val;
     117               
     118                asm volatile (
     119                        "inw %w[port], %w[val]\n"
     120                        : [val] "=a" (val)
     121                        : [port] "d" (port)
     122                );
     123               
     124                return val;
     125        } else
     126                return (uint16_t) *port;
    119127}
    120128
    … …  
    129137NO_TRACE static inline uint32_t pio_read_32(ioport32_t *port)
    130138{
    131         uint32_t val;
    132        
    133         asm volatile (
    134                 "inl %w[port], %[val]\n"
    135                 : [val] "=a" (val)
    136                 : [port] "d" (port)
    137         );
    138        
    139         return val;
     139        if (port < (ioport32_t *) IO_SPACE_BOUNDARY) {
     140                uint32_t val;
     141               
     142                asm volatile (
     143                        "inl %w[port], %[val]\n"
     144                        : [val] "=a" (val)
     145                        : [port] "d" (port)
     146                );
     147               
     148                return val;
     149        } else
     150                return (uint32_t) *port;
    140151}
    141152
    … …  
    150161NO_TRACE static inline void pio_write_8(ioport8_t *port, uint8_t val)
    151162{
    152         asm volatile (
    153                 "outb %b[val], %w[port]\n"
    154                 :: [val] "a" (val),
    155                    [port] "d" (port)
    156         );
     163        if (port < (ioport8_t *) IO_SPACE_BOUNDARY) {
     164                asm volatile (
     165                        "outb %b[val], %w[port]\n"
     166                        :: [val] "a" (val), [port] "d" (port)
     167                );     
     168        } else
     169                *port = val;
    157170}
    158171
    … …  
    167180NO_TRACE static inline void pio_write_16(ioport16_t *port, uint16_t val)
    168181{
    169         asm volatile (
    170                 "outw %w[val], %w[port]\n"
    171                 :: [val] "a" (val),
    172                    [port] "d" (port)
    173         );
     182        if (port < (ioport16_t *) IO_SPACE_BOUNDARY) {
     183                asm volatile (
     184                        "outw %w[val], %w[port]\n"
     185                        :: [val] "a" (val), [port] "d" (port)
     186                );
     187        } else
     188                *port = val;
    174189}
    175190
    … …  
    184199NO_TRACE static inline void pio_write_32(ioport32_t *port, uint32_t val)
    185200{
    186         asm volatile (
    187                 "outl %[val], %w[port]\n"
    188                 :: [val] "a" (val),
    189                    [port] "d" (port)
    190         );
     201        if (port < (ioport32_t *) IO_SPACE_BOUNDARY) {
     202                asm volatile (
     203                        "outl %[val], %w[port]\n"
     204                        :: [val] "a" (val), [port] "d" (port)
     205                );
     206        } else
     207                *port = val;
    191208}
    192209

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

    r3842a955 r26e7d6d  
    3636#define KERN_amd64_CONTEXT_H_
    3737
    38 #ifdef KERNEL
    39 
    4038#include <typedefs.h>
    4139
    … …  
    5250                (c)->rbp = 0; \
    5351        } while (0)
    54 
    55 #endif /* KERNEL */
    5652
    5753/* We include only registers that must be preserved

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

    r3842a955 r26e7d6d  
    3636#define KERN_amd64_ISTATE_H_
    3737
    38 #ifdef KERNEL
    39 
    40 #include <typedefs.h>
    4138#include <trace.h>
    42 
    43 #else /* KERNEL */
    44 
    45 #include <sys/types.h>
    46 
    47 #define NO_TRACE
    48 
    49 #endif /* KERNEL */
    5039
    5140/** This is passed to interrupt handlers */

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

    r3842a955 r26e7d6d  
    3939#define FRAME_SIZE   (1 << FRAME_WIDTH)
    4040
    41 #ifdef KERNEL
    4241#ifndef __ASM__
    4342
    … …  
    4948
    5049#endif /* __ASM__ */
    51 #endif /* KERNEL */
    5250
    5351#endif

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

    r3842a955 r26e7d6d  
    5050#define PAGE_WIDTH  FRAME_WIDTH
    5151#define PAGE_SIZE   FRAME_SIZE
    52 
    53 #ifdef KERNEL
    5452
    5553#ifndef __ASM__
    … …  
    231229#endif /* __ASM__ */
    232230
    233 #endif /* KERNEL */
    234 
    235231#endif
    236232

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

    r3842a955 r26e7d6d  
    3838#include <typedefs.h>
    3939#include <arch.h>
    40 #include <proc/uarg.h>
     40#include <abi/proc/uarg.h>
    4141#include <mm/as.h>
    42 
    4342
    4443/** Enter userspace

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

    r3842a955 r26e7d6d  
    3535#define KERN_arm32_ISTATE_H_
    3636
     37#include <trace.h>
     38
     39#ifdef KERNEL
     40
    3741#include <arch/regutils.h>
    3842
    39 #ifdef KERNEL
    40 #include <typedefs.h>
    41 #include <trace.h>
    42 #else
    43 #include <sys/types.h>
    44 #define NO_TRACE
    45 #endif
     43#else /* KERNEL */
     44
     45#include <libarch/regutils.h>
     46
     47#endif /* KERNEL */
    4648
    4749/** Struct representing CPU state saved when an exception occurs. */

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

    r3842a955 r26e7d6d  
    4040#define FRAME_SIZE   (1 << FRAME_WIDTH)
    4141
    42 #ifdef KERNEL
    4342#ifndef __ASM__
    4443
    … …  
    6968
    7069#endif /* __ASM__ */
    71 #endif /* KERNEL */
    7270
    7371#endif

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

    r3842a955 r26e7d6d  
    5252#       define PA2KA(x) ((x) + 0x80000000)
    5353#endif
    54 
    55 #ifdef KERNEL
    5654
    5755/* Number of entries in each level. */
    … …  
    320318#endif /* __ASM__ */
    321319
    322 #endif /* KERNEL */
    323 
    324320#endif
    325321

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

    r3842a955 r26e7d6d  
    3030 * @{
    3131 */
    32 /** 
     32/**
    3333 * @file
    3434 * @brief Utilities for convenient manipulation with ARM registers.
    … …  
    3838#define KERN_arm32_REGUTILS_H_
    3939
    40 #define STATUS_REG_IRQ_DISABLED_BIT (1 << 7)
    41 #define STATUS_REG_MODE_MASK        0x1f
     40#define STATUS_REG_IRQ_DISABLED_BIT  (1 << 7)
     41#define STATUS_REG_MODE_MASK         0x1f
    4242
    43 #define CP15_R1_HIGH_VECTORS_BIT    (1 << 13)
    44 
     43#define CP15_R1_HIGH_VECTORS_BIT     (1 << 13)
    4544
    4645/* ARM Processor Operation Modes */
    47 #define USER_MODE         0x10
    48 #define FIQ_MODE          0x11
    49 #define IRQ_MODE          0x12
    50 #define SUPERVISOR_MODE   0x13
    51 #define ABORT_MODE        0x17
    52 #define UNDEFINED_MODE    0x1b
    53 #define SYSTEM_MODE       0x1f
     46#define USER_MODE        0x10
     47#define FIQ_MODE         0x11
     48#define IRQ_MODE         0x12
     49#define SUPERVISOR_MODE  0x13
     50#define ABORT_MODE       0x17
     51#define UNDEFINED_MODE   0x1b
     52#define SYSTEM_MODE      0x1f
    5453
    5554/* [CS]PRS manipulation macros */
    56 #define GEN_STATUS_READ(nm,reg) \
    57 static inline uint32_t nm## _status_reg_read(void) \
    58 { \
    59         uint32_t retval; \
    60         asm volatile( \
    61                 "mrs %[retval], " #reg \
    62                 : [retval] "=r" (retval) \
    63         ); \
    64         return retval; \
    65 }
     55#define GEN_STATUS_READ(nm, reg) \
     56        static inline uint32_t nm## _status_reg_read(void) \
     57        { \
     58                uint32_t retval; \
     59                \
     60                asm volatile ( \
     61                        "mrs %[retval], " #reg \
     62                        : [retval] "=r" (retval) \
     63                ); \
     64                \
     65                return retval; \
     66        }
    6667
    67 #define GEN_STATUS_WRITE(nm,reg,fieldname, field) \
    68 static inline void nm## _status_reg_ ##fieldname## _write(uint32_t value) \
    69 { \
    70         asm volatile( \
    71                 "msr " #reg "_" #field ", %[value]" \
    72                 :: [value] "r" (value) \
    73         ); \
    74 }
     68#define GEN_STATUS_WRITE(nm, reg, fieldname, field) \
     69        static inline void nm## _status_reg_ ##fieldname## _write(uint32_t value) \
     70        { \
     71                asm volatile ( \
     72                        "msr " #reg "_" #field ", %[value]" \
     73                        :: [value] "r" (value) \
     74                ); \
     75        }
    7576
     77/** Return the value of CPSR (Current Program Status Register). */
     78GEN_STATUS_READ(current, cpsr);
    7679
    77 /** Returns the value of CPSR (Current Program Status Register). */
    78 GEN_STATUS_READ(current, cpsr)
    79 
    80 
    81 /** Sets control bits of CPSR. */
     80/** Set control bits of CPSR. */
    8281GEN_STATUS_WRITE(current, cpsr, control, c);
    8382
    84 
    85 /** Returns the value of SPSR (Saved Program Status Register). */
    86 GEN_STATUS_READ(saved, spsr)
    87 
     83/** Return the value of SPSR (Saved Program Status Register). */
     84GEN_STATUS_READ(saved, spsr);
    8885
    8986#endif

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

    r3842a955 r26e7d6d  
    3737#include <config.h>
    3838#include <genarch/fb/fb.h>
    39 #include <genarch/fb/visuals.h>
     39#include <abi/fb/visuals.h>
    4040#include <sysinfo/sysinfo.h>
    4141#include <console/console.h>

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

    r3842a955 r26e7d6d  
    3939#include <mm/page.h>
    4040#include <genarch/fb/fb.h>
    41 #include <genarch/fb/visuals.h>
     41#include <abi/fb/visuals.h>
    4242#include <genarch/drivers/s3c24xx_uart/s3c24xx_uart.h>
    4343#include <genarch/drivers/s3c24xx_irqc/s3c24xx_irqc.h>
    … …  
    158158{
    159159#ifdef CONFIG_FB
    160         parea_t fb_parea;
    161 
    162160        fb_properties_t prop = {
    163161                .addr = GTA02_FB_BASE,
    … …  
    170168
    171169        outdev_t *fb_dev = fb_init(&prop);
    172         if (fb_dev) {
     170        if (fb_dev)
    173171                stdout_wire(fb_dev);
    174                 fb_parea.pbase = GTA02_FB_BASE;
    175                 fb_parea.frames = 150;
    176                 fb_parea.unpriv = false;
    177                 ddi_parea_register(&fb_parea);
    178         }
    179172#endif
    180173
    181174        /* Initialize serial port of the debugging console. */
    182         s3c24xx_uart_io_t *scons_io;
    183 
    184         scons_io = (void *) hw_map(GTA02_SCONS_BASE, PAGE_SIZE);
    185         gta02_scons_dev = s3c24xx_uart_init(scons_io, S3C24XX_INT_UART2);
     175        gta02_scons_dev =
     176            s3c24xx_uart_init(GTA02_SCONS_BASE, S3C24XX_INT_UART2);
    186177
    187178        if (gta02_scons_dev) {

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

    r3842a955 r26e7d6d  
    4848#include <arch/mach/integratorcp/integratorcp.h>
    4949#include <genarch/fb/fb.h>
    50 #include <genarch/fb/visuals.h>
     50#include <abi/fb/visuals.h>
    5151#include <ddi/ddi.h>
    5252#include <print.h>
    5353
    5454#define SDRAM_SIZE      (sdram[((*(uint32_t *)(ICP_CMCR+ICP_SDRAMCR_OFFSET) & ICP_SDRAM_MASK) >> 2)])
    55 static parea_t fb_parea;
    5655static icp_hw_map_t icp_hw_map;
    5756static irq_t icp_timer_irq;
    … …  
    296295       
    297296        outdev_t *fbdev = fb_init(&prop);
    298         if (fbdev) {
     297        if (fbdev)
    299298                stdout_wire(fbdev);
    300                 fb_parea.pbase = ICP_FB;
    301                 fb_parea.frames = 300;
    302                 fb_parea.unpriv = false;
    303                 ddi_parea_register(&fb_parea);
    304         }
    305299#endif
    306300}

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

    r3842a955 r26e7d6d  
    3838#include <mm/page.h>
    3939#include <genarch/fb/fb.h>
    40 #include <genarch/fb/visuals.h>
     40#include <abi/fb/visuals.h>
    4141#include <genarch/drivers/dsrln/dsrlnin.h>
    4242#include <genarch/drivers/dsrln/dsrlnout.h>

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

    r3842a955 r26e7d6d  
    8686}
    8787
     88/** @}
     89 */

  • kernel/arch/ia32/Makefile.inc

    r3842a955 r26e7d6d  
    4343## Accepted CPUs
    4444#
     45
     46ifeq ($(PROCESSOR),i486)
     47        CMN2 = -march=i486
     48endif
    4549
    4650ifeq ($(PROCESSOR),athlon_xp)

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

    r3842a955 r26e7d6d  
    101101GEN_WRITE_REG(dr7)
    102102
     103#define IO_SPACE_BOUNDARY       ((void *) (64 * 1024))
     104
    103105/** Byte to port
    104106 *
    … …  
    111113NO_TRACE static inline void pio_write_8(ioport8_t *port, uint8_t val)
    112114{
    113         asm volatile (
    114                 "outb %b[val], %w[port]\n"
    115                 :: [val] "a" (val),
    116                    [port] "d" (port)
    117         );
     115        if (port < (ioport8_t *) IO_SPACE_BOUNDARY) {
     116                asm volatile (
     117                        "outb %b[val], %w[port]\n"
     118                        :: [val] "a" (val), [port] "d" (port)
     119                );     
     120        } else
     121                *port = val;
    118122}
    119123
    … …  
    128132NO_TRACE static inline void pio_write_16(ioport16_t *port, uint16_t val)
    129133{
    130         asm volatile (
    131                 "outw %w[val], %w[port]\n"
    132                 :: [val] "a" (val),
    133                    [port] "d" (port)
    134         );
     134        if (port < (ioport16_t *) IO_SPACE_BOUNDARY) {
     135                asm volatile (
     136                        "outw %w[val], %w[port]\n"
     137                        :: [val] "a" (val), [port] "d" (port)
     138                );
     139        } else
     140                *port = val;
    135141}
    136142
    … …  
    145151NO_TRACE static inline void pio_write_32(ioport32_t *port, uint32_t val)
    146152{
    147         asm volatile (
    148                 "outl %[val], %w[port]\n"
    149                 :: [val] "a" (val),
    150                    [port] "d" (port)
    151         );
     153        if (port < (ioport32_t *) IO_SPACE_BOUNDARY) {
     154                asm volatile (
     155                        "outl %[val], %w[port]\n"
     156                        :: [val] "a" (val), [port] "d" (port)
     157                );
     158        } else
     159                *port = val;
    152160}
    153161
    … …  
    162170NO_TRACE static inline uint8_t pio_read_8(ioport8_t *port)
    163171{
    164         uint8_t val;
    165        
    166         asm volatile (
    167                 "inb %w[port], %b[val]\n"
    168                 : [val] "=a" (val)
    169                 : [port] "d" (port)
    170         );
    171        
    172         return val;
     172        if (((void *)port) < IO_SPACE_BOUNDARY) {
     173                uint8_t val;
     174               
     175                asm volatile (
     176                        "inb %w[port], %b[val]\n"
     177                        : [val] "=a" (val)
     178                        : [port] "d" (port)
     179                );
     180               
     181                return val;
     182        } else
     183                return (uint8_t) *port;
    173184}
    174185
    … …  
    183194NO_TRACE static inline uint16_t pio_read_16(ioport16_t *port)
    184195{
    185         uint16_t val;
    186        
    187         asm volatile (
    188                 "inw %w[port], %w[val]\n"
    189                 : [val] "=a" (val)
    190                 : [port] "d" (port)
    191         );
    192        
    193         return val;
     196        if (((void *)port) < IO_SPACE_BOUNDARY) {
     197                uint16_t val;
     198               
     199                asm volatile (
     200                        "inw %w[port], %w[val]\n"
     201                        : [val] "=a" (val)
     202                        : [port] "d" (port)
     203                );
     204               
     205                return val;
     206        } else
     207                return (uint16_t) *port;
    194208}
    195209
    … …  
    204218NO_TRACE static inline uint32_t pio_read_32(ioport32_t *port)
    205219{
    206         uint32_t val;
    207        
    208         asm volatile (
    209                 "inl %w[port], %[val]\n"
    210                 : [val] "=a" (val)
    211                 : [port] "d" (port)
    212         );
    213        
    214         return val;
     220        if (((void *)port) < IO_SPACE_BOUNDARY) {
     221                uint32_t val;
     222               
     223                asm volatile (
     224                        "inl %w[port], %[val]\n"
     225                        : [val] "=a" (val)
     226                        : [port] "d" (port)
     227                );
     228               
     229                return val;
     230        } else
     231                return (uint32_t) *port;
    215232}
    216233
    … …  
    311328}
    312329
     330#ifndef PROCESSOR_i486
     331
    313332/** Write to MSR */
    314333NO_TRACE static inline void write_msr(uint32_t msr, uint64_t value)
    … …  
    335354        return ((uint64_t) dx << 32) | ax;
    336355}
     356
     357#endif /* PROCESSOR_i486 */
    337358
    338359

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

    r3842a955 r26e7d6d  
    121121        asm volatile (
    122122                "0:\n"
     123#ifndef PROCESSOR_i486
    123124                "pause\n"        /* Pentium 4's HT love this instruction */
     125#endif
    124126                "mov %[count], %[tmp]\n"
    125127                "testl %[tmp], %[tmp]\n"

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

    r3842a955 r26e7d6d  
    4343#define MULTIBOOT_HEADER_FLAGS  0x00010003
    4444
     45#define MULTIBOOT_LOADER_MAGIC  0x2BADB002
     46
    4547#ifndef __ASM__
    4648

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

    r3842a955 r26e7d6d  
    3636#define KERN_ia32_CONTEXT_H_
    3737
    38 #ifdef KERNEL
    39 
    4038#include <typedefs.h>
    4139
    … …  
    5755        } while (0)
    5856
    59 #endif /* KERNEL */
    60 
    6157/*
    6258 * Only save registers that must be preserved across

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

    r3842a955 r26e7d6d  
    4040NO_TRACE static inline uint64_t get_cycle(void)
    4141{
     42#ifdef PROCESSOR_i486
     43        return 0;
     44#else
    4245        uint64_t v;
    4346       
    … …  
    4851       
    4952        return v;
     53#endif
    5054}
    5155

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

    r3842a955 r26e7d6d  
    2727 */
    2828
    29 /** @addtogroup ia32   
     29/** @addtogroup ia32
    3030 * @{
    3131 */
    … …  
    3636#define KERN_ia32_ELF_H_
    3737
    38 #define ELF_MACHINE             EM_386
    39 #define ELF_DATA_ENCODING       ELFDATA2LSB
    40 #define ELF_CLASS               ELFCLASS32
     38#define ELF_MACHINE        EM_386
     39#define ELF_DATA_ENCODING  ELFDATA2LSB
     40#define ELF_CLASS          ELFCLASS32
    4141
    4242#endif

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

    r3842a955 r26e7d6d  
    3636#define KERN_ia32_ISTATE_H_
    3737
    38 #ifdef KERNEL
    39 
    40 #include <typedefs.h>
    4138#include <trace.h>
    42 
    43 #else /* KERNEL */
    44 
    45 #include <sys/types.h>
    46 
    47 #define NO_TRACE
    48 
    49 #endif /* KERNEL */
    5039
    5140typedef struct istate {

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

    r3842a955 r26e7d6d  
    3939#define FRAME_SIZE   (1 << FRAME_WIDTH)
    4040
    41 #ifdef KERNEL
    4241#ifndef __ASM__
    4342
    … …  
    5049
    5150#endif /* __ASM__ */
    52 #endif /* KERNEL */
    5351
    5452#endif

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

    r3842a955 r26e7d6d  
    4242#define PAGE_SIZE   FRAME_SIZE
    4343
    44 #ifdef KERNEL
    45 
    4644#ifndef __ASM__
    4745
    … …  
    201199#endif /* __ASM__ */
    202200
    203 #endif /* KERNEL */
    204 
    205201#endif
    206202

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

    r3842a955 r26e7d6d  
    405405        xorl %eax, %eax
    406406        cmpl $(GDT_SELECTOR(KTEXT_DES)), ISTATE_OFFSET_CS(%esp)
     407#ifdef PROCESSOR_i486
     408        jz 0f
     409                movl %eax, %ebp
     410        0:
     411#else
    407412        cmovnzl %eax, %ebp
     413#endif
    408414
    409415        movl %ebp, ISTATE_OFFSET_EBP_FRAME(%esp)

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

    r3842a955 r26e7d6d  
    9797        pm_status $status_prot
    9898       
     99#include "vesa_prot.inc"
     100       
     101#ifndef PROCESSOR_i486
     102       
     103        pm_status $status_prot2
     104       
    99105        movl $(INTEL_CPUID_LEVEL), %eax
    100106        cpuid
    … …  
    105111        cpuid
    106112        bt $(INTEL_PSE), %edx
    107         jc pse_supported
     113        jnc pse_unsupported
     114               
     115                /* Map kernel and turn paging on */
     116                pm_status $status_pse
     117                call map_kernel_pse
     118                jmp stack_init
     119       
     120#endif /* PROCESSOR_i486 */
    108121       
    109122        pse_unsupported:
    110123               
    111                 pm_error $err_pse
    112        
    113         pse_supported:
    114        
    115 #include "vesa_prot.inc"
    116        
    117         /* Map kernel and turn paging on */
    118         call map_kernel
     124                /* Map kernel and turn paging on */
     125                pm_status $status_non_pse
     126                call map_kernel
     127       
     128        stack_init:
    119129       
    120130        /* Create the first stack frame */
    … …  
    122132        movl %esp, %ebp
    123133       
    124         pm2_status $status_prot2
     134        pm2_status $status_prot3
    125135       
    126136        /* Call arch_pre_main(grub_eax, grub_ebx) */
    … …  
    140150                jmp hlt0
    141151
    142 /** Setup mapping for the kernel.
     152/** Setup mapping for the kernel (PSE variant)
    143153 *
    144154 * Setup mapping for both the unmapped and mapped sections
    … …  
    146156 *
    147157 */
    148 .global map_kernel
    149 map_kernel:
     158.global map_kernel_pse
     159map_kernel_pse:
     160        /* Paging features */
    150161        movl %cr4, %ecx
    151162        orl $(1 << 4), %ecx      /* PSE on */
    … …  
    158169        xorl %ebx, %ebx
    159170       
    160         floop:
     171        floop_pse:
    161172                movl $((1 << 7) | (1 << 1) | (1 << 0)), %eax
    162173                orl %ebx, %eax
    … …  
    169180                incl %ecx
    170181                cmpl $512, %ecx
    171                 jl floop
     182                jl floop_pse
    172183       
    173184        movl %esi, %cr3
    … …  
    177188        movl %ebx, %cr0
    178189        ret
     190
     191/** Setup mapping for the kernel (non-PSE variant).
     192 *
     193 * Setup mapping for both the unmapped and mapped sections
     194 * of the kernel. For simplicity, we map the entire 4G space.
     195 *
     196 */
     197.global map_kernel
     198map_kernel:
     199        /* Paging features */
     200        movl %cr4, %ecx
     201        andl $(~(1 << 5)), %ecx  /* PAE off */
     202        movl %ecx, %cr4
     203       
     204        call calc_kernel_end
     205        call find_mem_for_pt
     206       
     207        mov kernel_end, %esi
     208        mov free_area, %ecx
     209       
     210        cmpl %esi, %ecx
     211        jbe use_kernel_end
     212               
     213                mov %ecx, %esi
     214               
     215                /* Align address down to 4k */
     216                andl $(~4095), %esi
     217               
     218        use_kernel_end:
     219               
     220                /* Align address to 4k */
     221                addl $4095, %esi
     222                andl $(~4095), %esi
     223               
     224                /* Allocate space for page tables */
     225                movl %esi, pt_loc
     226                movl $ballocs, %edi
     227                andl $0x7fffffff, %edi
     228               
     229                movl %esi, (%edi)
     230                addl $4, %edi
     231                movl $(2 * 1024 * 1024), (%edi)
     232               
     233                /* Fill page tables */
     234                xorl %ecx, %ecx
     235                xorl %ebx, %ebx
     236               
     237                floop_pt:
     238                        movl $((1 << 1) | (1 << 0)), %eax
     239                        orl %ebx, %eax
     240                        movl %eax, (%esi, %ecx, 4)
     241                        addl $(4 * 1024), %ebx
     242                       
     243                        incl %ecx
     244                        cmpl $(512 * 1024), %ecx
     245                       
     246                        jl floop_pt
     247               
     248                /* Fill page directory */
     249                movl $(page_directory + 0), %esi
     250                movl $(page_directory + 2048), %edi
     251                xorl %ecx, %ecx
     252                movl pt_loc, %ebx
     253               
     254                floop:
     255                        movl $((1 << 1) | (1 << 0)), %eax
     256                        orl %ebx, %eax
     257                       
     258                        /* Mapping 0x00000000 + %ecx * 4M => 0x00000000 + %ecx * 4M */
     259                        movl %eax, (%esi, %ecx, 4)
     260                       
     261                        /* Mapping 0x80000000 + %ecx * 4M => 0x00000000 + %ecx * 4M */
     262                        movl %eax, (%edi, %ecx, 4)
     263                        addl $(4 * 1024), %ebx
     264                       
     265                        incl %ecx
     266                        cmpl $512, %ecx
     267                       
     268                        jl floop
     269               
     270                movl %esi, %cr3
     271               
     272                movl %cr0, %ebx
     273                orl $(1 << 31), %ebx  /* paging on */
     274                movl %ebx, %cr0
     275               
     276                ret
     277
     278/** Calculate unmapped address of the end of the kernel. */
     279calc_kernel_end:
     280        movl $hardcoded_load_address, %edi
     281        andl $0x7fffffff, %edi
     282        movl (%edi), %esi
     283        andl $0x7fffffff, %esi
     284       
     285        movl $hardcoded_ktext_size, %edi
     286        andl $0x7fffffff, %edi
     287        addl (%edi), %esi
     288        andl $0x7fffffff, %esi
     289       
     290        movl $hardcoded_kdata_size, %edi
     291        andl $0x7fffffff, %edi
     292        addl (%edi), %esi
     293        andl $0x7fffffff, %esi
     294        movl %esi, kernel_end
     295       
     296        ret
     297
     298/** Find free 2M (+4k for alignment) region where to store page tables */
     299find_mem_for_pt:
     300        /* Check if multiboot info is present */
     301        cmpl $MULTIBOOT_LOADER_MAGIC, grub_eax
     302        je check_multiboot_map
     303               
     304                ret
     305       
     306        check_multiboot_map:
     307               
     308                /* Copy address of the multiboot info to ebx */
     309                movl grub_ebx, %ebx
     310               
     311                /* Check if memory map flag is present */
     312                movl (%ebx), %edx
     313                andl $(1 << 6), %edx
     314                jnz use_multiboot_map
     315                       
     316                        ret
     317               
     318        use_multiboot_map:
     319               
     320                /* Copy address of the memory map to edx */
     321                movl 48(%ebx), %edx
     322                movl %edx, %ecx
     323               
     324                addl 44(%ebx), %ecx
     325               
     326                /* Find a free region at least 2M in size */
     327                check_memmap_loop:
     328                       
     329                        /* Is this a free region? */
     330                        cmp $1, 20(%edx)
     331                        jnz next_region
     332                       
     333                        /* Check size */
     334                        cmp $0, 16(%edx)
     335                        jnz next_region
     336                       
     337                        cmpl $(2 * 1024 * 1024 + 4 * 1024), 12(%edx)
     338                        jbe next_region
     339                       
     340                        cmp $0, 8(%edx)
     341                        jz found_region
     342               
     343                next_region:
     344                       
     345                        cmp %ecx, %edx
     346                        jbe next_region_do
     347                       
     348                                ret
     349               
     350                next_region_do:
     351                       
     352                        addl (%edx), %edx
     353                        addl $4, %edx
     354                        jmp check_memmap_loop
     355                       
     356                found_region:
     357                       
     358                        /* Use end of the found region */
     359                        mov 4(%edx), %ecx
     360                        add 12(%edx), %ecx
     361                        sub $(2 * 1024 * 1024), %ecx
     362                        mov %ecx, free_area
     363                       
     364                        ret
    179365
    180366/** Print string to EGA display (in light red) and halt.
    … …  
    521707grub_eax:
    522708        .long 0
    523 
    524709grub_ebx:
    525710        .long 0
    526711
    527 err_pse:
    528         .asciz "Page Size Extension not supported. System halted."
     712pt_loc:
     713        .long 0
     714kernel_end:
     715        .long 0
     716free_area:
     717        .long 0
    529718
    530719status_prot:
    531720        .asciz "[prot] "
     721status_pse:
     722        .asciz "[pse] "
     723status_non_pse:
     724        .asciz "[non_pse] "
    532725status_vesa_copy:
    533726        .asciz "[vesa_copy] "
    … …  
    538731status_prot2:
    539732        .asciz "[prot2] "
     733status_prot3:
     734        .asciz "[prot3] "
    540735status_main:
    541736        .asciz "[main] "

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

    r3842a955 r26e7d6d  
    154154        mov $e_vesa_init - vesa_init, %di
    155155        push %di
     156        /* Write the "VBE2" signature into the info structure in order
     157         * to get proper mode information. The presence of "VBE2"
     158         * indicates two things:
     159         *
     160         *  - VBE controller information structure is expected to be
     161         *    512 bytes long instead of 256 bytes.
     162         *  - The BIOS should report VBE 3.0 information (potentially
     163         *    including non-standard modes in the mode list).
     164         */
     165        movl $0x32454256, (%di)
    156166        int $0x10
    157167       

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

    r3842a955 r26e7d6d  
    118118                );
    119119        }
    120        
     120
     121#ifndef PROCESSOR_i486
    121122        if (CPU->arch.fi.bits.sep) {
    122123                /* Setup fast SYSENTER/SYSEXIT syscalls */
    123124                syscall_setup_cpu();
    124125        }
     126#endif
    125127}
    126128

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

    r3842a955 r26e7d6d  
    3838
    3939#include <genarch/fb/fb.h>
    40 #include <genarch/fb/visuals.h>
    4140#include <arch/drivers/vesa.h>
    4241#include <console/chardev.h>

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

    r3842a955 r26e7d6d  
    6060        uintptr_t kstk = (uintptr_t) &THREAD->kstack[STACK_SIZE];
    6161       
     62#ifndef PROCESSOR_i486
    6263        if (CPU->arch.fi.bits.sep) {
    6364                /* Set kernel stack for CP3 -> CPL0 switch via SYSENTER */
    6465                write_msr(IA32_MSR_SYSENTER_ESP, kstk - sizeof(istate_t));
    6566        }
     67#endif
    6668       
    6769        /* Set kernel stack for CPL3 -> CPL0 switch via interrupt */

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

    r3842a955 r26e7d6d  
    4242#include <config.h>
    4343#include <synch/waitq.h>
    44 #include <synch/synch.h>
    4544#include <arch/pm.h>
    4645#include <func.h>

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

    r3842a955 r26e7d6d  
    3939#include <arch/pm.h>
    4040
     41#ifndef PROCESSOR_i486
     42
    4143/** Enable & setup support for SYSENTER/SYSEXIT */
    4244void syscall_setup_cpu(void)
    … …  
    5052}
    5153
     54#endif /* PROCESSOR_i486 */
     55
    5256/** @}
    5357 */

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

    r3842a955 r26e7d6d  
    3737#include <typedefs.h>
    3838#include <arch.h>
    39 #include <proc/uarg.h>
     39#include <abi/proc/uarg.h>
    4040#include <mm/as.h>
    41 
    4241
    4342/** Enter userspace

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

    r3842a955 r26e7d6d  
    3434#define MEMMAP_ITEMS 128
    3535
    36 #define EFI_MEMMAP_FREE_MEM 0
     36#define MEMMAP_FREE_MEM 0
    3737
    3838/** Size of buffer for storing task name in binit_task_t. */
    … …  
    5454        unsigned long base;
    5555        unsigned long size;
    56 } efi_memmap_item_t;
     56} memmap_item_t;
    5757
    5858typedef struct {
    5959        binit_t taskmap;
    6060       
    61         efi_memmap_item_t memmap[MEMMAP_ITEMS];
     61        memmap_item_t memmap[MEMMAP_ITEMS];
    6262        unsigned int memmap_items;
    6363       
    … …  
    6666        unsigned long freq_scale;
    6767        unsigned int wakeup_intno;
    68         int hello_configured;
    6968} bootinfo_t;
    7069

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

    r3842a955 r26e7d6d  
    2727 */
    2828
    29 /** @addtogroup ia64   
     29/** @addtogroup ia64
    3030 * @{
    3131 */
    … …  
    3636#define KERN_ia64_ELF_H_
    3737
    38 #define ELF_MACHINE             EM_IA_64
    39 #define ELF_DATA_ENCODING       ELFDATA2LSB
    40 #define ELF_CLASS               ELFCLASS64
     38#define ELF_MACHINE        EM_IA_64
     39#define ELF_DATA_ENCODING  ELFDATA2LSB
     40#define ELF_CLASS          ELFCLASS64
    4141
    4242#endif

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

    r3842a955 r26e7d6d  
    3636#define KERN_ia64_ISTATE_H_
    3737
     38#include <trace.h>
     39
     40#ifdef KERNEL
     41
    3842#include <arch/register.h>
    3943
    40 #ifdef KERNEL
    41 #include <typedefs.h>
    42 #include <trace.h>
    43 #else
    44 #include <sys/types.h>
    45 #define NO_TRACE
    46 #endif
     44#else /* KERNEL */
     45
     46#include <libarch/register.h>
     47
     48#endif /* KERNEL */
    4749
    4850typedef struct istate {

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

    r3842a955 r26e7d6d  
    3939#define FRAME_SIZE   (1 << FRAME_WIDTH)
    4040
    41 #ifdef KERNEL
    4241#ifndef __ASM__
    4342
    … …  
    5049
    5150#endif /* __ASM__ */
    52 #endif /* KERNEL */
    5351
    5452#endif

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

    r3842a955 r26e7d6d  
    4141#define PAGE_SIZE   FRAME_SIZE
    4242#define PAGE_WIDTH  FRAME_WIDTH
    43 
    44 #ifdef KERNEL
    4543
    4644/** Bit width of the TLB-locked portion of kernel address space. */
    … …  
    316314#endif /* __ASM__ */
    317315
    318 #endif /* KERNEL */
    319 
    320316#endif
    321317

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

    r3842a955 r26e7d6d  
    6161#define PSR_CPL_MASK_SHIFTED  3
    6262
    63 #define PSR_RI_SHIFT    41
    64 #define PSR_RI_LEN      2
     63#define PSR_RI_SHIFT  41
     64#define PSR_RI_LEN    2
    6565
    6666#define PFM_MASK  (~0x3fffffffff)
    … …  
    145145#ifndef __ASM__
    146146
    147 #ifdef KERNEL
    148 #include <typedefs.h>
    149 #else
    150 #include <sys/types.h>
    151 #endif
    152 
    153147/** Processor Status Register. */
    154148typedef union {

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

    r3842a955 r26e7d6d  
    5757};
    5858
    59 static void ski_putchar(outdev_t *, const wchar_t, bool);
     59static void ski_putchar(outdev_t *, const wchar_t);
    6060
    6161static outdev_operations_t skidev_ops = {
    … …  
    9999static void poll_keyboard(ski_instance_t *instance)
    100100{
    101         if (silent)
    102                 return;
    103        
    104101        int count = POLL_LIMIT;
    105102       
    … …  
    121118       
    122119        while (true) {
    123                 if (!silent)
     120                // TODO FIXME:
     121                // This currently breaks the kernel console
     122                // before we get the override from uspace.
     123                if (console_override)
    124124                        poll_keyboard(instance);
    125125               
    … …  
    182182 * @param dev    Character device.
    183183 * @param ch     Character to be printed.
    184  * @param silent Whether the output should be silenced.
    185  *
    186  */
    187 static void ski_putchar(outdev_t *dev, const wchar_t ch, bool silent)
    188 {
    189         if (!silent) {
     184 *
     185 */
     186static void ski_putchar(outdev_t *dev, const wchar_t ch)
     187{
     188        // TODO FIXME:
     189        // This currently breaks the kernel console
     190        // before we get the override from uspace.
     191        if (console_override) {
    190192                if (ascii_check(ch)) {
    191193                        if (ch == '\n')
    … …  
    213215        if (!fb_exported) {
    214216                /*
    215                  * This is the necessary evil until the userspace driver is entirely
     217                 * This is the necessary evil until
     218                 * the userspace driver is entirely
    216219                 * self-sufficient.
    217220                 */

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

    r3842a955 r26e7d6d  
    5050#include <userspace.h>
    5151#include <console/console.h>
    52 #include <proc/uarg.h>
     52#include <abi/proc/uarg.h>
    5353#include <syscall/syscall.h>
    5454#include <ddi/irq.h>
    … …  
    151151        /* Set platform name. */
    152152#ifdef MACHINE_ski
    153         platform = "pc";
     153        platform = "ski";
    154154#endif
    155155#ifdef MACHINE_i460GX

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

    r3842a955 r26e7d6d  
    5858                unsigned int i;
    5959                for (i = 0; i < bootinfo->memmap_items; i++) {
    60                         if (bootinfo->memmap[i].type == EFI_MEMMAP_FREE_MEM) {
     60                        if (bootinfo->memmap[i].type == MEMMAP_FREE_MEM) {
    6161                                uint64_t base = bootinfo->memmap[i].base;
    6262                                uint64_t size = bootinfo->memmap[i].size;

  • kernel/arch/mips32/Makefile.inc

    r3842a955 r26e7d6d  
    2929BFD_ARCH = mips
    3030BFD = binary
    31 GCC_CFLAGS += -mno-abicalls -G 0 -fno-zero-initialized-in-bss -mips3
     31GCC_CFLAGS += -mno-abicalls -G 0 -fno-zero-initialized-in-bss -mips3 -mabi=32
    3232
    3333BITS = 32

  • kernel/arch/mips32/include/context_offset.h

    r3842a955 r26e7d6d  
    6363#ifdef __ASM__
    6464
     65#ifdef KERNEL
     66
    6567#include <arch/asm/regname.h>
    6668
    67 # ctx: address of the structure with saved context
     69#else /* KERNEL */
     70
     71#include <libarch/regname.h>
     72
     73#endif /* KERNEL */
     74
     75/* ctx: address of the structure with saved context */
    6876.macro CONTEXT_SAVE_ARCH_CORE ctx:req
    69         sw $s0,OFFSET_S0(\ctx)
    70         sw $s1,OFFSET_S1(\ctx)
    71         sw $s2,OFFSET_S2(\ctx)
    72         sw $s3,OFFSET_S3(\ctx)
    73         sw $s4,OFFSET_S4(\ctx)
    74         sw $s5,OFFSET_S5(\ctx)
    75         sw $s6,OFFSET_S6(\ctx)
    76         sw $s7,OFFSET_S7(\ctx)
    77         sw $s8,OFFSET_S8(\ctx)
    78         sw $gp,OFFSET_GP(\ctx)
    79 
     77        sw $s0, OFFSET_S0(\ctx)
     78        sw $s1, OFFSET_S1(\ctx)
     79        sw $s2, OFFSET_S2(\ctx)
     80        sw $s3, OFFSET_S3(\ctx)
     81        sw $s4, OFFSET_S4(\ctx)
     82        sw $s5, OFFSET_S5(\ctx)
     83        sw $s6, OFFSET_S6(\ctx)
     84        sw $s7, OFFSET_S7(\ctx)
     85        sw $s8, OFFSET_S8(\ctx)
     86        sw $gp, OFFSET_GP(\ctx)
     87       
    8088#ifndef KERNEL
    81         sw $k1,OFFSET_TLS(\ctx)
    82 
     89        sw $k1, OFFSET_TLS(\ctx)
     90       
    8391#ifdef CONFIG_FPU
    84         mfc1 $t0,$20
     92        mfc1 $t0, $20
    8593        sw $t0, OFFSET_F20(\ctx)
    86 
    87         mfc1 $t0,$21
     94       
     95        mfc1 $t0, $21
    8896        sw $t0, OFFSET_F21(\ctx)
    89 
    90         mfc1 $t0,$22
     97       
     98        mfc1 $t0, $22
    9199        sw $t0, OFFSET_F22(\ctx)
    92 
    93         mfc1 $t0,$23
     100       
     101        mfc1 $t0, $23
    94102        sw $t0, OFFSET_F23(\ctx)
    95 
    96         mfc1 $t0,$24
     103       
     104        mfc1 $t0, $24
    97105        sw $t0, OFFSET_F24(\ctx)
    98 
    99         mfc1 $t0,$25
     106       
     107        mfc1 $t0, $25
    100108        sw $t0, OFFSET_F25(\ctx)
    101 
    102         mfc1 $t0,$26
     109       
     110        mfc1 $t0, $26
    103111        sw $t0, OFFSET_F26(\ctx)
    104 
    105         mfc1 $t0,$27
     112       
     113        mfc1 $t0, $27
    106114        sw $t0, OFFSET_F27(\ctx)
    107 
    108         mfc1 $t0,$28
     115       
     116        mfc1 $t0, $28
    109117        sw $t0, OFFSET_F28(\ctx)
    110 
    111         mfc1 $t0,$29
     118       
     119        mfc1 $t0, $29
    112120        sw $t0, OFFSET_F29(\ctx)
    113121       
    114         mfc1 $t0,$30
     122        mfc1 $t0, $30
    115123        sw $t0, OFFSET_F30(\ctx)
    116124#endif /* CONFIG_FPU */
    117125#endif /* KERNEL */
    118 
    119         sw $ra,OFFSET_PC(\ctx)
    120         sw $sp,OFFSET_SP(\ctx)
     126       
     127        sw $ra, OFFSET_PC(\ctx)
     128        sw $sp, OFFSET_SP(\ctx)
    121129.endm
    122130
    123 # ctx: address of the structure with saved context
     131/* ctx: address of the structure with saved context */
    124132.macro CONTEXT_RESTORE_ARCH_CORE ctx:req
    125         lw $s0,OFFSET_S0(\ctx)
    126         lw $s1,OFFSET_S1(\ctx)
    127         lw $s2,OFFSET_S2(\ctx)
    128         lw $s3,OFFSET_S3(\ctx)
    129         lw $s4,OFFSET_S4(\ctx)
    130         lw $s5,OFFSET_S5(\ctx)
    131         lw $s6,OFFSET_S6(\ctx)
    132         lw $s7,OFFSET_S7(\ctx)
    133         lw $s8,OFFSET_S8(\ctx)
    134         lw $gp,OFFSET_GP(\ctx)
     133        lw $s0, OFFSET_S0(\ctx)
     134        lw $s1, OFFSET_S1(\ctx)
     135        lw $s2, OFFSET_S2(\ctx)
     136        lw $s3, OFFSET_S3(\ctx)
     137        lw $s4, OFFSET_S4(\ctx)
     138        lw $s5, OFFSET_S5(\ctx)
     139        lw $s6, OFFSET_S6(\ctx)
     140        lw $s7, OFFSET_S7(\ctx)
     141        lw $s8, OFFSET_S8(\ctx)
     142        lw $gp, OFFSET_GP(\ctx)
    135143#ifndef KERNEL
    136         lw $k1,OFFSET_TLS(\ctx)
    137 
     144        lw $k1, OFFSET_TLS(\ctx)
     145       
    138146#ifdef CONFIG_FPU
    139147        lw $t0, OFFSET_F20(\ctx)
    140         mtc1 $t0,$20
    141 
     148        mtc1 $t0, $20
     149       
    142150        lw $t0, OFFSET_F21(\ctx)
    143         mtc1 $t0,$21
    144 
     151        mtc1 $t0, $21
     152       
    145153        lw $t0, OFFSET_F22(\ctx)
    146         mtc1 $t0,$22
    147 
     154        mtc1 $t0, $22
     155       
    148156        lw $t0, OFFSET_F23(\ctx)
    149         mtc1 $t0,$23
    150 
     157        mtc1 $t0, $23
     158       
    151159        lw $t0, OFFSET_F24(\ctx)
    152         mtc1 $t0,$24
    153 
     160        mtc1 $t0, $24
     161       
    154162        lw $t0, OFFSET_F25(\ctx)
    155         mtc1 $t0,$25
    156 
     163        mtc1 $t0, $25
     164       
    157165        lw $t0, OFFSET_F26(\ctx)
    158         mtc1 $t0,$26
    159 
     166        mtc1 $t0, $26
     167       
    160168        lw $t0, OFFSET_F27(\ctx)
    161         mtc1 $t0,$27
    162 
     169        mtc1 $t0, $27
     170       
    163171        lw $t0, OFFSET_F28(\ctx)
    164         mtc1 $t0,$28
    165 
     172        mtc1 $t0, $28
     173       
    166174        lw $t0, OFFSET_F29(\ctx)
    167         mtc1 $t0,$29
    168 
     175        mtc1 $t0, $29
     176       
    169177        lw $t0, OFFSET_F30(\ctx)
    170         mtc1 $t0,$30
     178        mtc1 $t0, $30
    171179#endif /* CONFIG_FPU */
    172180#endif /* KERNEL */
    173 
    174         lw $ra,OFFSET_PC(\ctx)
    175         lw $sp,OFFSET_SP(\ctx)
     181       
     182        lw $ra, OFFSET_PC(\ctx)
     183        lw $sp, OFFSET_SP(\ctx)
    176184.endm
    177185
    178 #endif
    179 
     186#endif /* __ASM__ */
    180187
    181188#endif

  • kernel/arch/mips32/include/cp0.h

    r3842a955 r26e7d6d  
    3636#define KERN_mips32_CP0_H_
    3737
    38 #ifdef KERNEL
    39 #include <typedefs.h>
    40 #else
    41 #include <sys/types.h>
    42 #endif
    43 
    4438#define cp0_status_ie_enabled_bit     (1 << 0)
    4539#define cp0_status_exl_exception_bit  (1 << 1)
    … …  
    4943#define cp0_status_fpu_bit            (1 << 29)
    5044
    51 #define cp0_status_im_shift             8
    52 #define cp0_status_im_mask              0xff00
     45#define cp0_status_im_shift  8
     46#define cp0_status_im_mask   0xff00
    5347
    54 #define cp0_cause_excno(cause) ((cause >> 2) & 0x1f)
    55 #define cp0_cause_coperr(cause) ((cause >> 28) & 0x3)
     48#define cp0_cause_excno(cause)   ((cause >> 2) & 0x1f)
     49#define cp0_cause_coperr(cause)  ((cause >> 28) & 0x3)
    5650
    57 #define fpu_cop_id 1
     51#define fpu_cop_id  1
    5852
    5953/*
    6054 * Magic value for use in msim.
    6155 */
    62 #define cp0_compare_value               100000
     56#define cp0_compare_value  100000
    6357
    64 #define cp0_mask_all_int() cp0_status_write(cp0_status_read() & ~(cp0_status_im_mask))
    65 #define cp0_unmask_all_int() cp0_status_write(cp0_status_read() | cp0_status_im_mask)
    66 #define cp0_mask_int(it) cp0_status_write(cp0_status_read() & ~(1 << (cp0_status_im_shift + (it))))
    67 #define cp0_unmask_int(it) cp0_status_write(cp0_status_read() | (1 << (cp0_status_im_shift + (it))))
     58#define cp0_mask_all_int() \
     59        cp0_status_write(cp0_status_read() & ~(cp0_status_im_mask))
    6860
    69 #define GEN_READ_CP0(nm,reg) static inline uint32_t cp0_ ##nm##_read(void) \
    70   { \
    71       uint32_t retval; \
    72       asm volatile ("mfc0 %0, $" #reg : "=r"(retval)); \
    73       return retval; \
    74   }
     61#define cp0_unmask_all_int() \
     62        cp0_status_write(cp0_status_read() | cp0_status_im_mask)
    7563
    76 #define GEN_WRITE_CP0(nm,reg) static inline void cp0_ ##nm##_write(uint32_t val) \
    77  { \
    78     asm volatile ("mtc0 %0, $" #reg : : "r"(val) ); \
    79  }
     64#define cp0_mask_int(it) \
     65        cp0_status_write(cp0_status_read() & ~(1 << (cp0_status_im_shift + (it))))
     66
     67#define cp0_unmask_int(it) \
     68        cp0_status_write(cp0_status_read() | (1 << (cp0_status_im_shift + (it))))
     69
     70#define GEN_READ_CP0(nm, reg) \
     71        static inline uint32_t cp0_ ##nm##_read(void) \
     72        { \
     73                uint32_t retval; \
     74                \
     75                asm volatile ( \
     76                        "mfc0 %0, $" #reg \
     77                        : "=r"(retval) \
     78                ); \
     79                \
     80                return retval; \
     81        }
     82
     83#define GEN_WRITE_CP0(nm, reg) \
     84        static inline void cp0_ ##nm##_write(uint32_t val) \
     85        { \
     86                asm volatile ( \
     87                        "mtc0 %0, $" #reg \
     88                        :: "r"(val) \
     89                ); \
     90        }
    8091
    8192GEN_READ_CP0(index, 0);

  • kernel/arch/mips32/include/cycle.h

    r3842a955 r26e7d6d  
    2727 */
    2828
    29 /** @addtogroup mips2
     29/** @addtogroup mips32
    3030 * @{
    3131 */

  • kernel/arch/mips32/include/debug.h

    r3842a955 r26e7d6d  
    3434
    3535#ifndef KERN_mips32_DEBUG_H_
    36 #define KERN_mips23_DEBUG_H_
     36#define KERN_mips32_DEBUG_H_
    3737
    3838/** Enter the simulator trace mode */

  • kernel/arch/mips32/include/istate.h

    r3842a955 r26e7d6d  
    3636#define KERN_mips32_ISTATE_H_
    3737
     38#include <trace.h>
     39
     40#ifdef KERNEL
     41
    3842#include <arch/cp0.h>
    3943
    40 #ifdef KERNEL
    41 #include <typedefs.h>
    42 #include <trace.h>
    43 #else
    44 #include <sys/types.h>
    45 #define NO_TRACE
    46 #endif
     44#else /* KERNEL */
     45
     46#include <libarch/cp0.h>
     47
     48#endif /* KERNEL */
    4749
    4850typedef struct istate {

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

    r3842a955 r26e7d6d  
    3939#define FRAME_SIZE   (1 << FRAME_WIDTH)
    4040
    41 #ifdef KERNEL
    4241#ifndef __ASM__
    43 
    44 #include <typedefs.h>
    4542
    4643extern void frame_arch_init(void);
    … …  
    4845
    4946#endif /* __ASM__ */
    50 #endif /* KERNEL */
    5147
    5248#endif

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

    r3842a955 r26e7d6d  
    4949#       define PA2KA(x) ((x) + 0x80000000)
    5050#endif
    51 
    52 #ifdef KERNEL
    5351
    5452/*
    … …  
    188186#endif /* __ASM__ */
    189187
    190 #endif /* KERNEL */
    191 
    192188#endif
    193189

  • kernel/arch/mips32/include/stack.h

    r3842a955 r26e7d6d  
    3939#define STACK_ALIGNMENT         8
    4040
    41 #define STACK_ARG0              0
    42 #define STACK_ARG1              4
    43 #define STACK_ARG2              8
    44 #define STACK_ARG3              12
    45 #define STACK_ARG4              16
    46 #define STACK_ARG5              20
    47 #define STACK_ARG6              24
    48 
    4941#endif
    5042

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

    r3842a955 r26e7d6d  
    2727 */
    2828
    29 /** @addtogroup mips32 
     29/** @addtogroup mips32
    3030 * @{
    3131 */

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

    r3842a955 r26e7d6d  
    3737#include <arch.h>
    3838#include <arch/cp0.h>
    39 #include <print.h>     
     39#include <print.h>
    4040
    4141struct data_t {

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

    r3842a955 r26e7d6d  
    2727 */
    2828
    29 /** @addtogroup mips32 
     29/** @addtogroup mips32
    3030 * @{
    3131 */
    … …  
    4040
    4141void fpu_disable(void)
    42 {       
     42{
    4343#ifdef CONFIG_FPU
    4444        cp0_status_write(cp0_status_read() & ~cp0_status_fpu_bit);

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

    r3842a955 r26e7d6d  
    4141#include <memstr.h>
    4242#include <proc/thread.h>
    43 #include <proc/uarg.h>
     43#include <abi/proc/uarg.h>
    4444#include <print.h>
    4545#include <console/console.h>
    … …  
    5252#include <arch/debugger.h>
    5353#include <genarch/fb/fb.h>
    54 #include <genarch/fb/visuals.h>
     54#include <abi/fb/visuals.h>
    5555#include <genarch/drivers/dsrln/dsrlnin.h>
    5656#include <genarch/drivers/dsrln/dsrlnout.h>

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

    r3842a955 r26e7d6d  
    6161        /*
    6262         * Install ASID.
    63          */     
     63         */
    6464        hi.value = cp0_entry_hi_read();
    6565
    6666        hi.asid = as->asid;
    67         cp0_entry_hi_write(hi.value);   
     67        cp0_entry_hi_write(hi.value);
    6868}
    6969

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

    r3842a955 r26e7d6d  
    7373                tlbwi();
    7474        }
    75                
     75       
    7676        /*
    7777         * The kernel is going to make use of some wired
    … …  
    386386                        ASSERT(pte->w || access != PF_ACCESS_WRITE);
    387387                        return pte;
    388                         break;
    389388                case AS_PF_DEFER:
    390389                        *pfrc = AS_PF_DEFER;
    391390                        return NULL;
    392                         break;
    393391                case AS_PF_FAULT:
    394392                        *pfrc = AS_PF_FAULT;
    395393                        return NULL;
    396                         break;
    397394                default:
    398395                        panic("Unexpected rc (%d).", rc);

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

    r3842a955 r26e7d6d  
    222222       
    223223        /* move $k0 pointer to kernel stack */
    224         lui $k0, %hi(supervisor_sp)
    225         ori $k0, $k0, %lo(supervisor_sp)
     224        la $k0, supervisor_sp
    226225       
    227226        /* move $k0 (supervisor_sp) */

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

    r3842a955 r26e7d6d  
    11/*
    2  * Copyright (c) 2009 Jiri Svoboda
    3  * Copyright (c) 2010 Lenka Trochtova
     2 * Copyright (c) 2005 Martin Decky
    43 * All rights reserved.
    54 *
    … …  
    2827 */
    2928
    30 /** @addtogroup libc
     29/** @addtogroup mips64
    3130 * @{
    3231 */
    … …  
    3433 */
    3534
    36 #ifndef LIBC_DEVMAN_OBSOLETE_H_
    37 #define LIBC_DEVMAN_OBSOLETE_H_
     35#ifndef KERN_mips64_ARCH_H_
     36#define KERN_mips64_ARCH_H_
    3837
    39 #include <ipc/devman.h>
    40 #include <async.h>
    41 #include <bool.h>
     38#include <typedefs.h>
    4239
    43 extern int devman_obsolete_get_phone(devman_interface_t, unsigned int);
    44 extern void devman_obsolete_hangup_phone(devman_interface_t);
     40#define TASKMAP_MAX_RECORDS        32
     41#define CPUMAP_MAX_RECORDS         32
     42#define BOOTINFO_TASK_NAME_BUFLEN  32
    4543
    46 extern int devman_obsolete_device_connect(devman_handle_t, unsigned int);
    47 extern int devman_obsolete_parent_device_connect(devman_handle_t, unsigned int);
     44extern size_t cpu_count;
     45
     46typedef struct {
     47        void *addr;
     48        size_t size;
     49        char name[BOOTINFO_TASK_NAME_BUFLEN];
     50} utask_t;
     51
     52typedef struct {
     53        uint32_t cpumap;
     54        size_t cnt;
     55        utask_t tasks[TASKMAP_MAX_RECORDS];
     56} bootinfo_t;
     57
     58extern void arch_pre_main(void *entry, bootinfo_t *bootinfo);
    4859
    4960#endif

  • kernel/arch/mips64/include/cpu.h

    r3842a955 r26e7d6d  
    11/*
    2  * Copyright (c) 2009 Jiri Svoboda
     2 * Copyright (c) 2003-2004 Jakub Jermar
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup mouse
    30  * @brief
     29/** @addtogroup mips64
    3130 * @{
    3231 */
    … …  
    3433 */
    3534
    36 #ifndef LIBC_IPC_MOUSE_H_
    37 #define LIBC_IPC_MOUSE_H_
     35#ifndef KERN_mips64_CPU_H_
     36#define KERN_mips64_CPU_H_
    3837
    39 #include <ipc/common.h>
     38#include <typedefs.h>
     39#include <arch/asm.h>
    4040
    41 typedef enum {
    42         MEVENT_BUTTON = IPC_FIRST_USER_METHOD,
    43         MEVENT_MOVE
    44 } mouse_notif_t;
     41typedef struct {
     42        uint32_t imp_num;
     43        uint32_t rev_num;
     44} cpu_arch_t;
    4545
    4646#endif
    4747
    48 /**
    49  * @}
     48/** @}
    5049 */

  • kernel/arch/mips64/include/debugger.h

    r3842a955 r26e7d6d  
    11/*
    2  * Copyright (c) 2011 Jan Vesely
     2 * Copyright (c) 2005 Ondrej Palkovsky
    33 * All rights reserved.
    44 *
    … …  
    2626 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2727 */
    28 /** @addtogroup drvusbohci
     28
     29/** @addtogroup mips64
    2930 * @{
    3031 */
    3132/** @file
    32  * @brief OHCI driver USB transaction structure
    3333 */
    34 #ifndef DRV_OHCI_BATCH_H
    35 #define DRV_OHCI_BATCH_H
    3634
    37 #include <usbhc_iface.h>
    38 #include <usb/usb.h>
    39 #include <usb/host/device_keeper.h>
    40 #include <usb/host/endpoint.h>
    41 #include <usb/host/batch.h>
     35#ifndef KERN_mips64_DEBUGGER_H_
     36#define KERN_mips64_DEBUGGER_H_
    4237
    43 usb_transfer_batch_t * batch_get(
    44     ddf_fun_t *fun, endpoint_t *ep, char *buffer, size_t size,
    45     const char *setup_buffer, size_t setup_size,
    46     usbhc_iface_transfer_in_callback_t func_in,
    47     usbhc_iface_transfer_out_callback_t func_out,
    48     void *arg);
     38#include <arch/exception.h>
     39#include <typedefs.h>
    4940
    50 bool batch_is_complete(usb_transfer_batch_t *instance);
     41#define BKPOINTS_MAX  10
    5142
    52 void batch_commit(usb_transfer_batch_t *instance);
     43/** Breakpoint was shot */
     44#define BKPOINT_INPROG  (1 << 0)
    5345
    54 void batch_control_write(usb_transfer_batch_t *instance);
     46/** One-time breakpoint, mandatory for j/b instructions */
     47#define BKPOINT_ONESHOT  (1 << 1)
    5548
    56 void batch_control_read(usb_transfer_batch_t *instance);
     49/**
     50 * Breakpoint is set on the next instruction, so that it
     51 * could be reinstalled on the previous one
     52 */
     53#define BKPOINT_REINST  (1 << 2)
    5754
    58 void batch_interrupt_in(usb_transfer_batch_t *instance);
     55/** Call a predefined function */
     56#define BKPOINT_FUNCCALL  (1 << 3)
    5957
    60 void batch_interrupt_out(usb_transfer_batch_t *instance);
    6158
    62 void batch_bulk_in(usb_transfer_batch_t *instance);
     59typedef struct  {
     60        uintptr_t address;         /**< Breakpoint address */
     61        sysarg_t instruction;      /**< Original instruction */
     62        sysarg_t nextinstruction;  /**< Original instruction following break */
     63        unsigned int flags;        /**< Flags regarding breakpoint */
     64        size_t counter;
     65        void (*bkfunc)(void *, istate_t *);
     66} bpinfo_t;
    6367
    64 void batch_bulk_out(usb_transfer_batch_t *instance);
     68extern bpinfo_t breakpoints[BKPOINTS_MAX];
     69
     70extern bool is_jump(sysarg_t);
     71
     72extern void debugger_init(void);
     73extern void debugger_bpoint(istate_t *);
     74
    6575#endif
    66 /**
    67  * @}
     76
     77/** @}
    6878 */

  • kernel/arch/mips64/include/drivers/msim.h

    r3842a955 r26e7d6d  
    11/*
    2  * Copyright (c) 2006 Ondrej Palkovsky
    3  * Copyright (c) 2008 Martin Decky
     2 * Copyright (c) 2005 Ondrej Palkovsky
    43 * All rights reserved.
    54 *
    … …  
    2827 */
    2928
    30 /** @addtogroup msimfb
    31  * @brief       HelenOS MSIM text console.
    32  * @ingroup fbs
     29/** @addtogroup mips64
    3330 * @{
    34  */ 
     31 */
    3532/** @file
    3633 */
    3734
    38 #ifndef FB_MSIM_H_
    39 #define FB_MSIM_H_
     35#ifndef KERN_mips64_MSIM_H_
     36#define KERN_mips64_MSIM_H_
    4037
    41 extern int msim_init(void);
     38/** Address of devices. */
     39#define MSIM_VIDEORAM     0xffffffff90000000
     40#define MSIM_KBD_ADDRESS  0xffffffff90000000
     41#define MSIM_KBD_IRQ      2
    4242
    4343#endif
    … …  
    4545/** @}
    4646 */
    47 

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

    r3842a955 r26e7d6d  
    11/*
    2  * Copyright (c) 2006 Jakub Jermar
     2 * Copyright (c) 2003-2004 Jakub Jermar
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup sparc64
     29/** @addtogroup mips64
    3030 * @{
    3131 */
    … …  
    3333 */
    3434
    35 #ifndef KERN_sparc64_FHC_H_
    36 #define KERN_sparc64_FHC_H_
     35#ifndef KERN_mips64_INTERRUPT_H_
     36#define KERN_mips64_INTERRUPT_H_
    3737
    3838#include <typedefs.h>
    39 #include <genarch/ofw/ofw_tree.h>
     39#include <arch/exception.h>
    4040
    41 typedef struct {
    42         volatile uint32_t *uart_imap;
    43 } fhc_t;
     41#define IVT_ITEMS  32
     42#define IVT_FIRST  0
    4443
    45 extern fhc_t *central_fhc;
     44#define VECTOR_TLB_SHOOTDOWN_IPI  EXC_Int
    4645
    47 extern fhc_t *fhc_init(ofw_tree_node_t *);
    48 extern void fhc_enable_interrupt(fhc_t *, int);
    49 extern void fhc_clear_interrupt(void *, int);
     46extern function virtual_timer_fnc;
     47extern uint32_t count_hi;
     48
     49extern void interrupt_init(void);
    5050
    5151#endif

  • kernel/arch/mips64/include/proc/task.h

    r3842a955 r26e7d6d  
    11/*
    2  * Copyright (c) 2010 Jiri Svoboda
     2 * Copyright (c) 2006 Jakub Jermar
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup mouse
    30  * @brief
     29/** @addtogroup mips64proc
    3130 * @{
    3231 */
    … …  
    3433 */
    3534
    36 #ifndef ADB_MOUSE_H_
    37 #define ADB_MOUSE_H_
     35#ifndef KERN_mips64_TASK_H_
     36#define KERN_mips64_TASK_H_
    3837
    39 #include <sys/types.h>
     38typedef struct {
     39} task_arch_t;
    4040
    41 #define NAME       "adb_ms"
    42 #define NAMESPACE  "hid_in"
    43 
    44 extern void mouse_handle_data(uint16_t);
     41#define task_create_arch(task)
     42#define task_destroy_arch(task)
    4543
    4644#endif
    4745
    48 /**
    49  * @}
     46/** @}
    5047 */

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

    r3842a955 r26e7d6d  
    11/*
    2  * Copyright (c) 2011 Martin Decky
     2 * Copyright (c) 2003-2004 Jakub Jermar
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup libc
     29/** @addtogroup mips64mm
    3030 * @{
    3131 */
    … …  
    3333 */
    3434
    35 #include <async.h>
    36 #include <async_obsolete.h>
    37 #include <ns_obsolete.h>
    38 #include <kernel/ipc/ipc_methods.h>
     35#include <arch/mm/page.h>
     36#include <genarch/mm/page_ht.h>
     37#include <mm/page.h>
     38#include <mm/frame.h>
    3939
    40 int service_obsolete_connect(sysarg_t service, sysarg_t arg2, sysarg_t arg3)
     40void page_arch_init(void)
    4141{
    42         return async_obsolete_connect_me_to(PHONE_NS, service, arg2, arg3);
     42        page_mapping_operations = &ht_mapping_operations;
    4343}
    4444
    45 int service_obsolete_connect_blocking(sysarg_t service, sysarg_t arg2, sysarg_t arg3)
     45/** Map device into kernel space
     46 * - on mips, all devices are already mapped into kernel space,
     47 *   translate the physical address to uncached area
     48 */
     49uintptr_t hw_map(uintptr_t physaddr, size_t size)
    4650{
    47         return async_obsolete_connect_me_to_blocking(PHONE_NS, service, arg2, arg3);
     51        return physaddr + 0xffffffffa0000000;
    4852}
    4953

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

    r3842a955 r26e7d6d  
    3838#include <typedefs.h>
    3939#include <config.h>
    40 #include <arch/cpu.h>
     40#include <arch/msr.h>
    4141#include <arch/mm/asid.h>
    4242#include <trace.h>

  • kernel/arch/ppc32/include/context_offset.h

    r3842a955 r26e7d6d  
    7575
    7676#ifdef __ASM__
    77 # include <arch/asm/regname.h>
    7877
    79 # ctx: address of the structure with saved context
     78#ifdef KERNEL
     79
     80#include <arch/asm/regname.h>
     81
     82#else /* KERNEL */
     83
     84#include <libarch/regname.h>
     85
     86#endif /* KERNEL */
     87
     88/* ctx: address of the structure with saved context */
    8089.macro CONTEXT_SAVE_ARCH_CORE ctx:req
    8190        stw sp, OFFSET_SP(\ctx)
    … …  
    102111.endm
    103112
    104 # ctx: address of the structure with saved context
     113/* ctx: address of the structure with saved context */
    105114.macro CONTEXT_RESTORE_ARCH_CORE ctx:req
    106115        lwz sp, OFFSET_SP(\ctx)

  • kernel/arch/ppc32/include/cpu.h

    r3842a955 r26e7d6d  
    3636#define KERN_ppc32_CPU_H_
    3737
    38 /* MSR bits */
    39 #define MSR_DR  (1 << 4)
    40 #define MSR_IR  (1 << 5)
    41 #define MSR_PR  (1 << 14)
    42 #define MSR_EE  (1 << 15)
    43 
    44 /* HID0 bits */
    45 #define HID0_STEN  (1 << 24)
    46 #define HID0_ICE   (1 << 15)
    47 #define HID0_DCE   (1 << 14)
    48 #define HID0_ICFI  (1 << 11)
    49 #define HID0_DCI   (1 << 10)
    50 
    51 #ifndef __ASM__
    52 
    5338#include <typedefs.h>
    5439#include <trace.h>
    … …  
    6752}
    6853
    69 #endif /* __ASM__ */
    70 
    7154#endif
    7255

  • kernel/arch/ppc32/include/exception.h

    r3842a955 r26e7d6d  
    3737
    3838#include <typedefs.h>
    39 #include <arch/cpu.h>
     39#include <arch/msr.h>
    4040#include <trace.h>
    4141

  • kernel/arch/ppc32/include/istate.h

    r3842a955 r26e7d6d  
    3636#define KERN_ppc32_EXCEPTION_H_
    3737
    38 #include <typedefs.h>
    39 #include <arch/cpu.h>
    4038#include <trace.h>
     39
     40#ifdef KERNEL
     41
     42#include <arch/msr.h>
     43
     44#else /* KERNEL */
     45
     46#include <libarch/msr.h>
     47
     48#endif /* KERNEL */
    4149
    4250typedef struct istate {

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

    r3842a955 r26e7d6d  
    3939#define FRAME_SIZE   (1 << FRAME_WIDTH)
    4040
    41 #ifdef KERNEL
    4241#ifndef __ASM__
    4342
    … …  
    6362
    6463#endif /* __ASM__ */
    65 #endif /* KERNEL */
    6664
    6765#endif

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

    r3842a955 r26e7d6d  
    4141#define PAGE_WIDTH  FRAME_WIDTH
    4242#define PAGE_SIZE   FRAME_SIZE
    43 
    44 #ifdef KERNEL
    4543
    4644#ifndef __ASM__
    … …  
    181179#endif /* __ASM__ */
    182180
    183 #endif /* KERNEL */
    184 
    185181#endif
    186182

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

    r3842a955 r26e7d6d  
    2828
    2929#include <arch/asm/regname.h>
    30 #include <arch/cpu.h>
     30#include <arch/msr.h>
    3131
    3232.text

  • kernel/arch/ppc32/src/exception.S

    r3842a955 r26e7d6d  
    2828
    2929#include <arch/asm/regname.h>
    30 #include <arch/cpu.h>
     30#include <arch/msr.h>
    3131#include <arch/mm/page.h>
    3232

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

    r3842a955 r26e7d6d  
    4141#include <interrupt.h>
    4242#include <genarch/fb/fb.h>
    43 #include <genarch/fb/visuals.h>
     43#include <abi/fb/visuals.h>
    4444#include <genarch/ofw/ofw_tree.h>
    4545#include <genarch/ofw/pci.h>
    4646#include <userspace.h>
    4747#include <mm/page.h>
    48 #include <proc/uarg.h>
     48#include <abi/proc/uarg.h>
    4949#include <console/console.h>
    5050#include <sysinfo/sysinfo.h>

  • kernel/arch/sparc64/Makefile.inc

    r3842a955 r26e7d6d  
    8484        arch/$(KARCH)/src/drivers/tick.c \
    8585        arch/$(KARCH)/src/drivers/kbd.c \
    86         arch/$(KARCH)/src/drivers/sgcn.c \
    8786        arch/$(KARCH)/src/drivers/pci.c \
    88         arch/$(KARCH)/src/drivers/fhc.c \
    8987        arch/$(KARCH)/src/trap/$(USARCH)/interrupt.c
    9088

  • kernel/arch/sparc64/include/barrier.h

    r3842a955 r26e7d6d  
    3737
    3838#include <trace.h>
    39 
    40 #ifdef KERNEL
    41 
    42 #include <typedefs.h>
    43 
    44 #else
    45 
    46 #include <stdint.h>
    47 
    48 #endif
    4939
    5040/*

  • kernel/arch/sparc64/include/elf.h

    r3842a955 r26e7d6d  
    2727 */
    2828
    29 /** @addtogroup sparc64 
     29/** @addtogroup sparc64
    3030 * @{
    3131 */
    … …  
    3636#define KERN_sparc64_ELF_H_
    3737
    38 #define ELF_MACHINE             EM_SPARCV9
    39 #define ELF_DATA_ENCODING       ELFDATA2MSB
    40 #define ELF_CLASS               ELFCLASS64
     38#define ELF_MACHINE        EM_SPARCV9
     39#define ELF_DATA_ENCODING  ELFDATA2MSB
     40#define ELF_CLASS          ELFCLASS64
    4141
    4242#endif

  • kernel/arch/sparc64/include/istate.h

    r3842a955 r26e7d6d  
    3737#define KERN_sparc64_ISTATE_H_
    3838
     39#include <trace.h>
     40
     41#ifdef KERNEL
     42
    3943#include <arch/regdef.h>
    4044
    41 #ifdef KERNEL
    42 #include <typedefs.h>
    43 #include <trace.h>
    44 #else
    45 #include <sys/types.h>
    46 #define NO_TRACE
    47 #endif
     45#else /* KERNEL */
     46
     47#include <libarch/regdef.h>
     48
     49#endif /* KERNEL */
    4850
    4951typedef struct istate {

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

    r3842a955 r26e7d6d  
    5454#define MMU_PAGES_PER_PAGE      (1 << (PAGE_WIDTH - MMU_PAGE_WIDTH))
    5555
    56 #ifdef KERNEL
    57 
    5856#ifndef __ASM__
    5957
    … …  
    7775#endif /* !def __ASM__ */
    7876
    79 #endif /* KERNEL */
    80 
    8177#endif
    8278

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

    r3842a955 r26e7d6d  
    5252#define FRAME_SIZE              (1 << FRAME_WIDTH)
    5353
    54 #ifdef KERNEL
    5554#ifndef __ASM__
    5655
    … …  
    8079
    8180#endif
    82 #endif
    8381
    8482#endif

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

    r3842a955 r26e7d6d  
    4242#define FRAME_SIZE              (1 << FRAME_WIDTH)
    4343
    44 #ifdef KERNEL
    4544#ifndef __ASM__
    4645
    … …  
    5251
    5352#endif
    54 #endif
    5553
    5654#endif

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

    r3842a955 r26e7d6d  
    4646#define MMU_PAGES_PER_PAGE      (1 << (PAGE_WIDTH - MMU_PAGE_WIDTH))
    4747
    48 #ifdef KERNEL
    49 
    5048#ifndef __ASM__
    5149
    … …  
    6967#endif /* !def __ASM__ */
    7068
    71 #endif /* KERNEL */
    72 
    7369#endif
    7470

  • kernel/arch/sparc64/include/sun4v/regdef.h

    r3842a955 r26e7d6d  
    2828 */
    2929
    30 /** @addtogroup sparc64 
     30/** @addtogroup sparc64
    3131 * @{
    3232 */
    … …  
    3737#define KERN_sparc64_sun4v_REGDEF_H_
    3838
    39 #define PSTATE_IE_BIT   (1 << 1)
    40 #define PSTATE_PRIV_BIT (1 << 2)
    41 #define PSTATE_PEF_BIT  (1 << 4)
     39#define TSTATE_CWP_MASK  0x1f
    4240
    43 #define TSTATE_PSTATE_SHIFT     8
    44 #define TSTATE_PRIV_BIT         (PSTATE_PRIV_BIT << TSTATE_PSTATE_SHIFT)
    45 #define TSTATE_CWP_MASK         0x1f
    46 #define TSTATE_IE_BIT           (PSTATE_IE_BIT << TSTATE_PSTATE_SHIFT)
    47 
    48 #define WSTATE_NORMAL(n)        (n)
    49 #define WSTATE_OTHER(n)         ((n) << 3)
    50 
    51 #define TSTATE_PEF_BIT          (PSTATE_PEF_BIT << TSTATE_PSTATE_SHIFT)
     41#define WSTATE_NORMAL(n)  (n)
     42#define WSTATE_OTHER(n)   ((n) << 3)
    5243
    5344#endif

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

    r3842a955 r26e7d6d  
    3838#include <arch/drivers/scr.h>
    3939#include <arch/drivers/kbd.h>
    40 #include <arch/drivers/sgcn.h>
    4140#include <genarch/srln/srln.h>
    4241#include <console/chardev.h>
    … …  
    8988}
    9089
    91 /** Initilize I/O on the Serengeti machine. */
    92 static void serengeti_init(void)
    93 {
    94 #ifdef CONFIG_SGCN_KBD
    95         sgcn_instance_t *sgcn_instance = sgcnin_init();
    96         if (sgcn_instance) {
    97                 srln_instance_t *srln_instance = srln_init();
    98                 if (srln_instance) {
    99                         indev_t *sink = stdin_wire();
    100                         indev_t *srln = srln_wire(srln_instance, sink);
    101                         sgcnin_wire(sgcn_instance, srln);
    102                 }
    103         }
    104 #endif
    105        
    106 #ifdef CONFIG_SGCN_PRN
    107         outdev_t *sgcndev = sgcnout_init();
    108         if (sgcndev)
    109                 stdout_wire(sgcndev);
    110 #endif
    111 }
    112 
    11390/**
    11491 * Initialize input/output. Auto-detects the type of machine
    … …  
    127104        prop = ofw_tree_getprop(aliases, "def-cn");
    128105       
    129         if ((!prop) || (!prop->value) || (str_cmp(prop->value, "/sgcn") != 0)) {
     106        if ((!prop) || (!prop->value))
    130107                standard_console_init(aliases);
    131         } else {
    132                 serengeti_init();
    133         }
    134108}
    135109

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

    r3842a955 r26e7d6d  
    3535#include <arch/drivers/kbd.h>
    3636#include <genarch/ofw/ofw_tree.h>
    37 #include <genarch/ofw/fhc.h>
    3837#include <genarch/ofw/ebus.h>
    3938#include <console/console.h>
    … …  
    5150#endif
    5251
    53 #ifdef CONFIG_Z8530
    54 #include <genarch/drivers/z8530/z8530.h>
    55 #endif
    56 
    5752#ifdef CONFIG_NS16550
    5853#include <genarch/drivers/ns16550/ns16550.h>
    … …  
    6055
    6156#ifdef CONFIG_SUN_KBD
    62 
    63 #ifdef CONFIG_Z8530
    64 
    65 static bool kbd_z8530_init(ofw_tree_node_t *node)
    66 {
    67         const char *name = ofw_tree_node_name(node);
    68        
    69         if (str_cmp(name, "zs") != 0)
    70                 return false;
    71        
    72         /*
    73          * Read 'interrupts' property.
    74          */
    75         ofw_tree_property_t *prop = ofw_tree_getprop(node, "interrupts");
    76         if ((!prop) || (!prop->value)) {
    77                 printf("z8530: Unable to find interrupts property\n");
    78                 return false;
    79         }
    80        
    81         uint32_t interrupts = *((uint32_t *) prop->value);
    82        
    83         /*
    84          * Read 'reg' property.
    85          */
    86         prop = ofw_tree_getprop(node, "reg");
    87         if ((!prop) || (!prop->value)) {
    88                 printf("z8530: Unable to find reg property\n");
    89                 return false;
    90         }
    91        
    92         size_t size = ((ofw_fhc_reg_t *) prop->value)->size;
    93        
    94         uintptr_t pa;
    95         if (!ofw_fhc_apply_ranges(node->parent,
    96             ((ofw_fhc_reg_t *) prop->value), &pa)) {
    97                 printf("z8530: Failed to determine address\n");
    98                 return false;
    99         }
    100        
    101         inr_t inr;
    102         cir_t cir;
    103         void *cir_arg;
    104         if (!ofw_fhc_map_interrupt(node->parent,
    105             ((ofw_fhc_reg_t *) prop->value), interrupts, &inr, &cir,
    106             &cir_arg)) {
    107                 printf("z8530: Failed to determine interrupt\n");
    108                 return false;
    109         }
    110        
    111         /*
    112          * We need to pass aligned address to hw_map().
    113          * However, the physical keyboard address can
    114          * be pretty much unaligned, depending on the
    115          * underlying controller.
    116          */
    117         uintptr_t aligned_addr = ALIGN_DOWN(pa, PAGE_SIZE);
    118         size_t offset = pa - aligned_addr;
    119        
    120         z8530_t *z8530 = (z8530_t *)
    121             (hw_map(aligned_addr, offset + size) + offset);
    122        
    123         z8530_instance_t *z8530_instance = z8530_init(z8530, inr, cir, cir_arg);
    124         if (z8530_instance) {
    125                 kbrd_instance_t *kbrd_instance = kbrd_init();
    126                 if (kbrd_instance) {
    127                         indev_t *sink = stdin_wire();
    128                         indev_t *kbrd = kbrd_wire(kbrd_instance, sink);
    129                         z8530_wire(z8530_instance, kbrd);
    130                 }
    131         }
    132        
    133         /*
    134          * This is the necessary evil until the userspace drivers are
    135          * entirely self-sufficient.
    136          */
    137         sysinfo_set_item_val("kbd", NULL, true);
    138         sysinfo_set_item_val("kbd.inr", NULL, inr);
    139         sysinfo_set_item_val("kbd.address.kernel", NULL,
    140             (uintptr_t) z8530);
    141         sysinfo_set_item_val("kbd.address.physical", NULL, pa);
    142         sysinfo_set_item_val("kbd.type.z8530", NULL, true);
    143        
    144         return true;
    145 }
    146 
    147 #endif /* CONFIG_Z8530 */
    14857
    14958#ifdef CONFIG_NS16550
    … …  
    243152void kbd_init(ofw_tree_node_t *node)
    244153{
    245 #ifdef CONFIG_Z8530
    246         kbd_z8530_init(node);
    247 #endif
    248        
    249154#ifdef CONFIG_NS16550
    250155        kbd_ns16550_init(node);

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

    r3842a955 r26e7d6d  
    3232/**
    3333 * @file
    34  * @brief       Niagara input/output driver based on hypervisor calls.
     34 * @brief Niagara input/output driver based on hypervisor calls.
    3535 */
    3636
    … …  
    5252#include <genarch/srln/srln.h>
    5353
    54 /* polling interval in miliseconds */
     54/* Polling interval in miliseconds */
    5555#define POLL_INTERVAL  10000
    5656
    57 /* device instance */
     57/* Device instance */
    5858static niagara_instance_t *instance = NULL;
    5959
    60 static void niagara_putchar(outdev_t *, const wchar_t, bool);
    61 
    62 /** character device operations */
     60static void niagara_putchar(outdev_t *, const wchar_t);
     61
     62/** Character device operations */
    6363static outdev_operations_t niagara_ops = {
    6464        .write = niagara_putchar,
    … …  
    6666};
    6767
    68 /*
     68/**
    6969 * The driver uses hypercalls to print characters to the console. Since the
    7070 * hypercall cannot be performed from the userspace, we do this:
    71  * The kernel "little brother" driver (which will be present no matter what the
    72  * DDI architecture is - as we need the kernel part for the kconsole)
     71 *
     72 * The kernel "little brother" driver (which will be present no matter what
     73 * the DDI architecture is -- as we need the kernel part for the kconsole)
    7374 * defines a shared buffer. Kernel walks through the buffer (in the same thread
    7475 * which is used for polling the keyboard) and prints any pending characters
    75  * to the console (using hypercalls). The userspace fb server maps this shared
    76  * buffer to its address space and output operation it does is performed using
    77  * the mapped buffer. The shared buffer definition follows.
    78  */
    79 #define OUTPUT_BUFFER_SIZE      ((PAGE_SIZE) - 2 * 8)
     76 * to the console (using hypercalls).
     77 *
     78 * The userspace fb server maps this shared buffer to its address space and
     79 * output operation it does is performed using the mapped buffer. The shared
     80 * buffer definition follows.
     81 */
     82#define OUTPUT_BUFFER_SIZE  ((PAGE_SIZE) - 2 * 8)
     83
    8084static volatile struct {
    8185        uint64_t read_ptr;
    8286        uint64_t write_ptr;
    8387        char data[OUTPUT_BUFFER_SIZE];
    84 }
    85         __attribute__ ((packed))
    86         __attribute__ ((aligned(PAGE_SIZE)))
    87         output_buffer;
     88} __attribute__ ((packed)) __attribute__ ((aligned(PAGE_SIZE))) output_buffer;
     89
     90static parea_t outbuf_parea;
    8891
    8992/**
    9093 * Analogous to the output_buffer, see the previous definition.
    9194 */
    92 #define INPUT_BUFFER_SIZE       ((PAGE_SIZE) - 2 * 8)
     95#define INPUT_BUFFER_SIZE  ((PAGE_SIZE) - 2 * 8)
     96
    9397static volatile struct {
    9498        uint64_t write_ptr;
    9599        uint64_t read_ptr;
    96100        char data[INPUT_BUFFER_SIZE];
    97 }
    98         __attribute__ ((packed))
    99         __attribute__ ((aligned(PAGE_SIZE)))
    100         input_buffer;
    101 
    102 
    103 /** Writes a single character to the standard output. */
     101} __attribute__ ((packed)) __attribute__ ((aligned(PAGE_SIZE))) input_buffer;
     102
     103static parea_t inbuf_parea;
     104
     105/** Write a single character to the standard output. */
    104106static inline void do_putchar(const char c) {
    105         /* repeat until the buffer is non-full */
    106         while (__hypercall_fast1(CONS_PUTCHAR, c) == HV_EWOULDBLOCK)
    107                 ;
    108 }
    109 
    110 /** Writes a single character to the standard output. */
    111 static void niagara_putchar(outdev_t *dev, const wchar_t ch, bool silent)
    112 {
    113         if (silent)
    114             return;
    115 
    116         do_putchar(ch);
    117         if (ch == '\n')
    118                 do_putchar('\r');
    119 }
    120 
    121 /**
    122  * Function regularly called by the keyboard polling thread. Asks the
    123  * hypervisor whether there is any unread character. If so, it picks it up
    124  * and sends it to the upper layers of HelenOS.
    125  *
    126  * Apart from that, it also checks whether the userspace output driver has
    127  * pushed any characters to the output buffer. If so, it prints them.
    128  */
    129 static void niagara_poll(niagara_instance_t *instance)
    130 {
    131         /* print any pending characters from the shared buffer to the console */
     107        /* Repeat until the buffer is non-full */
     108        while (__hypercall_fast1(CONS_PUTCHAR, c) == HV_EWOULDBLOCK);
     109}
     110
     111/** Write a single character to the standard output. */
     112static void niagara_putchar(outdev_t *dev, const wchar_t ch)
     113{
     114        if ((!outbuf_parea.mapped) || (console_override)) {
     115                do_putchar(ch);
     116                if (ch == '\n')
     117                        do_putchar('\r');
     118        }
     119}
     120
     121/** Poll keyboard and print pending characters.
     122 *
     123 * Ask the hypervisor whether there is any unread character. If so,
     124 * pick it up and send it to the indev layer.
     125 *
     126 * Check whether the userspace output driver has pushed any
     127 * characters to the output buffer and eventually print them.
     128 *
     129 */
     130static void niagara_poll(void)
     131{
     132        /*
     133         * Print any pending characters from the
     134         * shared buffer to the console.
     135         */
     136       
    132137        while (output_buffer.read_ptr != output_buffer.write_ptr) {
    133138                do_putchar(output_buffer.data[output_buffer.read_ptr]);
    134139                output_buffer.read_ptr =
    135                         ((output_buffer.read_ptr) + 1) % OUTPUT_BUFFER_SIZE;
    136         }
    137 
     140                    ((output_buffer.read_ptr) + 1) % OUTPUT_BUFFER_SIZE;
     141        }
     142       
     143        /*
     144         * Read character from keyboard.
     145         */
     146       
    138147        uint64_t c;
    139 
    140         /* read character from keyboard, send it to upper layers of HelenOS */
    141148        if (__hypercall_fast_ret1(0, 0, 0, 0, 0, CONS_GETCHAR, &c) == HV_EOK) {
    142                 if (!silent) {
    143                         /* kconsole active, send the character to kernel */
     149                if ((!inbuf_parea.mapped) || (console_override)) {
     150                        /*
     151                         * Kernel console is active, send
     152                         * the character to kernel.
     153                         */
    144154                        indev_push_character(instance->srlnin, c);
    145155                } else {
    146                         /* kconsole inactive, send the character to uspace driver */
     156                        /*
     157                         * Kernel console is inactive, send
     158                         * the character to uspace driver.
     159                         */
    147160                        input_buffer.data[input_buffer.write_ptr] = (char) c;
    148161                        input_buffer.write_ptr =
    149                                 ((input_buffer.write_ptr) + 1) % INPUT_BUFFER_SIZE;
     162                            ((input_buffer.write_ptr) + 1) % INPUT_BUFFER_SIZE;
    150163                }
    151164        }
    152165}
    153166
    154 /**
    155  * Polling thread function.
    156  */
    157 static void kniagarapoll(void *instance) {
     167/** Polling thread function.
     168 *
     169 */
     170static void kniagarapoll(void *arg) {
    158171        while (true) {
    159                 niagara_poll(instance);
     172                niagara_poll();
    160173                thread_usleep(POLL_INTERVAL);
    161174        }
    162175}
    163176
    164 /**
    165  * Initializes the input/output subsystem so that the Niagara standard
    166  * input/output is used.
     177/** Initialize the input/output subsystem
     178 *
    167179 */
    168180static void niagara_init(void)
    … …  
    172184       
    173185        instance = malloc(sizeof(niagara_instance_t), FRAME_ATOMIC);
    174        
    175         if (instance) {
    176                 instance->thread = thread_create(kniagarapoll, instance, TASK, 0,
    177                         "kniagarapoll", true);
    178                
    179                 if (!instance->thread) {
    180                         free(instance);
    181                         instance = NULL;
    182                         return;
    183                 }
    184         }
    185 
     186        instance->thread = thread_create(kniagarapoll, NULL, TASK, 0,
     187            "kniagarapoll", true);
     188       
     189        if (!instance->thread) {
     190                free(instance);
     191                instance = NULL;
     192                return;
     193        }
     194       
    186195        instance->srlnin = NULL;
    187 
     196       
    188197        output_buffer.read_ptr = 0;
    189198        output_buffer.write_ptr = 0;
    190199        input_buffer.write_ptr = 0;
    191200        input_buffer.read_ptr = 0;
    192 
     201       
    193202        /*
    194203         * Set sysinfos and pareas so that the userspace counterpart of the
    195204         * niagara fb and kbd driver can communicate with kernel using shared
    196205         * buffers.
    197          */
    198 
     206         */
     207       
    199208        sysinfo_set_item_val("fb.kind", NULL, 5);
    200 
     209       
    201210        sysinfo_set_item_val("niagara.outbuf.address", NULL,
    202                 KA2PA(&output_buffer));
     211            KA2PA(&output_buffer));
    203212        sysinfo_set_item_val("niagara.outbuf.size", NULL,
    204                 PAGE_SIZE);
     213            PAGE_SIZE);
    205214        sysinfo_set_item_val("niagara.outbuf.datasize", NULL,
    206                 OUTPUT_BUFFER_SIZE);
    207 
     215            OUTPUT_BUFFER_SIZE);
     216       
    208217        sysinfo_set_item_val("niagara.inbuf.address", NULL,
    209                 KA2PA(&input_buffer));
     218            KA2PA(&input_buffer));
    210219        sysinfo_set_item_val("niagara.inbuf.size", NULL,
    211                 PAGE_SIZE);
     220            PAGE_SIZE);
    212221        sysinfo_set_item_val("niagara.inbuf.datasize", NULL,
    213                 INPUT_BUFFER_SIZE);
    214 
    215         static parea_t outbuf_parea;
     222           INPUT_BUFFER_SIZE);
     223       
    216224        outbuf_parea.pbase = (uintptr_t) (KA2PA(&output_buffer));
    217225        outbuf_parea.frames = 1;
    218226        outbuf_parea.unpriv = false;
     227        outbuf_parea.mapped = false;
    219228        ddi_parea_register(&outbuf_parea);
    220 
    221         static parea_t inbuf_parea;
     229       
    222230        inbuf_parea.pbase = (uintptr_t) (KA2PA(&input_buffer));
    223231        inbuf_parea.frames = 1;
    224232        inbuf_parea.unpriv = false;
     233        inbuf_parea.mapped = false;
    225234        ddi_parea_register(&inbuf_parea);
    226 
     235       
    227236        outdev_t *niagara_dev = malloc(sizeof(outdev_t), FRAME_ATOMIC);
    228237        outdev_initialize("niagara_dev", niagara_dev, &niagara_ops);
    … …  
    230239}
    231240
    232 /**
    233  * A public function which initializes input from the Niagara console.
     241/** Initialize input from the Niagara console.
     242 *
    234243 */
    235244niagara_instance_t *niagarain_init(void)
    236245{
    237246        niagara_init();
    238 
     247       
    239248        if (instance) {
    240249                srln_instance_t *srln_instance = srln_init();
    … …  
    242251                        indev_t *sink = stdin_wire();
    243252                        indev_t *srln = srln_wire(srln_instance, sink);
    244 
    245                         // wire std. input to niagara
     253                       
    246254                        instance->srlnin = srln;
    247255                        thread_ready(instance->thread);
    248256                }
    249257        }
     258       
    250259        return instance;
    251260}

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

    r3842a955 r26e7d6d  
    3939#include <genarch/ofw/upa.h>
    4040#include <genarch/fb/fb.h>
    41 #include <genarch/fb/visuals.h>
     41#include <abi/fb/visuals.h>
    4242#include <console/chardev.h>
    4343#include <console/console.h>

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

    r3842a955 r26e7d6d  
    4242#include <macros.h>
    4343#include <typedefs.h>
    44 #include <synch/synch.h>
    4544#include <synch/waitq.h>
    4645#include <print.h>

  • kernel/arch/sparc64/src/smp/sun4v/smp.c

    r3842a955 r26e7d6d  
    4545#include <func.h>
    4646#include <typedefs.h>
    47 #include <synch/synch.h>
    4847#include <synch/waitq.h>
    4948#include <print.h>

  • kernel/arch/sparc64/src/sun4v/start.S

    r3842a955 r26e7d6d  
    3030#include <arch/arch.h>
    3131#include <arch/stack.h>
     32#include <arch/regdef.h>
    3233#include <arch/context_offset.h>
    3334#include <arch/sun4v/regdef.h>
Note: See TracChangeset for help on using the changeset viewer.