Changes in / [9a1d8ab:dba4a23] in mainline


Ignore:
Files:
13 added
4 deleted
35 edited

Legend:

Unmodified
Added
Removed

  • HelenOS.config

    r9a1d8ab rdba4a23  
    441441! [(CONFIG_HID_OUT=generic|CONFIG_HID_OUT=serial)&PLATFORM=arm32&MACHINE=gta02] CONFIG_S3C24XX_UART (y/n)
    442442
    443 % Support for Samsung S3C24XX on-chip interrupt controller
    444 ! [PLATFORM=arm32&MACHINE=gta02] CONFIG_S3C24XX_IRQC (y)
    445 
    446443% Support for Z8530 controller
    447444! [(CONFIG_HID_IN=generic|CONFIG_HID_IN=keyboard)&PLATFORM=sparc64&MACHINE=generic] CONFIG_Z8530 (y/n)
    … …  
    472469
    473470% Serial line input module
    474 ! [CONFIG_DSRLNIN=y|(PLATFORM=arm32&MACHINE=gta02)|(PLATFORM=ia64&MACHINE=i460GX&CONFIG_NS16550=y)|(PLATFORM=ia64&MACHINE=ski)|(PLATFORM=sparc64&MACHINE=serengeti&CONFIG_SGCN_KBD=y)|(PLATFORM=sparc64&PROCESSOR=sun4v)] CONFIG_SRLN (y)
     471! [CONFIG_DSRLNIN=y|(PLATFORM=ia64&MACHINE=i460GX&CONFIG_NS16550=y)|(PLATFORM=ia64&MACHINE=ski)|(PLATFORM=sparc64&MACHINE=serengeti&CONFIG_SGCN_KBD=y)|(PLATFORM=sparc64&PROCESSOR=sun4v)] CONFIG_SRLN (y)
    475472
    476473% EGA support
    … …  
    546543! CONFIG_BAREBONE (n/y)
    547544
    548 % Line debugging information
    549 ! [CONFIG_STRIP_BINARIES!=y] CONFIG_LINE_DEBUG (n/y)

  • boot/Makefile

    r9a1d8ab rdba4a23  
    4848endif
    4949ifeq ($(RDFMT),fat)
    50         $(MKFAT) 1048576 $(DIST_PATH) $@
     50        $(MKFAT) $(DIST_PATH) $@
    5151endif
    5252

  • boot/Makefile.build

    r9a1d8ab rdba4a23  
    6161        GCC_CFLAGS += -Werror
    6262        ICC_CFLAGS += -Werror
    63 endif
    64 
    65 ifeq ($(CONFIG_LINE_DEBUG),y)
    66         GCC_CFLAGS += -g
    67         ICC_CFLAGS += -g
    68         SUNCC_CFLAGS += -g
    69         CLANG_CFLAGS += -g
    7063endif
    7164

  • boot/arch/arm32/Makefile.inc

    r9a1d8ab rdba4a23  
    4141PAGE_SIZE = 4096
    4242
    43 RD_SRVS_ESSENTIAL += \
    44         $(USPACE_PATH)/srv/hw/char/s3c24xx_uart/s3c24ser
     43RD_SRVS_ESSENTIAL +=
    4544
    4645RD_SRVS_NON_ESSENTIAL += \

  • boot/arch/mips32/src/Makefile

    r9a1d8ab rdba4a23  
    3232.PHONY: all clean
    3333
    34 all: ../../../../version ../../../../Makefile.common ../../../../Makefile.config ../../../../config.h
     34all: ../../../../version ../../../../Makefile.config ../../../../config.h ../../../../config.defs
    3535        -[ -f $(DEPEND) ] && mv -f $(DEPEND) $(DEPEND_PREV)
    3636        $(MAKE) -f Makefile.build PRECHECK=$(PRECHECK)
    3737
    3838clean:
    39         rm -f $(USPACEDIR)/dist/srv/*
    40         rm -f $(USPACEDIR)/dist/app/*
    41         rm -f $(USPACEDIR)/dist/cfg/net/*
    42 
    4339        for file in $(RD_SRVS) ; do \
    4440                rm -f $(USPACEDIR)/dist/srv/`basename $$file` ; \
    … …  
    4743                rm -f $(USPACEDIR)/dist/app/`basename $$file` ; \
    4844        done
    49         for file in $(NET_CFG) ; do \
    50                 rm -f $(USPACEDIR)/dist/cfg/net/`basename $$file` ; \
    51         done
    5245        rm -f $(DEPEND) $(DEPEND_PREV) $(JOB) $(OUTPUT) $(RAW) $(COMPS).h $(COMPS).c $(LINK) $(INITRD).img $(INITRD).fs
    5346        find . -name '*.o' -follow -exec rm \{\} \;

  • boot/arch/mips32/src/Makefile.build

    r9a1d8ab rdba4a23  
    3232
    3333include ../../../../version
    34 include ../../../../Makefile.common
    3534include ../../../../Makefile.config
     35include ../../../../config.defs
    3636include Makefile.common
    3737include Makefile.toolchain
    … …  
    7777
    7878$(DEPEND):
    79         rm -f $(USPACEDIR)/dist/srv/*
    80         rm -f $(USPACEDIR)/dist/app/*
    81         rm -f $(USPACEDIR)/dist/cfg/net/*
    82 
    8379        for file in $(RD_SRVS) ; do \
    8480                cp $$file $(USPACEDIR)/dist/srv/ ; \
    … …  
    8682        for file in $(RD_APPS) ; do \
    8783                cp $$file $(USPACEDIR)/dist/app/ ; \
    88         done
    89         for file in $(NET_CFG) ; do \
    90                 cp $$file $(USPACEDIR)/dist/cfg/net/ ; \
    9184        done
    9285ifeq ($(RDFMT),tmpfs)

  • boot/arch/mips32/src/Makefile.toolchain

    r9a1d8ab rdba4a23  
    2727#
    2828
     29## Toolchain configuration
     30#
     31
     32ifndef CROSS_PREFIX
     33        CROSS_PREFIX = /usr/local
     34endif
     35
    2936BFD_ARCH = mips
     37TARGET = mipsel-linux-gnu
     38TOOLCHAIN_DIR = $(CROSS_PREFIX)/mips32/bin
    3039
    3140JOBFILE = ../../../../tools/jobfile.py
    … …  
    3948        BFD_NAME = elf32-tradbigmips
    4049        BFD = ecoff-bigmips
     50        TOOLCHAIN_DIR = $(CROSS_PREFIX)/mips32eb/bin
     51        TARGET = mips-linux-gnu
    4152endif
    4253
    … …  
    4455        BFD_NAME = elf32-tradlittlemips
    4556        BFD = binary
     57endif
     58
     59ifeq ($(COMPILER),gcc_native)
     60        CC = gcc
     61        AS = as
     62        LD = ld
     63        OBJCOPY = objcopy
     64        OBJDUMP = objdump
     65endif
     66
     67ifeq ($(COMPILER),gcc_cross)
     68        CC = $(TOOLCHAIN_DIR)/$(TARGET)-gcc
     69        AS = $(TOOLCHAIN_DIR)/$(TARGET)-as
     70        LD = $(TOOLCHAIN_DIR)/$(TARGET)-ld
     71        OBJCOPY = $(TOOLCHAIN_DIR)/$(TARGET)-objcopy
     72        OBJDUMP = $(TOOLCHAIN_DIR)/$(TARGET)-objdump
    4673endif
    4774

  • contrib/conf/ia32-qe.sh

    r9a1d8ab rdba4a23  
    55# Create a disk image if it does not exist
    66if [ ! -f "$DISK_IMG" ]; then
    7         tools/mkfat.py 1048576 uspace/dist/data "$DISK_IMG"
     7        tools/mkfat.py uspace/dist/data "$DISK_IMG"
    88fi
    99

  • contrib/conf/mips32-gx.sh

    r9a1d8ab rdba4a23  
    55# Create a disk image if it does not exist
    66if [ ! -f "$DISK_IMG" ]; then
    7         tools/mkfat.py 1048576 uspace/dist/data "$DISK_IMG"
     7        tools/mkfat.py uspace/dist/data "$DISK_IMG"
    88fi
    99

  • kernel/Makefile

    r9a1d8ab rdba4a23  
    120120ifeq ($(CONFIG_LTO),y)
    121121        GCC_CFLAGS += -flto
    122 endif
    123 
    124 ifeq ($(CONFIG_LINE_DEBUG),y)
    125         GCC_CFLAGS += -g
    126         ICC_CFLAGS += -g
    127         SUNCC_CFLAGS += -g
    128         CLANG_CFLAGS += -g
    129122endif
    130123
    … …  
    408401
    409402$(DISASM): $(RAW)
    410 ifeq ($(CONFIG_LINE_DEBUG),y)
    411         $(OBJDUMP) -d -S $< > $@
    412 else
    413403        $(OBJDUMP) -d $< > $@
    414 endif
    415404
    416405$(RAW): $(LINK) $(ARCH_OBJECTS) $(GENARCH_OBJECTS) $(GENERIC_OBJECTS) $(SYMTAB_OBJECTS)

  • kernel/arch/amd64/_link.ld.in

    r9a1d8ab rdba4a23  
    5353        }
    5454       
    55 #ifdef CONFIG_LINE_DEBUG
    56         .comment 0 : { *(.comment); }
    57         .debug_abbrev 0 : { *(.debug_abbrev); }
    58         .debug_aranges 0 : { *(.debug_aranges); }
    59         .debug_info 0 : { *(.debug_info); }
    60         .debug_line 0 : { *(.debug_line); }
    61         .debug_loc 0 : { *(.debug_loc); }
    62         .debug_pubnames 0 : { *(.debug_pubnames); }
    63         .debug_pubtypes 0 : { *(.debug_pubtypes); }
    64         .debug_ranges 0 : { *(.debug_ranges); }
    65         .debug_str 0 : { *(.debug_str); }
    66 #endif
    67        
    6855        /DISCARD/ : {
    6956                *(*);

  • kernel/arch/arm32/include/mach/integratorcp/integratorcp.h

    r9a1d8ab rdba4a23  
    105105extern void icp_get_memory_extents(uintptr_t *, uintptr_t *);
    106106extern void icp_frame_init(void);
    107 extern size_t icp_get_irq_count(void);
    108107
    109108extern struct arm_machine_ops icp_machine_ops;

  • kernel/arch/arm32/include/mach/testarm/testarm.h

    r9a1d8ab rdba4a23  
    7373extern void gxemul_get_memory_extents(uintptr_t *, uintptr_t *);
    7474extern void gxemul_frame_init(void);
    75 extern size_t gxemul_get_irq_count(void);
    7675
    7776extern struct arm_machine_ops gxemul_machine_ops;

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

    r9a1d8ab rdba4a23  
    5555        void (*machine_output_init)(void);
    5656        void (*machine_input_init)(void);
    57         size_t (*machine_get_irq_count)(void);
    5857};
    5958

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

    r9a1d8ab rdba4a23  
    4343#include <genarch/drivers/s3c24xx_irqc/s3c24xx_irqc.h>
    4444#include <genarch/drivers/s3c24xx_timer/s3c24xx_timer.h>
    45 #include <genarch/srln/srln.h>
    46 #include <sysinfo/sysinfo.h>
    4745#include <interrupt.h>
    4846#include <ddi/ddi.h>
    … …  
    7068static void gta02_output_init(void);
    7169static void gta02_input_init(void);
    72 static size_t gta02_get_irq_count(void);
    7370
    7471static void gta02_timer_irq_init(void);
    … …  
    7774static void gta02_timer_irq_handler(irq_t *irq);
    7875
    79 static outdev_t *gta02_scons_dev;
    80 static s3c24xx_irqc_t gta02_irqc;
     76static void *gta02_scons_out;
     77static s3c24xx_irqc_t *gta02_irqc;
    8178static s3c24xx_timer_t *gta02_timer;
    8279
    … …  
    9188        gta02_frame_init,
    9289        gta02_output_init,
    93         gta02_input_init,
    94         gta02_get_irq_count
     90        gta02_input_init
    9591};
    9692
    9793static void gta02_init(void)
    9894{
    99         s3c24xx_irqc_regs_t *irqc_regs;
    100 
     95        gta02_scons_out = (void *) hw_map(GTA02_SCONS_BASE, PAGE_SIZE);
     96        gta02_irqc = (void *) hw_map(S3C24XX_IRQC_ADDRESS, PAGE_SIZE);
    10197        gta02_timer = (void *) hw_map(S3C24XX_TIMER_ADDRESS, PAGE_SIZE);
    102         irqc_regs = (void *) hw_map(S3C24XX_IRQC_ADDRESS, PAGE_SIZE);
    103 
    104         /* Initialize interrupt controller. */
    105         s3c24xx_irqc_init(&gta02_irqc, irqc_regs);
     98
     99        /* Make all interrupt sources use IRQ mode (not FIQ). */
     100        pio_write_32(&gta02_irqc->intmod, 0x00000000);
     101
     102        /* Disable all interrupt sources. */
     103        pio_write_32(&gta02_irqc->intmsk, 0xffffffff);
     104
     105        /* Disable interrupts from all sub-sources. */
     106        pio_write_32(&gta02_irqc->intsubmsk, 0xffffffff);
    106107}
    107108
    … …  
    131132        uint32_t inum;
    132133
    133         /* Determine IRQ number. */
    134         inum = s3c24xx_irqc_inum_get(&gta02_irqc);
    135 
    136         /* Clear interrupt condition in the interrupt controller. */
    137         s3c24xx_irqc_clear(&gta02_irqc, inum);
     134        inum = pio_read_32(&gta02_irqc->intoffset);
    138135
    139136        irq_t *irq = irq_dispatch_and_lock(inum);
    … …  
    147144                    CPU->id, inum);
    148145        }
     146
     147        /* Clear interrupt condition in the interrupt controller. */
     148        pio_write_32(&gta02_irqc->srcpnd, S3C24XX_INT_BIT(inum));
     149        pio_write_32(&gta02_irqc->intpnd, S3C24XX_INT_BIT(inum));
    149150}
    150151
    … …  
    175176        }
    176177#endif
    177 
    178         /* Initialize serial port of the debugging console. */
    179         s3c24xx_uart_io_t *scons_io;
    180 
    181         scons_io = (void *) hw_map(GTA02_SCONS_BASE, PAGE_SIZE);
    182         gta02_scons_dev = s3c24xx_uart_init(scons_io, S3C24XX_INT_UART2);
    183 
    184         if (gta02_scons_dev) {
    185                 /* Create output device. */
    186                 stdout_wire(gta02_scons_dev);
    187         }
    188 
    189         /*
    190          * This is the necessary evil until the userspace driver is entirely
    191          * self-sufficient.
    192          */
    193         sysinfo_set_item_val("s3c24xx_uart", NULL, true);
    194         sysinfo_set_item_val("s3c24xx_uart.inr", NULL, S3C24XX_INT_UART2);
    195         sysinfo_set_item_val("s3c24xx_uart.address.physical", NULL,
    196             (uintptr_t) GTA02_SCONS_BASE);
    197 
     178        outdev_t *scons_dev;
     179
     180        scons_dev = s3c24xx_uart_init((ioport8_t *) gta02_scons_out);
     181        if (scons_dev)
     182                stdout_wire(scons_dev);
    198183}
    199184
    200185static void gta02_input_init(void)
    201186{
    202         s3c24xx_uart_t *scons_inst;
    203 
    204         if (gta02_scons_dev) {
    205                 /* Create input device. */
    206                 scons_inst = (void *) gta02_scons_dev->data;
    207 
    208                 srln_instance_t *srln_instance = srln_init();
    209                 if (srln_instance) {
    210                         indev_t *sink = stdin_wire();
    211                         indev_t *srln = srln_wire(srln_instance, sink);
    212                         s3c24xx_uart_input_wire(scons_inst, srln);
    213 
    214                         /* Enable interrupts from UART2 */
    215                         s3c24xx_irqc_src_enable(&gta02_irqc,
    216                             S3C24XX_INT_UART2);
    217 
    218                         /* Enable interrupts from UART2 RXD */
    219                         s3c24xx_irqc_subsrc_enable(&gta02_irqc,
    220                             S3C24XX_SUBINT_RXD2);
    221                 }
    222         }
    223 }
    224 
    225 size_t gta02_get_irq_count(void)
    226 {
    227         return GTA02_IRQ_COUNT;
    228187}
    229188
    … …  
    289248
    290249        /* Enable interrupts from timer0 */
    291         s3c24xx_irqc_src_enable(&gta02_irqc, S3C24XX_INT_TIMER0);
     250        pio_write_32(&gta02_irqc->intmsk, pio_read_32(&gta02_irqc->intmsk) &
     251            ~S3C24XX_INT_BIT(S3C24XX_INT_TIMER0));
    292252
    293253        /* Load data from tcntb0/tcmpb0 into tcnt0/tcmp0. */

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

    r9a1d8ab rdba4a23  
    6464        icp_frame_init,
    6565        icp_output_init,
    66         icp_input_init,
    67         icp_get_irq_count
     66        icp_input_init
    6867};
    6968
    … …  
    337336}
    338337
    339 size_t icp_get_irq_count(void)
    340 {
    341         return ICP_IRQ_COUNT;
    342 }
    343338
    344339/** @}

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

    r9a1d8ab rdba4a23  
    6464        gxemul_frame_init,
    6565        gxemul_output_init,
    66         gxemul_input_init,
    67         gxemul_get_irq_count
     66        gxemul_input_init
    6867};
    6968
    … …  
    127126}
    128127
    129 size_t gxemul_get_irq_count(void)
    130 {
    131         return GXEMUL_IRQ_COUNT;
    132 }
    133 
    134128/** Starts gxemul Real Time Clock device, which asserts regular interrupts.
    135129 *

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

    r9a1d8ab rdba4a23  
    128128size_t machine_get_irq_count(void)
    129129{
    130         return (machine_ops->machine_get_irq_count)();
     130        size_t irq_count;
     131 
     132#if defined(MACHINE_gta02)
     133        irq_count = GTA02_IRQ_COUNT;
     134#elif defined(MACHINE_testarm)
     135        irq_count = GXEMUL_IRQ_COUNT;
     136#elif defined(MACHINE_integratorcp)
     137        irq_count = ICP_IRQ_COUNT;
     138#else
     139#error Machine type not defined.
     140#endif
     141        return irq_count;
    131142}
    132143

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

    r9a1d8ab rdba4a23  
    131131                        if (last_frame < ALIGN_UP(new_base + new_size, FRAME_SIZE))
    132132                                last_frame = ALIGN_UP(new_base + new_size, FRAME_SIZE);
    133                 } else if ((e820table[i].type == MEMMAP_MEMORY_ACPI) ||
    134                     (e820table[i].type == MEMMAP_MEMORY_NVS)) {
     133                }
     134               
     135                if (e820table[i].type == MEMMAP_MEMORY_RESERVED) {
     136                        /* To be safe, make the reserved zone possibly larger */
     137                        uint64_t new_base = ALIGN_DOWN(base, FRAME_SIZE);
     138                        uint64_t new_size = ALIGN_UP(size + (base - new_base),
     139                            FRAME_SIZE);
     140                       
     141                        zone_create(ADDR2PFN(new_base), SIZE2FRAMES(new_size), 0,
     142                            ZONE_RESERVED);
     143                }
     144               
     145                if (e820table[i].type == MEMMAP_MEMORY_ACPI) {
    135146                        /* To be safe, make the firmware zone possibly larger */
    136147                        uint64_t new_base = ALIGN_DOWN(base, FRAME_SIZE);
    … …  
    140151                        zone_create(ADDR2PFN(new_base), SIZE2FRAMES(new_size), 0,
    141152                            ZONE_FIRMWARE);
    142                 } else {
    143                         /* To be safe, make the reserved zone possibly larger */
    144                         uint64_t new_base = ALIGN_DOWN(base, FRAME_SIZE);
    145                         uint64_t new_size = ALIGN_UP(size + (base - new_base),
    146                             FRAME_SIZE);
    147                        
    148                         zone_create(ADDR2PFN(new_base), SIZE2FRAMES(new_size), 0,
    149                             ZONE_RESERVED);
    150153                }
    151154        }
    … …  
    200203#ifdef CONFIG_SMP
    201204                /* Reserve AP real mode bootstrap memory */
    202                 frame_mark_unavailable(AP_BOOT_OFFSET >> FRAME_WIDTH,
     205                frame_mark_unavailable(AP_BOOT_OFFSET >> FRAME_WIDTH, 
    203206                    (hardcoded_unmapped_ktext_size +
    204207                    hardcoded_unmapped_kdata_size) >> FRAME_WIDTH);

  • kernel/genarch/Makefile.inc

    r9a1d8ab rdba4a23  
    9090endif
    9191
    92 ifeq ($(CONFIG_S3C24XX_IRQC),y)
    93         GENARCH_SOURCES += \
    94                 genarch/src/drivers/s3c24xx_irqc/s3c24xx_irqc.c
    95 endif
    96 
    9792ifeq ($(CONFIG_S3C24XX_UART),y)
    9893        GENARCH_SOURCES += \

  • kernel/genarch/include/drivers/s3c24xx_irqc/s3c24xx_irqc.h

    r9a1d8ab rdba4a23  
    5353        ioport32_t subsrcpnd;   /**< Sub source pending */
    5454        ioport32_t intsubmsk;   /** Interrupt sub mask */
    55 } s3c24xx_irqc_regs_t;
     55} s3c24xx_irqc_t;
    5656
    5757/** S3C24xx Interrupt source numbers.
    … …  
    120120#define S3C24XX_SUBINT_BIT(subsource) (1 << (subsource))
    121121
    122 typedef struct {
    123         s3c24xx_irqc_regs_t *regs;
    124 } s3c24xx_irqc_t;
    125 
    126 extern void s3c24xx_irqc_init(s3c24xx_irqc_t *, s3c24xx_irqc_regs_t *);
    127 extern unsigned s3c24xx_irqc_inum_get(s3c24xx_irqc_t *);
    128 extern void s3c24xx_irqc_clear(s3c24xx_irqc_t *, unsigned);
    129 extern void s3c24xx_irqc_src_enable(s3c24xx_irqc_t *, unsigned);
    130 extern void s3c24xx_irqc_src_disable(s3c24xx_irqc_t *, unsigned);
    131 extern void s3c24xx_irqc_subsrc_enable(s3c24xx_irqc_t *, unsigned);
    132 extern void s3c24xx_irqc_subsrc_disable(s3c24xx_irqc_t *, unsigned);
    133 
    134122#endif
    135123

  • kernel/genarch/include/drivers/s3c24xx_uart/s3c24xx_uart.h

    r9a1d8ab rdba4a23  
    3838#define KERN_S3C24XX_UART_H_
    3939
    40 #include <ddi/irq.h>
     40#include <typedefs.h>
    4141#include <console/chardev.h>
    42 #include <typedefs.h>
    4342
    44 /** S3C24xx UART I/O */
    45 typedef struct {
    46         uint32_t ulcon;
    47         uint32_t ucon;
    48         uint32_t ufcon;
    49         uint32_t umcon;
    50 
    51         uint32_t utrstat;
    52         uint32_t uerstat;
    53         uint32_t ufstat;
    54         uint32_t umstat;
    55 
    56         uint32_t utxh;
    57         uint32_t urxh;
    58 
    59         uint32_t ubrdiv;
    60 } s3c24xx_uart_io_t;
    61 
    62 /** S3C24xx UART instance */
    63 typedef struct {
    64         s3c24xx_uart_io_t *io;
    65         indev_t *indev;
    66         irq_t irq;
    67 } s3c24xx_uart_t;
    68 
    69 extern outdev_t *s3c24xx_uart_init(s3c24xx_uart_io_t *, inr_t inr);
    70 extern void s3c24xx_uart_input_wire(s3c24xx_uart_t *,
    71     indev_t *);
     43extern outdev_t *s3c24xx_uart_init(ioport8_t *);
    7244
    7345#endif

  • kernel/genarch/src/drivers/s3c24xx_uart/s3c24xx_uart.c

    r9a1d8ab rdba4a23  
    4040#include <genarch/drivers/s3c24xx_uart/s3c24xx_uart.h>
    4141#include <console/chardev.h>
    42 #include <console/console.h>
    43 #include <ddi/device.h>
    4442#include <arch/asm.h>
    4543#include <mm/slab.h>
     44#include <console/console.h>
    4645#include <sysinfo/sysinfo.h>
    4746#include <str.h>
    4847
    49 /* Bits in UTRSTAT register */
    50 #define S3C24XX_UTRSTAT_TX_EMPTY        0x4
    51 #define S3C24XX_UTRSTAT_RDATA           0x1
     48/** S3C24xx UART register offsets */
     49#define S3C24XX_UTRSTAT         0x10
     50#define S3C24XX_UTXH            0x20
    5251
    53 #define S3C24XX_UFSTAT_TX_FULL          0x4000
    54 #define S3C24XX_UFSTAT_RX_FULL          0x0040
    55 #define S3C24XX_UFSTAT_RX_COUNT         0x002f
     52/* Bits in UTXH register */
     53#define S3C24XX_UTXH_TX_EMPTY   0x4
     54
     55typedef struct {
     56        ioport8_t *base;
     57} s3c24xx_uart_instance_t;
    5658
    5759static void s3c24xx_uart_sendb(outdev_t *dev, uint8_t byte)
    5860{
    59         s3c24xx_uart_t *uart =
    60             (s3c24xx_uart_t *) dev->data;
     61        s3c24xx_uart_instance_t *instance =
     62            (s3c24xx_uart_instance_t *) dev->data;
     63        ioport32_t *utrstat, *utxh;
    6164
    62         /* Wait for space becoming available in Tx FIFO. */
    63         while ((pio_read_32(&uart->io->ufstat) & S3C24XX_UFSTAT_TX_FULL) != 0)
     65        utrstat = (ioport32_t *) (instance->base + S3C24XX_UTRSTAT);
     66        utxh = (ioport32_t *) (instance->base + S3C24XX_UTXH);
     67
     68        /* Wait for transmitter to be empty. */
     69        while ((pio_read_32(utrstat) & S3C24XX_UTXH_TX_EMPTY) == 0)
    6470                ;
    6571
    66         pio_write_32(&uart->io->utxh, byte);
     72        pio_write_32(utxh, byte);
    6773}
    6874
    … …  
    8086}
    8187
    82 static irq_ownership_t s3c24xx_uart_claim(irq_t *irq)
    83 {
    84         return IRQ_ACCEPT;
    85 }
    86 
    87 static void s3c24xx_uart_irq_handler(irq_t *irq)
    88 {
    89         s3c24xx_uart_t *uart = irq->instance;
    90 
    91         while ((pio_read_32(&uart->io->ufstat) & S3C24XX_UFSTAT_RX_COUNT) != 0) {
    92                 uint32_t data = pio_read_32(&uart->io->urxh);
    93                 pio_read_32(&uart->io->uerstat);
    94                 indev_push_character(uart->indev, data & 0xff);
    95         }
    96 }
    97 
    9888static outdev_operations_t s3c24xx_uart_ops = {
    9989        .write = s3c24xx_uart_putchar,
    … …  
    10191};
    10292
    103 outdev_t *s3c24xx_uart_init(s3c24xx_uart_io_t *io, inr_t inr)
     93outdev_t *s3c24xx_uart_init(ioport8_t *base)
    10494{
    10595        outdev_t *uart_dev = malloc(sizeof(outdev_t), FRAME_ATOMIC);
    … …  
    10797                return NULL;
    10898
    109         s3c24xx_uart_t *uart =
    110             malloc(sizeof(s3c24xx_uart_t), FRAME_ATOMIC);
    111         if (!uart) {
     99        s3c24xx_uart_instance_t *instance =
     100            malloc(sizeof(s3c24xx_uart_instance_t), FRAME_ATOMIC);
     101        if (!instance) {
    112102                free(uart_dev);
    113103                return NULL;
    … …  
    115105
    116106        outdev_initialize("s3c24xx_uart_dev", uart_dev, &s3c24xx_uart_ops);
    117         uart_dev->data = uart;
     107        uart_dev->data = instance;
    118108
    119         uart->io = io;
    120         uart->indev = NULL;
    121 
    122         /* Initialize IRQ structure. */
    123         irq_initialize(&uart->irq);
    124         uart->irq.devno = device_assign_devno();
    125         uart->irq.inr = inr;
    126         uart->irq.claim = s3c24xx_uart_claim;
    127         uart->irq.handler = s3c24xx_uart_irq_handler;
    128         uart->irq.instance = uart;
    129 
    130         /* Enable FIFO, Tx trigger level: empty, Rx trigger level: 1 byte. */
    131         pio_write_32(&uart->io->ufcon, 0x01);
    132 
    133         /* Set RX interrupt to pulse mode */
    134         pio_write_32(&uart->io->ucon,
    135             pio_read_32(&uart->io->ucon) & ~(1 << 8));
     109        instance->base = base;
    136110
    137111        if (!fb_exported) {
    … …  
    142116                sysinfo_set_item_val("fb", NULL, true);
    143117                sysinfo_set_item_val("fb.kind", NULL, 3);
    144                 sysinfo_set_item_val("fb.address.physical", NULL, KA2PA(io));
     118                sysinfo_set_item_val("fb.address.physical", NULL, KA2PA(base));
    145119
    146120                fb_exported = true;
    … …  
    150124}
    151125
    152 void s3c24xx_uart_input_wire(s3c24xx_uart_t *uart, indev_t *indev)
    153 {
    154         ASSERT(uart);
    155         ASSERT(indev);
    156 
    157         uart->indev = indev;
    158         irq_register(&uart->irq);
    159 }
    160 
    161126/** @}
    162127 */

  • kernel/generic/src/mm/frame.c

    r9a1d8ab rdba4a23  
    161161        for (j = zones.count; j > i; j--) {
    162162                zones.info[j] = zones.info[j - 1];
    163                 if (zones.info[j].buddy_system != NULL)
    164                         zones.info[j].buddy_system->data =
    165                             (void *) &zones.info[j];
     163                zones.info[j].buddy_system->data =
     164                    (void *) &zones.info[j - 1];
    166165        }
    167166       
    … …  
    763762        for (i = z2 + 1; i < zones.count; i++) {
    764763                zones.info[i - 1] = zones.info[i];
    765                 if (zones.info[i - 1].buddy_system != NULL)
    766                         zones.info[i - 1].buddy_system->data =
    767                             (void *) &zones.info[i - 1];
     764                zones.info[i - 1].buddy_system->data =
     765                    (void *) &zones.info[i - 1];
    768766        }
    769767       

  • tools/mkfat.py

    r9a1d8ab rdba4a23  
    343343def usage(prname):
    344344        "Print usage syntax"
    345         print prname + " <EXTRA_BYTES> <PATH> <IMAGE>"
     345        print prname + " <PATH> <IMAGE>"
    346346
    347347def main():
    348         if (len(sys.argv) < 4):
     348        if (len(sys.argv) < 3):
    349349                usage(sys.argv[0])
    350350                return
    351351       
    352         if (not sys.argv[1].isdigit()):
    353                 print "<EXTRA_BYTES> must be a number"
    354                 return
    355        
    356         extra_bytes = int(sys.argv[1])
    357        
    358         path = os.path.abspath(sys.argv[2])
     352        path = os.path.abspath(sys.argv[1])
    359353        if (not os.path.isdir(path)):
    360354                print "<PATH> must be a directory"
    … …  
    371365       
    372366        # Make sure the filesystem is large enought for FAT16
    373         size = subtree_size(path, cluster_size, dirent_size) + reserved_clusters * cluster_size + extra_bytes
     367        size = subtree_size(path, cluster_size, dirent_size) + reserved_clusters * cluster_size
    374368        while (size / cluster_size < fat16_clusters):
    375369                if (cluster_size > sector_size):
    376370                        cluster_size /= 2
    377                         size = subtree_size(path, cluster_size, dirent_size) + reserved_clusters * cluster_size + extra_bytes
     371                        size = subtree_size(path, cluster_size, dirent_size) + reserved_clusters * cluster_size
    378372                else:
    379373                        size = fat16_clusters * cluster_size + reserved_clusters * cluster_size
    … …  
    387381        data_start = root_start + root_size
    388382       
    389         outf = file(sys.argv[3], "w")
     383        outf = file(sys.argv[2], "w")
    390384       
    391385        boot_sector = xstruct.create(BOOT_SECTOR)

  • uspace/Makefile

    r9a1d8ab rdba4a23  
    6969        srv/hid/kbd \
    7070        srv/hw/char/i8042 \
    71         srv/hw/char/s3c24xx_uart \
    7271        srv/hw/netif/dp8390 \
    7372        srv/net/cfg \

  • uspace/Makefile.common

    r9a1d8ab rdba4a23  
    172172ifneq ($(BINARY),)
    173173%.disasm: $(BINARY)
    174 ifeq ($(CONFIG_LINE_DEBUG),y)
    175         $(OBJDUMP) -d -S $< > $@
    176 else
    177174        $(OBJDUMP) -d $< > $@
    178 endif
    179175
    180176$(BINARY): $(LINKER_SCRIPT) $(OBJECTS) $(LIBS) $(BASE_LIBS)

  • uspace/app/init/init.c

    r9a1d8ab rdba4a23  
    274274        srv_start("/srv/cuda_adb");
    275275        srv_start("/srv/i8042");
    276         srv_start("/srv/s3c24ser");
    277276        srv_start("/srv/adb_ms");
    278277        srv_start("/srv/char_ms");

  • uspace/app/klog/klog.c

    r9a1d8ab rdba4a23  
    4343#include <event.h>
    4444#include <errno.h>
    45 #include <str_error.h>
    4645#include <io/klog.h>
    4746
    48 #define NAME       "klog"
    49 #define LOG_FNAME  "/log/klog"
     47#define NAME  "klog"
    5048
    5149/* Pointer to klog area */
    5250static wchar_t *klog;
    5351static size_t klog_length;
    54 
    55 static FILE *log;
    5652
    5753static void interrupt_received(ipc_callid_t callid, ipc_call_t *call)
    … …  
    6258        size_t i;
    6359       
    64         for (i = klog_len - klog_stored; i < klog_len; i++) {
    65                 wchar_t ch = klog[(klog_start + i) % klog_length];
    66                
    67                 putchar(ch);
    68                
    69                 if (log != NULL)
    70                         fputc(ch, log);
    71         }
    72        
    73         if (log != NULL) {
    74                 fflush(log);
    75                 fsync(fileno(log));
    76         }
     60        for (i = klog_len - klog_stored; i < klog_len; i++)
     61                putchar(klog[(klog_start + i) % klog_length]);
    7762}
    7863
    … …  
    10691        }
    10792       
    108         /*
    109          * Mode "a" would be definitively much better here, but it is
    110          * not well supported by the FAT driver.
    111          *
    112          */
    113         log = fopen(LOG_FNAME, "w");
    114         if (log == NULL)
    115                 printf("%s: Unable to create log file %s (%s)\n", NAME, LOG_FNAME,
    116                     str_error(errno));
    117        
    11893        async_set_interrupt_received(interrupt_received);
    11994        klog_update();

  • uspace/lib/c/generic/io/io.c

    r9a1d8ab rdba4a23  
    757757}
    758758
    759 int fileno(FILE *stream)
    760 {
    761         if (stream->klog) {
    762                 errno = EBADF;
    763                 return -1;
    764         }
    765        
    766         return stream->fd;
    767 }
    768 
    769759int fphone(FILE *stream)
    770760{

  • uspace/lib/c/include/stdio.h

    r9a1d8ab rdba4a23  
    171171extern off64_t ftell(FILE *);
    172172extern int feof(FILE *);
    173 extern int fileno(FILE *);
    174173
    175174extern int fflush(FILE *);

  • uspace/srv/fs/fat/fat_ops.c

    r9a1d8ab rdba4a23  
    15271527void fat_sync(ipc_callid_t rid, ipc_call_t *request)
    15281528{
    1529         dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
    1530         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    1531        
    1532         fs_node_t *fn;
    1533         int rc = fat_node_get(&fn, dev_handle, index);
    1534         if (rc != EOK) {
    1535                 ipc_answer_0(rid, rc);
    1536                 return;
    1537         }
    1538         if (!fn) {
    1539                 ipc_answer_0(rid, ENOENT);
    1540                 return;
    1541         }
    1542        
    1543         fat_node_t *nodep = FAT_NODE(fn);
    1544        
    1545         nodep->dirty = true;
    1546         rc = fat_node_sync(nodep);
    1547        
    1548         fat_node_put(fn);
    1549         ipc_answer_0(rid, rc);
     1529        /* Dummy implementation */
     1530        ipc_answer_0(rid, EOK);
    15501531}
    15511532

  • uspace/srv/fs/tmpfs/tmpfs_ops.c

    r9a1d8ab rdba4a23  
    736736void tmpfs_sync(ipc_callid_t rid, ipc_call_t *request)
    737737{
    738         /*
    739          * TMPFS keeps its data structures always consistent,
    740          * thus the sync operation is a no-op.
    741          */
     738        /* Dummy implementation */
    742739        ipc_answer_0(rid, EOK);
    743740}

  • uspace/srv/hid/kbd/Makefile

    r9a1d8ab rdba4a23  
    6060        ifeq ($(MACHINE),gta02)
    6161                SOURCES += \
    62                         port/chardev.c \
    63                         ctl/stty.c
     62                        port/dummy.c \
     63                        ctl/pc.c
    6464        endif
    6565        ifeq ($(MACHINE),testarm)

  • uspace/srv/hid/kbd/port/chardev.c

    r9a1d8ab rdba4a23  
    4141#include <kbd.h>
    4242#include <vfs/vfs.h>
    43 #include <sys/stat.h>
    4443#include <fcntl.h>
    4544#include <errno.h>
    … …  
    5150#define NAME "kbd"
    5251
    53 /** List of devices to try connecting to. */
    54 static const char *in_devs[] = {
    55         "/dev/char/ps2a",
    56         "/dev/char/s3c24ser"
    57 };
    58 
    59 static const int num_devs = sizeof(in_devs) / sizeof(in_devs[0]);
    60 
    6152int kbd_port_init(void)
    6253{
     54        const char *input = "/dev/char/ps2a";
    6355        int input_fd;
    64         int i;
    6556
    66         input_fd = -1;
    67         for (i = 0; i < num_devs; i++) {
    68                 struct stat s;
     57        printf(NAME ": open %s\n", input);
    6958
    70                 if (stat(in_devs[i], &s) == EOK)
    71                         break;
    72         }
    73 
    74         if (i >= num_devs) {
    75                 printf(NAME ": Could not find any suitable input device.\n");
    76                 return -1;
    77         }
    78 
    79         input_fd = open(in_devs[i], O_RDONLY);
     59        input_fd = open(input, O_RDONLY);
    8060        if (input_fd < 0) {
    81                 printf(NAME ": failed opening device %s (%d).\n", in_devs[i],
    82                     input_fd);
    83                 return -1;
     61                printf(NAME ": Failed opening %s (%d)\n", input, input_fd);
     62                return false;
    8463        }
    8564
    8665        dev_phone = fd_phone(input_fd);
    8766        if (dev_phone < 0) {
    88                 printf(NAME ": Failed connecting to device\n");
    89                 return -1;
     67                printf(NAME ": Failed to connect to device\n");
     68                return false;
    9069        }
    9170
    … …  
    9473        if (ipc_connect_to_me(dev_phone, 0, 0, 0, &phonehash) != 0) {
    9574                printf(NAME ": Failed to create callback from device\n");
    96                 return -1;
     75                return false;
    9776        }
    9877
Note: See TracChangeset for help on using the changeset viewer.