WebSVN – HelenOS – Path Comparison – / – /SPARTAN/trunk/ Rev HEAD and /SPARTAN/trunk Rev 168

Ignore whitespace Rev HEAD → Rev 168

 /SPARTAN/trunk/src/mm/vm.c
 ,0 → 1,197
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <mm/vm.h>
+#include <mm/page.h>
+#include <mm/frame.h>
+#include <mm/tlb.h>
+#include <mm/heap.h>
+#include <arch/mm/page.h>
+#include <arch/types.h>
+#include <typedefs.h>
+#include <synch/spinlock.h>
+#include <config.h>
+#include <list.h>
+#include <panic.h>
+#include <arch/asm.h>
+#include <debug.h>
+#define KAS_START_INDEX     PTL0_INDEX(KERNEL_ADDRESS_SPACE_START)
+#define KAS_END_INDEX       PTL0_INDEX(KERNEL_ADDRESS_SPACE_END)
+#define KAS_INDICES     (1+(KAS_END_INDEX-KAS_START_INDEX))
+vm_t *vm_create(pte_t *ptl0)
+{
+    vm_t *m;
+    m = (vm_t *) malloc(sizeof(vm_t));
+    if (m) {
+        spinlock_initialize(&m->lock);
+        list_initialize(&m->vm_area_head);
+        /*
+         * Each vm_t is supposed to have its own page table.
+         * It is either passed one or it has to allocate and set one up.
+         */
+        m->ptl0 = ptl0;
+        if (!m->ptl0) {
+            pte_t *src_ptl0, *dst_ptl0;
+            src_ptl0 = (pte_t *) PA2KA((__address) GET_PTL0_ADDRESS());
+            dst_ptl0 = (pte_t *) frame_alloc(FRAME_KA | FRAME_PANIC);
+//          memsetb((__address) dst_ptl0, PAGE_SIZE, 0);
+//          memcopy((__address) &src_ptl0[KAS_START_INDEX], (__address) &dst_ptl0[KAS_START_INDEX], KAS_INDICES*sizeof(pte_t));
+            memcopy(PA2KA((__address) GET_PTL0_ADDRESS()), (__address) dst_ptl0, PAGE_SIZE);
+            m->ptl0 = (pte_t *) KA2PA((__address) dst_ptl0);
+        }
+    }
+    return m;
+}
+void vm_destroy(vm_t *m)
+{
+}
+vm_area_t *vm_area_create(vm_t *m, vm_type_t type, size_t size, __address addr)
+{
+    pri_t pri;
+    vm_area_t *a;
+    if (addr % PAGE_SIZE)
+        panic("addr not aligned to a page boundary");
+    pri = cpu_priority_high();
+    spinlock_lock(&m->lock);
+    /*
+     * TODO: test vm_area which is to be created doesn't overlap with an existing one.
+     */
+    a = (vm_area_t *) malloc(sizeof(vm_area_t));
+    if (a) {
+        int i;
+        a->mapping = (__address *) malloc(size * sizeof(__address));
+        if (!a->mapping) {
+            free(a);
+            spinlock_unlock(&m->lock);
+            cpu_priority_restore(pri);
+            return NULL;
+        }
+        for (i=0; i<size; i++)
+            a->mapping[i] = frame_alloc(0);
+        spinlock_initialize(&a->lock);
+        link_initialize(&a->link);
+        a->type = type;
+        a->size = size;
+        a->address = addr;
+        list_append(&a->link, &m->vm_area_head);
+    }
+    spinlock_unlock(&m->lock);
+    cpu_priority_restore(pri);
+    return a;
+}
+void vm_area_destroy(vm_area_t *a)
+{
+}
+void vm_area_map(vm_area_t *a, vm_t *m)
+{
+    int i, flags;
+    pri_t pri;
+    pri = cpu_priority_high();
+    spinlock_lock(&m->lock);
+    spinlock_lock(&a->lock);
+    switch (a->type) {
+        case VMA_TEXT:
+            flags = PAGE_EXEC | PAGE_READ | PAGE_USER | PAGE_PRESENT | PAGE_CACHEABLE;
+            break;
+        case VMA_DATA:
+        case VMA_STACK:
+            flags = PAGE_READ | PAGE_WRITE | PAGE_USER | PAGE_PRESENT | PAGE_CACHEABLE;
+            break;
+        default:
+            panic("unexpected vm_type_t %d", a->type);
+    }
+    ASSERT(m->ptl0);
+    for (i=0; i<a->size; i++)
+        map_page_to_frame(a->address + i*PAGE_SIZE, a->mapping[i], flags, (__address) m->ptl0);
+    spinlock_unlock(&a->lock);
+    spinlock_unlock(&m->lock);
+    cpu_priority_restore(pri);
+}
+void vm_area_unmap(vm_area_t *a, vm_t *m)
+{
+    int i;
+    pri_t pri;
+    pri = cpu_priority_high();
+    spinlock_lock(&m->lock);
+    spinlock_lock(&a->lock);
+    ASSERT(m->ptl0);
+    for (i=0; i<a->size; i++)
+        map_page_to_frame(a->address + i*PAGE_SIZE, 0, PAGE_NOT_PRESENT, (__address) m->ptl0);
+    spinlock_unlock(&a->lock);
+    spinlock_unlock(&m->lock);
+    cpu_priority_restore(pri);
+}
+void vm_install(vm_t *m)
+{
+    link_t *l;
+    pri_t pri;
+    pri = cpu_priority_high();
+    tlb_shootdown_start();
+    spinlock_lock(&m->lock);
+    ASSERT(m->ptl0);
+    SET_PTL0_ADDRESS(m->ptl0);
+    spinlock_unlock(&m->lock);
+    tlb_shootdown_finalize();
+    cpu_priority_restore(pri);
+}

 /SPARTAN/trunk/src/mm/page.c
 ,0 → 1,110
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <mm/page.h>
+#include <mm/frame.h>
+#include <arch/mm/page.h>
+#include <arch/types.h>
+#include <typedefs.h>
+#include <arch/asm.h>
+void page_init(void)
+{
+    page_arch_init();
+    map_page_to_frame(0x0, 0x0, PAGE_NOT_PRESENT, 0);
+}
+/** Map memory structure
+ *
+ * Identity-map memory structure
+ * considering possible crossings
+ * of page boundaries.
+ *
+ * @param s Address of the structure.
+ * @param size Size of the structure.
+ */
+void map_structure(__address s, size_t size)
+{
+    int i, cnt, length;
+    /* TODO: implement portable way of computing page address from address */
+    length = size + (s - (s & 0xfffff000));
+    cnt = length/PAGE_SIZE + (length%PAGE_SIZE>0);
+    for (i = 0; i < cnt; i++)
+        map_page_to_frame(s + i*PAGE_SIZE, s + i*PAGE_SIZE, PAGE_NOT_CACHEABLE, 0);
+}
+/** Map page to frame
+ *
+ * Map virtual address 'page' to physical address 'frame'
+ * using 'flags'. Allocate and setup any missing page tables.
+ *
+ * @param page Virtual address of the page to be mapped.
+ * @param frame Physical address of memory frame to which the mapping is done.
+ * @param flags Flags to be used for mapping.
+ * @param root Explicit PTL0 address.
+ */
+void map_page_to_frame(__address page, __address frame, int flags, __address root)
+{
+    pte_t *ptl0, *ptl1, *ptl2, *ptl3;
+    __address newpt;
+    ptl0 = (pte_t *) PA2KA(root ? root : (__address) GET_PTL0_ADDRESS());
+    if (GET_PTL1_FLAGS(ptl0, PTL0_INDEX(page)) & PAGE_NOT_PRESENT) {
+        newpt = frame_alloc(FRAME_KA);
+        memsetb(newpt, PAGE_SIZE, 0);
+        SET_PTL1_ADDRESS(ptl0, PTL0_INDEX(page), KA2PA(newpt));
+        SET_PTL1_FLAGS(ptl0, PTL0_INDEX(page), PAGE_PRESENT | PAGE_USER);
+    }
+    ptl1 = (pte_t *) PA2KA(GET_PTL1_ADDRESS(ptl0, PTL0_INDEX(page)));
+    if (GET_PTL2_FLAGS(ptl1, PTL1_INDEX(page)) & PAGE_NOT_PRESENT) {
+        newpt = frame_alloc(FRAME_KA);
+        memsetb(newpt, PAGE_SIZE, 0);
+        SET_PTL2_ADDRESS(ptl1, PTL1_INDEX(page), KA2PA(newpt));
+        SET_PTL2_FLAGS(ptl1, PTL1_INDEX(page), PAGE_PRESENT | PAGE_USER);
+    }
+    ptl2 = (pte_t *) PA2KA(GET_PTL2_ADDRESS(ptl1, PTL1_INDEX(page)));
+    if (GET_PTL3_FLAGS(ptl2, PTL2_INDEX(page)) & PAGE_NOT_PRESENT) {
+        newpt = frame_alloc(FRAME_KA);
+        memsetb(newpt, PAGE_SIZE, 0);
+        SET_PTL3_ADDRESS(ptl2, PTL2_INDEX(page), KA2PA(newpt));
+        SET_PTL3_FLAGS(ptl2, PTL2_INDEX(page), PAGE_PRESENT | PAGE_USER);
+    }
+    ptl3 = (pte_t *) PA2KA(GET_PTL3_ADDRESS(ptl2, PTL2_INDEX(page)));
+    SET_FRAME_ADDRESS(ptl3, PTL3_INDEX(page), frame);
+    SET_FRAME_FLAGS(ptl3, PTL3_INDEX(page), flags);
+}

 /SPARTAN/trunk/src/mm/frame.c
 ,0 → 1,199
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch/types.h>
+#include <func.h>
+#include <mm/heap.h>
+#include <mm/frame.h>
+#include <mm/page.h>
+#include <mm/vm.h>
+#include <arch/mm/page.h>
+#include <config.h>
+#include <memstr.h>
+#include <panic.h>
+#include <synch/spinlock.h>
+#include <arch/asm.h>
+count_t frames = 0;
+count_t frames_free;
+__u8 *frame_bitmap;
+count_t frame_bitmap_octets;
+static spinlock_t framelock;
+void frame_init(void)
+{
+    if (config.cpu_active == 1) {
+        /*
+         * The bootstrap processor will allocate all necessary memory for frame allocation.
+         */
+        frames = config.memory_size / FRAME_SIZE;
+        frame_bitmap_octets = frames / 8 + (frames % 8 > 0);
+        frame_bitmap = (__u8 *) malloc(frame_bitmap_octets);
+        if (!frame_bitmap)
+            panic("malloc/frame_bitmap\n");
+        /*
+         * Mark all frames free.
+         */
+        memsetb((__address) frame_bitmap, frame_bitmap_octets, 0);
+        frames_free = frames;
+    }
+    /*
+     * No frame allocations/reservations prior this point.
+     */
+    frame_arch_init();
+    if (config.cpu_active == 1) {
+        /*
+         * Create the memory address space map. Marked frames and frame
+         * regions cannot be used for allocation.
+         */
+        frame_region_not_free(config.base, config.base + config.kernel_size);
+    }
+}
+/*
+ * Allocate a frame.
+ */
+__address frame_alloc(int flags)
+{
+    int i;
+    pri_t pri;
+loop:
+    pri = cpu_priority_high();
+    spinlock_lock(&framelock);
+    if (frames_free) {
+        for (i=0; i < frames; i++) {
+            int m, n;
+            m = i / 8;
+            n = i % 8;
+            if ((frame_bitmap[m] & (1<<n)) == 0) {
+                frame_bitmap[m] |= (1<<n);
+                frames_free--;
+                spinlock_unlock(&framelock);
+                cpu_priority_restore(pri);
+                if (flags & FRAME_KA) return PA2KA(i*FRAME_SIZE);
+                return i*FRAME_SIZE;
+            }
+        }
+        panic("frames_free inconsistent (%d)\n", frames_free);
+    }
+    spinlock_unlock(&framelock);
+    cpu_priority_restore(pri);
+    if (flags & FRAME_PANIC)
+        panic("unable to allocate frame\n");
+    /* TODO: implement sleeping logic here */
+    panic("sleep not supported\n");
+    goto loop;
+}
+/*
+ * Free a frame.
+ */
+void frame_free(__address addr)
+{
+    pri_t pri;
+    __u32 frame;
+    pri = cpu_priority_high();
+    spinlock_lock(&framelock);
+    frame = IS_KA(addr) ? KA2PA(addr) : addr;
+    frame /= FRAME_SIZE;
+    if (frame < frames) {
+        int m, n;
+        m = frame / 8;
+        n = frame % 8;
+        if (frame_bitmap[m] & (1<<n)) {
+            frame_bitmap[m] &= ~(1<<n);
+            frames_free++;
+        }
+        else panic("frame already free\n");
+    }
+    else panic("frame number too big\n");
+    spinlock_unlock(&framelock);
+    cpu_priority_restore(pri);
+}
+/*
+ * Don't use this function for normal allocation. Use frame_alloc() instead.
+ * Use this function to declare that some special frame is not free.
+ */
+void frame_not_free(__address addr)
+{
+    pri_t pri;
+    __u32 frame;
+    pri = cpu_priority_high();
+    spinlock_lock(&framelock);
+    frame = IS_KA(addr) ? KA2PA(addr) : addr;
+    frame /= FRAME_SIZE;
+    if (frame < frames) {
+        int m, n;
+        m = frame / 8;
+        n = frame % 8;
+        if ((frame_bitmap[m] & (1<<n)) == 0) {
+            frame_bitmap[m] |= (1<<n);
+            frames_free--;
+        }
+    }
+    spinlock_unlock(&framelock);
+    cpu_priority_restore(pri);
+}
+void frame_region_not_free(__address start, __address stop)
+{
+    __u32 i;
+    start /= FRAME_SIZE;
+    stop /= FRAME_SIZE;
+    for (i = start; i <= stop; i++)
+        frame_not_free(i * FRAME_SIZE);
+}

 /SPARTAN/trunk/src/mm/heap.c
 ,0 → 1,153
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <mm/heap.h>
+#include <synch/spinlock.h>
+#include <func.h>
+#include <memstr.h>
+#include <panic.h>
+#include <arch/types.h>
+#include <arch/asm.h>
+/*
+ * First-fit algorithm.
+ * Simple, but hopefully correct.
+ * Chunks being freed are tested for mergability with their neighbours.
+ */
+static chunk_t *chunk0;
+static spinlock_t heaplock;
+void heap_init(__address heap, size_t size)
+{
+    spinlock_initialize(&heaplock);
+    memsetb(heap, size, 0);
+    chunk0 = (chunk_t *) heap;
+    chunk0->used = 0;
+    chunk0->size = size - sizeof(chunk_t);
+    chunk0->next = NULL;
+    chunk0->prev = NULL;
+}
+/*
+ * Uses first-fit algorithm.
+ */
+void *malloc(size_t size)
+{
+    pri_t pri;
+    chunk_t *x, *y, *z;
+    if (size == 0)
+        panic("zero-size allocation request");
+    x = chunk0;
+    pri = cpu_priority_high();
+    spinlock_lock(&heaplock);
+    while (x) {
+        if (x->used || x->size < size) {
+            x = x->next;
+            continue;
+        }
+        x->used = 1;
+        /*
+         * If the chunk exactly matches required size or if truncating
+         * it would not provide enough space for storing a new chunk
+         * header plus at least one byte of data, we are finished.
+         */
+        if (x->size < size + sizeof(chunk_t) + 1) {
+            spinlock_unlock(&heaplock);
+            cpu_priority_restore(pri);
+            return &x->data[0];
+        }
+        /*
+         * Truncate x and create a new chunk.
+         */
+        y = (chunk_t *) (((__address) x) + size + sizeof(chunk_t));
+        y->used = 0;
+        y->size = x->size - size - sizeof(chunk_t);
+        y->prev = x;
+        y->next = NULL;
+        if (z = x->next) {
+            z->prev = y;
+            y->next = z;
+        }
+        x->size = size;
+        x->next = y;
+        spinlock_unlock(&heaplock);
+        cpu_priority_restore(pri);
+        return &x->data[0];
+    }
+    spinlock_unlock(&heaplock);
+    cpu_priority_restore(pri);
+    return NULL;
+}
+void free(void *ptr)
+{
+    pri_t pri;
+    chunk_t *x, *y, *z;
+    if (!ptr)
+        panic("free on NULL");
+    y = (chunk_t *) (((__u8 *) ptr) - sizeof(chunk_t));
+    if (y->used != 1)
+        panic("freeing unused/damaged chunk");
+    pri = cpu_priority_high();
+    spinlock_lock(&heaplock);
+    x = y->prev;
+    z = y->next;
+    /* merge x and y */
+    if (x && !x->used) {
+        x->size += y->size + sizeof(chunk_t);
+        x->next = z;
+        if (z)
+            z->prev = x;
+        y = x;
+    }
+    /* merge y and z or merge (x merged with y) and z */
+    if (z && !z->used) {
+        y->size += z->size + sizeof(chunk_t);
+        y->next = z->next;
+        if (z->next)  {
+            /* y is either y or x */
+            z->next->prev = y;
+        }
+    }
+    y->used = 0;
+    spinlock_unlock(&heaplock);
+    cpu_priority_restore(pri);
+}

 /SPARTAN/trunk/src/mm/tlb.c
 ,0 → 1,81
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <mm/tlb.h>
+#include <smp/ipi.h>
+#include <synch/spinlock.h>
+#include <typedefs.h>
+#include <arch/atomic.h>
+#include <arch/interrupt.h>
+#include <config.h>
+#include <arch.h>
+#ifdef __SMP__
+static spinlock_t tlblock;
+void tlb_init(void)
+{
+    spinlock_initialize(&tlblock);
+}
+/* must be called with interrupts disabled */
+void tlb_shootdown_start(void)
+{
+    int i;
+    CPU->tlb_active = 0;
+    spinlock_lock(&tlblock);
+    tlb_shootdown_ipi_send();
+    tlb_invalidate(0); /* TODO: use valid ASID */
+busy_wait:
+    for (i = 0; i<config.cpu_count; i++)
+        if (cpus[i].tlb_active)
+            goto busy_wait;
+}
+void tlb_shootdown_finalize(void)
+{
+    spinlock_unlock(&tlblock);
+    CPU->tlb_active = 1;
+}
+void tlb_shootdown_ipi_send(void)
+{
+    ipi_broadcast(VECTOR_TLB_SHOOTDOWN_IPI);
+}
+void tlb_shootdown_ipi_recv(void)
+{
+    CPU->tlb_active = 0;
+    spinlock_lock(&tlblock);
+    spinlock_unlock(&tlblock);
+    tlb_invalidate(0);  /* TODO: use valid ASID */
+    CPU->tlb_active = 1;
+}
+#endif /* __SMP__ */

 /SPARTAN/trunk/src/main/kinit.c
 ,0 → 1,156
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <config.h>
+#include <arch.h>
+#include <main/kinit.h>
+#include <main/uinit.h>
+#include <proc/scheduler.h>
+#include <proc/task.h>
+#include <proc/thread.h>
+#include <panic.h>
+#include <func.h>
+#include <cpu.h>
+#include <arch/asm.h>
+#include <mm/page.h>
+#include <arch/mm/page.h>
+#include <mm/vm.h>
+#ifdef __SMP__
+#include <arch/smp/mps.h>
+#endif /* __SMP__ */
+#include <synch/waitq.h>
+#include <synch/spinlock.h>
+#ifdef __TEST__
+#include <test.h>
+#endif /* __TEST__ */
+void kinit(void *arg)
+{
+    vm_t *m;
+    vm_area_t *a;
+    task_t *u;
+    thread_t *t;
+    int i;
+    cpu_priority_high();
+#ifdef __SMP__
+    if (config.cpu_count > 1) {
+        /*
+         * Create the kmp thread and wait for its completion.
+         * cpu1 through cpuN-1 will come up consecutively and
+         * not mess together with kcpulb and klwtm threads.
+         * Just a beautification.
+         */
+        if (t = thread_create(kmp, NULL, TASK, 0)) {
+            spinlock_lock(&t->lock);
+            t->flags |= X_WIRED;
+            t->cpu = &cpus[0];
+            spinlock_unlock(&t->lock);
+            thread_ready(t);
+            waitq_sleep(&kmp_completion_wq);
+            cpu_priority_high();
+        }
+        else panic("thread_create/kmp");
+    }
+#endif /* __SMP__ */
+    /*
+     * Now that all CPUs are up, we can report what we've found.
+     */
+    for (i = 0; i < config.cpu_count; i++) {
+        if (cpus[i].active)
+            cpu_print_report(&cpus[i]);
+        else
+            printf("cpu%d: not active\n", i);
+    }
+#ifdef __SMP__
+    if (config.cpu_count > 1) {
+        /*
+         * For each CPU, create its load balancing thread.
+         */
+        for (i = 0; i < config.cpu_count; i++) {
+            if (t = thread_create(kcpulb, NULL, TASK, 0)) {
+                spinlock_lock(&t->lock);
+                t->flags |= X_WIRED;
+                t->cpu = &cpus[i];
+                spinlock_unlock(&t->lock);
+                thread_ready(t);
+            }
+            else panic("thread_create/kcpulb");
+        }
+    }
+#endif /* __SMP__ */
+    cpu_priority_low();
+#ifdef __USERSPACE__
+    /*
+     * Create the first user task.
+     */
+    m = vm_create(NULL);
+    if (!m) panic("vm_create");
+    u = task_create(m);
+    if (!u) panic("task_create");
+    t = thread_create(uinit, NULL, u, THREAD_USER_STACK);
+    if (!t) panic("thread_create");
+    /*
+     * Create the text vm_area and copy the userspace code there.
+     */
+    a = vm_area_create(m, VMA_TEXT, 1, UTEXT_ADDRESS);
+    if (!a) panic("vm_area_create: vm_text");
+    vm_area_map(a, m);
+    memcopy((__address) utext, PA2KA(a->mapping[0]), utext_size < PAGE_SIZE ? utext_size : PAGE_SIZE);
+    /*
+     * Create the data vm_area.
+     */
+    a = vm_area_create(m, VMA_STACK, 1, USTACK_ADDRESS);
+    if (!a) panic("vm_area_create: vm_stack");
+    vm_area_map(a, m);
+    thread_ready(t);
+#endif /* __USERSPACE__ */
+#ifdef __TEST__
+    test();
+#endif /* __TEST__ */
+    while (1) {
+        thread_usleep(1000000);
+        printf("kinit... ");
+    }
+}

 /SPARTAN/trunk/src/main/main.c
 ,0 → 1,236
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch/asm.h>
+#include <context.h>
+#include <print.h>
+#include <panic.h>
+#include <config.h>
+#include <time/clock.h>
+#include <proc/scheduler.h>
+#include <proc/thread.h>
+#include <proc/task.h>
+#include <mm/vm.h>
+#include <main/kinit.h>
+#include <cpu.h>
+#include <mm/heap.h>
+#ifdef __SMP__
+#include <arch/smp/apic.h>
+#include <arch/smp/mps.h>
+#endif /* __SMP__ */
+#include <smp/smp.h>
+#include <arch/mm/memory_init.h>
+#include <mm/frame.h>
+#include <mm/page.h>
+#include <mm/tlb.h>
+#include <synch/waitq.h>
+#include <arch.h>
+#include <arch/faddr.h>
+#include <typedefs.h>
+char *project = "SPARTAN kernel";
+char *copyright = "Copyright (C) 2001-2005 Jakub Jermar\nCopyright (C) 2005 HelenOS project";
+config_t config;
+context_t ctx;
+/*
+ * These 'hardcoded' variables will be intialised by
+ * the linker or the low level assembler code with
+ * appropriate sizes and addresses.
+ */
+__address hardcoded_load_address = 0;
+size_t hardcoded_ktext_size = 0;
+size_t hardcoded_kdata_size = 0;
+void main_bsp(void);
+void main_ap(void);
+/*
+ * These two functions prevent stack from underflowing during the
+ * kernel boot phase when SP is set to the very top of the reserved
+ * space. The stack could get corrupted by a fooled compiler-generated
+ * pop sequence otherwise.
+ */
+static void main_bsp_separated_stack(void);
+static void main_ap_separated_stack(void);
+/** Bootstrap CPU main kernel routine
+ *
+ * Initializes the kernel by bootstrap CPU.
+ *
+ * Assuming cpu_priority_high().
+ *
+ */
+void main_bsp(void)
+{
+    config.cpu_count = 1;
+    config.cpu_active = 1;
+    config.base = hardcoded_load_address;
+    config.memory_size = get_memory_size();
+    config.kernel_size = hardcoded_ktext_size + hardcoded_kdata_size + CONFIG_HEAP_SIZE + CONFIG_STACK_SIZE;
+    context_save(&ctx);
+    context_set(&ctx, FADDR(main_bsp_separated_stack), config.base + hardcoded_ktext_size + hardcoded_kdata_size + CONFIG_HEAP_SIZE, CONFIG_STACK_SIZE);
+    context_restore(&ctx);
+    /* not reached */
+}
+/** Bootstrap CPU main kernel routine stack wrapper
+ *
+ * Second part of main_bsp().
+ *
+ */
+void main_bsp_separated_stack(void) {
+    vm_t *m;
+    task_t *k;
+    thread_t *t;
+    arch_pre_mm_init();
+    heap_init(config.base + hardcoded_ktext_size + hardcoded_kdata_size, CONFIG_HEAP_SIZE);
+    frame_init();
+    page_init();
+    tlb_init();
+    arch_post_mm_init();
+    printf("%s\n%s\n", project, copyright);
+    printf("%P: hardcoded_ktext_size=%dK, hardcoded_kdata_size=%dK\n",
+        config.base, hardcoded_ktext_size/1024, hardcoded_kdata_size/1024);
+    arch_late_init();
+    smp_init();
+    printf("config.memory_size=%dM\n", config.memory_size/(1024*1024));
+    printf("config.cpu_count=%d\n", config.cpu_count);
+    cpu_init();
+    calibrate_delay_loop();
+    timeout_init();
+    scheduler_init();
+    task_init();
+    thread_init();
+    /*
+     * Create kernel vm mapping.
+     */
+    m = vm_create(GET_PTL0_ADDRESS());
+    if (!m) panic("can't create kernel vm address space\n");
+    /*
+     * Create kernel task.
+     */
+    k = task_create(m);
+    if (!k) panic("can't create kernel task\n");
+    /*
+     * Create the first thread.
+     */
+    t = thread_create(kinit, NULL, k, 0);
+    if (!t) panic("can't create kinit thread\n");
+    thread_ready(t);
+    /*
+     * This call to scheduler() will return to kinit,
+     * starting the thread of kernel threads.
+     */
+    scheduler();
+    /* not reached */
+}
+#ifdef __SMP__
+/** Application CPUs main kernel routine
+ *
+ * Executed by application processors, temporary stack
+ * is at ctx.sp which was set during BP boot.
+ *
+ * Assuming  cpu_priority_high().
+ *
+ */
+void main_ap(void)
+{
+    /*
+     * Incrementing the active CPU counter will guarantee that the
+     * pm_init() will not attempt to build GDT and IDT tables again.
+     * Neither frame_init() will do the complete thing. Neither cpu_init()
+     * will do.
+     */
+    config.cpu_active++;
+    arch_pre_mm_init();
+    frame_init();
+    page_init();
+    arch_post_mm_init();
+    cpu_init();
+    calibrate_delay_loop();
+    l_apic_init();
+    l_apic_debug();
+    /*
+     * If we woke kmp up before we left the kernel stack, we could
+     * collide with another CPU coming up. To prevent this, we
+     * switch to this cpu's private stack prior to waking kmp up.
+     */
+    context_set(&CPU->saved_context, FADDR(main_ap_separated_stack), CPU->stack, CPU_STACK_SIZE);
+    context_restore(&CPU->saved_context);
+    /* not reached */
+}
+/** Application CPUs main kernel routine stack wrapper
+ *
+ * Second part of main_ap().
+ *
+ */
+void main_ap_separated_stack(void)
+{
+    /*
+     * Configure timeouts for this cpu.
+     */
+    timeout_init();
+    waitq_wakeup(&ap_completion_wq, WAKEUP_FIRST);
+    scheduler();
+    /* not reached */
+}
+#endif /* __SMP__*/

 /SPARTAN/trunk/src/main/uinit.c
 ,0 → 1,38
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <main/uinit.h>
+#include <arch/types.h>
+#include <proc/thread.h>
+#include <userspace.h>
+void uinit(void *arg)
+{
+    printf("USER task, uinit thread: kernel mode\n");
+    userspace();
+}

 /SPARTAN/trunk/src/proc/scheduler.c
 ,0 → 1,560
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <proc/scheduler.h>
+#include <proc/thread.h>
+#include <proc/task.h>
+#include <cpu.h>
+#include <mm/vm.h>
+#include <config.h>
+#include <context.h>
+#include <func.h>
+#include <arch.h>
+#include <arch/asm.h>
+#include <list.h>
+#include <panic.h>
+#include <typedefs.h>
+#include <mm/page.h>
+#include <synch/spinlock.h>
+#include <arch/faddr.h>
+#include <arch/atomic.h>
+volatile int nrdy;
+/** Take actions before new thread runs
+ *
+ * Perform actions that need to be
+ * taken before the newly selected
+ * tread is passed control.
+ *
+ */
+void before_thread_runs(void)
+{
+    before_thread_runs_arch();
+    fpu_context_restore(&(THREAD->saved_fpu_context));
+}
+/** Initialize scheduler
+ *
+ * Initialize kernel scheduler.
+ *
+ */
+void scheduler_init(void)
+{
+}
+/** Get thread to be scheduled
+ *
+ * Get the optimal thread to be scheduled
+ * according to thread accounting and scheduler
+ * policy.
+ *
+ * @return Thread to be scheduled.
+ *
+ */
+struct thread *find_best_thread(void)
+{
+    thread_t *t;
+    runq_t *r;
+    int i, n;
+loop:
+    cpu_priority_high();
+    spinlock_lock(&CPU->lock);
+    n = CPU->nrdy;
+    spinlock_unlock(&CPU->lock);
+    cpu_priority_low();
+    if (n == 0) {
+        #ifdef __SMP__
+        /*
+         * If the load balancing thread is not running, wake it up and
+         * set CPU-private flag that the kcpulb has been started.
+         */
+        if (test_and_set(&CPU->kcpulbstarted) == 0) {
+            waitq_wakeup(&CPU->kcpulb_wq, 0);
+            goto loop;
+        }
+        #endif /* __SMP__ */
+        /*
+         * For there was nothing to run, the CPU goes to sleep
+         * until a hardware interrupt or an IPI comes.
+         * This improves energy saving and hyperthreading.
+         * On the other hand, several hardware interrupts can be ignored.
+         */
+         cpu_sleep();
+         goto loop;
+    }
+    cpu_priority_high();
+    i = 0;
+retry:
+    for (; i<RQ_COUNT; i++) {
+        r = &CPU->rq[i];
+        spinlock_lock(&r->lock);
+        if (r->n == 0) {
+            /*
+             * If this queue is empty, try a lower-priority queue.
+             */
+            spinlock_unlock(&r->lock);
+            continue;
+        }
+        /* avoid deadlock with relink_rq() */
+        if (!spinlock_trylock(&CPU->lock)) {
+            /*
+             * Unlock r and try again.
+             */
+            spinlock_unlock(&r->lock);
+            goto retry;
+        }
+        CPU->nrdy--;
+        spinlock_unlock(&CPU->lock);
+        atomic_dec(&nrdy);
+        r->n--;
+        /*
+         * Take the first thread from the queue.
+         */
+        t = list_get_instance(r->rq_head.next, thread_t, rq_link);
+        list_remove(&t->rq_link);
+        spinlock_unlock(&r->lock);
+        spinlock_lock(&t->lock);
+        t->cpu = CPU;
+        t->ticks = us2ticks((i+1)*10000);
+        t->pri = i; /* eventually correct rq index */
+        /*
+         * Clear the X_STOLEN flag so that t can be migrated when load balancing needs emerge.
+         */
+        t->flags &= ~X_STOLEN;
+        spinlock_unlock(&t->lock);
+        return t;
+    }
+    goto loop;
+}
+/** Prevent rq starvation
+ *
+ * Prevent low priority threads from starving in rq's.
+ *
+ * When the function decides to relink rq's, it reconnects
+ * respective pointers so that in result threads with 'pri'
+ * greater or equal 'start' are moved to a higher-priority queue.
+ *
+ * @param start Threshold priority.
+ *
+ */
+void relink_rq(int start)
+{
+    link_t head;
+    runq_t *r;
+    int i, n;
+    list_initialize(&head);
+    spinlock_lock(&CPU->lock);
+    if (CPU->needs_relink > NEEDS_RELINK_MAX) {
+        for (i = start; i<RQ_COUNT-1; i++) {
+            /* remember and empty rq[i + 1] */
+            r = &CPU->rq[i + 1];
+            spinlock_lock(&r->lock);
+            list_concat(&head, &r->rq_head);
+            n = r->n;
+            r->n = 0;
+            spinlock_unlock(&r->lock);
+            /* append rq[i + 1] to rq[i] */
+            r = &CPU->rq[i];
+            spinlock_lock(&r->lock);
+            list_concat(&r->rq_head, &head);
+            r->n += n;
+            spinlock_unlock(&r->lock);
+        }
+        CPU->needs_relink = 0;
+    }
+    spinlock_unlock(&CPU->lock);
+}
+/** The scheduler
+ *
+ * The thread scheduling procedure.
+ *
+ */
+void scheduler(void)
+{
+    volatile pri_t pri;
+    pri = cpu_priority_high();
+    if (haltstate)
+        halt();
+    if (THREAD) {
+        spinlock_lock(&THREAD->lock);
+        fpu_context_save(&(THREAD->saved_fpu_context));
+        if (!context_save(&THREAD->saved_context)) {
+            /*
+             * This is the place where threads leave scheduler();
+             */
+            before_thread_runs();
+            spinlock_unlock(&THREAD->lock);
+            cpu_priority_restore(THREAD->saved_context.pri);
+            return;
+        }
+        THREAD->saved_context.pri = pri;
+    }
+    /*
+     * We may not keep the old stack.
+     * Reason: If we kept the old stack and got blocked, for instance, in
+     * find_best_thread(), the old thread could get rescheduled by another
+     * CPU and overwrite the part of its own stack that was also used by
+     * the scheduler on this CPU.
+     *
+     * Moreover, we have to bypass the compiler-generated POP sequence
+     * which is fooled by SP being set to the very top of the stack.
+     * Therefore the scheduler() function continues in
+     * scheduler_separated_stack().
+     */
+    context_save(&CPU->saved_context);
+    context_set(&CPU->saved_context, FADDR(scheduler_separated_stack), CPU->stack, CPU_STACK_SIZE);
+    context_restore(&CPU->saved_context);
+    /* not reached */
+}
+/** Scheduler stack switch wrapper
+ *
+ * Second part of the scheduler() function
+ * using new stack. Handling the actual context
+ * switch to a new thread.
+ *
+ */
+void scheduler_separated_stack(void)
+{
+    int priority;
+    if (THREAD) {
+        switch (THREAD->state) {
+            case Running:
+            THREAD->state = Ready;
+            spinlock_unlock(&THREAD->lock);
+            thread_ready(THREAD);
+            break;
+            case Exiting:
+            frame_free((__address) THREAD->kstack);
+            if (THREAD->ustack) {
+                frame_free((__address) THREAD->ustack);
+            }
+            /*
+             * Detach from the containing task.
+             */
+            spinlock_lock(&TASK->lock);
+            list_remove(&THREAD->th_link);
+            spinlock_unlock(&TASK->lock);
+            spinlock_unlock(&THREAD->lock);
+            spinlock_lock(&threads_lock);
+            list_remove(&THREAD->threads_link);
+            spinlock_unlock(&threads_lock);
+            spinlock_lock(&CPU->lock);
+            if(CPU->fpu_owner==THREAD) CPU->fpu_owner=NULL;
+            spinlock_unlock(&CPU->lock);
+            free(THREAD);
+            break;
+            case Sleeping:
+            /*
+             * Prefer the thread after it's woken up.
+             */
+            THREAD->pri = -1;
+            /*
+             * We need to release wq->lock which we locked in waitq_sleep().
+             * Address of wq->lock is kept in THREAD->sleep_queue.
+             */
+            spinlock_unlock(&THREAD->sleep_queue->lock);
+            /*
+             * Check for possible requests for out-of-context invocation.
+             */
+            if (THREAD->call_me) {
+                THREAD->call_me(THREAD->call_me_with);
+                THREAD->call_me = NULL;
+                THREAD->call_me_with = NULL;
+            }
+            spinlock_unlock(&THREAD->lock);
+            break;
+            default:
+            /*
+             * Entering state is unexpected.
+             */
+            panic("tid%d: unexpected state %s\n", THREAD->tid, thread_states[THREAD->state]);
+            break;
+        }
+        THREAD = NULL;
+    }
+    THREAD = find_best_thread();
+    spinlock_lock(&THREAD->lock);
+    priority = THREAD->pri;
+    spinlock_unlock(&THREAD->lock);
+    relink_rq(priority);
+    spinlock_lock(&THREAD->lock);
+    /*
+     * If both the old and the new task are the same, lots of work is avoided.
+     */
+    if (TASK != THREAD->task) {
+        vm_t *m1 = NULL;
+        vm_t *m2;
+        if (TASK) {
+            spinlock_lock(&TASK->lock);
+            m1 = TASK->vm;
+            spinlock_unlock(&TASK->lock);
+        }
+        spinlock_lock(&THREAD->task->lock);
+        m2 = THREAD->task->vm;
+        spinlock_unlock(&THREAD->task->lock);
+        /*
+         * Note that it is possible for two tasks to share one vm mapping.
+         */
+        if (m1 != m2) {
+            /*
+             * Both tasks and vm mappings are different.
+             * Replace the old one with the new one.
+             */
+            vm_install(m2);
+        }
+        TASK = THREAD->task;
+    }
+    THREAD->state = Running;
+    #ifdef SCHEDULER_VERBOSE
+    printf("cpu%d: tid %d (pri=%d,ticks=%d,nrdy=%d)\n", CPU->id, THREAD->tid, THREAD->pri, THREAD->ticks, CPU->nrdy);
+    #endif
+    context_restore(&THREAD->saved_context);
+    /* not reached */
+}
+#ifdef __SMP__
+/** Load balancing thread
+ *
+ * SMP load balancing thread, supervising thread supplies
+ * for the CPU it's wired to.
+ *
+ * @param arg Generic thread argument (unused).
+ *
+ */
+void kcpulb(void *arg)
+{
+    thread_t *t;
+    int count, i, j, k = 0;
+    pri_t pri;
+loop:
+    /*
+     * Sleep until there's some work to do.
+     */
+    waitq_sleep(&CPU->kcpulb_wq);
+not_satisfied:
+    /*
+     * Calculate the number of threads that will be migrated/stolen from
+     * other CPU's. Note that situation can have changed between two
+     * passes. Each time get the most up to date counts.
+     */
+    pri = cpu_priority_high();
+    spinlock_lock(&CPU->lock);
+    count = nrdy / config.cpu_active;
+    count -= CPU->nrdy;
+    spinlock_unlock(&CPU->lock);
+    cpu_priority_restore(pri);
+    if (count <= 0)
+        goto satisfied;
+    /*
+     * Searching least priority queues on all CPU's first and most priority queues on all CPU's last.
+     */
+    for (j=RQ_COUNT-1; j >= 0; j--) {
+        for (i=0; i < config.cpu_active; i++) {
+            link_t *l;
+            runq_t *r;
+            cpu_t *cpu;
+            cpu = &cpus[(i + k) % config.cpu_active];
+            /*
+             * Not interested in ourselves.
+             * Doesn't require interrupt disabling for kcpulb is X_WIRED.
+             */
+            if (CPU == cpu)
+                continue;
+restart:        pri = cpu_priority_high();
+            r = &cpu->rq[j];
+            spinlock_lock(&r->lock);
+            if (r->n == 0) {
+                spinlock_unlock(&r->lock);
+                cpu_priority_restore(pri);
+                continue;
+            }
+            t = NULL;
+            l = r->rq_head.prev;    /* search rq from the back */
+            while (l != &r->rq_head) {
+                t = list_get_instance(l, thread_t, rq_link);
+                /*
+                 * We don't want to steal CPU-wired threads neither threads already stolen.
+                 * The latter prevents threads from migrating between CPU's without ever being run.
+                 * We don't want to steal threads whose FPU context is still in CPU.
+                 */
+                spinlock_lock(&t->lock);
+                if ( (!(t->flags & (X_WIRED | X_STOLEN))) && (!(t->fpu_context_engaged)) ) {
+                    /*
+                     * Remove t from r.
+                     */
+                    spinlock_unlock(&t->lock);
+                    /*
+                     * Here we have to avoid deadlock with relink_rq(),
+                     * because it locks cpu and r in a different order than we do.
+                     */
+                    if (!spinlock_trylock(&cpu->lock)) {
+                        /* Release all locks and try again. */
+                        spinlock_unlock(&r->lock);
+                        cpu_priority_restore(pri);
+                        goto restart;
+                    }
+                    cpu->nrdy--;
+                    spinlock_unlock(&cpu->lock);
+                    atomic_dec(&nrdy);
+                    r->n--;
+                    list_remove(&t->rq_link);
+                    break;
+                }
+                spinlock_unlock(&t->lock);
+                l = l->prev;
+                t = NULL;
+            }
+            spinlock_unlock(&r->lock);
+            if (t) {
+                /*
+                 * Ready t on local CPU
+                 */
+                spinlock_lock(&t->lock);
+                #ifdef KCPULB_VERBOSE
+                printf("kcpulb%d: TID %d -> cpu%d, nrdy=%d, avg=%d\n", CPU->id, t->tid, CPU->id, CPU->nrdy, nrdy / config.cpu_active);
+                #endif
+                t->flags |= X_STOLEN;
+                spinlock_unlock(&t->lock);
+                thread_ready(t);
+                cpu_priority_restore(pri);
+                if (--count == 0)
+                    goto satisfied;
+                /*
+                 * We are not satisfied yet, focus on another CPU next time.
+                 */
+                k++;
+                continue;
+            }
+            cpu_priority_restore(pri);
+        }
+    }
+    if (CPU->nrdy) {
+        /*
+         * Be a little bit light-weight and let migrated threads run.
+         */
+        scheduler();
+    }
+    else {
+        /*
+         * We failed to migrate a single thread.
+         * Something more sophisticated should be done.
+         */
+        scheduler();
+    }
+    goto not_satisfied;
+satisfied:
+    /*
+     * Tell find_best_thread() to wake us up later again.
+     */
+    CPU->kcpulbstarted = 0;
+    goto loop;
+}
+#endif /* __SMP__ */

 /SPARTAN/trunk/src/proc/thread.c
 ,0 → 1,320
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <proc/scheduler.h>
+#include <proc/thread.h>
+#include <proc/task.h>
+#include <mm/heap.h>
+#include <mm/frame.h>
+#include <mm/page.h>
+#include <arch/asm.h>
+#include <arch.h>
+#include <synch/synch.h>
+#include <synch/spinlock.h>
+#include <synch/waitq.h>
+#include <synch/rwlock.h>
+#include <cpu.h>
+#include <func.h>
+#include <context.h>
+#include <list.h>
+#include <typedefs.h>
+#include <time/clock.h>
+#include <list.h>
+#include <config.h>
+#include <arch/interrupt.h>
+#include <smp/ipi.h>
+#include <arch/faddr.h>
+#include <arch/atomic.h>
+char *thread_states[] = {"Invalid", "Running", "Sleeping", "Ready", "Entering", "Exiting"}; /**< Thread states */
+spinlock_t threads_lock;
+link_t threads_head;
+static spinlock_t tidlock;
+__u32 last_tid = 0;
+/** Thread wrapper
+ *
+ * This wrapper is provided to ensure that every thread
+ * makes a call to thread_exit() when its implementing
+ * function returns.
+ *
+ * cpu_priority_high() is assumed.
+ *
+ */
+void cushion(void)
+{
+    void (*f)(void *) = THREAD->thread_code;
+    void *arg = THREAD->thread_arg;
+    before_thread_runs();
+    /* this is where each thread wakes up after its creation */
+    spinlock_unlock(&THREAD->lock);
+    cpu_priority_low();
+    f(arg);
+    thread_exit();
+    /* not reached */
+}
+/** Initialize threads
+ *
+ * Initialize kernel threads support.
+ *
+ */
+void thread_init(void)
+{
+    THREAD = NULL;
+    nrdy = 0;
+    spinlock_initialize(&threads_lock);
+    list_initialize(&threads_head);
+}
+/** Make thread ready
+ *
+ * Switch thread t to the ready state.
+ *
+ * @param t Thread to make ready.
+ *
+ */
+void thread_ready(thread_t *t)
+{
+    cpu_t *cpu;
+    runq_t *r;
+    pri_t pri;
+    int i, avg, send_ipi = 0;
+    pri = cpu_priority_high();
+    spinlock_lock(&t->lock);
+    i = (t->pri < RQ_COUNT -1) ? ++t->pri : t->pri;
+    cpu = CPU;
+    if (t->flags & X_WIRED) {
+        cpu = t->cpu;
+    }
+    spinlock_unlock(&t->lock);
+    /*
+     * Append t to respective ready queue on respective processor.
+     */
+    r = &cpu->rq[i];
+    spinlock_lock(&r->lock);
+    list_append(&t->rq_link, &r->rq_head);
+    r->n++;
+    spinlock_unlock(&r->lock);
+    atomic_inc(&nrdy);
+    avg = nrdy / config.cpu_active;
+    spinlock_lock(&cpu->lock);
+    if ((++cpu->nrdy) > avg) {
+        /*
+         * If there are idle halted CPU's, this will wake them up.
+         */
+        ipi_broadcast(VECTOR_WAKEUP_IPI);
+    }
+    spinlock_unlock(&cpu->lock);
+    cpu_priority_restore(pri);
+}
+/** Create new thread
+ *
+ * Create a new thread.
+ *
+ * @param func  Thread's implementing function.
+ * @param arg   Thread's implementing function argument.
+ * @param task  Task to which the thread belongs.
+ * @param flags Thread flags.
+ *
+ * @return New thread's structure on success, NULL on failure.
+ *
+ */
+thread_t *thread_create(void (* func)(void *), void *arg, task_t *task, int flags)
+{
+    thread_t *t;
+    __address frame_ks, frame_us = NULL;
+    t = (thread_t *) malloc(sizeof(thread_t));
+    if (t) {
+        pri_t pri;
+        spinlock_initialize(&t->lock);
+        frame_ks = frame_alloc(FRAME_KA);
+        if (THREAD_USER_STACK & flags) {
+            frame_us = frame_alloc(FRAME_KA);
+        }
+        pri = cpu_priority_high();
+        spinlock_lock(&tidlock);
+        t->tid = ++last_tid;
+        spinlock_unlock(&tidlock);
+        cpu_priority_restore(pri);
+        memsetb(frame_ks, THREAD_STACK_SIZE, 0);
+        link_initialize(&t->rq_link);
+        link_initialize(&t->wq_link);
+        link_initialize(&t->th_link);
+        link_initialize(&t->threads_link);
+        t->kstack = (__u8 *) frame_ks;
+        t->ustack = (__u8 *) frame_us;
+        context_save(&t->saved_context);
+        context_set(&t->saved_context, FADDR(cushion), t->kstack, THREAD_STACK_SIZE);
+        pri = cpu_priority_high();
+        t->saved_context.pri = cpu_priority_read();
+        cpu_priority_restore(pri);
+        t->thread_code = func;
+        t->thread_arg = arg;
+        t->ticks = -1;
+        t->pri = -1;        /* start in rq[0] */
+        t->cpu = NULL;
+        t->flags = 0;
+        t->state = Entering;
+        t->call_me = NULL;
+        t->call_me_with = NULL;
+        timeout_initialize(&t->sleep_timeout);
+        t->sleep_queue = NULL;
+        t->timeout_pending = 0;
+        t->rwlock_holder_type = RWLOCK_NONE;
+        t->task = task;
+        t->fpu_context_exists=0;
+        t->fpu_context_engaged=0;
+        /*
+         * Register this thread in the system-wide list.
+         */
+        pri = cpu_priority_high();
+        spinlock_lock(&threads_lock);
+        list_append(&t->threads_link, &threads_head);
+        spinlock_unlock(&threads_lock);
+        /*
+         * Attach to the containing task.
+         */
+        spinlock_lock(&task->lock);
+        list_append(&t->th_link, &task->th_head);
+        spinlock_unlock(&task->lock);
+        cpu_priority_restore(pri);
+    }
+    return t;
+}
+/** Make thread exiting
+ *
+ * End current thread execution and switch it to the exiting
+ * state. All pending timeouts are executed.
+ *
+ */
+void thread_exit(void)
+{
+    pri_t pri;
+restart:
+    pri = cpu_priority_high();
+    spinlock_lock(&THREAD->lock);
+    if (THREAD->timeout_pending) { /* busy waiting for timeouts in progress */
+        spinlock_unlock(&THREAD->lock);
+        cpu_priority_restore(pri);
+        goto restart;
+    }
+    THREAD->state = Exiting;
+    spinlock_unlock(&THREAD->lock);
+    scheduler();
+}
+/** Thread sleep
+ *
+ * Suspend execution of the current thread.
+ *
+ * @param sec Number of seconds to sleep.
+ *
+ */
+void thread_sleep(__u32 sec)
+{
+    thread_usleep(sec*1000000);
+}
+/** Thread usleep
+ *
+ * Suspend execution of the current thread.
+ *
+ * @param usec Number of microseconds to sleep.
+ *
+ */
+void thread_usleep(__u32 usec)
+{
+    waitq_t wq;
+    waitq_initialize(&wq);
+    (void) waitq_sleep_timeout(&wq, usec, SYNCH_NON_BLOCKING);
+}
+/** Register thread out-of-context invocation
+ *
+ * Register a function and its argument to be executed
+ * on next context switch to the current thread.
+ *
+ * @param call_me      Out-of-context function.
+ * @param call_me_with Out-of-context function argument.
+ *
+ */
+void thread_register_call_me(void (* call_me)(void *), void *call_me_with)
+{
+    pri_t pri;
+    pri = cpu_priority_high();
+    spinlock_lock(&THREAD->lock);
+    THREAD->call_me = call_me;
+    THREAD->call_me_with = call_me_with;
+    spinlock_unlock(&THREAD->lock);
+    cpu_priority_restore(pri);
+}

 /SPARTAN/trunk/src/proc/task.c
 ,0 → 1,85
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <proc/thread.h>
+#include <proc/task.h>
+#include <mm/vm.h>
+#include <mm/heap.h>
+#include <synch/spinlock.h>
+#include <arch.h>
+#include <panic.h>
+#include <list.h>
+spinlock_t tasks_lock;
+link_t tasks_head;
+/** Initialize tasks
+ *
+ * Initialize kernel tasks support.
+ *
+ */
+void task_init(void)
+{
+    TASK = NULL;
+    spinlock_initialize(&tasks_lock);
+    list_initialize(&tasks_head);
+}
+/** Create new task
+ *
+ * Create new task with no threads.
+ *
+ * @param m Task's virtual memory structure.
+ *
+ * @return New task's structure on success, NULL on failure.
+ *
+ */
+task_t *task_create(vm_t *m)
+{
+    pri_t pri;
+    task_t *ta;
+    ta = (task_t *) malloc(sizeof(task_t));
+    if (ta) {
+        spinlock_initialize(&ta->lock);
+        list_initialize(&ta->th_head);
+        list_initialize(&ta->tasks_link);
+        ta->vm = m;
+        pri = cpu_priority_high();
+        spinlock_lock(&tasks_lock);
+        list_append(&ta->tasks_link, &tasks_head);
+        spinlock_unlock(&tasks_lock);
+        cpu_priority_restore(pri);
+    }
+    return ta;
+}

/SPARTAN/trunk/src/clean.amd64
0,0 → 1,3
#! /bin/sh

make dist-clean ARCH=amd64
Property changes:
Added: svn:executable
+*
\ No newline at end of property

/SPARTAN/trunk/src/build.amd64
0,0 → 1,3
#! /bin/sh

make all ARCH=amd64
Property changes:
Added: svn:executable
+*
\ No newline at end of property

 /SPARTAN/trunk/src/Makefile.config
 ,0 → 1,35
+ARCH=ia32
+#ARCH=mips
+#ARCH=ia64
+#ARCH=ppc
+#ARCH=amd64
+# Support for symetric multiprocessors
+SMP=__SMP__
+# Improved support for hyperthreading
+HT=__HT__
+# General debuging and assert checking disable
+#NDEBUG=__NDEBUG__
+# Deadlock detection support for spinlocks.
+DEBUG_SPINLOCK=DEBUG_SPINLOCK
+# Uncomment if you want to compile in userspace support
+#USERSPACE=__USERSPACE__
+# Uncomment if you want to run in the test mode
+#TEST=__TEST__
+TEST_FILE=test.c
+# Select what test do you want to run
+#TEST_DIR=synch/rwlock1/
+#TEST_DIR=synch/rwlock2/
+#TEST_DIR=synch/rwlock3/
+#TEST_DIR=synch/rwlock4/
+#TEST_DIR=synch/rwlock5/
+#TEST_DIR=synch/semaphore1/
+#TEST_DIR=synch/semaphore2/
+TEST_DIR=fpu/fpu1

/SPARTAN/trunk/src/build.ppc
0,0 → 1,3
#! /bin/sh

make all ARCH=ppc
Property changes:
Added: svn:executable
+*
\ No newline at end of property

/SPARTAN/trunk/src/clean.ppc
0,0 → 1,3
#! /bin/sh

make dist-clean ARCH=ppc
Property changes:
Added: svn:executable
+*
\ No newline at end of property

 /SPARTAN/trunk/src/synch/rwlock.c
 ,0 → 1,311
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/*
+ * Reader/Writer locks
+ */
+/*
+ * These locks are not recursive.
+ * Neither readers nor writers will suffer starvation.
+ *
+ * If there is a writer followed by a reader waiting for the rwlock
+ * and the writer times out, all leading readers are automatically woken up
+ * and allowed in.
+ */
+/*
+ * NOTE ON rwlock_holder_type
+ * This field is set on an attempt to acquire the exclusive mutex
+ * to the respective value depending whether the caller is a reader
+ * or a writer. The field is examined only if the thread had been
+ * previously blocked on the exclusive mutex. Thus it is save
+ * to store the rwlock type in the thread structure, because
+ * each thread can block on only one rwlock at a time.
+ */
+#include <synch/synch.h>
+#include <synch/rwlock.h>
+#include <synch/spinlock.h>
+#include <synch/mutex.h>
+#include <synch/waitq.h>
+#include <list.h>
+#include <typedefs.h>
+#include <arch/asm.h>
+#include <arch.h>
+#include <proc/thread.h>
+#include <panic.h>
+#define ALLOW_ALL       0
+#define ALLOW_READERS_ONLY  1
+static void let_others_in(rwlock_t *rwl, int readers_only);
+static void release_spinlock(void *arg);
+void rwlock_initialize(rwlock_t *rwl) {
+    spinlock_initialize(&rwl->lock);
+    mutex_initialize(&rwl->exclusive);
+    rwl->readers_in = 0;
+}
+int _rwlock_write_lock_timeout(rwlock_t *rwl, __u32 usec, int trylock)
+{
+    pri_t pri;
+    int rc;
+    pri = cpu_priority_high();
+    spinlock_lock(&THREAD->lock);
+    THREAD->rwlock_holder_type = RWLOCK_WRITER;
+    spinlock_unlock(&THREAD->lock);
+    cpu_priority_restore(pri);
+    /*
+     * Writers take the easy part.
+     * They just need to acquire the exclusive mutex.
+     */
+    rc = _mutex_lock_timeout(&rwl->exclusive, usec, trylock);
+    if (SYNCH_FAILED(rc)) {
+        /*
+         * Lock operation timed out.
+         * The state of rwl is UNKNOWN at this point.
+         * No claims about its holder can be made.
+         */
+        pri = cpu_priority_high();
+        spinlock_lock(&rwl->lock);
+        /*
+         * Now when rwl is locked, we can inspect it again.
+         * If it is held by some readers already, we can let
+         * readers from the head of the wait queue in.
+         */
+        if (rwl->readers_in)
+            let_others_in(rwl, ALLOW_READERS_ONLY);
+        spinlock_unlock(&rwl->lock);
+        cpu_priority_restore(pri);
+    }
+    return rc;
+}
+int _rwlock_read_lock_timeout(rwlock_t *rwl, __u32 usec, int trylock)
+{
+    int rc;
+    pri_t pri;
+    pri = cpu_priority_high();
+    spinlock_lock(&THREAD->lock);
+    THREAD->rwlock_holder_type = RWLOCK_READER;
+    spinlock_unlock(&THREAD->lock);
+    spinlock_lock(&rwl->lock);
+    /*
+     * Find out whether we can get what we want without blocking.
+     */
+    rc = mutex_trylock(&rwl->exclusive);
+    if (SYNCH_FAILED(rc)) {
+        /*
+         * 'exclusive' mutex is being held by someone else.
+         * If the holder is a reader and there is no one
+         * else waiting for it, we can enter the critical
+         * section.
+         */
+        if (rwl->readers_in) {
+            spinlock_lock(&rwl->exclusive.sem.wq.lock);
+            if (list_empty(&rwl->exclusive.sem.wq.head)) {
+                /*
+                 * We can enter.
+                 */
+                spinlock_unlock(&rwl->exclusive.sem.wq.lock);
+                goto shortcut;
+            }
+            spinlock_unlock(&rwl->exclusive.sem.wq.lock);
+        }
+        /*
+         * In order to prevent a race condition when a reader
+         * could block another reader at the head of the waitq,
+         * we register a function to unlock rwl->lock
+         * after this thread is put asleep.
+         */
+        thread_register_call_me(release_spinlock, &rwl->lock);
+        rc = _mutex_lock_timeout(&rwl->exclusive, usec, trylock);
+        switch (rc) {
+            case ESYNCH_WOULD_BLOCK:
+                /*
+                 * release_spinlock() wasn't called
+                 */
+                thread_register_call_me(NULL, NULL);
+                spinlock_unlock(&rwl->lock);
+            case ESYNCH_TIMEOUT:
+                /*
+                 * The sleep timeouted.
+                 * We just restore the cpu priority.
+                 */
+            case ESYNCH_OK_BLOCKED:
+                /*
+                 * We were woken with rwl->readers_in already incremented.
+                 * Note that this arrangement avoids race condition between
+                 * two concurrent readers. (Race is avoided if 'exclusive' is
+                 * locked at the same time as 'readers_in' is incremented.
+                 * Same time means both events happen atomically when
+                 * rwl->lock is held.)
+                 */
+                cpu_priority_restore(pri);
+                break;
+            case ESYNCH_OK_ATOMIC:
+                panic("_mutex_lock_timeout()==ESYNCH_OK_ATOMIC");
+                break;
+            dafault:
+                panic("invalid ESYNCH");
+                break;
+        }
+        return rc;
+    }
+shortcut:
+    /*
+     * We can increment readers_in only if we didn't go to sleep.
+     * For sleepers, rwlock_let_others_in() will do the job.
+     */
+    rwl->readers_in++;
+    spinlock_unlock(&rwl->lock);
+    cpu_priority_restore(pri);
+    return ESYNCH_OK_ATOMIC;
+}
+void rwlock_write_unlock(rwlock_t *rwl)
+{
+    pri_t pri;
+    pri = cpu_priority_high();
+    spinlock_lock(&rwl->lock);
+    let_others_in(rwl, ALLOW_ALL);
+    spinlock_unlock(&rwl->lock);
+    cpu_priority_restore(pri);
+}
+void rwlock_read_unlock(rwlock_t *rwl)
+{
+    pri_t pri;
+    pri = cpu_priority_high();
+    spinlock_lock(&rwl->lock);
+    if (!--rwl->readers_in)
+        let_others_in(rwl, ALLOW_ALL);
+    spinlock_unlock(&rwl->lock);
+    cpu_priority_restore(pri);
+}
+/*
+ * Must be called with rwl->lock locked.
+ * Must be called with cpu_priority_high'ed.
+ */
+/*
+ * If readers_only is false: (unlock scenario)
+ * Let the first sleeper on 'exclusive' mutex in, no matter
+ * whether it is a reader or a writer. If there are more leading
+ * readers in line, let each of them in.
+ *
+ * Otherwise: (timeout scenario)
+ * Let all leading readers in.
+ */
+void let_others_in(rwlock_t *rwl, int readers_only)
+{
+    rwlock_type_t type = RWLOCK_NONE;
+    thread_t *t = NULL;
+    int one_more = 1;
+    spinlock_lock(&rwl->exclusive.sem.wq.lock);
+    if (!list_empty(&rwl->exclusive.sem.wq.head))
+        t = list_get_instance(rwl->exclusive.sem.wq.head.next, thread_t, wq_link);
+    do {
+        if (t) {
+            spinlock_lock(&t->lock);
+            type = t->rwlock_holder_type;
+            spinlock_unlock(&t->lock);
+        }
+        /*
+         * If readers_only is true, we wake all leading readers
+         * if and only if rwl is locked by another reader.
+         * Assumption: readers_only ==> rwl->readers_in
+         */
+        if (readers_only && (type != RWLOCK_READER))
+            break;
+        if (type == RWLOCK_READER) {
+            /*
+             * Waking up a reader.
+             * We are responsible for incrementing rwl->readers_in for it.
+             */
+             rwl->readers_in++;
+        }
+        /*
+         * Only the last iteration through this loop can increment
+         * rwl->exclusive.sem.wq.missed_wakeup's. All preceeding
+         * iterations will wake up a thread.
+         */
+        /* We call the internal version of waitq_wakeup, which
+         * relies on the fact that the waitq is already locked.
+         */
+        _waitq_wakeup_unsafe(&rwl->exclusive.sem.wq, WAKEUP_FIRST);
+        t = NULL;
+        if (!list_empty(&rwl->exclusive.sem.wq.head)) {
+            t = list_get_instance(rwl->exclusive.sem.wq.head.next, thread_t, wq_link);
+            if (t) {
+                spinlock_lock(&t->lock);
+                if (t->rwlock_holder_type != RWLOCK_READER)
+                    one_more = 0;
+                spinlock_unlock(&t->lock);
+            }
+        }
+    } while ((type == RWLOCK_READER) && t && one_more);
+    spinlock_unlock(&rwl->exclusive.sem.wq.lock);
+}
+void release_spinlock(void *arg)
+{
+    spinlock_unlock((spinlock_t *) arg);
+}

 /SPARTAN/trunk/src/synch/spinlock.c
 ,0 → 1,85
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch.h>
+#include <arch/atomic.h>
+#include <arch/barrier.h>
+#include <synch/spinlock.h>
+#ifdef __SMP__
+void spinlock_initialize(spinlock_t *sl)
+{
+    sl->val = 0;
+}
+#ifdef DEBUG_SPINLOCK
+void spinlock_lock(spinlock_t *sl)
+{
+    int i = 0;
+    __address caller = ((__u32 *) &sl)[-1];
+    while (test_and_set(&sl->val)) {
+        if (i++ > 300000) {
+            printf("cpu%d: looping on spinlock %X, caller=%X\n", CPU->id, sl, caller);
+            i = 0;
+        }
+    }
+    CS_ENTER_BARRIER();
+}
+#else
+void spinlock_lock(spinlock_t *sl)
+{
+    /*
+     * Each architecture has its own efficient/recommended
+     * implementation of spinlock.
+     */
+    spinlock_arch(&sl->val);
+    CS_ENTER_BARRIER();
+}
+#endif
+int spinlock_trylock(spinlock_t *sl)
+{
+    int rc;
+    rc = !test_and_set(&sl->val);
+    CS_ENTER_BARRIER();
+    return rc;
+}
+void spinlock_unlock(spinlock_t *sl)
+{
+    CS_LEAVE_BARRIER();
+    sl->val = 0;
+}
+#endif

 /SPARTAN/trunk/src/synch/semaphore.c
 ,0 → 1,58
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <synch/synch.h>
+#include <synch/semaphore.h>
+#include <synch/waitq.h>
+#include <synch/spinlock.h>
+#include <arch/asm.h>
+void semaphore_initialize(semaphore_t *s, int val)
+{
+    pri_t pri;
+    waitq_initialize(&s->wq);
+    pri = cpu_priority_high();
+    spinlock_lock(&s->wq.lock);
+    s->wq.missed_wakeups = val;
+    spinlock_unlock(&s->wq.lock);
+    cpu_priority_restore(pri);
+}
+int _semaphore_down_timeout(semaphore_t *s, __u32 usec, int trydown)
+{
+    return waitq_sleep_timeout(&s->wq, usec, trydown);
+}
+void semaphore_up(semaphore_t *s)
+{
+    waitq_wakeup(&s->wq, WAKEUP_FIRST);
+}

 /SPARTAN/trunk/src/synch/waitq.c
 ,0 → 1,241
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <context.h>
+#include <proc/thread.h>
+#include <synch/synch.h>
+#include <synch/waitq.h>
+#include <synch/spinlock.h>
+#include <arch/asm.h>
+#include <arch/types.h>
+#include <arch.h>
+#include <list.h>
+#include <time/timeout.h>
+void waitq_initialize(waitq_t *wq)
+{
+    spinlock_initialize(&wq->lock);
+    list_initialize(&wq->head);
+    wq->missed_wakeups = 0;
+}
+/*
+ * Called with interrupts disabled from clock() when sleep_timeout
+ * timeouts. This function is not allowed to enable interrupts.
+ *
+ * It is supposed to try to remove 'its' thread from the waitqueue; it
+ * can eventually fail to achieve this goal when these two events
+ * overlap; in that case it behaves just as though there was no
+ * timeout at all
+ */
+void waitq_interrupted_sleep(void *data)
+{
+    thread_t *t = (thread_t *) data;
+    waitq_t *wq;
+    int do_wakeup = 0;
+    spinlock_lock(&threads_lock);
+    if (!list_member(&t->threads_link, &threads_head))
+        goto out;
+grab_locks:
+    spinlock_lock(&t->lock);
+    if (wq = t->sleep_queue) {
+        if (!spinlock_trylock(&wq->lock)) {
+            spinlock_unlock(&t->lock);
+            goto grab_locks; /* avoid deadlock */
+        }
+        list_remove(&t->wq_link);
+        t->saved_context = t->sleep_timeout_context;
+        do_wakeup = 1;
+        spinlock_unlock(&wq->lock);
+        t->sleep_queue = NULL;
+    }
+    t->timeout_pending = 0;
+    spinlock_unlock(&t->lock);
+    if (do_wakeup) thread_ready(t);
+out:
+    spinlock_unlock(&threads_lock);
+}
+/*
+ * This is a sleep implementation which allows itself to be
+ * interrupted from the sleep, restoring a failover context.
+ *
+ * This function is really basic in that other functions as waitq_sleep()
+ * and all the *_timeout() functions use it.
+ *
+ * The third argument controls whether only a conditional sleep
+ * (non-blocking sleep) is called for when the second argument is 0.
+ *
+ * usec | nonblocking | what happens if there is no missed_wakeup
+ * -----+-------------+--------------------------------------------
+ *  0   | 0       | blocks without timeout until wakeup
+ *  0   | <> 0        | immediately returns ESYNCH_WOULD_BLOCK
+ *  > 0 | x       | blocks with timeout until timeout or wakeup
+ *
+ * return values:
+ *  ESYNCH_WOULD_BLOCK
+ *  ESYNCH_TIMEOUT
+ *  ESYNCH_OK_ATOMIC
+ *  ESYNCH_OK_BLOCKED
+ */
+int waitq_sleep_timeout(waitq_t *wq, __u32 usec, int nonblocking)
+{
+    volatile pri_t pri; /* must be live after context_restore() */
+restart:
+    pri = cpu_priority_high();
+    /*
+     * Busy waiting for a delayed timeout.
+     * This is an important fix for the race condition between
+     * a delayed timeout and a next call to waitq_sleep_timeout().
+     * Simply, the thread is not allowed to go to sleep if
+     * there are timeouts in progress.
+     */
+    spinlock_lock(&THREAD->lock);
+    if (THREAD->timeout_pending) {
+        spinlock_unlock(&THREAD->lock);
+        cpu_priority_restore(pri);
+        goto restart;
+    }
+    spinlock_unlock(&THREAD->lock);
+    spinlock_lock(&wq->lock);
+    /* checks whether to go to sleep at all */
+    if (wq->missed_wakeups) {
+        wq->missed_wakeups--;
+        spinlock_unlock(&wq->lock);
+        cpu_priority_restore(pri);
+        return ESYNCH_OK_ATOMIC;
+    }
+    else {
+        if (nonblocking && (usec == 0)) {
+            /* return immediatelly instead of going to sleep */
+            spinlock_unlock(&wq->lock);
+            cpu_priority_restore(pri);
+            return ESYNCH_WOULD_BLOCK;
+        }
+    }
+    /*
+     * Now we are firmly decided to go to sleep.
+     */
+    spinlock_lock(&THREAD->lock);
+    if (usec) {
+        /* We use the timeout variant. */
+        if (!context_save(&THREAD->sleep_timeout_context)) {
+            /*
+             * Short emulation of scheduler() return code.
+             */
+            before_thread_runs();
+            spinlock_unlock(&THREAD->lock);
+            cpu_priority_restore(pri);
+            return ESYNCH_TIMEOUT;
+        }
+        THREAD->timeout_pending = 1;
+        timeout_register(&THREAD->sleep_timeout, (__u64) usec, waitq_interrupted_sleep, THREAD);
+    }
+    list_append(&THREAD->wq_link, &wq->head);
+    /*
+     * Suspend execution.
+     */
+    THREAD->state = Sleeping;
+    THREAD->sleep_queue = wq;
+    spinlock_unlock(&THREAD->lock);
+    scheduler();    /* wq->lock is released in scheduler_separated_stack() */
+    cpu_priority_restore(pri);
+    return ESYNCH_OK_BLOCKED;
+}
+/*
+ * This is the SMP- and IRQ-safe wrapper meant for general use.
+ */
+/*
+ * Besides its 'normal' wakeup operation, it attempts to unregister possible timeout.
+ */
+void waitq_wakeup(waitq_t *wq, int all)
+{
+    pri_t pri;
+    pri = cpu_priority_high();
+    spinlock_lock(&wq->lock);
+    _waitq_wakeup_unsafe(wq, all);
+    spinlock_unlock(&wq->lock);
+    cpu_priority_restore(pri);
+}
+/*
+ * This is the internal SMP- and IRQ-unsafe version of waitq_wakeup.
+ * It assumes wq->lock is already locked.
+ */
+void _waitq_wakeup_unsafe(waitq_t *wq, int all)
+{
+    thread_t *t;
+loop:
+    if (list_empty(&wq->head)) {
+        wq->missed_wakeups++;
+        if (all) wq->missed_wakeups = 0;
+        return;
+    }
+    t = list_get_instance(wq->head.next, thread_t, wq_link);
+    list_remove(&t->wq_link);
+    spinlock_lock(&t->lock);
+    if (t->timeout_pending && timeout_unregister(&t->sleep_timeout))
+        t->timeout_pending = 0;
+    t->sleep_queue = NULL;
+    spinlock_unlock(&t->lock);
+    thread_ready(t);
+    if (all) goto loop;
+}

 /SPARTAN/trunk/src/synch/mutex.c
 ,0 → 1,46
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <synch/synch.h>
+#include <synch/mutex.h>
+#include <synch/semaphore.h>
+void mutex_initialize(mutex_t *mtx)
+{
+    semaphore_initialize(&mtx->sem, 1);
+}
+int _mutex_lock_timeout(mutex_t *mtx, __u32 usec, int trylock)
+{
+    return _semaphore_down_timeout(&mtx->sem, usec, trylock);
+}
+void mutex_unlock(mutex_t *mtx)
+{
+    semaphore_up(&mtx->sem);
+}

 /SPARTAN/trunk/src/synch/condvar.c
 ,0 → 1,57
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <synch/synch.h>
+#include <synch/condvar.h>
+#include <synch/mutex.h>
+#include <synch/waitq.h>
+void condvar_initialize(condvar_t *cv)
+{
+    waitq_initialize(&cv->wq);
+}
+void condvar_signal(condvar_t *cv)
+{
+    waitq_wakeup(&cv->wq, WAKEUP_FIRST);
+}
+void condvar_broadcast(condvar_t *cv)
+{
+    waitq_wakeup(&cv->wq, WAKEUP_ALL);
+}
+int _condvar_wait_timeout(condvar_t *cv, mutex_t *mtx, __u32 usec, int trywait)
+{
+    int rc;
+    mutex_unlock(mtx);
+    rc = waitq_sleep_timeout(&cv->wq, usec, trywait);
+    mutex_lock(mtx);
+    return rc;
+}

 /SPARTAN/trunk/src/cpu/cpu.c
 ,0 → 1,95
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <cpu.h>
+#include <arch.h>
+#include <arch/cpu.h>
+#include <mm/heap.h>
+#include <mm/page.h>
+#include <mm/frame.h>
+#include <arch/types.h>
+#include <config.h>
+#include <panic.h>
+#include <typedefs.h>
+#include <memstr.h>
+#include <list.h>
+cpu_private_data_t *cpu_private_data;
+cpu_t *cpus;
+/** Initialize CPUs
+ *
+ * Initialize kernel CPUs support.
+ *
+ */
+void cpu_init(void) {
+    int i, j;
+    #ifdef __SMP__
+    if (config.cpu_active == 1) {
+    #endif /* __SMP__ */
+        cpu_private_data = (cpu_private_data_t *) malloc(sizeof(cpu_private_data_t) * config.cpu_count);
+        if (!cpu_private_data)
+            panic("malloc/cpu_private_data");
+        cpus = (cpu_t *) malloc(sizeof(cpu_t) * config.cpu_count);
+        if (!cpus)
+            panic("malloc/cpus");
+        /* initialize everything */
+        memsetb((__address) cpu_private_data, sizeof(cpu_private_data_t) * config.cpu_count, 0);
+        memsetb((__address) cpus, sizeof(cpu_t) * config.cpu_count, 0);
+        for (i=0; i < config.cpu_count; i++) {
+            cpus[i].stack = (__u8 *) malloc(CPU_STACK_SIZE);
+            if (!cpus[i].stack)
+                panic("malloc/cpus[%d].stack\n", i);
+            cpus[i].id = i;
+            #ifdef __SMP__
+            waitq_initialize(&cpus[i].kcpulb_wq);
+            #endif /* __SMP */
+            for (j = 0; j < RQ_COUNT; j++) {
+                list_initialize(&cpus[i].rq[j].rq_head);
+            }
+        }
+    #ifdef __SMP__
+    }
+    #endif /* __SMP__ */
+    CPU->active = 1;
+    CPU->tlb_active = 1;
+    cpu_identify();
+    cpu_arch_init();
+}

 /SPARTAN/trunk/src/time/timeout.c
 ,0 → 1,205
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <time/timeout.h>
+#include <typedefs.h>
+#include <arch/types.h>
+#include <config.h>
+#include <panic.h>
+#include <synch/spinlock.h>
+#include <func.h>
+#include <cpu.h>
+#include <print.h>
+#include <arch/asm.h>
+#include <arch.h>
+/** Initialize timeouts
+ *
+ * Initialize kernel timeouts.
+ *
+ */
+void timeout_init(void)
+{
+    spinlock_initialize(&CPU->timeoutlock);
+    list_initialize(&CPU->timeout_active_head);
+}
+/** Initialize empty timeout list
+ *
+ * Initialize the timeout list to be empty.
+ *
+ * @param t Timeout list to be initialized.
+ *
+ */
+void timeout_reinitialize(timeout_t *t)
+{
+    t->cpu = NULL;
+    t->ticks = 0;
+    t->handler = NULL;
+    t->arg = NULL;
+    link_initialize(&t->link);
+}
+/** Initialize timeout list
+ *
+ * Initialize the timeout list and its spinlock.
+ *
+ * @param t Timeout list to be initialized.
+ *
+ */
+void timeout_initialize(timeout_t *t)
+{
+    spinlock_initialize(&t->lock);
+    timeout_reinitialize(t);
+}
+/** Register timeout callback
+ *
+ * Insert the timeout handler f (with argument arg)
+ * to the timeout list and make it execute in
+ * time microseconds (or slightly more).
+ *
+ * @param t    Timeout list.
+ * @patam time Number of usec in the future to execute
+ *             the handler.
+ * @param f    Timeout handler function.
+ * @param arg  Timeout handler argument.
+ *
+ */
+void timeout_register(timeout_t *t, __u64 time, timeout_handler f, void *arg)
+{
+    timeout_t *hlp;
+    link_t *l, *m;
+    pri_t pri;
+    __u64 sum;
+    pri = cpu_priority_high();
+    spinlock_lock(&CPU->timeoutlock);
+    spinlock_lock(&t->lock);
+    if (t->cpu)
+        panic("t->cpu != 0");
+    t->cpu = CPU;
+    t->ticks = us2ticks(time);
+    t->handler = f;
+    t->arg = arg;
+    /*
+     * Insert t into the active timeouts list according to t->ticks.
+     */
+    sum = 0;
+    l = CPU->timeout_active_head.next;
+    while (l != &CPU->timeout_active_head) {
+        hlp = list_get_instance(l, timeout_t, link);
+        spinlock_lock(&hlp->lock);
+        if (t->ticks < sum + hlp->ticks) {
+            spinlock_unlock(&hlp->lock);
+            break;
+        }
+        sum += hlp->ticks;
+        spinlock_unlock(&hlp->lock);
+        l = l->next;
+    }
+    m = l->prev;
+    list_prepend(&t->link, m); /* avoid using l->prev */
+    /*
+     * Adjust t->ticks according to ticks accumulated in h's predecessors.
+     */
+    t->ticks -= sum;
+    /*
+     * Decrease ticks of t's immediate succesor by t->ticks.
+     */
+    if (l != &CPU->timeout_active_head) {
+        spinlock_lock(&hlp->lock);
+        hlp->ticks -= t->ticks;
+        spinlock_unlock(&hlp->lock);
+    }
+    spinlock_unlock(&t->lock);
+    spinlock_unlock(&CPU->timeoutlock);
+    cpu_priority_restore(pri);
+}
+/** Unregister timeout callback
+ *
+ * Remove timeout from timeout list.
+ *
+ * @param t Timeout to unregister.
+ *
+ */
+int timeout_unregister(timeout_t *t)
+{
+    timeout_t *hlp;
+    link_t *l;
+    pri_t pri;
+grab_locks:
+    pri = cpu_priority_high();
+    spinlock_lock(&t->lock);
+    if (!t->cpu) {
+        spinlock_unlock(&t->lock);
+        cpu_priority_restore(pri);
+        return 0;
+    }
+    if (!spinlock_trylock(&t->cpu->timeoutlock)) {
+        spinlock_unlock(&t->lock);
+        cpu_priority_restore(pri);
+        goto grab_locks;
+    }
+    /*
+     * Now we know for sure that t hasn't been activated yet
+     * and is lurking in t->cpu->timeout_active_head queue.
+     */
+    l = t->link.next;
+    if (l != &t->cpu->timeout_active_head) {
+        hlp = list_get_instance(l, timeout_t, link);
+        spinlock_lock(&hlp->lock);
+        hlp->ticks += t->ticks;
+        spinlock_unlock(&hlp->lock);
+    }
+    list_remove(&t->link);
+    spinlock_unlock(&t->cpu->timeoutlock);
+    timeout_reinitialize(t);
+    spinlock_unlock(&t->lock);
+    cpu_priority_restore(pri);
+    return 1;
+}

 /SPARTAN/trunk/src/time/clock.c
 ,0 → 1,101
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <time/clock.h>
+#include <time/timeout.h>
+#include <arch/types.h>
+#include <config.h>
+#include <synch/spinlock.h>
+#include <synch/waitq.h>
+#include <func.h>
+#include <proc/scheduler.h>
+#include <cpu.h>
+#include <print.h>
+#include <arch.h>
+#include <list.h>
+#include <arch/atomic.h>
+/** Clock routine
+ *
+ * Clock routine executed from clock interrupt handler
+ * (assuming cpu_priority_high()). Runs expired timeouts
+ * and preemptive scheduling.
+ *
+ */
+void clock(void)
+{
+    link_t *l;
+    timeout_t *h;
+    timeout_handler f;
+    void *arg;
+    /*
+     * To avoid lock ordering problems,
+     * run all expired timeouts as you visit them.
+     */
+    spinlock_lock(&CPU->timeoutlock);
+    while ((l = CPU->timeout_active_head.next) != &CPU->timeout_active_head) {
+        h = list_get_instance(l, timeout_t, link);
+        spinlock_lock(&h->lock);
+        if (h->ticks-- != 0) {
+            spinlock_unlock(&h->lock);
+            break;
+        }
+        list_remove(l);
+        f = h->handler;
+        arg = h->arg;
+        timeout_reinitialize(h);
+        spinlock_unlock(&h->lock);
+        spinlock_unlock(&CPU->timeoutlock);
+        f(arg);
+        spinlock_lock(&CPU->timeoutlock);
+    }
+    spinlock_unlock(&CPU->timeoutlock);
+    /*
+     * Do CPU usage accounting and find out whether to preempt THREAD.
+     */
+    if (THREAD) {
+        spinlock_lock(&CPU->lock);
+        CPU->needs_relink++;
+        spinlock_unlock(&CPU->lock);
+        spinlock_lock(&THREAD->lock);
+        if (!THREAD->ticks--) {
+            spinlock_unlock(&THREAD->lock);
+            scheduler();
+        }
+        else {
+            spinlock_unlock(&THREAD->lock);
+        }
+    }
+}

 /SPARTAN/trunk/src/time/delay.c
 ,0 → 1,54
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <time/delay.h>
+#include <arch/types.h>
+#include <cpu.h>
+#include <arch/asm.h>
+#include <arch.h>
+/** Active delay
+ *
+ * Delay the execution for the given number
+ * of microseconds (or slightly more). The delay
+ * is implemented as CPU calibrated active loop.
+ *
+ * @param microseconds Number of usec to sleep.
+ *
+ */
+void delay(__u32 microseconds)
+{
+    pri_t pri;
+    /* The delay loop is calibrated for each and every
+       CPU in the system. Therefore it is necessary to
+       cpu_priority_high() before calling the asm_delay_loop(). */
+    pri = cpu_priority_high();
+    asm_delay_loop(microseconds * CPU->delay_loop_const);
+    cpu_priority_restore(pri);
+}

 /SPARTAN/trunk/src/debug/print.c
 ,0 → 1,242
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <putchar.h>
+#include <print.h>
+#include <synch/spinlock.h>
+#include <arch/arg.h>
+#include <arch/asm.h>
+static char digits[] = "0123456789abcdef"; /**< Hexadecimal characters */
+static spinlock_t printflock;              /**< printf spinlock */
+/** Print NULL terminated string
+ *
+ * Print characters from str using putchar() until
+ * \x00 character is reached.
+ *
+ * @param str Characters to print.
+ *
+ */
+void print_str(const char *str)
+{
+    int i = 0;
+    char c;
+    while (c = str[i++])
+        putchar(c);
+}
+/** Print hexadecimal digits
+ *
+ * Print fixed count of hexadecimal digits from
+ * the number num. The digits are printed in
+ * natural left-to-right order starting with
+ * the width-th digit.
+ *
+ * @param num   Number containing digits.
+ * @param width Count of digits to print.
+ *
+ */
+void print_fixed_hex(const __native num, const int width)
+{
+    int i;
+    for (i = width*8 - 4; i >= 0; i -= 4)
+        putchar(digits[(num>>i) & 0xf]);
+}
+/** Print number in given base
+ *
+ * Print significant digits of a number in given
+ * base.
+ *
+ * @param num  Number to print.
+ * @param base Base to print the number in (should
+ *             be in range 2 .. 16).
+ *
+ */
+void print_number(const __native num, const unsigned int base)
+{
+    int val = num;
+    char d[sizeof(__native)*8+1];       /* this is good enough even for base == 2 */
+    int i = sizeof(__native)*8-1;
+    do {
+        d[i--] = digits[val % base];
+    } while (val /= base);
+    d[sizeof(__native)*8] = 0;
+    print_str(&d[i + 1]);
+}
+/** General formatted text print
+ *
+ * Print text formatted according the fmt parameter
+ * and variant arguments. Each formatting directive
+ * begins with % (percentage) character and one of the
+ * following character:
+ *
+ * %    Prints the percentage character.
+ * s    The next variant argument is treated as char*
+ *      and printed as a NULL terminated string.
+ * c    The next variant argument is treated as a single char.
+ * p    The next variant argument is treated as a maximum
+ *      bit-width integer with respect to architecture
+ *      and printed in full hexadecimal width.
+ * P    As with 'p', but '0x' is prefixed.
+ * q    The next variant argument is treated as a 64b integer
+ *      and printed in full hexadecimal width.
+ * Q    As with 'q', but '0x' is prefixed.
+ * l    The next variant argument is treated as a 32b integer
+ *      and printed in full hexadecimal width.
+ * L    As with 'l', but '0x' is prefixed.
+ * w    The next variant argument is treated as a 16b integer
+ *      and printed in full hexadecimal width.
+ * W    As with 'w', but '0x' is prefixed.
+ * b    The next variant argument is treated as a 8b integer
+ *      and printed in full hexadecimal width.
+ * N    As with 'b', but '0x' is prefixed.
+ * d    The next variant argument is treated as integer
+ *      and printed in standard decimal format (only significant
+ *      digits).
+ * x    The next variant argument is treated as integer
+ *      and printed in standard hexadecimal format (only significant
+ *      digits).
+ * X    As with 'x', but '0x' is prefixed.
+ *
+ * All other characters from fmt except the formatting directives
+ * are printed in verbatim.
+ *
+ * @param fmt Formatting NULL terminated string.
+ *
+ */
+void printf(const char *fmt, ...)
+{
+    int irqpri, i = 0;
+    va_list ap;
+    char c;
+    va_start(ap, fmt);
+    irqpri = cpu_priority_high();
+    spinlock_lock(&printflock);
+    while (c = fmt[i++]) {
+        switch (c) {
+            /* control character */
+            case '%':
+                switch (c = fmt[i++]) {
+                /* percentile itself */
+                case '%':
+                    break;
+                /*
+                 * String and character conversions.
+                 */
+                case 's':
+                    print_str(va_arg(ap, char_ptr));
+                    goto loop;
+                case 'c':
+                    c = (char) va_arg(ap, int);
+                    break;
+                /*
+                         * Hexadecimal conversions with fixed width.
+                         */
+                case 'P':
+                    print_str("0x");
+                case 'p':
+                        print_fixed_hex(va_arg(ap, __native), sizeof(__native));
+                    goto loop;
+                case 'Q':
+                    print_str("0x");
+                case 'q':
+                        print_fixed_hex(va_arg(ap, __native), INT64);
+                    goto loop;
+                case 'L':
+                    print_str("0x");
+                case 'l':
+                        print_fixed_hex(va_arg(ap, __native), INT32);
+                    goto loop;
+                case 'W':
+                    print_str("0x");
+                case 'w':
+                        print_fixed_hex(va_arg(ap, __native), INT16);
+                    goto loop;
+                case 'B':
+                    print_str("0x");
+                case 'b':
+                        print_fixed_hex(va_arg(ap, __native), INT8);
+                    goto loop;
+                /*
+                         * Decimal and hexadecimal conversions.
+                         */
+                case 'd':
+                        print_number(va_arg(ap, __native), 10);
+                    goto loop;
+                case 'X':
+                            print_str("0x");
+                case 'x':
+                        print_number(va_arg(ap, __native), 16);
+                    goto loop;
+                /*
+                 * Bad formatting.
+                 */
+                default:
+                    goto out;
+                }
+            default: putchar(c);
+        }
+loop:
+        ;
+    }
+out:
+    spinlock_unlock(&printflock);
+    cpu_priority_restore(irqpri);
+    va_end(ap);
+}

 /SPARTAN/trunk/src/Makefile
 ,0 → 1,87
+include Makefile.config
+include ../arch/$(ARCH)/Makefile.inc
+sources=cpu/cpu.c \
+    main/main.c \
+    main/kinit.c \
+    main/uinit.c \
+    proc/scheduler.c \
+    proc/thread.c \
+    proc/task.c \
+    mm/heap.c \
+    mm/frame.c \
+    mm/page.c \
+    mm/tlb.c \
+    mm/vm.c \
+    lib/func.c \
+    lib/list.c \
+    lib/memstr.c \
+    debug/print.c \
+    time/clock.c \
+    time/timeout.c \
+    time/delay.c \
+    synch/spinlock.c \
+    synch/condvar.c \
+    synch/rwlock.c \
+    synch/mutex.c \
+    synch/semaphore.c \
+    synch/waitq.c \
+    smp/ipi.c
+ifdef DEBUG_SPINLOCK
+CFLAGS+=-D$(DEBUG_SPINLOCK)
+endif
+ifdef USERSPACE
+CFLAGS+=-D$(USERSPACE)
+endif
+ifdef TEST
+test_objects:=$(addsuffix .o,$(basename ../test/$(TEST_DIR)/$(TEST_FILE)))
+CFLAGS+=-D$(TEST)
+endif
+arch_objects:=$(addsuffix .o,$(basename $(arch_sources)))
+objects:=$(addsuffix .o,$(basename $(sources)))
+.PHONY : all config depend build clean dist-clean boot
+all: dist-clean config depend build
+-include Makefile.depend
+config:
+    find . ../include -name arch -type l -exec rm \{\} \;
+    ln -s ../arch/$(ARCH)/src arch
+    ln -s ../arch/$(ARCH)/include ../include/arch
+depend:
+    $(CC) $(CPPFLAGS) -M $(arch_sources) $(sources) >Makefile.depend
+build: kernel.bin boot
+clean:
+    find . ../arch/$(ARCH)/src ../test -name '*.o' -exec rm \{\} \;
+    -rm *.bin kernel.map
+    $(MAKE) -C ../arch/$(ARCH)/boot clean
+dist-clean:
+    find . ../include -name arch -type l -exec rm \{\} \;
+    -rm Makefile.depend
+    -$(MAKE) clean
+kernel.bin: $(arch_objects) $(objects) $(test_objects)
+    $(LD) $(LFLAGS) $(arch_objects) $(objects) $(test_objects) -o $@ -Map kernel.map
+%.s: %.S
+    $(CC) $(CPPFLAGS) -E $< >$@
+%.o: %.s
+    $(AS) $(ASFLAGS) $< -o $@
+%.o: %.c
+    $(CC) $(CFLAGS) -c $< -o $@
+KS=`cat kernel.bin | wc -c`
+boot:
+    $(MAKE) -C ../arch/$(ARCH)/boot build KERNEL_SIZE=$(KS)

 /SPARTAN/trunk/src/smp/ipi.c
 ,0 → 1,54
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifdef __SMP__
+#include <smp/ipi.h>
+#include <config.h>
+/** Broadcast IPI message
+ *
+ * Broadcast IPI message to all CPUs.
+ *
+ * @param ipi Message to broadcast.
+ *
+ */
+void ipi_broadcast(int ipi)
+{
+    /*
+     * Provisions must be made to avoid sending IPI:
+     * - before all CPU's were configured to accept the IPI
+     * - if there is only one CPU but the kernel was compiled with __SMP__
+     */
+    if ((config.cpu_active > 1) && (config.cpu_active == config.cpu_count))
+        ipi_broadcast_arch(ipi);
+}
+#endif /* __SMP__ */

 /SPARTAN/trunk/src/lib/memstr.c
 ,0 → 1,70
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <memstr.h>
+#include <arch/types.h>
+/** Copy block of memory
+ *
+ * Copy cnt bytes from src address to dst address.
+ * The copying is done byte-by-byte. The source
+ * and destination memory areas cannot overlap.
+ *
+ * @param src Origin address to copy from.
+ * @param dst Origin address to copy to.
+ * @param cnt Number of bytes to copy.
+ *
+ */
+void _memcopy(__address src, __address dst, size_t cnt)
+{
+    int i;
+    for (i=0; i<cnt; i++)
+        *((__u8 *) (dst + i)) = *((__u8 *) (src + i));
+}
+/** Fill block of memory
+ *
+ * Fill cnt bytes at dst address with the value x.
+ * The filling is done byte-by-byte.
+ *
+ * @param dst Origin address to fill.
+ * @param cnt Number of bytes to fill.
+ * @param x   Value to fill.
+ *
+ */
+void _memsetb(__address dst, size_t cnt, __u8 x)
+{
+    int i;
+    __u8 *p = (__u8 *) dst;
+    for(i=0; i<cnt; i++)
+        p[i] = x;
+}

 /SPARTAN/trunk/src/lib/func.c
 ,0 → 1,75
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <func.h>
+#include <print.h>
+#include <cpu.h>
+#include <arch/asm.h>
+#include <arch.h>
+__u32   haltstate = 0; /**< Halt flag */
+/** Halt wrapper
+ *
+ * Set halt flag and halt the cpu.
+ *
+ */
+void halt(void)
+{
+    haltstate = 1;
+    cpu_priority_high();
+    printf("cpu%d: halted\n", CPU->id);
+    cpu_halt();
+}
+/** Compare two NULL terminated strings
+ *
+ * Do a char-by-char comparment of two NULL terminated strings.
+ * The strings are considered equal iff they have the same
+ * length and consist of the same characters.
+ *
+ * @param src First string to compare.
+ * @param dst Second string to compare.
+ *
+ * @return 0 if the strings are equal, 1 otherwise.
+ *
+ */
+int strcmp(const char *src, const char *dst)
+{
+    int i;
+    i = 0;
+    while (src[i] == dst[i]) {
+        if (src[i] == '\0')
+            return 0;
+        i++;
+    }
+    return 1;
+}

 /SPARTAN/trunk/src/lib/list.c
 ,0 → 1,80
+/*
+ * Copyright (C) 2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <list.h>
+/** Check for membership
+ *
+ * Check whether link is contained in the list head.
+ * The membership is defined as pointer equivalence.
+ *
+ * @param link Item to look for.
+ * @param head List to look in.
+ *
+ * @return true if link is contained in head, false otherwise.
+ *
+ */
+bool list_member(const link_t *link, const link_t *head)
+{
+    bool found = false;
+    link_t *hlp = head->next;
+    while (hlp != head) {
+        if (hlp == link) {
+            found = true;
+            break;
+        }
+        hlp = hlp->next;
+    }
+    return found;
+}
+/** Concatenate two lists
+ *
+ * Concatenate lists head1 and head2, producing a single
+ * list head1 containing items from both (in head1, head2
+ * order) and empty list head2.
+ *
+ * @param head1 First list and concatenated output
+ * @param head2 Second list and empty output.
+ *
+ */
+void list_concat(link_t *head1, link_t *head2)
+{
+    if (list_empty(head2))
+        return;
+    head2->next->prev = head1->prev;
+    head2->prev->next = head1;
+    head1->prev->next = head2->next;
+    head1->prev = head2->prev;
+    list_initialize(head2);
+}

/SPARTAN/trunk/src/clean.ia32
0,0 → 1,3
#! /bin/sh

make dist-clean ARCH=ia32
Property changes:
Added: svn:executable
+*
\ No newline at end of property

/SPARTAN/trunk/src/clean.ia64
0,0 → 1,3
#! /bin/sh

make dist-clean ARCH=ia64
Property changes:
Added: svn:executable
+*
\ No newline at end of property

/SPARTAN/trunk/src/clean.mips
0,0 → 1,3
#! /bin/sh

make dist-clean ARCH=mips
Property changes:
Added: svn:executable
+*
\ No newline at end of property

/SPARTAN/trunk/src/build.ia32
0,0 → 1,3
#! /bin/sh

make all ARCH=ia32
Property changes:
Added: svn:executable
+*
\ No newline at end of property

/SPARTAN/trunk/src/build.ia64
0,0 → 1,3
#! /bin/sh

make all ARCH=ia64
Property changes:
Added: svn:executable
+*
\ No newline at end of property

/SPARTAN/trunk/src/build.mips
0,0 → 1,3
#! /bin/sh

make all ARCH=mips
Property changes:
Added: svn:executable
+*
\ No newline at end of property

 /SPARTAN/trunk/arch/ia32/src/asm.S
 ,0 → 1,396
+#
+# Copyright (C) 2001-2004 Jakub Jermar
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+## very low and hardware-level functions
+#  Mask for interrupts 0 - 31 (bits 0 - 31) where 0 means that int has no error word
+# and 1 means interrupt with error word
+#define ERROR_WORD_INTERRUPT_LIST 0x00027D00
+.text
+.global cpu_halt
+.global cpu_sleep
+.global paging_on
+.global enable_l_apic_in_msr
+.global interrupt_handlers
+.global inb
+.global inw
+.global inl
+.global outb
+.global outw
+.global outl
+.global memcopy
+.global memsetb
+.global memsetw
+.global memcmp
+## Turn paging on
+#
+# Enable paging and write-back caching in CR0.
+#
+paging_on:
+    pushl %eax
+    movl %cr0,%eax
+    orl $(1<<31),%eax       # paging on
+    andl $~((1<<30)|(1<<29)),%eax   # clear Cache Disable and not Write Though
+    movl %eax,%cr0
+    jmp 0f
+:
+    popl %eax
+    ret
+## Enable local APIC
+#
+# Enable local APIC in MSR.
+#
+enable_l_apic_in_msr:
+    pusha
+    movl $0x1b, %ecx
+    rdmsr
+    orl $(1<<11),%eax
+    orl $(0xfee00000),%eax
+    wrmsr
+    popa
+    ret
+## Declare interrupt handlers
+#
+# Declare interrupt handlers for n interrupt
+# vectors starting at vector i.
+#
+# The handlers setup data segment registers
+# and call trap_dispatcher().
+#
+.macro handler i n
+    push %ebp
+    movl %esp,%ebp
+    pusha
+    push %ds
+    push %es
+    # we must fill the data segment registers
+    movw $16,%ax
+    movw %ax,%ds
+    movw %ax,%es
+    movl $(\i),%edi
+    pushl %ebp
+    addl $4,(%esp)
+    pushl %edi
+    call trap_dispatcher
+    addl $8,%esp
+    pop %es
+    pop %ds
+# CLNT
+  pushfl;
+    pop %eax;
+    and $0xFFFFBFFF,%eax;
+    push %eax;
+    popfl;
+# Test if this is interrupt with error word or not
+    mov $\i,%cl;
+    movl $1,%eax;
+    test $0xe0,%cl;
+    jnz 0f;
+    and $0x1f,%cl;
+    shl %cl,%eax;
+    and $ERROR_WORD_INTERRUPT_LIST,%eax;
+    jz 0f;
+# Return with error word
+    popa;
+    pop %ebp;
+    add $4,%esp;    # Skip error word
+    iret;
+:
+# Return with no error word
+    popa
+    pop %ebp
+    iret
+    .if (\n-\i)-1
+    handler "(\i+1)",\n
+    .endif
+.endm
+# keep in sync with pm.h !!!
+IDT_ITEMS=64
+interrupt_handlers:
+h_start:
+    handler 0 64
+#   handler 64 128
+#   handler 128 192
+#   handler 192 256
+h_end:
+## I/O input (byte)
+#
+# Get a byte from I/O port and store it AL.
+#
+inb:
+    push %edx
+    xorl %eax,%eax
+    movl 8(%esp),%edx
+    inb %dx,%al
+    pop %edx
+    ret
+## I/O input (word)
+#
+# Get a word from I/O port and store it AX.
+#
+inw:
+    push %edx
+    xorl %eax,%eax
+    movl 8(%esp),%edx
+    inw %dx,%ax
+    pop %edx
+    ret
+## I/O input (dword)
+#
+# Get a dword from I/O port and store it EAX.
+#
+inl:
+    push %edx
+    xorl %eax,%eax
+    movl 8(%esp),%edx
+    inl %dx,%eax
+    pop %edx
+    ret
+## I/O output (byte)
+#
+# Send a byte to I/O port.
+#
+outb:
+    push %ebp
+    movl %esp,%ebp
+    pusha
+    movl 8(%ebp),%edx
+    movl 12(%ebp),%eax
+    outb %al,%dx
+    popa
+    pop %ebp
+    ret
+## I/O output (word)
+#
+# Send a word to I/O port.
+#
+outw:
+    push %ebp
+    movl %esp,%ebp
+    pusha
+    movl 8(%ebp),%edx
+    movl 12(%ebp),%eax
+    outw %ax,%dx
+    popa
+    pop %ebp
+    ret
+## I/O output (dword)
+#
+# Send a dword to I/O port.
+#
+outl:
+    push %ebp
+    movl %esp,%ebp
+    pusha
+    movl 8(%ebp),%edx
+    movl 12(%ebp),%eax
+    outl %eax,%dx
+    popa
+    pop %ebp
+    ret
+## Copy memory
+#
+# Copy a given number of bytes (3rd argument)
+# from the memory location defined by 1st argument
+# to the memory location defined by 2nd argument.
+# The memory areas cannot overlap.
+#
+SRC=8
+DST=12
+CNT=16
+memcopy:
+    push %ebp
+    movl %esp,%ebp
+    pusha
+    cld
+    movl CNT(%ebp),%ecx
+    movl DST(%ebp),%edi
+    movl SRC(%ebp),%esi
+    rep movsb %ds:(%esi),%es:(%edi)
+    popa
+    pop %ebp
+    ret
+## Fill memory with bytes
+#
+# Fill a given number of bytes (2nd argument)
+# at memory defined by 1st argument with the
+# byte value defined by 3rd argument.
+#
+DST=8
+CNT=12
+X=16
+memsetb:
+    push %ebp
+    movl %esp,%ebp
+    pusha
+    cld
+    movl CNT(%ebp),%ecx
+    movl DST(%ebp),%edi
+    movl X(%ebp),%eax
+    rep stosb %al,%es:(%edi)
+    popa
+    pop %ebp
+    ret
+## Fill memory with words
+#
+# Fill a given number of words (2nd argument)
+# at memory defined by 1st argument with the
+# word value defined by 3rd argument.
+#
+DST=8
+CNT=12
+X=16
+memsetw:
+    push %ebp
+    movl %esp,%ebp
+    pusha
+    cld
+    movl CNT(%ebp),%ecx
+    movl DST(%ebp),%edi
+    movl X(%ebp),%eax
+    rep stosw %ax,%es:(%edi)
+    popa
+    pop %ebp
+    ret
+## Compare memory regions for equality
+#
+# Compare a given number of bytes (3rd argument)
+# at memory locations defined by 1st and 2nd argument
+# for equality. If the bytes are equal, EAX contains
+# 0.
+#
+SRC=12
+DST=16
+CNT=20
+memcmp:
+    push %ebp
+    subl $4,%esp
+    movl %esp,%ebp
+    pusha
+    cld
+    movl CNT(%ebp),%ecx
+    movl DST(%ebp),%edi
+    movl SRC(%ebp),%esi
+    repe cmpsb %es:(%edi),%ds:(%esi)
+    movl %ecx,(%ebp)
+    popa
+    movl (%ebp),%eax    # return value => %eax (zero on success)
+    addl $4,%esp
+    pop %ebp
+    ret
+# THIS IS USERSPACE CODE
+.global utext
+utext:
+    xor %ax,%ax;
+    mov %ax,%ds;
+    mov %ax,%es;
+    mov %ax,%fs;
+    mov %ax,%gs;
+:
+    int $48
+    jmp 0b
+    # not reached
+utext_end:
+.data
+.global utext_size
+utext_size:
+    .long utext_end - utext
+#.section K_DATA_START
+.global interrupt_handler_size
+interrupt_handler_size: .long (h_end-h_start)/IDT_ITEMS

 /SPARTAN/trunk/arch/ia32/src/interrupt.c
 ,0 → 1,161
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch/interrupt.h>
+#include <print.h>
+#include <debug.h>
+#include <panic.h>
+#include <arch/i8259.h>
+#include <func.h>
+#include <cpu.h>
+#include <arch/asm.h>
+#include <mm/tlb.h>
+#include <arch.h>
+/*
+ * Interrupt and exception dispatching.
+ */
+static iroutine ivt[IVT_ITEMS];
+void (* disable_irqs_function)(__u16 irqmask) = NULL;
+void (* enable_irqs_function)(__u16 irqmask) = NULL;
+void (* eoi_function)(void) = NULL;
+iroutine trap_register(__u8 n, iroutine f)
+{
+    ASSERT(n < IVT_ITEMS);
+    iroutine old;
+    old = ivt[n];
+    ivt[n] = f;
+    return old;
+}
+/*
+ * Called directly from the assembler code.
+ * CPU is cpu_priority_high().
+ */
+void trap_dispatcher(__u8 n, __u32 stack[])
+{
+    ASSERT(n < IVT_ITEMS);
+    ivt[n](n, stack);
+}
+void null_interrupt(__u8 n, __u32 stack[])
+{
+    printf("int %d: null_interrupt\n", n);
+    printf("stack: %L, %L, %L, %L\n", stack[0], stack[1], stack[2], stack[3]);
+    panic("unserviced interrupt\n");
+}
+void gp_fault(__u8 n, __u32 stack[])
+{
+    printf("ERROR_WORD=%X, %%eip=%X, %%cs=%X, flags=%X\n", stack[0], stack[1], stack[2], stack[3]);
+    printf("%%eax=%L, %%ebx=%L, %%ecx=%L, %%edx=%L,\n%%edi=%L, %%esi=%L, %%ebp=%L, %%esp=%L\n", stack[-2], stack[-5], stack[-3], stack[-4], stack[-9], stack[-8], stack[-1], stack);
+    printf("stack: %X, %X, %X, %X\n", stack[4], stack[5], stack[6], stack[7]);
+    panic("general protection fault\n");
+    stack[1]++;
+}
+void ss_fault(__u8 n, __u32 stack[])
+{
+    printf("ERROR_WORD=%X, %%eip=%X, %%cs=%X, flags=%X\n", stack[0], stack[1], stack[2], stack[3]);
+    printf("%%eax=%L, %%ebx=%L, %%ecx=%L, %%edx=%L,\n%%edi=%L, %%esi=%L, %%ebp=%L, %%esp=%L\n", stack[-2], stack[-5], stack[-3], stack[-4], stack[-9], stack[-8], stack[-1], stack);
+    printf("stack: %X, %X, %X, %X\n", stack[4], stack[5], stack[6], stack[7]);
+    panic("stack fault\n");
+}
+void nm_fault(__u8 n, __u32 stack[])
+{
+    reset_TS_flag();
+    if ((CPU->fpu_owner)!=NULL) {
+        fpu_lazy_context_save(&((CPU->fpu_owner)->saved_fpu_context));
+        (CPU->fpu_owner)->fpu_context_engaged=0; /* don't prevent migration */
+    }
+    if(THREAD->fpu_context_exists) fpu_lazy_context_restore(&(THREAD->saved_fpu_context));
+    else {fpu_init();THREAD->fpu_context_exists=1;}
+    CPU->fpu_owner=THREAD;
+}
+void page_fault(__u8 n, __u32 stack[])
+{
+    printf("page fault address: %X\n", read_cr2());
+    printf("ERROR_WORD=%X, %%eip=%X, %%cs=%X, flags=%X\n", stack[0], stack[1], stack[2], stack[3]);
+    printf("%%eax=%L, %%ebx=%L, %%ecx=%L, %%edx=%L,\n%%edi=%L, %%esi=%L, %%ebp=%L, %%esp=%L\n", stack[-2], stack[-5], stack[-3], stack[-4], stack[-9], stack[-8], stack[-1], stack);
+    printf("stack: %X, %X, %X, %X\n", stack[4], stack[5], stack[6], stack[7]);
+    panic("page fault\n");
+}
+void syscall(__u8 n, __u32 stack[])
+{
+    printf("cpu%d: syscall\n", CPU->id);
+    thread_usleep(1000);
+}
+void tlb_shootdown_ipi(__u8 n, __u32 stack[])
+{
+    trap_virtual_eoi();
+    tlb_shootdown_ipi_recv();
+}
+void wakeup_ipi(__u8 n, __u32 stack[])
+{
+    trap_virtual_eoi();
+}
+void trap_virtual_enable_irqs(__u16 irqmask)
+{
+    if (enable_irqs_function)
+        enable_irqs_function(irqmask);
+    else
+        panic("no enable_irqs_function\n");
+}
+void trap_virtual_disable_irqs(__u16 irqmask)
+{
+    if (disable_irqs_function)
+        disable_irqs_function(irqmask);
+    else
+        panic("no disable_irqs_function\n");
+}
+void trap_virtual_eoi(void)
+{
+    if (eoi_function)
+        eoi_function();
+    else
+        panic("no eoi_function\n");
+}

 /SPARTAN/trunk/arch/ia32/src/pm.c
 ,0 → 1,202
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch/pm.h>
+#include <config.h>
+#include <arch/types.h>
+#include <typedefs.h>
+#include <arch/interrupt.h>
+#include <arch/asm.h>
+#include <arch/context.h>
+#include <panic.h>
+#include <arch/mm/page.h>
+/*
+ * Early ia32 configuration functions and data structures.
+ */
+/*
+ * We have no use for segmentation so we set up flat mode. In this
+ * mode, we use, for each privilege level, two segments spanning the
+ * whole memory. One is for code and one is for data.
+ */
+struct descriptor gdt[GDT_ITEMS] = {
+    /* NULL descriptor */
+    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+    /* KTEXT descriptor */
+    { 0xffff, 0, 0, AR_PRESENT | AR_CODE | DPL_KERNEL, 0xf, 0, 0, 1, 1, 0 },
+    /* KDATA descriptor */
+    { 0xffff, 0, 0, AR_PRESENT | AR_DATA | AR_WRITABLE | DPL_KERNEL, 0xf, 0, 0, 1, 1, 0 },
+    /* UTEXT descriptor */
+    { 0xffff, 0, 0, AR_PRESENT | AR_CODE | DPL_USER, 0xf, 0, 0, 1, 1, 0 },
+    /* UDATA descriptor */
+    { 0xffff, 0, 0, AR_PRESENT | AR_DATA | AR_WRITABLE | DPL_USER, 0xf, 0, 0, 1, 1, 0 },
+    /* TSS descriptor - set up will be completed later */
+    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
+};
+static struct idescriptor idt[IDT_ITEMS];
+static struct tss tss;
+struct tss *tss_p = NULL;
+/* gdtr is changed by kmp before next CPU is initialized */
+struct ptr_16_32 gdtr __attribute__ ((section ("K_DATA_START"))) = { .limit = sizeof(gdt), .base = KA2PA((__address) gdt) };
+struct ptr_16_32 idtr __attribute__ ((section ("K_DATA_START"))) = { .limit = sizeof(idt), .base = KA2PA((__address) idt) };
+void gdt_setbase(struct descriptor *d, __address base)
+{
+    d->base_0_15 = base & 0xffff;
+    d->base_16_23 = ((base) >> 16) & 0xff;
+    d->base_24_31 = ((base) >> 24) & 0xff;
+}
+void gdt_setlimit(struct descriptor *d, __u32 limit)
+{
+    d->limit_0_15 = limit & 0xffff;
+    d->limit_16_19 = (limit >> 16) & 0xf;
+}
+void idt_setoffset(struct idescriptor *d, __address offset)
+{
+    /*
+     * Offset is a linear address.
+     */
+    d->offset_0_15 = offset & 0xffff;
+    d->offset_16_31 = offset >> 16;
+}
+void tss_initialize(struct tss *t)
+{
+    memsetb((__address) t, sizeof(struct tss), 0);
+}
+/*
+ * This function takes care of proper setup of IDT and IDTR.
+ */
+void idt_init(void)
+{
+    struct idescriptor *d;
+    int i;
+    for (i = 0; i < IDT_ITEMS; i++) {
+        d = &idt[i];
+        d->unused = 0;
+        d->selector = selector(KTEXT_DES);
+        d->access = AR_PRESENT | AR_INTERRUPT;  /* masking interrupt */
+        if (i == VECTOR_SYSCALL) {
+            /*
+             * The syscall interrupt gate must be calleable from userland.
+             */
+            d->access |= DPL_USER;
+        }
+        idt_setoffset(d, ((__address) interrupt_handlers) + i*interrupt_handler_size);
+        trap_register(i, null_interrupt);
+    }
+    trap_register(13, gp_fault);
+    trap_register( 7, nm_fault);
+    trap_register(12, ss_fault);
+}
+/* Clean IOPL(12,13) and NT(14) flags in EFLAGS register */
+static void clean_IOPL_NT_flags(void)
+{
+    asm
+    (
+        "pushfl;"
+        "pop %%eax;"
+        "and $0xffff8fff,%%eax;"
+        "push %%eax;"
+        "popfl;"
+        :
+        :
+        :"%eax"
+    );
+}
+/* Clean AM(18) flag in CR0 register */
+static void clean_AM_flag(void)
+{
+    asm
+    (
+        "mov %%cr0,%%eax;"
+        "and $0xFFFBFFFF,%%eax;"
+        "mov %%eax,%%cr0;"
+        :
+        :
+        :"%eax"
+    );
+}
+void pm_init(void)
+{
+    struct descriptor *gdt_p = (struct descriptor *) PA2KA(gdtr.base);
+    /*
+     * Each CPU has its private GDT and TSS.
+     * All CPUs share one IDT.
+     */
+    if (config.cpu_active == 1) {
+        idt_init();
+        /*
+         * NOTE: bootstrap CPU has statically allocated TSS, because
+         * the heap hasn't been initialized so far.
+         */
+        tss_p = &tss;
+    }
+    else {
+        tss_p = (struct tss *) malloc(sizeof(struct tss));
+        if (!tss_p)
+            panic("could not allocate TSS\n");
+    }
+    tss_initialize(tss_p);
+    gdt_p[TSS_DES].access = AR_PRESENT | AR_TSS | DPL_KERNEL;
+    gdt_p[TSS_DES].special = 1;
+    gdt_p[TSS_DES].granularity = 1;
+    gdt_setbase(&gdt_p[TSS_DES], (__address) tss_p);
+    gdt_setlimit(&gdt_p[TSS_DES], sizeof(struct tss) - 1);
+    /*
+     * As of this moment, the current CPU has its own GDT pointing
+     * to its own TSS. We just need to load the TR register.
+     */
+    __asm__("ltr %0" : : "r" ((__u16) selector(TSS_DES)));
+    clean_IOPL_NT_flags();    /* Disable I/O on nonprivileged levels */
+    clean_AM_flag();          /* Disable alignment check */
+}

 /SPARTAN/trunk/arch/ia32/src/proc/scheduler.c
 ,0 → 1,38
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <proc/scheduler.h>
+#include <cpu.h>
+#include <proc/thread.h>
+#include <arch.h>
+void before_thread_runs_arch(void)
+{
+    CPU->arch.tss->esp0 = (__address) &THREAD->kstack[THREAD_STACK_SIZE-8];
+    CPU->arch.tss->ss0 = selector(KDATA_DES);
+}

 /SPARTAN/trunk/arch/ia32/src/mm/page.c
 ,0 → 1,79
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch/types.h>
+#include <config.h>
+#include <func.h>
+#include <mm/frame.h>
+#include <mm/page.h>
+#include <arch/mm/page.h>
+#include <arch/interrupt.h>
+#include <arch/asm.h>
+#include <synch/spinlock.h>
+#include <debug.h>
+__address bootstrap_dba;
+void page_arch_init(void)
+{
+    __address dba;
+    __u32 i;
+    if (config.cpu_active == 1) {
+        dba = frame_alloc(FRAME_KA | FRAME_PANIC);
+        memsetb(dba, PAGE_SIZE, 0);
+        bootstrap_dba = dba;
+        /*
+         * Identity mapping for all frames.
+         * PA2KA(identity) mapping for all frames.
+         */
+        for (i = 0; i < frames; i++) {
+            map_page_to_frame(i * PAGE_SIZE, i * PAGE_SIZE, PAGE_CACHEABLE, KA2PA(dba));
+            map_page_to_frame(PA2KA(i * PAGE_SIZE), i * PAGE_SIZE, PAGE_CACHEABLE, KA2PA(dba));
+        }
+        trap_register(14, page_fault);
+        write_cr3(KA2PA(dba));
+    }
+    else {
+        /*
+         * Application processors need to create their own view of the
+         * virtual address space. Because of that, each AP copies
+         * already-initialized paging information from the bootstrap
+         * processor and adjusts it to fulfill its needs.
+         */
+        dba = frame_alloc(FRAME_KA | FRAME_PANIC);
+        memcopy(bootstrap_dba, dba, PAGE_SIZE);
+        write_cr3(KA2PA(dba));
+    }
+    paging_on();
+}

 /SPARTAN/trunk/arch/ia32/src/mm/memory_init.c
 ,0 → 1,38
+/*
+ * Copyright (C) 2005 Josef Cejka
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch/boot/memmap.h>
+#include <arch/mm/memory_init.h>
+size_t get_memory_size(void)
+{
+    return e801memorysize*1024;
+}

 /SPARTAN/trunk/arch/ia32/src/mm/frame.c
 ,0 → 1,57
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <mm/frame.h>
+#include <arch/mm/frame.h>
+#include <mm/vm.h>
+#include <config.h>
+#include <arch/boot/memmap.h>
+#include <print.h>
+/*
+ * TODO: use the memory map obtained from BIOS
+ */
+void frame_arch_init(void)
+{
+    __u8 i;
+    if (config.cpu_active == 1) {
+        frame_not_free(0x0);
+        frame_region_not_free(0xa0000,0xff000);
+        frame_region_not_free(0xfec00000,0xffffffff);
+        for (i=e820counter;i>0;i--) {
+            // printf("E820 base: %Q size: %Q type: %L \n",e820table[i-1].base_address,e820table[i-1].size,e820table[i-1].type);
+            if (e820table[i-1].type!=MEMMAP_MEMORY_AVAILABLE) {
+                frame_region_not_free(e820table[i-1].base_address,e820table[i-1].size);
+                }
+            }
+    }
+}

 /SPARTAN/trunk/arch/ia32/src/mm/tlb.c
 ,0 → 1,35
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <mm/tlb.h>
+#include <arch/asm.h>
+void tlb_invalidate(int asid)
+{
+    write_cr3(read_cr3());
+}

 /SPARTAN/trunk/arch/ia32/src/drivers/ega.c
 ,0 → 1,117
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch/ega.h>
+#include <putchar.h>
+#include <mm/page.h>
+#include <arch/mm/page.h>
+#include <synch/spinlock.h>
+#include <arch/types.h>
+#include <arch/asm.h>
+/*
+ * The EGA driver.
+ * Simple and short. Function for displaying characters and "scrolling".
+ */
+static spinlock_t egalock;
+static __u32 ega_cursor;
+void ega_move_cursor(void);
+void ega_init(void)
+{
+    __u8 hi, lo;
+    map_page_to_frame(PA2KA(VIDEORAM), VIDEORAM, PAGE_NOT_CACHEABLE, 0);
+    outb(0x3d4,0xe);
+    hi = inb(0x3d5);
+    outb(0x3d4,0xf);
+    lo = inb(0x3d5);
+    ega_cursor = (hi<<8)|lo;
+    ega_putchar('\n');
+}
+void ega_display_char(char ch)
+{
+    __u8 *vram = (__u8 *) PA2KA(VIDEORAM);
+    vram[ega_cursor*2] = ch;
+}
+/*
+ * This function takes care of scrolling.
+ */
+void ega_check_cursor(void)
+{
+    if (ega_cursor < SCREEN)
+        return;
+    memcopy(PA2KA(VIDEORAM) + ROW*2, PA2KA(VIDEORAM), (SCREEN - ROW)*2);
+    memsetw(PA2KA(VIDEORAM) + (SCREEN - ROW)*2, ROW, 0x0720);
+    ega_cursor = ega_cursor - ROW;
+}
+void ega_putchar(const char ch)
+{
+    pri_t pri;
+    pri = cpu_priority_high();
+    spinlock_lock(&egalock);
+    switch (ch) {
+        case '\n':
+        ega_cursor = (ega_cursor + ROW) - ega_cursor % ROW;
+        break;
+        case '\t':
+        ega_cursor = (ega_cursor + 8) - ega_cursor % 8;
+        break;
+        default:
+        ega_display_char(ch);
+        ega_cursor++;
+        break;
+        }
+    ega_check_cursor();
+    ega_move_cursor();
+    spinlock_unlock(&egalock);
+    cpu_priority_restore(pri);
+}
+void ega_move_cursor(void)
+{
+    outb(0x3d4,0xe);
+    outb(0x3d5,(ega_cursor>>8)&0xff);
+    outb(0x3d4,0xf);
+    outb(0x3d5,ega_cursor&0xff);
+}
+void putchar(const char ch)
+{
+    ega_putchar(ch);
+}

 /SPARTAN/trunk/arch/ia32/src/drivers/i8259.c
 ,0 → 1,120
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch/i8259.h>
+#include <cpu.h>
+#include <arch/types.h>
+#include <arch/asm.h>
+#include <arch.h>
+/*
+ * This is the PIC driver.
+ * Programmable Interrupt Controller for UP systems.
+ */
+void i8259_init(void)
+{
+    /* ICW1: this is ICW1, ICW4 to follow */
+    outb(PIC_PIC0PORT1, PIC_ICW1 | PIC_NEEDICW4);
+    /* ICW2: IRQ 0 maps to INT IRQBASE */
+    outb(PIC_PIC0PORT2, IVT_IRQBASE);
+    /* ICW3: pic1 using IRQ IRQ_PIC1 */
+    outb(PIC_PIC0PORT2, 1 << IRQ_PIC1);
+    /* ICW4: i8086 mode */
+    outb(PIC_PIC0PORT2, 1);
+    /* ICW1: ICW1, ICW4 to follow */
+    outb(PIC_PIC1PORT1, PIC_ICW1 | PIC_NEEDICW4);
+    /* ICW2: IRQ 8 maps to INT (IVT_IRQBASE + 8) */
+    outb(PIC_PIC1PORT2, IVT_IRQBASE + 8);
+    /* ICW3: pic1 is known as PIC_PIC1ID */
+    outb(PIC_PIC1PORT2, PIC_PIC1ID);
+    /* ICW4: i8086 mode */
+    outb(PIC_PIC1PORT2, 1);
+    /*
+     * Register interrupt handler for the PIC spurious interrupt.
+     */
+    trap_register(VECTOR_PIC_SPUR, pic_spurious);
+    /*
+     * Set the enable/disable IRQs handlers.
+     * Set the End-of-Interrupt handler.
+     */
+    enable_irqs_function = pic_enable_irqs;
+    disable_irqs_function = pic_disable_irqs;
+    eoi_function = pic_eoi;
+    pic_disable_irqs(0xffff);       /* disable all irq's */
+    pic_enable_irqs(1<<IRQ_PIC1);       /* but enable pic1 */
+}
+void pic_enable_irqs(__u16 irqmask)
+{
+    __u8 x;
+    if (irqmask & 0xff) {
+        x = inb(PIC_PIC0PORT2);
+        outb(PIC_PIC0PORT2, x & (~(irqmask & 0xff)));
+    }
+    if (irqmask >> 8) {
+        x = inb(PIC_PIC1PORT2);
+        outb(PIC_PIC1PORT2, x & (~(irqmask >> 8)));
+    }
+}
+void pic_disable_irqs(__u16 irqmask)
+{
+    __u8 x;
+    if (irqmask & 0xff) {
+        x = inb(PIC_PIC0PORT2);
+        outb(PIC_PIC0PORT2, x | (irqmask & 0xff));
+    }
+    if (irqmask >> 8) {
+        x = inb(PIC_PIC1PORT2);
+        outb(PIC_PIC1PORT2, x | (irqmask >> 8));
+    }
+}
+void pic_eoi(void)
+{
+    outb(0x20,0x20);
+    outb(0xa0,0x20);
+}
+void pic_spurious(__u8 n, __u32 stack[])
+{
+    printf("cpu%d: PIC spurious interrupt\n", CPU->id);
+}

 /SPARTAN/trunk/arch/ia32/src/drivers/i8254.c
 ,0 → 1,127
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch/types.h>
+#include <time/clock.h>
+#include <time/delay.h>
+#include <arch/interrupt.h>
+#include <arch/i8259.h>
+#include <arch/i8254.h>
+#include <cpu.h>
+#include <config.h>
+#include <arch/pm.h>
+#include <arch/asm.h>
+#include <arch.h>
+/*
+ * i8254 chip driver.
+ * Low level time functions.
+ */
+#define CLK_PORT1   0x40
+#define CLK_PORT4   0x43
+#define CLK_CONST   1193180
+#define MAGIC_NUMBER    1194
+void i8254_init(void)
+{
+    i8254_normal_operation();
+}
+void i8254_normal_operation(void)
+{
+    outb(CLK_PORT4, 0x36);
+    trap_virtual_disable_irqs(1<<IRQ_CLK);
+    outb(CLK_PORT1, (CLK_CONST/HZ) & 0xf);
+    outb(CLK_PORT1, (CLK_CONST/HZ) >> 8);
+    trap_virtual_enable_irqs(1<<IRQ_CLK);
+    trap_register(VECTOR_CLK, i8254_interrupt);
+}
+#define LOOPS 150000
+#define SHIFT 11
+void i8254_calibrate_delay_loop(void)
+{
+    __u64 clk1, clk2;
+    __u32 t1, t2, o1, o2;
+    __u8 not_ok;
+    /*
+     * One-shot timer. Count-down from 0xffff at 1193180Hz
+     * MAGIC_NUMBER is the magic value for 1ms.
+     */
+    outb(CLK_PORT4, 0x30);
+    outb(CLK_PORT1, 0xff);
+    outb(CLK_PORT1, 0xff);
+    do {
+        /* will read both status and count */
+        outb(CLK_PORT4, 0xc2);
+        not_ok = (inb(CLK_PORT1)>>6)&1;
+        t1 = inb(CLK_PORT1);
+        t1 |= inb(CLK_PORT1) << 8;
+    } while (not_ok);
+    asm_delay_loop(LOOPS);
+    outb(CLK_PORT4, 0xd2);
+    t2 = inb(CLK_PORT1);
+    t2 |= inb(CLK_PORT1) << 8;
+    /*
+     * We want to determine the overhead of the calibrating mechanism.
+     */
+    outb(CLK_PORT4, 0xd2);
+    o1 = inb(CLK_PORT1);
+    o1 |= inb(CLK_PORT1) << 8;
+    asm_fake_loop(LOOPS);
+    outb(CLK_PORT4, 0xd2);
+    o2 = inb(CLK_PORT1);
+    o2 |= inb(CLK_PORT1) << 8;
+    CPU->delay_loop_const = ((MAGIC_NUMBER*LOOPS)/1000) / ((t1-t2)-(o1-o2)) + (((MAGIC_NUMBER*LOOPS)/1000) % ((t1-t2)-(o1-o2)) ? 1 : 0);
+    clk1 = rdtsc();
+    delay(1<<SHIFT);
+    clk2 = rdtsc();
+    CPU->frequency_mhz = (clk2-clk1)>>SHIFT;
+    return;
+}
+void i8254_interrupt(__u8 n, __u32 stack[])
+{
+    trap_virtual_eoi();
+    clock();
+}

 /SPARTAN/trunk/arch/ia32/src/drivers/i8042.c
 ,0 → 1,58
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch/i8042.h>
+#include <arch/i8259.h>
+#include <arch/interrupt.h>
+#include <cpu.h>
+#include <arch/asm.h>
+#include <arch.h>
+#include <print.h>
+/*
+ * i8042 processor driver.
+ * Its very essential function is enabling the A20.
+ */
+void i8042_init(void)
+{
+    /* A20: deadly if not enabled */
+    outb(0x64,0xd1);
+    outb(0x60,0xdf);
+    trap_register(VECTOR_KBD, i8042_interrupt);
+}
+void i8042_interrupt(__u8 n, __u32 stack[])
+{
+    __u8 x;
+    trap_virtual_eoi();
+    x = inb(0x60);
+    printf("%d", CPU->id);;
+}

 /SPARTAN/trunk/arch/ia32/src/boot/memmap.S
 ,0 → 1,125
+/*
+ * Copyright (C) 2005 Josef Cejka
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch/boot/memmapasm.h>
+E820_RECORD_SIZE = MEMMAP_E820_RECORD_SIZE
+E820_MAX_RECORDS = MEMMAP_E820_MAX_RECORDS
+E820_SMAP = 0x534d4150
+.global memmap_arch_init
+.global e820counter
+.global e820table
+.global e801memorysize
+.code16
+.section K_TEXT_START_2
+memmap_arch_init:
+e820begin:
+    xorl    %ebx,%ebx   # during first call, ebx must be 0
+    movw    %bx,%ds
+    movw    %bx,%es
+    movw    $e820table,%di
+    movb    $E820_MAX_RECORDS,e820counter
+e820loop:
+    movl    $E820_SMAP,%edx     # control sequence "SMAP"
+    movl    $0x0000e820,%eax    # service
+    movl    $E820_RECORD_SIZE,%ecx
+    int     $0x15
+    jc  e820err
+    cmpl    $E820_SMAP,%eax     # verifying BIOS
+    jne e820err
+    cmpl    $E820_RECORD_SIZE,%ecx
+    jne e820err         # bad record size - bug in bios
+    movw    %di,%ax     # next record
+    addw    $E820_RECORD_SIZE,%ax
+    movw    %ax,%di
+    decb    e820counter # buffer is full
+    jz  e820end
+    cmpl    $0,%ebx
+    jne e820loop
+e820end:
+    movb    $E820_MAX_RECORDS,%al
+    subb    e820counter,%al
+    movb    %al,e820counter # store # of valid entries in e820counter
+    jmp e801begin
+e820err:
+    movb    $0,e820counter
+# method e801 - get size of memory
+e801begin:
+    xorw    %dx,%dx
+    xorw    %cx,%cx
+    xorw    %bx,%bx
+    movw    $0xe801,%ax
+    stc
+    int $0x15
+    jc  e801end
+            # fix problem with some BIOSes which use ax:bx rather than cx:dx
+    testw   %cx,%cx
+    jnz e801cxdx
+    testw   %dx,%dx
+    jnz e801cxdx
+    movw    %ax,%cx
+    movw    %bx,%dx
+e801cxdx:
+    andl    $0xffff,%edx
+    shll    $6,%edx
+    andl    $0xffff,%ecx
+    addl    %ecx,%edx
+    addl    $0x0400,%edx  # add lower 1 MB - it's not included by e801 method
+    movl    %edx,e801memorysize
+e801end:
+    ret
+    #memory size in 1 kb chunks
+e801memorysize:
+    .long   0
+e820counter:
+    .byte 0xff
+e820table:
+    .space  (32*E820_RECORD_SIZE),0xff # space for 32 records, each E820_RECORD_SIZE bytes long

 /SPARTAN/trunk/arch/ia32/src/boot/boot.S
 ,0 → 1,105
+#
+# Copyright (C) 2001-2004 Jakub Jermar
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+.section K_TEXT_START
+.global kernel_image_start
+.code16
+#
+# This is where we require any SPARTAN-kernel-compatible boot loader
+# to pass control in real mode.
+#
+# Protected mode tables are statically initialised during compile
+# time. So we can just load the respective table registers and
+# switch to protected mode.
+#
+kernel_image_start:
+    call memmap_arch_init
+    cli
+    xorw %ax,%ax
+    movw %ax,%ds
+    lgdt gdtr
+    movl %cr0,%eax
+    orl $0x1,%eax
+    movl %eax,%cr0
+    jmpl $8,$meeting_point
+meeting_point:
+.code32
+    movw $16,%ax
+    movw %ax,%es
+    movw %ax,%gs
+    movw %ax,%fs
+    movw %ax,%ds            # kernel data + stack
+    movw %ax,%ss
+    movl $0x7c00,%esp
+    lidt idtr
+    call map_kernel
+    movl $_hardcoded_ktext_size, hardcoded_ktext_size
+    movl $_hardcoded_kdata_size, hardcoded_kdata_size
+    movl $_hardcoded_load_address, hardcoded_load_address
+    call main_bsp           # never returns
+    cli
+    hlt
+.global map_kernel
+map_kernel:
+    #
+    # Here we setup mapping for both the unmapped and mapped sections of the kernel.
+    # For simplicity, we set only one 4M page for 0x00000000 and one for 0x80000000.
+    #
+    movl %cr4, %ecx
+    orl $(1<<4), %ecx
+    movl %ecx, %cr4             # turn PSE on
+    movl $((1<<7)|(1<<0)), %eax
+    movl %eax, page_directory       # mapping 0x00000000 => 0x00000000
+    movl $(page_directory+(4096/2)), %edx
+    movl %eax, (%edx)           # mapping 0x80000000 => 0x00000000
+    leal page_directory, %eax
+    movl %eax, %cr3
+    # turn on paging
+    movl %cr0, %ebx
+    orl $(1<<31), %ebx
+    movl %ebx, %cr0
+    ret
+.section K_DATA_START
+.align 4096
+page_directory:
+    .space 4096, 0

 /SPARTAN/trunk/arch/ia32/src/userspace.c
 ,0 → 1,66
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <userspace.h>
+#include <arch/pm.h>
+#include <arch/types.h>
+#include <arch.h>
+#include <proc/thread.h>
+#include <mm/vm.h>
+/** Enter userspace
+ *
+ * Change CPU protection level to 3, enter userspace.
+ *
+ */
+void userspace(void)
+{
+    pri_t pri;
+    pri = cpu_priority_high();
+    __asm__ volatile (""
+    /* CLNT */
+        "pushfl;"
+        "pop %%eax;"
+        "and $0xFFFFBFFF,%%eax;"
+        "push %%eax;"
+        "popfl;"
+        "pushl %0\n"
+        "pushl %1\n"
+        "pushl %2\n"
+        "pushl %3\n"
+        "pushl %4\n"
+        "iret"
+        : : "i" (selector(UDATA_DES) | PL_USER), "i" (USTACK_ADDRESS+(THREAD_STACK_SIZE-1)), "r" (pri), "i" (selector(UTEXT_DES) | PL_USER), "i" (UTEXT_ADDRESS));
+    /* Unreachable */
+    for(;;);
+}

 /SPARTAN/trunk/arch/ia32/src/cpu/cpu.c
 ,0 → 1,136
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch/cpu.h>
+#include <arch/cpuid.h>
+#include <arch/pm.h>
+#include <arch.h>
+#include <arch/types.h>
+#include <print.h>
+#include <typedefs.h>
+#include <arch/smp/apic.h>
+/*
+ * Identification of CPUs.
+ * Contains only non-MP-Specification specific SMP code.
+ */
+#define AMD_CPUID_EBX   0x68747541
+#define AMD_CPUID_ECX   0x444d4163
+#define AMD_CPUID_EDX   0x69746e65
+#define INTEL_CPUID_EBX 0x756e6547
+#define INTEL_CPUID_ECX 0x6c65746e
+#define INTEL_CPUID_EDX 0x49656e69
+enum vendor {
+    VendorUnknown=0,
+    VendorAMD,
+    VendorIntel
+};
+static char *vendor_str[] = {
+    "Unknown Vendor",
+    "AuthenticAMD",
+    "GenuineIntel"
+};
+void set_TS_flag(void)
+{
+    asm
+    (
+        "mov %%cr0,%%eax;"
+        "or $8,%%eax;"
+        "mov %%eax,%%cr0;"
+        :
+        :
+        :"%eax"
+    );
+}
+void reset_TS_flag(void)
+{
+    asm
+    (
+        "mov %%cr0,%%eax;"
+        "and $0xffFFffF7,%%eax;"
+        "mov %%eax,%%cr0;"
+        :
+        :
+        :"%eax"
+    );
+}
+void cpu_arch_init(void)
+{
+    CPU->arch.tss = tss_p;
+    CPU->fpu_owner=NULL;
+}
+void cpu_identify(void)
+{
+    cpu_info_t info;
+    int i;
+    CPU->arch.vendor = VendorUnknown;
+    if (has_cpuid()) {
+        cpuid(0, &info);
+        /*
+         * Check for AMD processor.
+         */
+        if (info.cpuid_ebx==AMD_CPUID_EBX && info.cpuid_ecx==AMD_CPUID_ECX && info.cpuid_edx==AMD_CPUID_EDX) {
+            CPU->arch.vendor = VendorAMD;
+        }
+        /*
+         * Check for Intel processor.
+         */
+        if (info.cpuid_ebx==INTEL_CPUID_EBX && info.cpuid_ecx==INTEL_CPUID_ECX && info.cpuid_edx==INTEL_CPUID_EDX) {
+            CPU->arch.vendor = VendorIntel;
+        }
+        cpuid(1, &info);
+        CPU->arch.family = (info.cpuid_eax>>8)&0xf;
+        CPU->arch.model = (info.cpuid_eax>>4)&0xf;
+        CPU->arch.stepping = (info.cpuid_eax>>0)&0xf;
+    }
+}
+void cpu_print_report(cpu_t* m)
+{
+    printf("cpu%d: (%s family=%d model=%d stepping=%d) %dMHz\n",
+        m->id, vendor_str[m->arch.vendor], m->arch.family, m->arch.model, m->arch.stepping,
+        m->frequency_mhz);
+}

 /SPARTAN/trunk/arch/ia32/src/smp/mps.c
 ,0 → 1,427
+/*
+ * Copyright (C) 2001-2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifdef __SMP__
+#include <config.h>
+#include <print.h>
+#include <debug.h>
+#include <arch/smp/mps.h>
+#include <arch/smp/apic.h>
+#include <arch/smp/smp.h>
+#include <func.h>
+#include <arch/types.h>
+#include <typedefs.h>
+#include <cpu.h>
+#include <arch/asm.h>
+#include <arch/bios/bios.h>
+/*
+ * MultiProcessor Specification detection code.
+ */
+#define FS_SIGNATURE    0x5f504d5f
+#define CT_SIGNATURE    0x504d4350
+int mps_fs_check(__u8 *base);
+int mps_ct_check(void);
+int configure_via_ct(void);
+int configure_via_default(__u8 n);
+int ct_processor_entry(struct __processor_entry *pr);
+void ct_bus_entry(struct __bus_entry *bus);
+void ct_io_apic_entry(struct __io_apic_entry *ioa);
+void ct_io_intr_entry(struct __io_intr_entry *iointr);
+void ct_l_intr_entry(struct __l_intr_entry *lintr);
+void ct_extended_entries(void);
+static struct mps_fs *fs;
+static struct mps_ct *ct;
+struct __processor_entry *processor_entries = NULL;
+struct __bus_entry *bus_entries = NULL;
+struct __io_apic_entry *io_apic_entries = NULL;
+struct __io_intr_entry *io_intr_entries = NULL;
+struct __l_intr_entry *l_intr_entries = NULL;
+int processor_entry_cnt = 0;
+int bus_entry_cnt = 0;
+int io_apic_entry_cnt = 0;
+int io_intr_entry_cnt = 0;
+int l_intr_entry_cnt = 0;
+waitq_t ap_completion_wq;
+waitq_t kmp_completion_wq;
+/*
+ * Implementation of IA-32 SMP configuration interface.
+ */
+static count_t get_cpu_count(void);
+static bool is_cpu_enabled(index_t i);
+static bool is_bsp(index_t i);
+static __u8 get_cpu_apic_id(index_t i);
+struct smp_config_operations mps_config_operations = {
+    .cpu_count = get_cpu_count,
+    .cpu_enabled = is_cpu_enabled,
+    .cpu_bootstrap = is_bsp,
+    .cpu_apic_id = get_cpu_apic_id
+};
+count_t get_cpu_count(void)
+{
+    return processor_entry_cnt;
+}
+bool is_cpu_enabled(index_t i)
+{
+    ASSERT(i < processor_entry_cnt);
+    return processor_entries[i].cpu_flags & 0x1;
+}
+bool is_bsp(index_t i)
+{
+    ASSERT(i < processor_entry_cnt);
+    return processor_entries[i].cpu_flags & 0x2;
+}
+__u8 get_cpu_apic_id(index_t i)
+{
+    ASSERT(i < processor_entry_cnt);
+    return processor_entries[i].l_apic_id;
+}
+/*
+ * Used to check the integrity of the MP Floating Structure.
+ */
+int mps_fs_check(__u8 *base)
+{
+    int i;
+    __u8 sum;
+    for (i = 0, sum = 0; i < 16; i++)
+        sum += base[i];
+    return !sum;
+}
+/*
+ * Used to check the integrity of the MP Configuration Table.
+ */
+int mps_ct_check(void)
+{
+    __u8 *base = (__u8 *) ct;
+    __u8 *ext = base + ct->base_table_length;
+    __u8 sum;
+    int i;
+    /* count the checksum for the base table */
+    for (i=0,sum=0; i < ct->base_table_length; i++)
+        sum += base[i];
+    if (sum)
+        return 0;
+    /* count the checksum for the extended table */
+    for (i=0,sum=0; i < ct->ext_table_length; i++)
+        sum += ext[i];
+    return sum == ct->ext_table_checksum;
+}
+void mps_init(void)
+{
+    __u8 *addr[2] = { NULL, (__u8 *) 0xf0000 };
+    int i, j, length[2] = { 1024, 64*1024 };
+    /*
+     * Find MP Floating Pointer Structure
+     * 1a. search first 1K of EBDA
+     * 1b. if EBDA is undefined, search last 1K of base memory
+     *  2. search 64K starting at 0xf0000
+     */
+    addr[0] = (__u8 *) (ebda ? ebda : 639 * 1024);
+    for (i = 0; i < 2; i++) {
+        for (j = 0; j < length[i]; j += 16) {
+            if (*((__u32 *) &addr[i][j]) == FS_SIGNATURE && mps_fs_check(&addr[i][j])) {
+                fs = (struct mps_fs *) &addr[i][j];
+                goto fs_found;
+            }
+        }
+    }
+    return;
+fs_found:
+    printf("%L: MPS Floating Pointer Structure\n", fs);
+    frame_not_free((__address) fs);
+    if (fs->config_type == 0 && fs->configuration_table) {
+        if (fs->mpfib2 >> 7) {
+            printf("%s: PIC mode not supported\n", __FUNCTION__);
+            return;
+        }
+        ct = fs->configuration_table;
+        frame_not_free((__address) ct);
+        config.cpu_count = configure_via_ct();
+    }
+    else
+        config.cpu_count = configure_via_default(fs->config_type);
+    return;
+}
+int configure_via_ct(void)
+{
+    __u8 *cur;
+    int i, cnt;
+    if (ct->signature != CT_SIGNATURE) {
+        printf("%s: bad ct->signature\n", __FUNCTION__);
+        return 1;
+    }
+    if (!mps_ct_check()) {
+        printf("%s: bad ct checksum\n", __FUNCTION__);
+        return 1;
+    }
+    if (ct->oem_table) {
+        printf("%s: ct->oem_table not supported\n", __FUNCTION__);
+        return 1;
+    }
+    l_apic = ct->l_apic;
+    cnt = 0;
+    cur = &ct->base_table[0];
+    for (i=0; i < ct->entry_count; i++) {
+        switch (*cur) {
+            /* Processor entry */
+            case 0:
+                processor_entries = processor_entries ? processor_entries : (struct __processor_entry *) cur;
+                processor_entry_cnt++;
+                cnt += ct_processor_entry((struct __processor_entry *) cur);
+                cur += 20;
+                break;
+            /* Bus entry */
+            case 1:
+                bus_entries = bus_entries ? bus_entries : (struct __bus_entry *) cur;
+                bus_entry_cnt++;
+                ct_bus_entry((struct __bus_entry *) cur);
+                cur += 8;
+                break;
+            /* I/O Apic */
+            case 2:
+                io_apic_entries = io_apic_entries ? io_apic_entries : (struct __io_apic_entry *) cur;
+                io_apic_entry_cnt++;
+                ct_io_apic_entry((struct __io_apic_entry *) cur);
+                cur += 8;
+                break;
+            /* I/O Interrupt Assignment */
+            case 3:
+                io_intr_entries = io_intr_entries ? io_intr_entries : (struct __io_intr_entry *) cur;
+                io_intr_entry_cnt++;
+                ct_io_intr_entry((struct __io_intr_entry *) cur);
+                cur += 8;
+                break;
+            /* Local Interrupt Assignment */
+            case 4:
+                l_intr_entries = l_intr_entries ? l_intr_entries : (struct __l_intr_entry *) cur;
+                l_intr_entry_cnt++;
+                ct_l_intr_entry((struct __l_intr_entry *) cur);
+                cur += 8;
+                break;
+            default:
+                /*
+                 * Something is wrong. Fallback to UP mode.
+                 */
+                printf("%s: ct badness\n", __FUNCTION__);
+                return 1;
+        }
+    }
+    /*
+     * Process extended entries.
+     */
+    ct_extended_entries();
+    return cnt;
+}
+int configure_via_default(__u8 n)
+{
+    /*
+     * Not yet implemented.
+     */
+    printf("%s: not supported\n", __FUNCTION__);
+    return 1;
+}
+int ct_processor_entry(struct __processor_entry *pr)
+{
+    /*
+     * Ignore processors which are not marked enabled.
+     */
+    if ((pr->cpu_flags & (1<<0)) == 0)
+        return 0;
+    apic_id_mask |= (1<<pr->l_apic_id);
+    return 1;
+}
+void ct_bus_entry(struct __bus_entry *bus)
+{
+#ifdef MPSCT_VERBOSE
+    char buf[7];
+    memcopy((__address) bus->bus_type, (__address) buf, 6);
+    buf[6] = 0;
+    printf("bus%d: %s\n", bus->bus_id, buf);
+#endif
+}
+void ct_io_apic_entry(struct __io_apic_entry *ioa)
+{
+    static int io_apic_count = 0;
+    /* this ioapic is marked unusable */
+    if (ioa->io_apic_flags & 1 == 0)
+        return;
+    if (io_apic_count++ > 0) {
+        /*
+         * Multiple IO APIC's are currently not supported.
+         */
+        return;
+    }
+    io_apic = ioa->io_apic;
+}
+//#define MPSCT_VERBOSE
+void ct_io_intr_entry(struct __io_intr_entry *iointr)
+{
+#ifdef MPSCT_VERBOSE
+    switch (iointr->intr_type) {
+        case 0: printf("INT"); break;
+        case 1: printf("NMI"); break;
+        case 2: printf("SMI"); break;
+        case 3: printf("ExtINT"); break;
+    }
+    putchar(',');
+    switch (iointr->poel&3) {
+        case 0: printf("bus-like"); break;
+        case 1: printf("active high"); break;
+        case 2: printf("reserved"); break;
+        case 3: printf("active low"); break;
+    }
+    putchar(',');
+    switch ((iointr->poel>>2)&3) {
+        case 0: printf("bus-like"); break;
+        case 1: printf("edge-triggered"); break;
+        case 2: printf("reserved"); break;
+        case 3: printf("level-triggered"); break;
+    }
+    putchar(',');
+    printf("bus%d,irq%d", iointr->src_bus_id, iointr->src_bus_irq);
+    putchar(',');
+    printf("io_apic%d,pin%d", iointr->dst_io_apic_id, iointr->dst_io_apic_pin);
+    putchar('\n');
+#endif
+}
+void ct_l_intr_entry(struct __l_intr_entry *lintr)
+{
+#ifdef MPSCT_VERBOSE
+    switch (lintr->intr_type) {
+        case 0: printf("INT"); break;
+        case 1: printf("NMI"); break;
+        case 2: printf("SMI"); break;
+        case 3: printf("ExtINT"); break;
+    }
+    putchar(',');
+    switch (lintr->poel&3) {
+        case 0: printf("bus-like"); break;
+        case 1: printf("active high"); break;
+        case 2: printf("reserved"); break;
+        case 3: printf("active low"); break;
+    }
+    putchar(',');
+    switch ((lintr->poel>>2)&3) {
+        case 0: printf("bus-like"); break;
+        case 1: printf("edge-triggered"); break;
+        case 2: printf("reserved"); break;
+        case 3: printf("level-triggered"); break;
+    }
+    putchar(',');
+    printf("bus%d,irq%d", lintr->src_bus_id, lintr->src_bus_irq);
+    putchar(',');
+    printf("l_apic%d,pin%d", lintr->dst_l_apic_id, lintr->dst_l_apic_pin);
+    putchar('\n');
+#endif
+}
+void ct_extended_entries(void)
+{
+    __u8 *ext = (__u8 *) ct + ct->base_table_length;
+    __u8 *cur;
+    for (cur = ext; cur < ext + ct->ext_table_length; cur += cur[CT_EXT_ENTRY_LEN]) {
+        switch (cur[CT_EXT_ENTRY_TYPE]) {
+            default:
+                printf("%L: skipping MP Configuration Table extended entry type %d\n", cur, cur[CT_EXT_ENTRY_TYPE]);
+                break;
+        }
+    }
+}
+int mps_irq_to_pin(int irq)
+{
+    int i;
+    for(i=0;i<io_intr_entry_cnt;i++) {
+        if (io_intr_entries[i].src_bus_irq == irq && io_intr_entries[i].intr_type == 0)
+            return io_intr_entries[i].dst_io_apic_pin;
+    }
+    return -1;
+}
+#endif /* __SMP__ */

 /SPARTAN/trunk/arch/ia32/src/smp/smp.c
 ,0 → 1,164
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <smp/smp.h>
+#include <arch/smp/smp.h>
+#include <arch/smp/mps.h>
+#include <arch/smp/ap.h>
+#include <arch/acpi/acpi.h>
+#include <arch/acpi/madt.h>
+#include <config.h>
+#include <synch/waitq.h>
+#include <arch/pm.h>
+#include <func.h>
+#include <panic.h>
+#include <debug.h>
+#include <arch/asm.h>
+#include <mm/frame.h>
+#include <mm/page.h>
+#include <mm/heap.h>
+#ifdef __SMP__
+static struct smp_config_operations *ops = NULL;
+void smp_init(void)
+{
+    if (acpi_madt) {
+        acpi_madt_parse();
+        ops = &madt_config_operations;
+    }
+    if (config.cpu_count == 1) {
+        mps_init();
+        ops = &mps_config_operations;
+    }
+    if (config.cpu_count > 1) {
+        map_page_to_frame((__address) l_apic, (__address) l_apic, PAGE_NOT_CACHEABLE, 0);
+        map_page_to_frame((__address) io_apic, (__address) io_apic, PAGE_NOT_CACHEABLE, 0);
+        }
+        /*
+         * Must be initialized outside the kmp thread, since it is waited
+         * on before the kmp thread is created.
+         */
+        waitq_initialize(&kmp_completion_wq);
+}
+/*
+ * Kernel thread for bringing up application processors. It becomes clear
+ * that we need an arrangement like this (AP's being initialized by a kernel
+ * thread), for a thread has its dedicated stack. (The stack used during the
+ * BSP initialization (prior the very first call to scheduler()) will be used
+ * as an initialization stack for each AP.)
+ */
+void kmp(void *arg)
+{
+    __address src, dst;
+    int i;
+    ASSERT(ops != NULL);
+    waitq_initialize(&ap_completion_wq);
+    /*
+     * We need to access data in frame 0.
+     * We boldly make use of kernel address space mapping.
+     */
+    /*
+     * Set the warm-reset vector to the real-mode address of 4K-aligned ap_boot()
+     */
+    *((__u16 *) (PA2KA(0x467+0))) =  ((__address) ap_boot) >> 4;    /* segment */
+    *((__u16 *) (PA2KA(0x467+2))) =  0;             /* offset */
+    /*
+     * Save 0xa to address 0xf of the CMOS RAM.
+     * BIOS will not do the POST after the INIT signal.
+     */
+    outb(0x70,0xf);
+    outb(0x71,0xa);
+    cpu_priority_high();
+    pic_disable_irqs(0xffff);
+    apic_init();
+    for (i = 0; i < ops->cpu_count(); i++) {
+        struct descriptor *gdt_new;
+        /*
+         * Skip processors marked unusable.
+         */
+        if (!ops->cpu_enabled(i))
+            continue;
+        /*
+         * The bootstrap processor is already up.
+         */
+        if (ops->cpu_bootstrap(i))
+            continue;
+        if (ops->cpu_apic_id(i) == l_apic_id()) {
+            printf("kmp: bad processor entry #%d, will not send IPI to myself\n", i);
+            continue;
+        }
+        /*
+         * Prepare new GDT for CPU in question.
+         */
+        if (!(gdt_new = (struct descriptor *) malloc(GDT_ITEMS*sizeof(struct descriptor))))
+            panic("couldn't allocate memory for GDT\n");
+        memcopy(gdt, gdt_new, GDT_ITEMS*sizeof(struct descriptor));
+        memsetb(&gdt_new[TSS_DES], sizeof(struct descriptor), 0);
+        gdtr.base = KA2PA((__address) gdt_new);
+        if (l_apic_send_init_ipi(ops->cpu_apic_id(i))) {
+            /*
+                 * There may be just one AP being initialized at
+             * the time. After it comes completely up, it is
+             * supposed to wake us up.
+                 */
+            waitq_sleep(&ap_completion_wq);
+            cpu_priority_high();
+        }
+        else {
+            printf("INIT IPI for l_apic%d failed\n", ops->cpu_apic_id(i));
+        }
+    }
+    /*
+     * Wakeup the kinit thread so that
+     * system initialization can go on.
+     */
+    waitq_wakeup(&kmp_completion_wq, WAKEUP_FIRST);
+}
+#endif /* __SMP__ */

 /SPARTAN/trunk/arch/ia32/src/smp/apic.c
 ,0 → 1,417
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch/types.h>
+#include <arch/smp/apic.h>
+#include <arch/smp/ap.h>
+#include <arch/smp/mps.h>
+#include <mm/page.h>
+#include <time/delay.h>
+#include <arch/interrupt.h>
+#include <print.h>
+#include <arch/asm.h>
+#include <arch.h>
+#ifdef __SMP__
+/*
+ * This is functional, far-from-general-enough interface to the APIC.
+ * Advanced Programmable Interrupt Controller for MP systems.
+ * Tested on:
+ *  Bochs 2.0.2 - Bochs 2.2 with 2-8 CPUs
+ *  Simics 2.0.28 - Simics 2.2.14 2-4 CPUs
+ *  ASUS P/I-P65UP5 + ASUS C-P55T2D REV. 1.41 with 2x 200Mhz Pentium CPUs
+ */
+/*
+ * These variables either stay configured as initilalized, or are changed by
+ * the MP configuration code.
+ *
+ * Pay special attention to the volatile keyword. Without it, gcc -O2 would
+ * optimize the code too much and accesses to l_apic and io_apic, that must
+ * always be 32-bit, would use byte oriented instructions.
+ */
+volatile __u32 *l_apic = (__u32 *) 0xfee00000;
+volatile __u32 *io_apic = (__u32 *) 0xfec00000;
+__u32 apic_id_mask = 0;
+int apic_poll_errors(void);
+void apic_init(void)
+{
+    __u32 tmp, id, i;
+    trap_register(VECTOR_APIC_SPUR, apic_spurious);
+    enable_irqs_function = io_apic_enable_irqs;
+    disable_irqs_function = io_apic_disable_irqs;
+    eoi_function = l_apic_eoi;
+    /*
+     * Configure interrupt routing.
+     * IRQ 0 remains masked as the time signal is generated by l_apic's themselves.
+     * Other interrupts will be forwarded to the lowest priority CPU.
+     */
+    io_apic_disable_irqs(0xffff);
+    trap_register(VECTOR_CLK, l_apic_timer_interrupt);
+    for (i=1; i<16; i++) {
+        int pin;
+        if ((pin = mps_irq_to_pin(i)) != -1)
+        io_apic_change_ioredtbl(pin,0xf,IVT_IRQBASE+i,LOPRI);
+    }
+    /*
+     * Ensure that io_apic has unique ID.
+     */
+    tmp = io_apic_read(IOAPICID);
+    id = (tmp >> 24) & 0xf;
+    if ((1<<id) & apic_id_mask) {
+        int i;
+        for (i=0; i<15; i++) {
+            if (!((1<<i) & apic_id_mask)) {
+                io_apic_write(IOAPICID, (tmp & (~(0xf<<24))) | (i<<24));
+                break;
+            }
+        }
+    }
+    /*
+     * Configure the BSP's lapic.
+     */
+    l_apic_init();
+    l_apic_debug();
+}
+void apic_spurious(__u8 n, __u32 stack[])
+{
+    printf("cpu%d: APIC spurious interrupt\n", CPU->id);
+}
+int apic_poll_errors(void)
+{
+    __u32 esr;
+    esr = l_apic[ESR] & ~ESRClear;
+    if ((esr>>0) & 1)
+        printf("Send CS Error\n");
+    if ((esr>>1) & 1)
+        printf("Receive CS Error\n");
+    if ((esr>>2) & 1)
+        printf("Send Accept Error\n");
+    if ((esr>>3) & 1)
+        printf("Receive Accept Error\n");
+    if ((esr>>5) & 1)
+        printf("Send Illegal Vector\n");
+    if ((esr>>6) & 1)
+        printf("Received Illegal Vector\n");
+    if ((esr>>7) & 1)
+        printf("Illegal Register Address\n");
+    return !esr;
+}
+/*
+ * Send all CPUs excluding CPU IPI vector.
+ */
+int l_apic_broadcast_custom_ipi(__u8 vector)
+{
+    __u32 lo;
+    /*
+     * Read the ICR register in and zero all non-reserved fields.
+     */
+    lo = l_apic[ICRlo] & ICRloClear;
+    lo |= DLVRMODE_FIXED | DESTMODE_LOGIC | LEVEL_ASSERT | SHORTHAND_EXCL | TRGRMODE_LEVEL | vector;
+    l_apic[ICRlo] = lo;
+    lo = l_apic[ICRlo] & ICRloClear;
+    if (lo & SEND_PENDING)
+        printf("IPI is pending.\n");
+    return apic_poll_errors();
+}
+/*
+ * Universal Start-up Algorithm for bringing up the AP processors.
+ */
+int l_apic_send_init_ipi(__u8 apicid)
+{
+    __u32 lo, hi;
+    int i;
+    /*
+     * Read the ICR register in and zero all non-reserved fields.
+     */
+    lo = l_apic[ICRlo] & ICRloClear;
+    hi = l_apic[ICRhi] & ICRhiClear;
+    lo |= DLVRMODE_INIT | DESTMODE_PHYS | LEVEL_ASSERT | SHORTHAND_DEST | TRGRMODE_LEVEL;
+    hi |= apicid << 24;
+    l_apic[ICRhi] = hi;
+    l_apic[ICRlo] = lo;
+    /*
+     * According to MP Specification, 20us should be enough to
+     * deliver the IPI.
+     */
+    delay(20);
+    if (!apic_poll_errors()) return 0;
+    lo = l_apic[ICRlo] & ICRloClear;
+    if (lo & SEND_PENDING)
+        printf("IPI is pending.\n");
+    l_apic[ICRlo] = lo | DLVRMODE_INIT | DESTMODE_PHYS | LEVEL_DEASSERT | SHORTHAND_DEST | TRGRMODE_LEVEL;
+    /*
+     * Wait 10ms as MP Specification specifies.
+     */
+    delay(10000);
+    if (!is_82489DX_apic(l_apic[LAVR])) {
+        /*
+         * If this is not 82489DX-based l_apic we must send two STARTUP IPI's.
+         */
+        for (i = 0; i<2; i++) {
+            lo = l_apic[ICRlo] & ICRloClear;
+            lo |= ((__address) ap_boot) / 4096; /* calculate the reset vector */
+            l_apic[ICRlo] = lo | DLVRMODE_STUP | DESTMODE_PHYS | LEVEL_ASSERT | SHORTHAND_DEST | TRGRMODE_LEVEL;
+            delay(200);
+        }
+    }
+    return apic_poll_errors();
+}
+void l_apic_init(void)
+{
+    __u32 tmp, t1, t2;
+    l_apic[LVT_Err] |= (1<<16);
+    l_apic[LVT_LINT0] |= (1<<16);
+    l_apic[LVT_LINT1] |= (1<<16);
+    tmp = l_apic[SVR] & SVRClear;
+    l_apic[SVR] = tmp | (1<<8) | (VECTOR_APIC_SPUR);
+    l_apic[TPR] &= TPRClear;
+    if (CPU->arch.family >= 6)
+        enable_l_apic_in_msr();
+    tmp = l_apic[ICRlo] & ICRloClear;
+    l_apic[ICRlo] = tmp | DLVRMODE_INIT | DESTMODE_PHYS | LEVEL_DEASSERT | SHORTHAND_INCL | TRGRMODE_LEVEL;
+    /*
+     * Program the timer for periodic mode and respective vector.
+     */
+    l_apic[TDCR] &= TDCRClear;
+    l_apic[TDCR] |= 0xb;
+    tmp = l_apic[LVT_Tm] | (1<<17) | (VECTOR_CLK);
+    l_apic[LVT_Tm] = tmp & ~(1<<16);
+    t1 = l_apic[CCRT];
+    l_apic[ICRT] = 0xffffffff;
+    while (l_apic[CCRT] == t1)
+        ;
+    t1 = l_apic[CCRT];
+    delay(1000);
+    t2 = l_apic[CCRT];
+    l_apic[ICRT] = t1-t2;
+}
+void l_apic_eoi(void)
+{
+    l_apic[EOI] = 0;
+}
+void l_apic_debug(void)
+{
+#ifdef LAPIC_VERBOSE
+    int i, lint;
+    printf("LVT on cpu%d, LAPIC ID: %d\n", CPU->id, l_apic_id());
+    printf("LVT_Tm: ");
+    if (l_apic[LVT_Tm] & (1<<17)) printf("periodic"); else printf("one-shot"); putchar(',');
+    if (l_apic[LVT_Tm] & (1<<16)) printf("masked"); else printf("not masked"); putchar(',');
+    if (l_apic[LVT_Tm] & (1<<12)) printf("send pending"); else printf("idle"); putchar(',');
+    printf("%B\n", l_apic[LVT_Tm] & 0xff);
+    for (i=0; i<2; i++) {
+        lint = i ? LVT_LINT1 : LVT_LINT0;
+        printf("LVT_LINT%d: ", i);
+        if (l_apic[lint] & (1<<16)) printf("masked"); else printf("not masked"); putchar(',');
+        if (l_apic[lint] & (1<<15)) printf("level"); else printf("edge"); putchar(',');
+        printf("%d", l_apic[lint] & (1<<14)); putchar(',');
+        printf("%d", l_apic[lint] & (1<<13)); putchar(',');
+        if (l_apic[lint] & (1<<12)) printf("send pending"); else printf("idle"); putchar(',');
+        switch ((l_apic[lint]>>8)&7) {
+            case 0: printf("fixed"); break;
+            case 4: printf("NMI"); break;
+            case 7: printf("ExtINT"); break;
+        }
+        putchar(',');
+        printf("%B\n", l_apic[lint] & 0xff);
+    }
+    printf("LVT_Err: ");
+    if (l_apic[LVT_Err] & (1<<16)) printf("masked"); else printf("not masked"); putchar(',');
+    if (l_apic[LVT_Err] & (1<<12)) printf("send pending"); else printf("idle"); putchar(',');
+    printf("%B\n", l_apic[LVT_Err] & 0xff);
+    /*
+     * This register is supported only on P6 and higher.
+     */
+    if (CPU->arch.family > 5) {
+        printf("LVT_PCINT: ");
+        if (l_apic[LVT_PCINT] & (1<<16)) printf("masked"); else printf("not masked"); putchar(',');
+        if (l_apic[LVT_PCINT] & (1<<12)) printf("send pending"); else printf("idle"); putchar(',');
+        switch ((l_apic[LVT_PCINT] >> 8)&7) {
+            case 0: printf("fixed"); break;
+            case 4: printf("NMI"); break;
+            case 7: printf("ExtINT"); break;
+        }
+        putchar(',');
+        printf("%B\n", l_apic[LVT_PCINT] & 0xff);
+    }
+#endif
+}
+void l_apic_timer_interrupt(__u8 n, __u32 stack[])
+{
+    l_apic_eoi();
+    clock();
+}
+__u8 l_apic_id(void)
+{
+    return (l_apic[L_APIC_ID] >> L_APIC_IDShift)&L_APIC_IDMask;
+}
+__u32 io_apic_read(__u8 address)
+{
+    __u32 tmp;
+    tmp = io_apic[IOREGSEL] & ~0xf;
+    io_apic[IOREGSEL] = tmp | address;
+    return io_apic[IOWIN];
+}
+void io_apic_write(__u8 address, __u32 x)
+{
+    __u32 tmp;
+    tmp = io_apic[IOREGSEL] & ~0xf;
+    io_apic[IOREGSEL] = tmp | address;
+    io_apic[IOWIN] = x;
+}
+void io_apic_change_ioredtbl(int signal, int dest, __u8 v, int flags)
+{
+    __u32 reglo, reghi;
+    int dlvr = 0;
+    if (flags & LOPRI)
+        dlvr = 1;
+    reglo = io_apic_read(IOREDTBL + signal*2);
+    reghi = io_apic_read(IOREDTBL + signal*2 + 1);
+    reghi &= ~0x0f000000;
+    reghi |= (dest<<24);
+    reglo &= (~0x1ffff) | (1<<16); /* don't touch the mask */
+    reglo |= (0<<15) | (0<<13) | (0<<11) | (dlvr<<8) | v;
+    io_apic_write(IOREDTBL + signal*2, reglo);
+    io_apic_write(IOREDTBL + signal*2 + 1, reghi);
+}
+void io_apic_disable_irqs(__u16 irqmask)
+{
+    int i,pin;
+    __u32 reglo;
+    for (i=0;i<16;i++) {
+        if ((irqmask>>i) & 1) {
+            /*
+             * Mask the signal input in IO APIC if there is a
+             * mapping for the respective IRQ number.
+             */
+            pin = mps_irq_to_pin(i);
+            if (pin != -1) {
+                reglo = io_apic_read(IOREDTBL + pin*2);
+                reglo |= (1<<16);
+                io_apic_write(IOREDTBL + pin*2,reglo);
+            }
+        }
+    }
+}
+void io_apic_enable_irqs(__u16 irqmask)
+{
+    int i,pin;
+    __u32 reglo;
+    for (i=0;i<16;i++) {
+        if ((irqmask>>i) & 1) {
+            /*
+             * Unmask the signal input in IO APIC if there is a
+             * mapping for the respective IRQ number.
+             */
+            pin = mps_irq_to_pin(i);
+            if (pin != -1) {
+                reglo = io_apic_read(IOREDTBL + pin*2);
+                reglo &= ~(1<<16);
+                io_apic_write(IOREDTBL + pin*2,reglo);
+            }
+        }
+    }
+}
+#endif /* __SMP__ */

 /SPARTAN/trunk/arch/ia32/src/smp/ap.S
 ,0 → 1,74
+#
+# Copyright (C) 2001-2004 Jakub Jermar
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+#
+# Init code for application processors.
+#
+.section K_TEXT_START_2
+#ifdef __SMP__
+.global ap_boot
+KTEXT=8
+KDATA=16
+# This piece of code is real-mode and is meant to be alligned at 4K boundary.
+# The requirement for such an alignment comes from MP Specification's STARTUP IPI
+# requirements.
+.align 4096
+ap_boot:
+.code16
+    cli
+    xorw %ax,%ax
+    movw %ax,%ds
+    lgdt gdtr
+    movl %cr0,%eax
+    orl $1,%eax
+    movl %eax,%cr0
+    jmpl $KTEXT,$jump_to_kernel
+jump_to_kernel:
+.code32
+    movw $KDATA,%ax
+    movw %ax,%ds
+    movw %ax,%es
+    movw %ax,%ss
+    movl $(ctx-0x80000000),%eax # KA2PA((__address) &ctx)
+    movl (%eax),%esp
+    subl $0x80000000,%esp       # KA2PA(ctx.sp)
+    lidt idtr
+    call map_kernel
+    jmpl $KTEXT,$main_ap
+#endif /* __SMP__ */

 /SPARTAN/trunk/arch/ia32/src/smp/ipi.c
 ,0 → 1,39
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifdef __SMP__
+#include <smp/ipi.h>
+#include <arch/smp/apic.h>
+void ipi_broadcast_arch(int ipi)
+{
+    (void) l_apic_broadcast_custom_ipi((__u8) ipi);
+}
+#endif /* __SMP__ */

 /SPARTAN/trunk/arch/ia32/src/acpi/madt.c
 ,0 → 1,187
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch/types.h>
+#include <typedefs.h>
+#include <arch/acpi/acpi.h>
+#include <arch/acpi/madt.h>
+#include <arch/smp/apic.h>
+#include <arch/smp/smp.h>
+#include <panic.h>
+#include <debug.h>
+#include <config.h>
+struct acpi_madt *acpi_madt = NULL;
+#ifdef __SMP__
+/*
+ * NOTE: it is currently not completely clear to the authors of SPARTAN whether
+ * MADT can exist in such a form that entries of the same type are not consecutive.
+ * Because of this uncertainity, some entry types are explicitly checked for
+ * being consecutive with other entries of the same kind.
+ */
+static void madt_l_apic_entry(struct madt_l_apic *la, __u8 prev_type);
+static void madt_io_apic_entry(struct madt_io_apic *ioa, __u8 prev_type);
+struct madt_l_apic *madt_l_apic_entries = NULL;
+struct madt_io_apic *madt_io_apic_entries = NULL;
+int madt_l_apic_entry_cnt = 0;
+int madt_io_apic_entry_cnt = 0;
+char *entry[] = {
+    "L_APIC",
+    "IO_APIC",
+    "INTR_SRC_OVRD",
+    "NMI_SRC",
+    "L_APIC_NMI",
+    "L_APIC_ADDR_OVRD",
+    "IO_SAPIC",
+    "L_SAPIC",
+    "PLATFORM_INTR_SRC"
+};
+/*
+ * ACPI MADT Implementation of SMP configuration interface.
+ */
+static count_t madt_cpu_count(void);
+static bool madt_cpu_enabled(index_t i);
+static bool madt_cpu_bootstrap(index_t i);
+static __u8 madt_cpu_apic_id(index_t i);
+struct smp_config_operations madt_config_operations = {
+    .cpu_count = madt_cpu_count,
+    .cpu_enabled = madt_cpu_enabled,
+    .cpu_bootstrap = madt_cpu_bootstrap,
+    .cpu_apic_id = madt_cpu_apic_id
+};
+static count_t madt_cpu_count(void)
+{
+    return madt_l_apic_entry_cnt;
+}
+static bool madt_cpu_enabled(index_t i)
+{
+    ASSERT(i < madt_l_apic_entry_cnt);
+    return madt_l_apic_entries[i].flags & 0x1;
+}
+static bool madt_cpu_bootstrap(index_t i)
+{
+    ASSERT(i < madt_l_apic_entry_cnt);
+    return madt_l_apic_entries[i].apic_id == l_apic_id();
+}
+static __u8 madt_cpu_apic_id(index_t i)
+{
+    ASSERT(i < madt_l_apic_entry_cnt);
+    return madt_l_apic_entries[i].apic_id;
+}
+void acpi_madt_parse(void)
+{
+    struct madt_apic_header *end = (struct madt_apic_header *) (((__u8 *) acpi_madt) + acpi_madt->header.length);
+    struct madt_apic_header *h = &acpi_madt->apic_header[0];
+    __u8 prev_type = 0; /* used to detect inconsecutive entries */
+    l_apic = (__u32 *) acpi_madt->l_apic_address;
+    while (h < end) {
+        switch (h->type) {
+            case MADT_L_APIC:
+                madt_l_apic_entry((struct madt_l_apic *) h, prev_type);
+                break;
+            case MADT_IO_APIC:
+                madt_io_apic_entry((struct madt_io_apic *) h, prev_type);
+                break;
+            case MADT_INTR_SRC_OVRD:
+            case MADT_NMI_SRC:
+            case MADT_L_APIC_NMI:
+            case MADT_L_APIC_ADDR_OVRD:
+            case MADT_IO_SAPIC:
+            case MADT_L_SAPIC:
+            case MADT_PLATFORM_INTR_SRC:
+                printf("MADT: skipping %s entry (type=%d)\n", entry[h->type], h->type);
+                break;
+            default:
+                if (h->type >= MADT_RESERVED_SKIP_BEGIN && h->type <= MADT_RESERVED_SKIP_END) {
+                    printf("MADT: skipping reserved entry (type=%d)\n", h->type);
+                }
+                if (h->type >= MADT_RESERVED_OEM_BEGIN) {
+                    printf("MADT: skipping OEM entry (type=%d)\n", h->type);
+                }
+                break;
+        }
+        prev_type = h->type;
+        h = (struct madt_apic_header *) (((__u8 *) h) + h->length);
+    }
+    if (madt_l_apic_entry_cnt)
+        config.cpu_count = madt_l_apic_entry_cnt;
+}
+void madt_l_apic_entry(struct madt_l_apic *la, __u8 prev_type)
+{
+    /* check for consecutiveness */
+    if (madt_l_apic_entry_cnt && prev_type != MADT_L_APIC)
+    panic("%s entries are not consecuitve\n", entry[MADT_L_APIC]);
+    if (!madt_l_apic_entry_cnt++)
+        madt_l_apic_entries = la;
+    if (!(la->flags & 0x1)) {
+        /* Processor is unusable, skip it. */
+        return;
+    }
+    apic_id_mask |= 1<<la->apic_id;
+}
+void madt_io_apic_entry(struct madt_io_apic *ioa, __u8 prev_type)
+{
+    /* check for consecutiveness */
+    if (madt_io_apic_entry_cnt && prev_type != MADT_IO_APIC)
+    panic("%s entries are not consecuitve\n", entry[MADT_IO_APIC]);
+    if (!madt_io_apic_entry_cnt++) {
+        madt_io_apic_entries = ioa;
+        io_apic = (__u32 *) ioa->io_apic_address;
+    }
+    else {
+        /* currently not supported */
+        return;
+    }
+}
+#endif /* __SMP__ */

 /SPARTAN/trunk/arch/ia32/src/acpi/acpi.c
 ,0 → 1,173
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch/acpi/acpi.h>
+#include <arch/acpi/madt.h>
+#include <arch/bios/bios.h>
+#include <mm/page.h>
+#define RSDP_SIGNATURE      "RSD PTR "
+#define RSDP_REVISION_OFFS  15
+struct acpi_rsdp *acpi_rsdp = NULL;
+struct acpi_rsdt *acpi_rsdt = NULL;
+struct acpi_xsdt *acpi_xsdt = NULL;
+struct acpi_signature_map signature_map[] = {
+    { "APIC", (struct acpi_sdt_header **) &acpi_madt, "Multiple APIC Description Table" }
+};
+int rsdp_check(__u8 *rsdp) {
+    struct acpi_rsdp *r = (struct acpi_rsdp *) rsdp;
+    __u8 sum = 0;
+    int i;
+    for (i=0; i<20; i++)
+        sum += rsdp[i];
+    if (sum)
+        return 0; /* bad checksum */
+    if (r->revision == 0)
+        return 1; /* ACPI 1.0 */
+    for (; i<r->length; i++)
+        sum += rsdp[i];
+    return !sum;
+}
+int acpi_sdt_check(__u8 *sdt)
+{
+    struct acpi_sdt_header *h = (struct acpi_sdt_header *) sdt;
+    __u8 sum = 0;
+    int i;
+    for (i=0; i<h->length; i++)
+        sum += sdt[i];
+    return !sum;
+}
+void map_sdt(struct acpi_sdt_header *sdt)
+{
+    map_page_to_frame((__address) sdt, (__address) sdt, PAGE_NOT_CACHEABLE, 0);
+    map_structure((__address) sdt, sdt->length);
+}
+void acpi_init(void)
+{
+    __u8 *addr[2] = { NULL, (__u8 *) 0xe0000 };
+    int i, j, length[2] = { 1024, 128*1024 };
+    __u64 *sig = (__u64 *) RSDP_SIGNATURE;
+    /*
+     * Find Root System Description Pointer
+     * 1. search first 1K of EBDA
+     * 2. search 128K starting at 0xe0000
+     */
+    addr[0] = (__u8 *) ebda;
+    for (i = (ebda ? 0 : 1); i < 2; i++) {
+        for (j = 0; j < length[i]; j += 16) {
+            if (*((__u64 *) &addr[i][j]) == *sig && rsdp_check(&addr[i][j])) {
+                acpi_rsdp = (struct acpi_rsdp *) &addr[i][j];
+                goto rsdp_found;
+            }
+        }
+    }
+    return;
+rsdp_found:
+    printf("%L: ACPI Root System Description Pointer\n", acpi_rsdp);
+    acpi_rsdt = (struct acpi_rsdt *) acpi_rsdp->rsdt_address;
+    if (acpi_rsdp->revision) acpi_xsdt = (struct acpi_xsdt *) ((__address) acpi_rsdp->xsdt_address);
+    if (acpi_rsdt) map_sdt((struct acpi_sdt_header *) acpi_rsdt);
+    if (acpi_xsdt) map_sdt((struct acpi_sdt_header *) acpi_xsdt);
+    if (acpi_rsdt && !acpi_sdt_check((__u8 *) acpi_rsdt)) {
+        printf("RSDT: %s\n", "bad checksum");
+        return;
+    }
+    if (acpi_xsdt && !acpi_sdt_check((__u8 *) acpi_xsdt)) {
+        printf("XSDT: %s\n", "bad checksum");
+        return;
+    }
+    if (acpi_xsdt) configure_via_xsdt();
+    else if (acpi_rsdt) configure_via_rsdt();
+}
+void configure_via_rsdt(void)
+{
+    int i, j, cnt = (acpi_rsdt->header.length - sizeof(struct acpi_sdt_header))/sizeof(__u32);
+    for (i=0; i<cnt; i++) {
+        for (j=0; j<sizeof(signature_map)/sizeof(struct acpi_signature_map); j++) {
+            struct acpi_sdt_header *h = (struct acpi_sdt_header *) acpi_rsdt->entry[i];
+            map_sdt(h);
+            if (*((__u32 *) &h->signature[0])==*((__u32 *) &signature_map[j].signature[0])) {
+                if (!acpi_sdt_check((__u8 *) h))
+                    goto next;
+                *signature_map[j].sdt_ptr = h;
+                printf("%L: ACPI %s\n", *signature_map[j].sdt_ptr, signature_map[j].description);
+            }
+        }
+next:
+        ;
+    }
+}
+void configure_via_xsdt(void)
+{
+    int i, j, cnt = (acpi_xsdt->header.length - sizeof(struct acpi_sdt_header))/sizeof(__u64);
+    for (i=0; i<cnt; i++) {
+        for (j=0; j<sizeof(signature_map)/sizeof(struct acpi_signature_map); j++) {
+            struct acpi_sdt_header *h = (struct acpi_sdt_header *) ((__address) acpi_rsdt->entry[i]);
+            map_sdt(h);
+            if (*((__u32 *) &h->signature[0])==*((__u32 *) &signature_map[j].signature[0])) {
+                if (!acpi_sdt_check((__u8 *) h))
+                    goto next;
+                *signature_map[j].sdt_ptr = h;
+                printf("%L: ACPI %s\n", *signature_map[j].sdt_ptr, signature_map[j].description);
+            }
+        }
+next:
+        ;
+    }
+}

 /SPARTAN/trunk/arch/ia32/src/ia32.c
 ,0 → 1,90
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch.h>
+#include <arch/types.h>
+#include <typedefs.h>
+#include <arch/pm.h>
+#include <arch/ega.h>
+#include <arch/i8042.h>
+#include <arch/i8254.h>
+#include <arch/i8259.h>
+#include <arch/context.h>
+#include <config.h>
+#include <arch/interrupt.h>
+#include <arch/asm.h>
+#include <arch/acpi/acpi.h>
+void arch_pre_mm_init(void)
+{
+    pm_init();
+    write_dr0(config.cpu_active - 1);
+    if (config.cpu_active == 1) {
+        bios_init();
+        i8042_init();   /* a20 bit */
+        i8259_init();   /* PIC */
+        i8254_init();   /* hard clock */
+        trap_register(VECTOR_SYSCALL, syscall);
+        #ifdef __SMP__
+        trap_register(VECTOR_TLB_SHOOTDOWN_IPI, tlb_shootdown_ipi);
+        trap_register(VECTOR_WAKEUP_IPI, wakeup_ipi);
+        #endif /* __SMP__ */
+    }
+}
+void arch_post_mm_init(void)
+{
+    if (config.cpu_active == 1) {
+        ega_init(); /* video */
+    }
+}
+void arch_late_init(void)
+{
+    if (config.cpu_active == 1) {
+        #ifdef __SMP__
+        acpi_init();
+        #endif /* __SMP__ */
+    }
+}
+void calibrate_delay_loop(void)
+{
+    i8254_calibrate_delay_loop();
+    i8254_normal_operation();
+}

 /SPARTAN/trunk/arch/ia32/src/fpu_context.c
 ,0 → 1,83
+/*
+ * Copyright (C) 2005 Jakub Vana
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#include <fpu_context.h>
+#include <arch.h>
+#include <cpu.h>
+void fpu_context_save(fpu_context_t *fctx)
+{
+}
+void fpu_context_restore(fpu_context_t *fctx)
+{
+    if(THREAD==CPU->fpu_owner) {reset_TS_flag(); }
+    else
+    {
+        set_TS_flag();
+        if((CPU->fpu_owner)!=NULL)(CPU->fpu_owner)->fpu_context_engaged=1;
+    }
+}
+void fpu_lazy_context_save(fpu_context_t *fctx)
+{
+    asm
+    (
+        "push %%eax;"
+        "mov 0x8(%%esp),%%eax;"
+        "fnsave (%%eax);"
+        "pop %%eax;"
+        :"=m"(fctx)
+        :
+        :"eax"
+    );
+}
+void fpu_lazy_context_restore(fpu_context_t *fctx)
+{
+    asm
+    (
+        "push %%eax;"
+        "mov 0x8(%%esp),%%eax;"
+        "frstor (%%eax);"
+        "pop %%eax;"
+        :"=m"(fctx)
+        :
+        :"eax"
+    );
+}
+void fpu_init(void)
+{
+    asm(
+        "fninit;"
+    );
+}

 /SPARTAN/trunk/arch/ia32/src/context.s
 ,0 → 1,83
+#
+# Copyright (C) 2001-2004 Jakub Jermar
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+.text
+.global context_save
+.global context_restore
+## Save current CPU context
+#
+# Save CPU context to the kernel_context variable
+# pointed by the 1st argument. Returns 1 in EAX.
+#
+context_save:
+    push %ebx
+    movl 4(%esp),%eax   # the caller's return %eip
+    movl 8(%esp),%ebx   # address of the kernel_context variable to save context to
+    movl %eax,4(%ebx)   # %eip -> ctx->pc
+    movl %esp,(%ebx)    # %esp -> ctx->sp
+    movl %ebx,%eax
+    pop %ebx
+    movl %ebx,8(%eax)
+    movl %ecx,12(%eax)
+    movl %edx,16(%eax)
+    movl %esi,20(%eax)
+    movl %edi,24(%eax)
+    movl %ebp,28(%eax)
+    xorl %eax,%eax      # context_save returns 1
+    incl %eax
+    ret
+## Restore current CPU context
+#
+# Restore CPU context from the kernel_context variable
+# pointed by the 1st argument. Returns 0 in EAX.
+#
+context_restore:
+    movl 4(%esp),%eax   # address of the kernel_context variable to restore context from
+    movl (%eax),%esp    # ctx->sp -> %esp
+    addl $4,%esp        # this is for the pop we don't do
+    movl 8(%eax),%ebx
+    movl 12(%eax),%ecx
+    movl 16(%eax),%edx
+    movl 20(%eax),%esi
+    movl 24(%eax),%edi
+    movl 28(%eax),%ebp
+    movl 4(%eax),%eax
+    movl %eax,(%esp)    # ctx->pc -> saver's return %eip
+    xorl %eax,%eax      # context_restore returns 0
+    ret

 /SPARTAN/trunk/arch/ia32/src/cpuid.s
 ,0 → 1,93
+#
+# Copyright (C) 2001-2004 Jakub Jermar
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# The code below just interfaces the CPUID instruction.
+# CPU recognition logic is contained in higher-level functions.
+.text
+.global has_cpuid
+.global cpuid
+.global rdtsc
+## Determine CPUID support
+#
+# Return 0 in EAX if CPUID is not support, 1 if supported.
+#
+has_cpuid:
+    push %ebx
+    pushf           # store flags
+    popl %eax       # read flags
+    movl %eax,%ebx      # copy flags
+    btcl $21,%ebx       # swap the ID bit
+    pushl %ebx
+    popf            # propagate the change into flags
+    pushf
+    popl %ebx       # read flags
+    andl $(1<<21),%eax  # interested only in ID bit
+    andl $(1<<21),%ebx
+    xorl %ebx,%eax      # 0 if not supported, 1 if supported
+    pop %ebx
+    ret
+## Get CPUID data
+#
+# This code is just an interfaces the CPUID instruction, CPU recognition
+# logic is contained in higher-level functions.
+#
+# The C prototype is:
+#   void cpuid(__u32 cmd, struct cpu_info *info)
+#
+# @param cmd  CPUID command.
+# @param info Buffer to store CPUID output.
+#
+cpuid:
+    pushl %ebp
+    movl %esp,%ebp
+    pusha
+    movl 8(%ebp),%eax   # load the command into %eax
+    movl 12(%ebp),%esi  # laod the address of the info struct
+    cpuid
+    movl %eax,0(%esi)
+    movl %ebx,4(%esi)
+    movl %ecx,8(%esi)
+    movl %edx,12(%esi)
+    popa
+    popl %ebp
+    ret
+rdtsc:
+    rdtsc
+    ret

 /SPARTAN/trunk/arch/ia32/src/atomic.S
 ,0 → 1,60
+#
+# Copyright (C) 2001-2004 Jakub Jermar
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+.text
+#ifdef __SMP__
+.global spinlock_arch
+#
+# This is a bus-and-hyperthreading-friendly implementation of spinlock
+#
+spinlock_arch:
+    pushl %eax
+    pushl %ebx
+    movl 12(%esp),%ebx
+:
+    #ifdef __HT__
+    pause           # Pentium 4's with HT love this instruction
+    #endif
+    movl (%ebx),%eax
+    testl %eax,%eax
+    jnz 0b          # lightweight looping while it is locked
+    incl %eax
+    xchgl %eax,(%ebx)   # now use the atomic operation
+    testl %eax,%eax
+    jnz 0b
+    popl %ebx
+    popl %eax
+    ret
+#endif

 /SPARTAN/trunk/arch/ia32/src/debug/panic.s
 ,0 → 1,34
+#
+# Copyright (C) 2001-2004 Jakub Jermar
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+.text
+.global panic_printf
+panic_printf:
+    movl $halt,(%esp)   # fake stack to make printf return to halt
+    jmp printf

 /SPARTAN/trunk/arch/ia32/src/bios/bios.c
 ,0 → 1,38
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch/bios/bios.h>
+#include <arch/types.h>
+__address ebda = 0;
+void bios_init(void)
+{
+    /* Copy the EBDA address out from BIOS Data Area */
+    ebda = *((__u16 *) BIOS_EBDA_PTR) * 0x10;
+}

 /SPARTAN/trunk/arch/ia32/src/delay.s
 ,0 → 1,54
+#
+# Copyright (C) 2001-2004 Jakub Jermar
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+#
+# Micro second delay loop functions.
+#
+.text
+.global asm_delay_loop
+.global asm_fake_loop
+asm_delay_loop:
+    pushl %ecx
+    movl 8(%esp),%ecx   # move argument to %ecx
+:  lahf
+    dec %ecx
+    jnz 0b
+    popl %ecx
+    ret
+asm_fake_loop:
+    pushl %ecx
+    movl 8(%esp),%ecx   # move argument to %ecx
+:  lahf
+    dec %ecx
+    jz 0b
+    popl %ecx
+    ret

 /SPARTAN/trunk/arch/ia32/include/barrier.h
 ,0 → 1,46
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ia32_BARRIER_H__
+#define __ia32_BARRIER_H__
+/*
+ * NOTE:
+ * No barriers for critical section (i.e. spinlock) on IA-32 are needed:
+ * - spinlock_lock() and spinlock_trylock() use serializing XCHG instruction
+ * - writes cannot pass reads on IA-32 => spinlock_unlock() needs no barriers
+ */
+/*
+ * Provisions are made to prevent compiler from reordering instructions itself.
+ */
+#define CS_ENTER_BARRIER()  __asm__ volatile ("" ::: "memory")
+#define CS_LEAVE_BARRIER()  __asm__ volatile ("" ::: "memory")
+#endif

 /SPARTAN/trunk/arch/ia32/include/mm/memory_init.h
 ,0 → 1,36
+/*
+ * Copyright (C) 2005 Josef Cejka
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ia32_MEMORY_INIT_H__
+#define __ia32_MEMORY_INIT_H__
+#include <typedefs.h>
+size_t get_memory_size(void);
+#endif

 /SPARTAN/trunk/arch/ia32/include/mm/page.h
 ,0 → 1,114
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ia32_PAGE_H__
+#define __ia32_PAGE_H__
+#include <mm/page.h>
+#include <arch/types.h>
+#include <arch/mm/frame.h>
+#include <typedefs.h>
+#define PAGE_SIZE   FRAME_SIZE
+#define KA2PA(x)    ((x) - 0x80000000)
+#define PA2KA(x)    ((x) + 0x80000000)
+/*
+ * Implementation of generic 4-level page table interface.
+ * IA-32 has 2-level page tables, so PTL1 and PTL2 are left out.
+ */
+#define PTL0_INDEX_ARCH(vaddr)  (((vaddr)>>22)&0x3ff)
+#define PTL1_INDEX_ARCH(vaddr)  0
+#define PTL2_INDEX_ARCH(vaddr)  0
+#define PTL3_INDEX_ARCH(vaddr)  (((vaddr)>>12)&0x3ff)
+#define GET_PTL0_ADDRESS_ARCH()         ((pte_t *) read_cr3())
+#define GET_PTL1_ADDRESS_ARCH(ptl0, i)      ((pte_t *)((((pte_t *)(ptl0))[(i)].frame_address)<<12))
+#define GET_PTL2_ADDRESS_ARCH(ptl1, i)      (ptl1)
+#define GET_PTL3_ADDRESS_ARCH(ptl2, i)      (ptl2)
+#define GET_FRAME_ADDRESS_ARCH(ptl3, i)     ((__address)((((pte_t *)(ptl3))[(i)].frame_address)<<12))
+#define SET_PTL0_ADDRESS_ARCH(ptl0)     (write_cr3((__address) (ptl0)))
+#define SET_PTL1_ADDRESS_ARCH(ptl0, i, a)   (((pte_t *)(ptl0))[(i)].frame_address = (a)>>12)
+#define SET_PTL2_ADDRESS_ARCH(ptl1, i, a)
+#define SET_PTL3_ADDRESS_ARCH(ptl2, i, a)
+#define SET_FRAME_ADDRESS_ARCH(ptl3, i, a)  (((pte_t *)(ptl3))[(i)].frame_address = (a)>>12)
+#define GET_PTL1_FLAGS_ARCH(ptl0, i)        get_pt_flags((pte_t *)(ptl0), (index_t)(i))
+#define GET_PTL2_FLAGS_ARCH(ptl1, i)        PAGE_PRESENT
+#define GET_PTL3_FLAGS_ARCH(ptl2, i)        PAGE_PRESENT
+#define GET_FRAME_FLAGS_ARCH(ptl3, i)       get_pt_flags((pte_t *)(ptl3), (index_t)(i))
+#define SET_PTL1_FLAGS_ARCH(ptl0, i, x)     set_pt_flags((pte_t *)(ptl0), (index_t)(i), (x))
+#define SET_PTL2_FLAGS_ARCH(ptl1, i, x)
+#define SET_PTL3_FLAGS_ARCH(ptl2, i, x)
+#define SET_FRAME_FLAGS_ARCH(ptl3, i, x)    set_pt_flags((pte_t *)(ptl3), (index_t)(i), (x))
+struct page_specifier {
+    unsigned present : 1;
+    unsigned writeable : 1;
+    unsigned uaccessible : 1;
+    unsigned page_write_through : 1;
+    unsigned page_cache_disable : 1;
+    unsigned accessed : 1;
+    unsigned dirty : 1;
+    unsigned : 2;
+    unsigned avl : 3;
+    unsigned frame_address : 20;
+} __attribute__ ((packed));
+typedef struct page_specifier pte_t;
+static inline int get_pt_flags(pte_t *pt, index_t i)
+{
+    pte_t *p = &pt[i];
+    return (
+        (!p->page_cache_disable)<<PAGE_CACHEABLE_SHIFT |
+        (!p->present)<<PAGE_PRESENT_SHIFT |
+        p->uaccessible<<PAGE_USER_SHIFT |
+<<PAGE_READ_SHIFT |
+        p->writeable<<PAGE_WRITE_SHIFT |
+<<PAGE_EXEC_SHIFT
+    );
+}
+static inline void set_pt_flags(pte_t *pt, index_t i, int flags)
+{
+    pte_t *p = &pt[i];
+    p->page_cache_disable = !(flags & PAGE_CACHEABLE);
+    p->present = !(flags & PAGE_NOT_PRESENT);
+    p->uaccessible = (flags & PAGE_USER) != 0;
+    p->writeable = (flags & PAGE_WRITE) != 0;
+}
+extern void page_arch_init(void);
+#endif

 /SPARTAN/trunk/arch/ia32/include/mm/vm.h
 ,0 → 1,43
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ia32_VM_H__
+#define __ia32_VM_H__
+#include <arch/types.h>
+#define KERNEL_ADDRESS_SPACE_START_ARCH     (__address) 0x80000000
+#define KERNEL_ADDRESS_SPACE_END_ARCH       (__address) 0xffffffff
+#define USER_ADDRESS_SPACE_START_ARCH       (__address) 0x00000000
+#define USER_ADDRESS_SPACE_END_ARCH     (__address) 0x7fffffff
+#define UTEXT_ADDRESS_ARCH  0x00001000
+#define USTACK_ADDRESS_ARCH (0x7fffffff-(PAGE_SIZE-1))
+#define UDATA_ADDRESS_ARCH  0x21000000
+#endif

 /SPARTAN/trunk/arch/ia32/include/mm/frame.h
 ,0 → 1,40
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ia32_FRAME_H__
+#define __ia32_FRAME_H__
+#include <arch/types.h>
+#define FRAME_SIZE  4096
+extern __address bootstrap_dba;
+extern void frame_arch_init(void);
+#endif

 /SPARTAN/trunk/arch/ia32/include/boot/memmap.h
 ,0 → 1,48
+/*
+ * Copyright (C) 2005 Josef Cejka
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ia32_MEMMAP_H__
+#define __ia32_MEMMAP_H__
+#include <arch/boot/memmapasm.h>
+#include <arch/types.h>
+struct e820memmap_ {
+    __u64 base_address;
+    __u64 size;
+    __u32 type;
+    } __attribute__ ((packed));
+extern struct e820memmap_ e820table[MEMMAP_E820_MAX_RECORDS];
+extern __u8 e820counter;
+extern __u32 e801memorysize; // size of memory in KB
+#endif

 /SPARTAN/trunk/arch/ia32/include/boot/memmapasm.h
 ,0 → 1,50
+/*
+ * Copyright (C) 2005 Josef Cejka
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ia32_MEMMAPASM_H__
+#define __ia32_MEMMAPASM_H__
+/* E820h memory range types - other values*/
+    /* Free memory */
+#define MEMMAP_MEMORY_AVAILABLE 1
+    /* Not available for OS */
+#define MEMMAP_MEMORY_RESERVED  2
+    /* OS may use it after reading ACPI table */
+#define MEMMAP_MEMORY_ACPI  3
+    /* Unusable, required to be saved and restored across an NVS sleep */
+#define MEMMAP_MEMORY_NVS   4
+    /* Corrupted memory */
+#define MEMMAP_MEMORY_UNUSABLE  5
+     /* size of one entry */
+#define MEMMAP_E820_RECORD_SIZE 20
+    /* maximum entries */
+#define MEMMAP_E820_MAX_RECORDS 32
+#endif

 /SPARTAN/trunk/arch/ia32/include/asm.h
 ,0 → 1,159
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ia32_ASM_H__
+#define __ia32_ASM_H__
+#include <arch/types.h>
+#include <typedefs.h>
+#include <mm/page.h>
+#include <synch/spinlock.h>
+#include <arch/boot/memmap.h>
+extern __u32 interrupt_handler_size;
+extern void paging_on(void);
+extern void interrupt_handlers(void);
+extern __u8 inb(int port);
+extern __u16 inw(int port);
+extern __u32 inl(int port);
+extern void outb(int port, __u8 b);
+extern void outw(int port, __u16 w);
+extern void outl(int port, __u32 l);
+extern void enable_l_apic_in_msr(void);
+/** Halt CPU
+ *
+ * Halt the current CPU until interrupt event.
+ */
+static inline void cpu_halt(void) { __asm__("hlt"); };
+static inline void cpu_sleep(void) { __asm__("hlt"); };
+/** Read CR2
+ *
+ * Return value in CR2
+ *
+ * @return Value read.
+ */
+static inline __u32 read_cr2(void) { __u32 v; __asm__ volatile ("movl %%cr2,%0" : "=r" (v)); return v; }
+/** Write CR3
+ *
+ * Write value to CR3.
+ *
+ * @param v Value to be written.
+ */
+static inline void write_cr3(__u32 v) { __asm__ volatile ("movl %0,%%cr3\n" : : "r" (v)); }
+/** Read CR3
+ *
+ * Return value in CR3
+ *
+ * @return Value read.
+ */
+static inline __u32 read_cr3(void) { __u32 v; __asm__ volatile ("movl %%cr3,%0" : "=r" (v)); return v; }
+/** Write DR0
+ *
+ * Write value to DR0.
+ *
+ * @param v Value to be written.
+ */
+static inline void write_dr0(__u32 v) { __asm__ volatile ("movl %0,%%dr0\n" : : "r" (v)); }
+/** Read DR0
+ *
+ * Return value in DR0
+ *
+ * @return Value read.
+ */
+static inline __u32 read_dr0(void) { __u32 v; __asm__ volatile ("movl %%dr0,%0" : "=r" (v)); return v; }
+/** Set priority level low
+ *
+ * Enable interrupts and return previous
+ * value of EFLAGS.
+ */
+static inline pri_t cpu_priority_low(void) {
+    pri_t v;
+    __asm__ volatile (
+        "pushf\n"
+        "popl %0\n"
+        "sti\n"
+        : "=r" (v)
+    );
+    return v;
+}
+/** Set priority level high
+ *
+ * Disable interrupts and return previous
+ * value of EFLAGS.
+ */
+static inline pri_t cpu_priority_high(void) {
+    pri_t v;
+    __asm__ volatile (
+        "pushf\n"
+        "popl %0\n"
+        "cli\n"
+        : "=r" (v)
+    );
+    return v;
+}
+/** Restore priority level
+ *
+ * Restore EFLAGS.
+ */
+static inline void cpu_priority_restore(pri_t pri) {
+    __asm__ volatile (
+        "pushl %0\n"
+        "popf\n"
+        : : "r" (pri)
+    );
+}
+/** Return raw priority level
+ *
+ * Return EFLAFS.
+ */
+static inline pri_t cpu_priority_read(void) {
+    pri_t v;
+    __asm__ volatile (
+        "pushf\n"
+        "popl %0\n"
+        : "=r" (v)
+    );
+    return v;
+}
+#endif

 /SPARTAN/trunk/arch/ia32/include/acpi/madt.h
 ,0 → 1,140
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __MADT_H__
+#define __MADT_H__
+#include <arch/acpi/acpi.h>
+#include <arch/smp/apic.h>
+#include <arch/smp/smp.h>
+#define MADT_L_APIC         0
+#define MADT_IO_APIC            1
+#define MADT_INTR_SRC_OVRD      2
+#define MADT_NMI_SRC            3
+#define MADT_L_APIC_NMI         4
+#define MADT_L_APIC_ADDR_OVRD       5
+#define MADT_IO_SAPIC           6
+#define MADT_L_SAPIC            7
+#define MADT_PLATFORM_INTR_SRC      8
+#define MADT_RESERVED_SKIP_BEGIN    9
+#define MADT_RESERVED_SKIP_END      127
+#define MADT_RESERVED_OEM_BEGIN     128
+struct madt_apic_header {
+    __u8 type;
+    __u8 length;
+} __attribute__ ((packed));
+/* Multiple APIC Description Table */
+struct acpi_madt {
+    struct acpi_sdt_header header;
+    __u32 l_apic_address;
+    __u32 flags;
+    struct madt_apic_header apic_header[];
+} __attribute__ ((packed));
+struct madt_l_apic {
+    struct madt_apic_header header;
+    __u8 acpi_id;
+    __u8 apic_id;
+    __u32 flags;
+} __attribute__ ((packed));
+struct madt_io_apic {
+    struct madt_apic_header header;
+    __u8 io_apic_id;
+    __u8 reserved;
+    __u32 io_apic_address;
+    __u32 global_intr_base;
+} __attribute__ ((packed));
+struct madt_intr_src_ovrd {
+    struct madt_apic_header header;
+    __u8 bus;
+    __u8 source;
+    __u32 global_intr;
+    __u16 flags;
+} __attribute__ ((packed));
+struct madt_nmi_src {
+    struct madt_apic_header header;
+    __u16 flags;
+    __u32 global_intr;
+} __attribute__ ((packed));
+struct madt_l_apic_nmi {
+    struct madt_apic_header header;
+    __u8 acpi_id;
+    __u16 flags;
+    __u8 l_apic_lint;
+} __attribute__ ((packed));
+struct madt_l_apic_addr_ovrd {
+    struct madt_apic_header header;
+    __u16 reserved;
+    __u64 l_apic_address;
+} __attribute__ ((packed));
+struct madt_io_sapic {
+    struct madt_apic_header header;
+    __u8 io_apic_id;
+    __u8 reserved;
+    __u32 global_intr_base;
+    __u64 io_apic_address;
+} __attribute__ ((packed));
+struct madt_l_sapic {
+    struct madt_apic_header header;
+    __u8 acpi_id;
+    __u8 sapic_id;
+    __u8 sapic_eid;
+    __u8 reserved[3];
+    __u32 flags;
+    __u32 acpi_processor_uid_value;
+    __u8 acpi_processor_uid_str[1];
+} __attribute__ ((packed));
+struct madt_platform_intr_src {
+    struct madt_apic_header header;
+    __u16 flags;
+    __u8 intr_type;
+    __u8 processor_id;
+    __u8 processor_eid;
+    __u8 io_sapic_vector;
+    __u32 global_intr;
+    __u32 platform_intr_src_flags;
+} __attribute__ ((packed));
+extern struct acpi_madt *acpi_madt;
+extern struct smp_config_operations madt_config_operations;
+extern void acpi_madt_parse(void);
+#endif /* __MADT_H__ */

 /SPARTAN/trunk/arch/ia32/include/acpi/acpi.h
 ,0 → 1,89
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ACPI_H__
+#define __ACPI_H__
+#include <arch/types.h>
+/* Root System Description Pointer */
+struct acpi_rsdp {
+    __u8 signature[8];
+    __u8 checksum;
+    __u8 oemid[6];
+    __u8 revision;
+    __u32 rsdt_address;
+    __u32 length;
+    __u64 xsdt_address;
+    __u32 ext_checksum;
+    __u8 reserved[3];
+} __attribute__ ((packed));
+/* System Description Table Header */
+struct acpi_sdt_header {
+    __u8 signature[4];
+    __u32 length;
+    __u8 revision;
+    __u8 checksum;
+    __u8 oemid[6];
+    __u8 oem_table_id[8];
+    __u32 oem_revision;
+    __u32 creator_id;
+    __u32 creator_revision;
+} __attribute__ ((packed));;
+struct acpi_signature_map {
+    __u8 *signature;
+    struct acpi_sdt_header **sdt_ptr;
+    char *description;
+};
+/* Root System Description Table */
+struct acpi_rsdt {
+    struct acpi_sdt_header header;
+    __u32 entry[];
+} __attribute__ ((packed));;
+/* Extended System Description Table */
+struct acpi_xsdt {
+    struct acpi_sdt_header header;
+    __u64 entry[];
+} __attribute__ ((packed));;
+extern struct acpi_rsdp *acpi_rsdp;
+extern struct acpi_rsdt *acpi_rsdt;
+extern struct acpi_xsdt *acpi_xsdt;
+extern void acpi_init(void);
+static int rsdp_check(__u8 *rsdp);
+static void map_sdt(struct acpi_sdt_header *sdt);
+extern int acpi_sdt_check(__u8 *sdt);
+static void configure_via_rsdt(void);
+static void configure_via_xsdt(void);
+#endif /* __ACPI_H__ */

 /SPARTAN/trunk/arch/ia32/include/smp/mps.h
 ,0 → 1,128
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __MPS_H__
+#define __MPS_H__
+#include <arch/types.h>
+#include <typedefs.h>
+#include <synch/waitq.h>
+#include <config.h>
+#include <arch/smp/smp.h>
+#define CT_EXT_ENTRY_TYPE       0
+#define CT_EXT_ENTRY_LEN        1
+struct mps_fs {
+    __u32 signature;
+    struct mps_ct *configuration_table;
+    __u8 length;
+    __u8 revision;
+    __u8 checksum;
+    __u8 config_type;
+    __u8 mpfib2;
+    __u8 mpfib3;
+    __u8 mpfib4;
+    __u8 mpfib5;
+} __attribute__ ((packed));
+struct mps_ct {
+    __u32 signature;
+    __u16 base_table_length;
+    __u8 revision;
+    __u8 checksum;
+    __u8 oem_id[8];
+    __u8 product_id[12];
+    __u8 *oem_table;
+    __u16 oem_table_size;
+    __u16 entry_count;
+    __u32 *l_apic;
+    __u16 ext_table_length;
+    __u8 ext_table_checksum;
+    __u8 xxx;
+    __u8 base_table[0];
+} __attribute__ ((packed));
+struct __processor_entry {
+    __u8 type;
+    __u8 l_apic_id;
+    __u8 l_apic_version;
+    __u8 cpu_flags;
+    __u8 cpu_signature[4];
+    __u32 feature_flags;
+    __u32 xxx[2];
+} __attribute__ ((packed));
+struct __bus_entry {
+    __u8 type;
+    __u8 bus_id;
+    __u8 bus_type[6];
+} __attribute__ ((packed));
+struct __io_apic_entry {
+    __u8 type;
+    __u8 io_apic_id;
+    __u8 io_apic_version;
+    __u8 io_apic_flags;
+    __u32 *io_apic;
+} __attribute__ ((packed));
+struct __io_intr_entry {
+    __u8 type;
+    __u8 intr_type;
+    __u8 poel;
+    __u8 xxx;
+    __u8 src_bus_id;
+    __u8 src_bus_irq;
+    __u8 dst_io_apic_id;
+    __u8 dst_io_apic_pin;
+} __attribute__ ((packed));
+struct __l_intr_entry {
+    __u8 type;
+    __u8 intr_type;
+    __u8 poel;
+    __u8 xxx;
+    __u8 src_bus_id;
+    __u8 src_bus_irq;
+    __u8 dst_l_apic_id;
+    __u8 dst_l_apic_pin;
+} __attribute__ ((packed));
+extern waitq_t ap_completion_wq;
+extern waitq_t kmp_completion_wq;
+extern struct smp_config_operations mps_config_operations;
+extern int mps_irq_to_pin(int irq);
+extern void mps_init(void);
+extern void kmp(void *arg);
+#endif

 /SPARTAN/trunk/arch/ia32/include/smp/smp.h
 ,0 → 1,42
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ia32_SMP_H__
+#define __ia32_SMP_H__
+#include <arch/types.h>
+#include <typedefs.h>
+struct smp_config_operations {
+    count_t (* cpu_count)(void);
+    bool (* cpu_enabled)(index_t i);
+    bool (*cpu_bootstrap)(index_t i);
+    __u8 (*cpu_apic_id)(index_t i);
+};
+#endif

 /SPARTAN/trunk/arch/ia32/include/smp/apic.h
 ,0 → 1,140
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __APIC_H__
+#define __APIC_H__
+#include <arch/types.h>
+#include <cpu.h>
+#define FIXED       (0<<0)
+#define LOPRI       (1<<0)
+/* local APIC macros */
+#define IPI_INIT    0
+#define IPI_STARTUP 0
+#define DLVRMODE_FIXED  (0<<8)
+#define DLVRMODE_INIT   (5<<8)
+#define DLVRMODE_STUP   (6<<8)
+#define DESTMODE_PHYS   (0<<11)
+#define DESTMODE_LOGIC  (1<<11)
+#define LEVEL_ASSERT    (1<<14)
+#define LEVEL_DEASSERT  (0<<14)
+#define TRGRMODE_LEVEL  (1<<15)
+#define TRGRMODE_EDGE   (0<<15)
+#define SHORTHAND_DEST  (0<<18)
+#define SHORTHAND_INCL  (2<<18)
+#define SHORTHAND_EXCL  (3<<18)
+#define SEND_PENDING    (1<<12)
+/* Interrupt Command Register */
+#define ICRlo       (0x300/sizeof(__u32))
+#define ICRhi       (0x310/sizeof(__u32))
+#define ICRloClear  ((1<<13)|(3<<16)|(0xfff<<20))
+#define ICRhiClear  (0xffffff<<0)
+/* End Of Interrupt */
+#define EOI     (0x0b0/sizeof(__u32))
+/* Error Status Register */
+#define ESR     (0x280/sizeof(__u32))
+#define ESRClear    ((0xffffff<<8)|(1<<4))
+/* Task Priority Register */
+#define TPR     (0x080/sizeof(__u32))
+#define TPRClear    0xffffff00
+/* Spurious Vector Register */
+#define SVR     (0x0f0/sizeof(__u32))
+#define SVRClear    (~0x3f0)
+/* Time Divide Configuratio Register */
+#define TDCR        (0x3e0/sizeof(__u32))
+#define TDCRClear   (~0xb)
+/* Initial Count Register for Timer */
+#define ICRT        (0x380/sizeof(__u32))
+/* Current Count Register for Timer */
+#define CCRT        (0x390/sizeof(__u32))
+/* LVT */
+#define LVT_Tm      (0x320/sizeof(__u32))
+#define LVT_LINT0   (0x350/sizeof(__u32))
+#define LVT_LINT1   (0x360/sizeof(__u32))
+#define LVT_Err     (0x370/sizeof(__u32))
+#define LVT_PCINT   (0x340/sizeof(__u32))
+/* Local APIC ID Register */
+#define L_APIC_ID   (0x020/sizeof(__u32))
+#define L_APIC_IDClear  (~(0xf<<24))
+#define L_APIC_IDShift  24
+#define L_APIC_IDMask   0xf
+/* Local APIC Version Register */
+#define LAVR        (0x030/sizeof(__u32))
+#define LAVR_Mask   0xff
+#define is_local_apic(x)    (((x)&LAVR_Mask&0xf0)==0x1)
+#define is_82489DX_apic(x)  ((((x)&LAVR_Mask&0xf0)==0x0))
+#define is_local_xapic(x)   (((x)&LAVR_Mask)==0x14)
+/* IO APIC */
+#define IOREGSEL    (0x00/sizeof(__u32))
+#define IOWIN       (0x10/sizeof(__u32))
+#define IOAPICID    0x00
+#define IOAPICVER   0x01
+#define IOAPICARB   0x02
+#define IOREDTBL    0x10
+extern volatile __u32 *l_apic;
+extern volatile __u32 *io_apic;
+extern __u32 apic_id_mask;
+extern void apic_init(void);
+extern void apic_spurious(__u8 n, __u32 stack[]);
+extern void l_apic_init(void);
+extern void l_apic_eoi(void);
+extern int l_apic_broadcast_custom_ipi(__u8 vector);
+extern int l_apic_send_init_ipi(__u8 apicid);
+extern void l_apic_debug(void);
+extern void l_apic_timer_interrupt(__u8 n, __u32 stack[]);
+extern __u8 l_apic_id(void);
+extern __u32 io_apic_read(__u8 address);
+extern void io_apic_write(__u8 address , __u32 x);
+extern void io_apic_change_ioredtbl(int signal, int dest, __u8 v, int flags);
+extern void io_apic_disable_irqs(__u16 irqmask);
+extern void io_apic_enable_irqs(__u16 irqmask);
+#endif

 /SPARTAN/trunk/arch/ia32/include/smp/ap.h
 ,0 → 1,34
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __AP_H__
+#define __AP_H__
+extern void ap_boot(void);
+#endif

 /SPARTAN/trunk/arch/ia32/include/cpu.h
 ,0 → 1,56
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ia32_CPU_H__
+#define __ia32_CPU_H__
+#include <config.h>
+#include <proc/thread.h>
+#include <typedefs.h>
+#include <arch/pm.h>
+#include <arch/asm.h>
+#ifdef __SMP__
+#define CPU_ID_ARCH (read_dr0())
+#else
+#define CPU_ID_ARCH (0)
+#endif
+struct cpu_arch {
+    int vendor;
+    int family;
+    int model;
+    int stepping;
+    struct tss *tss;
+};
+void set_TS_flag(void);
+void reset_TS_flag(void);
+#endif

 /SPARTAN/trunk/arch/ia32/include/atomic.h
 ,0 → 1,66
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ia32_ATOMIC_H__
+#define __ia32_ATOMIC_H__
+#include <arch/types.h>
+static inline void atomic_inc(volatile int *val) {
+#ifdef __SMP__
+    __asm__ volatile ("lock incl (%0)\n" : : "r" (val));
+#else
+    __asm__ volatile ("incl (%0)\n" : : "r" (val));
+#endif /* __SMP__ */
+}
+static inline void atomic_dec(volatile int *val) {
+#ifdef __SMP__
+    __asm__ volatile ("lock decl (%0)\n" : : "r" (val));
+#else
+    __asm__ volatile ("decl (%0)\n" : : "r" (val));
+#endif /* __SMP__ */
+}
+static inline int test_and_set(volatile int *val) {
+    int v;
+    __asm__ volatile (
+        "movl $1, %0\n"
+        "xchgl %0, (%1)\n"
+        : "=r" (v)
+        : "r" (val)
+    );
+    return v;
+}
+extern void spinlock_arch(volatile int *val);
+#endif

 /SPARTAN/trunk/arch/ia32/include/pm.h
 ,0 → 1,147
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __PM_H__
+#define __PM_H__
+#include <arch/types.h>
+#include <typedefs.h>
+#include <arch/context.h>
+#define IDT_ITEMS 64
+#define GDT_ITEMS 6
+#define NULL_DES    0
+#define KTEXT_DES   1
+#define KDATA_DES   2
+#define UTEXT_DES   3
+#define UDATA_DES   4
+#define TSS_DES     5
+#define selector(des)   ((des)<<3)
+#define PL_KERNEL   0
+#define PL_USER     3
+#define AR_PRESENT  (1<<7)
+#define AR_DATA     (2<<3)
+#define AR_CODE     (3<<3)
+#define AR_WRITABLE (1<<1)
+#define AR_INTERRUPT    (0xe)
+#define AR_TSS      (0x9)
+#define DPL_KERNEL  (PL_KERNEL<<5)
+#define DPL_USER    (PL_USER<<5)
+#define IO_MAP_BASE (104)
+struct ptr_16_32 {
+    __u16 limit;
+    __u32 base;
+} __attribute__ ((packed));
+struct descriptor {
+    unsigned limit_0_15: 16;
+    unsigned base_0_15: 16;
+    unsigned base_16_23: 8;
+    unsigned access: 8;
+    unsigned limit_16_19: 4;
+    unsigned available: 1;
+    unsigned unused: 1;
+    unsigned special: 1;
+    unsigned granularity : 1;
+    unsigned base_24_31: 8;
+} __attribute__ ((packed));
+struct idescriptor {
+    unsigned offset_0_15: 16;
+    unsigned selector: 16;
+    unsigned unused: 8;
+    unsigned access: 8;
+    unsigned offset_16_31: 16;
+} __attribute__ ((packed));
+struct tss {
+    __u16 link;
+    unsigned : 16;
+    __u32 esp0;
+    __u16 ss0;
+    unsigned : 16;
+    __u32 esp1;
+    __u16 ss1;
+    unsigned : 16;
+    __u32 esp2;
+    __u16 ss2;
+    unsigned : 16;
+    __u32 cr3;
+    __u32 eip;
+    __u32 eflags;
+    __u32 eax;
+    __u32 ecx;
+    __u32 edx;
+    __u32 ebx;
+    __u32 esp;
+    __u32 ebp;
+    __u32 esi;
+    __u32 edi;
+    __u16 es;
+    unsigned : 16;
+    __u16 cs;
+    unsigned : 16;
+    __u16 ss;
+    unsigned : 16;
+    __u16 ds;
+    unsigned : 16;
+    __u16 fs;
+    unsigned : 16;
+    __u16 gs;
+    unsigned : 16;
+    __u16 ldtr;
+    unsigned : 16;
+    unsigned : 16;
+    __u16 io_map_base;
+} __attribute__ ((packed));
+extern struct ptr_16_32 gdtr;
+extern struct tss *tss_p;
+extern struct descriptor gdt[];
+extern struct idescriptor idt[];
+extern void pm_init(void);
+extern void gdt_setbase(struct descriptor *d, __address base);
+extern void gdt_setlimit(struct descriptor *d, __u32 limit);
+extern void idt_init(void);
+extern void idt_setoffset(struct idescriptor *d, __address offset);
+extern void tss_initialize(struct tss *t);
+#endif

 /SPARTAN/trunk/arch/ia32/include/fpu_context.h
 ,0 → 1,40
+/*
+ * Copyright (C) 2005 Jakub Vana
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ia32_FPU_CONTEXT_H__
+#define __ia32_FPU_CONTEXT_H__
+#include <arch/types.h>
+struct fpu_context {
+    __u8 fpu[512];      /* FXSAVE & FXRSTOR storage area */
+};
+#endif

 /SPARTAN/trunk/arch/ia32/include/interrupt.h
 ,0 → 1,90
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __INTERRUPT_H__
+#define __INTERRUPT_H__
+#include <arch/types.h>
+#include <arch/pm.h>
+#define IVT_ITEMS       IDT_ITEMS
+#define IVT_EXCBASE     0
+#define EXCLAST         31
+#define IVT_IRQBASE     (IVT_EXCBASE+EXCLAST+1)
+#define IRQLAST         15
+#define IVT_FREEBASE        (IVT_IRQBASE+IRQLAST+1)
+#define IRQ_CLK     0
+#define IRQ_KBD     1
+#define IRQ_PIC1    2
+#define IRQ_PIC_SPUR    7
+/* this one must have four least significant bits set to ones */
+#define VECTOR_APIC_SPUR    (IVT_ITEMS-1)
+#if (((VECTOR_APIC_SPUR + 1)%16) || VECTOR_APIC_SPUR >= IVT_ITEMS)
+#error Wrong definition of VECTOR_APIC_SPUR
+#endif
+#define VECTOR_PIC_SPUR     (IVT_IRQBASE+IRQ_PIC_SPUR)
+#define VECTOR_CLK      (IVT_IRQBASE+IRQ_CLK)
+#define VECTOR_KBD      (IVT_IRQBASE+IRQ_KBD)
+#define VECTOR_SYSCALL          (IVT_FREEBASE+0)
+#define VECTOR_TLB_SHOOTDOWN_IPI    (IVT_FREEBASE+1)
+#define VECTOR_WAKEUP_IPI       (IVT_FREEBASE+2)
+typedef void (* iroutine)(__u8 n, __u32 stack[]);
+extern iroutine ivt[IVT_ITEMS];
+extern void (* disable_irqs_function)(__u16 irqmask);
+extern void (* enable_irqs_function)(__u16 irqmask);
+extern void (* eoi_function)(void);
+extern iroutine trap_register(__u8 n, iroutine f);
+extern void trap_dispatcher(__u8 n, __u32 stack[]);
+extern void null_interrupt(__u8 n, __u32 stack[]);
+extern void gp_fault(__u8 n, __u32 stack[]);
+extern void nm_fault(__u8 n, __u32 stack[]);
+extern void ss_fault(__u8 n, __u32 stack[]);
+extern void page_fault(__u8 n, __u32 stack[]);
+extern void syscall(__u8 n, __u32 stack[]);
+extern void tlb_shootdown_ipi(__u8 n, __u32 stack[]);
+extern void wakeup_ipi(__u8 n, __u32 stack[]);
+extern void trap_virtual_enable_irqs(__u16 irqmask);
+extern void trap_virtual_disable_irqs(__u16 irqmask);
+extern void trap_virtual_eoi(void);
+#endif

 /SPARTAN/trunk/arch/ia32/include/context.h
 ,0 → 1,52
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ia32_CONTEXT_H__
+#define __ia32_CONTEXT_H__
+#include <arch/types.h>
+/*
+ * Both context_save() and context_restore() eat two doublewords from the stack.
+ * First for pop of the saved register, second during ret instruction.
+ */
+#define SP_DELTA    8
+struct context {
+    __u32 sp;
+    __u32 pc;
+    __u32 ebx;
+    __u32 ecx;
+    __u32 edx;
+    __u32 esi;
+    __u32 edi;
+    __u32 ebp;
+    __u32 pri;
+} __attribute__ ((packed));
+#endif

 /SPARTAN/trunk/arch/ia32/include/faddr.h
 ,0 → 1,36
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ia32_FADDR_H__
+#define __ia32_FADDR_H__
+#include <arch/types.h>
+#define FADDR(fptr)     ((__address) (fptr))
+#endif

 /SPARTAN/trunk/arch/ia32/include/ega.h
 ,0 → 1,43
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __EGA_H__
+#define __EGA_H__
+#define VIDEORAM    0xb8000
+#define ROW     80
+#define ROWS        25
+#define SCREEN      (ROW*ROWS)
+extern void ega_init(void);
+extern void ega_putchar(const char ch);
+static void ega_check_cursor(void);
+static void ega_display_char(char ch);
+#endif

 /SPARTAN/trunk/arch/ia32/include/types.h
 ,0 → 1,47
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __TYPES_H__
+#define __TYPES_H__
+#define NULL 0
+typedef signed char __s8;
+typedef unsigned char __u8;
+typedef unsigned short __u16;
+typedef unsigned long __u32;
+typedef long long __u64;
+typedef __u32 __address;
+typedef __u32 pri_t;
+typedef __u32 __native;
+#endif

 /SPARTAN/trunk/arch/ia32/include/arg.h
 ,0 → 1,34
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ia32_ARG_H__
+#define __ia32_ARG_H__
+#include <stackarg.h>
+#endif

 /SPARTAN/trunk/arch/ia32/include/bios/bios.h
 ,0 → 1,40
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __BIOS_H__
+#define __BIOS_H__
+#include <arch/types.h>
+#define BIOS_EBDA_PTR   0x40e
+extern __address ebda;
+extern void bios_init(void);
+#endif /* __BIOS_H__ */

 /SPARTAN/trunk/arch/ia32/include/i8254.h
 ,0 → 1,39
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __I8254_H__
+#define __I8254_H__
+#include <arch/types.h>
+extern void i8254_init(void);
+extern void i8254_interrupt(__u8 n, __u32 stack[]);
+extern void i8254_calibrate_delay_loop(void);
+extern void i8254_normal_operation(void);
+#endif

 /SPARTAN/trunk/arch/ia32/include/thread.h
 ,0 → 1,34
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ia32_THREAD_H__
+#define __ia32_THREAD_H__
+#define ARCH_THREAD_DATA
+#endif

 /SPARTAN/trunk/arch/ia32/include/cpuid.h
 ,0 → 1,46
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __CPUID_H__
+#define __CPUID_H__
+#include <arch/types.h>
+struct cpu_info {
+    __u32 cpuid_eax;
+    __u32 cpuid_ebx;
+    __u32 cpuid_ecx;
+    __u32 cpuid_edx;
+} __attribute__ ((packed));
+extern int has_cpuid(void);
+extern void cpuid(__u32 cmd, cpu_info_t *info);
+extern __u64 rdtsc(void);
+#endif

 /SPARTAN/trunk/arch/ia32/include/i8042.h
 ,0 → 1,37
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __I8042_H__
+#define __I8042_H__
+#include <arch/types.h>
+extern void i8042_init(void);
+extern void i8042_interrupt(__u8 n, __u32 stack[]);
+#endif

 /SPARTAN/trunk/arch/ia32/include/i8259.h
 ,0 → 1,51
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __I8259_H__
+#define __I8259_H__
+#include <arch/types.h>
+#include <arch/interrupt.h>
+#define PIC_PIC0PORT1   0x20
+#define PIC_PIC0PORT2   0x21
+#define PIC_PIC1PORT1   0xa0
+#define PIC_PIC1PORT2   0xa1
+#define PIC_NEEDICW4    (1<<0)
+#define PIC_ICW1    (1<<4)
+#define PIC_PIC1ID  1
+extern void i8259_init(void);
+extern void pic_enable_irqs(__u16 irqmask);
+extern void pic_disable_irqs(__u16 irqmask);
+extern void pic_eoi(void);
+extern void pic_spurious(__u8 n, __u32 stack[]);
+#endif

 /SPARTAN/trunk/arch/ia32/Makefile.inc
 ,0 → 1,50
+CC=gcc
+AS=as
+LD=ld
+DEFS:=-DARCH=$(ARCH)
+ifdef SMP
+DEFS+=-D$(SMP)
+endif
+ifdef HT
+DEFS+=-D$(HT)
+endif
+CPPFLAGS=$(DEFS) -nostdinc -I../include
+CFLAGS=$(CPPFLAGS) -nostdlib -fno-builtin -fomit-frame-pointer -Wmissing-prototypes -Werror -O3
+LFLAGS=-M -no-check-sections -T ../arch/ia32/_link.ld
+arch_sources= \
+    arch/context.s \
+    arch/debug/panic.s \
+    arch/cpuid.s \
+    arch/delay.s \
+    arch/asm.S \
+    arch/proc/scheduler.c \
+    arch/acpi/acpi.c \
+    arch/acpi/madt.c \
+    arch/bios/bios.c \
+    arch/smp/ap.S \
+    arch/smp/apic.c \
+    arch/smp/mps.c \
+    arch/smp/smp.c \
+    arch/atomic.S \
+    arch/smp/ipi.c \
+    arch/ia32.c \
+    arch/interrupt.c \
+    arch/pm.c \
+    arch/userspace.c \
+    arch/cpu/cpu.c \
+    arch/mm/frame.c \
+    arch/mm/memory_init.c \
+    arch/mm/page.c \
+    arch/mm/tlb.c \
+    arch/drivers/i8042.c \
+    arch/drivers/i8254.c \
+    arch/drivers/i8259.c \
+    arch/drivers/ega.c \
+    arch/boot/boot.S \
+    arch/boot/memmap.S\
+    arch/fpu_context.c

 /SPARTAN/trunk/arch/ia32/boot/boot.S
 ,0 → 1,151
+#
+# Copyright (C) 2001-2004 Jakub Jermar
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# This is a very primitive boot.s
+# It assumes that the first sector of the kernel image is found
+# on head 0, track 0, sector 2 of the first floppy drive (1440K).
+# Next kernel sectors follow on disk sector 3, 4, ...
+#
+# KERNEL_SIZE is passed from the outside to the preprocessor
+#if (KERNEL_SIZE%512>0)
+#define TAIL        1
+#else
+#define TAIL        0
+#endif
+#define SECTORS     (KERNEL_SIZE/512+TAIL)
+.text
+.global _start_0x7c00
+.code16
+_start_0x7c00:
+    xorw %ax,%ax        # reset, %al will be used below
+    movw %ax,%dx        # fd0, %dh and %dl will be used below
+    movw %dx,%ds
+    movw %dx,%ss        # initialize stack
+    movw $stack,%sp
+    int $0x13       # reset floppy
+    jc stop_trying
+    movw %dx,%ds
+    movw %dx,%ss
+    movw $0x7c00,%sp
+    movw $0xffe0,%si    # after next increment, %si will become 0x0000
+    movw %si,%es
+    movw $0x8000,%bx    # at %es:%bx
+    movl $(SECTORS),%edi
+read_next:
+    test %edi,%edi
+    jnz read_sectors
+    movb $12,%al
+    movw $0x3f2,%dx
+    outb %al,%dx
+    movb $('$'),%al
+    call echo_mark
+    jmpl $0,$0x8000
+read_sectors:
+    movb $('.'),%al
+    call echo_mark
+    decl %edi
+    incw logical_sector
+    movw %es,%si
+    addw $0x20,%si
+    movw %si,%es
+    movw logical_sector,%ax
+    divb sectors
+    movb %ah,%cl
+    incb %cl            # sector
+    movb %al,%ch
+    shrb $1,%ch         # track
+    movb %al,%dh
+    andb $1,%dh         # head
+    movw $0x0201,%ax
+    int $0x13
+    jnc read_next
+    movb $('R'),%al
+    call echo_mark
+    xorw %ax,%ax            # try to reset
+    movw %ax,%dx            # fd0
+    int $0x13
+    jnc read_next
+stop_trying:
+    movb $('F'),%al
+    call echo_mark
+    cli
+    hlt
+CH=4
+echo_mark:
+    push %bp
+    movw %sp,%bp
+    pusha
+    movb $0xe,%ah
+    movb $7,%bl
+    int $0x10
+    popa
+    pop %bp
+    ret
+# current logical sector from the beginning of the disk
+logical_sector:
+    .word 0
+# number of sectors per track on 1440 floppy
+sectors:
+    .byte 18
+# boot floppy signature
+.org 0x1fe
+boot_floppy_signature:
+    .byte 0x55
+    .byte 0xaa
+stack:

 /SPARTAN/trunk/arch/ia32/boot/Makefile
 ,0 → 1,19
+.PHONY: nothing build clean
+nothing:
+build: boot.bin
+    dd if=boot.bin of=../../../src/image.bin bs=512 conv=sync
+    -cat ../../../src/kernel.bin >>../../../src/image.bin
+    dd if=/dev/zero of=../../../src/image.bin bs=1 seek=1474559 count=1
+boot.bin: boot.o
+    ld -T boot.ld -entry _start_0x7c00 --oformat binary boot.o -o $@
+boot.o: boot.S
+    gcc -E -DKERNEL_SIZE=$(KERNEL_SIZE) boot.S >boot.s
+    as boot.s -o $@
+    rm boot.s
+clean:
+    -rm *.o *.bin

 /SPARTAN/trunk/arch/ia32/_link.ld
 ,0 → 1,43
+/** IA-32 linker script
+ *
+ * umapped section:
+ *  kernel text
+ *  kernel data
+ * mapped section:
+ *  kernel text
+ *  kernel data
+ */
+OUTPUT_FORMAT(binary)
+ENTRY(kernel_image_start)
+SECTIONS {
+    .unmapped 0x8000: AT (0x8000) {
+        unmapped_ktext_start = .;
+        *(K_TEXT_START);
+        *(K_TEXT_START_2);
+        unmapped_ktext_end = .;
+        unmapped_kdata_start = .;
+        *(K_DATA_START);
+        unmapped_kdata_end = .;
+    }
+    .mapped (0x80000000+SIZEOF(.unmapped)+0x8000) : AT (0x8000+SIZEOF(.unmapped)) {
+        ktext_start = .;
+        *(.text);
+        ktext_end = .;
+        kdata_start = .;
+        *(.data);       /* initialized data */
+        *(.rodata*);        /* string literals */
+        *(COMMON);      /* global variables */
+        *(.bss);        /* uninitialized static variables */
+        *(K_DATA_END);
+        kdata_end = .;
+    }
+    _hardcoded_ktext_size = ktext_end - ktext_start + (unmapped_ktext_end - unmapped_ktext_start);
+    _hardcoded_kdata_size = kdata_end - kdata_start + (unmapped_kdata_end - unmapped_kdata_start);
+    _hardcoded_load_address = 0x80008000;
+}

 /SPARTAN/trunk/arch/ppc/src/dummy.s
 ,0 → 1,79
+#
+# Copyright (C) 2005 Jakub Jermar
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+.text
+.global memcopy
+.global cpu_priority_high
+.global cpu_priority_low
+.global cpu_priority_read
+.global cpu_priority_restore
+.global memsetb
+.global context_save
+.global context_restore
+.global userspace
+.global before_thread_runs_arch
+.global panic_printf
+.global cpu_identify
+.global cpu_arch_init
+.global cpu_sleep
+.global cpu_print_report
+.global get_memory_size
+.global arch_pre_mm_init
+.global arch_post_mm_init
+.global arch_late_init
+.global calibrate_delay_loop
+.global asm_delay_loop
+.global dummy
+memcopy:
+cpu_priority_high:
+cpu_priority_low:
+cpu_priority_restore:
+cpu_priority_read:
+memsetb:
+context_save:
+context_restore:
+before_thread_runs_arch:
+userspace:
+calibrate_delay_loop:
+asm_delay_loop:
+panic_printf:
+cpu_identify:
+cpu_arch_init:
+cpu_sleep:
+cpu_print_report:
+get_memory_size:
+arch_pre_mm_init:
+arch_post_mm_init:
+arch_late_init:
+calibrate_delay_loop:
+dummy:
+:
+    bl 0b

 /SPARTAN/trunk/arch/ppc/src/drivers/vga.c
 ,0 → 1,92
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch/vga.h>
+#include <putchar.h>
+#include <mm/page.h>
+#include <synch/spinlock.h>
+#include <arch/types.h>
+#include <arch/asm.h>
+static spinlock_t vgalock;
+static __u32 vga_cursor;
+void vga_move_cursor(void);
+void vga_init(void)
+{
+}
+void vga_display_char(char ch)
+{
+//  __u8 *vram = (__u8 *) PA2KA(VIDEORAM);
+//  vram[vga_cursor*2] = ch;
+}
+/*
+ * This function takes care of scrolling.
+ */
+void vga_check_cursor(void)
+{
+}
+void vga_putchar(const char ch)
+{
+    pri_t pri;
+    pri = cpu_priority_high();
+    spinlock_lock(&vgalock);
+    switch (ch) {
+        case '\n':
+        vga_cursor = (vga_cursor + ROW) - vga_cursor % ROW;
+        break;
+        case '\t':
+        vga_cursor = (vga_cursor + 8) - vga_cursor % 8;
+        break;
+        default:
+        vga_display_char(ch);
+        vga_cursor++;
+        break;
+        }
+    vga_check_cursor();
+    vga_move_cursor();
+    spinlock_unlock(&vgalock);
+    cpu_priority_restore(pri);
+}
+void vga_move_cursor(void)
+{
+}
+void putchar(const char ch)
+{
+    vga_putchar(ch);
+}

 /SPARTAN/trunk/arch/ppc/src/ppc.c
 ,0 → 1,28
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */

 /SPARTAN/trunk/arch/ppc/src/mm/page.c
 ,0 → 1,37
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch/types.h>
+#include <arch/mm/page.h>
+#include <arch/mm/frame.h>
+#include <mm/frame.h>
+#include <mm/page.h>
+void page_arch_init(void)
+{
+}

 /SPARTAN/trunk/arch/ppc/src/mm/frame.c
 ,0 → 1,34
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch/mm/frame.h>
+#include <mm/frame.h>
+void frame_arch_init(void)
+{
+}

 /SPARTAN/trunk/arch/ppc/src/start.S
 ,0 → 1,34
+#
+# Copyright (C) 2005 Jakub Jermar
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+.section K_TEXT_START
+.global kernel_image_start
+kernel_image_start:
+    b main_bsp

 /SPARTAN/trunk/arch/ppc/src/asm.s
 ,0 → 1,34
+#
+# Copyright (C) 2005 Martin Decky
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+.text
+.global cpu_halt
+cpu_halt:
+    b cpu_halt

 /SPARTAN/trunk/arch/ppc/src/fpu_context.c
 ,0 → 1,49
+/*
+ * Copyright (C) 2005 Jakub Vana
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#include <fpu_context.h>
+void fpu_context_save(fpu_context_t *fctx)
+{
+}
+void fpu_context_restore(fpu_context_t *fctx)
+{
+}
+void fpu_lazy_context_save(fpu_context_t *fctx)
+{
+}
+void fpu_lazy_context_restore(fpu_context_t *fctx)
+{
+}

 /SPARTAN/trunk/arch/ppc/include/vga.h
 ,0 → 1,42
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __VGA_H__
+#define __VGA_H__
+#define ROW     80
+#define ROWS        25
+#define SCREEN      (ROW*ROWS)
+extern void vga_init(void);
+extern void vga_putchar(const char ch);
+static void vga_check_cursor(void);
+static void vga_display_char(char ch);
+#endif

 /SPARTAN/trunk/arch/ppc/include/interrupt.h
 ,0 → 1,34
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __INTERRUPT_H__
+#define __INTERRUPT_H__
+extern void interrupt(void);
+#endif

 /SPARTAN/trunk/arch/ppc/include/mm/page.h
 ,0 → 1,73
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ppc_PAGE_H__
+#define __ppc_PAGE_H__
+#include <mm/page.h>
+#include <arch/mm/frame.h>
+#include <arch/types.h>
+#define PAGE_SIZE   FRAME_SIZE
+#define KA2PA(x)    ((x) - 0x80000000)
+#define PA2KA(x)    ((x) + 0x80000000)
+#define PTL0_INDEX_ARCH(vaddr)      0
+#define PTL1_INDEX_ARCH(vaddr)      0
+#define PTL2_INDEX_ARCH(vaddr)      0
+#define PTL3_INDEX_ARCH(vaddr)      0
+#define GET_PTL0_ADDRESS_ARCH()     0
+#define SET_PTL0_ADDRESS_ARCH(ptl0)
+#define GET_PTL1_ADDRESS_ARCH(ptl0, i)      ((pte_t *) 0)
+#define GET_PTL2_ADDRESS_ARCH(ptl1, i)      ((pte_t *) 0)
+#define GET_PTL3_ADDRESS_ARCH(ptl2, i)      ((pte_t *) 0)
+#define GET_FRAME_ADDRESS_ARCH(ptl3, i)     ((pte_t *) 0)
+#define SET_PTL1_ADDRESS_ARCH(ptl0, i, a)
+#define SET_PTL2_ADDRESS_ARCH(ptl1, i, a)
+#define SET_PTL3_ADDRESS_ARCH(ptl2, i, a)
+#define SET_FRAME_ADDRESS_ARCH(ptl3, i, a)
+#define GET_PTL1_FLAGS_ARCH(ptl0, i)        0
+#define GET_PTL2_FLAGS_ARCH(ptl1, i)        0
+#define GET_PTL3_FLAGS_ARCH(ptl2, i)        0
+#define GET_FRAME_FLAGS_ARCH(ptl3, i)       0
+#define SET_PTL1_FLAGS_ARCH(ptl0, i, x)
+#define SET_PTL2_FLAGS_ARCH(ptl1, i, x)
+#define SET_PTL3_FLAGS_ARCH(ptl2, i, x)
+#define SET_FRAME_FLAGS_ARCH(ptl3, i, x)
+extern void page_arch_init(void);
+typedef __u32 pte_t;
+#endif

 /SPARTAN/trunk/arch/ppc/include/mm/frame.h
 ,0 → 1,36
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ppc_FRAME_H__
+#define __ppc_FRAME_H__
+#define FRAME_SIZE      4096
+extern void frame_arch_init(void);
+#endif

 /SPARTAN/trunk/arch/ppc/include/mm/memory_init.h
 ,0 → 1,36
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ppc_MEMORY_INIT_H__
+#define __ppc_MEMORY_INIT_H__
+#include <config.h>
+size_t get_memory_size(void);
+#endif

 /SPARTAN/trunk/arch/ppc/include/mm/vm.h
 ,0 → 1,43
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ppc_VM_H__
+#define __ppc_VM_H__
+#include <arch/types.h>
+#define KERNEL_ADDRESS_SPACE_START_ARCH     (__address) 0x80000000
+#define KERNEL_ADDRESS_SPACE_END_ARCH       (__address) 0xffffffff
+#define USER_ADDRESS_SPACE_START_ARCH       (__address) 0x00000000
+#define USER_ADDRESS_SPACE_END_ARCH     (__address) 0x7fffffff
+#define UTEXT_ADDRESS_ARCH  0x00001000
+#define USTACK_ADDRESS_ARCH (0x7fffffff-(PAGE_SIZE-1))
+#define UDATA_ADDRESS_ARCH  0x21000000
+#endif

 /SPARTAN/trunk/arch/ppc/include/types.h
 ,0 → 1,47
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __TYPES_H__
+#define __TYPES_H__
+#define NULL 0
+typedef signed char __s8;
+typedef unsigned char __u8;
+typedef unsigned short __u16;
+typedef unsigned long __u32;
+typedef long long __u64;
+typedef __u32 __address;
+typedef __u32 pri_t;
+typedef __u32 __native;
+#endif

 /SPARTAN/trunk/arch/ppc/include/cpu.h
 ,0 → 1,39
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ppc_CPU_H__
+#define __ppc_CPU_H__
+#include <typedefs.h>
+#define CPU_ID_ARCH 0
+struct cpu_arch {
+};
+#endif

 /SPARTAN/trunk/arch/ppc/include/thread.h
 ,0 → 1,34
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ppc_THREAD_H__
+#define __ppc_THREAD_H__
+#define ARCH_THREAD_DATA
+#endif

 /SPARTAN/trunk/arch/ppc/include/arg.h
 ,0 → 1,34
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ppc_ARG_H__
+#define __ppc_ARG_H__
+#include <stdarg.h>
+#endif

 /SPARTAN/trunk/arch/ppc/include/atomic.h
 ,0 → 1,45
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ppc_ATOMIC_H__
+#define __ppc_ATOMIC_H__
+/*
+ * TODO: these are just placeholders for real implementations of atomic_inc and atomic_dec.
+ * WARNING: the following functions cause the code to be preemption-unsafe !!!
+ */
+static inline atomic_inc(volatile int *val) {
+    *val++;
+}
+static inline atomic_dec(volatile int *val) {
+    *val--;
+}
+#endif

 /SPARTAN/trunk/arch/ppc/include/fpu_context.h
 ,0 → 1,37
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ppc_FPU_CONTEXT_H__
+#define __ppc_FPU_CONTEXT_H__
+#include <arch/types.h>
+struct fpu_context {
+};
+#endif

/SPARTAN/trunk/arch/ppc/include/asm.h
--- arch/ppc/include/faddr.h (nonexistent)
+++ arch/ppc/include/faddr.h (revision 168)
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __ppc_FADDR_H__
+#define __ppc_FADDR_H__
+
+#include <arch/types.h>
+
+#define FADDR(fptr) ((__address) (fptr))
+
+#endif

 /SPARTAN/trunk/arch/ppc/include/context.h
 ,0 → 1,43
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ppc_CONTEXT_H__
+#define __ppc_CONTEXT_H__
+#include <arch/types.h>
+#define SP_DELTA    0
+struct context {
+    __u32 sp;
+    __u32 pc;
+    pri_t pri;
+} __attribute__ ((packed));
+#endif

 /SPARTAN/trunk/arch/ppc/include/barrier.h
 ,0 → 1,35
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ppc_BARRIER_H__
+#define __ppc_BARRIER_H__
+#define CS_ENTER_BARRIER()  __asm__ volatile ("" ::: "memory")
+#define CS_LEAVE_BARRIER()  __asm__ volatile ("" ::: "memory")
+#endif

 /SPARTAN/trunk/arch/ppc/Makefile.inc
 ,0 → 1,25
+PPC_TARGET=ppc-linux-gnu
+PPC_CC_DIR=/usr/local/ppc/bin
+PPC_BINUTILS_DIR=/usr/local/ppc/bin
+CC=$(PPC_CC_DIR)/$(PPC_TARGET)-gcc
+AS=$(PPC_BINUTILS_DIR)/$(PPC_TARGET)-as
+LD=$(PPC_BINUTILS_DIR)/$(PPC_TARGET)-ld
+ASFLAGS=
+DEFS=-DARCH=$(ARCH)
+CPPFLAGS=$(DEFS) -nostdinc -I../include
+CFLAGS=$(CPPFLAGS) -nostdlib -fno-builtin -Wmissing-prototypes -Werror -O2
+LFLAGS=-M -no-check-sections -T ../arch/ppc/_link.ld
+arch_sources= \
+    arch/ppc.c \
+    arch/fpu_context.c \
+    arch/dummy.s \
+    arch/start.S \
+    arch/asm.s \
+    arch/mm/frame.c \
+    arch/mm/page.c \
+    arch/drivers/vga.c

 /SPARTAN/trunk/arch/ppc/boot/boot.s
 ,0 → 1,33
+#
+# Copyright (C) 2005 Martin Decky
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+.text
+.global start
+start:

 /SPARTAN/trunk/arch/ppc/boot/Makefile
 ,0 → 1,24
+PPC_BINUTILS_DIR=/usr/local/ppc/bin
+PPC_TARGET=ppc-linux-gnu
+.PHONY: nothing build
+nothing:
+build: boot.bin
+    cp boot.bin ../../../src/load.bin
+AS=$(PPC_BINUTILS_DIR)/$(PPC_TARGET)-as
+LD=$(PPC_BINUTILS_DIR)/$(PPC_TARGET)-ld
+ASFLAGS=
+LFLAGS=--oformat=binary -e start
+boot.bin: boot.o
+    $(LD) $(LFLAGS) boot.o -o $@
+boot.o:
+    $(AS) boot.s -o $@
+clean:
+    -rm *.o *.bin

 /SPARTAN/trunk/arch/ppc/_link.ld
 ,0 → 1,36
+/*
+ *  PPC linker script
+ *
+ *  It is ELF format, but its only section looks like this:
+ *  kernel text
+ *  kernel data
+ *
+ */
+OUTPUT_FORMAT(elf32-powerpc)
+ENTRY(kernel_image_start)
+SECTIONS {
+    .image 0x80000000: AT (0x80000000) {
+        ktext_start = .;
+        *(K_TEXT_START)
+        *(.text);
+        ktext_end = .;
+        kdata_start = .;
+        *(K_DATA_START)
+        *(.rodata);
+        *(.rodata.*);
+        *(.data);       /* initialized data */
+        *(.sdata);
+        *(.sbss);
+        *(.bss);        /* uninitialized static variables */
+        *(COMMON);      /* global variables */
+        kdata_end = .;
+    }
+    _hardcoded_ktext_size = ktext_end - ktext_start;
+    _hardcoded_kdata_size = kdata_end - kdata_start;
+    _hardcoded_load_address = 0x80000000;
+}

 /SPARTAN/trunk/arch/amd64/src/dummy.s
 ,0 → 1,85
+#
+# Copyright (C) 2005 Jakub Jermar
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+.text
+.global memcopy
+.global cpu_priority_high
+.global cpu_priority_low
+.global cpu_priority_read
+.global cpu_priority_restore
+.global memsetb
+.global context_save
+.global context_restore
+.global userspace
+.global before_thread_runs_arch
+.global panic_printf
+.global cpu_identify
+.global cpu_arch_init
+.global cpu_sleep
+.global cpu_print_report
+.global get_memory_size
+.global arch_pre_mm_init
+.global arch_post_mm_init
+.global arch_late_init
+.global calibrate_delay_loop
+.global asm_delay_loop
+.global cpu_halt
+.global page_arch_init
+.global frame_arch_init
+.global dummy
+memcopy:
+cpu_priority_high:
+cpu_priority_low:
+cpu_priority_restore:
+cpu_priority_read:
+memsetb:
+context_save:
+context_restore:
+before_thread_runs_arch:
+userspace:
+calibrate_delay_loop:
+asm_delay_loop:
+panic_printf:
+cpu_identify:
+cpu_arch_init:
+cpu_sleep:
+cpu_print_report:
+get_memory_size:
+arch_pre_mm_init:
+arch_post_mm_init:
+arch_late_init:
+calibrate_delay_loop:
+cpu_halt:
+page_arch_init:
+frame_arch_init:
+dummy:
+:
+    ret

 /SPARTAN/trunk/arch/amd64/src/fpu_context.c
 ,0 → 1,49
+/*
+ * Copyright (C) 2005 Jakub Vana
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#include <fpu_context.h>
+void fpu_context_save(fpu_context_t *fctx)
+{
+}
+void fpu_context_restore(fpu_context_t *fctx)
+{
+}
+void fpu_lazy_context_save(fpu_context_t *fctx)
+{
+}
+void fpu_lazy_context_restore(fpu_context_t *fctx)
+{
+}

 /SPARTAN/trunk/arch/amd64/src/boot/boot.S
 ,0 → 1,51
+#
+# Copyright (C) 2001-2004 Jakub Jermar
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+.section K_TEXT_START
+.global kernel_image_start
+.code16
+#
+# This is where we require any SPARTAN-kernel-compatible boot loader
+# to pass control in real mode.
+#
+# Protected mode tables are statically initialised during compile
+# time. So we can just load the respective table registers and
+# switch to protected mode.
+#
+kernel_image_start:
+meeting_point:
+.code32
+.section K_DATA_START
+.align 4096
+page_directory:
+    .space 4096, 0

 /SPARTAN/trunk/arch/amd64/src/putchar.c
 ,0 → 1,35
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <putchar.h>
+#include <arch/types.h>
+void putchar(const char ch)
+{
+}

 /SPARTAN/trunk/arch/amd64/boot/Makefile
 ,0 → 1,19
+.PHONY: nothing build clean
+nothing:
+build: boot.bin
+    dd if=boot.bin of=../../../src/image.bin bs=512 conv=sync
+    -cat ../../../src/kernel.bin >>../../../src/image.bin
+    dd if=/dev/zero of=../../../src/image.bin bs=1 seek=1474559 count=1
+boot.bin: boot.o
+    ld -T boot.ld -entry _start_0x7c00 --oformat binary boot.o -o $@
+boot.o: boot.S
+    gcc -E -DKERNEL_SIZE=$(KERNEL_SIZE) boot.S >boot.s
+    as boot.s -o $@
+    rm boot.s
+clean:
+    -rm *.o *.bin

 /SPARTAN/trunk/arch/amd64/boot/boot.S
 ,0 → 1,151
+#
+# Copyright (C) 2001-2004 Jakub Jermar
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# This is a very primitive boot.s
+# It assumes that the first sector of the kernel image is found
+# on head 0, track 0, sector 2 of the first floppy drive (1440K).
+# Next kernel sectors follow on disk sector 3, 4, ...
+#
+# KERNEL_SIZE is passed from the outside to the preprocessor
+#if (KERNEL_SIZE%512>0)
+#define TAIL        1
+#else
+#define TAIL        0
+#endif
+#define SECTORS     (KERNEL_SIZE/512+TAIL)
+.text
+.global _start_0x7c00
+.code16
+_start_0x7c00:
+    xorw %ax,%ax        # reset, %al will be used below
+    movw %ax,%dx        # fd0, %dh and %dl will be used below
+    movw %dx,%ds
+    movw %dx,%ss        # initialize stack
+    movw $stack,%sp
+    int $0x13       # reset floppy
+    jc stop_trying
+    movw %dx,%ds
+    movw %dx,%ss
+    movw $0x7c00,%sp
+    movw $0xffe0,%si    # after next increment, %si will become 0x0000
+    movw %si,%es
+    movw $0x8000,%bx    # at %es:%bx
+    movl $(SECTORS),%edi
+read_next:
+    test %edi,%edi
+    jnz read_sectors
+    movb $12,%al
+    movw $0x3f2,%dx
+    outb %al,%dx
+    movb $('$'),%al
+    call echo_mark
+    jmpl $0,$0x8000
+read_sectors:
+    movb $('.'),%al
+    call echo_mark
+    decl %edi
+    incw logical_sector
+    movw %es,%si
+    addw $0x20,%si
+    movw %si,%es
+    movw logical_sector,%ax
+    divb sectors
+    movb %ah,%cl
+    incb %cl            # sector
+    movb %al,%ch
+    shrb $1,%ch         # track
+    movb %al,%dh
+    andb $1,%dh         # head
+    movw $0x0201,%ax
+    int $0x13
+    jnc read_next
+    movb $('R'),%al
+    call echo_mark
+    xorw %ax,%ax            # try to reset
+    movw %ax,%dx            # fd0
+    int $0x13
+    jnc read_next
+stop_trying:
+    movb $('F'),%al
+    call echo_mark
+    cli
+    hlt
+CH=4
+echo_mark:
+    push %bp
+    movw %sp,%bp
+    pusha
+    movb $0xe,%ah
+    movb $7,%bl
+    int $0x10
+    popa
+    pop %bp
+    ret
+# current logical sector from the beginning of the disk
+logical_sector:
+    .word 0
+# number of sectors per track on 1440 floppy
+sectors:
+    .byte 18
+# boot floppy signature
+.org 0x1fe
+boot_floppy_signature:
+    .byte 0x55
+    .byte 0xaa
+stack:

 /SPARTAN/trunk/arch/amd64/include/arg.h
 ,0 → 1,34
+/*
+ * Copyright (C) 2005 Ondrej Palkovsky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __amd64_ARG_H__
+#define __amd64_ARG_H__
+#include <stdarg.h>
+#endif

 /SPARTAN/trunk/arch/amd64/include/atomic.h
 ,0 → 1,45
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __amd64_ATOMIC_H__
+#define __amd64_ATOMIC_H__
+/*
+ * TODO: these are just placeholders for real implementations of atomic_inc and atomic_dec.
+ * WARNING: the following functions cause the code to be preemption-unsafe !!!
+ */
+static inline atomic_inc(volatile int *val) {
+    *val++;
+}
+static inline atomic_dec(volatile int *val) {
+    *val--;
+}
+#endif

 /SPARTAN/trunk/arch/amd64/include/interrupt.h
 ,0 → 1,34
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __INTERRUPT_H__
+#define __INTERRUPT_H__
+extern void interrupt(void);
+#endif

/SPARTAN/trunk/arch/amd64/include/pm.h
--- arch/amd64/include/fpu_context.h (nonexistent)
+++ arch/amd64/include/fpu_context.h (revision 168)
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __amd64_FPU_CONTEXT_H__
+#define __amd64_FPU_CONTEXT_H__
+
+#include <arch/types.h>
+
+struct fpu_context {
+};
+
+#endif

/SPARTAN/trunk/arch/amd64/include/asm.h
--- arch/amd64/include/faddr.h (nonexistent)
+++ arch/amd64/include/faddr.h (revision 168)
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __amd64_FADDR_H__
+#define __amd64_FADDR_H__
+
+#include <arch/types.h>
+
+#define FADDR(fptr) ((__address) (fptr))
+
+#endif

 /SPARTAN/trunk/arch/amd64/include/mm/frame.h
 ,0 → 1,36
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __amd64_FRAME_H__
+#define __amd64_FRAME_H__
+#define FRAME_SIZE      4096
+extern void frame_arch_init(void);
+#endif

 /SPARTAN/trunk/arch/amd64/include/mm/memory_init.h
 ,0 → 1,36
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __amd64_MEMORY_INIT_H__
+#define __amd64_MEMORY_INIT_H__
+#include <config.h>
+size_t get_memory_size(void);
+#endif

 /SPARTAN/trunk/arch/amd64/include/mm/page.h
 ,0 → 1,73
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __amd64_PAGE_H__
+#define __amd64_PAGE_H__
+#include <mm/page.h>
+#include <arch/mm/frame.h>
+#include <arch/types.h>
+#define PAGE_SIZE   FRAME_SIZE
+#define KA2PA(x)    ((x) - 0x80000000)
+#define PA2KA(x)    ((x) + 0x80000000)
+#define PTL0_INDEX_ARCH(vaddr)      0
+#define PTL1_INDEX_ARCH(vaddr)      0
+#define PTL2_INDEX_ARCH(vaddr)      0
+#define PTL3_INDEX_ARCH(vaddr)      0
+#define GET_PTL0_ADDRESS_ARCH()     0
+#define SET_PTL0_ADDRESS_ARCH(ptl0)
+#define GET_PTL1_ADDRESS_ARCH(ptl0, i)      ((pte_t *) 0)
+#define GET_PTL2_ADDRESS_ARCH(ptl1, i)      ((pte_t *) 0)
+#define GET_PTL3_ADDRESS_ARCH(ptl2, i)      ((pte_t *) 0)
+#define GET_FRAME_ADDRESS_ARCH(ptl3, i)     ((pte_t *) 0)
+#define SET_PTL1_ADDRESS_ARCH(ptl0, i, a)
+#define SET_PTL2_ADDRESS_ARCH(ptl1, i, a)
+#define SET_PTL3_ADDRESS_ARCH(ptl2, i, a)
+#define SET_FRAME_ADDRESS_ARCH(ptl3, i, a)
+#define GET_PTL1_FLAGS_ARCH(ptl0, i)        0
+#define GET_PTL2_FLAGS_ARCH(ptl1, i)        0
+#define GET_PTL3_FLAGS_ARCH(ptl2, i)        0
+#define GET_FRAME_FLAGS_ARCH(ptl3, i)       0
+#define SET_PTL1_FLAGS_ARCH(ptl0, i, x)
+#define SET_PTL2_FLAGS_ARCH(ptl1, i, x)
+#define SET_PTL3_FLAGS_ARCH(ptl2, i, x)
+#define SET_FRAME_FLAGS_ARCH(ptl3, i, x)
+extern void page_arch_init(void);
+typedef __u32 pte_t;
+#endif

 /SPARTAN/trunk/arch/amd64/include/mm/vm.h
 ,0 → 1,43
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __amd64_VM_H__
+#define __amd64_VM_H__
+#include <arch/types.h>
+#define KERNEL_ADDRESS_SPACE_START_ARCH     (__address) 0x80000000
+#define KERNEL_ADDRESS_SPACE_END_ARCH       (__address) 0xffffffff
+#define USER_ADDRESS_SPACE_START_ARCH       (__address) 0x00000000
+#define USER_ADDRESS_SPACE_END_ARCH     (__address) 0x7fffffff
+#define UTEXT_ADDRESS_ARCH  0x00001000
+#define USTACK_ADDRESS_ARCH (0x7fffffff-(PAGE_SIZE-1))
+#define UDATA_ADDRESS_ARCH  0x21000000
+#endif

 /SPARTAN/trunk/arch/amd64/include/context.h
 ,0 → 1,43
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __amd64_CONTEXT_H__
+#define __amd64_CONTEXT_H__
+#include <arch/types.h>
+#define SP_DELTA    0
+struct context {
+    __u64 sp;
+    __u64 pc;
+    pri_t pri;
+} __attribute__ ((packed));
+#endif

 /SPARTAN/trunk/arch/amd64/include/types.h
 ,0 → 1,47
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __TYPES_H__
+#define __TYPES_H__
+#define NULL 0
+typedef signed char __s8;
+typedef unsigned char __u8;
+typedef unsigned short __u16;
+typedef unsigned int __u32;
+typedef long long __u64;
+typedef __u64 __address;
+typedef __u32 pri_t;
+typedef __u64 __native;
+#endif

 /SPARTAN/trunk/arch/amd64/include/barrier.h
 ,0 → 1,35
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ppc_BARRIER_H__
+#define __ppc_BARRIER_H__
+#define CS_ENTER_BARRIER()  __asm__ volatile ("" ::: "memory")
+#define CS_LEAVE_BARRIER()  __asm__ volatile ("" ::: "memory")
+#endif

 /SPARTAN/trunk/arch/amd64/include/cpu.h
 ,0 → 1,56
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __amd64_CPU_H__
+#define __amd64_CPU_H__
+#include <config.h>
+#include <proc/thread.h>
+#include <typedefs.h>
+#include <arch/pm.h>
+#include <arch/asm.h>
+#ifdef __SMP__
+#define CPU_ID_ARCH (read_dr0())
+#else
+#define CPU_ID_ARCH (0)
+#endif
+struct cpu_arch {
+    int vendor;
+    int family;
+    int model;
+    int stepping;
+    struct tss *tss;
+};
+void set_TS_flag(void);
+void reset_TS_flag(void);
+#endif

 /SPARTAN/trunk/arch/amd64/include/thread.h
 ,0 → 1,34
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __amd64_THREAD_H__
+#define __amd64_THREAD_H__
+#define ARCH_THREAD_DATA
+#endif

 /SPARTAN/trunk/arch/amd64/Makefile.inc
 ,0 → 1,19
+AMD64_TARGET=amd64-linux-gnu
+AMD64_CC_DIR=/usr/local/amd64/bin
+AMD64_BINUTILS_DIR=/usr/local/amd64/bin
+CC=$(AMD64_CC_DIR)/$(AMD64_TARGET)-gcc
+AS=$(AMD64_BINUTILS_DIR)/$(AMD64_TARGET)-as
+LD=$(AMD64_BINUTILS_DIR)/$(AMD64_TARGET)-ld
+#ASFLAGS=--64
+DEFS=-DARCH=$(ARCH)
+CPPFLAGS=$(DEFS) -nostdinc -I../include
+CFLAGS=$(CPPFLAGS) -nostdlib -fno-builtin -fno-unwind-tables -Wmissing-prototypes -Werror -O3 -march=opteron -m64 -mcmodel=kernel
+LFLAGS=-M -T ../arch/amd64/_link.ld
+arch_sources = arch/dummy.s \
+    arch/fpu_context.c \
+    arch/putchar.c \
+    arch/boot/boot.S

 /SPARTAN/trunk/arch/amd64/_link.ld
 ,0 → 1,43
+/** IA-32 linker script
+ *
+ * umapped section:
+ *  kernel text
+ *  kernel data
+ * mapped section:
+ *  kernel text
+ *  kernel data
+ */
+OUTPUT_FORMAT(binary)
+ENTRY(kernel_image_start)
+SECTIONS {
+    .unmapped 0x8000: AT (0x8000) {
+        unmapped_ktext_start = .;
+        *(K_TEXT_START);
+        *(K_TEXT_START_2);
+        unmapped_ktext_end = .;
+        unmapped_kdata_start = .;
+        *(K_DATA_START);
+        unmapped_kdata_end = .;
+    }
+    .mapped (-0x80000000+SIZEOF(.unmapped)) : AT (0x8000+SIZEOF(.unmapped)) {
+        ktext_start = .;
+        *(.text);
+        ktext_end = .;
+        kdata_start = .;
+        *(.data);       /* initialized data */
+        *(.rodata*);        /* string literals */
+        *(COMMON);      /* global variables */
+        *(.bss);        /* uninitialized static variables */
+        *(K_DATA_END);
+        kdata_end = .;
+    }
+    _hardcoded_ktext_size = ktext_end - ktext_start + (unmapped_ktext_end - unmapped_ktext_start);
+    _hardcoded_kdata_size = kdata_end - kdata_start + (unmapped_kdata_end - unmapped_kdata_start);
+    _hardcoded_load_address = -0x80008000;
+}

 /SPARTAN/trunk/arch/ia64/Makefile.inc
 ,0 → 1,25
+IA-64_TARGET=ia64-pc-linux-gnu
+IA-64_CC_DIR=/usr/local/ia64/bin
+IA-64_BINUTILS_DIR=/usr/local/ia64/bin
+CC=$(IA-64_CC_DIR)/$(IA-64_TARGET)-gcc
+AS=$(IA-64_BINUTILS_DIR)/$(IA-64_TARGET)-as
+LD=$(IA-64_BINUTILS_DIR)/$(IA-64_TARGET)-ld
+ASFLAGS=-mconstant-gp
+DEFS=-DARCH=$(ARCH)
+CPPFLAGS=$(DEFS) -nostdinc -I../include
+CFLAGS=$(CPPFLAGS) -mconstant-gp -nostdlib -fno-builtin -fno-unwind-tables -Wmissing-prototypes -Werror -O3
+LFLAGS=-EL -M -T ../arch/ia64/_link.ld
+arch_sources= \
+    arch/start.S \
+    arch/asm.S \
+    arch/dummy.s \
+    arch/putchar.c \
+    arch/ia64.c \
+    arch/fpu_context.c \
+    arch/context.S \
+    arch/ski/ski.c

 /SPARTAN/trunk/arch/ia64/src/dummy.s
 ,0 → 1,64
+#
+# Copyright (C) 2005 Jakub Jermar
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+.text
+.global calibrate_delay_loop
+.global asm_delay_loop
+.global userspace
+.global before_thread_runs_arch
+.global arch_late_init
+.global cpu_arch_init
+.global cpu_identify
+.global cpu_print_report
+.global cpu_priority_high
+.global cpu_priority_low
+.global cpu_priority_read
+.global cpu_priority_restore
+.global cpu_sleep
+.global frame_arch_init
+.global dummy
+before_thread_runs_arch:
+userspace:
+calibrate_delay_loop:
+asm_delay_loop:
+arch_late_init:
+cpu_arch_init:
+cpu_identify:
+cpu_print_report:
+cpu_priority_high:
+cpu_priority_low:
+cpu_priority_read:
+cpu_priority_restore:
+cpu_sleep:
+frame_arch_init:
+dummy:
+    br.ret.sptk.many b0

 /SPARTAN/trunk/arch/ia64/src/start.S
 ,0 → 1,71
+#
+# Copyright (C) 2005 Jakub Jermar
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+.section K_TEXT_START
+.global kernel_image_start
+stack0:
+kernel_image_start:
+    .auto
+    # initialize PSR
+    mov psr.l = r0
+    # initialize register stack
+    mov ar.rsc = r0
+    mov ar.bspstore = r0
+    loadrs
+    .explicit
+    # initialize memory stack to some sane value
+    movl r12 = stack0   ;;
+    add r12 = - 16, r12 /* allocate a scratch area on the stack */
+    # initialize gp (Global Pointer) register
+    movl r1 = _hardcoded_load_address
+    ;;
+    #
+    # Initialize hardcoded_* variables.
+    #
+    movl r14 = _hardcoded_ktext_size
+    movl r15 = _hardcoded_kdata_size
+    movl r16 = _hardcoded_load_address
+    addl r17 = @gprel(hardcoded_ktext_size), gp
+    addl r18 = @gprel(hardcoded_kdata_size), gp
+    addl r19 = @gprel(hardcoded_load_address), gp
+    ;;
+    st4 [r17] = r14
+    st4 [r18] = r15
+    st8 [r19] = r16
+    br.call.sptk.many b0=main_bsp
+:
+    br 0b

 /SPARTAN/trunk/arch/ia64/src/fpu_context.c
 ,0 → 1,48
+/*
+ * Copyright (C) 2005 Jakub Vana
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#include <fpu_context.h>
+void fpu_context_save(fpu_context_t *fctx)
+{
+}
+void fpu_context_restore(fpu_context_t *fctx)
+{
+}
+void fpu_lazy_context_save(fpu_context_t *fctx)
+{
+}
+void fpu_lazy_context_restore(fpu_context_t *fctx)
+{
+}

 /SPARTAN/trunk/arch/ia64/src/asm.S
 ,0 → 1,59
+#
+# Copyright (C) 2005 Jakub Jermar
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+.text
+.global memcpy
+memcpy:
+    /*
+     * Switch the role of first two arguments
+     */
+    sub r33 = r33, r32  ;;
+    add r32 = r32, r33  ;;
+    sub r33 = r32, r33
+    br _memcopy
+.global memcopy
+memcopy:
+    br _memcopy
+.global memsetb
+memsetb:
+    br _memsetb
+.global cpu_halt
+cpu_halt:
+    br cpu_halt
+.global panic_printf
+panic_printf:
+    {
+        br.call.sptk.many b0=printf
+    }
+    br cpu_halt

 /SPARTAN/trunk/arch/ia64/src/ia64.c
 ,0 → 1,39
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch.h>
+#include <arch/ski/ski.h>
+void arch_pre_mm_init(void)
+{
+    ski_init_console();
+}
+void arch_post_mm_init(void)
+{
+}

 /SPARTAN/trunk/arch/ia64/src/context.S
 ,0 → 1,256
+#
+# Copyright (C) 2005 Jakub Jermar
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+.text
+.global context_save
+.global context_restore
+context_save:
+    alloc loc0 = ar.pfs, 1, 11, 0, 0
+    mov loc1 = ar.unat  ;;
+    /* loc2 */
+    mov loc3 = ar.rsc
+    .auto
+    /*
+     * Flush dirty registers to backing store.
+     * After this ar.bsp and ar.bspstore are equal.
+     */
+    flushrs
+    mov loc4 = ar.bsp
+    /*
+     * Put RSE to enforced lazy mode.
+     * So that ar.rnat can be read.
+     */
+    movl loc5 = ~3
+    and loc5 = loc3, loc5
+    mov ar.rsc = loc5
+    mov loc5 = ar.rnat
+    .explicit
+    mov loc6 = ar.lc
+    mov loc7 = ar.ec
+    mov loc8 = ar.ccv
+    mov loc9 = ar.csd
+    mov loc10 = ar.ssd
+    /*
+     * Save application registers
+     */
+    st8 [in0] = loc0, 8 ;;  /* save ar.pfs */
+    st8 [in0] = loc1, 8 ;;  /* save ar.unat (caller) */
+    mov loc2 = in0      ;;
+    add in0 = 8, in0    ;;  /* skip ar.unat (callee) */
+    st8 [in0] = loc3, 8 ;;  /* save ar.rsc */
+    st8 [in0] = loc4, 8 ;;  /* save ar.bsp */
+    st8 [in0] = loc5, 8 ;;  /* save ar.rnat */
+    st8 [in0] = loc6, 8 ;;  /* save ar.lc */
+    st8 [in0] = loc7, 8 ;;  /* save ar.ec */
+    st8 [in0] = loc8, 8 ;;  /* save ar.ccv */
+    st8 [in0] = loc9, 8 ;;  /* save ar.csd */
+    st8 [in0] = loc10, 8    ;;  /* save ar.ssd */
+    /*
+     * Save general registers including NaT bits
+     */
+    st8.spill [in0] = r1, 8     ;;
+    st8.spill [in0] = r2, 8     ;;
+    st8.spill [in0] = r3, 8     ;;
+    st8.spill [in0] = r4, 8     ;;
+    st8.spill [in0] = r5, 8     ;;
+    st8.spill [in0] = r6, 8     ;;
+    st8.spill [in0] = r7, 8     ;;
+    st8.spill [in0] = r8, 8     ;;
+    st8.spill [in0] = r9, 8     ;;
+    st8.spill [in0] = r10, 8    ;;
+    st8.spill [in0] = r11, 8    ;;
+    st8.spill [in0] = r12, 8    ;;  /* save sp */
+    st8.spill [in0] = r13, 8    ;;
+    st8.spill [in0] = r14, 8    ;;
+    st8.spill [in0] = r15, 8    ;;
+    st8.spill [in0] = r16, 8    ;;
+    st8.spill [in0] = r17, 8    ;;
+    st8.spill [in0] = r18, 8    ;;
+    st8.spill [in0] = r19, 8    ;;
+    st8.spill [in0] = r20, 8    ;;
+    st8.spill [in0] = r21, 8    ;;
+    st8.spill [in0] = r22, 8    ;;
+    st8.spill [in0] = r23, 8    ;;
+    st8.spill [in0] = r24, 8    ;;
+    st8.spill [in0] = r25, 8    ;;
+    st8.spill [in0] = r26, 8    ;;
+    st8.spill [in0] = r27, 8    ;;
+    st8.spill [in0] = r28, 8    ;;
+    st8.spill [in0] = r29, 8    ;;
+    st8.spill [in0] = r30, 8    ;;
+    st8.spill [in0] = r31, 8    ;;
+    mov loc3 = ar.unat      ;;
+    st8 [loc2] = loc3       /* save ar.unat (callee) */
+    /*
+     * Save branch registers
+     */
+    mov loc2 = b0       ;;
+    st8 [in0] = loc2, 8     /* save pc */
+    mov loc3 = b1       ;;
+    st8 [in0] = loc3, 8
+    mov loc4 = b2       ;;
+    st8 [in0] = loc4, 8
+    mov loc5 = b3       ;;
+    st8 [in0] = loc5, 8
+    mov loc6 = b4       ;;
+    st8 [in0] = loc6, 8
+    mov loc7 = b5       ;;
+    st8 [in0] = loc7, 8
+    mov loc8 = b6       ;;
+    st8 [in0] = loc8, 8
+    mov loc9 = b7       ;;
+    st8 [in0] = loc9, 8
+    /*
+     * Save predicate registers
+     */
+    mov loc2 = pr       ;;
+    st8 [in0] = loc2, 8
+    mov ar.pfs = loc0
+    mov ar.unat = loc1
+    add r8 = r0, r0, 1      /* context_save returns 1 */
+    br.ret.sptk.many b0
+context_restore:
+    alloc loc0 = ar.pfs, 1, 11, 0, 0    ;;
+    ld8 loc0 = [in0], 8 ;;  /* load ar.pfs */
+    ld8 loc1 = [in0], 8 ;;  /* load ar.unat (caller) */
+    ld8 loc2 = [in0], 8 ;;  /* load ar.unat (callee) */
+    ld8 loc3 = [in0], 8 ;;  /* load ar.rsc */
+    ld8 loc4 = [in0], 8 ;;  /* load ar.bsp */
+    ld8 loc5 = [in0], 8 ;;  /* load ar.rnat */
+    ld8 loc6 = [in0], 8 ;;  /* load ar.lc */
+    ld8 loc7 = [in0], 8 ;;  /* load ar.ec */
+    ld8 loc8 = [in0], 8 ;;  /* load ar.ccv */
+    ld8 loc9 = [in0], 8 ;;  /* load ar.csd */
+    ld8 loc10 = [in0], 8    ;;  /* load ar.ssd */
+    .auto
+    /*
+     * Invalidate the ALAT
+     */
+    invala
+    /*
+     * Restore application registers
+     */
+    mov ar.bspstore = loc4
+    mov ar.rnat = loc5
+    mov ar.pfs = loc0
+    mov ar.rsc = loc3
+    .explicit
+    mov ar.unat = loc2  ;;
+    mov ar.lc = loc6
+    mov ar.ec = loc7
+    mov ar.ccv = loc8
+    mov ar.csd = loc9
+    mov ar.ssd = loc10
+    /*
+     * Restore general registers including NaT bits
+     */
+    ld8.fill r1 = [in0], 8  ;;
+    ld8.fill r2 = [in0], 8  ;;
+    ld8.fill r3 = [in0], 8  ;;
+    ld8.fill r4 = [in0], 8  ;;
+    ld8.fill r5 = [in0], 8  ;;
+    ld8.fill r6 = [in0], 8  ;;
+    ld8.fill r7 = [in0], 8  ;;
+    ld8.fill r8 = [in0], 8  ;;
+    ld8.fill r9 = [in0], 8  ;;
+    ld8.fill r10 = [in0], 8 ;;
+    ld8.fill r11 = [in0], 8 ;;
+    ld8.fill r12 = [in0], 8 ;;  /* restore sp */
+    ld8.fill r13 = [in0], 8 ;;
+    ld8.fill r14 = [in0], 8 ;;
+    ld8.fill r15 = [in0], 8 ;;
+    ld8.fill r16 = [in0], 8 ;;
+    ld8.fill r17 = [in0], 8 ;;
+    ld8.fill r18 = [in0], 8 ;;
+    ld8.fill r19 = [in0], 8 ;;
+    ld8.fill r20 = [in0], 8 ;;
+    ld8.fill r21 = [in0], 8 ;;
+    ld8.fill r22 = [in0], 8 ;;
+    ld8.fill r23 = [in0], 8 ;;
+    ld8.fill r24 = [in0], 8 ;;
+    ld8.fill r25 = [in0], 8 ;;
+    ld8.fill r26 = [in0], 8 ;;
+    ld8.fill r27 = [in0], 8 ;;
+    ld8.fill r28 = [in0], 8 ;;
+    ld8.fill r29 = [in0], 8 ;;
+    ld8.fill r30 = [in0], 8 ;;
+    ld8.fill r31 = [in0], 8 ;;
+    /*
+     * Restore branch registers
+     */
+    ld8 loc2 = [in0], 8 ;;  /* restore pc */
+    mov b0 = loc2
+    ld8 loc3 = [in0], 8 ;;
+    mov b1 = loc3
+    ld8 loc4 = [in0], 8 ;;
+    mov b2 = loc4
+    ld8 loc5 = [in0], 8 ;;
+    mov b3 = loc5
+    ld8 loc6 = [in0], 8 ;;
+    mov b4 = loc6
+    ld8 loc7 = [in0], 8 ;;
+    mov b5 = loc7
+    ld8 loc8 = [in0], 8 ;;
+    mov b6 = loc8
+    ld8 loc9 = [in0], 8 ;;
+    mov b7 = loc9
+    /*
+     * Restore predicate registers
+     */
+    ld8 loc2 = [in0], 8 ;;
+    mov pr = loc2, ~0
+    mov ar.unat = loc1
+    mov r8 = r0         /* context_restore returns 0 */
+    br.ret.sptk.many b0

 /SPARTAN/trunk/arch/ia64/src/ski/ski.c
 ,0 → 1,66
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch/ski/ski.h>
+/** Initialize debug console
+ *
+ * Issue SSC (Simulator System Call) to
+ * to open debug console.
+ */
+void ski_init_console(void)
+{
+    __asm__ (
+        "mov r15=%0\n"
+        "break 0x80000\n"
+        :
+        : "i" (SKI_INIT_CONSOLE)
+        : "r15", "r8"
+    );
+}
+/** Display character on debug console
+ *
+ * Use SSC (Simulator System Call) to
+ * display character on debug console.
+ *
+ * @param ch   Character to be printed.
+ */
+void ski_putchar(const char ch)
+{
+    __asm__ (
+        "mov r15=%0\n"
+        "mov r32=%1\n"      /* r32 is in0 */
+        "break 0x80000\n"   /* modifies r8 */
+        :
+        : "i" (SKI_PUTCHAR), "r" (ch)
+        : "r15", "in0", "r8"
+    );
+    if (ch == '\n') ski_putchar('\r');
+}

 /SPARTAN/trunk/arch/ia64/src/putchar.c
 ,0 → 1,35
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <putchar.h>
+#include <arch/ski/ski.h>
+void putchar(const char ch)
+{
+    ski_putchar(ch);
+}

 /SPARTAN/trunk/arch/ia64/include/barrier.h
 ,0 → 1,38
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ia64_BARRIER_H__
+#define __ia64_BARRIER_H__
+/*
+ * TODO: Implement true IA-64 memory barriers for macros below.
+ */
+#define CS_ENTER_BARRIER()  __asm__ volatile ("" ::: "memory")
+#define CS_LEAVE_BARRIER()  __asm__ volatile ("" ::: "memory")
+#endif

 /SPARTAN/trunk/arch/ia64/include/mm/memory_init.h
 ,0 → 1,36
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ia64_MEMORY_INIT_H__
+#define __ia64_MEMORY_INIT_H__
+#include <config.h>
+#define get_memory_size()   CONFIG_MEMORY_SIZE
+#endif

 /SPARTAN/trunk/arch/ia64/include/mm/page.h
 ,0 → 1,75
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ia64_PAGE_H__
+#define __ia64_PAGE_H__
+#include <arch/types.h>
+#include <arch/mm/frame.h>
+#define PAGE_SIZE   FRAME_SIZE
+#define KA2PA(x)    ((x)-0x8000000000000000)
+#define PA2KA(x)    ((x)+0x8000000000000000)
+#define page_arch_init()    ;
+/*
+ * Implementation of generic 4-level page table interface.
+ * TODO: this is a fake implementation provided to satisfy the compiler
+ */
+#define PTL0_INDEX_ARCH(vaddr)  0
+#define PTL1_INDEX_ARCH(vaddr)  0
+#define PTL2_INDEX_ARCH(vaddr)  0
+#define PTL3_INDEX_ARCH(vaddr)  0
+#define GET_PTL0_ADDRESS_ARCH()         ((pte_t *) 0)
+#define GET_PTL1_ADDRESS_ARCH(ptl0, i)      ((pte_t *) 0)
+#define GET_PTL2_ADDRESS_ARCH(ptl1, i)      ((pte_t *) 0)
+#define GET_PTL3_ADDRESS_ARCH(ptl2, i)      ((pte_t *) 0)
+#define GET_FRAME_ADDRESS_ARCH(ptl3, i)     ((pte_t *) 0)
+#define SET_PTL0_ADDRESS_ARCH(ptl0)
+#define SET_PTL1_ADDRESS_ARCH(ptl0, i, a)
+#define SET_PTL2_ADDRESS_ARCH(ptl1, i, a)
+#define SET_PTL3_ADDRESS_ARCH(ptl2, i, a)
+#define SET_FRAME_ADDRESS_ARCH(ptl3, i, a)
+#define GET_PTL1_FLAGS_ARCH(ptl0, i)        0
+#define GET_PTL2_FLAGS_ARCH(ptl1, i)        0
+#define GET_PTL3_FLAGS_ARCH(ptl2, i)        0
+#define GET_FRAME_FLAGS_ARCH(ptl3, i)       0
+#define SET_PTL1_FLAGS_ARCH(ptl0, i, x)
+#define SET_PTL2_FLAGS_ARCH(ptl1, i, x)
+#define SET_PTL3_FLAGS_ARCH(ptl2, i, x)
+#define SET_FRAME_FLAGS_ARCH(ptl3, i, x)
+typedef __u64 pte_t;
+#endif

 /SPARTAN/trunk/arch/ia64/include/mm/vm.h
 ,0 → 1,43
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ia64_VM_H__
+#define __ia64_VM_H__
+#include <arch/types.h>
+#define KERNEL_ADDRESS_SPACE_START_ARCH     (__address) 0x8000000000000000
+#define KERNEL_ADDRESS_SPACE_END_ARCH       (__address) 0xffffffffffffffff
+#define USER_ADDRESS_SPACE_START_ARCH       (__address) 0x0000000000000000
+#define USER_ADDRESS_SPACE_END_ARCH     (__address) 0x7fffffffffffffff
+#define UTEXT_ADDRESS_ARCH  0x0000000000001000
+#define USTACK_ADDRESS_ARCH (0x7fffffffffffffff-(PAGE_SIZE-1))
+#define UDATA_ADDRESS_ARCH  0x0000000001001000
+#endif

 /SPARTAN/trunk/arch/ia64/include/mm/frame.h
 ,0 → 1,36
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ia64_FRAME_H__
+#define __ia64_FRAME_H__
+#define FRAME_SIZE      (16*1024)
+extern void frame_arch_init(void);
+#endif

 /SPARTAN/trunk/arch/ia64/include/atomic.h
 ,0 → 1,45
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ia64_ATOMIC_H__
+#define __ia64_ATOMIC_H__
+/*
+ * TODO: these are just placeholders for real implementations of atomic_inc and atomic_dec.
+ * WARNING: the following functions cause the code to be preemption-unsafe !!!
+ */
+static inline atomic_inc(volatile int *val) {
+    *val++;
+}
+static inline atomic_dec(volatile int *val) {
+    *val--;
+}
+#endif

 /SPARTAN/trunk/arch/ia64/include/context.h
 ,0 → 1,121
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ia64_CONTEXT_H__
+#define __ia64_CONTEXT_H__
+#include <arch/types.h>
+/*
+ * context_save() and context_restore() are both leaf procedures.
+ * No need to allocate scratch area.
+ */
+#define SP_DELTA    0
+#ifdef context_set
+#undef context_set
+#endif
+#define context_set(c, _pc, stack, size)    \
+    (c)->pc = (__address) _pc;      \
+    (c)->bsp = (__address) stack;       \
+    (c)->sp = ((__address) stack) + (size) - SP_DELTA;
+struct context {
+    /*
+     * Application registers
+     */
+    __u64 ar_pfs;
+    __u64 ar_unat_caller;
+    __u64 ar_unat_callee;
+    __u64 ar_rsc;
+    __u64 bsp;  /* ar_bsp */
+    __u64 ar_rnat;
+    __u64 ar_lc;
+    __u64 ar_ec;
+    __u64 ar_ccv;
+    __u64 ar_csd;
+    __u64 ar_ssd;
+    /*
+     * General registers
+     */
+    __u64 r1;
+    __u64 r2;
+    __u64 r3;
+    __u64 r4;
+    __u64 r5;
+    __u64 r6;
+    __u64 r7;
+    __u64 r8;
+    __u64 r9;
+    __u64 r10;
+    __u64 r11;
+    __u64 sp;       /* r12 */
+    __u64 r13;
+    __u64 r14;
+    __u64 r15;
+    __u64 r16;
+    __u64 r17;
+    __u64 r18;
+    __u64 r19;
+    __u64 r20;
+    __u64 r21;
+    __u64 r22;
+    __u64 r23;
+    __u64 r24;
+    __u64 r25;
+    __u64 r26;
+    __u64 r27;
+    __u64 r28;
+    __u64 r29;
+    __u64 r30;
+    __u64 r31;
+    /*
+     * Branch registers
+     */
+    __u64 pc;       /* b0 */
+    __u64 b1;
+    __u64 b2;
+    __u64 b3;
+    __u64 b4;
+    __u64 b5;
+    __u64 b6;
+    __u64 b7;
+    /*
+     * Predicate registers
+     */
+    __u64 pr;
+    pri_t pri;
+} __attribute__ ((packed));
+#endif

 /SPARTAN/trunk/arch/ia64/include/fpu_context.h
 ,0 → 1,39
+/*
+ * Copyright (C) 2005 Jakub Vana
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ia64_FPU_CONTEXT_H__
+#define __ia64_FPU_CONTEXT_H__
+#include <arch/types.h>
+struct fpu_context {
+/* TODO: define IA-64 FPU context */
+};
+#endif

 /SPARTAN/trunk/arch/ia64/include/types.h
 ,0 → 1,47
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __TYPES_H__
+#define __TYPES_H__
+#define NULL    0
+typedef signed char __s8;
+typedef unsigned char __u8;
+typedef unsigned short __u16;
+typedef unsigned long __u32;
+typedef long long __u64;
+typedef __u64 __address;
+typedef __u64 pri_t;
+typedef __u64 __native;
+#endif

 /SPARTAN/trunk/arch/ia64/include/ski/ski.h
 ,0 → 1,38
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __SKI_H__
+#define __SKI_H__
+#define SKI_INIT_CONSOLE    20
+#define SKI_PUTCHAR     31
+extern void ski_init_console(void);
+extern void ski_putchar(const char ch);
+#endif

 /SPARTAN/trunk/arch/ia64/include/faddr.h
 ,0 → 1,56
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ia64_FADDR_H__
+#define __ia64_FADDR_H__
+#include <arch/types.h>
+static __address FADDR(void (* fptr)(void));
+/**
+ *
+ * Calculate absolute address of function
+ * referenced by fptr pointer.
+ *
+ * @param fptr Function pointer.
+ *
+ */
+inline __address FADDR(void (* fptr)(void)) {
+    __address faddr;
+    __asm__(
+        "ld8 %0 = [%1]\n\t"
+        : "=r" (faddr)
+        : "r" (fptr)
+    );
+    return faddr;
+}
+#endif

 /SPARTAN/trunk/arch/ia64/include/arg.h
 ,0 → 1,34
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ia64_ARG_H__
+#define __ia64_ARG_H__
+#include <stdarg.h>
+#endif

/SPARTAN/trunk/arch/ia64/include/asm.h
--- arch/ia64/include/cpu.h (nonexistent)
+++ arch/ia64/include/cpu.h (revision 168)
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __ia64_CPU_H__
+#define __ia64_CPU_H__
+
+#include <typedefs.h>
+
+#define CPU_ID_ARCH 0
+
+struct cpu_arch {
+};
+
+#endif

 /SPARTAN/trunk/arch/ia64/include/thread.h
 ,0 → 1,34
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ia64_THREAD_H__
+#define __ia64_THREAD_H__
+#define ARCH_THREAD_DATA struct { } arch_thread_data;
+#endif

 /SPARTAN/trunk/arch/ia64/_link.ld
 ,0 → 1,38
+/*
+ *  IA-64 linker script
+ *
+ *  It is ELF format, but its only section looks like this:
+ *  kernel text
+ *  kernel data
+ *
+ */
+OUTPUT_FORMAT(elf64-ia64-little)
+ENTRY(kernel_image_start)
+SECTIONS {
+    .image 0x0000000000001000: AT (0x0000000000001000) {
+        ktext_start = .;
+        *(K_TEXT_START);
+        *(.text)
+        ktext_end = .;
+        kdata_start = .;
+        *(K_DATA_START)
+        *(.rodata .rodata.*)
+        *(.opd)
+        *(.data)
+        *(.got .got.*)
+        *(.sdata)
+        *(.sbss)
+        *(.scommon)
+        *(.bss)
+        *(COMMON);
+        kdata_end = .;
+    }
+    _hardcoded_ktext_size = ktext_end - ktext_start;
+    _hardcoded_kdata_size = kdata_end - kdata_start;
+    _hardcoded_load_address = 0x0000000000001000;
+}

 /SPARTAN/trunk/arch/ia64/boot/_link.ld
 ,0 → 1,72
+OUTPUT_FORMAT(elf64-ia64-little)
+ENTRY(start)
+SECTIONS {
+    .image 0x0000000000000000: AT (0x0000000000000000) {
+        *(.text .stub .text.* .gnu.linkonce.t.*)
+        *(.interp)
+        *(.hash)
+        *(.dynsym)
+        *(.dynstr)
+        *(.rel.init)
+        *(.rela.init)
+        *(.rel.text .rel.text.* .rel.gnu.linkonce.t.*)
+        *(.rela.text .rela.text.* .rela.gnu.linkonce.t.*)
+        *(.rel.fini)
+        *(.rela.fini)
+        *(.rel.rodata .rel.rodata.* .rel.gnu.linkonce.r.*)
+        *(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*)
+        *(.rel.data .rel.data.* .rel.gnu.linkonce.d.*)
+        *(.rela.data .rela.data.* .rela.gnu.linkonce.d.*)
+        *(.rel.tdata .rel.tdata.* .rel.gnu.linkonce.td.*)
+        *(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*)
+        *(.rel.tbss .rel.tbss.* .rel.gnu.linkonce.tb.*)
+        *(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*)
+        *(.rel.got)
+        *(.rela.got)
+        *(.rel.sdata .rel.sdata.* .rel.gnu.linkonce.s.*)
+        *(.rela.sdata .rela.sdata.* .rela.gnu.linkonce.s.*)
+        *(.rel.sbss .rel.sbss.* .rel.gnu.linkonce.sb.*)
+        *(.rela.sbss .rela.sbss.* .rela.gnu.linkonce.sb.*)
+        *(.rel.sdata2 .rel.sdata2.* .rel.gnu.linkonce.s2.*)
+        *(.rela.sdata2 .rela.sdata2.* .rela.gnu.linkonce.s2.*)
+        *(.rel.sbss2 .rel.sbss2.* .rel.gnu.linkonce.sb2.*)
+        *(.rela.sbss2 .rela.sbss2.* .rela.gnu.linkonce.sb2.*)
+        *(.rel.bss .rel.bss.* .rel.gnu.linkonce.b.*)
+        *(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*)
+        *(.rel.plt)
+        *(.rela.plt)
+        *(.rela.IA_64.pltoff)
+        *(.init)
+        *(.plt)
+        *(.fini)
+        *(.rodata .rodata.* .gnu.linkonce.r.*)
+        *(.rodata1)
+        *(.sdata2 .sdata2.* .gnu.linkonce.s2.*)
+        *(.sbss2 .sbss2.* .gnu.linkonce.sb2.*)
+        *(.opd)
+        *(.IA_64.unwind_info* .gnu.linkonce.ia64unwi.*)
+        *(.IA_64.unwind* .gnu.linkonce.ia64unw.*)
+        *(.eh_frame_hdr)
+        *(.preinit_array)
+        *(.init_array)
+        *(.fini_array)
+        *(.data .data.* .gnu.linkonce.d.*)
+        *(.data1)
+        *(.tdata .tdata.* .gnu.linkonce.td.*)
+        *(.tcommon)
+        *(.eh_frame)
+        *(.gcc_except_table)
+        *(.dynamic)
+        *(.jcr)
+        *(.got)
+        *(.IA_64.pltoff)
+        *(.sdata .sdata.* .gnu.linkonce.s.*)
+        *(.dynsbss)
+        *(.sbss .sbss.* .gnu.linkonce.sb.*)
+        *(.scommon)
+        *(.dynbss)
+        *(.bss .bss.* .gnu.linkonce.b.*)
+        *(COMMON)
+    }
+}

 /SPARTAN/trunk/arch/ia64/boot/boot.s
 ,0 → 1,33
+#
+# Copyright (C) 2005 Jakub Jermar
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+.text
+.global start
+start:
+    brl 0x0000000000001000

 /SPARTAN/trunk/arch/ia64/boot/Makefile
 ,0 → 1,24
+IA-64_BINUTILS_DIR=/usr/local/ia64/bin
+IA-64_TARGET=ia64-pc-linux-gnu
+.PHONY: nothing build
+nothing:
+build: boot.bin
+    cp boot.bin ../../../src/load.bin
+AS=$(IA-64_BINUTILS_DIR)/$(IA-64_TARGET)-as
+LD=$(IA-64_BINUTILS_DIR)/$(IA-64_TARGET)-ld
+ASFLAGS=-EL
+LFLAGS=-EL -T _link.ld -n
+boot.bin: boot.o
+    $(LD) $(LFLAGS) boot.o -o $@
+boot.o:
+    $(AS) boot.s -o $@
+clean:
+    -rm *.o *.bin

 /SPARTAN/trunk/arch/mips/Makefile.inc
 ,0 → 1,32
+MIPS_TARGET=mipsel-linux-gnu
+MIPS_CC_DIR=/usr/local/mipsel/bin
+MIPS_BINUTILS_DIR=/usr/local/mipsel/bin
+CC=$(MIPS_CC_DIR)/$(MIPS_TARGET)-gcc
+AS=$(MIPS_BINUTILS_DIR)/$(MIPS_TARGET)-as
+LD=$(MIPS_BINUTILS_DIR)/$(MIPS_TARGET)-ld
+ASFLAGS=-mips3
+DEFS=-DARCH=$(ARCH)
+CPPFLAGS=$(DEFS) -mno-abicalls -nostdinc -I../include
+CFLAGS=$(CPPFLAGS) -mips2 -G 0 -nostdlib -fno-builtin -Wmissing-prototypes -Werror -O2
+LFLAGS=-mips2 -M -no-check-sections -T ../arch/mips/_link.ld
+arch_sources= \
+    arch/start.S \
+    arch/context.S \
+    arch/panic.s \
+    arch/mips.c \
+    arch/dummy.s \
+    arch/putchar.c \
+    arch/asm.s \
+    arch/exception.c \
+    arch/interrupt.c \
+    arch/cache.c \
+    arch/cpu/cpu.c \
+    arch/mm/frame.c \
+    arch/mm/page.c \
+    arch/mm/tlb.c \
+    arch/fpu_context.c

 /SPARTAN/trunk/arch/mips/src/dummy.s
 ,0 → 1,45
+#
+# Copyright (C) 2001-2004 Jakub Jermar
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+.text
+.set noat
+.global calibrate_delay_loop
+.global asm_delay_loop
+.global userspace
+.global before_thread_runs_arch
+.global dummy
+before_thread_runs_arch:
+userspace:
+calibrate_delay_loop:
+asm_delay_loop:
+dummy:
+    j $31
+    nop

 /SPARTAN/trunk/arch/mips/src/mm/asid.c
 ,0 → 1,56
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch.h>
+#include <memstr.h>
+/**< Array of threads that have currently some ASID assigned,
+     NULL means no thread have ASID with number of that index assigned */
+struct thread * asids[256];
+int last_asid; /**< The number of last assigned ASID */
+int asid_bitmap[32]; /**< Bitmap of ASIDs currently in TLB */
+/** Cleanup asid_bitmap
+ *
+ */
+void asid_bitmap_reset(void)
+{
+    memsetb(asid_bitmap, sizeof(asid_bitmap), 0);
+}
+/** Initialize manipulating with ASIDs
+ *
+ */
+void init_asids(void)
+{
+    memsetb(asids, sizeof(asids), 0);
+    asid_bitmap_reset();
+    last_asid = 0;
+}

 /SPARTAN/trunk/arch/mips/src/mm/tlb.c
 ,0 → 1,64
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch/mm/tlb.h>
+#include <arch/mm/asid.h>
+#include <mm/tlb.h>
+#include <arch/cp0.h>
+#include <panic.h>
+#include <arch.h>
+int bootstrap = 1;
+void tlb_refill(void)
+{
+    if (bootstrap) {
+        bootstrap = 0;
+        main_bsp();
+    }
+    panic("tlb_refill exception\n");
+}
+void tlb_invalid(void)
+{
+    panic("%X: TLB exception at %X", cp0_badvaddr_read(), THREAD ? THREAD->saved_epc : 0);
+}
+void tlb_invalidate(int asid)
+{
+    pri_t pri;
+    pri = cpu_priority_high();
+    asid_bitmap_reset();
+    // TODO
+    cpu_priority_restore(pri);
+}

 /SPARTAN/trunk/arch/mips/src/mm/page.c
 ,0 → 1,45
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch/types.h>
+#include <arch/mm/page.h>
+#include <arch/mm/frame.h>
+#include <mm/frame.h>
+#include <mm/page.h>
+pte_t *PTL0 = NULL;
+void page_arch_init(void)
+{
+    __address ptl0;
+    ptl0 = frame_alloc(FRAME_KA | FRAME_PANIC);
+    memsetb(ptl0, FRAME_SIZE, 0);
+    SET_PTL0_ADDRESS(KA2PA(ptl0));
+}

 /SPARTAN/trunk/arch/mips/src/mm/frame.c
 ,0 → 1,34
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch/mm/frame.h>
+#include <mm/frame.h>
+void frame_arch_init(void)
+{
+}

 /SPARTAN/trunk/arch/mips/src/cpu/cpu.c
 ,0 → 1,94
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch/cpu.h>
+#include <cpu.h>
+#include <arch.h>
+#include <arch/cp0.h>
+#include <typedefs.h>
+struct {
+    char *vendor;
+    char *model;
+} imp_data[] = {
+    { "Invalid", "Invalid" },   /* 0x00 */
+    { "MIPS", "R2000" },        /* 0x01 */
+    { "MIPS", "R3000" },        /* 0x02 */
+    { "MIPS", "R6000" },        /* 0x03 */
+    { "MIPS", " R4000/R4400" },     /* 0x04 */
+    { "LSI Logic", "R3000" },   /* 0x05 */
+    { "MIPS", "R6000A" },       /* 0x06 */
+    { "IDT", "3051/3052" },     /* 0x07 */
+    { "Invalid", "Invalid" },   /* 0x08 */
+    { "MIPS", "R10000/T5" },    /* 0x09 */
+    { "MIPS", "R4200" },        /* 0x0a */
+    { "Unknown", "Unknown" },   /* 0x0b */
+    { "Unknown", "Unknown" },   /* 0x0c */
+    { "Invalid", "Invalid" },   /* 0x0d */
+    { "Invalid", "Invalid" },   /* 0x0e */
+    { "Invalid", "Invalid" },   /* 0x0f */
+    { "MIPS", "R8000" },        /* 0x10 */
+    { "Invalid", "Invalid" },   /* 0x11 */
+    { "Invalid", "Invalid" },   /* 0x12 */
+    { "Invalid", "Invalid" },   /* 0x13 */
+    { "Invalid", "Invalid" },   /* 0x14 */
+    { "Invalid", "Invalid" },   /* 0x15 */
+    { "Invalid", "Invalid" },   /* 0x16 */
+    { "Invalid", "Invalid" },   /* 0x17 */
+    { "Invalid", "Invalid" },   /* 0x18 */
+    { "Invalid", "Invalid" },   /* 0x19 */
+    { "Invalid", "Invalid" },   /* 0x1a */
+    { "Invalid", "Invalid" },   /* 0x1b */
+    { "Invalid", "Invalid" },   /* 0x1c */
+    { "Invalid", "Invalid" },   /* 0x1d */
+    { "Invalid", "Invalid" },   /* 0x1e */
+    { "Invalid", "Invalid" },   /* 0x1f */
+    { "QED", "R4600" },     /* 0x20 */
+    { "Sony", "R3000" },        /* 0x21 */
+    { "Toshiba", "R3000" },     /* 0x22 */
+    { "NKK", "R3000" }      /* 0x23 */
+};
+void cpu_arch_init(void)
+{
+}
+void cpu_identify(void)
+{
+    CPU->arch.rev_num = cp0_prid_read() & 0xff;
+    CPU->arch.imp_num = (cp0_prid_read() >> 8) & 0xff;
+}
+void cpu_print_report(cpu_t *m)
+{
+    printf("cpu%d: %s %s (rev=%d.%d, imp=%d)\n",
+        m->id, imp_data[m->arch.imp_num].vendor, imp_data[m->arch.imp_num].model, m->arch.rev_num >> 4, m->arch.rev_num & 0xf, m->arch.imp_num);
+}

 /SPARTAN/trunk/arch/mips/src/mips.c
 ,0 → 1,59
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch.h>
+#include <arch/cp0.h>
+#include <arch/exception.h>
+void arch_pre_mm_init(void)
+{
+    /*
+     * Switch to BEV normal level so that exception vectors point to the kernel.
+     * Clear the error level.
+     */
+    cp0_status_write(cp0_status_read() & ~(cp0_status_bev_bootstrap_bit|cp0_status_erl_error_bit));
+    /*
+     * Unmask hardware clock interrupt.
+     */
+    cp0_status_write(cp0_status_read() | (1<<cp0_status_im7_shift));
+    /*
+     * Start hardware clock.
+     */
+    cp0_compare_write(cp0_compare_value);
+    cp0_count_write(0);
+}
+void arch_post_mm_init(void)
+{
+}
+void arch_late_init(void)
+{
+}

 /SPARTAN/trunk/arch/mips/src/interrupt.c
 ,0 → 1,95
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch/interrupt.h>
+#include <arch/types.h>
+#include <arch.h>
+#include <arch/cp0.h>
+#include <time/clock.h>
+#include <panic.h>
+pri_t cpu_priority_high(void)
+{
+    pri_t pri = (pri_t) cp0_status_read();
+    cp0_status_write(pri & ~cp0_status_ie_enabled_bit);
+    return pri;
+}
+pri_t cpu_priority_low(void)
+{
+    pri_t pri = (pri_t) cp0_status_read();
+    cp0_status_write(pri | cp0_status_ie_enabled_bit);
+    return pri;
+}
+void cpu_priority_restore(pri_t pri)
+{
+    cp0_status_write(cp0_status_read() | (pri & cp0_status_ie_enabled_bit));
+}
+pri_t cpu_priority_read(void)
+{
+    return cp0_status_read();
+}
+void interrupt(void)
+{
+    __u32 cause;
+    int i;
+    /* decode interrupt number and process the interrupt */
+    cause = (cp0_cause_read() >> 8) &0xff;
+    for (i = 0; i < 8; i++) {
+        if (cause & (1 << i)) {
+            switch (i) {
+                case 0: /* SW0 - Software interrupt 0 */
+                    cp0_cause_write(cause & ~(1 << 8)); /* clear SW0 interrupt */
+                    break;
+                case 1: /* SW1 - Software interrupt 1 */
+                    cp0_cause_write(cause & ~(1 << 9)); /* clear SW1 interrupt */
+                    break;
+                case 2: /* IRQ0 */
+                case 3: /* IRQ1 */
+                case 4: /* IRQ2 */
+                case 5: /* IRQ3 */
+                case 6: /* IRQ4 */
+                    panic("unhandled interrupt %d\n", i);
+                    break;
+                case 7: /* Timer Interrupt */
+                    cp0_compare_write(cp0_compare_value); /* clear timer interrupt */
+                    /* start counting over again */
+                    cp0_count_write(0);
+                    clock();
+                    break;
+            }
+        }
+    }
+}

 /SPARTAN/trunk/arch/mips/src/start.S
 ,0 → 1,91
+#
+# Copyright (C) 2001-2004 Jakub Jermar
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+#include <arch/asm/macro.h>
+#define STACK_SPACE 128
+.text
+.set noat
+.set noreorder
+.set nomacro
+.global kernel_image_start
+.global tlb_refill_entry
+.global cache_error_entry
+.global exception_entry
+.org 0x0
+kernel_image_start:
+tlb_refill_entry:
+    j tlb_refill_handler
+    nop
+.org 0x100
+cache_error_entry:
+    j cache_error_handler
+    nop
+.org 0x180
+exception_entry:
+exception_handler:
+    sub $29, STACK_SPACE
+    REGISTERS_STORE $29
+    jal exception
+    nop
+    REGISTERS_LOAD $29
+    add $29, STACK_SPACE
+    eret
+tlb_refill_handler:
+    sub $29, STACK_SPACE
+    REGISTERS_STORE $29
+    jal tlb_refill
+    nop
+    REGISTERS_LOAD $29
+    add $29, STACK_SPACE
+    eret
+cache_error_handler:
+    sub $29, STACK_SPACE
+    REGISTERS_STORE $29
+    jal cache_error
+    nop
+    REGISTERS_LOAD $29
+    add $29, STACK_SPACE
+    eret

 /SPARTAN/trunk/arch/mips/src/asm.s
 ,0 → 1,169
+#
+# Copyright (C) 2001-2004 Jakub Jermar
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+.text
+.macro cp0_read reg
+    mfc0 $2,\reg
+    j $31
+    nop
+.endm
+.macro cp0_write reg
+    mtc0 $4,\reg
+    j $31
+    nop
+.endm
+.set noat
+.set noreorder
+.set nomacro
+.global cp0_index_read
+.global cp0_index_write
+.global cp0_random_read
+.global cp0_entry_lo0_read
+.global cp0_entry_lo0_write
+.global cp0_entry_lo1_read
+.global cp0_entry_lo1_write
+.global cp0_context_read
+.global cp0_context_write
+.global cp0_pagemask_read
+.global cp0_pagemask_write
+.global cp0_wired_read
+.global cp0_wired_write
+.global cp0_badvaddr_read
+.global cp0_count_read
+.global cp0_count_write
+.global cp0_hi_read
+.global cp0_hi_write
+.global cp0_compare_read
+.global cp0_compare_write
+.global cp0_status_read
+.global cp0_status_write
+.global cp0_cause_read
+.global cp0_cause_write
+.global cp0_epc_read
+.global cp0_epc_write
+.global cp0_prid_read
+cp0_index_read:     cp0_read $0
+cp0_index_write:    cp0_write $0
+cp0_random_read:    cp0_read $1
+cp0_entry_lo0_read: cp0_read $2
+cp0_entry_lo0_write:    cp0_write $2
+cp0_entry_lo1_read: cp0_read $3
+cp0_entry_lo1_write:    cp0_write $3
+cp0_context_read:   cp0_read $4
+cp0_context_write:  cp0_write $4
+cp0_pagemask_read:  cp0_read $5
+cp0_pagemask_write: cp0_write $5
+cp0_wired_read:     cp0_read $6
+cp0_wired_write:    cp0_write $6
+cp0_badvaddr_read:  cp0_read $8
+cp0_count_read:     cp0_read $9
+cp0_count_write:    cp0_write $9
+cp0_entry_hi_read:  cp0_read $10
+cp0_entry_hi_write: cp0_write $10
+cp0_compare_read:   cp0_read $11
+cp0_compare_write:  cp0_write $11
+cp0_status_read:    cp0_read $12
+cp0_status_write:   cp0_write $12
+cp0_cause_read:     cp0_read $13
+cp0_cause_write:    cp0_write $13
+cp0_epc_read:       cp0_read $14
+cp0_epc_write:      cp0_write $14
+cp0_prid_read:      cp0_read $15
+.global tlbp
+tlbp:
+    tlbp
+    j $31
+    nop
+.global tlbr
+tlbr:
+    tlbr
+    j $31
+    nop
+.global tlbwi
+tlbwi:
+    tlbwi
+    j $31
+    nop
+.global tlbwr
+tlbwr:
+    tlbwr
+    j $31
+    nop
+.global cpu_halt
+cpu_halt:
+    j cpu_halt
+    nop
+.global memsetb
+memsetb:
+    j _memsetb
+    nop
+.global memcopy
+memcopy:
+    j _memcopy
+    nop
+# THIS IS USERSPACE CODE
+.global utext
+utext:
+    j $31
+    nop
+utext_end:
+.data
+.global utext_size
+utext_size:
+    .long utext_end-utext

 /SPARTAN/trunk/arch/mips/src/exception.c
 ,0 → 1,115
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch/exception.h>
+#include <panic.h>
+#include <arch/cp0.h>
+#include <arch/types.h>
+#include <arch.h>
+void exception(void)
+{
+    int excno;
+    __u32 epc;
+    __u32 epc_shift = 0;
+    pri_t pri;
+    pri = cpu_priority_high();
+    epc = cp0_epc_read();
+    cp0_status_write(cp0_status_read() & ~ cp0_status_exl_exception_bit);
+    if (THREAD) {
+        THREAD->saved_pri = pri;
+        THREAD->saved_epc = epc;
+    }
+    /* decode exception number and process the exception */
+    switch (excno = (cp0_cause_read() >> 2) & 0x1f) {
+        case EXC_Int:
+            interrupt();
+            break;
+        case EXC_TLBL:
+        case EXC_TLBS:
+            tlb_invalid();
+            break;
+        case EXC_Mod:
+            panic("unhandled TLB Modification Exception\n");
+            break;
+        case EXC_AdEL:
+            panic("unhandled Address Error Exception - load or instruction fetch\n");
+            break;
+        case EXC_AdES:
+            panic("unhandled Address Error Exception - store\n");
+            break;
+        case EXC_IBE:
+            panic("unhandled Bus Error Exception - fetch instruction\n");
+            break;
+        case EXC_DBE:
+            panic("unhandled Bus Error Exception - data reference: load or store\n");
+            break;
+        case EXC_Bp:
+            /* it is necessary to not re-execute BREAK instruction after returning from Exception handler
+               (see page 138 in R4000 Manual for more information) */
+            epc_shift = 4;
+            break;
+        case EXC_RI:
+            panic("unhandled Reserved Instruction Exception\n");
+            break;
+        case EXC_CpU:
+            panic("unhandled Coprocessor Unusable Exception\n");
+            break;
+        case EXC_Ov:
+            panic("unhandled Arithmetic Overflow Exception\n");
+            break;
+        case EXC_Tr:
+            panic("unhandled Trap Exception\n");
+            break;
+        case EXC_VCEI:
+            panic("unhandled Virtual Coherency Exception - instruction\n");
+            break;
+        case EXC_FPE:
+            panic("unhandled Floating-Point Exception\n");
+            break;
+        case EXC_WATCH:
+            panic("unhandled reference to WatchHi/WatchLo address\n");
+            break;
+        case EXC_VCED:
+            panic("unhandled Virtual Coherency Exception - data\n");
+            break;
+        default:
+            panic("unhandled exception %d\n", excno);
+    }
+    if (THREAD) {
+        pri = THREAD->saved_pri;
+        epc = THREAD->saved_epc;
+    }
+    cp0_epc_write(epc + epc_shift);
+    cp0_status_write(cp0_status_read() | cp0_status_exl_exception_bit);
+    cpu_priority_restore(pri);
+}

 /SPARTAN/trunk/arch/mips/src/putchar.c
 ,0 → 1,42
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <putchar.h>
+#include <arch/types.h>
+#include <arch/cp0.h>
+#define VIDEORAM    0xB0000000
+void putchar(const char ch)
+{
+    __u32 status = cp0_status_read();
+    cp0_status_write(cp0_status_read() | cp0_status_erl_error_bit);
+    *((char *) VIDEORAM) = ch;
+    cp0_status_write(status);
+}

 /SPARTAN/trunk/arch/mips/src/fpu_context.c
 ,0 → 1,48
+/*
+ * Copyright (C) 2005 Jakub Vana
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#include <fpu_context.h>
+void fpu_context_save(fpu_context_t *fctx)
+{
+}
+void fpu_context_restore(fpu_context_t *fctx)
+{
+}
+void fpu_lazy_context_save(fpu_context_t *fctx)
+{
+}
+void fpu_lazy_context_restore(fpu_context_t *fctx)
+{
+}

 /SPARTAN/trunk/arch/mips/src/cache.c
 ,0 → 1,35
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <arch/cache.h>
+#include <panic.h>
+void cache_error(void)
+{
+    panic("cache_error exception\n");
+}

 /SPARTAN/trunk/arch/mips/src/panic.s
 ,0 → 1,42
+#
+# Copyright (C) 2001-2004 Jakub Jermar
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+.text
+.set noat
+.set noreorder
+.set nomacro
+.global panic_printf
+panic_printf:
+    jal printf
+    nop
+    j cpu_halt
+    nop

 /SPARTAN/trunk/arch/mips/src/context.S
 ,0 → 1,52
+#
+# Copyright (C) 2001-2004 Jakub Jermar
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+#include <arch/asm/macro.h>
+.text
+.set noat
+.set noreorder
+.set nomacro
+.global context_save
+.global context_restore
+context_save:
+    REGISTERS_STORE $4
+    # context_save returns 1
+    j $31
+    li $2, 1
+context_restore:
+    REGISTERS_LOAD $4
+    # context_restore returns 0
+    j $31
+    xor $2, $2

 /SPARTAN/trunk/arch/mips/include/barrier.h
 ,0 → 1,38
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __mips_BARRIER_H__
+#define __mips_BARRIER_H__
+/*
+ * TODO: implement true MIPS memory barriers for macros below.
+ */
+#define CS_ENTER_BARRIER()  __asm__ volatile ("" ::: "memory")
+#define CS_LEAVE_BARRIER()  __asm__ volatile ("" ::: "memory")
+#endif

 /SPARTAN/trunk/arch/mips/include/mm/memory_init.h
 ,0 → 1,36
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __mips_MEMORY_INIT_H__
+#define __mips_MEMORY_INIT_H__
+#include <config.h>
+#define get_memory_size()   CONFIG_MEMORY_SIZE
+#endif

 /SPARTAN/trunk/arch/mips/include/mm/page.h
 ,0 → 1,113
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __mips_PAGE_H__
+#define __mips_PAGE_H__
+#include <arch/mm/tlb.h>
+#include <mm/page.h>
+#include <arch/mm/frame.h>
+#include <arch/types.h>
+#include <arch.h>
+#define PAGE_SIZE   FRAME_SIZE
+#define KA2PA(x)    ((x) - 0x80000000)
+#define PA2KA(x)    ((x) + 0x80000000)
+/*
+ * Implementation of generic 4-level page table interface.
+ * NOTE: this implementation is under construction
+ *
+ * Page table layout:
+ * - 32-bit virtual addresses
+ * - Offset is 14 bits => pages are 16K long
+ * - PTE's use the same format as CP0 EntryLo[01] registers => PTE is therefore 4 bytes long
+ * - PTL0 has 64 entries (6 bits)
+ * - PTL1 is not used
+ * - PTL2 is not used
+ * - PTL3 has 4096 entries (12 bits)
+ */
+#define PTL0_INDEX_ARCH(vaddr)  ((vaddr)>>26)
+#define PTL1_INDEX_ARCH(vaddr)  0
+#define PTL2_INDEX_ARCH(vaddr)  0
+#define PTL3_INDEX_ARCH(vaddr)  (((vaddr)>>14)&0xfff)
+#define GET_PTL0_ADDRESS_ARCH()         (PTL0)
+#define SET_PTL0_ADDRESS_ARCH(ptl0)     (PTL0 = (pte_t *)(ptl0))
+#define GET_PTL1_ADDRESS_ARCH(ptl0, i)      (((pte_t *)(ptl0))[(i)].pfn<<14)
+#define GET_PTL2_ADDRESS_ARCH(ptl1, i)      (ptl1)
+#define GET_PTL3_ADDRESS_ARCH(ptl2, i)      (ptl2)
+#define GET_FRAME_ADDRESS_ARCH(ptl3, i)     (((pte_t *)(ptl3))[(i)].pfn<<14)
+#define SET_PTL1_ADDRESS_ARCH(ptl0, i, a)   (((pte_t *)(ptl0))[(i)].pfn = (a)>>14)
+#define SET_PTL2_ADDRESS_ARCH(ptl1, i, a)
+#define SET_PTL3_ADDRESS_ARCH(ptl2, i, a)
+#define SET_FRAME_ADDRESS_ARCH(ptl3, i, a)  (((pte_t *)(ptl3))[(i)].pfn = (a)>>14)
+#define GET_PTL1_FLAGS_ARCH(ptl0, i)        get_pt_flags((pte_t *)(ptl0), (index_t)(i))
+#define GET_PTL2_FLAGS_ARCH(ptl1, i)        PAGE_PRESENT
+#define GET_PTL3_FLAGS_ARCH(ptl2, i)        PAGE_PRESENT
+#define GET_FRAME_FLAGS_ARCH(ptl3, i)       get_pt_flags((pte_t *)(ptl3), (index_t)(i))
+#define SET_PTL1_FLAGS_ARCH(ptl0, i, x)     set_pt_flags((pte_t *)(ptl0), (index_t)(i), (x))
+#define SET_PTL2_FLAGS_ARCH(ptl1, i, x)
+#define SET_PTL3_FLAGS_ARCH(ptl2, i, x)
+#define SET_FRAME_FLAGS_ARCH(ptl3, i, x)    set_pt_flags((pte_t *)(ptl3), (index_t)(i), (x))
+static inline int get_pt_flags(pte_t *pt, index_t i)
+{
+    pte_t *p = &pt[i];
+    return (
+        ((p->c>PAGE_UNCACHED)<<PAGE_CACHEABLE_SHIFT) |
+        ((!p->v)<<PAGE_PRESENT_SHIFT) |
+        (1<<PAGE_USER_SHIFT) |
+        (1<<PAGE_READ_SHIFT) |
+        ((p->d)<<PAGE_WRITE_SHIFT) |
+        (1<<PAGE_EXEC_SHIFT)
+    );
+}
+static inline void set_pt_flags(pte_t *pt, index_t i, int flags)
+{
+    pte_t *p = &pt[i];
+    p->c = (flags & PAGE_CACHEABLE) != 0 ? PAGE_CACHEABLE_EXC_WRITE : PAGE_UNCACHED;
+    p->v = !(flags & PAGE_NOT_PRESENT);
+    p->d = (flags & PAGE_WRITE) != 0;
+}
+extern void page_arch_init(void);
+extern pte_t *PTL0;
+#endif

 /SPARTAN/trunk/arch/mips/include/mm/asid.h
 ,0 → 1,34
+/*
+ * Copyright (C) 2005 Matrin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __mips_ASID_H__
+#define __mips_ASID_H__
+extern void asid_bitmap_reset(void);
+#endif

 /SPARTAN/trunk/arch/mips/include/mm/frame.h
 ,0 → 1,36
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __mips_FRAME_H__
+#define __mips_FRAME_H__
+#define FRAME_SIZE      16384
+extern void frame_arch_init(void);
+#endif

 /SPARTAN/trunk/arch/mips/include/mm/tlb.h
 ,0 → 1,69
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __mips_TLB_H__
+#define __mips_TLB_H__
+#define PAGE_UNCACHED           2
+#define PAGE_CACHEABLE_EXC_WRITE    5
+struct entry_lo {
+    unsigned g : 1;     /* global bit */
+    unsigned v : 1;     /* valid bit */
+    unsigned d : 1;     /* dirty/write-protect bit */
+    unsigned c : 3;     /* cache coherency attribute */
+    unsigned pfn : 24;  /* frame number */
+    unsigned : 2;
+} __attribute__ ((packed));
+struct entry_hi {
+    unsigned asid : 8;
+    unsigned : 4;
+    unsigned g : 1;
+    unsigned vpn2 : 19;
+} __attribute__ ((packed));
+struct page_mask {
+    unsigned : 13;
+    unsigned mask : 12;
+    unsigned : 7;
+} __attribute__ ((packed));
+struct tlb_entry {
+    struct entry_lo lo0;
+    struct entry_lo lo1;
+    struct entry_hi hi;
+    struct page_mask mask;
+} __attribute__ ((packed));
+typedef struct entry_lo pte_t;
+extern void tlb_refill(void);
+extern void tlb_invalid(void);
+#endif

 /SPARTAN/trunk/arch/mips/include/mm/vm.h
 ,0 → 1,43
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __mips_VM_H__
+#define __mips_VM_H__
+#include <arch/types.h>
+#define KERNEL_ADDRESS_SPACE_START_ARCH     (__address) 0x80000000
+#define KERNEL_ADDRESS_SPACE_END_ARCH       (__address) 0xffffffff
+#define USER_ADDRESS_SPACE_START_ARCH       (__address) 0x00000000
+#define USER_ADDRESS_SPACE_END_ARCH     (__address) 0x7fffffff
+#define UTEXT_ADDRESS_ARCH  0x00001000
+#define USTACK_ADDRESS_ARCH (0x7fffffff-(PAGE_SIZE-1))
+#define UDATA_ADDRESS_ARCH  0x01001000
+#endif

 /SPARTAN/trunk/arch/mips/include/context.h
 ,0 → 1,73
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __mips_CONTEXT_H__
+#define __mips_CONTEXT_H__
+#include <arch/types.h>
+#define SP_DELTA    0
+struct context {
+    __u32 r0;
+    __u32 r1;
+    __u32 r2;
+    __u32 r3;
+    __u32 r4;
+    __u32 r5;
+    __u32 r6;
+    __u32 r7;
+    __u32 r8;
+    __u32 r9;
+    __u32 r10;
+    __u32 r11;
+    __u32 r12;
+    __u32 r13;
+    __u32 r14;
+    __u32 r15;
+    __u32 r16;
+    __u32 r17;
+    __u32 r18;
+    __u32 r19;
+    __u32 r20;
+    __u32 r21;
+    __u32 r22;
+    __u32 r23;
+    __u32 r24;
+    __u32 r25;
+    __u32 r26;
+    __u32 r27;
+    __u32 r28;
+    __u32 sp;
+    __u32 r30;
+    __u32 pc;
+    __u32 pri;
+};
+#endif

 /SPARTAN/trunk/arch/mips/include/cpu.h
 ,0 → 1,41
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __mips_CPU_H__
+#define __mips_CPU_H__
+#include <typedefs.h>
+#define CPU_ID_ARCH 0
+struct cpu_arch {
+    int imp_num;
+    int rev_num;
+};
+#endif

 /SPARTAN/trunk/arch/mips/include/exception.h
 ,0 → 1,53
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __EXCEPTION_H__
+#define __EXCEPTION_H__
+#define EXC_Int     0
+#define EXC_Mod     1
+#define EXC_TLBL    2
+#define EXC_TLBS    3
+#define EXC_AdEL    4
+#define EXC_AdES    5
+#define EXC_IBE     6
+#define EXC_DBE     7
+#define EXC_Sys     8
+#define EXC_Bp      9
+#define EXC_RI      10
+#define EXC_CpU     11
+#define EXC_Ov      12
+#define EXC_Tr      13
+#define EXC_VCEI    14
+#define EXC_FPE     15
+#define EXC_WATCH   23
+#define EXC_VCED    31
+extern void exception(void);
+#endif

 /SPARTAN/trunk/arch/mips/include/atomic.h
 ,0 → 1,96
+/*
+ * Copyright (C) 2005 Ondrej Palkovsky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __MIPS_ATOMIC_H__
+#define __MIPS_ATOMIC_H__
+#define atomic_inc(x)   (a_add(x,1))
+#define atomic_dec(x)   (a_sub(x,1))
+/*
+ * Atomic addition
+ *
+ * This case is harder, and we have to use the special LL and SC operations
+ * to achieve atomicity. The instructions are similar to LW (load) and SW
+ * (store), except that the LL (load-linked) instruction loads the address
+ * of the variable to a special register and if another process writes to
+ * the same location, the SC (store-conditional) instruction fails.
+ */
+static inline int a_add( volatile int *val, int i)
+{
+    int tmp, tmp2;
+    asm volatile (
+        "   .set    push\n"
+        "   .set    noreorder\n"
+        "   nop\n"
+        "1:\n"
+        "   ll  %0, %1\n"
+        "   addu    %0, %0, %2\n"
+        "       move    %3, %0\n"
+        "   sc  %0, %1\n"
+        "   beq %0, 0x0, 1b\n"
+        "   move    %0, %3\n"
+        "   .set    pop\n"
+        : "=&r" (tmp), "=o" (*val)
+        : "r" (i), "r" (tmp2)
+        );
+    return tmp;
+}
+/*
+ * Atomic subtraction
+ *
+ * Implemented in the same manner as a_add, except we substract the value.
+ */
+static inline int a_sub( volatile int *val, int i)
+{
+    int tmp, tmp2;
+    asm volatile (
+        "   .set    push\n"
+        "   .set    noreorder\n"
+        "   nop\n"
+        "1:\n"
+        "   ll  %0, %1\n"
+        "   subu    %0, %0, %2\n"
+        "       move    %3, %0\n"
+        "   sc  %0, %1\n"
+        "   beq %0, 0x0, 1b\n"
+        "       move    %0, %3\n"
+        "   .set    pop\n"
+        : "=&r" (tmp), "=o" (*val)
+        : "r" (i), "r" (tmp2)
+        );
+    return tmp;
+}
+#endif

 /SPARTAN/trunk/arch/mips/include/fpu_context.h
 ,0 → 1,41
+/*
+ * Copyright (C) 2005 Jakub Vana
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __mips_FPU_CONTEXT_H__
+#define __mips_FPU_CONTEXT_H__
+#include <arch/types.h>
+struct fpu_context {
+/* TODO: define MIPS FPU context */
+};
+#endif

 /SPARTAN/trunk/arch/mips/include/faddr.h
 ,0 → 1,36
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __mips_FADDR_H__
+#define __mips_FADDR_H__
+#include <arch/types.h>
+#define FADDR(fptr)     ((__address) (fptr))
+#endif

 /SPARTAN/trunk/arch/mips/include/arg.h
 ,0 → 1,34
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __mips_ARG_H__
+#define __mips_ARG_H__
+#include <stackarg.h>
+#endif

 /SPARTAN/trunk/arch/mips/include/types.h
 ,0 → 1,47
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __TYPES_H__
+#define __TYPES_H__
+#define NULL    0
+typedef signed char __s8;
+typedef unsigned char __u8;
+typedef unsigned short __u16;
+typedef unsigned long __u32;
+typedef long long __u64;
+typedef __u32 __address;
+typedef __u32 pri_t;
+typedef __u32 __native;
+#endif

 /SPARTAN/trunk/arch/mips/include/asm/macro.h
 ,0 → 1,101
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/*
+ * MIPS assembler macros
+ */
+.macro REGISTERS_STORE r
+    sw $0,0(\r)
+    sw $1,4(\r)
+    sw $2,8(\r) # meaningless
+    sw $3,12(\r)
+    sw $4,16(\r)
+    sw $5,20(\r)
+    sw $6,24(\r)
+    sw $7,28(\r)
+    sw $8,32(\r)
+    sw $9,36(\r)
+    sw $10,40(\r)
+    sw $11,44(\r)
+    sw $12,48(\r)
+    sw $13,52(\r)
+    sw $14,56(\r)
+    sw $15,60(\r)
+    sw $16,64(\r)
+    sw $17,68(\r)
+    sw $18,72(\r)
+    sw $19,76(\r)
+    sw $20,80(\r)
+    sw $21,84(\r)
+    sw $22,88(\r)
+    sw $23,92(\r)
+    sw $24,96(\r)
+    sw $25,100(\r)
+    sw $26,104(\r)
+    sw $27,108(\r)
+    sw $28,112(\r)
+    sw $29,116(\r)
+    sw $30,120(\r)
+    sw $31,124(\r)
+.endm
+.macro REGISTERS_LOAD r
+    lw $0,0(\r)
+    lw $1,4(\r)
+    lw $2,8(\r)  # meaningless
+    lw $3,12(\r)
+    lw $4,16(\r) # this is ok, $4 == 16(\r)
+    lw $5,20(\r)
+    lw $6,24(\r)
+    lw $7,28(\r)
+    lw $8,32(\r)
+    lw $9,36(\r)
+    lw $10,40(\r)
+    lw $11,44(\r)
+    lw $12,48(\r)
+    lw $13,52(\r)
+    lw $14,56(\r)
+    lw $15,60(\r)
+    lw $16,64(\r)
+    lw $17,68(\r)
+    lw $18,72(\r)
+    lw $19,76(\r)
+    lw $20,80(\r)
+    lw $21,84(\r)
+    lw $22,88(\r)
+    lw $23,92(\r)
+    lw $24,96(\r)
+    lw $25,100(\r)
+    lw $26,104(\r)
+    lw $27,108(\r)
+    lw $28,112(\r)
+    lw $29,116(\r)
+    lw $30,120(\r)
+    lw $31,124(\r)
+.endm

 /SPARTAN/trunk/arch/mips/include/interrupt.h
 ,0 → 1,34
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __INTERRUPT_H__
+#define __INTERRUPT_H__
+extern void interrupt(void);
+#endif

 /SPARTAN/trunk/arch/mips/include/asm.h
 ,0 → 1,34
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __MIPS_ASM_H__
+#define __MIPS_ASM_H__
+#define cpu_sleep() ;
+#endif

 /SPARTAN/trunk/arch/mips/include/cp0.h
 ,0 → 1,93
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __CP0_H__
+#define __CP0_H__
+#include <arch/types.h>
+#define cp0_status_ie_enabled_bit   (1<<0)
+#define cp0_status_exl_exception_bit    (1<<1)
+#define cp0_status_erl_error_bit    (1<<2)
+#define cp0_status_bev_bootstrap_bit    (1<<22)
+#define cp0_status_im7_shift        15
+/*
+ * Magic value for use in msim.
+ * On AMD Duron 800Mhz, this roughly seems like one us.
+ */
+#define cp0_compare_value       10000
+extern  __u32 cp0_index_read(void);
+extern void cp0_idnex_write(__u32 val);
+extern __u32 cp0_random_read(void);
+extern __u32 cp0_entry_lo0_read(void);
+extern void cp0_entry_lo0_write(__u32 val);
+extern __u32 cp0_entry_lo1_read(void);
+extern void cp0_entry_lo1_write(__u32 val);
+extern __u32 cp0_context_read(void);
+extern void cp0_context_write(__u32 val);
+extern __u32 cp0_pagemask_read(void);
+extern void cp0_pagemask_write(__u32 val);
+extern __u32 cp0_wired_read(void);
+extern void cp0_wired_write(__u32 val);
+extern __u32 cp0_badvaddr_read(void);
+extern volatile __u32 cp0_count_read(void);
+extern void cp0_count_write(__u32 val);
+extern volatile __u32 cp0_entry_hi_read(void);
+extern void cp0_entry_hi_write(__u32 val);
+extern volatile __u32 cp0_compare_read(void);
+extern void cp0_compare_write(__u32 val);
+extern __u32 cp0_status_read(void);
+extern void cp0_status_write(__u32 val);
+extern __u32 cp0_cause_read(void);
+extern void cp0_cause_write(__u32 val);
+extern __u32 cp0_epc_read(void);
+extern void cp0_epc_write(__u32 val);
+extern __u32 cp0_prid_read(void);
+extern void tlbp(void);
+extern void tlbr(void);
+extern void tlbwi(void);
+extern void tlbwr(void);
+#endif

 /SPARTAN/trunk/arch/mips/include/cache.h
 ,0 → 1,34
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __CACHE_H__
+#define __CACHE_H__
+extern void cache_error(void);
+#endif

 /SPARTAN/trunk/arch/mips/include/thread.h
 ,0 → 1,36
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __mips_THREAD_H__
+#define __mips_THREAD_H__
+#define ARCH_THREAD_DATA \
+    pri_t   saved_pri; \
+    __u32   saved_epc;
+#endif

 /SPARTAN/trunk/arch/mips/boot/boot.s
 ,0 → 1,44
+#
+# Copyright (C) 2001-2004 Jakub Jermar
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+.text
+.set noat
+.set noreorder
+.set nomacro
+.global start
+start:
+    # move 0x80000000 to reg $8
+    lui $8, 0x8000
+    # prepare stack
+    lui $29, 0x8100
+    j $8
+    nop

 /SPARTAN/trunk/arch/mips/boot/Makefile
 ,0 → 1,24
+MIPS_BINUTILS_DIR=/usr/local/mipsel/bin
+MIPS_TARGET=mipsel-linux-gnu
+.PHONY: nothing build
+nothing:
+build: boot.bin
+    cp boot.bin ../../../src/load.bin
+AS=$(MIPS_BINUTILS_DIR)/$(MIPS_TARGET)-as
+LD=$(MIPS_BINUTILS_DIR)/$(MIPS_TARGET)-ld
+ASFLAGS=-mips2
+LFLAGS=--oformat=binary -mips2 -e start
+boot.bin: boot.o
+    $(LD) $(LFLAGS) boot.o -o $@
+boot.o:
+    $(AS) boot.s -o $@
+clean:
+    -rm *.o *.bin

 /SPARTAN/trunk/arch/mips/_link.ld
 ,0 → 1,52
+/*
+ *  MIPS linker script
+ *
+ *  kernel text
+ *  kernel data
+ *
+ */
+OUTPUT_FORMAT(binary)
+ENTRY(kernel_image_start)
+SECTIONS {
+    .image 0x80000000: AT (0x80000000) {
+        _gp = 0x00000000;
+        ktext_start = .;
+        *(.text);
+        ktext_end = .;
+        kdata_start = .;
+        *(.reginfo);
+        *(.rodata);
+        *(.rodata.*);
+        *(.rdata);
+        *(.data);       /* initialized data */
+        *(.lit8);
+        *(.lit4);
+        *(.sdata);
+        *(.sbss);
+        *(.bss);        /* uninitialized static variables */
+        *(.scommon);
+        *(COMMON);      /* global variables */
+        kdata_end = .;
+    } = 0x00000000
+    . = ABSOLUTE(hardcoded_ktext_size);
+    .patch_1 : {
+        LONG(ktext_end - ktext_start);
+    }
+    . = ABSOLUTE(hardcoded_kdata_size);
+    .patch_2 : {
+        LONG(kdata_end - kdata_start);
+    }
+    . = ABSOLUTE(hardcoded_load_address);
+    .patch_3 : {
+        LONG(0x80000000);
+    }
+}

 /SPARTAN/trunk/include/mm/page.h
 ,0 → 1,113
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __PAGE_H__
+#define __PAGE_H__
+#include <arch/types.h>
+#include <typedefs.h>
+#define PAGE_CACHEABLE_SHIFT        0
+#define PAGE_NOT_CACHEABLE_SHIFT    PAGE_CACHEABLE_SHIFT
+#define PAGE_PRESENT_SHIFT      1
+#define PAGE_NOT_PRESENT_SHIFT      PAGE_PRESENT_SHIFT
+#define PAGE_USER_SHIFT         2
+#define PAGE_KERNEL_SHIFT       PAGE_USER_SHIFT
+#define PAGE_READ_SHIFT         3
+#define PAGE_WRITE_SHIFT        4
+#define PAGE_EXEC_SHIFT         5
+#define PAGE_NOT_CACHEABLE  (0<<PAGE_CACHEABLE_SHIFT)
+#define PAGE_CACHEABLE      (1<<PAGE_CACHEABLE_SHIFT)
+#define PAGE_PRESENT        (0<<PAGE_PRESENT_SHIFT)
+#define PAGE_NOT_PRESENT    (1<<PAGE_PRESENT_SHIFT)
+#define PAGE_USER       (1<<PAGE_USER_SHIFT)
+#define PAGE_KERNEL     (0<<PAGE_USER_SHIFT)
+#define PAGE_READ       (1<<PAGE_READ_SHIFT)
+#define PAGE_WRITE      (1<<PAGE_WRITE_SHIFT)
+#define PAGE_EXEC       (1<<PAGE_EXEC_SHIFT)
+/*
+ * This is the generic 4-level page table interface.
+ * Architectures are supposed to implement *_ARCH macros.
+ */
+/*
+ * These macros process vaddr and extract those portions
+ * of it that function as indices to respective page tables.
+ */
+#define PTL0_INDEX(vaddr)       PTL0_INDEX_ARCH(vaddr)
+#define PTL1_INDEX(vaddr)       PTL1_INDEX_ARCH(vaddr)
+#define PTL2_INDEX(vaddr)       PTL2_INDEX_ARCH(vaddr)
+#define PTL3_INDEX(vaddr)       PTL3_INDEX_ARCH(vaddr)
+#define GET_PTL0_ADDRESS()      GET_PTL0_ADDRESS_ARCH()
+#define SET_PTL0_ADDRESS(ptl0)      SET_PTL0_ADDRESS_ARCH(ptl0)
+/*
+ * These macros traverse the 4-level tree of page tables,
+ * each descending by one level.
+ */
+#define GET_PTL1_ADDRESS(ptl0, i)   GET_PTL1_ADDRESS_ARCH(ptl0, i)
+#define GET_PTL2_ADDRESS(ptl1, i)   GET_PTL2_ADDRESS_ARCH(ptl1, i)
+#define GET_PTL3_ADDRESS(ptl2, i)   GET_PTL3_ADDRESS_ARCH(ptl2, i)
+#define GET_FRAME_ADDRESS(ptl3, i)  GET_FRAME_ADDRESS_ARCH(ptl3, i)
+/*
+ * These macros are provided to change shape of the 4-level
+ * tree of page tables on respective level.
+ */
+#define SET_PTL1_ADDRESS(ptl0, i, a)    SET_PTL1_ADDRESS_ARCH(ptl0, i, a)
+#define SET_PTL2_ADDRESS(ptl1, i, a)    SET_PTL2_ADDRESS_ARCH(ptl1, i, a)
+#define SET_PTL3_ADDRESS(ptl2, i, a)    SET_PTL3_ADDRESS_ARCH(ptl2, i, a)
+#define SET_FRAME_ADDRESS(ptl3, i, a)   SET_FRAME_ADDRESS_ARCH(ptl3, i, a)
+/*
+ * These macros are provided to query various flags within the page tables.
+ */
+#define GET_PTL1_FLAGS(ptl0, i)     GET_PTL1_FLAGS_ARCH(ptl0, i)
+#define GET_PTL2_FLAGS(ptl1, i)     GET_PTL2_FLAGS_ARCH(ptl1, i)
+#define GET_PTL3_FLAGS(ptl2, i)     GET_PTL3_FLAGS_ARCH(ptl2, i)
+#define GET_FRAME_FLAGS(ptl3, i)    GET_FRAME_FLAGS_ARCH(ptl3, i)
+/*
+ * These macros are provided to set/clear various flags within the page tables.
+ */
+#define SET_PTL1_FLAGS(ptl0, i, x)  SET_PTL1_FLAGS_ARCH(ptl0, i, x)
+#define SET_PTL2_FLAGS(ptl1, i, x)  SET_PTL2_FLAGS_ARCH(ptl1, i, x)
+#define SET_PTL3_FLAGS(ptl2, i, x)  SET_PTL3_FLAGS_ARCH(ptl2, i, x)
+#define SET_FRAME_FLAGS(ptl3, i, x) SET_FRAME_FLAGS_ARCH(ptl3, i, x)
+extern void page_init(void);
+extern void map_page_to_frame(__address page, __address frame, int flags, __address root);
+extern void map_structure(__address s, size_t size);
+#endif

 /SPARTAN/trunk/include/mm/vm.h
 ,0 → 1,91
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __VM_H__
+#define __VM_H__
+#include <arch/mm/page.h>
+#include <arch/mm/vm.h>
+#include <arch/types.h>
+#include <typedefs.h>
+#include <synch/spinlock.h>
+#include <list.h>
+#define KERNEL_ADDRESS_SPACE_START  KERNEL_ADDRESS_SPACE_START_ARCH
+#define KERNEL_ADDRESS_SPACE_END    KERNEL_ADDRESS_SPACE_END_ARCH
+#define USER_ADDRESS_SPACE_START    USER_ADDRESS_SPACE_START_ARCH
+#define USER_ADDRESS_SPACE_END      USER_ADDRESS_SPACE_END_ARCH
+#define IS_KA(addr) ((addr)>=KERNEL_ADDRESS_SPACE_START && (addr)<=KERNEL_ADDRESS_SPACE_END)
+#define UTEXT_ADDRESS   UTEXT_ADDRESS_ARCH
+#define USTACK_ADDRESS  USTACK_ADDRESS_ARCH
+#define UDATA_ADDRESS   UDATA_ADDRESS_ARCH
+enum vm_type {
+    VMA_TEXT = 1, VMA_DATA, VMA_STACK
+};
+/*
+ * Each vm_area_t structure describes one continuous area of virtual memory.
+ * In the future, it should not be difficult to support shared areas of vm.
+ */
+struct vm_area {
+    spinlock_t lock;
+    link_t link;
+    vm_type_t type;
+    int size;
+    __address address;
+    __address *mapping;
+};
+/*
+ * vm_t contains the list of vm_areas of userspace accessible
+ * pages for one or more tasks. Ranges of kernel memory pages are not
+ * supposed to figure in the list as they are shared by all tasks and
+ * set up during system initialization.
+ */
+struct vm {
+    spinlock_t lock;
+    link_t vm_area_head;
+    pte_t *ptl0;
+};
+extern vm_t * vm_create(pte_t *ptl0);
+extern void vm_destroy(vm_t *m);
+extern vm_area_t *vm_area_create(vm_t *m, vm_type_t type, size_t size, __address addr);
+extern void vm_area_destroy(vm_area_t *a);
+extern void vm_area_map(vm_area_t *a, vm_t *m);
+extern void vm_area_unmap(vm_area_t *a, vm_t *m);
+extern void vm_install(vm_t *m);
+extern void vm_uninstall(vm_t *m);
+#endif

 /SPARTAN/trunk/include/mm/frame.h
 ,0 → 1,56
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __FRAME_H__
+#define __FRAME_H__
+#include <arch/types.h>
+#include <typedefs.h>
+#define FRAME_KA    1   /* skip frames conflicting with user address space */
+#define FRAME_PANIC 2   /* panic on failure */
+extern count_t frames;
+extern count_t frames_free;
+extern count_t kernel_frames;
+extern count_t kernel_frames_free;
+extern __u8 *frame_bitmap;
+extern count_t frame_bitmap_octets;
+extern __u8 *frame_kernel_bitmap;
+extern void frame_init(void);
+__address frame_alloc(int flags);
+extern void frame_free(__address addr);
+extern void frame_not_free(__address addr);
+extern void frame_region_not_free(__address start, __address stop);
+#endif

 /SPARTAN/trunk/include/mm/heap.h
 ,0 → 1,48
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __HEAP_H__
+#define __HEAP_H__
+#include <arch/types.h>
+#include <typedefs.h>
+struct chunk {
+    int used;
+    struct chunk *next;
+    struct chunk *prev;
+    __u32 size;
+    __u8 data[0];
+};
+extern void heap_init(__address heap, size_t size);
+extern void *malloc(size_t size);
+extern void free(void *ptr);
+#endif

 /SPARTAN/trunk/include/mm/tlb.h
 ,0 → 1,50
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __TLB_H__
+#define __TLB_H__
+#ifdef __SMP__
+extern void tlb_init(void);
+extern void tlb_shootdown_start(void);
+extern void tlb_shootdown_finalize(void);
+extern void tlb_shootdown_ipi_recv(void);
+#else
+#define tlb_init()      ;
+#define tlb_shootdown_start()   ;
+#define tlb_shootdown_finalize()    ;
+#define tlb_shootdown_ipi_recv() ;
+#endif /* __SMP__ */
+/* Export TLB interface that each architecture must implement. */
+extern void tlb_invalidate(int asid);
+extern void tlb_shootdown_ipi_send(void);
+#endif

 /SPARTAN/trunk/include/synch/semaphore.h
 ,0 → 1,53
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __SEMAPHORE_H__
+#define __SEMAPHORE_H__
+#include <arch/types.h>
+#include <typedefs.h>
+#include <synch/waitq.h>
+#include <synch/synch.h>
+struct semaphore
+{
+    waitq_t wq;
+};
+#define semaphore_down(s) \
+    _semaphore_down_timeout((s),SYNCH_NO_TIMEOUT,SYNCH_BLOCKING)
+#define semaphore_trydown(s) \
+    _semaphore_down_timeout((s),SYNCH_NO_TIMEOUT,SYNCH_NON_BLOCKING)
+#define semaphore_down_timeout(s,usec) \
+    _semaphore_down_timeout((s),(usec),SYNCH_NON_BLOCKING)
+extern void semaphore_initialize(semaphore_t *s, int val);
+extern int _semaphore_down_timeout(semaphore_t *s, __u32 usec, int trydown);
+extern void semaphore_up(semaphore_t *s);
+#endif

 /SPARTAN/trunk/include/synch/waitq.h
 ,0 → 1,57
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __WAITQ_H__
+#define __WAITQ_H__
+#include <arch/types.h>
+#include <typedefs.h>
+#include <synch/spinlock.h>
+#include <synch/synch.h>
+#include <list.h>
+#define WAKEUP_FIRST    0
+#define WAKEUP_ALL  1
+struct waitq {
+    spinlock_t lock;
+    int missed_wakeups;
+    link_t head;
+};
+#define waitq_sleep(wq) \
+    waitq_sleep_timeout((wq),SYNCH_NO_TIMEOUT,SYNCH_BLOCKING)
+extern void waitq_interrupted_sleep(void *data);
+extern void waitq_initialize(waitq_t *wq);
+extern int waitq_sleep_timeout(waitq_t *wq, __u32 usec, int nonblocking);
+extern void waitq_wakeup(waitq_t *wq, int all);
+extern void _waitq_wakeup_unsafe(waitq_t *wq, int all);
+#endif

 /SPARTAN/trunk/include/synch/condvar.h
 ,0 → 1,53
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __CONDVAR_H__
+#define __CONDVAR_H__
+#include <arch/types.h>
+#include <synch/waitq.h>
+#include <typedefs.h>
+#include <synch/synch.h>
+struct condvar {
+    waitq_t wq;
+};
+#define condvar_wait(cv,mtx) \
+    _condvar_wait_timeout((cv),(mtx),SYNCH_NO_TIMEOUT,SYNCH_BLOCKING)
+#define condvar_trywait(cv,mtx) \
+    _condvar_wait_timeout((cv),(mtx),SYNCH_NO_TIMEOUT,SYNCH_NON_BLOCKING)
+#define condvar_wait_timeout(cv,mtx,usec) \
+    _condvar_wait_timeout((cv),(mtx),(usec),SYNCH_NON_BLOCKING)
+extern void condvar_initialize(condvar_t *cv);
+extern void condvar_signal(condvar_t *cv);
+extern void condvar_broadcast(condvar_t *cv);
+extern int _condvar_wait_timeout(condvar_t *cv, mutex_t *mtx, __u32 usec, int trywait);
+#endif

 /SPARTAN/trunk/include/synch/rwlock.h
 ,0 → 1,68
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __RWLOCK_H__
+#define __RWLOCK_H__
+#include <arch/types.h>
+#include <typedefs.h>
+#include <synch/mutex.h>
+#include <synch/synch.h>
+enum rwlock_type {
+    RWLOCK_NONE,
+    RWLOCK_READER,
+    RWLOCK_WRITER
+};
+struct rwlock {
+    spinlock_t lock;
+    mutex_t exclusive;
+    int readers_in;
+};
+#define rwlock_write_lock(rwl) \
+    _rwlock_write_lock_timeout((rwl),SYNCH_NO_TIMEOUT,SYNCH_BLOCKING)
+#define rwlock_read_lock(rwl) \
+    _rwlock_read_lock_timeout((rwl),SYNCH_NO_TIMEOUT,SYNCH_BLOCKING)
+#define rwlock_write_trylock(rwl) \
+    _rwlock_write_lock_timeout((rwl),SYNCH_NO_TIMEOUT,SYNCH_NON_BLOCKING)
+#define rwlock_read_trylock(rwl) \
+    _rwlock_read_lock_timeout((rwl),SYNCH_NO_TIMEOUT,SYNCH_NON_BLOCKING)
+#define rwlock_write_lock_timeout(rwl,usec) \
+    _rwlock_write_lock_timeout((rwl),(usec),SYNCH_NON_BLOCKING)
+#define rwlock_read_lock_timeout(rwl,usec) \
+    _rwlock_read_lock_timeout((rwl),(usec),SYNCH_NON_BLOCKING)
+extern void rwlock_initialize(rwlock_t *rwl);
+extern void rwlock_read_unlock(rwlock_t *rwl);
+extern void rwlock_write_unlock(rwlock_t *rwl);
+extern int _rwlock_read_lock_timeout(rwlock_t *rwl, __u32 usec, int trylock);
+extern int _rwlock_write_lock_timeout(rwlock_t *rwl, __u32 usec, int trylock);
+#endif

 /SPARTAN/trunk/include/synch/mutex.h
 ,0 → 1,52
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __MUTEX_H__
+#define __MUTEX_H__
+#include <arch/types.h>
+#include <typedefs.h>
+#include <synch/semaphore.h>
+#include <synch/synch.h>
+struct mutex {
+    semaphore_t sem;
+};
+#define mutex_lock(mtx) \
+    _mutex_lock_timeout((mtx),SYNCH_NO_TIMEOUT,SYNCH_BLOCKING)
+#define mutex_trylock(mtx) \
+    _mutex_lock_timeout((mtx),SYNCH_NO_TIMEOUT,SYNCH_NON_BLOCKING)
+#define mutex_lock_timeout(mtx,usec) \
+    _mutex_lock_timeout((mtx),(usec),SYNCH_NON_BLOCKING)
+extern void mutex_initialize(mutex_t *mtx);
+extern int _mutex_lock_timeout(mutex_t *mtx, __u32 usec, int trylock);
+extern void mutex_unlock(mutex_t *mtx);
+#endif

 /SPARTAN/trunk/include/synch/spinlock.h
 ,0 → 1,57
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __SPINLOCK_H__
+#define __SPINLOCK_H__
+#include <arch/types.h>
+#include <typedefs.h>
+#ifdef __SMP__
+struct spinlock {
+    int val;
+};
+extern void spinlock_initialize(spinlock_t *sl);
+extern void spinlock_lock(spinlock_t *sl);
+extern int spinlock_trylock(spinlock_t *sl);
+extern void spinlock_unlock(spinlock_t *sl);
+#else
+struct spinlock {
+};
+#define spinlock_initialize(x)
+#define spinlock_lock(x)
+#define spinlock_trylock(x) 1
+#define spinlock_unlock(x)
+#endif
+#endif

 /SPARTAN/trunk/include/synch/synch.h
 ,0 → 1,44
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __SYNCH_H__
+#define __SYNCH_H__
+#define SYNCH_NO_TIMEOUT    0
+#define SYNCH_BLOCKING      0
+#define SYNCH_NON_BLOCKING  1
+#define ESYNCH_WOULD_BLOCK  1
+#define ESYNCH_TIMEOUT      2
+#define ESYNCH_OK_ATOMIC    4
+#define ESYNCH_OK_BLOCKED   8
+#define SYNCH_FAILED(rc)    ((rc) & (ESYNCH_WOULD_BLOCK | ESYNCH_TIMEOUT))
+#define SYNCH_OK(rc)        ((rc) & (ESYNCH_OK_ATOMIC | ESYNCH_OK_BLOCKED))
+#endif

 /SPARTAN/trunk/include/stackarg.h
 ,0 → 1,55
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/*
+ * Variable argument list manipulation macros
+ * for architectures using stack to pass arguments.
+ */
+#ifndef __STACKARG_H__
+#define __STACKARG_H__
+#include <arch/types.h>
+typedef struct va_list {
+    int pos;
+    __address *last;
+} va_list;
+#define va_start(ap, lst)       \
+    (ap).pos = 0;           \
+    (ap).last = (__address *) &(lst)
+#define va_arg(ap, type)        \
+    ((type) *((ap).last + ++((ap).pos)))
+#define va_end(ap)
+#endif

 /SPARTAN/trunk/include/time/timeout.h
 ,0 → 1,60
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __TIMEOUT_H__
+#define __TIMEOUT_H__
+#include <arch/types.h>
+#include <typedefs.h>
+#include <synch/spinlock.h>
+#include <list.h>
+#define us2ticks(us)    ((__u64)(((__u32) (us)/(1000000/HZ))))
+typedef void (* timeout_handler)(void *arg);
+struct timeout {
+    spinlock_t lock;
+    link_t link;
+    __u64 ticks;
+    timeout_handler handler;
+    void *arg;
+    cpu_t *cpu;
+};
+extern void timeout_init(void);
+extern void timeout_initialize(timeout_t *t);
+extern void timeout_reinitialize(timeout_t *t);
+extern void timeout_register(timeout_t *t, __u64 usec, timeout_handler f, void *arg);
+extern int timeout_unregister(timeout_t *t);
+#endif

 /SPARTAN/trunk/include/time/clock.h
 ,0 → 1,36
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __CLOCK_H__
+#define __CLOCK_H__
+#define HZ      100
+extern void clock(void);
+#endif

 /SPARTAN/trunk/include/time/delay.h
 ,0 → 1,36
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __DELAY_H__
+#define __DELAY_H__
+#include <arch/types.h>
+extern void delay(__u32 microseconds);
+#endif

 /SPARTAN/trunk/include/proc/thread.h
 ,0 → 1,127
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __THREAD_H__
+#define __THREAD_H__
+#include <arch/thread.h>
+#include <proc/task.h>
+#include <synch/spinlock.h>
+#include <arch/context.h>
+#include <fpu_context.h>
+#include <arch/types.h>
+#include <typedefs.h>
+#include <time/timeout.h>
+#include <synch/rwlock.h>
+#include <mm/page.h>
+#include <list.h>
+#define THREAD_STACK_SIZE   PAGE_SIZE
+#define THREAD_USER_STACK   1
+enum state {
+    Invalid,
+    Running,
+    Sleeping,
+    Ready,
+    Entering,
+    Exiting
+};
+extern char *thread_states[];
+#define X_WIRED     (1<<0)
+#define X_STOLEN    (1<<1)
+struct thread {
+    link_t rq_link;             /* run queue link */
+    link_t wq_link;             /* wait queue link */
+    link_t th_link;             /* links to threads within the parent task*/
+    link_t threads_link;
+    /* items below are protected by lock */
+    spinlock_t lock;
+    void (* thread_code)(void *);
+    void *thread_arg;
+    context_t saved_context;
+    context_t sleep_timeout_context;
+    fpu_context_t saved_fpu_context;
+    int fpu_context_exists;
+    /*
+     * Defined only if thread doesn't run.
+     * It means that fpu context is in CPU that last time executes this thread.
+     * This disables migration
+     */
+    int fpu_context_engaged;
+    waitq_t *sleep_queue;
+    timeout_t sleep_timeout;
+    volatile int timeout_pending;
+    rwlock_type_t rwlock_holder_type;
+    void (* call_me)(void *);
+    void *call_me_with;
+    int state;
+    int flags;
+    cpu_t *cpu;
+    task_t *task;
+    __u64 ticks;
+    __u32 tid;
+    int pri;
+    ARCH_THREAD_DATA;
+    __u8 *kstack;
+    __u8 *ustack;
+};
+extern spinlock_t threads_lock;
+extern link_t threads_head;
+static void cushion(void);
+extern void thread_init(void);
+extern thread_t *thread_create(void (* func)(void *), void *arg, task_t *task, int flags);
+extern void thread_ready(thread_t *t);
+extern void thread_exit(void);
+extern void thread_sleep(__u32 sec);
+extern void thread_usleep(__u32 usec);
+extern void thread_register_call_me(void (* call_me)(void *), void *call_me_with);
+#endif

 /SPARTAN/trunk/include/proc/scheduler.h
 ,0 → 1,64
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __SCHEDULER_H__
+#define __SCHEDULER_H__
+#include <synch/spinlock.h>
+#include <time/clock.h>     /* HZ */
+#include <typedefs.h>
+#include <list.h>
+#define RQ_COUNT        16
+#define NEEDS_RELINK_MAX    (HZ)
+struct runq {
+    spinlock_t lock;
+    link_t rq_head;
+    int n;
+};
+extern volatile int nrdy;
+static thread_t *find_best_thread(void);
+static void relink_rq(int start);
+static void scheduler_separated_stack(void);
+extern void scheduler_init(void);
+extern void scheduler(void);
+extern void kcpulb(void *arg);
+/*
+ * To be defined by architectures:
+ */
+extern void before_thread_runs(void);
+extern void before_thread_runs_arch(void);
+#endif

 /SPARTAN/trunk/include/proc/task.h
 ,0 → 1,51
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __TASK_H__
+#define __TASK_H__
+#include <typedefs.h>
+#include <synch/spinlock.h>
+#include <proc/thread.h>
+#include <mm/vm.h>
+#include <list.h>
+struct task {
+    spinlock_t lock;
+    link_t th_head;     /* list of threads contained in this task */
+    link_t tasks_link;  /* link to other tasks within the system */
+    vm_t *vm;
+};
+extern spinlock_t tasks_lock;
+extern link_t tasks_head;
+extern void task_init(void);
+extern task_t *task_create(vm_t *m);
+#endif

 /SPARTAN/trunk/include/typedefs.h
 ,0 → 1,74
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __TYPEDEFS_H__
+#define __TYPEDEFS_H__
+#define false 0
+#define true 1
+typedef short bool;
+typedef unsigned int size_t;
+typedef unsigned int count_t;
+typedef unsigned int index_t;
+typedef struct config config_t;
+typedef struct cpu_private_data cpu_private_data_t;
+typedef struct cpu_info cpu_info_t;
+typedef struct cpu cpu_t;
+typedef struct cpu_arch cpu_arch_t;
+typedef struct task task_t;
+typedef struct thread thread_t;
+typedef struct context context_t;
+typedef struct fpu_context fpu_context_t;
+typedef struct timeout timeout_t;
+typedef struct runq runq_t;
+typedef struct spinlock spinlock_t;
+typedef struct mutex mutex_t;
+typedef struct semaphore semaphore_t;
+typedef struct rwlock rwlock_t;
+typedef enum rwlock_type rwlock_type_t;
+typedef struct condvar condvar_t;
+typedef struct waitq waitq_t;
+typedef struct chunk chunk_t;
+typedef enum vm_type vm_type_t;
+typedef struct vm_area vm_area_t;
+typedef struct vm vm_t;
+typedef struct link link_t;
+typedef char *char_ptr;
+#endif

 /SPARTAN/trunk/include/arch.h
 ,0 → 1,59
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __ARCH_H__
+#define __ARCH_H__
+#include <arch/types.h>
+#include <typedefs.h>
+#include <cpu.h>
+#include <arch/cpu.h>
+/*
+ * NOTE:
+ * CPU, THREAD and TASK are not preemption-safe.
+ * Provisions must be made to prevent preemption prior
+ * to using these macros. Simple cpu_priority_high()
+ * call will suffice.
+ */
+#define CPU     (&cpus[CPU_ID_ARCH])
+#define THREAD      (cpu_private_data[CPU_ID_ARCH].thread)
+#define TASK        (cpu_private_data[CPU_ID_ARCH].task)
+extern void arch_pre_mm_init(void);
+extern void arch_post_mm_init(void);
+extern void arch_late_init(void);
+extern void calibrate_delay_loop(void);
+extern pri_t cpu_priority_high(void);
+extern pri_t cpu_priority_low(void);
+extern void cpu_priority_restore(pri_t pri);
+extern pri_t cpu_priority_read(void);
+#endif

 /SPARTAN/trunk/include/userspace.h
 ,0 → 1,34
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __USERSPACE_H__
+#define __USERSPACE_H__
+extern void userspace(void) __attribute__ ((noreturn)); /**< Switch to user-space (CPU user priviledge level) */
+#endif

 /SPARTAN/trunk/include/config.h
 ,0 → 1,50
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __CONFIG_H__
+#define __CONFIG_H__
+#include <arch/types.h>
+#include <typedefs.h>
+#define CONFIG_MEMORY_SIZE  4*1024*1024
+#define CONFIG_HEAP_SIZE    300*1024
+#define CONFIG_STACK_SIZE   32*1024
+struct config {
+    __address base;
+    size_t memory_size;
+    size_t kernel_size;
+    count_t cpu_count;
+    volatile count_t cpu_active;
+};
+extern config_t config;
+#endif

 /SPARTAN/trunk/include/context.h
 ,0 → 1,46
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __CONTEXT_H__
+#define __CONTEXT_H__
+#include <arch/types.h>
+#include <typedefs.h>
+#ifndef context_set
+#define context_set(c, _pc, stack, size)    \
+    (c)->pc = (__address) (_pc);        \
+    (c)->sp = ((__address) (stack)) + (size) - SP_DELTA;
+#endif /* context_set */
+extern int context_save(context_t *c);
+extern void context_restore(context_t *c) __attribute__ ((noreturn));
+#endif

 /SPARTAN/trunk/include/fpu_context.h
 ,0 → 1,44
+/*
+ * Copyright (C) 2005 Jakub Vana
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef fpu_context_h
+#define fpu_context_h
+#include <arch/fpu_context.h>
+#include <typedefs.h>
+extern void fpu_context_save(fpu_context_t *);
+extern void fpu_context_restore(fpu_context_t *);
+extern void fpu_lazy_context_save(fpu_context_t *);
+extern void fpu_lazy_context_restore(fpu_context_t *);
+extern void fpu_init(void);
+#endif /*fpu_context_h*/

 /SPARTAN/trunk/include/print.h
 ,0 → 1,46
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __PRINT_H__
+#define __PRINT_H__
+#include <arch/types.h>
+#define INT8    1
+#define INT16   2
+#define INT32   4
+#define INT64   8
+static void print_str(const char *str);
+static void print_fixed_hex(const __native num, const int width);
+static void print_number(const __native num, const unsigned int base);
+extern void putchar(const char c);
+extern void printf(const char *fmt, ...);
+#endif

 /SPARTAN/trunk/include/cpu.h
 ,0 → 1,92
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __CPU_H__
+#define __CPU_H__
+#include <arch/cpu.h>
+#include <proc/thread.h>
+#include <proc/task.h>
+#include <proc/scheduler.h>
+#include <time/clock.h>
+#include <synch/spinlock.h>
+#include <synch/waitq.h>
+#include <arch/types.h>
+#include <typedefs.h>
+#include <arch/context.h>
+#define CPU_STACK_SIZE  (4096)
+struct cpu {
+    spinlock_t lock;
+    context_t saved_context;
+    volatile int nrdy;
+    runq_t rq[RQ_COUNT];
+    volatile int needs_relink;
+    spinlock_t timeoutlock;
+    link_t timeout_active_head;
+    #ifdef __SMP__
+    int kcpulbstarted;
+    waitq_t kcpulb_wq;
+    #endif /* __SMP__ */
+    int id;
+    int active;
+    int tlb_active;
+    __u16 frequency_mhz;
+    __u32 delay_loop_const;
+    cpu_arch_t arch;
+    thread_t *fpu_owner;
+    __u8 *stack;
+};
+/*
+ * read/write by associated CPU
+ * read only by other CPUs
+ */
+struct cpu_private_data {
+    thread_t *thread;
+    task_t *task;
+};
+extern cpu_private_data_t *cpu_private_data;
+extern cpu_t *cpus;
+extern void cpu_init(void);
+extern void cpu_arch_init(void);
+extern void cpu_identify(void);
+extern void cpu_print_report(cpu_t *m);
+#endif

 /SPARTAN/trunk/include/func.h
 ,0 → 1,40
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __FUNC_H__
+#define __FUNC_H__
+#include <arch/types.h>
+extern __u32 haltstate;
+extern void halt(void);
+extern int strcmp(const char *src, const char *dst);
+#endif

 /SPARTAN/trunk/include/memstr.h
 ,0 → 1,48
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __MEMSTR_H__
+#define __MEMSTR_H__
+#include <typedefs.h>
+#include <arch/types.h>
+extern void memcopy(__address src, __address dst, size_t cnt);
+extern void memsetw(__address dst, size_t cnt, __u16 x);
+extern void memsetb(__address dst, size_t cnt, __u8 x);
+extern int memcmp(__address src, __address dst, int cnt);
+/*
+ * Architecture independent variants.
+ */
+extern void _memcopy(__address src, __address dst, size_t cnt);
+extern void _memsetb(__address dst, size_t cnt, __u8 x);
+#endif

 /SPARTAN/trunk/include/debug.h
 ,0 → 1,50
+/*
+ * Copyright (C) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __DEBUG_H__
+#define __DEBUG_H__
+#include <panic.h>
+/** Debugging ASSERT macro
+ *
+ * If NDEBUG is not set, the ASSERT() macro
+ * evaluates expr and if it is false raises
+ * kernel panic.
+ *
+ * @param expr Expression which is expected to be true.
+ *
+ */
+#ifndef NDEBUG
+#   define ASSERT(expr) if (!(expr)) { panic("assertion failed (%s)", #expr); }
+#else
+#   define ASSERT(expr)
+#endif
+#endif

 /SPARTAN/trunk/include/panic.h
 ,0 → 1,40
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __PANIC_H__
+#define __PANIC_H__
+#ifndef NDEBUG
+#   define panic(format, ...) panic_printf("Kernel panic in %s() at %s on line %d: " format, __FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__);
+#else
+#   define panic(format, ...) panic_printf("Kernel panic: " format, ##__VA_ARGS__);
+#endif
+extern void panic_printf(char *fmt, ...);
+#endif

 /SPARTAN/trunk/include/list.h
 ,0 → 1,78
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __LIST_H__
+#define __LIST_H__
+#include <arch/types.h>
+#include <typedefs.h>
+struct link {
+    link_t *prev;
+    link_t *next;
+};
+#define link_initialize(link) { \
+    (link)->prev = NULL; \
+    (link)->next = NULL; \
+}
+#define list_initialize(head) { \
+    (head)->prev = (head); \
+    (head)->next = (head); \
+}
+#define list_prepend(link, head) { \
+    (link)->next = (head)->next; \
+    (link)->prev = (head); \
+    (head)->next->prev = (link); \
+    (head)->next = (link); \
+}
+#define list_append(link, head) { \
+    (link)->prev = (head)->prev; \
+    (link)->next = (head); \
+    (head)->prev->next = (link); \
+    (head)->prev = (link); \
+}
+#define list_remove(link) { \
+    (link)->next->prev = (link)->prev; \
+    (link)->prev->next = (link)->next; \
+    link_initialize(link); \
+}
+#define list_empty(head) (((head)->next == (head))?true:false)
+#define list_get_instance(link,type,member) (type *)(((__u8*)(link))-((__u8*)&(((type *)NULL)->member)))
+extern bool list_member(const link_t *link, const link_t *head);
+extern void list_concat(link_t *head1, link_t *head2);
+#endif

 /SPARTAN/trunk/include/putchar.h
 ,0 → 1,34
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __PUTCHAR_H__
+#define __PUTCHAR_H__
+extern void putchar(const char ch);
+#endif

 /SPARTAN/trunk/include/stdarg.h
 ,0 → 1,44
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/*
+ * Variable argument list manipulation macros
+ * for all architectures with compiler support for __builtin_va_*.
+ */
+#ifndef __STDARG_H__
+#define __STDARG_H__
+typedef __builtin_va_list va_list;
+#define va_start(ap, last)      __builtin_va_start(ap, last)
+#define va_arg(ap, type)        __builtin_va_arg(ap, type)
+#define va_end(ap)          __builtin_va_end(ap)
+#endif

 /SPARTAN/trunk/include/smp/smp.h
 ,0 → 1,38
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __SMP_H__
+#define __SMP_H__
+#ifdef __SMP__
+extern void smp_init(void);
+#else
+#define smp_init()  ;
+#endif /* __SMP__ */
+#endif /* __SMP_H__ */

 /SPARTAN/trunk/include/smp/ipi.h
 ,0 → 1,39
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __IPI_H__
+#define __IPI_H__
+#ifdef __SMP__
+extern void ipi_broadcast(int ipi);
+extern void ipi_broadcast_arch(int ipi);
+#else
+#define ipi_broadcast(x)    ;
+#endif /* __SMP__ */
+#endif

 /SPARTAN/trunk/include/main/kinit.h
 ,0 → 1,34
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __KINIT_H__
+#define __KINIT_H__
+extern void kinit(void *arg);
+#endif

 /SPARTAN/trunk/include/main/uinit.h
 ,0 → 1,39
+/*
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __UINIT_H__
+#define __UINIT_H__
+#include <arch/types.h>
+extern void utext(void);
+extern __u32 utext_size;
+extern void uinit(void *arg);
+#endif

 /SPARTAN/trunk/include/test.h
 ,0 → 1,34
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __TEST_H__
+#define __TEST_H__
+extern void test(void);
+#endif

 /SPARTAN/trunk/contrib/toolchain.ppc.sh
 ,0 → 1,84
+#!/bin/bash
+# Cross-Compiler Toolchain for ${PLATFORM}
+#  by Martin Decky <martin@decky.cz>
+#
+#  GPL'ed, copyleft
+#
+check_error() {
+    if [ "$1" -ne "0" ]; then
+    echo
+    echo "Script failed: $2"
+    exit
+    fi
+}
+BINUTILS_VERSION="2.16"
+GCC_VERSION="4.0.1"
+BINUTILS="binutils-${BINUTILS_VERSION}.tar.gz"
+GCC="gcc-core-${GCC_VERSION}.tar.bz2"
+BINUTILS_SOURCE="ftp://ftp.gnu.org/gnu/binutils/"
+GCC_SOURCE="ftp://ftp.gnu.org/gnu/gcc/gcc-${GCC_VERSION}/"
+PLATFORM="ppc"
+WORKDIR=`pwd`
+TARGET="${PLATFORM}-linux-gnu"
+HOST="i686-pc-linux-gnu"
+PREFIX="/usr/local/${PLATFORM}"
+BINUTILSDIR="${WORKDIR}/binutils-${BINUTILS_VERSION}"
+GCCDIR="${WORKDIR}/gcc-${GCC_VERSION}"
+OBJDIR="${WORKDIR}/gcc-obj"
+echo ">>> Downloading tarballs"
+if [ ! -f "${BINUTILS}" ]; then
+    wget -c "${BINUTILS_SOURCE}${BINUTILS}"
+    check_error $? "Error downloading binutils."
+fi
+if [ ! -f "${GCC}" ]; then
+    wget -c "${GCC_SOURCE}${GCC}"
+    check_error $? "Error downloading GCC."
+fi
+echo ">>> Creating destionation directory"
+if [ ! -d "${PREFIX}" ]; then
+    mkdir -p "${PREFIX}"
+    test -d "${PREFIX}"
+    check_error $? "Unable to create ${PREFIX}."
+fi
+echo ">>> Creating GCC work directory"
+if [ ! -d "${OBJDIR}" ]; then
+    mkdir -p "${OBJDIR}"
+    test -d "${OBJDIR}"
+    check_error $? "Unable to create ${OBJDIR}."
+fi
+echo ">>> Unpacking tarballs"
+tar -xvzf "${BINUTILS}"
+check_error $? "Error unpacking binutils."
+tar -xvjf "${GCC}"
+check_error $? "Error unpacking GCC."
+echo ">>> Compiling and installing binutils"
+cd "${BINUTILSDIR}"
+check_error $? "Change directory failed."
+./configure "--host=${HOST}" "--target=${TARGET}" "--prefix=${PREFIX}" "--disable-nls"
+check_error $? "Error configuring binutils."
+make all install
+check_error $? "Error compiling/installing binutils."
+echo ">>> Compiling and installing GCC"
+cd "${OBJDIR}"
+check_error $? "Change directory failed."
+"${GCCDIR}/configure" "--host=${HOST}" "--target=${TARGET}" "--prefix=${PREFIX}" "--program-prefix=${TARGET}-" --with-gnu-as --with-gnu-ld --disable-nls --disable-threads --enable-languages=c --disable-multilib --disable-libgcj --without-headers --disable-shared
+check_error $? "Error configuring GCC."
+PATH="${PATH}:${PREFIX}/bin" make all-gcc install-gcc
+check_error $? "Error compiling/installing GCC."
+echo
+echo ">>> Cross-compiler for ${TARGET} installed."
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /SPARTAN/trunk/contrib/toolchain.ia64.sh
 ,0 → 1,93
+#!/bin/bash
+# Cross-Compiler Toolchain for ${PLATFORM}
+#  by Martin Decky <martin@decky.cz>
+#
+#  GPL'ed, copyleft
+#
+check_error() {
+    if [ "$1" -ne "0" ]; then
+    echo
+    echo "Script failed: $2"
+    exit
+    fi
+}
+BINUTILS_VERSION="2.16"
+GCC_VERSION="4.0.1"
+INCLUDES="ia64-pc-gnu-linux_includes.tar.bz2"
+BINUTILS="binutils-${BINUTILS_VERSION}.tar.gz"
+GCC="gcc-core-${GCC_VERSION}.tar.bz2"
+INCLUDES_SOURCE="http://download.decky.cz/"
+BINUTILS_SOURCE="ftp://ftp.gnu.org/gnu/binutils/"
+GCC_SOURCE="ftp://ftp.gnu.org/gnu/gcc/gcc-${GCC_VERSION}/"
+PLATFORM="ia64"
+WORKDIR=`pwd`
+TARGET="${PLATFORM}-pc-linux-gnu"
+HOST="i686-pc-linux-gnu"
+PREFIX="/usr/local/${PLATFORM}"
+INCLUDESDIR="${WORKDIR}/include"
+BINUTILSDIR="${WORKDIR}/binutils-${BINUTILS_VERSION}"
+GCCDIR="${WORKDIR}/gcc-${GCC_VERSION}"
+OBJDIR="${WORKDIR}/gcc-obj"
+echo ">>> Downloading tarballs"
+if [ ! -f "${INCLUDES}" ]; then
+    wget -c "${INCLUDES_SOURCE}${INCLUDES}"
+    check_error $? "Error downloading includes."
+fi
+if [ ! -f "${BINUTILS}" ]; then
+    wget -c "${BINUTILS_SOURCE}${BINUTILS}"
+    check_error $? "Error downloading binutils."
+fi
+if [ ! -f "${GCC}" ]; then
+    wget -c "${GCC_SOURCE}${GCC}"
+    check_error $? "Error downloading GCC."
+fi
+echo ">>> Creating destionation directory"
+if [ ! -d "${PREFIX}" ]; then
+    mkdir -p "${PREFIX}"
+    test -d "${PREFIX}"
+    check_error $? "Unable to create ${PREFIX}."
+fi
+echo ">>> Creating GCC work directory"
+if [ ! -d "${OBJDIR}" ]; then
+    mkdir -p "${OBJDIR}"
+    test -d "${OBJDIR}"
+    check_error $? "Unable to create ${OBJDIR}."
+fi
+echo ">>> Unpacking tarballs"
+tar -xvjf "${INCLUDES}"
+check_error $? "Error unpacking includes."
+tar -xvzf "${BINUTILS}"
+check_error $? "Error unpacking binutils."
+tar -xvjf "${GCC}"
+check_error $? "Error unpacking GCC."
+echo ">>> Compiling and installing binutils"
+cd "${BINUTILSDIR}"
+check_error $? "Change directory failed."
+./configure "--host=${HOST}" "--target=${TARGET}" "--prefix=${PREFIX}" "--disable-nls"
+check_error $? "Error configuring binutils."
+make all install
+check_error $? "Error compiling/installing binutils."
+echo ">>> Compiling and installing GCC"
+cd "${OBJDIR}"
+check_error $? "Change directory failed."
+"${GCCDIR}/configure" "--host=${HOST}" "--target=${TARGET}" "--prefix=${PREFIX}" "--program-prefix=${TARGET}-" --with-gnu-as --with-gnu-ld --disable-nls --disable-threads --enable-languages=c --disable-multilib --disable-libgcj "--with-headers=${INCLUDESDIR}" --disable-shared
+check_error $? "Error configuring GCC."
+PATH="${PATH}:${PREFIX}/bin" make all-gcc install-gcc
+check_error $? "Error compiling/installing GCC."
+echo
+echo ">>> Cross-compiler for ${TARGET} installed."
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /SPARTAN/trunk/contrib/toolchain.amd64.sh
 ,0 → 1,84
+#!/bin/bash
+# Cross-Compiler Toolchain for ${PLATFORM}
+#  by Martin Decky <martin@decky.cz>
+#
+#  GPL'ed, copyleft
+#
+check_error() {
+    if [ "$1" -ne "0" ]; then
+    echo
+    echo "Script failed: $2"
+    exit
+    fi
+}
+BINUTILS_VERSION="2.16"
+GCC_VERSION="4.0.1"
+BINUTILS="binutils-${BINUTILS_VERSION}.tar.gz"
+GCC="gcc-core-${GCC_VERSION}.tar.bz2"
+BINUTILS_SOURCE="ftp://ftp.gnu.org/gnu/binutils/"
+GCC_SOURCE="ftp://ftp.gnu.org/gnu/gcc/gcc-${GCC_VERSION}/"
+PLATFORM="amd64"
+WORKDIR=`pwd`
+TARGET="${PLATFORM}-linux-gnu"
+HOST="i686-pc-linux-gnu"
+PREFIX="/usr/local/${PLATFORM}"
+BINUTILSDIR="${WORKDIR}/binutils-${BINUTILS_VERSION}"
+GCCDIR="${WORKDIR}/gcc-${GCC_VERSION}"
+OBJDIR="${WORKDIR}/gcc-obj"
+echo ">>> Downloading tarballs"
+if [ ! -f "${BINUTILS}" ]; then
+    wget -c "${BINUTILS_SOURCE}${BINUTILS}"
+    check_error $? "Error downloading binutils."
+fi
+if [ ! -f "${GCC}" ]; then
+    wget -c "${GCC_SOURCE}${GCC}"
+    check_error $? "Error downloading GCC."
+fi
+echo ">>> Creating destionation directory"
+if [ ! -d "${PREFIX}" ]; then
+    mkdir -p "${PREFIX}"
+    test -d "${PREFIX}"
+    check_error $? "Unable to create ${PREFIX}."
+fi
+echo ">>> Creating GCC work directory"
+if [ ! -d "${OBJDIR}" ]; then
+    mkdir -p "${OBJDIR}"
+    test -d "${OBJDIR}"
+    check_error $? "Unable to create ${OBJDIR}."
+fi
+echo ">>> Unpacking tarballs"
+tar -xvzf "${BINUTILS}"
+check_error $? "Error unpacking binutils."
+tar -xvjf "${GCC}"
+check_error $? "Error unpacking GCC."
+echo ">>> Compiling and installing binutils"
+cd "${BINUTILSDIR}"
+check_error $? "Change directory failed."
+./configure "--host=${HOST}" "--target=${TARGET}" "--prefix=${PREFIX}" "--disable-nls"
+check_error $? "Error configuring binutils."
+make all install
+check_error $? "Error compiling/installing binutils."
+echo ">>> Compiling and installing GCC"
+cd "${OBJDIR}"
+check_error $? "Change directory failed."
+"${GCCDIR}/configure" "--host=${HOST}" "--target=${TARGET}" "--prefix=${PREFIX}" "--program-prefix=${TARGET}-" --with-gnu-as --with-gnu-ld --disable-nls --disable-threads --enable-languages=c --disable-multilib --disable-libgcj --without-headers --disable-shared
+check_error $? "Error configuring GCC."
+PATH="${PATH}:${PREFIX}/bin" make all-gcc install-gcc
+check_error $? "Error compiling/installing GCC."
+echo
+echo ">>> Cross-compiler for ${TARGET} installed."
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /SPARTAN/trunk/contrib/toolchain.ppc64.sh
 ,0 → 1,84
+#!/bin/bash
+# Cross-Compiler Toolchain for ${PLATFORM}
+#  by Martin Decky <martin@decky.cz>
+#
+#  GPL'ed, copyleft
+#
+check_error() {
+    if [ "$1" -ne "0" ]; then
+    echo
+    echo "Script failed: $2"
+    exit
+    fi
+}
+BINUTILS_VERSION="2.16"
+GCC_VERSION="4.0.1"
+BINUTILS="binutils-${BINUTILS_VERSION}.tar.gz"
+GCC="gcc-core-${GCC_VERSION}.tar.bz2"
+BINUTILS_SOURCE="ftp://ftp.gnu.org/gnu/binutils/"
+GCC_SOURCE="ftp://ftp.gnu.org/gnu/gcc/gcc-${GCC_VERSION}/"
+PLATFORM="ppc64"
+WORKDIR=`pwd`
+TARGET="${PLATFORM}-linux-gnu"
+HOST="i686-pc-linux-gnu"
+PREFIX="/usr/local/${PLATFORM}"
+BINUTILSDIR="${WORKDIR}/binutils-${BINUTILS_VERSION}"
+GCCDIR="${WORKDIR}/gcc-${GCC_VERSION}"
+OBJDIR="${WORKDIR}/gcc-obj"
+echo ">>> Downloading tarballs"
+if [ ! -f "${BINUTILS}" ]; then
+    wget -c "${BINUTILS_SOURCE}${BINUTILS}"
+    check_error $? "Error downloading binutils."
+fi
+if [ ! -f "${GCC}" ]; then
+    wget -c "${GCC_SOURCE}${GCC}"
+    check_error $? "Error downloading GCC."
+fi
+echo ">>> Creating destionation directory"
+if [ ! -d "${PREFIX}" ]; then
+    mkdir -p "${PREFIX}"
+    test -d "${PREFIX}"
+    check_error $? "Unable to create ${PREFIX}."
+fi
+echo ">>> Creating GCC work directory"
+if [ ! -d "${OBJDIR}" ]; then
+    mkdir -p "${OBJDIR}"
+    test -d "${OBJDIR}"
+    check_error $? "Unable to create ${OBJDIR}."
+fi
+echo ">>> Unpacking tarballs"
+tar -xvzf "${BINUTILS}"
+check_error $? "Error unpacking binutils."
+tar -xvjf "${GCC}"
+check_error $? "Error unpacking GCC."
+echo ">>> Compiling and installing binutils"
+cd "${BINUTILSDIR}"
+check_error $? "Change directory failed."
+./configure "--host=${HOST}" "--target=${TARGET}" "--prefix=${PREFIX}" "--disable-nls"
+check_error $? "Error configuring binutils."
+make all install
+check_error $? "Error compiling/installing binutils."
+echo ">>> Compiling and installing GCC"
+cd "${OBJDIR}"
+check_error $? "Change directory failed."
+"${GCCDIR}/configure" "--host=${HOST}" "--target=${TARGET}" "--prefix=${PREFIX}" "--program-prefix=${TARGET}-" --with-gnu-as --with-gnu-ld --disable-nls --disable-threads --enable-languages=c --disable-multilib --disable-libgcj --without-headers --disable-shared
+check_error $? "Error configuring GCC."
+PATH="${PATH}:${PREFIX}/bin" make all-gcc install-gcc
+check_error $? "Error compiling/installing GCC."
+echo
+echo ">>> Cross-compiler for ${TARGET} installed."
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /SPARTAN/trunk/contrib/toolchain.mips.sh
 ,0 → 1,84
+#!/bin/bash
+# Cross-Compiler Toolchain for ${PLATFORM}
+#  by Martin Decky <martin@decky.cz>
+#
+#  GPL'ed, copyleft
+#
+check_error() {
+    if [ "$1" -ne "0" ]; then
+    echo
+    echo "Script failed: $2"
+    exit
+    fi
+}
+BINUTILS_VERSION="2.16"
+GCC_VERSION="4.0.1"
+BINUTILS="binutils-${BINUTILS_VERSION}.tar.gz"
+GCC="gcc-core-${GCC_VERSION}.tar.bz2"
+BINUTILS_SOURCE="ftp://ftp.gnu.org/gnu/binutils/"
+GCC_SOURCE="ftp://ftp.gnu.org/gnu/gcc/gcc-${GCC_VERSION}/"
+PLATFORM="mipsel"
+WORKDIR=`pwd`
+TARGET="${PLATFORM}-linux-gnu"
+HOST="i686-pc-linux-gnu"
+PREFIX="/usr/local/${PLATFORM}"
+BINUTILSDIR="${WORKDIR}/binutils-${BINUTILS_VERSION}"
+GCCDIR="${WORKDIR}/gcc-${GCC_VERSION}"
+OBJDIR="${WORKDIR}/gcc-obj"
+echo ">>> Downloading tarballs"
+if [ ! -f "${BINUTILS}" ]; then
+    wget -c "${BINUTILS_SOURCE}${BINUTILS}"
+    check_error $? "Error downloading binutils."
+fi
+if [ ! -f "${GCC}" ]; then
+    wget -c "${GCC_SOURCE}${GCC}"
+    check_error $? "Error downloading GCC."
+fi
+echo ">>> Creating destionation directory"
+if [ ! -d "${PREFIX}" ]; then
+    mkdir -p "${PREFIX}"
+    test -d "${PREFIX}"
+    check_error $? "Unable to create ${PREFIX}."
+fi
+echo ">>> Creating GCC work directory"
+if [ ! -d "${OBJDIR}" ]; then
+    mkdir -p "${OBJDIR}"
+    test -d "${OBJDIR}"
+    check_error $? "Unable to create ${OBJDIR}."
+fi
+echo ">>> Unpacking tarballs"
+tar -xvzf "${BINUTILS}"
+check_error $? "Error unpacking binutils."
+tar -xvjf "${GCC}"
+check_error $? "Error unpacking GCC."
+echo ">>> Compiling and installing binutils"
+cd "${BINUTILSDIR}"
+check_error $? "Change directory failed."
+./configure "--host=${HOST}" "--target=${TARGET}" "--prefix=${PREFIX}" "--disable-nls"
+check_error $? "Error configuring binutils."
+make all install
+check_error $? "Error compiling/installing binutils."
+echo ">>> Compiling and installing GCC"
+cd "${OBJDIR}"
+check_error $? "Change directory failed."
+"${GCCDIR}/configure" "--host=${HOST}" "--target=${TARGET}" "--prefix=${PREFIX}" "--program-prefix=${TARGET}-" --with-gnu-as --with-gnu-ld --disable-nls --disable-threads --enable-languages=c --disable-multilib --disable-libgcj --without-headers --disable-shared
+check_error $? "Error configuring GCC."
+PATH="${PATH}:${PREFIX}/bin" make all-gcc install-gcc
+check_error $? "Error compiling/installing GCC."
+echo
+echo ">>> Cross-compiler for ${TARGET} installed."
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /SPARTAN/trunk/doc/TODO
 ,0 → 1,28
++ implement true memory barriers for all architectures
++ implement true memory management
+  + [ia32] use int 0x15 ax=0xe820 to get memory map and memory size [DONE]
+  + [mips] use some heuristics to get memory map and memory size
+  + reimplement heap so that it can allocate/deallocate
+    itself frames as necessary
+  + provide native four-level portable page table interface     [DONE]
+    + every architecture uses its native page table format
+    + kernel provides unified four-level page table interface
+      for all architectures
+  + track usage of frames containing middle-level page tables
+    (frame leak)
++ get user mode support for all architectures
++ save/restore floating point context on context switch
+  + [ia32] lazy context switch using TS flag                            [DONE]
++ [ia32] MMX,SSE1-.. initialization
++ [ia32] review privilege separation                                    [DONE]
+  + zero IOPL in EFLAGS                                                 [DONE]
+  + before IRET (from SYSCALL), zero NT in EFLAGS                       [DONE]
++ [ia32] review the cache controling bits in CR0 register
++ [ia32] zero the alignment exception bit in EFLAGS                     [DONE]
+  - Task changed to clear AM in CR0 so that
+    the alignment check is disabled globally
++ make emulated architectures also work on real hardware
++ bring in support for other architectures (e.g. PowerPC)

 /SPARTAN/trunk/doc/requirements
 ,0 → 1,49
+ia32 port
+=========
+    HARDWARE REQUIREMENTS
+    o IA-32 processor (Pentium and successors)
+    COMPILER REQUIREMENTS
+    o binutils 2.15 and gcc 3.3.5
+    o older versions may do as well, but are now obsoleted
+    SMP COMPATIBILITY
+    o Bochs 2.0.2 - Bochs 2.2
+        o 2x-8x 686 CPU
+    o Simics 2.0.28 - Simics 2.2.14
+        o 2x-4x Pentium 4 CPU
+    o ASUS P/I-P65UP5 + ASUS C-P55T2D REV. 1.41
+        o 2x 200Mhz Pentium CPU
+    EMULATORS AND VIRTUALIZERS
+    o Bochs 2.0.2 - Bochs 2.2
+    o VMware Workstation 4, VMware Workstation 5
+mips port
+=========
+    HARDWARE REQUIREMENTS
+    o no real hardware supported
+    o msim emulated MIPS R4000 CPU (see mips)
+    COMPILER REQUIREMENTS
+    o mips binutils 2.16 and gcc 4.0.1 cross compiler
+    o older versions may do as well, but are now obsoleted
+    EMULATORS AND VIRTUALIZERS
+    o msim
+ia64 port
+=========
+    HARDWARE REQUIREMENTS
+    o no real hardware supported
+    EMULATORS AND VIRTUALIZERS
+    o ski
+    COMPILER REQUIREMENTS
+    o IA-64 binutils 2.15 and gcc 4.0.0 cross compiler
+    o older versions may do as well, but are now obsoleted

/SPARTAN/trunk/doc/AUTHORS
0,0 → 1,6
Jakub Jermar <jermar@itbs.cz>
Jakub Vana <jakub.vana@gmail.com>
Martin Decky <martin@decky.cz>
Josef Cejka <malyzelenyhnus@seznam.cz>
Sergey Bondari <bondari@itbs.cz>
Ondrej Palkovsky <ondrap@penguin.cz>

 /SPARTAN/trunk/doc/mm
 ,0 → 1,52
+Memory management
+=================
+SPARTAN kernel deploys generic interface for 4-level page tables,
+no matter what the real underlying hardware architecture is.
+ VADDR
+ +-----------------------------------------------------------------------------+
+ |   PTL0_INDEX  |   PTL1_INDEX   |   PTL2_INDEX   |   PTL3_INDEX   |   OFFSET |
+ +-----------------------------------------------------------------------------+
+ PTL0                   PTL1                   PTL2                   PTL3
+ +--------+             +--------+             +--------+             +--------+
+ |        |             |        |             |  PTL3  | -----\      |        |
+ |        |             |        |             +--------+      |      |        |
+ |        |             +--------+             |        |      |      |        |
+ |        |             |  PTL2  | -----\      |        |      |      |        |
+ |        |             +--------+      |      |        |      |      |        |
+ |        |             |        |      |      |        |      |      +--------+
+ +--------+             |        |      |      |        |      |      | FRAME  |
+ |  PTL1  | -----\      |        |      |      |        |      |      +--------+
+ +--------+      |      |        |      |      |        |      |      |        |
+ |        |      |      |        |      |      |        |      |      |        |
+ |        |      |      |        |      |      |        |      |      |        |
+ +--------+      \----> +--------+      \----> +--------+      \----> +--------+
+     ^
+     |
+     |
+ +--------+
+ |  PTL0  |
+ +--------+
+PTL0        Page Table Level 0 (Page Directory)
+PTL1        Page Table Level 1
+PTL2        Page Table Level 2
+PTL3        Page Table Level 3
+PTL0_INDEX  Index into PTL0
+PTL1_INDEX  Index into PTL1
+PTL2_INDEX  Index into PTL2
+PTL3_INDEX  Index into PTL3
+VADDR       Virtual address for which mapping is looked up
+FRAME       Physical address of memory frame to which VADDR is mapped
+On architectures whose hardware has fewer levels, PTL2 and, if need be, PTL1 are
+left out. TLB-only architectures are to define custom format for software page
+tables.

 /SPARTAN/trunk/doc/arch/mips
 ,0 → 1,37
+SPARTAN kernel currently supports emulated MIPS R4000 32-bit
+little-endian architecture. In other words, it can only run in MIPS
+R4000 emulator called msim. This emulator is being developed by Viliam
+Holub:
+http://nenya.ms.mff.cuni.cz/~holub/msim
+Note that msim diverges from real MIPS hardware in some aspects.
+Therefore, some non-trivial changes will be necessary for a real
+hardware port. The simulator is described in this manual:
+http://nenya.ms.mff.cuni.cz/~holub/msim/msim.ps
+You'll need a msim.conf script like this:
+    #
+    # MSIM configuration script
+    #
+    add dcpu mips1
+    add rwm     mainmem     0               16M load "kernel.bin"
+    add rom     startmem        0x1fc00000  1k      load "load.bin"
+    add dprinter    printer         0x10000000
+BOOTSTRAP
+=========
+Because the mips port uses binary executable format and for some other
+architectural reasons, it shares one address for bootstrap entry
+(address where control is passed from loader) and for TLB refill
+exception entry. The former is used only once during system bootstrap.
+From that point further, only TLB refill exception entry uses that
+address. Note that this is the reason why main_bsp() is called from
+tlb_refill() code.

 /SPARTAN/trunk/doc/arch/ia64
 ,0 → 1,14
+SPARTAN kernel now features early IA-64 support.
+To run SPARTAN on IA-64, you must use the
+HP Ski simulator. It can be downloaded from here:
+http://www.hpl.hp.com/research/linux/ski/
+Use init skript like this to run the kernel:
+-----8<------
+load kernel.bin
+load load.bin
+----->8------

 /SPARTAN/trunk/doc/synchronization
 ,0 → 1,29
+                                 SPINNING LOCKS
+                spinlock_lock, spinlock_trylock, spinlock_unlock
+                                 +------------+
+                                 | spinlock_t |
+                                 +------------+
+                                   WAIT QUEUES
+                         waitq_sleep_timeout, waitq_wakeup
+                                   +---------+
+                                   | waitq_t |
+                       +---------+
+                  /           \
+               SEMAPHORES        /             \  CONDITION VARIABLES
+ semaphore_down_timeout, semaphore_up    condvar_wait_timeout, condvar_signal
+            +--------------+   /                 \   +-----------+
+            | semaphore_t  |<-+                   +->| condvar_t |
+            +--------------+                         +-----------+
+                   |                                       ^
+           |                                       |
+                   |                                +------+
+                   V                               /
+                MUTEXES                           / READERS/WRITERS LOCKS
+    mutex_lock_timeout, mutex_unlock   rwlock_reader/writer_lock_timeout, rwlock_unlock
+              +---------+                       /        +----------+
+          | mutex_t |------------------------------->| rwlock_t |
+          +---------+                     /          +----------+
+               |                         /
+           +------------------------+

 /SPARTAN/trunk/doc/preemption
 ,0 → 1,58
+Kernel makes it possible for a thread to be preempted anytime when
+IRQ's are enabled on local CPU. This arrangement triggers a discussion
+about its correctness and efficiency.
+The correctness issue relates to the possibility of preempting a
+thread holding a spinlock. It is natural to ask whether such a
+preemption can lead to a deadlock. By proving the following lemma, we
+will show that deadlock is actually not possible.
+Lemma:
+  On condition that each spinning lock is always locked on the same
+  CPU priority level (either always with IRQ's disabled or always
+  with IRQ's enabled), otherwise correct code never deadlocks.
+Proof:
+  Let all assumptions from the lemma hold.
+  Let us further assume that we have encountered a deadlock.
+  We will analyse all likely ways how that could have happened.
+  a)  Deadlock happened between two CPUs. This means that there must
+  have been wrong lock-ordering. Code with lock-ordering problems is
+  considered incorrect and contradicts our assumptions.
+  b)  Deadlock happened between two threads of execution executing on
+  the same CPU.
+  b1) If one thread of execution was servicing an interrupt and the
+  other was executing in thread context, our assumption that each
+  spinning lock is acquired always on the same CPU priority level is
+  violated.
+  b2) The last likely scenario is that the deadlock happened between
+  two threads executing on the same CPU with IRQ's enabled.  Again,
+  this means that we were working with incorrect code because it
+  contained wrong ordering of lock operations.
+  Since there is no possibility left, except for trivial errors, we
+  have shown that the deadlock contradicts with our assumptions and
+  therefore is not possible.
+  Q.E.D.
+Notes on the proof:
+  ad a)  Deadlock between two CPUs is independent on the preemption
+         model. If we have this kind of deadlock, we would have had
+     the same kind of deadlock on an ordinary SMP system with
+     kernel preemption disabled.
+     This preemption model makes UP behave more like SMP because
+     it introduces some SMP specific specialities.
+  ad b2) Notice that the scenario when thread A acquires lock X and
+     gets preempted in favor of thread B which is trying to
+     acquire lock X, doesn't deadlock the two threads. Of course,
+     B won't be allowed to get X until A releases it, but that
+     will certainly happen because B too will sooner or later be
+     preempted. This scenario emphasizes the efficiency issues,
+     though.

 /SPARTAN/trunk/test/fpu/fpu1/test.c
 ,0 → 1,133
+/*
+ * Copyright (C) 2005 Jakub Vana
+ * Copyright (C) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <print.h>
+#include <debug.h>
+#include <panic.h>
+#include <test.h>
+#include <arch/atomic.h>
+#include <proc/thread.h>
+#include <arch.h>
+#define THREADS     150*2
+#define ATTEMPTS    10
+#define E_10e8  271828182
+#define PI_10e8 314159265
+static inline double sqrt(double x) { double v; __asm__ ("fsqrt\n" : "=t" (v) : "0" (x)); return v; }
+static volatile int threads_ok;
+static waitq_t can_start;
+static void e(void *data)
+{
+    int i;
+    double e,d,le,f;
+    waitq_sleep(&can_start);
+    for (i = 0; i<ATTEMPTS; i++) {
+        le=-1;
+        e=0;
+        f=1;
+        for(d=1;e!=le;d*=f,f+=1) {
+            le=e;
+            e=e+1/d;
+        }
+        if((int)(100000000*e)!=E_10e8)
+            panic("tid%d: e*10e8=%d\n", THREAD->tid, (int) 100000000*e);
+    }
+    atomic_inc(&threads_ok);
+}
+static void pi(void *data)
+{
+    int i;
+    double lpi, pi;
+    double n, ab, ad;
+    waitq_sleep(&can_start);
+    for (i = 0; i<ATTEMPTS; i++) {
+        lpi = -1;
+        pi = 0;
+        for (n=2, ab = sqrt(2); lpi != pi; n *= 2, ab = ad) {
+            double sc, cd;
+            sc = sqrt(1 - (ab*ab/4));
+            cd = 1 - sc;
+            ad = sqrt(ab*ab/4 + cd*cd);
+            lpi = pi;
+            pi = 2 * n * ad;
+        }
+        if((int)(100000000*pi)!=PI_10e8)
+            panic("tid%d: pi*10e8=%d\n", THREAD->tid, (int) 100000000*pi);
+    }
+    atomic_inc(&threads_ok);
+}
+void test(void)
+{
+    thread_t *t;
+    int i;
+    waitq_initialize(&can_start);
+    printf("FPU test #1\n");
+    printf("Creating %d threads... ", THREADS);
+    for (i=0; i<THREADS/2; i++) {
+        if (!(t = thread_create(e, NULL, TASK, 0)))
+            panic("could not create thread\n");
+        thread_ready(t);
+        if (!(t = thread_create(pi, NULL, TASK, 0)))
+            panic("could not create thread\n");
+        thread_ready(t);
+    }
+    printf("ok\n");
+    thread_sleep(1);
+    waitq_wakeup(&can_start, WAKEUP_ALL);
+    while (threads_ok != THREADS)
+        ;
+    printf("Test passed.\n");
+}

 /SPARTAN/trunk/test/synch/semaphore1/test.c
 ,0 → 1,128
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <test.h>
+#include <arch.h>
+#include <arch/atomic.h>
+#include <print.h>
+#include <proc/thread.h>
+#include <synch/waitq.h>
+#include <synch/semaphore.h>
+#define AT_ONCE         3
+#define PRODUCERS       50
+#define CONSUMERS       50
+static semaphore_t sem;
+static waitq_t can_start;
+static volatile int items_produced;
+static volatile int items_consumed;
+static void consumer(void *arg);
+static void producer(void *arg);
+static void failed(void);
+void producer(void *arg)
+{
+    waitq_sleep(&can_start);
+    semaphore_down(&sem);
+    atomic_inc(&items_produced);
+    thread_usleep(250);
+    semaphore_up(&sem);
+}
+void consumer(void *arg)
+{
+    waitq_sleep(&can_start);
+    semaphore_down(&sem);
+    atomic_inc(&items_consumed);
+    thread_usleep(500);
+    semaphore_up(&sem);
+}
+void failed(void)
+{
+    printf("Test failed prematurely.\n");
+    thread_exit();
+}
+void test(void)
+{
+    int i, j, k;
+    int consumers, producers;
+    printf("Semaphore test #1\n");
+    waitq_initialize(&can_start);
+    semaphore_initialize(&sem, AT_ONCE);
+    for (i=1; i<=3; i++) {
+        thread_t *thrd;
+        items_produced = 0;
+        items_consumed = 0;
+        consumers = i * CONSUMERS;
+        producers = (4-i) * PRODUCERS;
+        printf("Creating %d consumers and %d producers...", consumers, producers);
+        for (j=0; j<(CONSUMERS+PRODUCERS)/2; j++) {
+            for (k=0; k<i; k++) {
+                thrd = thread_create(consumer, NULL, TASK, 0);
+                if (thrd)
+                    thread_ready(thrd);
+                else
+                    failed();
+            }
+            for (k=0; k<(4-i); k++) {
+                thrd = thread_create(producer, NULL, TASK, 0);
+                if (thrd)
+                    thread_ready(thrd);
+                else
+                    failed();
+            }
+        }
+        printf("ok\n");
+        thread_sleep(1);
+        waitq_wakeup(&can_start, WAKEUP_ALL);
+        while (items_consumed != consumers || items_produced != producers) {
+            printf("%d consumers remaining, %d producers remaining\n", consumers - items_consumed, producers - items_produced);
+            thread_sleep(1);
+        }
+    }
+    printf("Test passed.\n");
+}

 /SPARTAN/trunk/test/synch/rwlock5/test.c
 ,0 → 1,124
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <test.h>
+#include <arch.h>
+#include <arch/atomic.h>
+#include <print.h>
+#include <proc/thread.h>
+#include <synch/waitq.h>
+#include <synch/rwlock.h>
+#define READERS     50
+#define WRITERS     50
+static rwlock_t rwlock;
+static waitq_t can_start;
+static volatile int items_read;
+static volatile int items_written;
+static void writer(void *arg);
+static void reader(void *arg);
+static void failed(void);
+void writer(void *arg)
+{
+    waitq_sleep(&can_start);
+    rwlock_write_lock(&rwlock);
+    atomic_inc(&items_written);
+    rwlock_write_unlock(&rwlock);
+}
+void reader(void *arg)
+{
+    waitq_sleep(&can_start);
+    rwlock_read_lock(&rwlock);
+    atomic_inc(&items_read);
+    rwlock_read_unlock(&rwlock);
+}
+void failed(void)
+{
+    printf("Test failed prematurely.\n");
+    thread_exit();
+}
+void test(void)
+{
+    int i, j, k;
+    int readers, writers;
+    printf("Read/write locks test #5\n");
+    waitq_initialize(&can_start);
+    rwlock_initialize(&rwlock);
+    for (i=1; i<=3; i++) {
+        thread_t *thrd;
+        items_read = 0;
+        items_written = 0;
+        readers = i*READERS;
+        writers = (4-i)*WRITERS;
+        printf("Creating %d readers and %d writers...", readers, writers);
+        for (j=0; j<(READERS+WRITERS)/2; j++) {
+            for (k=0; k<i; k++) {
+                thrd = thread_create(reader, NULL, TASK, 0);
+                if (thrd)
+                    thread_ready(thrd);
+                else
+                    failed();
+            }
+            for (k=0; k<(4-i); k++) {
+                thrd = thread_create(writer, NULL, TASK, 0);
+                if (thrd)
+                    thread_ready(thrd);
+                else
+                    failed();
+            }
+        }
+        printf("ok\n");
+        thread_sleep(1);
+        waitq_wakeup(&can_start, WAKEUP_ALL);
+        while (items_read != readers || items_written != writers) {
+            printf("%d readers remaining, %d writers remaining, readers_in=%d\n", readers - items_read, writers - items_written, rwlock.readers_in);
+            thread_usleep(100000);
+        }
+    }
+    printf("Test passed.\n");
+}

 /SPARTAN/trunk/test/synch/rwlock1/test.c
 ,0 → 1,78
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <test.h>
+#include <arch.h>
+#include <arch/atomic.h>
+#include <print.h>
+#include <proc/thread.h>
+#include <synch/waitq.h>
+#include <synch/rwlock.h>
+#define READERS     50
+#define WRITERS     50
+static rwlock_t rwlock;
+void test(void)
+{
+    printf("Read/write locks test #1\n");
+    rwlock_initialize(&rwlock);
+    rwlock_write_lock(&rwlock);
+    rwlock_write_unlock(&rwlock);
+    rwlock_read_lock(&rwlock);
+    rwlock_read_lock(&rwlock);
+    rwlock_read_lock(&rwlock);
+    rwlock_read_lock(&rwlock);
+    rwlock_read_lock(&rwlock);
+    rwlock_read_unlock(&rwlock);
+    rwlock_read_unlock(&rwlock);
+    rwlock_read_unlock(&rwlock);
+    rwlock_read_unlock(&rwlock);
+    rwlock_read_unlock(&rwlock);
+    rwlock_write_lock(&rwlock);
+    rwlock_write_unlock(&rwlock);
+    rwlock_read_lock(&rwlock);
+    rwlock_read_unlock(&rwlock);
+    rwlock_write_lock(&rwlock);
+    rwlock_write_unlock(&rwlock);
+    rwlock_read_lock(&rwlock);
+    rwlock_read_unlock(&rwlock);
+    printf("Test passed.\n");
+}

 /SPARTAN/trunk/test/synch/rwlock2/test.c
 ,0 → 1,91
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <test.h>
+#include <arch.h>
+#include <arch/atomic.h>
+#include <print.h>
+#include <proc/thread.h>
+#include <synch/rwlock.h>
+#define READERS     50
+#define WRITERS     50
+static rwlock_t rwlock;
+static void writer(void *arg);
+static void failed(void *arg);
+void writer(void *arg)
+{
+    printf("Trying to lock rwlock for writing....\n");
+    rwlock_write_lock(&rwlock);
+    rwlock_write_unlock(&rwlock);
+    printf("Trying to lock rwlock for reading....\n");
+    rwlock_read_lock(&rwlock);
+    rwlock_read_unlock(&rwlock);
+    printf("Test passed.\n");
+}
+void failed(void)
+{
+    printf("Test failed prematurely.\n");
+    thread_exit();
+}
+void test(void)
+{
+    thread_t *thrd;
+    printf("Read/write locks test #2\n");
+    rwlock_initialize(&rwlock);
+    rwlock_read_lock(&rwlock);
+    rwlock_read_lock(&rwlock);
+    rwlock_read_lock(&rwlock);
+    rwlock_read_lock(&rwlock);
+    thrd = thread_create(writer, NULL, TASK, 0);
+    if (thrd)
+        thread_ready(thrd);
+    else
+        failed();
+    thread_sleep(1);
+    rwlock_read_unlock(&rwlock);
+    rwlock_read_unlock(&rwlock);
+    rwlock_read_unlock(&rwlock);
+    rwlock_read_unlock(&rwlock);
+}

 /SPARTAN/trunk/test/synch/rwlock3/test.c
 ,0 → 1,91
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <test.h>
+#include <arch.h>
+#include <arch/atomic.h>
+#include <print.h>
+#include <proc/thread.h>
+#include <synch/rwlock.h>
+#define READERS     50
+#define WRITERS     50
+static rwlock_t rwlock;
+static void reader(void *arg);
+static void failed(void *arg);
+void reader(void *arg)
+{
+    printf("cpu%d, tid %d: trying to lock rwlock for reading....\n", CPU->id, THREAD->tid);
+    rwlock_read_lock(&rwlock);
+    rwlock_read_unlock(&rwlock);
+    printf("cpu%d, tid %d: success\n", CPU->id, THREAD->tid);
+    printf("cpu%d, tid %d: trying to lock rwlock for writing....\n", CPU->id, THREAD->tid);
+    rwlock_write_lock(&rwlock);
+    rwlock_write_unlock(&rwlock);
+    printf("cpu%d, tid %d: success\n", CPU->id, THREAD->tid);
+    printf("Test passed.\n");
+}
+void failed(void)
+{
+    printf("Test failed prematurely.\n");
+    thread_exit();
+}
+void test(void)
+{
+    int i;
+    thread_t *thrd;
+    printf("Read/write locks test #2\n");
+    rwlock_initialize(&rwlock);
+    rwlock_write_lock(&rwlock);
+    for (i=0; i<4; i++) {
+        thrd = thread_create(reader, NULL, TASK, 0);
+        if (thrd)
+            thread_ready(thrd);
+        else
+            failed();
+    }
+    thread_sleep(1);
+    rwlock_write_unlock(&rwlock);
+}

 /SPARTAN/trunk/test/synch/rwlock4/test.c
 ,0 → 1,159
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <test.h>
+#include <arch.h>
+#include <arch/atomic.h>
+#include <print.h>
+#include <proc/thread.h>
+#include <arch/types.h>
+#include <arch/context.h>
+#include <panic.h>
+#include <synch/waitq.h>
+#include <synch/rwlock.h>
+#include <synch/synch.h>
+#define READERS     50
+#define WRITERS     50
+static rwlock_t rwlock;
+static spinlock_t lock;
+static waitq_t can_start;
+__u32 seed = 0xdeadbeaf;
+static __u32 random(__u32 max);
+static void writer(void *arg);
+static void reader(void *arg);
+static void failed(void);
+__u32 random(__u32 max)
+{
+    __u32 rc;
+    spinlock_lock(&lock);
+    rc = seed % max;
+    seed = (((seed<<2) ^ (seed>>2)) * 487) + rc;
+    spinlock_unlock(&lock);
+    return rc;
+}
+void writer(void *arg)
+{
+    int rc, to;
+    waitq_sleep(&can_start);
+    to = random(40000);
+    printf("cpu%d, tid %d w+ (%d)\n", CPU->id, THREAD->tid, to);
+    rc = rwlock_write_lock_timeout(&rwlock, to);
+    if (SYNCH_FAILED(rc)) {
+        printf("cpu%d, tid %d w!\n", CPU->id, THREAD->tid);
+        return;
+    };
+    printf("cpu%d, tid %d w=\n", CPU->id, THREAD->tid);
+    if (rwlock.readers_in) panic("Oops.");
+    thread_usleep(random(1000000));
+    if (rwlock.readers_in) panic("Oops.");
+    rwlock_write_unlock(&rwlock);
+    printf("cpu%d, tid %d w-\n", CPU->id, THREAD->tid);
+}
+void reader(void *arg)
+{
+    int rc, to;
+    waitq_sleep(&can_start);
+    to = random(2000);
+    printf("cpu%d, tid %d r+ (%d)\n", CPU->id, THREAD->tid, to);
+    rc = rwlock_read_lock_timeout(&rwlock, to);
+    if (SYNCH_FAILED(rc)) {
+        printf("cpu%d, tid %d r!\n", CPU->id, THREAD->tid);
+        return;
+    }
+    printf("cpu%d, tid %d r=\n", CPU->id, THREAD->tid);
+    thread_usleep(30000);
+    rwlock_read_unlock(&rwlock);
+    printf("cpu%d, tid %d r-\n", CPU->id, THREAD->tid);
+}
+void failed(void)
+{
+    printf("Test failed prematurely.\n");
+    thread_exit();
+}
+void test(void)
+{
+    context_t ctx;
+    __u32 i, k;
+    printf("Read/write locks test #4\n");
+    waitq_initialize(&can_start);
+    rwlock_initialize(&rwlock);
+    for (; ;) {
+        thread_t *thrd;
+        context_save(&ctx);
+        printf("sp=%X, readers_in=%d\n", ctx.sp, rwlock.readers_in);
+        k = random(7) + 1;
+        printf("Creating %d readers\n", k);
+        for (i=0; i<k; i++) {
+            thrd = thread_create(reader, NULL, TASK, 0);
+            if (thrd)
+                thread_ready(thrd);
+            else
+                failed();
+        }
+        k = random(5) + 1;
+        printf("Creating %d writers\n", k);
+        for (i=0; i<k; i++) {
+            thrd = thread_create(writer, NULL, TASK, 0);
+            if (thrd)
+                thread_ready(thrd);
+            else
+                failed();
+        }
+        thread_usleep(20000);
+        waitq_wakeup(&can_start, WAKEUP_ALL);
+    }
+}

 /SPARTAN/trunk/test/synch/semaphore2/test.c
 ,0 → 1,121
+/*
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <test.h>
+#include <arch.h>
+#include <arch/atomic.h>
+#include <print.h>
+#include <proc/thread.h>
+#include <arch/types.h>
+#include <arch/context.h>
+#include <synch/waitq.h>
+#include <synch/semaphore.h>
+#include <synch/synch.h>
+static semaphore_t sem;
+static spinlock_t lock;
+static waitq_t can_start;
+__u32 seed = 0xdeadbeaf;
+static __u32 random(__u32 max);
+static void consumer(void *arg);
+static void failed(void);
+__u32 random(__u32 max)
+{
+    __u32 rc;
+    spinlock_lock(&lock);
+    rc = seed % max;
+    seed = (((seed<<2) ^ (seed>>2)) * 487) + rc;
+    spinlock_unlock(&lock);
+    return rc;
+}
+void consumer(void *arg)
+{
+    int rc, to;
+    waitq_sleep(&can_start);
+    to = random(20000);
+    printf("cpu%d, tid %d down+ (%d)\n", CPU->id, THREAD->tid, to);
+    rc = semaphore_down_timeout(&sem, to);
+    if (SYNCH_FAILED(rc)) {
+        printf("cpu%d, tid %d down!\n", CPU->id, THREAD->tid);
+        return;
+    }
+    printf("cpu%d, tid %d down=\n", CPU->id, THREAD->tid);
+    thread_usleep(random(30000));
+    semaphore_up(&sem);
+    printf("cpu%d, tid %d up\n", CPU->id, THREAD->tid);
+}
+void failed(void)
+{
+    printf("Test failed prematurely.\n");
+    thread_exit();
+}
+void test(void)
+{
+    context_t ctx;
+    __u32 i, k;
+    printf("Semaphore test #2\n");
+    waitq_initialize(&can_start);
+    semaphore_initialize(&sem, 5);
+    for (; ;) {
+        thread_t *thrd;
+        k = random(7) + 1;
+        printf("Creating %d consumers\n", k);
+        for (i=0; i<k; i++) {
+            thrd = thread_create(consumer, NULL, TASK, 0);
+            if (thrd)
+                thread_ready(thrd);
+            else
+                failed();
+        }
+        thread_usleep(20000);
+        waitq_wakeup(&can_start, WAKEUP_ALL);
+    }
+}

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev HEAD → Rev 168