| /tags/0.4.0/boot/arch/sparc64/loader/main.c |
|---|
| 0,0 → 1,278 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * Copyright (c) 2006 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.h" |
| #include <printf.h> |
| #include "asm.h" |
| #include "_components.h" |
| #include <balloc.h> |
| #include <ofw.h> |
| #include <ofw_tree.h> |
| #include "ofwarch.h" |
| #include <align.h> |
| #include <string.h> |
| bootinfo_t bootinfo; |
| component_t components[COMPONENTS]; |
| char *release = RELEASE; |
| #ifdef REVISION |
| char *revision = ", revision " REVISION; |
| #else |
| char *revision = ""; |
| #endif |
| #ifdef TIMESTAMP |
| char *timestamp = "\nBuilt on " TIMESTAMP; |
| #else |
| char *timestamp = ""; |
| #endif |
| /** UltraSPARC subarchitecture - 1 for US, 3 for US3 */ |
| uint8_t subarchitecture; |
| /** |
| * mask of the MID field inside the ICBUS_CONFIG register shifted by |
| * MID_SHIFT bits to the right |
| */ |
| uint16_t mid_mask; |
| /** Print version information. */ |
| static void version_print(void) |
| { |
| printf("HelenOS SPARC64 Bootloader\nRelease %s%s%s\n" |
| "Copyright (c) 2006 HelenOS project\n", |
| release, revision, timestamp); |
| } |
| /* the lowest ID (read from the VER register) of some US3 CPU model */ |
| #define FIRST_US3_CPU 0x14 |
| /* the greatest ID (read from the VER register) of some US3 CPU model */ |
| #define LAST_US3_CPU 0x19 |
| /* UltraSPARC IIIi processor implementation code */ |
| #define US_IIIi_CODE 0x15 |
| /** |
| * Sets the global variables "subarchitecture" and "mid_mask" to |
| * correct values. |
| */ |
| static void detect_subarchitecture(void) |
| { |
| uint64_t v; |
| asm volatile ("rdpr %%ver, %0\n" : "=r" (v)); |
| v = (v << 16) >> 48; |
| if ((v >= FIRST_US3_CPU) && (v <= LAST_US3_CPU)) { |
| subarchitecture = SUBARCH_US3; |
| if (v == US_IIIi_CODE) |
| mid_mask = (1 << 5) - 1; |
| else |
| mid_mask = (1 << 10) - 1; |
| } else if (v < FIRST_US3_CPU) { |
| subarchitecture = SUBARCH_US; |
| mid_mask = (1 << 5) - 1; |
| } else { |
| printf("\nThis CPU is not supported by HelenOS."); |
| } |
| } |
| void bootstrap(void) |
| { |
| void *base = (void *) KERNEL_VIRTUAL_ADDRESS; |
| void *balloc_base; |
| unsigned int top = 0; |
| int i, j; |
| version_print(); |
| detect_subarchitecture(); |
| init_components(components); |
| if (!ofw_get_physmem_start(&bootinfo.physmem_start)) { |
| printf("Error: unable to get start of physical memory.\n"); |
| halt(); |
| } |
| if (!ofw_memmap(&bootinfo.memmap)) { |
| printf("Error: unable to get memory map, halting.\n"); |
| halt(); |
| } |
| if (bootinfo.memmap.total == 0) { |
| printf("Error: no memory detected, halting.\n"); |
| halt(); |
| } |
| /* |
| * SILO for some reason adds 0x400000 and subtracts |
| * bootinfo.physmem_start to/from silo_ramdisk_image. |
| * We just need plain physical address so we fix it up. |
| */ |
| if (silo_ramdisk_image) { |
| silo_ramdisk_image += bootinfo.physmem_start; |
| silo_ramdisk_image -= 0x400000; |
| /* Install 1:1 mapping for the ramdisk. */ |
| if (ofw_map((void *)((uintptr_t) silo_ramdisk_image), |
| (void *)((uintptr_t) silo_ramdisk_image), |
| silo_ramdisk_size, -1) != 0) { |
| printf("Failed to map ramdisk.\n"); |
| halt(); |
| } |
| } |
| printf("\nSystem info\n"); |
| printf(" memory: %dM starting at %P\n", |
| bootinfo.memmap.total >> 20, bootinfo.physmem_start); |
| printf("\nMemory statistics\n"); |
| printf(" kernel entry point at %P\n", KERNEL_VIRTUAL_ADDRESS); |
| printf(" %P: boot info structure\n", &bootinfo); |
| /* |
| * Figure out destination address for each component. |
| * In this phase, we don't copy the components yet because we want to |
| * to be careful not to overwrite anything, especially the components |
| * which haven't been copied yet. |
| */ |
| bootinfo.taskmap.count = 0; |
| for (i = 0; i < COMPONENTS; i++) { |
| printf(" %P: %s image (size %d bytes)\n", components[i].start, |
| components[i].name, components[i].size); |
| top = ALIGN_UP(top, PAGE_SIZE); |
| if (i > 0) { |
| if (bootinfo.taskmap.count == TASKMAP_MAX_RECORDS) { |
| printf("Skipping superfluous components.\n"); |
| break; |
| } |
| bootinfo.taskmap.tasks[bootinfo.taskmap.count].addr = |
| base + top; |
| bootinfo.taskmap.tasks[bootinfo.taskmap.count].size = |
| components[i].size; |
| bootinfo.taskmap.count++; |
| } |
| top += components[i].size; |
| } |
| j = bootinfo.taskmap.count - 1; /* do not consider ramdisk */ |
| if (silo_ramdisk_image) { |
| /* Treat the ramdisk as the last bootinfo task. */ |
| if (bootinfo.taskmap.count == TASKMAP_MAX_RECORDS) { |
| printf("Skipping ramdisk.\n"); |
| goto skip_ramdisk; |
| } |
| top = ALIGN_UP(top, PAGE_SIZE); |
| bootinfo.taskmap.tasks[bootinfo.taskmap.count].addr = |
| base + top; |
| bootinfo.taskmap.tasks[bootinfo.taskmap.count].size = |
| silo_ramdisk_size; |
| bootinfo.taskmap.count++; |
| printf("\nCopying ramdisk..."); |
| /* |
| * Claim and map the whole ramdisk as it may exceed the area |
| * given to us by SILO. |
| */ |
| (void) ofw_claim_phys(base + top, silo_ramdisk_size); |
| (void) ofw_map(bootinfo.physmem_start + base + top, base + top, |
| silo_ramdisk_size, -1); |
| memmove(base + top, (void *)((uintptr_t)silo_ramdisk_image), |
| silo_ramdisk_size); |
| printf("done.\n"); |
| top += silo_ramdisk_size; |
| } |
| skip_ramdisk: |
| /* |
| * Now we can proceed to copy the components. We do it in reverse order |
| * so that we don't overwrite anything even if the components overlap |
| * with base. |
| */ |
| printf("\nCopying bootinfo tasks\n"); |
| for (i = COMPONENTS - 1; i > 0; i--, j--) { |
| printf(" %s...", components[i].name); |
| /* |
| * At this point, we claim the physical memory that we are |
| * going to use. We should be safe in case of the virtual |
| * address space because the OpenFirmware, according to its |
| * SPARC binding, should restrict its use of virtual memory |
| * to addresses from [0xffd00000; 0xffefffff] and |
| * [0xfe000000; 0xfeffffff]. |
| * |
| * XXX We don't map this piece of memory. We simply rely on |
| * SILO to have it done for us already in this case. |
| */ |
| (void) ofw_claim_phys(bootinfo.physmem_start + |
| bootinfo.taskmap.tasks[j].addr, |
| ALIGN_UP(components[i].size, PAGE_SIZE)); |
| memcpy((void *)bootinfo.taskmap.tasks[j].addr, |
| components[i].start, components[i].size); |
| printf("done.\n"); |
| } |
| printf("\nCopying kernel..."); |
| (void) ofw_claim_phys(bootinfo.physmem_start + base, |
| ALIGN_UP(components[0].size, PAGE_SIZE)); |
| memcpy(base, components[0].start, components[0].size); |
| printf("done.\n"); |
| /* |
| * Claim and map the physical memory for the boot allocator. |
| * Initialize the boot allocator. |
| */ |
| balloc_base = base + ALIGN_UP(top, PAGE_SIZE); |
| (void) ofw_claim_phys(bootinfo.physmem_start + balloc_base, |
| BALLOC_MAX_SIZE); |
| (void) ofw_map(bootinfo.physmem_start + balloc_base, balloc_base, |
| BALLOC_MAX_SIZE, -1); |
| balloc_init(&bootinfo.ballocs, (uintptr_t)balloc_base); |
| printf("\nCanonizing OpenFirmware device tree..."); |
| bootinfo.ofw_root = ofw_tree_build(); |
| printf("done.\n"); |
| #ifdef CONFIG_AP |
| printf("\nChecking for secondary processors..."); |
| if (!ofw_cpu()) |
| printf("Error: unable to get CPU properties\n"); |
| printf("done.\n"); |
| #endif |
| ofw_setup_palette(); |
| printf("\nBooting the kernel...\n"); |
| jump_to_kernel((void *) KERNEL_VIRTUAL_ADDRESS, |
| bootinfo.physmem_start | BSP_PROCESSOR, &bootinfo, |
| sizeof(bootinfo)); |
| } |
| /tags/0.4.0/boot/arch/sparc64/loader/Makefile |
|---|
| 0,0 → 1,170 |
| # |
| # Copyright (c) 2006 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 ../../../../version |
| include ../../../../Makefile.config |
| ## Toolchain configuration |
| # |
| ifndef CROSS_PREFIX |
| CROSS_PREFIX = /usr/local |
| endif |
| BFD_NAME = elf64-sparc |
| BFD_ARCH = sparc |
| TARGET = sparc64-linux-gnu |
| TOOLCHAIN_DIR = $(CROSS_PREFIX)/sparc64/bin |
| ifeq ($(COMPILER),gcc_native) |
| CC = gcc |
| AS = as |
| LD = ld |
| OBJCOPY = objcopy |
| OBJDUMP = objdump |
| endif |
| ifeq ($(COMPILER),gcc_cross) |
| CC = $(TOOLCHAIN_DIR)/$(TARGET)-gcc |
| AS = $(TOOLCHAIN_DIR)/$(TARGET)-as |
| LD = $(TOOLCHAIN_DIR)/$(TARGET)-ld |
| OBJCOPY = $(TOOLCHAIN_DIR)/$(TARGET)-objcopy |
| OBJDUMP = $(TOOLCHAIN_DIR)/$(TARGET)-objdump |
| endif |
| CFLAGS = -DRELEASE=\"$(RELEASE)\" -I. -I../../../generic -I../../../genarch -nostdinc -nostdlib -fno-builtin -Werror-implicit-function-declaration -Wmissing-prototypes -Werror -O3 -mcpu=ultrasparc -m64 -mno-fpu -pipe |
| ifdef REVISION |
| CFLAGS += "-DREVISION=\"$(REVISION)\"" |
| endif |
| ifdef TIMESTAMP |
| CFLAGS += "-DTIMESTAMP=\"$(TIMESTAMP)\"" |
| endif |
| SOURCES = \ |
| main.c \ |
| _components.c \ |
| ../../../generic/printf.c \ |
| ../../../generic/string.c \ |
| ../../../genarch/balloc.c \ |
| ../../../genarch/ofw.c \ |
| ../../../genarch/ofw_tree.c \ |
| ofwarch.c \ |
| asm.S \ |
| boot.S |
| # |
| # All components that go to image.boot without the ramdisk. |
| # |
| COMPONENTS = \ |
| $(KERNELDIR)/kernel.bin \ |
| $(USPACEDIR)/srv/ns/ns \ |
| $(USPACEDIR)/app/init/init \ |
| $(USPACEDIR)/srv/loader/loader \ |
| $(USPACEDIR)/srv/devmap/devmap \ |
| $(USPACEDIR)/srv/rd/rd \ |
| $(USPACEDIR)/srv/vfs/vfs |
| ifeq ($(RDFMT),tmpfs) |
| COMPONENTS += $(USPACEDIR)/srv/fs/tmpfs/tmpfs |
| endif |
| ifeq ($(RDFMT),fat) |
| COMPONENTS += $(USPACEDIR)/srv/fs/fat/fat |
| endif |
| # |
| # Final list of all components that go to image.boot. |
| # |
| ALL_COMPONENTS = $(COMPONENTS) |
| ifeq ($(CONFIG_RD_EXTERNAL),n) |
| ALL_COMPONENTS += ./initrd.img |
| endif |
| RD_SRVS = \ |
| $(USPACEDIR)/srv/fb/fb \ |
| $(USPACEDIR)/srv/kbd/kbd \ |
| $(USPACEDIR)/srv/console/console \ |
| $(USPACEDIR)/srv/fs/tmpfs/tmpfs \ |
| $(USPACEDIR)/srv/fs/fat/fat |
| RD_APPS = \ |
| $(USPACEDIR)/app/tetris/tetris \ |
| $(USPACEDIR)/app/tester/tester \ |
| $(USPACEDIR)/app/trace/trace \ |
| $(USPACEDIR)/app/bdsh/bdsh \ |
| $(USPACEDIR)/app/klog/klog |
| OBJECTS := $(addsuffix .o,$(basename $(SOURCES))) |
| ALL_COMPONENT_OBJECTS := $(addsuffix .o,$(basename $(notdir $(ALL_COMPONENTS)))) |
| .PHONY: all clean depend |
| all: image.boot disasm |
| -include Makefile.depend |
| image.boot: depend _components.h _link.ld $(ALL_COMPONENT_OBJECTS) $(OBJECTS) |
| $(LD) -Map image.map -no-check-sections -N -T _link.ld $(ALL_COMPONENT_OBJECTS) $(OBJECTS) -o $@ |
| depend: |
| -makedepend -f - -- $(DEFS) $(CFLAGS) -- $(SOURCES) > Makefile.depend 2> /dev/null |
| clean: |
| -for file in $(RD_SRVS) ; do \ |
| rm -f $(USPACEDIR)/dist/srv/`basename $$file` ; \ |
| done |
| -for file in $(RD_APPS) ; do \ |
| rm -f $(USPACEDIR)/dist/app/`basename $$file` ; \ |
| done |
| -rm -f _components.h _components.c _link.ld $(ALL_COMPONENT_OBJECTS) $(OBJECTS) initrd.img image.boot image.map image.disasm Makefile.depend |
| _components.h _components.c _link.ld $(ALL_COMPONENT_OBJECTS): $(COMPONENTS) $(RD_SRVS) $(RD_APPS) _link.ld.in |
| for file in $(RD_SRVS) ; do \ |
| cp $$file $(USPACEDIR)/dist/srv/ ; \ |
| done |
| for file in $(RD_APPS) ; do \ |
| cp $$file $(USPACEDIR)/dist/app/ ; \ |
| done |
| ifeq ($(RDFMT),tmpfs) |
| ../../../../tools/mktmpfs.py $(USPACEDIR)/dist/ initrd.fs |
| endif |
| ifeq ($(RDFMT),fat) |
| ../../../../tools/mkfat.py $(USPACEDIR)/dist/ initrd.fs |
| endif |
| ../../../../tools/mkhord.py 16384 initrd.fs initrd.img |
| rm initrd.fs |
| ../../../tools/pack.py $(OBJCOPY) $(BFD_NAME) $(BFD_ARCH) 1 "unsigned long" $(ALL_COMPONENTS) |
| %.o: %.S |
| $(CC) $(DEFS) $(CFLAGS) -D__ASM__ -c $< -o $@ |
| %.o: %.c |
| $(CC) $(DEFS) $(CFLAGS) -c $< -o $@ |
| disasm: image.boot |
| $(OBJDUMP) -d image.boot > image.disasm |
| /tags/0.4.0/boot/arch/sparc64/loader/asm.S |
|---|
| 0,0 → 1,172 |
| # |
| # Copyright (c) 2006 Martin Decky |
| # Copyright (c) 2006 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 <stack.h> |
| #include <register.h> |
| .register %g2, #scratch |
| .register %g3, #scratch |
| .text |
| .global halt |
| .global memcpy |
| .global jump_to_kernel |
| halt: |
| b halt |
| nop |
| memcpy: |
| mov %o0, %o3 ! save dst |
| add %o1, 7, %g1 |
| and %g1, -8, %g1 |
| cmp %o1, %g1 |
| be,pn %xcc, 3f |
| add %o0, 7, %g1 |
| mov 0, %g3 |
| 0: |
| brz,pn %o2, 2f |
| mov 0, %g2 |
| 1: |
| ldub [%g3 + %o1], %g1 |
| add %g2, 1, %g2 |
| cmp %o2, %g2 |
| stb %g1, [%g3 + %o0] |
| bne,pt %xcc, 1b |
| mov %g2, %g3 |
| 2: |
| jmp %o7 + 8 ! exit point |
| mov %o3, %o0 |
| 3: |
| and %g1, -8, %g1 |
| cmp %o0, %g1 |
| bne,pt %xcc, 0b |
| mov 0, %g3 |
| srlx %o2, 3, %g4 |
| brz,pn %g4, 5f |
| mov 0, %g5 |
| 4: |
| sllx %g3, 3, %g2 |
| add %g5, 1, %g3 |
| ldx [%o1 + %g2], %g1 |
| mov %g3, %g5 |
| cmp %g4, %g3 |
| bne,pt %xcc, 4b |
| stx %g1, [%o0 + %g2] |
| 5: |
| and %o2, 7, %o2 |
| brz,pn %o2, 2b |
| sllx %g4, 3, %g1 |
| mov 0, %g2 |
| add %g1, %o0, %o0 |
| add %g1, %o1, %g4 |
| mov 0, %g3 |
| 6: |
| ldub [%g2 + %g4], %g1 |
| stb %g1, [%g2 + %o0] |
| add %g3, 1, %g2 |
| cmp %o2, %g2 |
| bne,pt %xcc, 6b |
| mov %g2, %g3 |
| jmp %o7 + 8 ! exit point |
| mov %o3, %o0 |
| jump_to_kernel: |
| /* |
| * We have copied code and now we need to guarantee cache coherence. |
| * 1. Make sure that the code we have moved has drained to main memory. |
| * 2. Invalidate I-cache. |
| * 3. Flush instruction pipeline. |
| */ |
| /* |
| * US3 processors have a write-invalidate cache, so explicitly |
| * invalidating it is not required. Whether to invalidate I-cache |
| * or not is decided according to the value of the global |
| * "subarchitecture" variable (set in the bootstrap). |
| */ |
| set subarchitecture, %g2 |
| ldub [%g2], %g2 |
| cmp %g2, 3 |
| be 1f |
| nop |
| 0: |
| call icache_flush |
| nop |
| 1: |
| membar #StoreStore |
| /* |
| * Flush the instruction pipeline. |
| */ |
| flush %i7 |
| mov %o0, %l1 |
| mov %o1, %o0 |
| mov %o2, %o1 |
| mov %o3, %o2 |
| jmp %l1 ! jump to kernel |
| nop |
| #define ICACHE_SIZE 8192 |
| #define ICACHE_LINE_SIZE 32 |
| #define ICACHE_SET_BIT (1 << 13) |
| #define ASI_ICACHE_TAG 0x67 |
| # Flush I-cache |
| icache_flush: |
| set ((ICACHE_SIZE - ICACHE_LINE_SIZE) | ICACHE_SET_BIT), %g1 |
| stxa %g0, [%g1] ASI_ICACHE_TAG |
| 0: membar #Sync |
| subcc %g1, ICACHE_LINE_SIZE, %g1 |
| bnz,pt %xcc, 0b |
| stxa %g0, [%g1] ASI_ICACHE_TAG |
| membar #Sync |
| retl |
| ! SF Erratum #51 |
| nop |
| .global ofw |
| ofw: |
| save %sp, -STACK_WINDOW_SAVE_AREA_SIZE, %sp |
| set ofw_cif, %l0 |
| ldx [%l0], %l0 |
| rdpr %pstate, %l1 |
| and %l1, ~PSTATE_AM_BIT, %l2 |
| wrpr %l2, 0, %pstate |
| jmpl %l0, %o7 |
| mov %i0, %o0 |
| wrpr %l1, 0, %pstate |
| ret |
| restore %o0, 0, %o0 |
| /tags/0.4.0/boot/arch/sparc64/loader/main.h |
|---|
| 0,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 BOOT_sparc64_MAIN_H_ |
| #define BOOT_sparc64_MAIN_H_ |
| #include <ofw.h> |
| #include <ofw_tree.h> |
| #include <balloc.h> |
| #include <types.h> |
| #define KERNEL_VIRTUAL_ADDRESS 0x400000 |
| #define TASKMAP_MAX_RECORDS 32 |
| #define BSP_PROCESSOR 1 |
| #define AP_PROCESSOR 0 |
| #define SUBARCH_US 1 |
| #define SUBARCH_US3 3 |
| typedef struct { |
| void *addr; |
| uint32_t size; |
| } task_t; |
| typedef struct { |
| uint32_t count; |
| task_t tasks[TASKMAP_MAX_RECORDS]; |
| } taskmap_t; |
| typedef struct { |
| uintptr_t physmem_start; |
| taskmap_t taskmap; |
| memmap_t memmap; |
| ballocs_t ballocs; |
| ofw_tree_node_t *ofw_root; |
| } bootinfo_t; |
| extern uint32_t silo_ramdisk_image; |
| extern uint32_t silo_ramdisk_size; |
| extern bootinfo_t bootinfo; |
| extern void start(void); |
| extern void bootstrap(void); |
| #endif |
| /tags/0.4.0/boot/arch/sparc64/loader/ofwarch.c |
|---|
| 0,0 → 1,179 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * Copyright (c) 2006 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. |
| */ |
| /** |
| * @file |
| * @brief Architecture dependent parts of OpenFirmware interface. |
| */ |
| #include <ofwarch.h> |
| #include <ofw.h> |
| #include <printf.h> |
| #include <string.h> |
| #include <register.h> |
| #include "main.h" |
| #include "asm.h" |
| /* these tho variables will be set by the detect_subarchitecture function */ |
| extern uint8_t subarchitecture; |
| extern uint16_t mid_mask; |
| void write(const char *str, const int len) |
| { |
| int i; |
| for (i = 0; i < len; i++) { |
| if (str[i] == '\n') |
| ofw_write("\r", 1); |
| ofw_write(&str[i], 1); |
| } |
| } |
| int ofw_translate_failed(ofw_arg_t flag) |
| { |
| return flag != -1; |
| } |
| /** |
| * Starts all CPUs represented by following siblings of the given node, |
| * except for the current CPU. |
| * |
| * @param child The first child of the OFW tree node whose children |
| * represent CPUs to be woken up. |
| * @param current_mid MID of the current CPU, the current CPU will |
| * (of course) not be woken up. |
| * @return Number of CPUs which have the same parent node as |
| * "child". |
| */ |
| static int wake_cpus_in_node(phandle child, uint64_t current_mid) |
| { |
| int cpus; |
| char type_name[BUF_SIZE]; |
| for (cpus = 0; child != 0 && child != -1; |
| child = ofw_get_peer_node(child), cpus++) { |
| if (ofw_get_property(child, "device_type", type_name, |
| sizeof(type_name)) > 0) { |
| if (strcmp(type_name, "cpu") == 0) { |
| uint32_t mid; |
| /* |
| * "upa-portid" for US, "portid" for US-III, |
| * "cpuid" for US-IV |
| */ |
| if (ofw_get_property( |
| child, "upa-portid", |
| &mid, sizeof(mid)) <= 0 |
| && ofw_get_property(child, "portid", |
| &mid, sizeof(mid)) <= 0 |
| && ofw_get_property(child, "cpuid", |
| &mid, sizeof(mid)) <= 0) |
| continue; |
| if (current_mid != mid) { |
| /* |
| * Start secondary processor. |
| */ |
| (void) ofw_call("SUNW,start-cpu", 3, 1, |
| NULL, child, KERNEL_VIRTUAL_ADDRESS, |
| bootinfo.physmem_start | |
| AP_PROCESSOR); |
| } |
| } |
| } |
| } |
| return cpus; |
| } |
| /** |
| * Finds out the current CPU's MID and wakes up all AP processors. |
| */ |
| int ofw_cpu(void) |
| { |
| int cpus; |
| phandle node; |
| phandle subnode; |
| phandle cpus_parent; |
| phandle cmp; |
| char name[BUF_SIZE]; |
| /* get the current CPU MID */ |
| uint64_t current_mid; |
| asm volatile ("ldxa [%1] %2, %0\n" |
| : "=r" (current_mid) |
| : "r" (0), "i" (ASI_ICBUS_CONFIG)); |
| current_mid >>= ICBUS_CONFIG_MID_SHIFT; |
| current_mid &= mid_mask; |
| /* wake up CPUs */ |
| cpus_parent = ofw_find_device("/ssm@0,0"); |
| if (cpus_parent == 0 || cpus_parent == -1) { |
| cpus_parent = ofw_find_device("/"); |
| } |
| node = ofw_get_child_node(cpus_parent); |
| cpus = wake_cpus_in_node(node, current_mid); |
| while (node != 0 && node != -1) { |
| if (ofw_get_property(node, "name", name, |
| sizeof(name)) > 0) { |
| if (strcmp(name, "cmp") == 0) { |
| subnode = ofw_get_child_node(node); |
| cpus += wake_cpus_in_node(subnode, |
| current_mid); |
| } |
| } |
| node = ofw_get_peer_node(node); |
| } |
| return cpus; |
| } |
| /** Get physical memory starting address. |
| * |
| * @param start Pointer to variable where the physical memory starting |
| * address will be stored. |
| * |
| * @return Non-zero on succes, zero on failure. |
| */ |
| int ofw_get_physmem_start(uintptr_t *start) |
| { |
| uint32_t memreg[4]; |
| if (ofw_get_property(ofw_memory, "reg", &memreg, sizeof(memreg)) <= 0) |
| return 0; |
| *start = (((uint64_t) memreg[0]) << 32) | memreg[1]; |
| return 1; |
| } |
| /tags/0.4.0/boot/arch/sparc64/loader/register.h |
|---|
| 0,0 → 1,39 |
| /* |
| * Copyright (c) 2006 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 BOOT_sparc64_REGISTER_H_ |
| #define BOOT_sparc64_REGISTER_H_ |
| #define PSTATE_IE_BIT 2 |
| #define PSTATE_PRIV_BIT 4 |
| #define PSTATE_AM_BIT 8 |
| #define ASI_ICBUS_CONFIG 0x4a |
| #define ICBUS_CONFIG_MID_SHIFT 17 |
| #endif |
| /tags/0.4.0/boot/arch/sparc64/loader/boot.S |
|---|
| 0,0 → 1,93 |
| # |
| # Copyright (c) 2006 Martin Decky |
| # Copyright (c) 2006 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 <stack.h> |
| #include <register.h> |
| #define INITIAL_STACK_SIZE 8192 |
| #define NWINDOWS 8 |
| .register %g2, #scratch |
| .register %g3, #scratch |
| .register %g6, #scratch |
| .register %g7, #scratch |
| .section BOOTSTRAP, "ax" |
| .global start |
| start: |
| b 1f |
| nop |
| /* |
| * This header forces SILO to load the image at 0x4000. |
| * More precisely, SILO will think this is an old version of Linux. |
| */ |
| .ascii "HdrS" |
| .word 0 |
| .half 0 |
| .half 0 |
| .half 0 |
| .half 0 |
| .global silo_ramdisk_image |
| silo_ramdisk_image: |
| .word 0 |
| .global silo_ramdisk_size |
| silo_ramdisk_size: |
| .word 0 |
| .align 8 |
| 1: |
| /* |
| * Disable interrupts and disable address masking. |
| */ |
| wrpr %g0, PSTATE_PRIV_BIT, %pstate |
| wrpr %g0, NWINDOWS - 2, %cansave ! set maximum saveable windows |
| wrpr %g0, 0, %canrestore ! get rid of windows we will never need again |
| wrpr %g0, 0, %otherwin ! make sure the window state is consistent |
| wrpr %g0, NWINDOWS - 1, %cleanwin ! prevent needless clean_window traps for kernel |
| set initial_stack_top, %sp |
| add %sp, -STACK_BIAS, %sp |
| set ofw_cif, %l0 |
| call ofw_init ! initialize OpenFirmware |
| stx %o4, [%l0] |
| b bootstrap |
| nop |
| .align STACK_ALIGNMENT |
| initial_stack: |
| .space INITIAL_STACK_SIZE |
| initial_stack_top: |
| .space STACK_WINDOW_SAVE_AREA_SIZE |
| /tags/0.4.0/boot/arch/sparc64/loader/_link.ld.in |
|---|
| 0,0 → 1,23 |
| OUTPUT_FORMAT("elf64-sparc") |
| ENTRY(start) |
| SECTIONS { |
| .boot 0x4000: AT (0x4000) { |
| *(BOOTSTRAP); |
| *(.text); |
| *(.rodata); |
| *(.rodata.*); |
| *(.data); /* initialized data */ |
| *(.sdata); |
| *(.sdata2); |
| *(.sbss); |
| *(.bss); /* uninitialized static variables */ |
| *(COMMON); |
| [[COMPONENTS]] |
| } |
| /DISCARD/ : { |
| *(.comment); |
| *(.note*); |
| } |
| } |
| /tags/0.4.0/boot/arch/sparc64/loader/asm.h |
|---|
| 0,0 → 1,45 |
| /* |
| * Copyright (c) 2006 Martin Decky |
| * Copyright (c) 2006 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 BOOT_sparc64_ASM_H_ |
| #define BOOT_sparc64_ASM_H_ |
| #include "types.h" |
| #include "main.h" |
| #define PAGE_WIDTH 14 |
| #define PAGE_SIZE (1 << PAGE_WIDTH) |
| #define memcpy(dst, src, cnt) __builtin_memcpy((dst), (src), (cnt)) |
| extern void halt(void); |
| extern void jump_to_kernel(void *entry, uint64_t cfg, bootinfo_t *bootinfo, |
| unsigned int bootinfo_size) __attribute__((noreturn)); |
| #endif |
| /tags/0.4.0/boot/arch/sparc64/loader/ofwarch.h |
|---|
| 0,0 → 1,41 |
| /* |
| * Copyright (c) 2006 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 BOOT_sparc64_OFWARCH_H_ |
| #define BOOT_sparc64_OFWARCH_H_ |
| #include "main.h" |
| #include "types.h" |
| #define OFW_ADDRESS_CELLS 2 |
| #define OFW_SIZE_CELLS 2 |
| extern int ofw_cpu(void); |
| extern int ofw_get_physmem_start(uintptr_t *start); |
| #endif |
| /tags/0.4.0/boot/arch/sparc64/loader/types.h |
|---|
| 0,0 → 1,44 |
| /* |
| * Copyright (c) 2006 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 BOOT_sparc64_TYPES_H_ |
| #define BOOT_sparc64_TYPES_H_ |
| #include <gentypes.h> |
| typedef signed char int8_t; |
| typedef unsigned char uint8_t; |
| typedef unsigned short uint16_t; |
| typedef unsigned int uint32_t; |
| typedef unsigned long uint64_t; |
| typedef uint64_t uintptr_t; |
| typedef uint64_t unative_t; |
| #endif |
| /tags/0.4.0/boot/arch/sparc64/loader/stack.h |
|---|
| 0,0 → 1,36 |
| /* |
| * Copyright (c) 2006 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 BOOT_sparc64_STACK_H_ |
| #define BOOT_sparc64_STACK_H_ |
| #define STACK_ALIGNMENT 16 |
| #define STACK_BIAS 2047 |
| #define STACK_WINDOW_SAVE_AREA_SIZE (16*8) |
| #endif |
| /tags/0.4.0/boot/arch/sparc64/Makefile.inc |
|---|
| 0,0 → 1,69 |
| # |
| # Copyright (c) 2006 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. |
| # |
| TMP = distroot |
| ifeq ($(CONFIG_AOUT_ISOFS_B),n) |
| SILO_PACKAGE=silo.patched.tar.gz |
| endif |
| ifeq ($(CONFIG_AOUT_ISOFS_B),y) |
| SILO_PACKAGE=silo.tar.gz |
| endif |
| build: $(BASE)/image.iso |
| ifeq ($(CONFIG_RD_EXTERNAL),y) |
| SILO_CONF_FILTER = cat |
| else |
| SILO_CONF_FILTER = grep -v initrd |
| endif |
| $(BASE)/image.iso: depend arch/$(ARCH)/loader/image.boot |
| mkdir -p $(TMP)/boot |
| mkdir -p $(TMP)/HelenOS |
| cat arch/$(ARCH)/silo/$(SILO_PACKAGE) | (cd $(TMP)/boot; tar xvfz -) |
| cp arch/$(ARCH)/silo/README arch/$(ARCH)/silo/COPYING $(TMP)/boot |
| cat arch/$(ARCH)/silo/silo.conf | $(SILO_CONF_FILTER) >$(TMP)/boot/silo.conf |
| cp arch/$(ARCH)/loader/image.boot $(TMP)/HelenOS/image.boot |
| gzip -f $(TMP)/HelenOS/image.boot |
| ifeq ($(CONFIG_RD_EXTERNAL),y) |
| cp arch/$(ARCH)/loader/initrd.img $(TMP)/HelenOS/initrd.img |
| endif |
| mkisofs -f -G $(TMP)/boot/isofs.b -B ... -r -o $(BASE)/image.iso $(TMP)/ |
| depend: |
| -rm arch/$(ARCH)/loader/image.boot |
| arch/$(ARCH)/loader/image.boot: |
| $(MAKE) -C arch/$(ARCH)/loader COMPILER=$(COMPILER) KERNELDIR=../../../$(KERNELDIR) USPACEDIR=../../../$(USPACEDIR) "DEFS=$(DEFS)" |
| clean: generic_clean |
| $(MAKE) -C arch/$(ARCH)/loader clean COMPILER=$(COMPILER) KERNELDIR=../../../$(KERNELDIR) USPACEDIR=../../../$(USPACEDIR) |
| -rm -fr $(TMP) |
| -rm -f $(BASE)/image.iso |
| /tags/0.4.0/boot/arch/sparc64/silo/silo.patched.tar.gz |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /tags/0.4.0/boot/arch/sparc64/silo/silo.conf |
|---|
| 0,0 → 1,4 |
| timeout = 0 |
| image = /HelenOS/image.boot.gz |
| label = HelenOS |
| initrd = /HelenOS/initrd.img |
| /tags/0.4.0/boot/arch/sparc64/silo/silo.tar.gz |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /tags/0.4.0/boot/arch/sparc64/silo/README |
|---|
| 0,0 → 1,5 |
| For licensing terms of SILO boot loader see the file COPYING contained |
| in this directory. Full version of SILO, including its source code, |
| can be downloaded from SILO's project page: |
| http://www.sparc-boot.org/ |
| /tags/0.4.0/boot/arch/sparc64/silo/COPYING |
|---|
| 0,0 → 1,340 |
| GNU GENERAL PUBLIC LICENSE |
| Version 2, June 1991 |
| Copyright (C) 1989, 1991 Free Software Foundation, Inc. |
| 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| Everyone is permitted to copy and distribute verbatim copies |
| of this license document, but changing it is not allowed. |
| Preamble |
| The licenses for most software are designed to take away your |
| freedom to share and change it. By contrast, the GNU General Public |
| License is intended to guarantee your freedom to share and change free |
| software--to make sure the software is free for all its users. This |
| General Public License applies to most of the Free Software |
| Foundation's software and to any other program whose authors commit to |
| using it. (Some other Free Software Foundation software is covered by |
| the GNU Library General Public License instead.) You can apply it to |
| your programs, too. |
| When we speak of free software, we are referring to freedom, not |
| price. Our General Public Licenses are designed to make sure that you |
| have the freedom to distribute copies of free software (and charge for |
| this service if you wish), that you receive source code or can get it |
| if you want it, that you can change the software or use pieces of it |
| in new free programs; and that you know you can do these things. |
| To protect your rights, we need to make restrictions that forbid |
| anyone to deny you these rights or to ask you to surrender the rights. |
| These restrictions translate to certain responsibilities for you if you |
| distribute copies of the software, or if you modify it. |
| For example, if you distribute copies of such a program, whether |
| gratis or for a fee, you must give the recipients all the rights that |
| you have. You must make sure that they, too, receive or can get the |
| source code. And you must show them these terms so they know their |
| rights. |
| We protect your rights with two steps: (1) copyright the software, and |
| (2) offer you this license which gives you legal permission to copy, |
| distribute and/or modify the software. |
| Also, for each author's protection and ours, we want to make certain |
| that everyone understands that there is no warranty for this free |
| software. If the software is modified by someone else and passed on, we |
| want its recipients to know that what they have is not the original, so |
| that any problems introduced by others will not reflect on the original |
| authors' reputations. |
| Finally, any free program is threatened constantly by software |
| patents. We wish to avoid the danger that redistributors of a free |
| program will individually obtain patent licenses, in effect making the |
| program proprietary. To prevent this, we have made it clear that any |
| patent must be licensed for everyone's free use or not licensed at all. |
| The precise terms and conditions for copying, distribution and |
| modification follow. |
| GNU GENERAL PUBLIC LICENSE |
| TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION |
| 0. This License applies to any program or other work which contains |
| a notice placed by the copyright holder saying it may be distributed |
| under the terms of this General Public License. The "Program", below, |
| refers to any such program or work, and a "work based on the Program" |
| means either the Program or any derivative work under copyright law: |
| that is to say, a work containing the Program or a portion of it, |
| either verbatim or with modifications and/or translated into another |
| language. (Hereinafter, translation is included without limitation in |
| the term "modification".) Each licensee is addressed as "you". |
| Activities other than copying, distribution and modification are not |
| covered by this License; they are outside its scope. The act of |
| running the Program is not restricted, and the output from the Program |
| is covered only if its contents constitute a work based on the |
| Program (independent of having been made by running the Program). |
| Whether that is true depends on what the Program does. |
| 1. You may copy and distribute verbatim copies of the Program's |
| source code as you receive it, in any medium, provided that you |
| conspicuously and appropriately publish on each copy an appropriate |
| copyright notice and disclaimer of warranty; keep intact all the |
| notices that refer to this License and to the absence of any warranty; |
| and give any other recipients of the Program a copy of this License |
| along with the Program. |
| You may charge a fee for the physical act of transferring a copy, and |
| you may at your option offer warranty protection in exchange for a fee. |
| 2. You may modify your copy or copies of the Program or any portion |
| of it, thus forming a work based on the Program, and copy and |
| distribute such modifications or work under the terms of Section 1 |
| above, provided that you also meet all of these conditions: |
| a) You must cause the modified files to carry prominent notices |
| stating that you changed the files and the date of any change. |
| b) You must cause any work that you distribute or publish, that in |
| whole or in part contains or is derived from the Program or any |
| part thereof, to be licensed as a whole at no charge to all third |
| parties under the terms of this License. |
| c) If the modified program normally reads commands interactively |
| when run, you must cause it, when started running for such |
| interactive use in the most ordinary way, to print or display an |
| announcement including an appropriate copyright notice and a |
| notice that there is no warranty (or else, saying that you provide |
| a warranty) and that users may redistribute the program under |
| these conditions, and telling the user how to view a copy of this |
| License. (Exception: if the Program itself is interactive but |
| does not normally print such an announcement, your work based on |
| the Program is not required to print an announcement.) |
| These requirements apply to the modified work as a whole. If |
| identifiable sections of that work are not derived from the Program, |
| and can be reasonably considered independent and separate works in |
| themselves, then this License, and its terms, do not apply to those |
| sections when you distribute them as separate works. But when you |
| distribute the same sections as part of a whole which is a work based |
| on the Program, the distribution of the whole must be on the terms of |
| this License, whose permissions for other licensees extend to the |
| entire whole, and thus to each and every part regardless of who wrote it. |
| Thus, it is not the intent of this section to claim rights or contest |
| your rights to work written entirely by you; rather, the intent is to |
| exercise the right to control the distribution of derivative or |
| collective works based on the Program. |
| In addition, mere aggregation of another work not based on the Program |
| with the Program (or with a work based on the Program) on a volume of |
| a storage or distribution medium does not bring the other work under |
| the scope of this License. |
| 3. You may copy and distribute the Program (or a work based on it, |
| under Section 2) in object code or executable form under the terms of |
| Sections 1 and 2 above provided that you also do one of the following: |
| a) Accompany it with the complete corresponding machine-readable |
| source code, which must be distributed under the terms of Sections |
| 1 and 2 above on a medium customarily used for software interchange; or, |
| b) Accompany it with a written offer, valid for at least three |
| years, to give any third party, for a charge no more than your |
| cost of physically performing source distribution, a complete |
| machine-readable copy of the corresponding source code, to be |
| distributed under the terms of Sections 1 and 2 above on a medium |
| customarily used for software interchange; or, |
| c) Accompany it with the information you received as to the offer |
| to distribute corresponding source code. (This alternative is |
| allowed only for noncommercial distribution and only if you |
| received the program in object code or executable form with such |
| an offer, in accord with Subsection b above.) |
| The source code for a work means the preferred form of the work for |
| making modifications to it. For an executable work, complete source |
| code means all the source code for all modules it contains, plus any |
| associated interface definition files, plus the scripts used to |
| control compilation and installation of the executable. However, as a |
| special exception, the source code distributed need not include |
| anything that is normally distributed (in either source or binary |
| form) with the major components (compiler, kernel, and so on) of the |
| operating system on which the executable runs, unless that component |
| itself accompanies the executable. |
| If distribution of executable or object code is made by offering |
| access to copy from a designated place, then offering equivalent |
| access to copy the source code from the same place counts as |
| distribution of the source code, even though third parties are not |
| compelled to copy the source along with the object code. |
| 4. You may not copy, modify, sublicense, or distribute the Program |
| except as expressly provided under this License. Any attempt |
| otherwise to copy, modify, sublicense or distribute the Program is |
| void, and will automatically terminate your rights under this License. |
| However, parties who have received copies, or rights, from you under |
| this License will not have their licenses terminated so long as such |
| parties remain in full compliance. |
| 5. You are not required to accept this License, since you have not |
| signed it. However, nothing else grants you permission to modify or |
| distribute the Program or its derivative works. These actions are |
| prohibited by law if you do not accept this License. Therefore, by |
| modifying or distributing the Program (or any work based on the |
| Program), you indicate your acceptance of this License to do so, and |
| all its terms and conditions for copying, distributing or modifying |
| the Program or works based on it. |
| 6. Each time you redistribute the Program (or any work based on the |
| Program), the recipient automatically receives a license from the |
| original licensor to copy, distribute or modify the Program subject to |
| these terms and conditions. You may not impose any further |
| restrictions on the recipients' exercise of the rights granted herein. |
| You are not responsible for enforcing compliance by third parties to |
| this License. |
| 7. If, as a consequence of a court judgment or allegation of patent |
| infringement or for any other reason (not limited to patent issues), |
| conditions are imposed on you (whether by court order, agreement or |
| otherwise) that contradict the conditions of this License, they do not |
| excuse you from the conditions of this License. If you cannot |
| distribute so as to satisfy simultaneously your obligations under this |
| License and any other pertinent obligations, then as a consequence you |
| may not distribute the Program at all. For example, if a patent |
| license would not permit royalty-free redistribution of the Program by |
| all those who receive copies directly or indirectly through you, then |
| the only way you could satisfy both it and this License would be to |
| refrain entirely from distribution of the Program. |
| If any portion of this section is held invalid or unenforceable under |
| any particular circumstance, the balance of the section is intended to |
| apply and the section as a whole is intended to apply in other |
| circumstances. |
| It is not the purpose of this section to induce you to infringe any |
| patents or other property right claims or to contest validity of any |
| such claims; this section has the sole purpose of protecting the |
| integrity of the free software distribution system, which is |
| implemented by public license practices. Many people have made |
| generous contributions to the wide range of software distributed |
| through that system in reliance on consistent application of that |
| system; it is up to the author/donor to decide if he or she is willing |
| to distribute software through any other system and a licensee cannot |
| impose that choice. |
| This section is intended to make thoroughly clear what is believed to |
| be a consequence of the rest of this License. |
| 8. If the distribution and/or use of the Program is restricted in |
| certain countries either by patents or by copyrighted interfaces, the |
| original copyright holder who places the Program under this License |
| may add an explicit geographical distribution limitation excluding |
| those countries, so that distribution is permitted only in or among |
| countries not thus excluded. In such case, this License incorporates |
| the limitation as if written in the body of this License. |
| 9. The Free Software Foundation may publish revised and/or new versions |
| of the General Public License from time to time. Such new versions will |
| be similar in spirit to the present version, but may differ in detail to |
| address new problems or concerns. |
| Each version is given a distinguishing version number. If the Program |
| specifies a version number of this License which applies to it and "any |
| later version", you have the option of following the terms and conditions |
| either of that version or of any later version published by the Free |
| Software Foundation. If the Program does not specify a version number of |
| this License, you may choose any version ever published by the Free Software |
| Foundation. |
| 10. If you wish to incorporate parts of the Program into other free |
| programs whose distribution conditions are different, write to the author |
| to ask for permission. For software which is copyrighted by the Free |
| Software Foundation, write to the Free Software Foundation; we sometimes |
| make exceptions for this. Our decision will be guided by the two goals |
| of preserving the free status of all derivatives of our free software and |
| of promoting the sharing and reuse of software generally. |
| NO WARRANTY |
| 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY |
| FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN |
| OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES |
| PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED |
| OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS |
| TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE |
| PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, |
| REPAIR OR CORRECTION. |
| 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING |
| WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR |
| REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, |
| INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING |
| OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED |
| TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY |
| YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER |
| PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE |
| POSSIBILITY OF SUCH DAMAGES. |
| END OF TERMS AND CONDITIONS |
| How to Apply These Terms to Your New Programs |
| If you develop a new program, and you want it to be of the greatest |
| possible use to the public, the best way to achieve this is to make it |
| free software which everyone can redistribute and change under these terms. |
| To do so, attach the following notices to the program. It is safest |
| to attach them to the start of each source file to most effectively |
| convey the exclusion of warranty; and each file should have at least |
| the "copyright" line and a pointer to where the full notice is found. |
| <one line to give the program's name and a brief idea of what it does.> |
| Copyright (C) <year> <name of author> |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2 of the License, or |
| (at your option) any later version. |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| You should have received a copy of the GNU General Public License |
| along with this program; if not, write to the Free Software |
| Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| Also add information on how to contact you by electronic and paper mail. |
| If the program is interactive, make it output a short notice like this |
| when it starts in an interactive mode: |
| Gnomovision version 69, Copyright (C) year name of author |
| Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. |
| This is free software, and you are welcome to redistribute it |
| under certain conditions; type `show c' for details. |
| The hypothetical commands `show w' and `show c' should show the appropriate |
| parts of the General Public License. Of course, the commands you use may |
| be called something other than `show w' and `show c'; they could even be |
| mouse-clicks or menu items--whatever suits your program. |
| You should also get your employer (if you work as a programmer) or your |
| school, if any, to sign a "copyright disclaimer" for the program, if |
| necessary. Here is a sample; alter the names: |
| Yoyodyne, Inc., hereby disclaims all copyright interest in the program |
| `Gnomovision' (which makes passes at compilers) written by James Hacker. |
| <signature of Ty Coon>, 1 April 1989 |
| Ty Coon, President of Vice |
| This General Public License does not permit incorporating your program into |
| proprietary programs. If your program is a subroutine library, you may |
| consider it more useful to permit linking proprietary applications with the |
| library. If this is what you want to do, use the GNU Library General |
| Public License instead of this License. |
| /tags/0.4.0/boot/arch/ppc32/loader/main.c |
|---|
| 0,0 → 1,183 |
| /* |
| * 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 "main.h" |
| #include <printf.h> |
| #include "asm.h" |
| #include "_components.h" |
| #include <ofw.h> |
| #include <align.h> |
| #define HEAP_GAP 1024000 |
| bootinfo_t bootinfo; |
| static void check_align(const void *addr, const char *desc) |
| { |
| if ((unsigned int) addr % PAGE_SIZE != 0) { |
| printf("Error: %s not on page boundary, halting.\n", desc); |
| halt(); |
| } |
| } |
| static void fix_overlap(void *va, void **pa, const char *desc, unsigned int *top) |
| { |
| if ((unsigned int) *pa + PAGE_SIZE < *top) { |
| printf("Warning: %s overlaps kernel physical area\n", desc); |
| void *new_va = (void *) (ALIGN_UP((unsigned int) KERNEL_END + HEAP_GAP, PAGE_SIZE) + *top); |
| void *new_pa = (void *) (HEAP_GAP + *top); |
| *top += PAGE_SIZE; |
| if (ofw_map(new_pa, new_va, PAGE_SIZE, 0) != 0) { |
| printf("Error: Unable to map page aligned memory at %L (physical %L), halting.\n", new_va, new_pa); |
| halt(); |
| } |
| if ((unsigned int) new_pa + PAGE_SIZE < KERNEL_SIZE) { |
| printf("Error: %s cannot be relocated, halting.\n", desc); |
| halt(); |
| } |
| printf("Relocating %L -> %L (physical %L -> %L)\n", va, new_va, *pa, new_pa); |
| *pa = new_pa; |
| memcpy(new_va, va, PAGE_SIZE); |
| } |
| } |
| char *release = RELEASE; |
| #ifdef REVISION |
| char *revision = ", revision " REVISION; |
| #else |
| char *revision = ""; |
| #endif |
| #ifdef TIMESTAMP |
| char *timestamp = "\nBuilt on " TIMESTAMP; |
| #else |
| char *timestamp = ""; |
| #endif |
| /** Print version information. */ |
| static void version_print(void) |
| { |
| printf("HelenOS PPC32 Bootloader\nRelease %s%s%s\nCopyright (c) 2006 HelenOS project\n\n", release, revision, timestamp); |
| } |
| void bootstrap(void) |
| { |
| version_print(); |
| component_t components[COMPONENTS]; |
| init_components(components); |
| unsigned int i; |
| for (i = 0; i < COMPONENTS; i++) |
| check_align(components[i].start, components[i].name); |
| check_align(&real_mode, "bootstrap trampoline"); |
| check_align(&trans, "translation table"); |
| if (!ofw_memmap(&bootinfo.memmap)) { |
| printf("Error: Unable to get memory map, halting.\n"); |
| halt(); |
| } |
| if (bootinfo.memmap.total == 0) { |
| printf("Error: No memory detected, halting.\n"); |
| halt(); |
| } |
| if (!ofw_screen(&bootinfo.screen)) |
| printf("Warning: Unable to get screen properties.\n"); |
| if (!ofw_macio(&bootinfo.macio)) |
| printf("Warning: Unable to get macio properties.\n"); |
| printf("Device statistics\n"); |
| if (bootinfo.screen.addr) |
| printf(" screen at %L, resolution %dx%d, %d bpp (scanline %d bytes)\n", bootinfo.screen.addr, bootinfo.screen.width, bootinfo.screen.height, bootinfo.screen.bpp, bootinfo.screen.scanline); |
| if (bootinfo.macio.addr) |
| printf(" macio at %L (size %d bytes)\n", bootinfo.macio.addr, bootinfo.macio.size); |
| void *real_mode_pa = ofw_translate(&real_mode); |
| void *trans_pa = ofw_translate(&trans); |
| void *bootinfo_pa = ofw_translate(&bootinfo); |
| printf("\nMemory statistics (total %d MB)\n", bootinfo.memmap.total >> 20); |
| printf(" %L: boot info structure (physical %L)\n", &bootinfo, bootinfo_pa); |
| printf(" %L: bootstrap trampoline (physical %L)\n", &real_mode, real_mode_pa); |
| printf(" %L: translation table (physical %L)\n", &trans, trans_pa); |
| for (i = 0; i < COMPONENTS; i++) |
| printf(" %L: %s image (size %d bytes)\n", components[i].start, components[i].name, components[i].size); |
| unsigned int top = 0; |
| for (i = 0; i < COMPONENTS; i++) |
| top += ALIGN_UP(components[i].size, PAGE_SIZE); |
| unsigned int pages = ALIGN_UP(KERNEL_SIZE, PAGE_SIZE) >> PAGE_WIDTH; |
| for (i = 0; i < pages; i++) { |
| void *pa = ofw_translate(KERNEL_START + (i << PAGE_WIDTH)); |
| fix_overlap(KERNEL_START + (i << PAGE_WIDTH), &pa, "kernel", &top); |
| trans[i] = pa; |
| } |
| bootinfo.taskmap.count = 0; |
| for (i = 1; i < COMPONENTS; i++) { |
| unsigned int component_pages = ALIGN_UP(components[i].size, PAGE_SIZE) >> PAGE_WIDTH; |
| unsigned int j; |
| for (j = 0; j < component_pages; j++) { |
| void *pa = ofw_translate(components[i].start + (j << PAGE_WIDTH)); |
| fix_overlap(components[i].start + (j << PAGE_WIDTH), &pa, components[i].name, &top); |
| trans[pages + j] = pa; |
| if (j == 0) { |
| bootinfo.taskmap.tasks[bootinfo.taskmap.count].addr = (void *) (pages << PAGE_WIDTH); |
| bootinfo.taskmap.tasks[bootinfo.taskmap.count].size = components[i].size; |
| bootinfo.taskmap.count++; |
| } |
| } |
| pages += component_pages; |
| } |
| fix_overlap(&real_mode, &real_mode_pa, "bootstrap trampoline", &top); |
| fix_overlap(&trans, &trans_pa, "translation table", &top); |
| fix_overlap(&bootinfo, &bootinfo_pa, "boot info", &top); |
| ofw_setup_palette(); |
| printf("\nBooting the kernel...\n"); |
| jump_to_kernel(bootinfo_pa, sizeof(bootinfo), trans_pa, pages << PAGE_WIDTH, real_mode_pa, (void *) bootinfo.screen.addr, bootinfo.screen.scanline); |
| } |
| /tags/0.4.0/boot/arch/ppc32/loader/regname.h |
|---|
| 0,0 → 1,223 |
| /* |
| * 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 __ppc32_REGNAME_H__ |
| #define __ppc32_REGNAME_H__ |
| /* Condition Register Bit Fields */ |
| #define cr0 0 |
| #define cr1 1 |
| #define cr2 2 |
| #define cr3 3 |
| #define cr4 4 |
| #define cr5 5 |
| #define cr6 6 |
| #define cr7 7 |
| /* General Purpose Registers (GPRs) */ |
| #define r0 0 |
| #define r1 1 |
| #define r2 2 |
| #define r3 3 |
| #define r4 4 |
| #define r5 5 |
| #define r6 6 |
| #define r7 7 |
| #define r8 8 |
| #define r9 9 |
| #define r10 10 |
| #define r11 11 |
| #define r12 12 |
| #define r13 13 |
| #define r14 14 |
| #define r15 15 |
| #define r16 16 |
| #define r17 17 |
| #define r18 18 |
| #define r19 19 |
| #define r20 20 |
| #define r21 21 |
| #define r22 22 |
| #define r23 23 |
| #define r24 24 |
| #define r25 25 |
| #define r26 26 |
| #define r27 27 |
| #define r28 28 |
| #define r29 29 |
| #define r30 30 |
| #define r31 31 |
| /* GPR Aliases */ |
| #define sp 1 |
| /* Floating Point Registers (FPRs) */ |
| #define fr0 0 |
| #define fr1 1 |
| #define fr2 2 |
| #define fr3 3 |
| #define fr4 4 |
| #define fr5 5 |
| #define fr6 6 |
| #define fr7 7 |
| #define fr8 8 |
| #define fr9 9 |
| #define fr10 10 |
| #define fr11 11 |
| #define fr12 12 |
| #define fr13 13 |
| #define fr14 14 |
| #define fr15 15 |
| #define fr16 16 |
| #define fr17 17 |
| #define fr18 18 |
| #define fr19 19 |
| #define fr20 20 |
| #define fr21 21 |
| #define fr22 22 |
| #define fr23 23 |
| #define fr24 24 |
| #define fr25 25 |
| #define fr26 26 |
| #define fr27 27 |
| #define fr28 28 |
| #define fr29 29 |
| #define fr30 30 |
| #define fr31 31 |
| #define vr0 0 |
| #define vr1 1 |
| #define vr2 2 |
| #define vr3 3 |
| #define vr4 4 |
| #define vr5 5 |
| #define vr6 6 |
| #define vr7 7 |
| #define vr8 8 |
| #define vr9 9 |
| #define vr10 10 |
| #define vr11 11 |
| #define vr12 12 |
| #define vr13 13 |
| #define vr14 14 |
| #define vr15 15 |
| #define vr16 16 |
| #define vr17 17 |
| #define vr18 18 |
| #define vr19 19 |
| #define vr20 20 |
| #define vr21 21 |
| #define vr22 22 |
| #define vr23 23 |
| #define vr24 24 |
| #define vr25 25 |
| #define vr26 26 |
| #define vr27 27 |
| #define vr28 28 |
| #define vr29 29 |
| #define vr30 30 |
| #define vr31 31 |
| #define evr0 0 |
| #define evr1 1 |
| #define evr2 2 |
| #define evr3 3 |
| #define evr4 4 |
| #define evr5 5 |
| #define evr6 6 |
| #define evr7 7 |
| #define evr8 8 |
| #define evr9 9 |
| #define evr10 10 |
| #define evr11 11 |
| #define evr12 12 |
| #define evr13 13 |
| #define evr14 14 |
| #define evr15 15 |
| #define evr16 16 |
| #define evr17 17 |
| #define evr18 18 |
| #define evr19 19 |
| #define evr20 20 |
| #define evr21 21 |
| #define evr22 22 |
| #define evr23 23 |
| #define evr24 24 |
| #define evr25 25 |
| #define evr26 26 |
| #define evr27 27 |
| #define evr28 28 |
| #define evr29 29 |
| #define evr30 30 |
| #define evr31 31 |
| /* Special Purpose Registers (SPRs) */ |
| #define xer 1 |
| #define lr 8 |
| #define ctr 9 |
| #define dec 22 |
| #define sdr1 25 |
| #define srr0 26 |
| #define srr1 27 |
| #define sprg0 272 |
| #define sprg1 273 |
| #define sprg2 274 |
| #define sprg3 275 |
| #define prv 287 |
| #define ibat0u 528 |
| #define ibat0l 529 |
| #define ibat1u 530 |
| #define ibat1l 531 |
| #define ibat2u 532 |
| #define ibat2l 533 |
| #define ibat3u 534 |
| #define ibat3l 535 |
| #define dbat0u 536 |
| #define dbat0l 537 |
| #define dbat1u 538 |
| #define dbat1l 539 |
| #define dbat2u 540 |
| #define dbat2l 541 |
| #define dbat3u 542 |
| #define dbat3l 543 |
| #define hid0 1008 |
| /* MSR bits */ |
| #define msr_dr (1 << 4) |
| #define msr_ir (1 << 5) |
| #define msr_pr (1 << 14) |
| #define msr_ee (1 << 15) |
| /* HID0 bits */ |
| #define hid0_sten (1 << 24) |
| #define hid0_ice (1 << 15) |
| #define hid0_dce (1 << 14) |
| #define hid0_icfi (1 << 11) |
| #define hid0_dci (1 << 10) |
| #endif |
| /tags/0.4.0/boot/arch/ppc32/loader/asm.S |
|---|
| 0,0 → 1,456 |
| # |
| # Copyright (c) 2006 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 "asm.h" |
| #include "regname.h" |
| .macro SMC_COHERENCY addr |
| dcbst 0, \addr |
| sync |
| icbi 0, \addr |
| sync |
| isync |
| .endm |
| .macro FLUSH_DCACHE addr |
| dcbst 0, \addr |
| sync |
| isync |
| .endm |
| .macro TLB_FLUSH reg |
| tlbie \reg |
| addi \reg, \reg, 0x1000 |
| .endm |
| .text |
| .global halt |
| .global memcpy |
| .global jump_to_kernel |
| halt: |
| b halt |
| memcpy: |
| srwi. r7, r5, 3 |
| addi r6, r3, -4 |
| addi r4, r4, -4 |
| beq 2f |
| andi. r0, r6, 3 |
| mtctr r7 |
| bne 5f |
| 1: |
| lwz r7, 4(r4) |
| lwzu r8, 8(r4) |
| stw r7, 4(r6) |
| stwu r8, 8(r6) |
| bdnz 1b |
| andi. r5, r5, 7 |
| 2: |
| cmplwi 0, r5, 4 |
| blt 3f |
| lwzu r0, 4(r4) |
| addi r5, r5, -4 |
| stwu r0, 4(r6) |
| 3: |
| cmpwi 0, r5, 0 |
| beqlr |
| mtctr r5 |
| addi r4, r4, 3 |
| addi r6, r6, 3 |
| 4: |
| lbzu r0, 1(r4) |
| stbu r0, 1(r6) |
| bdnz 4b |
| blr |
| 5: |
| subfic r0, r0, 4 |
| mtctr r0 |
| 6: |
| lbz r7, 4(r4) |
| addi r4, r4, 1 |
| stb r7, 4(r6) |
| addi r6, r6, 1 |
| bdnz 6b |
| subf r5, r0, r5 |
| rlwinm. r7, r5, 32-3, 3, 31 |
| beq 2b |
| mtctr r7 |
| b 1b |
| jump_to_kernel: |
| # r3 = bootinfo (pa) |
| # r4 = bootinfo_size |
| # r5 = trans (pa) |
| # r6 = bytes to copy |
| # r7 = real_mode (pa) |
| # r8 = framebuffer (pa) |
| # r9 = scanline |
| # disable interrupts |
| mfmsr r31 |
| rlwinm r31, r31, 0, 17, 15 |
| mtmsr r31 |
| # set real_mode meeting point address |
| mtspr srr0, r7 |
| # jumps to real_mode |
| mfmsr r31 |
| lis r30, ~0@h |
| ori r30, r30, ~(msr_ir | msr_dr | msr_ee)@l |
| and r31, r31, r30 |
| mtspr srr1, r31 |
| sync |
| isync |
| rfi |
| .section REALMODE, "ax" |
| .align PAGE_WIDTH |
| .global real_mode |
| real_mode: |
| # copy kernel to proper location |
| # |
| # r5 = trans (pa) |
| # r6 = bytes to copy |
| # r8 = framebuffer (pa) |
| # r9 = scanline |
| li r31, PAGE_SIZE >> 2 |
| li r30, 0 |
| page_copy: |
| cmpwi r6, 0 |
| beq copy_end |
| # copy page |
| mtctr r31 |
| lwz r29, 0(r5) |
| copy_loop: |
| lwz r28, 0(r29) |
| stw r28, 0(r30) |
| SMC_COHERENCY r30 |
| addi r29, r29, 4 |
| addi r30, r30, 4 |
| subi r6, r6, 4 |
| cmpwi r6, 0 |
| beq copy_end |
| bdnz copy_loop |
| addi r5, r5, 4 |
| b page_copy |
| copy_end: |
| # initially fill segment registers |
| li r31, 0 |
| li r29, 8 |
| mtctr r29 |
| li r30, 0 # ASID 0 (VSIDs 0 .. 7) |
| seg_fill_uspace: |
| mtsrin r30, r31 |
| addi r30, r30, 1 |
| addis r31, r31, 0x1000 # move to next SR |
| bdnz seg_fill_uspace |
| li r29, 8 |
| mtctr r29 |
| lis r30, 0x4000 # priviledged access only |
| ori r30, r30, 8 # ASID 0 (VSIDs 8 .. 15) |
| seg_fill_kernel: |
| mtsrin r30, r31 |
| addi r30, r30, 1 |
| addis r31, r31, 0x1000 # move to next SR |
| bdnz seg_fill_kernel |
| # invalidate block address translation registers |
| li r30, 0 |
| mtspr ibat0u, r30 |
| mtspr ibat0l, r30 |
| mtspr ibat1u, r30 |
| mtspr ibat1l, r30 |
| mtspr ibat2u, r30 |
| mtspr ibat2l, r30 |
| mtspr ibat3u, r30 |
| mtspr ibat3l, r30 |
| mtspr dbat0u, r30 |
| mtspr dbat0l, r30 |
| mtspr dbat1u, r30 |
| mtspr dbat1l, r30 |
| mtspr dbat2u, r30 |
| mtspr dbat2l, r30 |
| mtspr dbat3u, r30 |
| mtspr dbat3l, r30 |
| # create empty Page Hash Table |
| # on top of memory, size 64 KB |
| lwz r31, 0(r3) # r31 = memory size |
| lis r30, 65536@h |
| ori r30, r30, 65536@l # r30 = 65536 |
| subi r29, r30, 1 # r29 = 65535 |
| sub r31, r31, r30 |
| andc r31, r31, r29 # pht = ALIGN_DOWN(memory_size - 65536, 65536) |
| mtsdr1 r31 |
| li r29, 2 |
| srw r30, r30, r29 # r30 = 16384 |
| li r29, 0 |
| pht_clear: |
| # write zeroes |
| stw r29, 0(r31) |
| FLUSH_DCACHE r31 |
| addi r31, r31, 4 |
| subi r30, r30, 4 |
| cmpwi r30, 0 |
| beq clear_end |
| bdnz pht_clear |
| clear_end: |
| #ifdef CONFIG_BAT |
| # create BAT identity mapping |
| lwz r31, 0(r3) # r31 = memory size |
| lis r29, 0x0002 |
| cmpw r31, r29 |
| blt no_bat # less than 128 KB -> no BAT |
| li r29, 18 |
| srw r31, r31, r29 # r31 = total >> 18 |
| # create Block Length mask by replicating |
| # the leading logical one 14 times |
| li r29, 14 |
| mtctr r31 |
| li r29, 1 |
| bat_mask: |
| srw r30, r31, r29 # r30 = mask >> 1 |
| or r31, r31, r30 # mask = mask | r30 |
| bdnz bat_mask |
| andi. r31, r31, 0x07ff # mask = mask & 0x07ff (BAT can map up to 256 MB) |
| li r29, 2 |
| slw r31, r31, r29 # mask = mask << 2 |
| ori r31, r31, 0x0002 # mask = mask | 0x0002 (priviledged access only) |
| lis r29, 0x8000 |
| or r29, r29, r31 |
| lis r30, 0x0000 |
| ori r30, r30, 0x0002 |
| mtspr ibat0u, r29 |
| mtspr ibat0l, r30 |
| mtspr dbat0u, r29 |
| mtspr dbat0l, r30 |
| no_bat: |
| #endif |
| # flush TLB |
| li r31, 0 |
| sync |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| TLB_FLUSH r31 |
| eieio |
| tlbsync |
| sync |
| # start the kernel |
| # |
| # pc = KERNEL_START_ADDR |
| # r3 = bootinfo (pa) |
| # sprg0 = KA2PA(KERNEL_START_ADDR) |
| # sprg3 = physical memory size |
| # sp = 0 (pa) |
| lis r31, KERNEL_START_ADDR@ha |
| addi r31, r31, KERNEL_START_ADDR@l |
| mtspr srr0, r31 |
| subis r31, r31, 0x8000 |
| mtsprg0 r31 |
| lwz r31, 0(r3) |
| mtsprg3 r31 |
| li sp, 0 |
| mfmsr r31 |
| ori r31, r31, (msr_ir | msr_dr)@l |
| mtspr srr1, r31 |
| sync |
| isync |
| rfi |
| .align PAGE_WIDTH |
| .global trans |
| trans: |
| .space (TRANS_SIZE * TRANS_ITEM_SIZE) |
| /tags/0.4.0/boot/arch/ppc32/loader/Makefile |
|---|
| 0,0 → 1,153 |
| # |
| # Copyright (c) 2006 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 ../../../../version |
| include ../../../../Makefile.config |
| ## Toolchain configuration |
| # |
| ifndef CROSS_PREFIX |
| CROSS_PREFIX = /usr/local |
| endif |
| BFD_NAME = elf32-powerpc |
| BFD_ARCH = powerpc:common |
| TARGET = ppc-linux-gnu |
| TOOLCHAIN_DIR = $(CROSS_PREFIX)/ppc/bin |
| ifeq ($(COMPILER),gcc_native) |
| CC = gcc |
| AS = as |
| LD = ld |
| OBJCOPY = objcopy |
| OBJDUMP = objdump |
| endif |
| ifeq ($(COMPILER),gcc_cross) |
| CC = $(TOOLCHAIN_DIR)/$(TARGET)-gcc |
| AS = $(TOOLCHAIN_DIR)/$(TARGET)-as |
| LD = $(TOOLCHAIN_DIR)/$(TARGET)-ld |
| OBJCOPY = $(TOOLCHAIN_DIR)/$(TARGET)-objcopy |
| OBJDUMP = $(TOOLCHAIN_DIR)/$(TARGET)-objdump |
| endif |
| CFLAGS = -DRELEASE=\"$(RELEASE)\" -I. -I../../../generic -I../../../genarch -nostdinc -nostdlib -fno-builtin -Werror-implicit-function-declaration -Wmissing-prototypes -Werror -O3 -mcpu=powerpc -msoft-float -m32 -pipe |
| ifdef REVISION |
| CFLAGS += "-DREVISION=\"$(REVISION)\"" |
| endif |
| ifdef TIMESTAMP |
| CFLAGS += "-DTIMESTAMP=\"$(TIMESTAMP)\"" |
| endif |
| SOURCES = \ |
| main.c \ |
| ofwarch.c \ |
| _components.c \ |
| ../../../genarch/ofw.c \ |
| ../../../generic/printf.c \ |
| asm.S \ |
| boot.S |
| COMPONENTS = \ |
| $(KERNELDIR)/kernel.bin \ |
| $(USPACEDIR)/srv/ns/ns \ |
| $(USPACEDIR)/srv/loader/loader \ |
| $(USPACEDIR)/app/init/init \ |
| $(USPACEDIR)/srv/devmap/devmap \ |
| $(USPACEDIR)/srv/rd/rd \ |
| $(USPACEDIR)/srv/vfs/vfs |
| ifeq ($(RDFMT),tmpfs) |
| COMPONENTS += $(USPACEDIR)/srv/fs/tmpfs/tmpfs |
| endif |
| ifeq ($(RDFMT),fat) |
| COMPONENTS += $(USPACEDIR)/srv/fs/fat/fat |
| endif |
| RD_SRVS = \ |
| $(USPACEDIR)/srv/fb/fb \ |
| $(USPACEDIR)/srv/kbd/kbd \ |
| $(USPACEDIR)/srv/console/console \ |
| $(USPACEDIR)/srv/fs/tmpfs/tmpfs \ |
| $(USPACEDIR)/srv/fs/fat/fat |
| RD_APPS = \ |
| $(USPACEDIR)/app/tetris/tetris \ |
| $(USPACEDIR)/app/tester/tester \ |
| $(USPACEDIR)/app/trace/trace \ |
| $(USPACEDIR)/app/klog/klog \ |
| $(USPACEDIR)/app/bdsh/bdsh |
| OBJECTS := $(addsuffix .o,$(basename $(SOURCES))) |
| COMPONENT_OBJECTS := $(addsuffix .o,$(basename $(notdir $(COMPONENTS)))) |
| .PHONY: all clean depend |
| all: image.boot |
| -include Makefile.depend |
| image.boot: depend _components.h _link.ld $(COMPONENT_OBJECTS) initrd.o $(OBJECTS) |
| $(LD) -no-check-sections -N -T _link.ld $(COMPONENT_OBJECTS) initrd.o $(OBJECTS) -o $@ |
| depend: |
| -makedepend -f - -- $(DEFS) $(CFLAGS) -- $(SOURCES) > Makefile.depend 2> /dev/null |
| clean: |
| -for file in $(RD_SRVS) ; do \ |
| rm -f $(USPACEDIR)/dist/srv/`basename $$file` ; \ |
| done |
| -for file in $(RD_APPS) ; do \ |
| rm -f $(USPACEDIR)/dist/app/`basename $$file` ; \ |
| done |
| -rm -f _components.h _components.c _link.ld $(COMPONENT_OBJECTS) initrd.o $(OBJECTS) initrd.img image.boot Makefile.depend |
| _components.h _components.c _link.ld $(COMPONENT_OBJECTS) initrd.o: $(COMPONENTS) $(RD_SRVS) $(RD_APPS) _link.ld.in |
| for file in $(RD_SRVS) ; do \ |
| cp $$file $(USPACEDIR)/dist/srv/ ; \ |
| done |
| for file in $(RD_APPS) ; do \ |
| cp $$file $(USPACEDIR)/dist/app/ ; \ |
| done |
| ifeq ($(RDFMT),tmpfs) |
| ../../../../tools/mktmpfs.py $(USPACEDIR)/dist/ initrd.fs |
| endif |
| ifeq ($(RDFMT),fat) |
| ../../../../tools/mkfat.py $(USPACEDIR)/dist/ initrd.fs |
| endif |
| ../../../../tools/mkhord.py 4096 initrd.fs initrd.img |
| rm initrd.fs |
| ../../../tools/pack.py $(OBJCOPY) $(BFD_NAME) $(BFD_ARCH) 4096 "unsigned int" $(COMPONENTS) ./initrd.img |
| %.o: %.S |
| $(CC) $(DEFS) $(CFLAGS) -D__ASM__ -c $< -o $@ |
| %.o: %.c |
| $(CC) $(DEFS) $(CFLAGS) -c $< -o $@ |
| /tags/0.4.0/boot/arch/ppc32/loader/main.h |
|---|
| 0,0 → 1,58 |
| /* |
| * 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 BOOT_ppc32_MAIN_H_ |
| #define BOOT_ppc32_MAIN_H_ |
| #include "ofw.h" |
| #define TASKMAP_MAX_RECORDS 32 |
| typedef struct { |
| void *addr; |
| unsigned int size; |
| } task_t; |
| typedef struct { |
| unsigned int count; |
| task_t tasks[TASKMAP_MAX_RECORDS]; |
| } taskmap_t; |
| typedef struct { |
| memmap_t memmap; |
| taskmap_t taskmap; |
| screen_t screen; |
| macio_t macio; |
| } bootinfo_t; |
| extern void start(void); |
| extern void bootstrap(void); |
| extern memmap_t memmap; |
| #endif |
| /tags/0.4.0/boot/arch/ppc32/loader/ofwarch.c |
|---|
| 0,0 → 1,75 |
| /* |
| * 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 <ofwarch.h> |
| #include <ofw.h> |
| #include <printf.h> |
| typedef int (* ofw_entry_t)(ofw_args_t *args); |
| int ofw(ofw_args_t *args) |
| { |
| return ((ofw_entry_t) ofw_cif)(args); |
| } |
| void write(const char *str, const int len) |
| { |
| int i; |
| for (i = 0; i < len; i++) { |
| if (str[i] == '\n') |
| ofw_write("\r", 1); |
| ofw_write(&str[i], 1); |
| } |
| } |
| int ofw_macio(macio_t *macio) |
| { |
| char device_name[BUF_SIZE]; |
| if (ofw_get_property(ofw_aliases, "macio", device_name, sizeof(device_name)) <= 0) |
| return false; |
| phandle device = ofw_find_device(device_name); |
| if (device == -1) |
| return false; |
| pci_reg_t pci_reg; |
| if (ofw_get_property(device, "assigned-addresses", &pci_reg, sizeof(pci_reg)) <= 0) |
| return false; |
| macio->addr = (void *) pci_reg.addr.addr_lo; |
| macio->size = pci_reg.size_lo; |
| return true; |
| } |
| int ofw_translate_failed(ofw_arg_t flag) |
| { |
| return 0; |
| } |
| /tags/0.4.0/boot/arch/ppc32/loader/_link.ld.in |
|---|
| 0,0 → 1,21 |
| OUTPUT_FORMAT("elf32-powerpc") |
| OUTPUT_ARCH(powerpc:common) |
| ENTRY(start) |
| SECTIONS { |
| .boot 0x01000000: AT (0) { |
| *(BOOTSTRAP); |
| *(REALMODE); |
| *(.text); |
| *(.rodata); |
| *(.rodata.*); |
| *(.data); /* initialized data */ |
| *(.sdata); |
| *(.sdata2); |
| *(.sbss); |
| *(.bss); /* uninitialized static variables */ |
| *(COMMON); /* global variables */ |
| [[COMPONENTS]] |
| } |
| } |
| /tags/0.4.0/boot/arch/ppc32/loader/ofwarch.h |
|---|
| 0,0 → 1,35 |
| /* |
| * Copyright (c) 2006 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 BOOT_ppc32_OFWARCH_H_ |
| #define BOOT_ppc32_OFWARCH_H_ |
| #define OFW_ADDRESS_CELLS 1 |
| #define OFW_SIZE_CELLS 1 |
| #endif |
| /tags/0.4.0/boot/arch/ppc32/loader/boot.S |
|---|
| 0,0 → 1,42 |
| # |
| # Copyright (c) 2006 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 "regname.h" |
| .section BOOTSTRAP, "ax" |
| .global start |
| start: |
| lis r4, ofw_cif@ha |
| addi r4, r4, ofw_cif@l |
| stw r5, 0(r4) |
| bl ofw_init |
| b bootstrap |
| /tags/0.4.0/boot/arch/ppc32/loader/asm.h |
|---|
| 0,0 → 1,52 |
| /* |
| * Copyright (c) 2006 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 BOOT_ppc32_ASM_H_ |
| #define BOOT_ppc32_ASM_H_ |
| #define PAGE_SIZE 4096 |
| #define PAGE_WIDTH 12 |
| #define TRANS_SIZE 1024 |
| #define TRANS_ITEM_SIZE 4 |
| #define KERNEL_START_ADDR 0x80008000 |
| #ifndef __ASM__ |
| #define memcpy(dst, src, cnt) __builtin_memcpy((dst), (src), (cnt)) |
| extern void *trans[TRANS_SIZE]; |
| extern void halt(); |
| extern void jump_to_kernel(void *bootinfo, unsigned int bootinfo_size, void *trans, unsigned int kernel_size, void *real_mode, void *fb, unsigned int scanline) __attribute__((noreturn)); |
| extern void real_mode(); |
| #endif |
| #endif |
| /tags/0.4.0/boot/arch/ppc32/loader/types.h |
|---|
| 0,0 → 1,44 |
| /* |
| * Copyright (c) 2006 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 BOOT_ppc32_TYPES_H_ |
| #define BOOT_ppc32_TYPES_H_ |
| #include <gentypes.h> |
| typedef signed char int8_t; |
| typedef unsigned char uint8_t; |
| typedef unsigned short uint16_t; |
| typedef unsigned int uint32_t; |
| typedef unsigned long long uint64_t; |
| typedef uint32_t uintptr_t; |
| typedef uint32_t unative_t; |
| #endif |
| /tags/0.4.0/boot/arch/ppc32/Makefile.inc |
|---|
| 0,0 → 1,42 |
| # |
| # Copyright (c) 2006 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. |
| # |
| build: $(BASE)/image.boot |
| $(BASE)/image.boot: depend arch/$(ARCH)/loader/image.boot |
| cp arch/$(ARCH)/loader/image.boot $(BASE)/image.boot |
| depend: |
| -rm arch/$(ARCH)/loader/image.boot |
| arch/$(ARCH)/loader/image.boot: |
| make -C arch/$(ARCH)/loader COMPILER=$(COMPILER) KERNELDIR=../../../$(KERNELDIR) USPACEDIR=../../../$(USPACEDIR) "DEFS=$(DEFS)" |
| clean: generic_clean |
| make -C arch/$(ARCH)/loader clean COMPILER=$(COMPILER) KERNELDIR=../../../$(KERNELDIR) USPACEDIR=../../../$(USPACEDIR) "DEFS=$(DEFS)" |
| -rm -f $(BASE)/image.boot |
| /tags/0.4.0/boot/arch/ia64/loader/Makefile |
|---|
| 0,0 → 1,177 |
| # |
| # Copyright (c) 2006 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 ../../../../version |
| include ../../../../Makefile.config |
| ## Toolchain configuration |
| # |
| ifndef CROSS_PREFIX |
| CROSS_PREFIX = /usr/local |
| endif |
| BFD_NAME = elf64-ia64-little |
| BFD_ARCH = ia64 |
| TARGET = ia64-pc-linux-gnu |
| TOOLCHAIN_DIR = $(CROSS_PREFIX)/ia64/bin |
| ifeq ($(COMPILER),gcc_native) |
| CC = gcc |
| AS = as |
| LD = ld |
| OBJCOPY = objcopy |
| OBJDUMP = objdump |
| GEFI_PREXIX = |
| endif |
| ifeq ($(COMPILER),icc_native) |
| CC = icc |
| AS = as |
| LD = ld |
| OBJCOPY = objcopy |
| OBJDUMP = objdump |
| endif |
| ifeq ($(COMPILER),gcc_cross) |
| CC = $(TOOLCHAIN_DIR)/$(TARGET)-gcc |
| AS = $(TOOLCHAIN_DIR)/$(TARGET)-as |
| LD = $(TOOLCHAIN_DIR)/$(TARGET)-ld |
| OBJCOPY = $(TOOLCHAIN_DIR)/$(TARGET)-objcopy |
| OBJDUMP = $(TOOLCHAIN_DIR)/$(TARGET)-objdump |
| GEFI_PREFIX = $(TOOLCHAIN_DIR)/$(TARGET)- |
| endif |
| #-mno-pic means do not use gp + imm22 to address data |
| CFLAGS = -DRELEASE=\"$(RELEASE)\" -I. -I../../../generic -I../../../genarch -I../../../../kernel/generic/include -nostdinc -nostdlib -fno-builtin -Werror-implicit-function-declaration -Wmissing-prototypes -Werror -O3 -fno-unwind-tables -mfixed-range=f32-f127 -mno-pic -pipe |
| ifdef REVISION |
| CFLAGS += "-DREVISION=\"$(REVISION)\"" |
| endif |
| ifdef TIMESTAMP |
| CFLAGS += "-DTIMESTAMP=\"$(TIMESTAMP)\"" |
| endif |
| SOURCES = \ |
| main.c \ |
| ../../../generic/printf.c \ |
| ../../../generic/string.c \ |
| ../../../genarch/balloc.c \ |
| _components.c \ |
| asm.S \ |
| boot.S |
| NOCOMPONENTS = \ |
| $(KERNELDIR)/kernel.bin |
| COMPONENTS = \ |
| $(KERNELDIR)/kernel.bin \ |
| $(USPACEDIR)/srv/ns/ns \ |
| $(USPACEDIR)/srv/loader/loader \ |
| $(USPACEDIR)/app/init/init \ |
| $(USPACEDIR)/srv/devmap/devmap \ |
| $(USPACEDIR)/srv/rd/rd \ |
| $(USPACEDIR)/srv/vfs/vfs |
| ifeq ($(RDFMT),tmpfs) |
| COMPONENTS += $(USPACEDIR)/srv/fs/tmpfs/tmpfs |
| endif |
| ifeq ($(RDFMT),fat) |
| COMPONENTS += $(USPACEDIR)/srv/fs/fat/fat |
| endif |
| RD_SRVS = \ |
| $(USPACEDIR)/srv/fb/fb \ |
| $(USPACEDIR)/srv/kbd/kbd \ |
| $(USPACEDIR)/srv/console/console \ |
| $(USPACEDIR)/srv/fs/tmpfs/tmpfs \ |
| $(USPACEDIR)/srv/fs/fat/fat |
| RD_APPS = \ |
| $(USPACEDIR)/app/tetris/tetris \ |
| $(USPACEDIR)/app/tester/tester \ |
| $(USPACEDIR)/app/trace/trace \ |
| $(USPACEDIR)/app/klog/klog \ |
| $(USPACEDIR)/app/bdsh/bdsh |
| OBJECTS := $(addsuffix .o,$(basename $(SOURCES))) |
| COMPONENT_OBJECTS := $(addsuffix .o,$(basename $(notdir $(COMPONENTS)))) |
| .PHONY: all clean depend |
| all: hello.efi disasm |
| -include Makefile.depend |
| hello.efi: image.boot |
| make -C gefi/HelenOS PREFIX=$(GEFI_PREFIX) |
| cp gefi/HelenOS/hello.efi ../../../../ |
| # cp gefi/HelenOS/hello.efi /boot/efi/ |
| cp gefi/HelenOS/image.bin ../../../../ |
| image.boot: depend _components.h _link.ld $(COMPONENT_OBJECTS) initrd.o $(OBJECTS) |
| $(LD) -Map image.map -no-check-sections -N -T _link.ld $(COMPONENT_OBJECTS) initrd.o $(OBJECTS) -o $@ |
| depend: |
| -makedepend -f - -- $(DEFS) $(CFLAGS) -- $(SOURCES) > Makefile.depend 2> /dev/null |
| clean: |
| -for file in $(RD_SRVS) ; do \ |
| rm -f $(USPACEDIR)/dist/srv/`basename $$file` ; \ |
| done |
| -for file in $(RD_APPS) ; do \ |
| rm -f $(USPACEDIR)/dist/app/`basename $$file` ; \ |
| done |
| -rm -f _components.h _components.c _link.ld $(COMPONENT_OBJECTS) initrd.o $(OBJECTS) image.boot image.map image.disasm initrd.img image.boot Makefile.depend ../../../../image.bin ../../../../hello.efi |
| make -C gefi clean |
| make -C gefi/HelenOS clean |
| _components.h _components.c _link.ld $(COMPONENT_OBJECTS) initrd.o: $(COMPONENTS) $(RD_SRVS) $(RD_APPS) _link.ld.in |
| for file in $(RD_SRVS) ; do \ |
| cp $$file $(USPACEDIR)/dist/srv/ ; \ |
| done |
| for file in $(RD_APPS) ; do \ |
| cp $$file $(USPACEDIR)/dist/app/ ; \ |
| done |
| ifeq ($(RDFMT),tmpfs) |
| ../../../../tools/mktmpfs.py $(USPACEDIR)/dist/ initrd.fs |
| endif |
| ifeq ($(RDFMT),fat) |
| ../../../../tools/mkfat.py $(USPACEDIR)/dist/ initrd.fs |
| endif |
| ../../../../tools/mkhord.py 16384 initrd.fs initrd.img |
| rm initrd.fs |
| ../../../tools/pack.py $(OBJCOPY) $(BFD_NAME) $(BFD_ARCH) 16384 "unsigned long" $(COMPONENTS) ./initrd.img |
| %.o: %.S |
| $(CC) $(DEFS) $(CFLAGS) -D__ASM__ -c $< -o $@ |
| %.o: %.c |
| $(CC) $(DEFS) $(CFLAGS) -c $< -o $@ |
| disasm: image.boot |
| $(OBJDUMP) -d image.boot > image.disasm |
| /tags/0.4.0/boot/arch/ia64/loader/main.c |
|---|
| 0,0 → 1,132 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * Copyright (c) 2006 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.h" |
| #include <printf.h> |
| #include "asm.h" |
| #include "_components.h" |
| #include <align.h> |
| #include <balloc.h> |
| extern bootinfo_t binfo; |
| component_t components[COMPONENTS]; |
| char *release = RELEASE; |
| void write(const char *str, const int len) |
| { |
| return; |
| } |
| #define DEFAULT_MEMORY_BASE 0x4000000 |
| #define DEFAULT_MEMORY_SIZE 0x4000000 |
| #define DEFAULT_LEGACY_IO_BASE 0x00000FFFFC000000 |
| #define DEFAULT_LEGACY_IO_SIZE 0x4000000 |
| #define DEFAULT_FREQ_SCALE 0x0000000100000001 /* 1/1 */ |
| #define DEFAULT_SYS_FREQ 100000000 /* 100MHz */ |
| #ifdef REVISION |
| char *revision = ", revision " REVISION; |
| #else |
| char *revision = ""; |
| #endif |
| #ifdef TIMESTAMP |
| char *timestamp = "\nBuilt on " TIMESTAMP; |
| #else |
| char *timestamp = ""; |
| #endif |
| /** Print version information. */ |
| static void version_print(void) |
| { |
| printf("HelenOS IA64 Bootloader\nRelease %s%s%s\n" |
| "Copyright (c) 2006 HelenOS project\n", release, revision, |
| timestamp); |
| } |
| void bootstrap(void) |
| { |
| int ii; |
| bootinfo_t *bootinfo = &binfo; |
| version_print(); |
| init_components(components); |
| printf("\nSystem info\n"); |
| printf("\nMemory statistics\n"); |
| printf(" %P: boot info structure\n", &bootinfo); |
| unsigned int i; |
| for (i = 0; i < COMPONENTS; i++) |
| printf(" %P: %s image (size %d bytes)\n", components[i].start, |
| components[i].name, components[i].size); |
| if (!bootinfo->hello_configured) { |
| /* |
| * Load configuration defaults for simulators. |
| */ |
| bootinfo->memmap_items = 0; |
| bootinfo->memmap[bootinfo->memmap_items].base = |
| DEFAULT_MEMORY_BASE; |
| bootinfo->memmap[bootinfo->memmap_items].size = |
| DEFAULT_MEMORY_SIZE; |
| bootinfo->memmap[bootinfo->memmap_items].type = |
| EFI_MEMMAP_FREE_MEM; |
| bootinfo->memmap_items++; |
| bootinfo->memmap[bootinfo->memmap_items].base = |
| DEFAULT_LEGACY_IO_BASE; |
| bootinfo->memmap[bootinfo->memmap_items].size = |
| DEFAULT_LEGACY_IO_SIZE; |
| bootinfo->memmap[bootinfo->memmap_items].type = |
| EFI_MEMMAP_IO_PORTS; |
| bootinfo->memmap_items++; |
| bootinfo->freq_scale = DEFAULT_FREQ_SCALE; |
| bootinfo->sys_freq = DEFAULT_SYS_FREQ; |
| } |
| bootinfo->taskmap.count = 0; |
| for (i = 0; i < COMPONENTS; i++) { |
| if (i > 0) { |
| bootinfo->taskmap.tasks[bootinfo->taskmap.count].addr = |
| components[i].start; |
| bootinfo->taskmap.tasks[bootinfo->taskmap.count].size = |
| components[i].size; |
| bootinfo->taskmap.count++; |
| } |
| } |
| jump_to_kernel(bootinfo); |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/_link.ld.in |
|---|
| 0,0 → 1,29 |
| OUTPUT_FORMAT("elf64-ia64-little") |
| ENTRY(start) |
| SECTIONS { |
| .boot 0x4400000: AT (0x4400000) { |
| *(BOOTSTRAP); |
| [[COMPONENTS]] |
| . = ALIGN (16384); |
| *(.text); |
| *(.rodata); |
| *(.rodata.*); |
| *(.data); /* initialized data */ |
| _got = . ; |
| *(.got .got.*); |
| *(.bss); /* uninitialized static variables */ |
| *(COMMON); |
| } |
| .sboot : { |
| *(.sdata); |
| *(.sdata2); |
| *(.sbss); |
| } |
| /DISCARD/ : { |
| *(.comment); |
| *(.note*); |
| } |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/Makefile |
|---|
| 0,0 → 1,51 |
| # |
| # Copyright (C) 1999-2001 Hewlett-Packard Co. |
| # Contributed by David Mosberger <davidm@hpl.hp.com> |
| # Contributed by Stephane Eranian <eranian@hpl.hp.com> |
| # |
| # This file is part of the gnu-efi package. |
| # |
| # GNU-EFI is free software; you can redistribute it and/or modify |
| # it under the terms of the GNU General Public License as published by |
| # the Free Software Foundation; either version 2, or (at your option) |
| # any later version. |
| # |
| # GNU-EFI is distributed in the hope that it will be useful, |
| # but WITHOUT ANY WARRANTY; without even the implied warranty of |
| # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| # GNU General Public License for more details. |
| # |
| # You should have received a copy of the GNU General Public License |
| # along with GNU-EFI; see the file COPYING. If not, write to the Free |
| # Software Foundation, 59 Temple Place - Suite 330, Boston, MA |
| # 02111-1307, USA. |
| # |
| include Make.defaults |
| SUBDIRS = lib gnuefi inc |
| all: check_gcc $(SUBDIRS) |
| $(SUBDIRS): |
| $(MAKE) -C $@ |
| clean: |
| rm -f *~ |
| @for d in $(SUBDIRS); do $(MAKE) -C $$d clean; done |
| install: |
| @for d in $(SUBDIRS); do $(MAKE) -C $$d install; done |
| .PHONY: $(SUBDIRS) clean depend |
| # |
| # on both platforms you must use gcc 3.0 or higher |
| # |
| check_gcc: |
| ifeq ($(GCC_VERSION),2) |
| @echo "you need to use a version of gcc >= 3.0, you are using `$(CC) --version`" |
| @exit 1 |
| endif |
| include Make.rules |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/HelenOS/hello.c |
|---|
| 0,0 → 1,310 |
| #include <efi.h> |
| #include <efilib.h> |
| #include <../../../../../../kernel/arch/ia64/include/bootinfo.h> |
| #define KERNEL_LOAD_ADDRESS 0x4400000 |
| #define MEM_MAP_DESCRIPTOR_OFFSET_TYPE 0 |
| #define MEM_MAP_DESCRIPTOR_OFFSET_BASE 8 |
| #define MEM_MAP_DESCRIPTOR_OFFSET_PAGES 24 |
| //Link image as a data array into hello - usefull with network boot |
| //#define IMAGE_LINKED |
| bootinfo_t *bootinfo=(bootinfo_t *)BOOTINFO_ADDRESS; |
| #ifdef IMAGE_LINKED |
| extern char HOSimage[]; |
| extern int HOSimagesize; |
| #endif |
| static CHAR16 * |
| a2u (char *str) |
| { |
| static CHAR16 mem[2048]; |
| int i; |
| for (i = 0; str[i]; ++i) |
| mem[i] = (CHAR16) str[i]; |
| mem[i] = 0; |
| return mem; |
| } |
| EFI_STATUS |
| efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab) |
| { |
| SIMPLE_TEXT_OUTPUT_INTERFACE *conout; |
| EFI_INPUT_KEY efi_input_key; |
| EFI_STATUS efi_status; |
| InitializeLib(image, systab); |
| Print(L"HelloLib application started\n"); |
| EFI_GUID LoadedImageProtocol=LOADED_IMAGE_PROTOCOL; |
| EFI_GUID DevicePathProtocol=DEVICE_PATH_PROTOCOL; |
| EFI_GUID FileSystemProtocol=SIMPLE_FILE_SYSTEM_PROTOCOL; |
| EFI_LOADED_IMAGE *LoadedImage; |
| EFI_DEVICE_PATH *DevicePath; |
| BS->HandleProtocol(image, |
| &LoadedImageProtocol, |
| &LoadedImage); |
| BS->HandleProtocol(LoadedImage->DeviceHandle, |
| &DevicePathProtocol, |
| &DevicePath); |
| Print (L"Image device : %s\n", DevicePathToStr (DevicePath)); |
| Print (L"Image file : %s\n", DevicePathToStr (LoadedImage->FilePath)); |
| Print (L"Image Base : %X\n", LoadedImage->ImageBase); |
| Print (L"Image Size : %X\n", LoadedImage->ImageSize); |
| EFI_FILE_IO_INTERFACE *Vol; |
| EFI_FILE *CurDir; |
| EFI_FILE *FileHandle; |
| BS->HandleProtocol(LoadedImage->DeviceHandle, &FileSystemProtocol, &Vol); |
| char FileName[1024]; |
| char *OsKernelBuffer; |
| int i; |
| int defaultLoad; |
| int imageLoad; |
| UINTN Size; |
| StrCpy(FileName,DevicePathToStr(LoadedImage->FilePath)); |
| for(i=StrLen(FileName);i>=0 && FileName[i]!='\\';i--); |
| FileName[i] = 0; |
| FileName[0] = 0; |
| Print(L"%s\n",LoadedImage->LoadOptions); |
| i=0; |
| CHAR16 *LoadOptions = LoadedImage->LoadOptions; |
| while(1) if(LoadOptions[i++]!=L' ') break; |
| while(LoadOptions[i]!=L' '){ |
| if(LoadOptions[i]==0) break; |
| i++; |
| } |
| while(LoadOptions[i]==L' ') if(LoadOptions[i++]==0) break; |
| if(LoadOptions[i++]==0){ |
| StrCat(FileName,L"\\image.bin"); |
| defaultLoad=1; |
| } |
| /* else{ |
| CHAR16 buf[1024]; |
| //buf[0]='\\'; |
| i--; |
| int j; |
| for(j=0;LoadOptions[i+j]!=L' '&&LoadOptions[i+j]!=0;j++) |
| buf[j+1]=LoadOptions[i+j]; |
| buf[j+1]=0; |
| StrCat(FileName,buf); |
| defaultLoad=0; |
| }*/ |
| else{ |
| CHAR16 buf[1024]; |
| //buf[0]='\\'; |
| i--; |
| int j; |
| for(j=0;LoadOptions[i+j]!=L' '&&LoadOptions[i+j]!=0;j++) |
| buf[j]=LoadOptions[i+j]; |
| buf[j+1]=0; |
| StrCat(FileName,buf); |
| defaultLoad=0; |
| } |
| imageLoad=1; |
| #ifdef IMAGE_LINKED |
| if(defaultLoad) { |
| Print(L"Using Linked Image\n"); |
| imageLoad=0; |
| } |
| #endif |
| char * HOS; |
| if(imageLoad) |
| { |
| Size = 0x00400000; |
| Vol->OpenVolume (Vol, &CurDir); |
| EFI_STATUS stat; |
| stat=CurDir->Open(CurDir, &FileHandle, FileName, EFI_FILE_MODE_READ, 0); |
| if(EFI_ERROR(stat)){ |
| Print(L"Error Opening Image %s\n",FileName); |
| return 0; |
| } |
| BS->AllocatePool(EfiLoaderData, Size, &OsKernelBuffer); |
| FileHandle->Read(FileHandle, &Size, OsKernelBuffer); |
| FileHandle->Close(FileHandle); |
| HOS = OsKernelBuffer; |
| if(Size<1) return 0; |
| } |
| #ifdef IMAGE_LINKED |
| else { |
| HOS = HOSimage; |
| Size = HOSimagesize; |
| Print(L"Image start %llX\n",(long long)HOS); |
| Print(L"Image size %llX\n",(long long)Size); |
| Print(L"Image &size %llX\n",(long long)&Size); |
| } |
| #endif |
| int HOSSize = Size; |
| rArg rSAL; |
| rArg rPAL; |
| //Setup AP's wake up address |
| LibSalProc(0x01000000,2,0x4400200,0,0,0,0,0,&rSAL); |
| //Get System Frequency |
| UINT64 sys_freq; |
| LibSalProc(0x01000012,0,0,0,0,0,0,0,&rSAL); |
| sys_freq=rSAL.p1; |
| UINT64 freq_scale; |
| //Get CPU Frequency to System Frequency ratio |
| LibPalProc(14,0,0,0,&rPAL); |
| freq_scale=rPAL.p1; |
| UINT64 sapic; |
| LibGetSalIpiBlock(&sapic); |
| Print (L"SAPIC:%X\n", sapic); |
| //bootinfo->sapic=sapic; |
| UINT64 wakeup_intno; |
| LibGetSalWakeupVector(&wakeup_intno); |
| Print (L"WAKEUP INTNO:%X\n", wakeup_intno); |
| UINTN cookie; |
| void *p=(void *)KERNEL_LOAD_ADDRESS; |
| UINTN mapsize,descsize; |
| UINT32 desver; |
| EFI_STATUS status; |
| status=BS->AllocatePages(AllocateAnyPages,EfiLoaderData,/*(HOSSize>>12)+1*/ 1,p); |
| if(EFI_ERROR(status)){ |
| Print(L"Error 0\n"); |
| if(status == EFI_OUT_OF_RESOURCES) Print(L"EFI_OUT_OF_RESOURCES\n"); |
| if(status == EFI_INVALID_PARAMETER) Print(L"EFI_INVALID_PARAMETER\n"); |
| if(status == EFI_NOT_FOUND) Print(L"EFI_NOT_FOUND\n"); |
| return EFI_SUCCESS; |
| } |
| UINTN no_entryes; |
| void * mds; |
| mds=LibMemoryMap(&no_entryes,&cookie,&descsize,&desver); |
| for(i=0;i<no_entryes;i++) |
| { |
| unsigned int type=*((unsigned int *)(mds+i*descsize+MEM_MAP_DESCRIPTOR_OFFSET_TYPE)); |
| unsigned long long base=*((unsigned long long *)(mds+i*descsize+MEM_MAP_DESCRIPTOR_OFFSET_BASE)); |
| unsigned long long pages=*((unsigned long long *)(mds+i*descsize+MEM_MAP_DESCRIPTOR_OFFSET_PAGES)); |
| Print(L"T:%02d %016llX %016llX\n",type,base,pages*EFI_PAGE_SIZE); |
| } |
| status=BS->ExitBootServices(image,cookie); |
| if(EFI_ERROR(status)){ |
| Print(L"Error 2\n"); |
| return EFI_SUCCESS; |
| } |
| int a; |
| for(a=0;a<HOSSize;a++){ |
| ((char *)(0x4400000))[a]=HOS[a]; |
| } |
| bootinfo->sapic=(unsigned long *)sapic; |
| bootinfo->wakeup_intno=wakeup_intno; |
| bootinfo->sys_freq=sys_freq; |
| bootinfo->freq_scale=freq_scale; |
| bootinfo->hello_configured=1; |
| bootinfo->memmap_items=0; |
| for(i=0;i<no_entryes;i++) |
| { |
| unsigned int type=*((unsigned int *)(mds+i*descsize+MEM_MAP_DESCRIPTOR_OFFSET_TYPE)); |
| unsigned long long base=*((unsigned long long *)(mds+i*descsize+MEM_MAP_DESCRIPTOR_OFFSET_BASE)); |
| unsigned long long pages=*((unsigned long long *)(mds+i*descsize+MEM_MAP_DESCRIPTOR_OFFSET_PAGES)); |
| switch (type) |
| { |
| case EfiConventionalMemory: |
| bootinfo->memmap[bootinfo->memmap_items].type=EFI_MEMMAP_FREE_MEM; |
| bootinfo->memmap[bootinfo->memmap_items].base=base; |
| bootinfo->memmap[bootinfo->memmap_items].size=pages*EFI_PAGE_SIZE; |
| bootinfo->memmap_items++; |
| break; |
| case EfiMemoryMappedIO: |
| bootinfo->memmap[bootinfo->memmap_items].type=EFI_MEMMAP_IO; |
| bootinfo->memmap[bootinfo->memmap_items].base=base; |
| bootinfo->memmap[bootinfo->memmap_items].size=pages*EFI_PAGE_SIZE; |
| bootinfo->memmap_items++; |
| break; |
| case EfiMemoryMappedIOPortSpace: |
| bootinfo->memmap[bootinfo->memmap_items].type=EFI_MEMMAP_IO_PORTS; |
| bootinfo->memmap[bootinfo->memmap_items].base=base; |
| bootinfo->memmap[bootinfo->memmap_items].size=pages*EFI_PAGE_SIZE; |
| bootinfo->memmap_items++; |
| break; |
| default : |
| break; |
| } |
| } |
| //Run Kernel |
| asm volatile( |
| "nop.i 0x00 ;;\n" |
| "movl r15 = 0x4400000 ;;\n" |
| "mov b0 = r15;;" |
| "br.few b0;;\n" |
| ); |
| //Not reached |
| return EFI_SUCCESS; |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/HelenOS/Makefile |
|---|
| 0,0 → 1,77 |
| # |
| # Copyright (C) 1999-2001 Hewlett-Packard Co. |
| # Contributed by David Mosberger <davidm@hpl.hp.com> |
| # Contributed by Stephane Eranian <eranian@hpl.hp.com> |
| # |
| # This file is part of the gnu-efi package. |
| # |
| # GNU-EFI is free software; you can redistribute it and/or modify |
| # it under the terms of the GNU General Public License as published by |
| # the Free Software Foundation; either version 2, or (at your option) |
| # any later version. |
| # |
| # GNU-EFI is distributed in the hope that it will be useful, |
| # but WITHOUT ANY WARRANTY; without even the implied warranty of |
| # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| # GNU General Public License for more details. |
| # |
| # You should have received a copy of the GNU General Public License |
| # along with GNU-EFI; see the file COPYING. If not, write to the Free |
| # Software Foundation, 59 Temple Place - Suite 330, Boston, MA |
| # 02111-1307, USA. |
| # |
| prefix=$(PREFIX) |
| include ../Make.defaults |
| CDIR=$(TOPDIR)/.. |
| LINUX_HEADERS = /usr/src/sys/build |
| CPPFLAGS += -D__KERNEL__ -I$(LINUX_HEADERS)/include |
| CRTOBJS = ../gnuefi/crt0-efi-$(ARCH).o |
| LDSCRIPT = ../gnuefi/elf_$(ARCH)_efi.lds |
| LDFLAGS += -T $(LDSCRIPT) -shared -Bsymbolic -L../lib -L../gnuefi $(CRTOBJS) |
| #LOADLIBES = -lefi -lgnuefi $(shell $(CC) -print-libgcc-file-name) |
| LOADLIBES = -lefi -lgnuefi |
| FORMAT = efi-app-$(ARCH) |
| all: gefi hello.efi |
| clean: |
| rm -f *.efi *~ *.o *.so *.map *.disass *.bin |
| .PHONY: install |
| hello.efi: hello.so |
| $(OBJCOPY) -j .text -j .sdata -j .data -j .dynamic -j .dynsym -j .rel \ |
| -j .rela -j .reloc --target=$(FORMAT) hello.so hello.efi |
| $(OBJDUMP) -d hello.efi > hello.disass |
| #When selected first lines or second lines, select if image is linked into hello or not - usefull for network boot |
| #hello.so: hello.o image.o division.o |
| hello.so: hello.o image.bin division.o |
| # $(LD) $(LDFLAGS) -Map hello.map hello.o division.o image.o -o hello.so $(LOADLIBES) #link image inside hello |
| $(LD) $(LDFLAGS) -Map hello.map hello.o division.o -o hello.so $(LOADLIBES) #dont link image inside hello |
| hello.o: hello.c |
| $(CC) $(INCDIR) $(CFLAGS) $(CPPFLAGS) -c hello.c -o hello.o |
| division.o: division.c |
| $(CC) $(INCDIR) $(CFLAGS) $(CPPFLAGS) -c division.c -o division.o |
| image.bin: ../../image.boot |
| $(OBJCOPY) -O binary ../../image.boot image.bin |
| image.o: ../../image.boot mkimage |
| $(OBJCOPY) -O binary ../../image.boot image.bin |
| ./mkimage |
| $(CC) $(INCDIR) $(CFLAGS) $(CPPFLAGS) -c image.c -o image.o |
| # $(OBJCOPY) -I binary -O elf64-ia64-little -B ia64 image.bin image.o |
| mkimage: mkimage.c |
| gcc -o mkimage mkimage.c |
| gefi: |
| make -C .. prefix=$(PREFIX) |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/HelenOS/division.c |
|---|
| 0,0 → 1,0 |
| link ../../../../../../uspace/lib/softint/generic/division.c |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/HelenOS/division.h |
|---|
| 0,0 → 1,0 |
| link ../../../../../../uspace/lib/softint/include/division.h |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/HelenOS/mkimage.c |
|---|
| 0,0 → 1,17 |
| #include<stdio.h> |
| #include<stdlib.h> |
| int main(int argc,char** argv) |
| { |
| FILE *fi,*fo; |
| int count=0; |
| int ch; |
| fi=fopen("image.bin","rb"); |
| fo=fopen("image.c","wb"); |
| fprintf(fo,"char HOSimage[]={\n"); |
| if((ch=getc(fi))!=EOF) {fprintf(fo,"0x%02X",ch);count++;} |
| while((ch=getc(fi))!=EOF) {fprintf(fo,",0x%02X",ch);count++;} |
| fprintf(fo,"};\nint HOSimagesize=%d;\n",count); |
| return EXIT_SUCCESS; |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/apps/Makefile |
|---|
| 0,0 → 1,44 |
| # |
| # Copyright (C) 1999-2001 Hewlett-Packard Co. |
| # Contributed by David Mosberger <davidm@hpl.hp.com> |
| # Contributed by Stephane Eranian <eranian@hpl.hp.com> |
| # |
| # This file is part of the gnu-efi package. |
| # |
| # GNU-EFI is free software; you can redistribute it and/or modify |
| # it under the terms of the GNU General Public License as published by |
| # the Free Software Foundation; either version 2, or (at your option) |
| # any later version. |
| # |
| # GNU-EFI is distributed in the hope that it will be useful, |
| # but WITHOUT ANY WARRANTY; without even the implied warranty of |
| # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| # GNU General Public License for more details. |
| # |
| # You should have received a copy of the GNU General Public License |
| # along with GNU-EFI; see the file COPYING. If not, write to the Free |
| # Software Foundation, 59 Temple Place - Suite 330, Boston, MA |
| # 02111-1307, USA. |
| # |
| include ../Make.defaults |
| CDIR=$(TOPDIR)/.. |
| LINUX_HEADERS = /usr/src/sys/build |
| CPPFLAGS += -D__KERNEL__ -I$(LINUX_HEADERS)/include |
| CRTOBJS = ../gnuefi/crt0-efi-$(ARCH).o |
| LDSCRIPT = ../gnuefi/elf_$(ARCH)_efi.lds |
| LDFLAGS += -T $(LDSCRIPT) -shared -Bsymbolic -L../lib -L../gnuefi $(CRTOBJS) |
| LOADLIBES = -lefi -lgnuefi $(shell $(CC) -print-libgcc-file-name) |
| FORMAT = efi-app-$(ARCH) |
| TARGETS = t.efi t2.efi t3.efi t4.efi t5.efi t6.efi printenv.efi t7.efi |
| all: $(TARGETS) |
| clean: |
| rm -f $(TARGETS) *~ *.o *.so |
| .PHONY: install |
| include ../Make.rules |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/apps/tpause.c |
|---|
| 0,0 → 1,9 |
| #include <efi.h> |
| #include <efilib.h> |
| EFI_STATUS |
| efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab) |
| { |
| Print(L"Press `q' to quit, any other key to continue:\n"); |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/apps/t.c |
|---|
| 0,0 → 1,71 |
| #define EFI_SUCCESS 0 |
| typedef short CHAR16; |
| typedef unsigned long UINTN; |
| typedef unsigned long long UINT64; |
| typedef unsigned int UINT32; |
| typedef void * EFI_HANDLE; |
| typedef UINTN EFI_STATUS; |
| typedef struct _EFI_TABLE_HEARDER { |
| UINT64 Signature; |
| UINT32 Revision; |
| UINT32 HeaderSize; |
| UINT32 CRC32; |
| UINT32 Reserved; |
| } EFI_TABLE_HEADER; |
| typedef EFI_STATUS (*EFI_TEXT_STRING) (void *This, CHAR16 *String); |
| typedef struct _SIMPLE_TEXT_OUTPUT_INTERFACE { |
| void * Reset; |
| EFI_TEXT_STRING OutputString; |
| } SIMPLE_TEXT_OUTPUT_INTERFACE; |
| typedef struct _EFI_SYSTEM_TABLE { |
| EFI_TABLE_HEADER Hdr; |
| CHAR16 *FirmwareVendor; |
| UINT32 FirmwareRevision; |
| EFI_HANDLE ConsoleInHandle; |
| /*SIMPLE_INPUT_INTERFACE*/ void *ConIn; |
| EFI_HANDLE ConsoleOutHandle; |
| SIMPLE_TEXT_OUTPUT_INTERFACE *ConOut; |
| EFI_HANDLE StandardErrorHandle; |
| SIMPLE_TEXT_OUTPUT_INTERFACE *StdErr; |
| /*EFI_RUNTIME_SERVICES*/ void *RuntimeServices; |
| /*EFI_BOOT_SERVICES*/ void *BootServices; |
| UINTN NumberOfTableEntries; |
| /*EFI_CONFIGURATION_TABLE*/void *ConfigurationTable; |
| } EFI_SYSTEM_TABLE; |
| static CHAR16 * |
| a2u (char *str) |
| { |
| static CHAR16 mem[2048]; |
| int i; |
| for (i = 0; str[i]; ++i) |
| mem[i] = (CHAR16) str[i]; |
| mem[i] = 0; |
| return mem; |
| } |
| EFI_STATUS |
| efi_main (EFI_HANDLE image_handle, EFI_SYSTEM_TABLE *systab) |
| { |
| SIMPLE_TEXT_OUTPUT_INTERFACE *conout; |
| conout = systab->ConOut; |
| conout->OutputString(conout, (CHAR16 *)L"Hello World!\n\r"); |
| conout->OutputString(conout, a2u("Hello World!\n\r")); |
| return EFI_SUCCESS; |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/apps/printenv.c |
|---|
| 0,0 → 1,32 |
| #include <efi.h> |
| #include <efilib.h> |
| EFI_STATUS |
| efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab) |
| { |
| EFI_STATUS status; |
| CHAR16 name[256], *val, fmt[20]; |
| EFI_GUID vendor; |
| UINTN size; |
| InitializeLib(image, systab); |
| name[0] = 0; |
| vendor = NullGuid; |
| Print(L"GUID Variable Name Value\n"); |
| Print(L"=================================== ==================== ========\n"); |
| StrCpy(fmt, L"%.-35g %.-20s %s\n"); |
| while (1) { |
| size = sizeof(name); |
| status = RT->GetNextVariableName(&size, name, &vendor); |
| if (status != EFI_SUCCESS) |
| break; |
| val = LibGetVariable(name, &vendor); |
| Print(fmt, &vendor, name, val); |
| FreePool(val); |
| } |
| return EFI_SUCCESS; |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/apps/t2.c |
|---|
| 0,0 → 1,13 |
| #include <efi.h> |
| #include <efilib.h> |
| EFI_STATUS |
| efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab) |
| { |
| SIMPLE_TEXT_OUTPUT_INTERFACE *conout; |
| conout = systab->ConOut; |
| conout->OutputString(conout, L"Hello World!\n\r"); |
| return EFI_SUCCESS; |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/apps/t3.c |
|---|
| 0,0 → 1,93 |
| #include <efi.h> |
| #include <efilib.h> |
| EFI_STATUS |
| efi_main( |
| EFI_HANDLE image_handle, |
| EFI_SYSTEM_TABLE *systab |
| ) |
| { |
| EFI_GUID loaded_image_protocol = LOADED_IMAGE_PROTOCOL; |
| EFI_STATUS efi_status; |
| EFI_LOADED_IMAGE *li; |
| UINTN pat = PoolAllocationType; |
| VOID *void_li_p; |
| InitializeLib(image_handle, systab); |
| PoolAllocationType = 2; /* klooj */ |
| Print(L"Hello World! (0xd=0x%x, 13=%d)\n", 13, 13); |
| Print(L"before InitializeLib(): PoolAllocationType=%d\n", |
| pat); |
| Print(L" after InitializeLib(): PoolAllocationType=%d\n", |
| PoolAllocationType); |
| /* |
| * Locate loaded_image_handle instance. |
| */ |
| Print(L"BS->HandleProtocol() "); |
| efi_status = BS->HandleProtocol( |
| image_handle, |
| &loaded_image_protocol, |
| &void_li_p); |
| li = void_li_p; |
| Print(L"%xh (%r)\n", efi_status, efi_status); |
| if (efi_status != EFI_SUCCESS) { |
| return efi_status; |
| } |
| Print(L" li: %xh\n", li); |
| if (!li) { |
| return EFI_UNSUPPORTED; |
| } |
| Print(L" li->Revision: %xh\n", li->Revision); |
| Print(L" li->ParentHandle: %xh\n", li->ParentHandle); |
| Print(L" li->SystemTable: %xh\n", li->SystemTable); |
| Print(L" li->DeviceHandle: %xh\n", li->DeviceHandle); |
| Print(L" li->FilePath: %xh\n", li->FilePath); |
| Print(L" li->Reserved: %xh\n", li->Reserved); |
| Print(L" li->LoadOptionsSize: %xh\n", li->LoadOptionsSize); |
| Print(L" li->LoadOptions: %xh\n", li->LoadOptions); |
| Print(L" li->ImageBase: %xh\n", li->ImageBase); |
| Print(L" li->ImageSize: %xh\n", li->ImageSize); |
| Print(L" li->ImageCodeType: %xh\n", li->ImageCodeType); |
| Print(L" li->ImageDataType: %xh\n", li->ImageDataType); |
| Print(L" li->Unload: %xh\n", li->Unload); |
| #if 0 |
| typedef struct { |
| UINT32 Revision; |
| EFI_HANDLE ParentHandle; |
| struct _EFI_SYSTEM_TABLE *SystemTable; |
| // Source location of image |
| EFI_HANDLE DeviceHandle; |
| EFI_DEVICE_PATH *FilePath; |
| VOID *Reserved; |
| // Images load options |
| UINT32 LoadOptionsSize; |
| VOID *LoadOptions; |
| // Location of where image was loaded |
| VOID *ImageBase; |
| UINT64 ImageSize; |
| EFI_MEMORY_TYPE ImageCodeType; |
| EFI_MEMORY_TYPE ImageDataType; |
| // If the driver image supports a dynamic unload request |
| EFI_IMAGE_UNLOAD Unload; |
| } EFI_LOADED_IMAGE; |
| #endif |
| return EFI_SUCCESS; |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/apps/t4.c |
|---|
| 0,0 → 1,13 |
| #include <efi.h> |
| #include <efilib.h> |
| EFI_STATUS |
| efi_main (EFI_HANDLE *image, EFI_SYSTEM_TABLE *systab) |
| { |
| UINTN index; |
| systab->ConOut->OutputString(systab->ConOut, L"Hello application started\r\n"); |
| systab->ConOut->OutputString(systab->ConOut, L"\r\n\r\n\r\nHit any key to exit\r\n"); |
| systab->BootServices->WaitForEvent(1, &systab->ConIn->WaitForKey, &index); |
| return EFI_SUCCESS; |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/apps/t5.c |
|---|
| 0,0 → 1,13 |
| #include <efi.h> |
| #include <efilib.h> |
| EFI_STATUS |
| efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab) |
| { |
| InitializeLib(image, systab); |
| Print(L"HelloLib application started\n"); |
| Print(L"\n\n\nHit any key to exit this image\n"); |
| WaitForSingleEvent(ST->ConIn->WaitForKey, 0); |
| ST->ConOut->OutputString(ST->ConOut, L"\n\n"); |
| return EFI_SUCCESS; |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/apps/t6.c |
|---|
| 0,0 → 1,39 |
| #include <efi.h> |
| #include <efilib.h> |
| typedef EFI_STATUS (*foo_t)(EFI_HANDLE, EFI_GUID *, VOID **); |
| typedef struct { |
| unsigned long addr; |
| unsigned long gp; |
| } fdesc_t; |
| EFI_LOADED_IMAGE my_loaded; |
| EFI_STATUS |
| efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab) |
| { |
| EFI_LOADED_IMAGE *loaded_image = NULL; |
| #if 0 |
| EFI_DEVICE_PATH *dev_path; |
| #endif |
| EFI_STATUS status; |
| InitializeLib(image, systab); |
| status = systab->BootServices->HandleProtocol(image, &LoadedImageProtocol, (void **) &loaded_image); |
| if (EFI_ERROR(status)) { |
| Print(L"handleprotocol: %r\n", status); |
| } |
| #if 0 |
| BS->HandleProtocol(loaded_image->DeviceHandle, &DevicePathProtocol, (void **) &dev_path); |
| Print(L"Image device : %s\n", DevicePathToStr(dev_path)); |
| Print(L"Image file : %s\n", DevicePathToStr(loaded_image->FilePath)); |
| #endif |
| Print(L"Image base : %lx\n", loaded_image->ImageBase); |
| Print(L"Image size : %lx\n", loaded_image->ImageSize); |
| Print(L"Load options size : %lx\n", loaded_image->LoadOptionsSize); |
| Print(L"Load options : %s\n", loaded_image->LoadOptions); |
| return EFI_SUCCESS; |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/apps/t7.c |
|---|
| 0,0 → 1,25 |
| #include <efi.h> |
| #include <efilib.h> |
| EFI_STATUS |
| efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab) |
| { |
| EFI_INPUT_KEY efi_input_key; |
| EFI_STATUS efi_status; |
| InitializeLib(image, systab); |
| Print(L"HelloLib application started\n"); |
| Print(L"\n\n\nHit any key to exit this image\n"); |
| WaitForSingleEvent(ST->ConIn->WaitForKey, 0); |
| ST->ConOut->OutputString(ST->ConOut, L"\n\n"); |
| efi_status = ST->ConIn->ReadKeyStroke(ST->ConIn, &efi_input_key); |
| Print(L"ScanCode: %xh UnicodeChar: %xh\n", |
| efi_input_key.ScanCode, efi_input_key.UnicodeChar); |
| return EFI_SUCCESS; |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/apps/trivial.S |
|---|
| 0,0 → 1,43 |
| .text |
| .align 4 |
| .globl _start |
| _start: |
| #if 0 |
| pushl %ebp |
| movl %esp,%ebp |
| pushl %ebx # save ebx |
| movl 12(%ebp),%eax # eax <- systab |
| movl 24(%eax),%ebx # ebx <- systab->FirmwareVendor |
| pushl %ebx |
| movl 44(%eax),%ebx # ebx <- systab->ConOut |
| pushl %ebx |
| movl 4(%ebx),%eax # eax <- conout->OutputString |
| call *%eax |
| movl -4(%ebp),%ebx # restore ebx |
| leave |
| ret |
| #else |
| pushl %ebp |
| movl %esp,%ebp |
| pushl %ebx |
| call 0f |
| 0: popl %eax |
| addl $hello-0b,%eax |
| pushl %eax |
| movl 12(%ebp),%eax # eax <- systab |
| movl 44(%eax),%ebx # ebx <- systab->ConOut |
| pushl %ebx |
| movl 4(%ebx),%eax # eax <- conout->OutputString |
| call *%eax |
| movl -4(%ebp),%ebx |
| leave |
| ret |
| .section .rodata |
| .align 2 |
| hello: .byte 'h',0,'e',0,'l',0,'l',0,'o',0,'\n',0,'\r',0,0,0 |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/Make.defaults |
|---|
| 0,0 → 1,56 |
| # |
| # Copyright (c) 1999-2004 Hewlett-Packard Development Company, L.P. |
| # Contributed by David Mosberger <davidm@hpl.hp.com> |
| # Contributed by Stephane Eranian <eranian@hpl.hp.com> |
| # |
| # This file is part of the gnu-efi package. |
| # |
| # GNU-EFI is free software; you can redistribute it and/or modify |
| # it under the terms of the GNU General Public License as published by |
| # the Free Software Foundation; either version 2, or (at your option) |
| # any later version. |
| # |
| # GNU-EFI is distributed in the hope that it will be useful, |
| # but WITHOUT ANY WARRANTY; without even the implied warranty of |
| # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| # GNU General Public License for more details. |
| # |
| # You should have received a copy of the GNU General Public License |
| # along with GNU-EFI; see the file COPYING. If not, write to the Free |
| # Software Foundation, 59 Temple Place - Suite 330, Boston, MA |
| # 02111-1307, USA. |
| # |
| # |
| # Where to install the package. GNU-EFI will create and access |
| # lib and include under the root |
| # |
| INSTALLROOT=/usr/local |
| TOPDIR := $(shell if [ "$$PWD" != "" ]; then echo $$PWD; else pwd; fi) |
| ARCH = $(shell uname -m | sed s,i[3456789]86,ia32,) |
| INCDIR = -I. -I$(CDIR)/inc -I$(CDIR)/inc/$(ARCH) -I$(CDIR)/inc/protocol |
| CPPFLAGS = -DCONFIG_$(ARCH) |
| CFLAGS = -O2 -fpic -Wall -fshort-wchar -fno-strict-aliasing -fno-merge-constants |
| LDFLAGS = -nostdlib |
| INSTALL = install |
| GCC_VERSION=$(shell $(CROSS_COMPILE)$(CC) -v 2>&1 | fgrep 'gcc version' | cut -f3 -d' ' | cut -f1 -d'.') |
| # prefix = |
| CC = $(prefix)gcc |
| AS = $(prefix)as |
| LD = $(prefix)ld |
| AR = $(prefix)ar |
| RANLIB = $(prefix)ranlib |
| OBJCOPY = $(prefix)objcopy |
| OBJDUMP = $(prefix)objdump |
| ifneq ($(GCC_VERSION),2) |
| CFLAGS += -frename-registers |
| endif |
| CFLAGS += -mfixed-range=f32-f127 |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/README.elilo |
|---|
| 0,0 → 1,18 |
| IMPORTANT information related to the gnu-efi package |
| ---------------------------------------------------- |
| June 2001 |
| As of version 3.0, the gnu-efi package is now split in two different packages: |
| -> gnu-efi-X.y: contains the EFI library, include files and crt0. |
| -> elilo-X.y : contains the ELILO bootloader. |
| Note that X.y don't need to match for both packages. However elilo-3.x |
| requires at least gnu-efi-3.0. |
| Both packages can be downloaded from: |
| ftp://ftp.hpl.hp.com/pub/linux-ia64/gnu-efi-X.y.tar.gz |
| http://www.sf.net/projects/elilo |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/Make.rules |
|---|
| 0,0 → 1,33 |
| # |
| # Copyright (C) 1999-2001 Hewlett-Packard Co. |
| # Contributed by David Mosberger <davidm@hpl.hp.com> |
| # Contributed by Stephane Eranian <eranian@hpl.hp.com> |
| # |
| # This file is part of the gnu-efi package. |
| # |
| # GNU-EFI is free software; you can redistribute it and/or modify |
| # it under the terms of the GNU General Public License as published by |
| # the Free Software Foundation; either version 2, or (at your option) |
| # any later version. |
| # |
| # GNU-EFI is distributed in the hope that it will be useful, |
| # but WITHOUT ANY WARRANTY; without even the implied warranty of |
| # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| # GNU General Public License for more details. |
| # |
| # You should have received a copy of the GNU General Public License |
| # along with GNU-EFI; see the file COPYING. If not, write to the Free |
| # Software Foundation, 59 Temple Place - Suite 330, Boston, MA |
| # 02111-1307, USA. |
| # |
| %.efi: %.so |
| $(OBJCOPY) -j .text -j .sdata -j .data -j .dynamic -j .dynsym -j .rel \ |
| -j .rela -j .reloc --target=$(FORMAT) $*.so $@ |
| %.so: %.o |
| $(LD) $(LDFLAGS) $^ -o $@ $(LOADLIBES) |
| %.o: %.c |
| $(CC) $(INCDIR) $(CFLAGS) $(CPPFLAGS) -c $< -o $@ |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/README.efilib |
|---|
| 0,0 → 1,30 |
| The files in the "lib" and "inc" subdirectories are using the EFI Application |
| Toolkit distributed by Intel at http://developer.intel.com/technology/efi |
| This code is covered by the following agreement: |
| Copyright (c) 1998-2000 Intel Corporation |
| 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. |
| THIS SOFTWARE IS PROVIDED ``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 INTEL 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 EFI SPECIFICATION AND ALL OTHER INFORMATION |
| ON THIS WEB SITE ARE PROVIDED "AS IS" WITH NO WARRANTIES, AND ARE SUBJECT |
| TO CHANGE WITHOUT NOTICE. |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/sread.c |
|---|
| 0,0 → 1,352 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| sread.c |
| Abstract: |
| Simple read file access |
| Revision History |
| --*/ |
| #include "lib.h" |
| #define SIMPLE_READ_SIGNATURE EFI_SIGNATURE_32('s','r','d','r') |
| typedef struct _SIMPLE_READ_FILE { |
| UINTN Signature; |
| BOOLEAN FreeBuffer; |
| VOID *Source; |
| UINTN SourceSize; |
| EFI_FILE_HANDLE FileHandle; |
| } SIMPLE_READ_HANDLE; |
| EFI_STATUS |
| OpenSimpleReadFile ( |
| IN BOOLEAN BootPolicy, |
| IN VOID *SourceBuffer OPTIONAL, |
| IN UINTN SourceSize, |
| IN OUT EFI_DEVICE_PATH **FilePath, |
| OUT EFI_HANDLE *DeviceHandle, |
| OUT SIMPLE_READ_FILE *SimpleReadHandle |
| ) |
| /*++ |
| Routine Description: |
| Opens a file for (simple) reading. The simple read abstraction |
| will access the file either from a memory copy, from a file |
| system interface, or from the load file interface. |
| Arguments: |
| Returns: |
| A handle to access the file |
| --*/ |
| { |
| SIMPLE_READ_HANDLE *FHand; |
| EFI_DEVICE_PATH *UserFilePath; |
| EFI_DEVICE_PATH *TempFilePath; |
| EFI_DEVICE_PATH *TempFilePathPtr; |
| FILEPATH_DEVICE_PATH *FilePathNode; |
| EFI_FILE_HANDLE FileHandle, LastHandle; |
| EFI_STATUS Status; |
| EFI_LOAD_FILE_INTERFACE *LoadFile; |
| FHand = NULL; |
| UserFilePath = *FilePath; |
| // |
| // Allocate a new simple read handle structure |
| // |
| FHand = AllocateZeroPool (sizeof(SIMPLE_READ_HANDLE)); |
| if (!FHand) { |
| Status = EFI_OUT_OF_RESOURCES; |
| goto Done; |
| } |
| *SimpleReadHandle = (SIMPLE_READ_FILE) FHand; |
| FHand->Signature = SIMPLE_READ_SIGNATURE; |
| // |
| // If the caller passed a copy of the file, then just use it |
| // |
| if (SourceBuffer) { |
| FHand->Source = SourceBuffer; |
| FHand->SourceSize = SourceSize; |
| *DeviceHandle = NULL; |
| Status = EFI_SUCCESS; |
| goto Done; |
| } |
| // |
| // Attempt to access the file via a file system interface |
| // |
| FileHandle = NULL; |
| Status = BS->LocateDevicePath (&FileSystemProtocol, FilePath, DeviceHandle); |
| if (!EFI_ERROR(Status)) { |
| FileHandle = LibOpenRoot (*DeviceHandle); |
| } |
| Status = FileHandle ? EFI_SUCCESS : EFI_UNSUPPORTED; |
| // |
| // To access as a filesystem, the filepath should only |
| // contain filepath components. Follow the filepath nodes |
| // and find the target file |
| // |
| FilePathNode = (FILEPATH_DEVICE_PATH *) *FilePath; |
| while (!IsDevicePathEnd(&FilePathNode->Header)) { |
| // |
| // For filesystem access each node should be a filepath component |
| // |
| if (DevicePathType(&FilePathNode->Header) != MEDIA_DEVICE_PATH || |
| DevicePathSubType(&FilePathNode->Header) != MEDIA_FILEPATH_DP) { |
| Status = EFI_UNSUPPORTED; |
| } |
| // |
| // If there's been an error, stop |
| // |
| if (EFI_ERROR(Status)) { |
| break; |
| } |
| // |
| // Open this file path node |
| // |
| LastHandle = FileHandle; |
| FileHandle = NULL; |
| Status = LastHandle->Open ( |
| LastHandle, |
| &FileHandle, |
| FilePathNode->PathName, |
| EFI_FILE_MODE_READ, |
| 0 |
| ); |
| // |
| // Close the last node |
| // |
| LastHandle->Close (LastHandle); |
| // |
| // Get the next node |
| // |
| FilePathNode = (FILEPATH_DEVICE_PATH *) NextDevicePathNode(&FilePathNode->Header); |
| } |
| // |
| // If success, return the FHand |
| // |
| if (!EFI_ERROR(Status)) { |
| ASSERT(FileHandle); |
| FHand->FileHandle = FileHandle; |
| goto Done; |
| } |
| // |
| // Cleanup from filesystem access |
| // |
| if (FileHandle) { |
| FileHandle->Close (FileHandle); |
| FileHandle = NULL; |
| *FilePath = UserFilePath; |
| } |
| // |
| // If the error is something other then unsupported, return it |
| // |
| if (Status != EFI_UNSUPPORTED) { |
| goto Done; |
| } |
| // |
| // Attempt to access the file via the load file protocol |
| // |
| Status = LibDevicePathToInterface (&LoadFileProtocol, *FilePath, (VOID*)&LoadFile); |
| if (!EFI_ERROR(Status)) { |
| TempFilePath = DuplicateDevicePath (*FilePath); |
| TempFilePathPtr = TempFilePath; |
| Status = BS->LocateDevicePath (&LoadFileProtocol, &TempFilePath, DeviceHandle); |
| FreePool (TempFilePathPtr); |
| // |
| // Determine the size of buffer needed to hold the file |
| // |
| SourceSize = 0; |
| Status = LoadFile->LoadFile ( |
| LoadFile, |
| *FilePath, |
| BootPolicy, |
| &SourceSize, |
| NULL |
| ); |
| // |
| // We expect a buffer too small error to inform us |
| // of the buffer size needed |
| // |
| if (Status == EFI_BUFFER_TOO_SMALL) { |
| SourceBuffer = AllocatePool (SourceSize); |
| if (SourceBuffer) { |
| FHand->FreeBuffer = TRUE; |
| FHand->Source = SourceBuffer; |
| FHand->SourceSize = SourceSize; |
| Status = LoadFile->LoadFile ( |
| LoadFile, |
| *FilePath, |
| BootPolicy, |
| &SourceSize, |
| SourceBuffer |
| ); |
| } |
| } |
| // |
| // If success, return FHand |
| // |
| if (!EFI_ERROR(Status) || Status == EFI_ALREADY_STARTED) { |
| goto Done; |
| } |
| } |
| // |
| // Nothing else to try |
| // |
| DEBUG ((D_LOAD|D_WARN, "OpenSimpleReadFile: Device did not support a known load protocol\n")); |
| Status = EFI_UNSUPPORTED; |
| Done: |
| // |
| // If the file was not accessed, clean up |
| // |
| if (EFI_ERROR(Status) && (Status != EFI_ALREADY_STARTED)) { |
| if (FHand) { |
| if (FHand->FreeBuffer) { |
| FreePool (FHand->Source); |
| } |
| FreePool (FHand); |
| } |
| } |
| return Status; |
| } |
| EFI_STATUS |
| ReadSimpleReadFile ( |
| IN SIMPLE_READ_FILE UserHandle, |
| IN UINTN Offset, |
| IN OUT UINTN *ReadSize, |
| OUT VOID *Buffer |
| ) |
| { |
| UINTN EndPos; |
| SIMPLE_READ_HANDLE *FHand; |
| EFI_STATUS Status; |
| FHand = UserHandle; |
| ASSERT (FHand->Signature == SIMPLE_READ_SIGNATURE); |
| if (FHand->Source) { |
| // |
| // Move data from our local copy of the file |
| // |
| EndPos = Offset + *ReadSize; |
| if (EndPos > FHand->SourceSize) { |
| *ReadSize = FHand->SourceSize - Offset; |
| if (Offset >= FHand->SourceSize) { |
| *ReadSize = 0; |
| } |
| } |
| CopyMem (Buffer, (CHAR8 *) FHand->Source + Offset, *ReadSize); |
| Status = EFI_SUCCESS; |
| } else { |
| // |
| // Read data from the file |
| // |
| Status = FHand->FileHandle->SetPosition (FHand->FileHandle, Offset); |
| if (!EFI_ERROR(Status)) { |
| Status = FHand->FileHandle->Read (FHand->FileHandle, ReadSize, Buffer); |
| } |
| } |
| return Status; |
| } |
| VOID |
| CloseSimpleReadFile ( |
| IN SIMPLE_READ_FILE UserHandle |
| ) |
| { |
| SIMPLE_READ_HANDLE *FHand; |
| FHand = UserHandle; |
| ASSERT (FHand->Signature == SIMPLE_READ_SIGNATURE); |
| // |
| // Free any file handle we opened |
| // |
| if (FHand->FileHandle) { |
| FHand->FileHandle->Close (FHand->FileHandle); |
| } |
| // |
| // If we allocated the Source buffer, free it |
| // |
| if (FHand->FreeBuffer) { |
| FreePool (FHand->Source); |
| } |
| // |
| // Done with this simple read file handle |
| // |
| FreePool (FHand); |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/dpath.c |
|---|
| 0,0 → 1,1035 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| dpath.c |
| Abstract: |
| MBR & Device Path functions |
| Revision History |
| --*/ |
| #include "lib.h" |
| #define ALIGN_SIZE(a) ((a % MIN_ALIGNMENT_SIZE) ? MIN_ALIGNMENT_SIZE - (a % MIN_ALIGNMENT_SIZE) : 0) |
| EFI_DEVICE_PATH * |
| DevicePathFromHandle ( |
| IN EFI_HANDLE Handle |
| ) |
| { |
| EFI_STATUS Status; |
| EFI_DEVICE_PATH *DevicePath; |
| Status = BS->HandleProtocol (Handle, &DevicePathProtocol, (VOID*)&DevicePath); |
| if (EFI_ERROR(Status)) { |
| DevicePath = NULL; |
| } |
| return DevicePath; |
| } |
| EFI_DEVICE_PATH * |
| DevicePathInstance ( |
| IN OUT EFI_DEVICE_PATH **DevicePath, |
| OUT UINTN *Size |
| ) |
| { |
| EFI_DEVICE_PATH *Start, *Next, *DevPath; |
| UINTN Count; |
| DevPath = *DevicePath; |
| Start = DevPath; |
| if (!DevPath) { |
| return NULL; |
| } |
| // |
| // Check for end of device path type |
| // |
| for (Count = 0; ; Count++) { |
| Next = NextDevicePathNode(DevPath); |
| if (IsDevicePathEndType(DevPath)) { |
| break; |
| } |
| if (Count > 01000) { |
| // |
| // BugBug: Debug code to catch bogus device paths |
| // |
| DEBUG((D_ERROR, "DevicePathInstance: DevicePath %x Size %d", *DevicePath, ((UINT8 *) DevPath) - ((UINT8 *) Start) )); |
| DumpHex (0, 0, ((UINT8 *) DevPath) - ((UINT8 *) Start), Start); |
| break; |
| } |
| DevPath = Next; |
| } |
| ASSERT (DevicePathSubType(DevPath) == END_ENTIRE_DEVICE_PATH_SUBTYPE || |
| DevicePathSubType(DevPath) == END_INSTANCE_DEVICE_PATH_SUBTYPE); |
| // |
| // Set next position |
| // |
| if (DevicePathSubType(DevPath) == END_ENTIRE_DEVICE_PATH_SUBTYPE) { |
| Next = NULL; |
| } |
| *DevicePath = Next; |
| // |
| // Return size and start of device path instance |
| // |
| *Size = ((UINT8 *) DevPath) - ((UINT8 *) Start); |
| return Start; |
| } |
| UINTN |
| DevicePathInstanceCount ( |
| IN EFI_DEVICE_PATH *DevicePath |
| ) |
| { |
| UINTN Count, Size; |
| Count = 0; |
| while (DevicePathInstance(&DevicePath, &Size)) { |
| Count += 1; |
| } |
| return Count; |
| } |
| EFI_DEVICE_PATH * |
| AppendDevicePath ( |
| IN EFI_DEVICE_PATH *Src1, |
| IN EFI_DEVICE_PATH *Src2 |
| ) |
| // Src1 may have multiple "instances" and each instance is appended |
| // Src2 is appended to each instance is Src1. (E.g., it's possible |
| // to append a new instance to the complete device path by passing |
| // it in Src2) |
| { |
| UINTN Src1Size, Src1Inst, Src2Size, Size; |
| EFI_DEVICE_PATH *Dst, *Inst; |
| UINT8 *DstPos; |
| // |
| // If there's only 1 path, just duplicate it |
| // |
| if (!Src1) { |
| ASSERT (!IsDevicePathUnpacked (Src2)); |
| return DuplicateDevicePath (Src2); |
| } |
| if (!Src2) { |
| ASSERT (!IsDevicePathUnpacked (Src1)); |
| return DuplicateDevicePath (Src1); |
| } |
| // |
| // Verify we're not working with unpacked paths |
| // |
| // ASSERT (!IsDevicePathUnpacked (Src1)); |
| // ASSERT (!IsDevicePathUnpacked (Src2)); |
| // |
| // Append Src2 to every instance in Src1 |
| // |
| Src1Size = DevicePathSize(Src1); |
| Src1Inst = DevicePathInstanceCount(Src1); |
| Src2Size = DevicePathSize(Src2); |
| Size = Src1Size * Src1Inst + Src2Size; |
| Dst = AllocatePool (Size); |
| if (Dst) { |
| DstPos = (UINT8 *) Dst; |
| // |
| // Copy all device path instances |
| // |
| while ((Inst = DevicePathInstance (&Src1, &Size))) { |
| CopyMem(DstPos, Inst, Size); |
| DstPos += Size; |
| CopyMem(DstPos, Src2, Src2Size); |
| DstPos += Src2Size; |
| CopyMem(DstPos, EndInstanceDevicePath, sizeof(EFI_DEVICE_PATH)); |
| DstPos += sizeof(EFI_DEVICE_PATH); |
| } |
| // Change last end marker |
| DstPos -= sizeof(EFI_DEVICE_PATH); |
| CopyMem(DstPos, EndDevicePath, sizeof(EFI_DEVICE_PATH)); |
| } |
| return Dst; |
| } |
| EFI_DEVICE_PATH * |
| AppendDevicePathNode ( |
| IN EFI_DEVICE_PATH *Src1, |
| IN EFI_DEVICE_PATH *Src2 |
| ) |
| // Src1 may have multiple "instances" and each instance is appended |
| // Src2 is a signal device path node (without a terminator) that is |
| // appended to each instance is Src1. |
| { |
| EFI_DEVICE_PATH *Temp, *Eop; |
| UINTN Length; |
| // |
| // Build a Src2 that has a terminator on it |
| // |
| Length = DevicePathNodeLength(Src2); |
| Temp = AllocatePool (Length + sizeof(EFI_DEVICE_PATH)); |
| if (!Temp) { |
| return NULL; |
| } |
| CopyMem (Temp, Src2, Length); |
| Eop = NextDevicePathNode(Temp); |
| SetDevicePathEndNode(Eop); |
| // |
| // Append device paths |
| // |
| Src1 = AppendDevicePath (Src1, Temp); |
| FreePool (Temp); |
| return Src1; |
| } |
| EFI_DEVICE_PATH * |
| FileDevicePath ( |
| IN EFI_HANDLE Device OPTIONAL, |
| IN CHAR16 *FileName |
| ) |
| /*++ |
| N.B. Results are allocated from pool. The caller must FreePool |
| the resulting device path structure |
| --*/ |
| { |
| UINTN Size; |
| FILEPATH_DEVICE_PATH *FilePath; |
| EFI_DEVICE_PATH *Eop, *DevicePath; |
| Size = StrSize(FileName); |
| FilePath = AllocateZeroPool (Size + SIZE_OF_FILEPATH_DEVICE_PATH + sizeof(EFI_DEVICE_PATH)); |
| DevicePath = NULL; |
| if (FilePath) { |
| // |
| // Build a file path |
| // |
| FilePath->Header.Type = MEDIA_DEVICE_PATH; |
| FilePath->Header.SubType = MEDIA_FILEPATH_DP; |
| SetDevicePathNodeLength (&FilePath->Header, Size + SIZE_OF_FILEPATH_DEVICE_PATH); |
| CopyMem (FilePath->PathName, FileName, Size); |
| Eop = NextDevicePathNode(&FilePath->Header); |
| SetDevicePathEndNode(Eop); |
| // |
| // Append file path to device's device path |
| // |
| DevicePath = (EFI_DEVICE_PATH *) FilePath; |
| if (Device) { |
| DevicePath = AppendDevicePath ( |
| DevicePathFromHandle(Device), |
| DevicePath |
| ); |
| FreePool(FilePath); |
| } |
| } |
| return DevicePath; |
| } |
| UINTN |
| DevicePathSize ( |
| IN EFI_DEVICE_PATH *DevPath |
| ) |
| { |
| EFI_DEVICE_PATH *Start; |
| // |
| // Search for the end of the device path structure |
| // |
| Start = DevPath; |
| while (!IsDevicePathEnd(DevPath)) { |
| DevPath = NextDevicePathNode(DevPath); |
| } |
| // |
| // Compute the size |
| // |
| return ((UINTN) DevPath - (UINTN) Start) + sizeof(EFI_DEVICE_PATH); |
| } |
| EFI_DEVICE_PATH * |
| DuplicateDevicePath ( |
| IN EFI_DEVICE_PATH *DevPath |
| ) |
| { |
| EFI_DEVICE_PATH *NewDevPath; |
| UINTN Size; |
| // |
| // Compute the size |
| // |
| Size = DevicePathSize (DevPath); |
| // |
| // Make a copy |
| // |
| NewDevPath = AllocatePool (Size); |
| if (NewDevPath) { |
| CopyMem (NewDevPath, DevPath, Size); |
| } |
| return NewDevPath; |
| } |
| EFI_DEVICE_PATH * |
| UnpackDevicePath ( |
| IN EFI_DEVICE_PATH *DevPath |
| ) |
| { |
| EFI_DEVICE_PATH *Src, *Dest, *NewPath; |
| UINTN Size; |
| // |
| // Walk device path and round sizes to valid boundries |
| // |
| Src = DevPath; |
| Size = 0; |
| for (; ;) { |
| Size += DevicePathNodeLength(Src); |
| Size += ALIGN_SIZE(Size); |
| if (IsDevicePathEnd(Src)) { |
| break; |
| } |
| Src = NextDevicePathNode(Src); |
| } |
| // |
| // Allocate space for the unpacked path |
| // |
| NewPath = AllocateZeroPool (Size); |
| if (NewPath) { |
| ASSERT (((UINTN)NewPath) % MIN_ALIGNMENT_SIZE == 0); |
| // |
| // Copy each node |
| // |
| Src = DevPath; |
| Dest = NewPath; |
| for (; ;) { |
| Size = DevicePathNodeLength(Src); |
| CopyMem (Dest, Src, Size); |
| Size += ALIGN_SIZE(Size); |
| SetDevicePathNodeLength (Dest, Size); |
| Dest->Type |= EFI_DP_TYPE_UNPACKED; |
| Dest = (EFI_DEVICE_PATH *) (((UINT8 *) Dest) + Size); |
| if (IsDevicePathEnd(Src)) { |
| break; |
| } |
| Src = NextDevicePathNode(Src); |
| } |
| } |
| return NewPath; |
| } |
| EFI_DEVICE_PATH* |
| AppendDevicePathInstance ( |
| IN EFI_DEVICE_PATH *Src, |
| IN EFI_DEVICE_PATH *Instance |
| ) |
| { |
| UINT8 *Ptr; |
| EFI_DEVICE_PATH *DevPath; |
| UINTN SrcSize; |
| UINTN InstanceSize; |
| if (Src == NULL) { |
| return DuplicateDevicePath (Instance); |
| } |
| SrcSize = DevicePathSize(Src); |
| InstanceSize = DevicePathSize(Instance); |
| Ptr = AllocatePool (SrcSize + InstanceSize); |
| DevPath = (EFI_DEVICE_PATH *)Ptr; |
| ASSERT(DevPath); |
| CopyMem (Ptr, Src, SrcSize); |
| // FreePool (Src); |
| while (!IsDevicePathEnd(DevPath)) { |
| DevPath = NextDevicePathNode(DevPath); |
| } |
| // |
| // Convert the End to an End Instance, since we are |
| // appending another instacne after this one its a good |
| // idea. |
| // |
| DevPath->SubType = END_INSTANCE_DEVICE_PATH_SUBTYPE; |
| DevPath = NextDevicePathNode(DevPath); |
| CopyMem (DevPath, Instance, InstanceSize); |
| return (EFI_DEVICE_PATH *)Ptr; |
| } |
| EFI_STATUS |
| LibDevicePathToInterface ( |
| IN EFI_GUID *Protocol, |
| IN EFI_DEVICE_PATH *FilePath, |
| OUT VOID **Interface |
| ) |
| { |
| EFI_STATUS Status; |
| EFI_HANDLE Device; |
| Status = BS->LocateDevicePath (Protocol, &FilePath, &Device); |
| if (!EFI_ERROR(Status)) { |
| // If we didn't get a direct match return not found |
| Status = EFI_NOT_FOUND; |
| if (IsDevicePathEnd(FilePath)) { |
| // |
| // It was a direct match, lookup the protocol interface |
| // |
| Status = BS->HandleProtocol (Device, Protocol, Interface); |
| } |
| } |
| // |
| // If there was an error, do not return an interface |
| // |
| if (EFI_ERROR(Status)) { |
| *Interface = NULL; |
| } |
| return Status; |
| } |
| VOID |
| _DevPathPci ( |
| IN OUT POOL_PRINT *Str, |
| IN VOID *DevPath |
| ) |
| { |
| PCI_DEVICE_PATH *Pci; |
| Pci = DevPath; |
| CatPrint(Str, L"Pci(%x|%x)", Pci->Device, Pci->Function); |
| } |
| VOID |
| _DevPathPccard ( |
| IN OUT POOL_PRINT *Str, |
| IN VOID *DevPath |
| ) |
| { |
| PCCARD_DEVICE_PATH *Pccard; |
| Pccard = DevPath; |
| CatPrint(Str, L"Pccard(Socket%x)", Pccard->SocketNumber); |
| } |
| VOID |
| _DevPathMemMap ( |
| IN OUT POOL_PRINT *Str, |
| IN VOID *DevPath |
| ) |
| { |
| MEMMAP_DEVICE_PATH *MemMap; |
| MemMap = DevPath; |
| CatPrint(Str, L"MemMap(%d:%x-%x)", |
| MemMap->MemoryType, |
| MemMap->StartingAddress, |
| MemMap->EndingAddress |
| ); |
| } |
| VOID |
| _DevPathController ( |
| IN OUT POOL_PRINT *Str, |
| IN VOID *DevPath |
| ) |
| { |
| CONTROLLER_DEVICE_PATH *Controller; |
| Controller = DevPath; |
| CatPrint(Str, L"Ctrl(%d)", |
| Controller->Controller |
| ); |
| } |
| VOID |
| _DevPathVendor ( |
| IN OUT POOL_PRINT *Str, |
| IN VOID *DevPath |
| ) |
| { |
| VENDOR_DEVICE_PATH *Vendor; |
| CHAR16 *Type; |
| UNKNOWN_DEVICE_VENDOR_DEVICE_PATH *UnknownDevPath; |
| Vendor = DevPath; |
| switch (DevicePathType(&Vendor->Header)) { |
| case HARDWARE_DEVICE_PATH: Type = L"Hw"; break; |
| case MESSAGING_DEVICE_PATH: Type = L"Msg"; break; |
| case MEDIA_DEVICE_PATH: Type = L"Media"; break; |
| default: Type = L"?"; break; |
| } |
| CatPrint(Str, L"Ven%s(%g", Type, &Vendor->Guid); |
| if (CompareGuid (&Vendor->Guid, &UnknownDevice) == 0) { |
| // |
| // GUID used by EFI to enumerate an EDD 1.1 device |
| // |
| UnknownDevPath = (UNKNOWN_DEVICE_VENDOR_DEVICE_PATH *)Vendor; |
| CatPrint(Str, L":%02x)", UnknownDevPath->LegacyDriveLetter); |
| } else { |
| CatPrint(Str, L")"); |
| } |
| } |
| VOID |
| _DevPathAcpi ( |
| IN OUT POOL_PRINT *Str, |
| IN VOID *DevPath |
| ) |
| { |
| ACPI_HID_DEVICE_PATH *Acpi; |
| Acpi = DevPath; |
| if ((Acpi->HID & PNP_EISA_ID_MASK) == PNP_EISA_ID_CONST) { |
| CatPrint(Str, L"Acpi(PNP%04x,%x)", EISA_ID_TO_NUM (Acpi->HID), Acpi->UID); |
| } else { |
| CatPrint(Str, L"Acpi(%08x,%x)", Acpi->HID, Acpi->UID); |
| } |
| } |
| VOID |
| _DevPathAtapi ( |
| IN OUT POOL_PRINT *Str, |
| IN VOID *DevPath |
| ) |
| { |
| ATAPI_DEVICE_PATH *Atapi; |
| Atapi = DevPath; |
| CatPrint(Str, L"Ata(%s,%s)", |
| Atapi->PrimarySecondary ? L"Secondary" : L"Primary", |
| Atapi->SlaveMaster ? L"Slave" : L"Master" |
| ); |
| } |
| VOID |
| _DevPathScsi ( |
| IN OUT POOL_PRINT *Str, |
| IN VOID *DevPath |
| ) |
| { |
| SCSI_DEVICE_PATH *Scsi; |
| Scsi = DevPath; |
| CatPrint(Str, L"Scsi(Pun%x,Lun%x)", Scsi->Pun, Scsi->Lun); |
| } |
| VOID |
| _DevPathFibre ( |
| IN OUT POOL_PRINT *Str, |
| IN VOID *DevPath |
| ) |
| { |
| FIBRECHANNEL_DEVICE_PATH *Fibre; |
| Fibre = DevPath; |
| CatPrint(Str, L"Fibre(%lx)", Fibre->WWN); |
| } |
| VOID |
| _DevPath1394 ( |
| IN OUT POOL_PRINT *Str, |
| IN VOID *DevPath |
| ) |
| { |
| F1394_DEVICE_PATH *F1394; |
| F1394 = DevPath; |
| CatPrint(Str, L"1394(%g)", &F1394->Guid); |
| } |
| VOID |
| _DevPathUsb ( |
| IN OUT POOL_PRINT *Str, |
| IN VOID *DevPath |
| ) |
| { |
| USB_DEVICE_PATH *Usb; |
| Usb = DevPath; |
| CatPrint(Str, L"Usb(%x)", Usb->Port); |
| } |
| VOID |
| _DevPathI2O ( |
| IN OUT POOL_PRINT *Str, |
| IN VOID *DevPath |
| ) |
| { |
| I2O_DEVICE_PATH *I2O; |
| I2O = DevPath; |
| CatPrint(Str, L"I2O(%x)", I2O->Tid); |
| } |
| VOID |
| _DevPathMacAddr ( |
| IN OUT POOL_PRINT *Str, |
| IN VOID *DevPath |
| ) |
| { |
| MAC_ADDR_DEVICE_PATH *MAC; |
| UINTN HwAddressSize; |
| UINTN Index; |
| MAC = DevPath; |
| HwAddressSize = sizeof(EFI_MAC_ADDRESS); |
| if (MAC->IfType == 0x01 || MAC->IfType == 0x00) { |
| HwAddressSize = 6; |
| } |
| CatPrint(Str, L"Mac("); |
| for(Index = 0; Index < HwAddressSize; Index++) { |
| CatPrint(Str, L"%02x",MAC->MacAddress.Addr[Index]); |
| } |
| CatPrint(Str, L")"); |
| } |
| VOID |
| _DevPathIPv4 ( |
| IN OUT POOL_PRINT *Str, |
| IN VOID *DevPath |
| ) |
| { |
| IPv4_DEVICE_PATH *IP; |
| IP = DevPath; |
| CatPrint(Str, L"IPv4(not-done)"); |
| } |
| VOID |
| _DevPathIPv6 ( |
| IN OUT POOL_PRINT *Str, |
| IN VOID *DevPath |
| ) |
| { |
| IPv6_DEVICE_PATH *IP; |
| IP = DevPath; |
| CatPrint(Str, L"IP-v6(not-done)"); |
| } |
| VOID |
| _DevPathInfiniBand ( |
| IN OUT POOL_PRINT *Str, |
| IN VOID *DevPath |
| ) |
| { |
| INFINIBAND_DEVICE_PATH *InfiniBand; |
| InfiniBand = DevPath; |
| CatPrint(Str, L"InfiniBand(not-done)"); |
| } |
| VOID |
| _DevPathUart ( |
| IN OUT POOL_PRINT *Str, |
| IN VOID *DevPath |
| ) |
| { |
| UART_DEVICE_PATH *Uart; |
| CHAR8 Parity; |
| Uart = DevPath; |
| switch (Uart->Parity) { |
| case 0 : Parity = 'D'; break; |
| case 1 : Parity = 'N'; break; |
| case 2 : Parity = 'E'; break; |
| case 3 : Parity = 'O'; break; |
| case 4 : Parity = 'M'; break; |
| case 5 : Parity = 'S'; break; |
| default : Parity = 'x'; break; |
| } |
| if (Uart->BaudRate == 0) { |
| CatPrint(Str, L"Uart(DEFAULT %c",Uart->BaudRate,Parity); |
| } else { |
| CatPrint(Str, L"Uart(%d %c",Uart->BaudRate,Parity); |
| } |
| if (Uart->DataBits == 0) { |
| CatPrint(Str, L"D"); |
| } else { |
| CatPrint(Str, L"%d",Uart->DataBits); |
| } |
| switch (Uart->StopBits) { |
| case 0 : CatPrint(Str, L"D)"); break; |
| case 1 : CatPrint(Str, L"1)"); break; |
| case 2 : CatPrint(Str, L"1.5)"); break; |
| case 3 : CatPrint(Str, L"2)"); break; |
| default : CatPrint(Str, L"x)"); break; |
| } |
| } |
| VOID |
| _DevPathHardDrive ( |
| IN OUT POOL_PRINT *Str, |
| IN VOID *DevPath |
| ) |
| { |
| HARDDRIVE_DEVICE_PATH *Hd; |
| Hd = DevPath; |
| switch (Hd->SignatureType) { |
| case SIGNATURE_TYPE_MBR: |
| CatPrint(Str, L"HD(Part%d,Sig%08X)", |
| Hd->PartitionNumber, |
| *((UINT32 *)(&(Hd->Signature[0]))) |
| ); |
| break; |
| case SIGNATURE_TYPE_GUID: |
| CatPrint(Str, L"HD(Part%d,Sig%g)", |
| Hd->PartitionNumber, |
| (EFI_GUID *) &(Hd->Signature[0]) |
| ); |
| break; |
| default: |
| CatPrint(Str, L"HD(Part%d,MBRType=%02x,SigType=%02x)", |
| Hd->PartitionNumber, |
| Hd->MBRType, |
| Hd->SignatureType |
| ); |
| break; |
| } |
| } |
| VOID |
| _DevPathCDROM ( |
| IN OUT POOL_PRINT *Str, |
| IN VOID *DevPath |
| ) |
| { |
| CDROM_DEVICE_PATH *Cd; |
| Cd = DevPath; |
| CatPrint(Str, L"CDROM(Entry%x)", Cd->BootEntry); |
| } |
| VOID |
| _DevPathFilePath ( |
| IN OUT POOL_PRINT *Str, |
| IN VOID *DevPath |
| ) |
| { |
| FILEPATH_DEVICE_PATH *Fp; |
| Fp = DevPath; |
| CatPrint(Str, L"%s", Fp->PathName); |
| } |
| VOID |
| _DevPathMediaProtocol ( |
| IN OUT POOL_PRINT *Str, |
| IN VOID *DevPath |
| ) |
| { |
| MEDIA_PROTOCOL_DEVICE_PATH *MediaProt; |
| MediaProt = DevPath; |
| CatPrint(Str, L"%g", &MediaProt->Protocol); |
| } |
| VOID |
| _DevPathBssBss ( |
| IN OUT POOL_PRINT *Str, |
| IN VOID *DevPath |
| ) |
| { |
| BBS_BBS_DEVICE_PATH *Bss; |
| CHAR16 *Type; |
| Bss = DevPath; |
| switch (Bss->DeviceType) { |
| case BBS_TYPE_FLOPPY: Type = L"Floppy"; break; |
| case BBS_TYPE_HARDDRIVE: Type = L"Harddrive"; break; |
| case BBS_TYPE_CDROM: Type = L"CDROM"; break; |
| case BBS_TYPE_PCMCIA: Type = L"PCMCIA"; break; |
| case BBS_TYPE_USB: Type = L"Usb"; break; |
| case BBS_TYPE_EMBEDDED_NETWORK: Type = L"Net"; break; |
| default: Type = L"?"; break; |
| } |
| CatPrint(Str, L"Bss-%s(%a)", Type, Bss->String); |
| } |
| VOID |
| _DevPathEndInstance ( |
| IN OUT POOL_PRINT *Str, |
| IN VOID *DevPath |
| ) |
| { |
| CatPrint(Str, L","); |
| } |
| VOID |
| _DevPathNodeUnknown ( |
| IN OUT POOL_PRINT *Str, |
| IN VOID *DevPath |
| ) |
| { |
| CatPrint(Str, L"?"); |
| } |
| struct { |
| UINT8 Type; |
| UINT8 SubType; |
| VOID (*Function)(POOL_PRINT *, VOID *); |
| } DevPathTable[] = { |
| { HARDWARE_DEVICE_PATH, HW_PCI_DP, _DevPathPci}, |
| { HARDWARE_DEVICE_PATH, HW_PCCARD_DP, _DevPathPccard}, |
| { HARDWARE_DEVICE_PATH, HW_MEMMAP_DP, _DevPathMemMap}, |
| { HARDWARE_DEVICE_PATH, HW_VENDOR_DP, _DevPathVendor}, |
| { HARDWARE_DEVICE_PATH, HW_CONTROLLER_DP, _DevPathController}, |
| { ACPI_DEVICE_PATH, ACPI_DP, _DevPathAcpi}, |
| { MESSAGING_DEVICE_PATH, MSG_ATAPI_DP, _DevPathAtapi}, |
| { MESSAGING_DEVICE_PATH, MSG_SCSI_DP, _DevPathScsi}, |
| { MESSAGING_DEVICE_PATH, MSG_FIBRECHANNEL_DP, _DevPathFibre}, |
| { MESSAGING_DEVICE_PATH, MSG_1394_DP, _DevPath1394}, |
| { MESSAGING_DEVICE_PATH, MSG_USB_DP, _DevPathUsb}, |
| { MESSAGING_DEVICE_PATH, MSG_I2O_DP, _DevPathI2O}, |
| { MESSAGING_DEVICE_PATH, MSG_MAC_ADDR_DP, _DevPathMacAddr}, |
| { MESSAGING_DEVICE_PATH, MSG_IPv4_DP, _DevPathIPv4}, |
| { MESSAGING_DEVICE_PATH, MSG_IPv6_DP, _DevPathIPv6}, |
| { MESSAGING_DEVICE_PATH, MSG_INFINIBAND_DP, _DevPathInfiniBand}, |
| { MESSAGING_DEVICE_PATH, MSG_UART_DP, _DevPathUart}, |
| { MESSAGING_DEVICE_PATH, MSG_VENDOR_DP, _DevPathVendor}, |
| { MEDIA_DEVICE_PATH, MEDIA_HARDDRIVE_DP, _DevPathHardDrive}, |
| { MEDIA_DEVICE_PATH, MEDIA_CDROM_DP, _DevPathCDROM}, |
| { MEDIA_DEVICE_PATH, MEDIA_VENDOR_DP, _DevPathVendor}, |
| { MEDIA_DEVICE_PATH, MEDIA_FILEPATH_DP, _DevPathFilePath}, |
| { MEDIA_DEVICE_PATH, MEDIA_PROTOCOL_DP, _DevPathMediaProtocol}, |
| { BBS_DEVICE_PATH, BBS_BBS_DP, _DevPathBssBss}, |
| { END_DEVICE_PATH_TYPE, END_INSTANCE_DEVICE_PATH_SUBTYPE, _DevPathEndInstance}, |
| { 0, 0, NULL} |
| }; |
| CHAR16 * |
| DevicePathToStr ( |
| EFI_DEVICE_PATH *DevPath |
| ) |
| /*++ |
| Turns the Device Path into a printable string. Allcoates |
| the string from pool. The caller must FreePool the returned |
| string. |
| --*/ |
| { |
| POOL_PRINT Str; |
| EFI_DEVICE_PATH *DevPathNode; |
| VOID (*DumpNode)(POOL_PRINT *, VOID *); |
| UINTN Index, NewSize; |
| ZeroMem(&Str, sizeof(Str)); |
| // |
| // Unpacked the device path |
| // |
| DevPath = UnpackDevicePath(DevPath); |
| ASSERT (DevPath); |
| // |
| // Process each device path node |
| // |
| DevPathNode = DevPath; |
| while (!IsDevicePathEnd(DevPathNode)) { |
| // |
| // Find the handler to dump this device path node |
| // |
| DumpNode = NULL; |
| for (Index = 0; DevPathTable[Index].Function; Index += 1) { |
| if (DevicePathType(DevPathNode) == DevPathTable[Index].Type && |
| DevicePathSubType(DevPathNode) == DevPathTable[Index].SubType) { |
| DumpNode = DevPathTable[Index].Function; |
| break; |
| } |
| } |
| // |
| // If not found, use a generic function |
| // |
| if (!DumpNode) { |
| DumpNode = _DevPathNodeUnknown; |
| } |
| // |
| // Put a path seperator in if needed |
| // |
| if (Str.len && DumpNode != _DevPathEndInstance) { |
| CatPrint (&Str, L"/"); |
| } |
| // |
| // Print this node of the device path |
| // |
| DumpNode (&Str, DevPathNode); |
| // |
| // Next device path node |
| // |
| DevPathNode = NextDevicePathNode(DevPathNode); |
| } |
| // |
| // Shrink pool used for string allocation |
| // |
| FreePool (DevPath); |
| NewSize = (Str.len + 1) * sizeof(CHAR16); |
| Str.str = ReallocatePool (Str.str, NewSize, NewSize); |
| Str.str[Str.len] = 0; |
| return Str.str; |
| } |
| BOOLEAN |
| LibMatchDevicePaths ( |
| IN EFI_DEVICE_PATH *Multi, |
| IN EFI_DEVICE_PATH *Single |
| ) |
| { |
| EFI_DEVICE_PATH *DevicePath, *DevicePathInst; |
| UINTN Size; |
| if (!Multi || !Single) { |
| return FALSE; |
| } |
| DevicePath = Multi; |
| while ((DevicePathInst = DevicePathInstance (&DevicePath, &Size))) { |
| if (CompareMem (Single, DevicePathInst, Size) == 0) { |
| return TRUE; |
| } |
| } |
| return FALSE; |
| } |
| EFI_DEVICE_PATH * |
| LibDuplicateDevicePathInstance ( |
| IN EFI_DEVICE_PATH *DevPath |
| ) |
| { |
| EFI_DEVICE_PATH *NewDevPath,*DevicePathInst,*Temp; |
| UINTN Size; |
| // |
| // get the size of an instance from the input |
| // |
| Temp = DevPath; |
| DevicePathInst = DevicePathInstance (&Temp, &Size); |
| // |
| // Make a copy and set proper end type |
| // |
| NewDevPath = NULL; |
| if (Size) { |
| NewDevPath = AllocatePool (Size + sizeof(EFI_DEVICE_PATH)); |
| } |
| if (NewDevPath) { |
| CopyMem (NewDevPath, DevicePathInst, Size); |
| Temp = NextDevicePathNode(NewDevPath); |
| SetDevicePathEndNode(Temp); |
| } |
| return NewDevPath; |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/console.c |
|---|
| 0,0 → 1,104 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| console.c |
| Abstract: |
| Revision History |
| --*/ |
| #include "lib.h" |
| VOID |
| Output ( |
| IN CHAR16 *Str |
| ) |
| // Write a string to the console at the current cursor location |
| { |
| ST->ConOut->OutputString (ST->ConOut, Str); |
| } |
| VOID |
| Input ( |
| IN CHAR16 *Prompt OPTIONAL, |
| OUT CHAR16 *InStr, |
| IN UINTN StrLen |
| ) |
| // Input a string at the current cursor location, for StrLen |
| { |
| IInput ( |
| ST->ConOut, |
| ST->ConIn, |
| Prompt, |
| InStr, |
| StrLen |
| ); |
| } |
| VOID |
| IInput ( |
| IN SIMPLE_TEXT_OUTPUT_INTERFACE *ConOut, |
| IN SIMPLE_INPUT_INTERFACE *ConIn, |
| IN CHAR16 *Prompt OPTIONAL, |
| OUT CHAR16 *InStr, |
| IN UINTN StrLen |
| ) |
| // Input a string at the current cursor location, for StrLen |
| { |
| EFI_INPUT_KEY Key; |
| EFI_STATUS Status; |
| UINTN Len; |
| if (Prompt) { |
| ConOut->OutputString (ConOut, Prompt); |
| } |
| Len = 0; |
| for (; ;) { |
| WaitForSingleEvent (ConIn->WaitForKey, 0); |
| Status = ConIn->ReadKeyStroke(ConIn, &Key); |
| if (EFI_ERROR(Status)) { |
| DEBUG((D_ERROR, "Input: error return from ReadKey %x\n", Status)); |
| break; |
| } |
| if (Key.UnicodeChar == '\n' || |
| Key.UnicodeChar == '\r') { |
| break; |
| } |
| if (Key.UnicodeChar == '\b') { |
| if (Len) { |
| ConOut->OutputString(ConOut, L"\b \b"); |
| Len -= 1; |
| } |
| continue; |
| } |
| if (Key.UnicodeChar >= ' ') { |
| if (Len < StrLen-1) { |
| InStr[Len] = Key.UnicodeChar; |
| InStr[Len+1] = 0; |
| ConOut->OutputString(ConOut, &InStr[Len]); |
| Len += 1; |
| } |
| continue; |
| } |
| } |
| InStr[Len] = 0; |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/runtime/rtlock.c |
|---|
| 0,0 → 1,98 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| lock.c |
| Abstract: |
| Implements FLOCK |
| Revision History |
| --*/ |
| #include "lib.h" |
| #pragma RUNTIME_CODE(RtAcquireLock) |
| VOID |
| RtAcquireLock ( |
| IN FLOCK *Lock |
| ) |
| /*++ |
| Routine Description: |
| Raising to the task priority level of the mutual exclusion |
| lock, and then acquires ownership of the lock. |
| Arguments: |
| Lock - The lock to acquire |
| Returns: |
| Lock owned |
| --*/ |
| { |
| if (BS) { |
| if (BS->RaiseTPL != NULL) { |
| Lock->OwnerTpl = BS->RaiseTPL(Lock->Tpl); |
| } |
| } |
| else { |
| if (LibRuntimeRaiseTPL != NULL) { |
| Lock->OwnerTpl = LibRuntimeRaiseTPL(Lock->Tpl); |
| } |
| } |
| Lock->Lock += 1; |
| ASSERT (Lock->Lock == 1); |
| } |
| #pragma RUNTIME_CODE(RtAcquireLock) |
| VOID |
| RtReleaseLock ( |
| IN FLOCK *Lock |
| ) |
| /*++ |
| Routine Description: |
| Releases ownership of the mutual exclusion lock, and |
| restores the previous task priority level. |
| Arguments: |
| Lock - The lock to release |
| Returns: |
| Lock unowned |
| --*/ |
| { |
| EFI_TPL Tpl; |
| Tpl = Lock->OwnerTpl; |
| ASSERT(Lock->Lock == 1); |
| Lock->Lock -= 1; |
| if (BS) { |
| if (BS->RestoreTPL != NULL) { |
| BS->RestoreTPL (Tpl); |
| } |
| } |
| else { |
| if (LibRuntimeRestoreTPL != NULL) { |
| LibRuntimeRestoreTPL(Tpl); |
| } |
| } |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/runtime/rtstr.c |
|---|
| 0,0 → 1,126 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| str.c |
| Abstract: |
| String runtime functions |
| Revision History |
| --*/ |
| #include "lib.h" |
| #pragma RUNTIME_CODE(RtAcquireLock) |
| INTN |
| RUNTIMEFUNCTION |
| RtStrCmp ( |
| IN CHAR16 *s1, |
| IN CHAR16 *s2 |
| ) |
| // compare strings |
| { |
| while (*s1) { |
| if (*s1 != *s2) { |
| break; |
| } |
| s1 += 1; |
| s2 += 1; |
| } |
| return *s1 - *s2; |
| } |
| #pragma RUNTIME_CODE(RtStrCpy) |
| VOID |
| RUNTIMEFUNCTION |
| RtStrCpy ( |
| IN CHAR16 *Dest, |
| IN CHAR16 *Src |
| ) |
| // copy strings |
| { |
| while (*Src) { |
| *(Dest++) = *(Src++); |
| } |
| *Dest = 0; |
| } |
| #pragma RUNTIME_CODE(RtStrCat) |
| VOID |
| RUNTIMEFUNCTION |
| RtStrCat ( |
| IN CHAR16 *Dest, |
| IN CHAR16 *Src |
| ) |
| { |
| RtStrCpy(Dest+StrLen(Dest), Src); |
| } |
| #pragma RUNTIME_CODE(RtStrLen) |
| UINTN |
| RUNTIMEFUNCTION |
| RtStrLen ( |
| IN CHAR16 *s1 |
| ) |
| // string length |
| { |
| UINTN len; |
| for (len=0; *s1; s1+=1, len+=1) ; |
| return len; |
| } |
| #pragma RUNTIME_CODE(RtStrSize) |
| UINTN |
| RUNTIMEFUNCTION |
| RtStrSize ( |
| IN CHAR16 *s1 |
| ) |
| // string size |
| { |
| UINTN len; |
| for (len=0; *s1; s1+=1, len+=1) ; |
| return (len + 1) * sizeof(CHAR16); |
| } |
| #pragma RUNTIME_CODE(RtBCDtoDecimal) |
| UINT8 |
| RUNTIMEFUNCTION |
| RtBCDtoDecimal( |
| IN UINT8 BcdValue |
| ) |
| { |
| UINTN High, Low; |
| High = BcdValue >> 4; |
| Low = BcdValue - (High << 4); |
| return ((UINT8)(Low + (High * 10))); |
| } |
| #pragma RUNTIME_CODE(RtDecimaltoBCD) |
| UINT8 |
| RUNTIMEFUNCTION |
| RtDecimaltoBCD ( |
| IN UINT8 DecValue |
| ) |
| { |
| UINTN High, Low; |
| High = DecValue / 10; |
| Low = DecValue - (High * 10); |
| return ((UINT8)(Low + (High << 4))); |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/runtime/rtdata.c |
|---|
| 0,0 → 1,63 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| data.c |
| Abstract: |
| EFI library global data |
| Revision History |
| --*/ |
| #include "lib.h" |
| // |
| // These globals are runtime globals |
| // |
| // N.B. The Microsoft C compiler will only put the data in the |
| // right data section if it is explicitly initialized.. |
| // |
| #pragma BEGIN_RUNTIME_DATA() |
| // |
| // RT - pointer to the runtime table |
| // |
| EFI_RUNTIME_SERVICES *RT; |
| // |
| // LibStandalone - TRUE if lib is linked in as part of the firmware. |
| // N.B. The EFI fw sets this value directly |
| // |
| BOOLEAN LibFwInstance; |
| // |
| // EFIDebug - Debug mask |
| // |
| UINTN EFIDebug = EFI_DBUG_MASK; |
| // |
| // LibRuntimeDebugOut - Runtime Debug Output device |
| // |
| SIMPLE_TEXT_OUTPUT_INTERFACE *LibRuntimeDebugOut; |
| // |
| // LibRuntimeRaiseTPL, LibRuntimeRestoreTPL - pointers to Runtime functions from the |
| // Boot Services Table |
| // |
| EFI_RAISE_TPL LibRuntimeRaiseTPL = NULL; |
| EFI_RESTORE_TPL LibRuntimeRestoreTPL = NULL; |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/runtime/efirtlib.c |
|---|
| 0,0 → 1,139 |
| /*++ |
| Copyright (c) 1999 Intel Corporation |
| Module Name: |
| EfiRtLib.h |
| Abstract: |
| EFI Runtime library functions |
| Revision History |
| --*/ |
| #include "efi.h" |
| #include "efilib.h" |
| #include "efirtlib.h" |
| #pragma RUNTIME_CODE(RtZeroMem) |
| VOID |
| RUNTIMEFUNCTION |
| RtZeroMem ( |
| IN VOID *Buffer, |
| IN UINTN Size |
| ) |
| { |
| INT8 *pt; |
| pt = Buffer; |
| while (Size--) { |
| *(pt++) = 0; |
| } |
| } |
| #pragma RUNTIME_CODE(RtSetMem) |
| VOID |
| RUNTIMEFUNCTION |
| RtSetMem ( |
| IN VOID *Buffer, |
| IN UINTN Size, |
| IN UINT8 Value |
| ) |
| { |
| INT8 *pt; |
| pt = Buffer; |
| while (Size--) { |
| *(pt++) = Value; |
| } |
| } |
| #pragma RUNTIME_CODE(RtCopyMem) |
| VOID |
| RUNTIMEFUNCTION |
| RtCopyMem ( |
| IN VOID *Dest, |
| IN VOID *Src, |
| IN UINTN len |
| ) |
| { |
| CHAR8 *d, *s; |
| d = Dest; |
| s = Src; |
| while (len--) { |
| *(d++) = *(s++); |
| } |
| } |
| #pragma RUNTIME_CODE(RtCompareMem) |
| INTN |
| RUNTIMEFUNCTION |
| RtCompareMem ( |
| IN VOID *Dest, |
| IN VOID *Src, |
| IN UINTN len |
| ) |
| { |
| CHAR8 *d, *s; |
| d = Dest; |
| s = Src; |
| while (len--) { |
| if (*d != *s) { |
| return *d - *s; |
| } |
| d += 1; |
| s += 1; |
| } |
| return 0; |
| } |
| #pragma RUNTIME_CODE(RtCompareGuid) |
| INTN |
| RUNTIMEFUNCTION |
| RtCompareGuid ( |
| IN EFI_GUID *Guid1, |
| IN EFI_GUID *Guid2 |
| ) |
| /*++ |
| Routine Description: |
| Compares to GUIDs |
| Arguments: |
| Guid1 - guid to compare |
| Guid2 - guid to compare |
| Returns: |
| = 0 if Guid1 == Guid2 |
| --*/ |
| { |
| INT32 *g1, *g2, r; |
| // |
| // Compare 32 bits at a time |
| // |
| g1 = (INT32 *) Guid1; |
| g2 = (INT32 *) Guid2; |
| r = g1[0] - g2[0]; |
| r |= g1[1] - g2[1]; |
| r |= g1[2] - g2[2]; |
| r |= g1[3] - g2[3]; |
| return r; |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/runtime/vm.c |
|---|
| 0,0 → 1,101 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| vm.c |
| Abstract: |
| EFI Hell to remap runtime address into the new virual address space |
| that was registered by the OS for RT calls. |
| So the code image needs to be relocated. All pointers need to be |
| manually fixed up since the address map changes. |
| GOOD LUCK NOT HAVING BUGS IN YOUR CODE! PLEASE TEST A LOT. MAKE SURE |
| EXIT BOOTSERVICES OVER WRITES ALL BOOTSERVICE MEMORY & DATA SPACES WHEN |
| YOU TEST. |
| Revision History |
| --*/ |
| #include "lib.h" |
| #pragma RUNTIME_CODE(RtLibEnableVirtualMappings) |
| VOID |
| RUNTIMEFUNCTION |
| RtLibEnableVirtualMappings ( |
| VOID |
| ) |
| { |
| EFI_CONVERT_POINTER ConvertPointer; |
| // |
| // If this copy of the lib is linked into the firmware, then |
| // do not update the pointers yet. |
| // |
| if (!LibFwInstance) { |
| // |
| // Different components are updating to the new virtual |
| // mappings at differnt times. The only function that |
| // is safe to call at this notification is ConvertAddress |
| // |
| ConvertPointer = RT->ConvertPointer; |
| // |
| // Fix any pointers that the lib created, that may be needed |
| // during runtime. |
| // |
| ConvertPointer (EFI_INTERNAL_PTR, (VOID **)&RT); |
| ConvertPointer (EFI_OPTIONAL_PTR, (VOID **)&LibRuntimeDebugOut); |
| ConvertPointer (EFI_INTERNAL_PTR, (VOID **)&LibRuntimeRaiseTPL); |
| ConvertPointer (EFI_INTERNAL_PTR, (VOID **)&LibRuntimeRestoreTPL); |
| // that was it :^) |
| } |
| } |
| #pragma RUNTIME_CODE(RtConvertList) |
| VOID |
| RUNTIMEFUNCTION |
| RtConvertList ( |
| IN UINTN DebugDisposition, |
| IN OUT LIST_ENTRY *ListHead |
| ) |
| { |
| LIST_ENTRY *Link; |
| LIST_ENTRY *NextLink; |
| EFI_CONVERT_POINTER ConvertPointer; |
| ConvertPointer = RT->ConvertPointer; |
| // |
| // Convert all the Flink & Blink pointers in the list |
| // |
| Link = ListHead; |
| do { |
| NextLink = Link->Flink; |
| ConvertPointer ( |
| Link->Flink == ListHead ? DebugDisposition : 0, |
| (VOID **)&Link->Flink |
| ); |
| ConvertPointer ( |
| Link->Blink == ListHead ? DebugDisposition : 0, |
| (VOID **)&Link->Blink |
| ); |
| Link = NextLink; |
| } while (Link != ListHead); |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/init.c |
|---|
| 0,0 → 1,181 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| Abstract: |
| Revision History |
| --*/ |
| #include "lib.h" |
| VOID |
| EFIDebugVariable ( |
| VOID |
| ); |
| VOID |
| InitializeLib ( |
| IN EFI_HANDLE ImageHandle, |
| IN EFI_SYSTEM_TABLE *SystemTable |
| ) |
| /*++ |
| Routine Description: |
| Initializes EFI library for use |
| Arguments: |
| Firmware's EFI system table |
| Returns: |
| None |
| --*/ |
| { |
| EFI_LOADED_IMAGE *LoadedImage; |
| EFI_STATUS Status; |
| CHAR8 *LangCode; |
| if (!LibInitialized) { |
| LibInitialized = TRUE; |
| LibFwInstance = FALSE; |
| // |
| // Set up global pointer to the system table, boot services table, |
| // and runtime services table |
| // |
| ST = SystemTable; |
| BS = SystemTable->BootServices; |
| RT = SystemTable->RuntimeServices; |
| // ASSERT (CheckCrc(0, &ST->Hdr)); |
| // ASSERT (CheckCrc(0, &BS->Hdr)); |
| // ASSERT (CheckCrc(0, &RT->Hdr)); |
| // |
| // Initialize pool allocation type |
| // |
| if (ImageHandle) { |
| Status = BS->HandleProtocol ( |
| ImageHandle, |
| &LoadedImageProtocol, |
| (VOID*)&LoadedImage |
| ); |
| if (!EFI_ERROR(Status)) { |
| PoolAllocationType = LoadedImage->ImageDataType; |
| } |
| EFIDebugVariable (); |
| } |
| // |
| // Initialize Guid table |
| // |
| InitializeGuid(); |
| InitializeLibPlatform(ImageHandle,SystemTable); |
| } |
| // |
| // |
| // |
| if (ImageHandle && UnicodeInterface == &LibStubUnicodeInterface) { |
| LangCode = LibGetVariable (VarLanguage, &EfiGlobalVariable); |
| InitializeUnicodeSupport (LangCode); |
| if (LangCode) { |
| FreePool (LangCode); |
| } |
| } |
| } |
| VOID |
| InitializeUnicodeSupport ( |
| CHAR8 *LangCode |
| ) |
| { |
| EFI_UNICODE_COLLATION_INTERFACE *Ui; |
| EFI_STATUS Status; |
| CHAR8 *Languages; |
| UINTN Index, Position, Length; |
| UINTN NoHandles; |
| EFI_HANDLE *Handles; |
| // |
| // If we don't know it, lookup the current language code |
| // |
| LibLocateHandle (ByProtocol, &UnicodeCollationProtocol, NULL, &NoHandles, &Handles); |
| if (!LangCode || !NoHandles) { |
| goto Done; |
| } |
| // |
| // Check all driver's for a matching language code |
| // |
| for (Index=0; Index < NoHandles; Index++) { |
| Status = BS->HandleProtocol (Handles[Index], &UnicodeCollationProtocol, (VOID*)&Ui); |
| if (EFI_ERROR(Status)) { |
| continue; |
| } |
| // |
| // Check for a matching language code |
| // |
| Languages = Ui->SupportedLanguages; |
| Length = strlena(Languages); |
| for (Position=0; Position < Length; Position += ISO_639_2_ENTRY_SIZE) { |
| // |
| // If this code matches, use this driver |
| // |
| if (CompareMem (Languages+Position, LangCode, ISO_639_2_ENTRY_SIZE) == 0) { |
| UnicodeInterface = Ui; |
| goto Done; |
| } |
| } |
| } |
| Done: |
| // |
| // Cleanup |
| // |
| if (Handles) { |
| FreePool (Handles); |
| } |
| } |
| VOID |
| EFIDebugVariable ( |
| VOID |
| ) |
| { |
| EFI_STATUS Status; |
| UINT32 Attributes; |
| UINTN DataSize; |
| UINTN NewEFIDebug; |
| DataSize = sizeof(EFIDebug); |
| Status = RT->GetVariable(L"EFIDebug", &EfiGlobalVariable, &Attributes, &DataSize, &NewEFIDebug); |
| if (!EFI_ERROR(Status)) { |
| EFIDebug = NewEFIDebug; |
| } |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/boxdraw.c |
|---|
| 0,0 → 1,173 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| BoxDraw.c |
| Abstract: |
| Lib functions to support Box Draw Unicode code pages. |
| Revision History |
| --*/ |
| #include "lib.h" |
| typedef struct { |
| CHAR16 Unicode; |
| CHAR8 PcAnsi; |
| CHAR8 Ascii; |
| } UNICODE_TO_CHAR; |
| // |
| // This list is used to define the valid extend chars. |
| // It also provides a mapping from Unicode to PCANSI or |
| // ASCII. The ASCII mapping we just made up. |
| // |
| // |
| STATIC UNICODE_TO_CHAR UnicodeToPcAnsiOrAscii[] = { |
| { BOXDRAW_HORIZONTAL, 0xc4, L'-'}, |
| { BOXDRAW_VERTICAL, 0xb3, L'|'}, |
| { BOXDRAW_DOWN_RIGHT, 0xda, L'/'}, |
| { BOXDRAW_DOWN_LEFT, 0xbf, L'\\'}, |
| { BOXDRAW_UP_RIGHT, 0xc0, L'\\'}, |
| { BOXDRAW_UP_LEFT, 0xd9, L'/'}, |
| { BOXDRAW_VERTICAL_RIGHT, 0xc3, L'|'}, |
| { BOXDRAW_VERTICAL_LEFT, 0xb4, L'|'}, |
| { BOXDRAW_DOWN_HORIZONTAL, 0xc2, L'+'}, |
| { BOXDRAW_UP_HORIZONTAL, 0xc1, L'+'}, |
| { BOXDRAW_VERTICAL_HORIZONTAL, 0xc5, L'+'}, |
| { BOXDRAW_DOUBLE_HORIZONTAL, 0xcd, L'-'}, |
| { BOXDRAW_DOUBLE_VERTICAL, 0xba, L'|'}, |
| { BOXDRAW_DOWN_RIGHT_DOUBLE, 0xd5, L'/'}, |
| { BOXDRAW_DOWN_DOUBLE_RIGHT, 0xd6, L'/'}, |
| { BOXDRAW_DOUBLE_DOWN_RIGHT, 0xc9, L'/'}, |
| { BOXDRAW_DOWN_LEFT_DOUBLE, 0xb8, L'\\'}, |
| { BOXDRAW_DOWN_DOUBLE_LEFT, 0xb7, L'\\'}, |
| { BOXDRAW_DOUBLE_DOWN_LEFT, 0xbb, L'\\'}, |
| { BOXDRAW_UP_RIGHT_DOUBLE, 0xd4, L'\\'}, |
| { BOXDRAW_UP_DOUBLE_RIGHT, 0xd3, L'\\'}, |
| { BOXDRAW_DOUBLE_UP_RIGHT, 0xc8, L'\\'}, |
| { BOXDRAW_UP_LEFT_DOUBLE, 0xbe, L'/'}, |
| { BOXDRAW_UP_DOUBLE_LEFT, 0xbd, L'/'}, |
| { BOXDRAW_DOUBLE_UP_LEFT, 0xbc, L'/'}, |
| { BOXDRAW_VERTICAL_RIGHT_DOUBLE, 0xc6, L'|'}, |
| { BOXDRAW_VERTICAL_DOUBLE_RIGHT, 0xc7, L'|'}, |
| { BOXDRAW_DOUBLE_VERTICAL_RIGHT, 0xcc, L'|'}, |
| { BOXDRAW_VERTICAL_LEFT_DOUBLE, 0xb5, L'|'}, |
| { BOXDRAW_VERTICAL_DOUBLE_LEFT, 0xb6, L'|'}, |
| { BOXDRAW_DOUBLE_VERTICAL_LEFT, 0xb9, L'|'}, |
| { BOXDRAW_DOWN_HORIZONTAL_DOUBLE, 0xd1, L'+'}, |
| { BOXDRAW_DOWN_DOUBLE_HORIZONTAL, 0xd2, L'+'}, |
| { BOXDRAW_DOUBLE_DOWN_HORIZONTAL, 0xcb, L'+'}, |
| { BOXDRAW_UP_HORIZONTAL_DOUBLE, 0xcf, L'+'}, |
| { BOXDRAW_UP_DOUBLE_HORIZONTAL, 0xd0, L'+'}, |
| { BOXDRAW_DOUBLE_UP_HORIZONTAL, 0xca, L'+'}, |
| { BOXDRAW_VERTICAL_HORIZONTAL_DOUBLE, 0xd8, L'+'}, |
| { BOXDRAW_VERTICAL_DOUBLE_HORIZONTAL, 0xd7, L'+'}, |
| { BOXDRAW_DOUBLE_VERTICAL_HORIZONTAL, 0xce, L'+'}, |
| { BLOCKELEMENT_FULL_BLOCK, 0xdb, L'*'}, |
| { BLOCKELEMENT_LIGHT_SHADE, 0xb0, L'+'}, |
| { GEOMETRICSHAPE_UP_TRIANGLE, 0x1e, L'^'}, |
| { GEOMETRICSHAPE_RIGHT_TRIANGLE, 0x10, L'>'}, |
| { GEOMETRICSHAPE_DOWN_TRIANGLE, 0x1f, L'v'}, |
| { GEOMETRICSHAPE_LEFT_TRIANGLE, 0x11, L'<'}, |
| /* BugBug: Left Arrow is an ESC. We can not make it print |
| on a PCANSI terminal. If we can make left arrow |
| come out on PC ANSI we can add it back. |
| { ARROW_LEFT, 0x1b, L'<'}, |
| */ |
| { ARROW_UP, 0x18, L'^'}, |
| /* BugBut: Took out left arrow so right has to go too. |
| { ARROW_RIGHT, 0x1a, L'>'}, |
| */ |
| { ARROW_DOWN, 0x19, L'v'}, |
| { 0x0000, 0x00 } |
| }; |
| BOOLEAN |
| LibIsValidTextGraphics ( |
| IN CHAR16 Graphic, |
| OUT CHAR8 *PcAnsi, OPTIONAL |
| OUT CHAR8 *Ascii OPTIONAL |
| ) |
| /*++ |
| Routine Description: |
| Detects if a Unicode char is for Box Drawing text graphics. |
| Arguments: |
| Grphic - Unicode char to test. |
| PcAnsi - Optional pointer to return PCANSI equivalent of Graphic. |
| Asci - Optional pointer to return Ascii equivalent of Graphic. |
| Returns: |
| TRUE if Gpaphic is a supported Unicode Box Drawing character. |
| --*/{ |
| UNICODE_TO_CHAR *Table; |
| if ((((Graphic & 0xff00) != 0x2500) && ((Graphic & 0xff00) != 0x2100))) { |
| // |
| // Unicode drawing code charts are all in the 0x25xx range, |
| // arrows are 0x21xx |
| // |
| return FALSE; |
| } |
| for (Table = UnicodeToPcAnsiOrAscii; Table->Unicode != 0x0000; Table++) { |
| if (Graphic == Table->Unicode) { |
| if (PcAnsi) { |
| *PcAnsi = Table->PcAnsi; |
| } |
| if (Ascii) { |
| *Ascii = Table->Ascii; |
| } |
| return TRUE; |
| } |
| } |
| return FALSE; |
| } |
| BOOLEAN |
| IsValidAscii ( |
| IN CHAR16 Ascii |
| ) |
| { |
| if ((Ascii >= 0x20) && (Ascii <= 0x7f)) { |
| return TRUE; |
| } |
| return FALSE; |
| } |
| BOOLEAN |
| IsValidEfiCntlChar ( |
| IN CHAR16 c |
| ) |
| { |
| if (c == CHAR_NULL || c == CHAR_BACKSPACE || c == CHAR_LINEFEED || c == CHAR_CARRIAGE_RETURN) { |
| return TRUE; |
| } |
| return FALSE; |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/crc.c |
|---|
| 0,0 → 1,218 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| crc.c |
| Abstract: |
| CRC32 functions |
| Revision History |
| --*/ |
| #include "lib.h" |
| UINT32 CRCTable[256] = { |
| 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, |
| 0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, |
| 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2, |
| 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, |
| 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, |
| 0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, |
| 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C, |
| 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, |
| 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, |
| 0xCFBA9599, 0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, |
| 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190, 0x01DB7106, |
| 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, |
| 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, |
| 0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, |
| 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950, |
| 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, |
| 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, |
| 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, |
| 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA, |
| 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, |
| 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, |
| 0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, |
| 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84, |
| 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, |
| 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, |
| 0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, |
| 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8, 0xA1D1937E, |
| 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, |
| 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, |
| 0x316E8EEF, 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, |
| 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28, |
| 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, |
| 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, |
| 0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, |
| 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242, |
| 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, |
| 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, |
| 0x616BFFD3, 0x166CCF45, 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, |
| 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, |
| 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, |
| 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, |
| 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, |
| 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D |
| }; |
| VOID |
| SetCrc ( |
| IN OUT EFI_TABLE_HEADER *Hdr |
| ) |
| /*++ |
| Routine Description: |
| Updates the CRC32 value in the table header |
| Arguments: |
| Hdr - The table to update |
| Returns: |
| None |
| --*/ |
| { |
| SetCrcAltSize (Hdr->HeaderSize, Hdr); |
| } |
| VOID |
| SetCrcAltSize ( |
| IN UINTN Size, |
| IN OUT EFI_TABLE_HEADER *Hdr |
| ) |
| /*++ |
| Routine Description: |
| Updates the CRC32 value in the table header |
| Arguments: |
| Hdr - The table to update |
| Returns: |
| None |
| --*/ |
| { |
| Hdr->CRC32 = 0; |
| Hdr->CRC32 = CalculateCrc((UINT8 *)Hdr, Size); |
| } |
| BOOLEAN |
| CheckCrc ( |
| IN UINTN MaxSize, |
| IN OUT EFI_TABLE_HEADER *Hdr |
| ) |
| /*++ |
| Routine Description: |
| Checks the CRC32 value in the table header |
| Arguments: |
| Hdr - The table to check |
| Returns: |
| TRUE if the CRC is OK in the table |
| --*/ |
| { |
| return CheckCrcAltSize (MaxSize, Hdr->HeaderSize, Hdr); |
| } |
| BOOLEAN |
| CheckCrcAltSize ( |
| IN UINTN MaxSize, |
| IN UINTN Size, |
| IN OUT EFI_TABLE_HEADER *Hdr |
| ) |
| /*++ |
| Routine Description: |
| Checks the CRC32 value in the table header |
| Arguments: |
| Hdr - The table to check |
| Returns: |
| TRUE if the CRC is OK in the table |
| --*/ |
| { |
| UINT32 Crc; |
| UINT32 OrgCrc; |
| BOOLEAN f; |
| if (Size == 0) { |
| // |
| // If header size is 0 CRC will pass so return FALSE here |
| // |
| return FALSE; |
| } |
| if (MaxSize && Size > MaxSize) { |
| DEBUG((D_ERROR, "CheckCrc32: Size > MaxSize\n")); |
| return FALSE; |
| } |
| // clear old crc from header |
| OrgCrc = Hdr->CRC32; |
| Hdr->CRC32 = 0; |
| Crc = CalculateCrc((UINT8 *)Hdr, Size); |
| // set restults |
| Hdr->CRC32 = OrgCrc; |
| // return status |
| f = OrgCrc == (UINT32) Crc; |
| if (!f) { |
| DEBUG((D_ERROR, "CheckCrc32: Crc check failed\n")); |
| } |
| return f; |
| } |
| UINT32 |
| CalculateCrc ( |
| UINT8 *pt, |
| UINTN Size |
| ) |
| { |
| UINTN Crc; |
| // compute crc |
| Crc = 0xffffffff; |
| while (Size) { |
| Crc = (Crc >> 8) ^ CRCTable[(UINT8) Crc ^ *pt]; |
| pt += 1; |
| Size -= 1; |
| } |
| Crc = Crc ^ 0xffffffff; |
| return (UINT32)Crc; |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/str.c |
|---|
| 0,0 → 1,370 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| str.c |
| Abstract: |
| Revision History |
| --*/ |
| #include "lib.h" |
| INTN |
| StrCmp ( |
| IN CHAR16 *s1, |
| IN CHAR16 *s2 |
| ) |
| // compare strings |
| { |
| return RtStrCmp(s1, s2); |
| } |
| INTN |
| StrnCmp ( |
| IN CHAR16 *s1, |
| IN CHAR16 *s2, |
| IN UINTN len |
| ) |
| // compare strings |
| { |
| while (*s1 && len) { |
| if (*s1 != *s2) { |
| break; |
| } |
| s1 += 1; |
| s2 += 1; |
| len -= 1; |
| } |
| return len ? *s1 - *s2 : 0; |
| } |
| INTN |
| LibStubStriCmp ( |
| IN EFI_UNICODE_COLLATION_INTERFACE *This, |
| IN CHAR16 *s1, |
| IN CHAR16 *s2 |
| ) |
| { |
| return StrCmp (s1, s2); |
| } |
| VOID |
| LibStubStrLwrUpr ( |
| IN EFI_UNICODE_COLLATION_INTERFACE *This, |
| IN CHAR16 *Str |
| ) |
| { |
| } |
| INTN |
| StriCmp ( |
| IN CHAR16 *s1, |
| IN CHAR16 *s2 |
| ) |
| // compare strings |
| { |
| return UnicodeInterface->StriColl(UnicodeInterface, s1, s2); |
| } |
| VOID |
| StrLwr ( |
| IN CHAR16 *Str |
| ) |
| // lwoer case string |
| { |
| UnicodeInterface->StrLwr(UnicodeInterface, Str); |
| } |
| VOID |
| StrUpr ( |
| IN CHAR16 *Str |
| ) |
| // upper case string |
| { |
| UnicodeInterface->StrUpr(UnicodeInterface, Str); |
| } |
| VOID |
| StrCpy ( |
| IN CHAR16 *Dest, |
| IN CHAR16 *Src |
| ) |
| // copy strings |
| { |
| RtStrCpy (Dest, Src); |
| } |
| VOID |
| StrCat ( |
| IN CHAR16 *Dest, |
| IN CHAR16 *Src |
| ) |
| { |
| RtStrCat(Dest, Src); |
| } |
| UINTN |
| StrLen ( |
| IN CHAR16 *s1 |
| ) |
| // string length |
| { |
| return RtStrLen(s1); |
| } |
| UINTN |
| StrSize ( |
| IN CHAR16 *s1 |
| ) |
| // string size |
| { |
| return RtStrSize(s1); |
| } |
| CHAR16 * |
| StrDuplicate ( |
| IN CHAR16 *Src |
| ) |
| // duplicate a string |
| { |
| CHAR16 *Dest; |
| UINTN Size; |
| Size = StrSize(Src); |
| Dest = AllocatePool (Size); |
| if (Dest) { |
| CopyMem (Dest, Src, Size); |
| } |
| return Dest; |
| } |
| UINTN |
| strlena ( |
| IN CHAR8 *s1 |
| ) |
| // string length |
| { |
| UINTN len; |
| for (len=0; *s1; s1+=1, len+=1) ; |
| return len; |
| } |
| UINTN |
| strcmpa ( |
| IN CHAR8 *s1, |
| IN CHAR8 *s2 |
| ) |
| // compare strings |
| { |
| while (*s1) { |
| if (*s1 != *s2) { |
| break; |
| } |
| s1 += 1; |
| s2 += 1; |
| } |
| return *s1 - *s2; |
| } |
| UINTN |
| strncmpa ( |
| IN CHAR8 *s1, |
| IN CHAR8 *s2, |
| IN UINTN len |
| ) |
| // compare strings |
| { |
| while (*s1 && len) { |
| if (*s1 != *s2) { |
| break; |
| } |
| s1 += 1; |
| s2 += 1; |
| len -= 1; |
| } |
| return len ? *s1 - *s2 : 0; |
| } |
| UINTN |
| xtoi ( |
| CHAR16 *str |
| ) |
| // convert hex string to uint |
| { |
| UINTN u; |
| CHAR16 c; |
| // skip preceeding white space |
| while (*str && *str == ' ') { |
| str += 1; |
| } |
| // convert hex digits |
| u = 0; |
| while ((c = *(str++))) { |
| if (c >= 'a' && c <= 'f') { |
| c -= 'a' - 'A'; |
| } |
| if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'F')) { |
| u = (u << 4) | (c - (c >= 'A' ? 'A'-10 : '0')); |
| } else { |
| break; |
| } |
| } |
| return u; |
| } |
| UINTN |
| Atoi ( |
| CHAR16 *str |
| ) |
| // convert hex string to uint |
| { |
| UINTN u; |
| CHAR16 c; |
| // skip preceeding white space |
| while (*str && *str == ' ') { |
| str += 1; |
| } |
| // convert digits |
| u = 0; |
| while ((c = *(str++))) { |
| if (c >= '0' && c <= '9') { |
| u = (u * 10) + c - '0'; |
| } else { |
| break; |
| } |
| } |
| return u; |
| } |
| BOOLEAN |
| MetaMatch ( |
| IN CHAR16 *String, |
| IN CHAR16 *Pattern |
| ) |
| { |
| CHAR16 c, p, l; |
| for (; ;) { |
| p = *Pattern; |
| Pattern += 1; |
| switch (p) { |
| case 0: |
| // End of pattern. If end of string, TRUE match |
| return *String ? FALSE : TRUE; |
| case '*': |
| // Match zero or more chars |
| while (*String) { |
| if (MetaMatch (String, Pattern)) { |
| return TRUE; |
| } |
| String += 1; |
| } |
| return MetaMatch (String, Pattern); |
| case '?': |
| // Match any one char |
| if (!*String) { |
| return FALSE; |
| } |
| String += 1; |
| break; |
| case '[': |
| // Match char set |
| c = *String; |
| if (!c) { |
| return FALSE; // syntax problem |
| } |
| l = 0; |
| while ((p = *Pattern++)) { |
| if (p == ']') { |
| return FALSE; |
| } |
| if (p == '-') { // if range of chars, |
| p = *Pattern; // get high range |
| if (p == 0 || p == ']') { |
| return FALSE; // syntax problem |
| } |
| if (c >= l && c <= p) { // if in range, |
| break; // it's a match |
| } |
| } |
| l = p; |
| if (c == p) { // if char matches |
| break; // move on |
| } |
| } |
| // skip to end of match char set |
| while (p && p != ']') { |
| p = *Pattern; |
| Pattern += 1; |
| } |
| String += 1; |
| break; |
| default: |
| c = *String; |
| if (c != p) { |
| return FALSE; |
| } |
| String += 1; |
| break; |
| } |
| } |
| } |
| BOOLEAN |
| LibStubMetaiMatch ( |
| IN EFI_UNICODE_COLLATION_INTERFACE *This, |
| IN CHAR16 *String, |
| IN CHAR16 *Pattern |
| ) |
| { |
| return MetaMatch (String, Pattern); |
| } |
| BOOLEAN |
| MetaiMatch ( |
| IN CHAR16 *String, |
| IN CHAR16 *Pattern |
| ) |
| { |
| return UnicodeInterface->MetaiMatch(UnicodeInterface, String, Pattern); |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/data.c |
|---|
| 0,0 → 1,154 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| data.c |
| Abstract: |
| EFI library global data |
| Revision History |
| --*/ |
| #include "lib.h" |
| // |
| // LibInitialized - TRUE once InitializeLib() is called for the first time |
| // |
| BOOLEAN LibInitialized = FALSE; |
| // |
| // ST - pointer to the EFI system table |
| // |
| EFI_SYSTEM_TABLE *ST; |
| // |
| // BS - pointer to the boot services table |
| // |
| EFI_BOOT_SERVICES *BS; |
| // |
| // Default pool allocation type |
| // |
| EFI_MEMORY_TYPE PoolAllocationType = EfiBootServicesData; |
| // |
| // Unicode collation functions that are in use |
| // |
| EFI_UNICODE_COLLATION_INTERFACE LibStubUnicodeInterface = { |
| LibStubStriCmp, |
| LibStubMetaiMatch, |
| LibStubStrLwrUpr, |
| LibStubStrLwrUpr, |
| NULL, // FatToStr |
| NULL, // StrToFat |
| NULL // SupportedLanguages |
| }; |
| EFI_UNICODE_COLLATION_INTERFACE *UnicodeInterface = &LibStubUnicodeInterface; |
| // |
| // Root device path |
| // |
| EFI_DEVICE_PATH RootDevicePath[] = { |
| {END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE, {END_DEVICE_PATH_LENGTH,0}} |
| }; |
| EFI_DEVICE_PATH EndDevicePath[] = { |
| {END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE, {END_DEVICE_PATH_LENGTH, 0}} |
| }; |
| EFI_DEVICE_PATH EndInstanceDevicePath[] = { |
| {END_DEVICE_PATH_TYPE, END_INSTANCE_DEVICE_PATH_SUBTYPE, {END_DEVICE_PATH_LENGTH, 0}} |
| }; |
| // |
| // EFI IDs |
| // |
| EFI_GUID EfiGlobalVariable = EFI_GLOBAL_VARIABLE; |
| EFI_GUID NullGuid = { 0,0,0,{0,0,0,0,0,0,0,0} }; |
| // |
| // Protocol IDs |
| // |
| EFI_GUID DevicePathProtocol = DEVICE_PATH_PROTOCOL; |
| EFI_GUID LoadedImageProtocol = LOADED_IMAGE_PROTOCOL; |
| EFI_GUID TextInProtocol = SIMPLE_TEXT_INPUT_PROTOCOL; |
| EFI_GUID TextOutProtocol = SIMPLE_TEXT_OUTPUT_PROTOCOL; |
| EFI_GUID BlockIoProtocol = BLOCK_IO_PROTOCOL; |
| EFI_GUID DiskIoProtocol = DISK_IO_PROTOCOL; |
| EFI_GUID FileSystemProtocol = SIMPLE_FILE_SYSTEM_PROTOCOL; |
| EFI_GUID LoadFileProtocol = LOAD_FILE_PROTOCOL; |
| EFI_GUID DeviceIoProtocol = DEVICE_IO_PROTOCOL; |
| EFI_GUID UnicodeCollationProtocol = UNICODE_COLLATION_PROTOCOL; |
| EFI_GUID SerialIoProtocol = SERIAL_IO_PROTOCOL; |
| EFI_GUID SimpleNetworkProtocol = EFI_SIMPLE_NETWORK_PROTOCOL; |
| EFI_GUID PxeBaseCodeProtocol = EFI_PXE_BASE_CODE_PROTOCOL; |
| EFI_GUID PxeCallbackProtocol = EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL; |
| EFI_GUID NetworkInterfaceIdentifierProtocol = EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL; |
| EFI_GUID UiProtocol = EFI_UI_PROTOCOL; |
| // |
| // File system information IDs |
| // |
| EFI_GUID GenericFileInfo = EFI_FILE_INFO_ID; |
| EFI_GUID FileSystemInfo = EFI_FILE_SYSTEM_INFO_ID; |
| EFI_GUID FileSystemVolumeLabelInfo = EFI_FILE_SYSTEM_VOLUME_LABEL_INFO_ID; |
| // |
| // Reference implementation public protocol IDs |
| // |
| EFI_GUID InternalShellProtocol = INTERNAL_SHELL_GUID; |
| EFI_GUID VariableStoreProtocol = VARIABLE_STORE_PROTOCOL; |
| EFI_GUID LegacyBootProtocol = LEGACY_BOOT_PROTOCOL; |
| EFI_GUID VgaClassProtocol = VGA_CLASS_DRIVER_PROTOCOL; |
| EFI_GUID TextOutSpliterProtocol = TEXT_OUT_SPLITER_PROTOCOL; |
| EFI_GUID ErrorOutSpliterProtocol = ERROR_OUT_SPLITER_PROTOCOL; |
| EFI_GUID TextInSpliterProtocol = TEXT_IN_SPLITER_PROTOCOL; |
| EFI_GUID AdapterDebugProtocol = ADAPTER_DEBUG_PROTOCOL; |
| // |
| // Device path media protocol IDs |
| // |
| EFI_GUID PcAnsiProtocol = DEVICE_PATH_MESSAGING_PC_ANSI; |
| EFI_GUID Vt100Protocol = DEVICE_PATH_MESSAGING_VT_100; |
| // |
| // EFI GPT Partition Type GUIDs |
| // |
| EFI_GUID EfiPartTypeSystemPartitionGuid = EFI_PART_TYPE_EFI_SYSTEM_PART_GUID; |
| EFI_GUID EfiPartTypeLegacyMbrGuid = EFI_PART_TYPE_LEGACY_MBR_GUID; |
| // |
| // Reference implementation Vendor Device Path Guids |
| // |
| EFI_GUID UnknownDevice = UNKNOWN_DEVICE_GUID; |
| // |
| // Configuration Table GUIDs |
| // |
| EFI_GUID MpsTableGuid = MPS_TABLE_GUID; |
| EFI_GUID AcpiTableGuid = ACPI_TABLE_GUID; |
| EFI_GUID SMBIOSTableGuid = SMBIOS_TABLE_GUID; |
| EFI_GUID SalSystemTableGuid = SAL_SYSTEM_TABLE_GUID; |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/hand.c |
|---|
| 0,0 → 1,620 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| hand.c |
| Abstract: |
| Revision History |
| --*/ |
| #include "lib.h" |
| #include "efistdarg.h" // !!! |
| EFI_STATUS |
| LibLocateProtocol ( |
| IN EFI_GUID *ProtocolGuid, |
| OUT VOID **Interface |
| ) |
| // |
| // Find the first instance of this Protocol in the system and return it's interface |
| // |
| { |
| EFI_STATUS Status; |
| UINTN NumberHandles, Index; |
| EFI_HANDLE *Handles; |
| *Interface = NULL; |
| Status = LibLocateHandle (ByProtocol, ProtocolGuid, NULL, &NumberHandles, &Handles); |
| if (EFI_ERROR(Status)) { |
| DEBUG((D_INFO, "LibLocateProtocol: Handle not found\n")); |
| return Status; |
| } |
| for (Index=0; Index < NumberHandles; Index++) { |
| Status = BS->HandleProtocol (Handles[Index], ProtocolGuid, Interface); |
| if (!EFI_ERROR(Status)) { |
| break; |
| } |
| } |
| if (Handles) { |
| FreePool (Handles); |
| } |
| return Status; |
| } |
| EFI_STATUS |
| LibLocateHandle ( |
| IN EFI_LOCATE_SEARCH_TYPE SearchType, |
| IN EFI_GUID *Protocol OPTIONAL, |
| IN VOID *SearchKey OPTIONAL, |
| IN OUT UINTN *NoHandles, |
| OUT EFI_HANDLE **Buffer |
| ) |
| { |
| EFI_STATUS Status; |
| UINTN BufferSize; |
| // |
| // Initialize for GrowBuffer loop |
| // |
| Status = EFI_SUCCESS; |
| *Buffer = NULL; |
| BufferSize = 50 * sizeof(EFI_HANDLE); |
| // |
| // Call the real function |
| // |
| while (GrowBuffer (&Status, (VOID **) Buffer, BufferSize)) { |
| Status = BS->LocateHandle ( |
| SearchType, |
| Protocol, |
| SearchKey, |
| &BufferSize, |
| *Buffer |
| ); |
| } |
| *NoHandles = BufferSize / sizeof (EFI_HANDLE); |
| if (EFI_ERROR(Status)) { |
| *NoHandles = 0; |
| } |
| return Status; |
| } |
| EFI_STATUS |
| LibLocateHandleByDiskSignature ( |
| IN UINT8 MBRType, |
| IN UINT8 SignatureType, |
| IN VOID *Signature, |
| IN OUT UINTN *NoHandles, |
| OUT EFI_HANDLE **Buffer |
| ) |
| { |
| EFI_STATUS Status; |
| UINTN BufferSize; |
| UINTN NoBlockIoHandles; |
| EFI_HANDLE *BlockIoBuffer; |
| EFI_DEVICE_PATH *DevicePath; |
| UINTN Index; |
| EFI_DEVICE_PATH *Start, *Next, *DevPath; |
| HARDDRIVE_DEVICE_PATH *HardDriveDevicePath; |
| BOOLEAN Match; |
| BOOLEAN PreviousNodeIsHardDriveDevicePath; |
| // |
| // Initialize for GrowBuffer loop |
| // |
| BlockIoBuffer = NULL; |
| BufferSize = 50 * sizeof(EFI_HANDLE); |
| // |
| // Call the real function |
| // |
| while (GrowBuffer (&Status, (VOID **)&BlockIoBuffer, BufferSize)) { |
| // |
| // Get list of device handles that support the BLOCK_IO Protocol. |
| // |
| Status = BS->LocateHandle ( |
| ByProtocol, |
| &BlockIoProtocol, |
| NULL, |
| &BufferSize, |
| BlockIoBuffer |
| ); |
| } |
| NoBlockIoHandles = BufferSize / sizeof (EFI_HANDLE); |
| if (EFI_ERROR(Status)) { |
| NoBlockIoHandles = 0; |
| } |
| // |
| // If there was an error or there are no device handles that support |
| // the BLOCK_IO Protocol, then return. |
| // |
| if (NoBlockIoHandles == 0) { |
| FreePool(BlockIoBuffer); |
| *NoHandles = 0; |
| *Buffer = NULL; |
| return Status; |
| } |
| // |
| // Loop through all the device handles that support the BLOCK_IO Protocol |
| // |
| *NoHandles = 0; |
| for(Index=0;Index<NoBlockIoHandles;Index++) { |
| Status = BS->HandleProtocol (BlockIoBuffer[Index], |
| &DevicePathProtocol, |
| (VOID*)&DevicePath |
| ); |
| // |
| // Search DevicePath for a Hard Drive Media Device Path node. |
| // If one is found, then see if it matches the signature that was |
| // passed in. If it does match, and the next node is the End of the |
| // device path, and the previous node is not a Hard Drive Media Device |
| // Path, then we have found a match. |
| // |
| Match = FALSE; |
| if (DevicePath != NULL) { |
| PreviousNodeIsHardDriveDevicePath = FALSE; |
| DevPath = DevicePath; |
| Start = DevPath; |
| // |
| // Check for end of device path type |
| // |
| for (; ;) { |
| if ((DevicePathType(DevPath) == MEDIA_DEVICE_PATH) && |
| (DevicePathSubType(DevPath) == MEDIA_HARDDRIVE_DP)) { |
| HardDriveDevicePath = (HARDDRIVE_DEVICE_PATH *)(DevPath); |
| if (PreviousNodeIsHardDriveDevicePath == FALSE) { |
| Next = NextDevicePathNode(DevPath); |
| if (IsDevicePathEndType(Next)) { |
| if ((HardDriveDevicePath->MBRType == MBRType) && |
| (HardDriveDevicePath->SignatureType == SignatureType)) { |
| switch(SignatureType) { |
| case SIGNATURE_TYPE_MBR: |
| if (*((UINT32 *)(Signature)) == *(UINT32 *)(&(HardDriveDevicePath->Signature[0]))) { |
| Match = TRUE; |
| } |
| break; |
| case SIGNATURE_TYPE_GUID: |
| if (CompareGuid((EFI_GUID *)Signature,(EFI_GUID *)(&(HardDriveDevicePath->Signature[0]))) == 0) { |
| Match = TRUE; |
| } |
| break; |
| } |
| } |
| } |
| } |
| PreviousNodeIsHardDriveDevicePath = TRUE; |
| } else { |
| PreviousNodeIsHardDriveDevicePath = FALSE; |
| } |
| if (IsDevicePathEnd(DevPath)) { |
| break; |
| } |
| DevPath = NextDevicePathNode(DevPath); |
| } |
| } |
| if (Match == FALSE) { |
| BlockIoBuffer[Index] = NULL; |
| } else { |
| *NoHandles = *NoHandles + 1; |
| } |
| } |
| // |
| // If there are no matches, then return |
| // |
| if (*NoHandles == 0) { |
| FreePool(BlockIoBuffer); |
| *NoHandles = 0; |
| *Buffer = NULL; |
| return EFI_SUCCESS; |
| } |
| // |
| // Allocate space for the return buffer of device handles. |
| // |
| *Buffer = AllocatePool(*NoHandles * sizeof(EFI_HANDLE)); |
| if (*Buffer == NULL) { |
| FreePool(BlockIoBuffer); |
| *NoHandles = 0; |
| *Buffer = NULL; |
| return EFI_OUT_OF_RESOURCES; |
| } |
| // |
| // Build list of matching device handles. |
| // |
| *NoHandles = 0; |
| for(Index=0;Index<NoBlockIoHandles;Index++) { |
| if (BlockIoBuffer[Index] != NULL) { |
| (*Buffer)[*NoHandles] = BlockIoBuffer[Index]; |
| *NoHandles = *NoHandles + 1; |
| } |
| } |
| FreePool(BlockIoBuffer); |
| return EFI_SUCCESS; |
| } |
| EFI_FILE_HANDLE |
| LibOpenRoot ( |
| IN EFI_HANDLE DeviceHandle |
| ) |
| { |
| EFI_STATUS Status; |
| EFI_FILE_IO_INTERFACE *Volume; |
| EFI_FILE_HANDLE File; |
| // |
| // File the file system interface to the device |
| // |
| Status = BS->HandleProtocol (DeviceHandle, &FileSystemProtocol, (VOID*)&Volume); |
| // |
| // Open the root directory of the volume |
| // |
| if (!EFI_ERROR(Status)) { |
| Status = Volume->OpenVolume(Volume, &File); |
| } |
| // |
| // Done |
| // |
| return EFI_ERROR(Status) ? NULL : File; |
| } |
| EFI_FILE_INFO * |
| LibFileInfo ( |
| IN EFI_FILE_HANDLE FHand |
| ) |
| { |
| EFI_STATUS Status; |
| EFI_FILE_INFO *Buffer; |
| UINTN BufferSize; |
| // |
| // Initialize for GrowBuffer loop |
| // |
| Buffer = NULL; |
| BufferSize = SIZE_OF_EFI_FILE_INFO + 200; |
| // |
| // Call the real function |
| // |
| while (GrowBuffer (&Status, (VOID **) &Buffer, BufferSize)) { |
| Status = FHand->GetInfo ( |
| FHand, |
| &GenericFileInfo, |
| &BufferSize, |
| Buffer |
| ); |
| } |
| return Buffer; |
| } |
| EFI_FILE_SYSTEM_INFO * |
| LibFileSystemInfo ( |
| IN EFI_FILE_HANDLE FHand |
| ) |
| { |
| EFI_STATUS Status; |
| EFI_FILE_SYSTEM_INFO *Buffer; |
| UINTN BufferSize; |
| // |
| // Initialize for GrowBuffer loop |
| // |
| Buffer = NULL; |
| BufferSize = SIZE_OF_EFI_FILE_SYSTEM_INFO + 200; |
| // |
| // Call the real function |
| // |
| while (GrowBuffer (&Status, (VOID **) &Buffer, BufferSize)) { |
| Status = FHand->GetInfo ( |
| FHand, |
| &FileSystemInfo, |
| &BufferSize, |
| Buffer |
| ); |
| } |
| return Buffer; |
| } |
| EFI_FILE_SYSTEM_VOLUME_LABEL_INFO * |
| LibFileSystemVolumeLabelInfo ( |
| IN EFI_FILE_HANDLE FHand |
| ) |
| { |
| EFI_STATUS Status; |
| EFI_FILE_SYSTEM_VOLUME_LABEL_INFO *Buffer; |
| UINTN BufferSize; |
| // |
| // Initialize for GrowBuffer loop |
| // |
| Buffer = NULL; |
| BufferSize = SIZE_OF_EFI_FILE_SYSTEM_VOLUME_LABEL_INFO + 200; |
| // |
| // Call the real function |
| // |
| while (GrowBuffer (&Status, (VOID **) &Buffer, BufferSize)) { |
| Status = FHand->GetInfo ( |
| FHand, |
| &FileSystemVolumeLabelInfo, |
| &BufferSize, |
| Buffer |
| ); |
| } |
| return Buffer; |
| } |
| EFI_STATUS |
| LibInstallProtocolInterfaces ( |
| IN OUT EFI_HANDLE *Handle, |
| ... |
| ) |
| { |
| va_list args; |
| EFI_STATUS Status; |
| EFI_GUID *Protocol; |
| VOID *Interface; |
| EFI_TPL OldTpl; |
| UINTN Index; |
| EFI_HANDLE OldHandle; |
| // |
| // Syncronize with notifcations |
| // |
| OldTpl = BS->RaiseTPL(TPL_NOTIFY); |
| OldHandle = *Handle; |
| // |
| // Install the protocol interfaces |
| // |
| Index = 0; |
| Status = EFI_SUCCESS; |
| va_start (args, Handle); |
| while (!EFI_ERROR(Status)) { |
| // |
| // If protocol is NULL, then it's the end of the list |
| // |
| Protocol = va_arg(args, EFI_GUID *); |
| if (!Protocol) { |
| break; |
| } |
| Interface = va_arg(args, VOID *); |
| // |
| // Install it |
| // |
| DEBUG((D_INFO, "LibInstallProtocolInterface: %d %x\n", Protocol, Interface)); |
| Status = BS->InstallProtocolInterface (Handle, Protocol, EFI_NATIVE_INTERFACE, Interface); |
| if (EFI_ERROR(Status)) { |
| break; |
| } |
| Index += 1; |
| } |
| // |
| // If there was an error, remove all the interfaces that were |
| // installed without any errors |
| // |
| if (EFI_ERROR(Status)) { |
| va_start (args, Handle); |
| while (Index) { |
| Protocol = va_arg(args, EFI_GUID *); |
| Interface = va_arg(args, VOID *); |
| BS->UninstallProtocolInterface (*Handle, Protocol, Interface); |
| Index -= 1; |
| } |
| *Handle = OldHandle; |
| } |
| // |
| // Done |
| // |
| BS->RestoreTPL(OldTpl); |
| return Status; |
| } |
| VOID |
| LibUninstallProtocolInterfaces ( |
| IN EFI_HANDLE Handle, |
| ... |
| ) |
| { |
| va_list args; |
| EFI_STATUS Status; |
| EFI_GUID *Protocol; |
| VOID *Interface; |
| va_start (args, Handle); |
| for (; ;) { |
| // |
| // If protocol is NULL, then it's the end of the list |
| // |
| Protocol = va_arg(args, EFI_GUID *); |
| if (!Protocol) { |
| break; |
| } |
| Interface = va_arg(args, VOID *); |
| // |
| // Uninstall it |
| // |
| Status = BS->UninstallProtocolInterface (Handle, Protocol, Interface); |
| if (EFI_ERROR(Status)) { |
| DEBUG((D_ERROR, "LibUninstallProtocolInterfaces: failed %g, %r\n", Protocol, Handle)); |
| } |
| } |
| } |
| EFI_STATUS |
| LibReinstallProtocolInterfaces ( |
| IN OUT EFI_HANDLE *Handle, |
| ... |
| ) |
| { |
| va_list args; |
| EFI_STATUS Status; |
| EFI_GUID *Protocol; |
| VOID *OldInterface, *NewInterface; |
| EFI_TPL OldTpl; |
| UINTN Index; |
| // |
| // Syncronize with notifcations |
| // |
| OldTpl = BS->RaiseTPL(TPL_NOTIFY); |
| // |
| // Install the protocol interfaces |
| // |
| Index = 0; |
| Status = EFI_SUCCESS; |
| va_start (args, Handle); |
| while (!EFI_ERROR(Status)) { |
| // |
| // If protocol is NULL, then it's the end of the list |
| // |
| Protocol = va_arg(args, EFI_GUID *); |
| if (!Protocol) { |
| break; |
| } |
| OldInterface = va_arg(args, VOID *); |
| NewInterface = va_arg(args, VOID *); |
| // |
| // Reinstall it |
| // |
| Status = BS->ReinstallProtocolInterface (Handle, Protocol, OldInterface, NewInterface); |
| if (EFI_ERROR(Status)) { |
| break; |
| } |
| Index += 1; |
| } |
| // |
| // If there was an error, undo all the interfaces that were |
| // reinstalled without any errors |
| // |
| if (EFI_ERROR(Status)) { |
| va_start (args, Handle); |
| while (Index) { |
| Protocol = va_arg(args, EFI_GUID *); |
| OldInterface = va_arg(args, VOID *); |
| NewInterface = va_arg(args, VOID *); |
| BS->ReinstallProtocolInterface (Handle, Protocol, NewInterface, OldInterface); |
| Index -= 1; |
| } |
| } |
| // |
| // Done |
| // |
| BS->RestoreTPL(OldTpl); |
| return Status; |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/lib.h |
|---|
| 0,0 → 1,88 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| lib.h |
| Abstract: |
| EFI library header files |
| Revision History |
| --*/ |
| #include "efi.h" |
| #include "efilib.h" |
| #include "efirtlib.h" |
| // |
| // Include non architectural protocols |
| // |
| #include "efivar.h" |
| #include "legacyboot.h" |
| #include "intload.h" |
| #include "vgaclass.h" |
| #include "eficonsplit.h" |
| #include "adapterdebug.h" |
| #include "intload.h" |
| #include "efigpt.h" |
| #include "libsmbios.h" |
| // |
| // Prototypes |
| // |
| VOID |
| InitializeGuid ( |
| VOID |
| ); |
| INTN |
| LibStubStriCmp ( |
| IN EFI_UNICODE_COLLATION_INTERFACE *This, |
| IN CHAR16 *S1, |
| IN CHAR16 *S2 |
| ); |
| BOOLEAN |
| LibStubMetaiMatch ( |
| IN EFI_UNICODE_COLLATION_INTERFACE *This, |
| IN CHAR16 *String, |
| IN CHAR16 *Pattern |
| ); |
| VOID |
| LibStubStrLwrUpr ( |
| IN EFI_UNICODE_COLLATION_INTERFACE *This, |
| IN CHAR16 *Str |
| ); |
| BOOLEAN |
| LibMatchDevicePaths ( |
| IN EFI_DEVICE_PATH *Multi, |
| IN EFI_DEVICE_PATH *Single |
| ); |
| EFI_DEVICE_PATH * |
| LibDuplicateDevicePathInstance ( |
| IN EFI_DEVICE_PATH *DevPath |
| ); |
| // |
| // Globals |
| // |
| extern BOOLEAN LibInitialized; |
| extern BOOLEAN LibFwInstance; |
| extern SIMPLE_TEXT_OUTPUT_INTERFACE *LibRuntimeDebugOut; |
| extern EFI_UNICODE_COLLATION_INTERFACE *UnicodeInterface; |
| extern EFI_UNICODE_COLLATION_INTERFACE LibStubUnicodeInterface; |
| extern EFI_RAISE_TPL LibRuntimeRaiseTPL; |
| extern EFI_RESTORE_TPL LibRuntimeRestoreTPL; |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/ia32/initplat.c |
|---|
| 0,0 → 1,28 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| initplat.c |
| Abstract: |
| Revision History |
| --*/ |
| #include "lib.h" |
| VOID |
| InitializeLibPlatform ( |
| IN EFI_HANDLE ImageHandle, |
| IN EFI_SYSTEM_TABLE *SystemTable |
| ) |
| { |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/ia32/math.c |
|---|
| 0,0 → 1,179 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| math.c |
| Abstract: |
| Revision History |
| --*/ |
| #include "lib.h" |
| // |
| // Declare runtime functions |
| // |
| #ifdef RUNTIME_CODE |
| #pragma RUNTIME_CODE(LShiftU64) |
| #pragma RUNTIME_CODE(RShiftU64) |
| #pragma RUNTIME_CODE(MultU64x32) |
| #pragma RUNTIME_CODE(DivU64x32) |
| #endif |
| // |
| // |
| // |
| UINT64 |
| LShiftU64 ( |
| IN UINT64 Operand, |
| IN UINTN Count |
| ) |
| // Left shift 64bit by 32bit and get a 64bit result |
| { |
| #ifdef __GNUC__ |
| return Operand << Count; |
| #else |
| UINT64 Result; |
| _asm { |
| mov eax, dword ptr Operand[0] |
| mov edx, dword ptr Operand[4] |
| mov ecx, Count |
| and ecx, 63 |
| shld edx, eax, cl |
| shl eax, cl |
| cmp ecx, 32 |
| jc short ls10 |
| mov edx, eax |
| xor eax, eax |
| ls10: |
| mov dword ptr Result[0], eax |
| mov dword ptr Result[4], edx |
| } |
| return Result; |
| #endif |
| } |
| UINT64 |
| RShiftU64 ( |
| IN UINT64 Operand, |
| IN UINTN Count |
| ) |
| // Right shift 64bit by 32bit and get a 64bit result |
| { |
| #ifdef __GNUC__ |
| return Operand >> Count; |
| #else |
| UINT64 Result; |
| _asm { |
| mov eax, dword ptr Operand[0] |
| mov edx, dword ptr Operand[4] |
| mov ecx, Count |
| and ecx, 63 |
| shrd eax, edx, cl |
| shr edx, cl |
| cmp ecx, 32 |
| jc short rs10 |
| mov eax, edx |
| xor edx, edx |
| rs10: |
| mov dword ptr Result[0], eax |
| mov dword ptr Result[4], edx |
| } |
| return Result; |
| #endif |
| } |
| UINT64 |
| MultU64x32 ( |
| IN UINT64 Multiplicand, |
| IN UINTN Multiplier |
| ) |
| // Multiple 64bit by 32bit and get a 64bit result |
| { |
| #ifdef __GNUC__ |
| return Multiplicand * Multiplier; |
| #else |
| UINT64 Result; |
| _asm { |
| mov eax, dword ptr Multiplicand[0] |
| mul Multiplier |
| mov dword ptr Result[0], eax |
| mov dword ptr Result[4], edx |
| mov eax, dword ptr Multiplicand[4] |
| mul Multiplier |
| add dword ptr Result[4], eax |
| } |
| return Result; |
| #endif |
| } |
| UINT64 |
| DivU64x32 ( |
| IN UINT64 Dividend, |
| IN UINTN Divisor, |
| OUT UINTN *Remainder OPTIONAL |
| ) |
| // divide 64bit by 32bit and get a 64bit result |
| // N.B. only works for 31bit divisors!! |
| { |
| #ifdef __GNUC__ |
| if (Remainder) |
| *Remainder = Dividend % Divisor; |
| return Dividend / Divisor; |
| #else |
| UINT32 Rem; |
| UINT32 bit; |
| ASSERT (Divisor != 0); |
| ASSERT ((Divisor >> 31) == 0); |
| // |
| // For each bit in the dividend |
| // |
| Rem = 0; |
| for (bit=0; bit < 64; bit++) { |
| _asm { |
| shl dword ptr Dividend[0], 1 ; shift rem:dividend left one |
| rcl dword ptr Dividend[4], 1 |
| rcl dword ptr Rem, 1 |
| mov eax, Rem |
| cmp eax, Divisor ; Is Rem >= Divisor? |
| cmc ; No - do nothing |
| sbb eax, eax ; Else, |
| sub dword ptr Dividend[0], eax ; set low bit in dividen |
| and eax, Divisor ; and |
| sub Rem, eax ; subtract divisor |
| } |
| } |
| if (Remainder) { |
| *Remainder = Rem; |
| } |
| return Dividend; |
| #endif |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/hw.c |
|---|
| 0,0 → 1,132 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| hw.c |
| Abstract: |
| Debug library functions for Hardware IO access |
| Revision History |
| --*/ |
| #include "lib.h" |
| EFI_STATUS |
| InitializeGlobalIoDevice ( |
| IN EFI_DEVICE_PATH *DevicePath, |
| IN EFI_GUID *Protocol, |
| IN CHAR8 *ErrorStr, |
| OUT EFI_DEVICE_IO_INTERFACE **GlobalIoFncs |
| ) |
| /*++ |
| Routine Description: |
| Check to see if DevicePath exists for a given Protocol. Return Error if it |
| exists. Return GlobalIoFuncs set match the DevicePath |
| Arguments: |
| DevicePath - to operate on |
| Protocol - to check the DevicePath against |
| ErrorStr - ASCII string to display on error |
| GlobalIoFncs - Returned with DeviceIoProtocol for the DevicePath |
| Returns: |
| Pass or Fail based on wether GlobalIoFncs where found |
| --*/ |
| { |
| EFI_STATUS Status; |
| EFI_HANDLE Handle; |
| // |
| // Check to see if this device path already has Protocol on it. |
| // if so we are loading recursivly and should exit with an error |
| // |
| Status = BS->LocateDevicePath (Protocol, &DevicePath, &Handle); |
| if (!EFI_ERROR(Status)) { |
| DEBUG ((D_INIT, "Device Already Loaded for %a device\n", ErrorStr)); |
| return EFI_LOAD_ERROR; |
| } |
| Status = BS->LocateDevicePath (&DeviceIoProtocol, &DevicePath, &Handle); |
| if (!EFI_ERROR(Status)) { |
| Status = BS->HandleProtocol (Handle, &DeviceIoProtocol, (VOID*)GlobalIoFncs); |
| } |
| ASSERT (!EFI_ERROR(Status)); |
| return Status; |
| } |
| UINT32 |
| ReadPort ( |
| IN EFI_DEVICE_IO_INTERFACE *GlobalIoFncs, |
| IN EFI_IO_WIDTH Width, |
| IN UINTN Port |
| ) |
| { |
| UINT32 Data; |
| EFI_STATUS Status; |
| Status = GlobalIoFncs->Io.Read (GlobalIoFncs, Width, (UINT64)Port, 1, &Data); |
| ASSERT(!EFI_ERROR(Status)); |
| return Data; |
| } |
| UINT32 |
| WritePort ( |
| IN EFI_DEVICE_IO_INTERFACE *GlobalIoFncs, |
| IN EFI_IO_WIDTH Width, |
| IN UINTN Port, |
| IN UINTN Data |
| ) |
| { |
| EFI_STATUS Status; |
| Status = GlobalIoFncs->Io.Write (GlobalIoFncs, Width, (UINT64)Port, 1, &Data); |
| ASSERT(!EFI_ERROR(Status)); |
| return (UINT32)Data; |
| } |
| UINT32 |
| ReadPciConfig ( |
| IN EFI_DEVICE_IO_INTERFACE *GlobalIoFncs, |
| IN EFI_IO_WIDTH Width, |
| IN UINTN Address |
| ) |
| { |
| UINT32 Data; |
| EFI_STATUS Status; |
| Status = GlobalIoFncs->Pci.Read (GlobalIoFncs, Width, (UINT64)Address, 1, &Data); |
| ASSERT(!EFI_ERROR(Status)); |
| return Data; |
| } |
| UINT32 |
| WritePciConfig ( |
| IN EFI_DEVICE_IO_INTERFACE *GlobalIoFncs, |
| IN EFI_IO_WIDTH Width, |
| IN UINTN Address, |
| IN UINTN Data |
| ) |
| { |
| EFI_STATUS Status; |
| Status = GlobalIoFncs->Pci.Write (GlobalIoFncs, Width, (UINT64)Address, 1, &Data); |
| ASSERT(!EFI_ERROR(Status)); |
| return (UINT32)Data; |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/event.c |
|---|
| 0,0 → 1,149 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| event.c |
| Abstract: |
| Revision History |
| --*/ |
| #include "lib.h" |
| EFI_EVENT |
| LibCreateProtocolNotifyEvent ( |
| IN EFI_GUID *ProtocolGuid, |
| IN EFI_TPL NotifyTpl, |
| IN EFI_EVENT_NOTIFY NotifyFunction, |
| IN VOID *NotifyContext, |
| OUT VOID *Registration |
| ) |
| { |
| EFI_STATUS Status; |
| EFI_EVENT Event; |
| // |
| // Create the event |
| // |
| Status = BS->CreateEvent ( |
| EVT_NOTIFY_SIGNAL, |
| NotifyTpl, |
| NotifyFunction, |
| NotifyContext, |
| &Event |
| ); |
| ASSERT (!EFI_ERROR(Status)); |
| // |
| // Register for protocol notifactions on this event |
| // |
| Status = BS->RegisterProtocolNotify ( |
| ProtocolGuid, |
| Event, |
| Registration |
| ); |
| ASSERT (!EFI_ERROR(Status)); |
| // |
| // Kick the event so we will perform an initial pass of |
| // current installed drivers |
| // |
| BS->SignalEvent (Event); |
| return Event; |
| } |
| EFI_STATUS |
| WaitForSingleEvent ( |
| IN EFI_EVENT Event, |
| IN UINT64 Timeout OPTIONAL |
| ) |
| { |
| EFI_STATUS Status; |
| UINTN Index; |
| EFI_EVENT TimerEvent; |
| EFI_EVENT WaitList[2]; |
| if (Timeout) { |
| // |
| // Create a timer event |
| // |
| Status = BS->CreateEvent (EVT_TIMER, 0, NULL, NULL, &TimerEvent); |
| if (!EFI_ERROR(Status)) { |
| // |
| // Set the timer event |
| // |
| BS->SetTimer (TimerEvent, TimerRelative, Timeout); |
| // |
| // Wait for the original event or the timer |
| // |
| WaitList[0] = Event; |
| WaitList[1] = TimerEvent; |
| Status = BS->WaitForEvent (2, WaitList, &Index); |
| BS->CloseEvent (TimerEvent); |
| // |
| // If the timer expired, change the return to timed out |
| // |
| if (!EFI_ERROR(Status) && Index == 1) { |
| Status = EFI_TIMEOUT; |
| } |
| } |
| } else { |
| // |
| // No timeout... just wait on the event |
| // |
| Status = BS->WaitForEvent (1, &Event, &Index); |
| ASSERT (!EFI_ERROR(Status)); |
| ASSERT (Index == 0); |
| } |
| return Status; |
| } |
| VOID |
| WaitForEventWithTimeout ( |
| IN EFI_EVENT Event, |
| IN UINTN Timeout, |
| IN UINTN Row, |
| IN UINTN Column, |
| IN CHAR16 *String, |
| IN EFI_INPUT_KEY TimeoutKey, |
| OUT EFI_INPUT_KEY *Key |
| ) |
| { |
| EFI_STATUS Status; |
| do { |
| PrintAt (Column, Row, String, Timeout); |
| Status = WaitForSingleEvent (Event, 10000000); |
| if (Status == EFI_SUCCESS) { |
| if (!EFI_ERROR(ST->ConIn->ReadKeyStroke (ST->ConIn, Key))) { |
| return; |
| } |
| } |
| } while (Timeout > 0); |
| *Key = TimeoutKey; |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/ia64/palproc.S |
|---|
| 0,0 → 1,170 |
| //++ |
| // Copyright (c) 1996-99 Intel Corp. |
| // All Rights Reserved |
| // |
| // INTEL CORPORATION PROPRIETARY INFORMATION |
| // |
| // This software is supplied under the terms of a license |
| // agreement or nondisclosure agreement with Intel Corpo- |
| // ration and may not be copied or disclosed except in |
| // accordance with the terms of that agreement. |
| // |
| // |
| // |
| // Module Name: |
| // |
| // palproc.s |
| // |
| // Abstract: |
| // |
| // Contains an implementation for making PAL PROC calls on |
| // IA-64 architecture. |
| // |
| // |
| // |
| // Revision History: |
| // |
| //-- |
| .file "palproc.s" |
| #include "palproc.h" |
| //----------------------------------------------------------------------------- |
| //++ |
| // MakeStaticPALCall |
| // |
| // This routine is called whenever an architected static calling convention |
| // based PAL call is to be made. This call does use RSE actually, but our policy |
| // in making static PAL calls before memory is available is to make sure that |
| // we do not nest too deep and allocate beyond 96 banked registers. In other |
| // words we carefully code calls and control flow before memory is available. |
| // |
| // Arguments : All parameters set up to do static PAL call. |
| // |
| // On Entry : |
| // |
| // Return Value: |
| // |
| // As per static calling conventions. |
| // |
| //-- |
| //--------------------------------------------------------------------------- |
| PROCEDURE_ENTRY(MakeStaticPALCall) |
| NESTED_SETUP (5,8,0,0) |
| mov loc3 = b5 |
| mov loc4 = r2 |
| mov loc7 = r1;; |
| movl loc6 = PAL_MC_CLEAR_LOG |
| mov r2 = psr;; |
| mov loc5 = r2 |
| cmp.eq p6,p7 = r28,loc6;; |
| (p7)movl loc6 = PAL_MC_DYNAMIC_STATE;; |
| (p7)cmp.eq p6,p7 = r28,loc6;; |
| (p7)movl loc6 = PAL_MC_ERROR_INFO;; |
| (p7)cmp.eq p6,p7 = r28,loc6;; |
| (p7)movl loc6 = PAL_MC_RESUME;; |
| (p7)cmp.eq p6,p7 = r28,loc6 |
| mov loc6 = 0x1;; |
| (p7)dep r2 = loc6,r2,13,1;; // psr.ic = 1 |
| // p6 will be true, if it is one of the MCHK calls. There has been lots of debate |
| // on psr.ic for these values. For now, do not do any thing to psr.ic |
| // (p6)dep r2 = r0,r2,13,1;; // psr.ic = 0 |
| dep r2 = r0,r2,14,1;; // psr.i = 0 |
| mov psr.l = r2 |
| srlz.d;; // Needs data serailization. |
| srlz.i;; // Needs instruction serailization. |
| StaticGetPALLocalIP: |
| mov loc2 = ip;; |
| add loc2 = StaticComeBackFromPALCall - StaticGetPALLocalIP,loc2;; |
| mov b0 = loc2 // return address after Pal call |
| mov r28 = in1 // get the input parameters to PAL call |
| mov r29 = in2 |
| mov r30 = in3;; |
| mov r31 = in4 |
| mov b5 = in0;; // get the PalProcEntrypt from input |
| br.sptk b5 // Take the plunge. |
| StaticComeBackFromPALCall: |
| mov psr.l = loc5;; |
| srlz.d;; // Needs data serailization. |
| srlz.i;; // Needs instruction serailization. |
| mov b5 = loc3 |
| mov r2 = loc4 |
| mov r1 = loc7 |
| NESTED_RETURN |
| PROCEDURE_EXIT(MakeStaticPALCall) |
| //----------------------------------------------------------------------------- |
| //++ |
| // MakeStackedPALCall |
| // |
| // This routine is called whenever an architected stacked calling convention |
| // based PAL call is to be made. This call is made after memory is available. |
| // Although stacked calls could be made directly from 'C', there is a PAL |
| // requirement which forces the index to be in GR28 and hence this stub is |
| // needed |
| // |
| // Arguments : All parameters set up to do stacted PAL call. |
| // |
| // On Entry : |
| // in0: PAL_PROC entrypoint |
| // in1-in4 : PAL_PROC arguments |
| // |
| // Return Value: |
| // |
| // As per stacked calling conventions. |
| // |
| //-- |
| //--------------------------------------------------------------------------- |
| PROCEDURE_ENTRY(MakeStackedPALCall) |
| NESTED_SETUP (5,8,4,0) |
| mov loc3 = b5 |
| mov loc4 = r2 |
| mov loc7 = r1 |
| mov r2 = psr;; |
| mov loc5 = r2;; |
| dep r2 = r0,r2,14,1;; // psr.i = 0 |
| mov psr.l = r2 |
| srlz.d;; // Needs data serailization. |
| srlz.i;; // Needs instruction serailization. |
| StackedGetPALLocalIP: |
| mov r28 = in1 // get the input parameters to PAL call |
| mov out0 = in1 |
| mov out1 = in2;; |
| mov out2 = in3 |
| mov out3 = in4 |
| mov b5 = in0;; // get the PalProcEntrypt from input |
| br.call.dpnt b0=b5;; // Take the plunge. |
| StackedComeBackFromPALCall: |
| mov psr.l = loc5;; |
| srlz.d;; // Needs data serailization. |
| srlz.i;; // Needs instruction serailization. |
| mov b5 = loc3 |
| mov r2 = loc4 |
| mov r1 = loc7 |
| NESTED_RETURN |
| PROCEDURE_EXIT(MakeStackedPALCall) |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/ia64/initplat.c |
|---|
| 0,0 → 1,31 |
| /*++ |
| Copyright (c) 1999 Intel Corporation |
| Module Name: |
| initplat.c |
| Abstract: |
| Functions to make SAL and PAL proc calls |
| Revision History |
| --*/ |
| #include "lib.h" |
| //#include "palproc.h" |
| VOID |
| InitializeLibPlatform ( |
| IN EFI_HANDLE ImageHandle, |
| IN EFI_SYSTEM_TABLE *SystemTable |
| ) |
| { |
| PLABEL SalPlabel; |
| UINT64 PalEntry; |
| LibInitSalAndPalProc (&SalPlabel, &PalEntry); |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/ia64/palproc.h |
|---|
| 0,0 → 1,60 |
| // |
| // |
| // Copyright (c) 1996-99 Intel Corp. |
| // All Rights Reserved |
| // |
| // INTEL CORPORATION PROPRIETARY INFORMATION |
| // |
| // This software is supplied under the terms of a license |
| // agreement or nondisclosure agreement with Intel Corpo- |
| // ration and may not be copied or disclosed except in |
| // accordance with the terms of that agreement. |
| // |
| // |
| // |
| //Module Name: |
| // |
| // palproc.h |
| // |
| //Abstract: |
| // |
| // This module contains generic macros for an IA64 assembly writer. |
| // |
| // |
| //Revision History |
| // |
| #ifndef _PALPROC_H |
| #define _PALPROC_H |
| #define PROCEDURE_ENTRY(name) .##text; \ |
| .##type name, @function; \ |
| .##global name; \ |
| .##proc name; \ |
| name: |
| #define PROCEDURE_EXIT(name) .##endp name |
| // Note: use of NESTED_SETUP requires number of locals (l) >= 3 |
| #define NESTED_SETUP(i,l,o,r) \ |
| alloc loc1=ar##.##pfs,i,l,o,r ;\ |
| mov loc0=b0 |
| #define NESTED_RETURN \ |
| mov b0=loc0 ;\ |
| mov ar##.##pfs=loc1 ;;\ |
| br##.##ret##.##dpnt b0;; |
| // defines needed in palproc.s |
| #define PAL_MC_CLEAR_LOG 0x0015 |
| #define PAL_MC_DRAIN 0x0016 |
| #define PAL_MC_EXPECTED 0x0017 |
| #define PAL_MC_DYNAMIC_STATE 0x0018 |
| #define PAL_MC_ERROR_INFO 0x0019 |
| #define PAL_MC_RESUME 0x001a |
| #define PAL_MC_REGISTER_MEM 0x001b |
| #endif // _PALPROC_H |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/ia64/math.c |
|---|
| 0,0 → 1,86 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| math.c |
| Abstract: |
| Revision History |
| --*/ |
| #include "lib.h" |
| // |
| // Declare runtime functions |
| // |
| #ifdef RUNTIME_CODE |
| #pragma RUNTIME_CODE(LShiftU64) |
| #pragma RUNTIME_CODE(RShiftU64) |
| #pragma RUNTIME_CODE(MultU64x32) |
| #pragma RUNTIME_CODE(DivU64x32) |
| #endif |
| // |
| // |
| // |
| UINT64 |
| LShiftU64 ( |
| IN UINT64 Operand, |
| IN UINTN Count |
| ) |
| // Left shift 64bit by 32bit and get a 64bit result |
| { |
| return Operand << Count; |
| } |
| UINT64 |
| RShiftU64 ( |
| IN UINT64 Operand, |
| IN UINTN Count |
| ) |
| // Right shift 64bit by 32bit and get a 64bit result |
| { |
| return Operand >> Count; |
| } |
| UINT64 |
| MultU64x32 ( |
| IN UINT64 Multiplicand, |
| IN UINTN Multiplier |
| ) |
| // Multiple 64bit by 32bit and get a 64bit result |
| { |
| return Multiplicand * Multiplier; |
| } |
| UINT64 |
| DivU64x32 ( |
| IN UINT64 Dividend, |
| IN UINTN Divisor, |
| OUT UINTN *Remainder OPTIONAL |
| ) |
| // divide 64bit by 32bit and get a 64bit result |
| // N.B. only works for 31bit divisors!! |
| { |
| ASSERT (Divisor != 0); |
| if (Remainder) { |
| *Remainder = Dividend % Divisor; |
| } |
| return Dividend / Divisor; |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/ia64/salpal.c |
|---|
| 0,0 → 1,335 |
| /*++ |
| Copyright (c) 1999 Intel Corporation |
| Module Name: |
| salpal.c |
| Abstract: |
| Functions to make SAL and PAL proc calls |
| Revision History |
| --*/ |
| #include "lib.h" |
| #include "palproc.h" |
| #include "salproc.h" |
| /*++ |
| Copyright (c) 1999 Intel Corporation |
| Module Name: |
| EfiRtLib.h |
| Abstract: |
| EFI Runtime library functions |
| Revision History |
| --*/ |
| #include "efi.h" |
| #include "efilib.h" |
| rArg |
| MakeStaticPALCall ( |
| IN UINT64 PALPROCPtr, |
| IN UINT64 Arg1, |
| IN UINT64 Arg2, |
| IN UINT64 Arg3, |
| IN UINT64 Arg4 |
| ); |
| rArg |
| MakeStackedPALCall ( |
| IN UINT64 PALPROCPtr, |
| IN UINT64 Arg1, |
| IN UINT64 Arg2, |
| IN UINT64 Arg3, |
| IN UINT64 Arg4 |
| ); |
| PLABEL SalProcPlabel; |
| PLABEL PalProcPlabel; |
| CALL_SAL_PROC GlobalSalProc; |
| CALL_PAL_PROC GlobalPalProc; |
| VOID |
| LibInitSalAndPalProc ( |
| OUT PLABEL *SalPlabel, |
| OUT UINT64 *PalEntry |
| ) |
| { |
| SAL_SYSTEM_TABLE_ASCENDING_ORDER *SalSystemTable; |
| EFI_STATUS Status; |
| GlobalSalProc = NULL; |
| GlobalPalProc = NULL; |
| Status = LibGetSystemConfigurationTable(&SalSystemTableGuid, (VOID **)&SalSystemTable); |
| if (EFI_ERROR(Status)) { |
| return; |
| } |
| // |
| // BugBug: Add code to test checksum on the Sal System Table |
| // |
| if (SalSystemTable->Entry0.Type != 0) { |
| return; |
| } |
| SalProcPlabel.ProcEntryPoint = SalSystemTable->Entry0.SalProcEntry; |
| SalProcPlabel.GP = SalSystemTable->Entry0.GlobalDataPointer; |
| GlobalSalProc = (CALL_SAL_PROC)&SalProcPlabel.ProcEntryPoint; |
| // |
| // Need to check the PAL spec to make sure I'm not responsible for |
| // storing more state. |
| // We are passing in a Plabel that should be ignorred by the PAL. Call |
| // this way will cause use to retore our gp after the PAL returns. |
| // |
| PalProcPlabel.ProcEntryPoint = SalSystemTable->Entry0.PalProcEntry; |
| PalProcPlabel.GP = SalSystemTable->Entry0.GlobalDataPointer; |
| GlobalPalProc = (CALL_PAL_PROC)PalProcPlabel.ProcEntryPoint; |
| *PalEntry = PalProcPlabel.ProcEntryPoint; |
| *SalPlabel = SalProcPlabel; |
| } |
| EFI_STATUS |
| LibGetSalIoPortMapping ( |
| OUT UINT64 *IoPortMapping |
| ) |
| /*++ |
| Get the IO Port Map from the SAL System Table. |
| DO NOT USE THIS TO DO YOU OWN IO's!!!!!!!!!!!! |
| Only use this for getting info, or initing the built in EFI IO abstraction. |
| Always use the EFI Device IO protoocl to access IO space. |
| --*/ |
| { |
| SAL_SYSTEM_TABLE_ASCENDING_ORDER *SalSystemTable; |
| SAL_ST_MEMORY_DESCRIPTOR_ENTRY *SalMemDesc; |
| EFI_STATUS Status; |
| Status = LibGetSystemConfigurationTable(&SalSystemTableGuid, (VOID **)&SalSystemTable); |
| if (EFI_ERROR(Status)) { |
| return EFI_UNSUPPORTED; |
| } |
| // |
| // BugBug: Add code to test checksum on the Sal System Table |
| // |
| if (SalSystemTable->Entry0.Type != 0) { |
| return EFI_UNSUPPORTED; |
| } |
| // |
| // The SalSystemTable pointer includes the Type 0 entry. |
| // The SalMemDesc is Type 1 so it comes next. |
| // |
| SalMemDesc = (SAL_ST_MEMORY_DESCRIPTOR_ENTRY *)(SalSystemTable + 1); |
| while (SalMemDesc->Type == SAL_ST_MEMORY_DESCRIPTOR) { |
| if (SalMemDesc->MemoryType == SAL_IO_PORT_MAPPING) { |
| *IoPortMapping = SalMemDesc->PhysicalMemoryAddress; |
| return EFI_SUCCESS; |
| } |
| SalMemDesc++; |
| } |
| return EFI_UNSUPPORTED; |
| } |
| EFI_STATUS |
| LibGetSalIpiBlock ( |
| OUT UINT64 *IpiBlock |
| ) |
| /*++ |
| Get the IPI block from the SAL system table |
| --*/ |
| { |
| SAL_SYSTEM_TABLE_ASCENDING_ORDER *SalSystemTable; |
| SAL_ST_MEMORY_DESCRIPTOR_ENTRY *SalMemDesc; |
| EFI_STATUS Status; |
| Status = LibGetSystemConfigurationTable(&SalSystemTableGuid, (VOID*)&SalSystemTable); |
| if (EFI_ERROR(Status)) { |
| return EFI_UNSUPPORTED; |
| } |
| // |
| // BugBug: Add code to test checksum on the Sal System Table |
| // |
| if (SalSystemTable->Entry0.Type != 0) { |
| return EFI_UNSUPPORTED; |
| } |
| // |
| // The SalSystemTable pointer includes the Type 0 entry. |
| // The SalMemDesc is Type 1 so it comes next. |
| // |
| SalMemDesc = (SAL_ST_MEMORY_DESCRIPTOR_ENTRY *)(SalSystemTable + 1); |
| while (SalMemDesc->Type == SAL_ST_MEMORY_DESCRIPTOR) { |
| if (SalMemDesc->MemoryType == SAL_SAPIC_IPI_BLOCK ) { |
| *IpiBlock = SalMemDesc->PhysicalMemoryAddress; |
| return EFI_SUCCESS; |
| } |
| SalMemDesc++; |
| } |
| return EFI_UNSUPPORTED; |
| } |
| EFI_STATUS |
| LibGetSalWakeupVector ( |
| OUT UINT64 *WakeVector |
| ) |
| /*++ |
| Get the wakeup vector from the SAL system table |
| --*/ |
| { |
| SAL_ST_AP_WAKEUP_DECRIPTOR *ApWakeUp; |
| ApWakeUp = LibSearchSalSystemTable (SAL_ST_AP_WAKEUP); |
| if (!ApWakeUp) { |
| *WakeVector = -1; |
| return EFI_UNSUPPORTED; |
| } |
| *WakeVector = ApWakeUp->ExternalInterruptVector; |
| return EFI_SUCCESS; |
| } |
| VOID * |
| LibSearchSalSystemTable ( |
| IN UINT8 EntryType |
| ) |
| { |
| EFI_STATUS Status; |
| UINT8 *SalTableHack; |
| SAL_SYSTEM_TABLE_ASCENDING_ORDER *SalSystemTable; |
| UINT16 EntryCount; |
| UINT16 Count; |
| Status = LibGetSystemConfigurationTable(&SalSystemTableGuid, (VOID*)&SalSystemTable); |
| if (EFI_ERROR(Status)) { |
| return NULL; |
| } |
| EntryCount = SalSystemTable->Header.EntryCount; |
| if (EntryCount == 0) { |
| return NULL; |
| } |
| // |
| // BugBug: Add code to test checksum on the Sal System Table |
| // |
| SalTableHack = (UINT8 *)&SalSystemTable->Entry0; |
| for (Count = 0; Count < EntryCount ;Count++) { |
| if (*SalTableHack == EntryType) { |
| return (VOID *)SalTableHack; |
| } |
| switch (*SalTableHack) { |
| case SAL_ST_ENTRY_POINT: |
| SalTableHack += 48; |
| break; |
| case SAL_ST_MEMORY_DESCRIPTOR: |
| SalTableHack += 32; |
| break; |
| case SAL_ST_PLATFORM_FEATURES: |
| SalTableHack += 16; |
| break; |
| case SAL_ST_TR_USAGE: |
| SalTableHack += 32; |
| break; |
| case SAL_ST_PTC: |
| SalTableHack += 16; |
| break; |
| case SAL_ST_AP_WAKEUP: |
| SalTableHack += 16; |
| break; |
| default: |
| ASSERT(FALSE); |
| break; |
| } |
| } |
| return NULL; |
| } |
| VOID |
| LibSalProc ( |
| IN UINT64 Arg1, |
| IN UINT64 Arg2, |
| IN UINT64 Arg3, |
| IN UINT64 Arg4, |
| IN UINT64 Arg5, |
| IN UINT64 Arg6, |
| IN UINT64 Arg7, |
| IN UINT64 Arg8, |
| OUT rArg *Results OPTIONAL |
| ) |
| { |
| rArg ReturnValue; |
| ReturnValue.p0 = -3; // SAL status return completed with error |
| if (GlobalSalProc) { |
| ReturnValue = GlobalSalProc(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8); |
| } |
| if (Results) { |
| CopyMem (Results, &ReturnValue, sizeof(rArg)); |
| } |
| } |
| VOID |
| LibPalProc ( |
| IN UINT64 Arg1, // Pal Proc index |
| IN UINT64 Arg2, |
| IN UINT64 Arg3, |
| IN UINT64 Arg4, |
| OUT rArg *Results OPTIONAL |
| ) |
| { |
| rArg ReturnValue; |
| ReturnValue.p0 = -3; // PAL status return completed with error |
| // |
| // check for valid PalProc entry point |
| // |
| if (!GlobalPalProc) { |
| if (Results) |
| CopyMem (Results, &ReturnValue, sizeof(rArg)); |
| return; |
| } |
| // |
| // check if index falls within stacked or static register calling conventions |
| // and call appropriate Pal stub call |
| // |
| if (((Arg1 >=255) && (Arg1 <=511)) || |
| ((Arg1 >=768) && (Arg1 <=1023))) { |
| ReturnValue = MakeStackedPALCall((UINT64)GlobalPalProc,Arg1,Arg2,Arg3,Arg4); |
| } |
| else { |
| ReturnValue = MakeStaticPALCall((UINT64)GlobalPalProc,Arg1,Arg2,Arg3,Arg4); |
| } |
| if (Results) |
| CopyMem (Results, &ReturnValue, sizeof(rArg)); |
| return; |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/debug.c |
|---|
| 0,0 → 1,43 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| debug.c |
| Abstract: |
| Debug library functions |
| Revision History |
| --*/ |
| #include "lib.h" |
| // |
| // Declare runtime functions |
| // |
| // |
| // |
| // |
| INTN |
| DbgAssert ( |
| IN CHAR8 *FileName, |
| IN INTN LineNo, |
| IN CHAR8 *Description |
| ) |
| { |
| DbgPrint (D_ERROR, (CHAR8 *)"%EASSERT FAILED: %a(%d): %a%N\n", FileName, LineNo, Description); |
| BREAKPOINT(); |
| return 0; |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/guid.c |
|---|
| 0,0 → 1,175 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| misc.c |
| Abstract: |
| Misc EFI support functions |
| Revision History |
| --*/ |
| #include "lib.h" |
| // |
| // Additional Known guids |
| // |
| #define SHELL_INTERFACE_PROTOCOL \ |
| { 0x47c7b223, 0xc42a, 0x11d2, {0x8e, 0x57, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } |
| #define ENVIRONMENT_VARIABLE_ID \ |
| { 0x47c7b224, 0xc42a, 0x11d2, {0x8e, 0x57, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } |
| #define DEVICE_PATH_MAPPING_ID \ |
| { 0x47c7b225, 0xc42a, 0x11d2, {0x8e, 0x57, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } |
| #define PROTOCOL_ID_ID \ |
| { 0x47c7b226, 0xc42a, 0x11d2, {0x8e, 0x57, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } |
| #define ALIAS_ID \ |
| { 0x47c7b227, 0xc42a, 0x11d2, {0x8e, 0x57, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } |
| static EFI_GUID ShellInterfaceProtocol = SHELL_INTERFACE_PROTOCOL; |
| static EFI_GUID SEnvId = ENVIRONMENT_VARIABLE_ID; |
| static EFI_GUID SMapId = DEVICE_PATH_MAPPING_ID; |
| static EFI_GUID SProtId = PROTOCOL_ID_ID; |
| static EFI_GUID SAliasId = ALIAS_ID; |
| static struct { |
| EFI_GUID *Guid; |
| WCHAR *GuidName; |
| } KnownGuids[] = { |
| { &NullGuid, L"G0"}, |
| { &EfiGlobalVariable, L"Efi"}, |
| { &VariableStoreProtocol, L"varstore"}, |
| { &DevicePathProtocol, L"dpath"}, |
| { &LoadedImageProtocol, L"image"}, |
| { &TextInProtocol, L"txtin"}, |
| { &TextOutProtocol, L"txtout"}, |
| { &BlockIoProtocol, L"blkio"}, |
| { &DiskIoProtocol, L"diskio"}, |
| { &FileSystemProtocol, L"fs"}, |
| { &LoadFileProtocol, L"load"}, |
| { &DeviceIoProtocol, L"DevIo"}, |
| { &GenericFileInfo, L"GenFileInfo"}, |
| { &FileSystemInfo, L"FileSysInfo"}, |
| { &UnicodeCollationProtocol, L"unicode"}, |
| { &LegacyBootProtocol, L"LegacyBoot"}, |
| { &SerialIoProtocol, L"serialio"}, |
| { &VgaClassProtocol, L"vgaclass"}, |
| { &SimpleNetworkProtocol, L"net"}, |
| { &NetworkInterfaceIdentifierProtocol, L"nii"}, |
| { &PxeBaseCodeProtocol, L"pxebc"}, |
| { &PxeCallbackProtocol, L"pxecb"}, |
| { &VariableStoreProtocol, L"varstore"}, |
| { &LegacyBootProtocol, L"LegacyBoot"}, |
| { &VgaClassProtocol, L"VgaClass"}, |
| { &TextOutSpliterProtocol, L"TxtOutSplit"}, |
| { &ErrorOutSpliterProtocol, L"ErrOutSplit"}, |
| { &TextInSpliterProtocol, L"TxtInSplit"}, |
| { &PcAnsiProtocol, L"PcAnsi"}, |
| { &Vt100Protocol, L"Vt100"}, |
| { &UnknownDevice, L"Unknown Device"}, |
| { &EfiPartTypeSystemPartitionGuid, L"ESP"}, |
| { &EfiPartTypeLegacyMbrGuid, L"GPT MBR"}, |
| { &ShellInterfaceProtocol, L"ShellInt"}, |
| { &SEnvId, L"SEnv"}, |
| { &SProtId, L"ShellProtId"}, |
| { &SMapId, L"ShellDevPathMap"}, |
| { &SAliasId, L"ShellAlias"}, |
| { NULL } |
| }; |
| // |
| // |
| // |
| LIST_ENTRY GuidList; |
| VOID |
| InitializeGuid ( |
| VOID |
| ) |
| { |
| } |
| INTN |
| CompareGuid( |
| IN EFI_GUID *Guid1, |
| IN EFI_GUID *Guid2 |
| ) |
| /*++ |
| Routine Description: |
| Compares to GUIDs |
| Arguments: |
| Guid1 - guid to compare |
| Guid2 - guid to compare |
| Returns: |
| = 0 if Guid1 == Guid2 |
| --*/ |
| { |
| return RtCompareGuid (Guid1, Guid2); |
| } |
| VOID |
| GuidToString ( |
| OUT CHAR16 *Buffer, |
| IN EFI_GUID *Guid |
| ) |
| { |
| UINTN Index; |
| // |
| // Else, (for now) use additional internal function for mapping guids |
| // |
| for (Index=0; KnownGuids[Index].Guid; Index++) { |
| if (CompareGuid(Guid, KnownGuids[Index].Guid) == 0) { |
| SPrint (Buffer, 0, KnownGuids[Index].GuidName); |
| return ; |
| } |
| } |
| // |
| // Else dump it |
| // |
| SPrint (Buffer, 0, L"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x", |
| Guid->Data1, |
| Guid->Data2, |
| Guid->Data3, |
| Guid->Data4[0], |
| Guid->Data4[1], |
| Guid->Data4[2], |
| Guid->Data4[3], |
| Guid->Data4[4], |
| Guid->Data4[5], |
| Guid->Data4[6], |
| Guid->Data4[7] |
| ); |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/lock.c |
|---|
| 0,0 → 1,107 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| lock.c |
| Abstract: |
| Implements FLOCK |
| Revision History |
| --*/ |
| #include "lib.h" |
| VOID |
| InitializeLock ( |
| IN OUT FLOCK *Lock, |
| IN EFI_TPL Priority |
| ) |
| /*++ |
| Routine Description: |
| Initialize a basic mutual exclusion lock. Each lock |
| provides mutual exclusion access at it's task priority |
| level. Since there is no-premption (at any TPL) or |
| multiprocessor support, acquiring the lock only consists |
| of raising to the locks TPL. |
| Note on a debug build the lock is acquired and released |
| to help ensure proper usage. |
| Arguments: |
| Lock - The FLOCK structure to initialize |
| Priority - The task priority level of the lock |
| Returns: |
| An initialized F Lock structure. |
| --*/ |
| { |
| Lock->Tpl = Priority; |
| Lock->OwnerTpl = 0; |
| Lock->Lock = 0; |
| } |
| VOID |
| AcquireLock ( |
| IN FLOCK *Lock |
| ) |
| /*++ |
| Routine Description: |
| Raising to the task priority level of the mutual exclusion |
| lock, and then acquires ownership of the lock. |
| Arguments: |
| Lock - The lock to acquire |
| Returns: |
| Lock owned |
| --*/ |
| { |
| RtAcquireLock (Lock); |
| } |
| VOID |
| ReleaseLock ( |
| IN FLOCK *Lock |
| ) |
| /*++ |
| Routine Description: |
| Releases ownership of the mutual exclusion lock, and |
| restores the previous task priority level. |
| Arguments: |
| Lock - The lock to release |
| Returns: |
| Lock unowned |
| --*/ |
| { |
| RtReleaseLock (Lock); |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/error.c |
|---|
| 0,0 → 1,76 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| error.c |
| Abstract: |
| Revision History |
| --*/ |
| #include "lib.h" |
| struct { |
| EFI_STATUS Code; |
| WCHAR *Desc; |
| } ErrorCodeTable[] = { |
| { EFI_SUCCESS, L"Success"}, |
| { EFI_LOAD_ERROR, L"Load Error"}, |
| { EFI_INVALID_PARAMETER, L"Invalid Parameter"}, |
| { EFI_UNSUPPORTED, L"Unsupported"}, |
| { EFI_BAD_BUFFER_SIZE, L"Bad Buffer Size"}, |
| { EFI_BUFFER_TOO_SMALL, L"Buffer Too Small"}, |
| { EFI_NOT_READY, L"Not Ready"}, |
| { EFI_DEVICE_ERROR, L"Device Error"}, |
| { EFI_WRITE_PROTECTED, L"Write Protected"}, |
| { EFI_OUT_OF_RESOURCES, L"Out of Resources"}, |
| { EFI_VOLUME_CORRUPTED, L"Volume Corrupt"}, |
| { EFI_VOLUME_FULL, L"Volume Full"}, |
| { EFI_NO_MEDIA, L"No Media"}, |
| { EFI_MEDIA_CHANGED, L"Media changed"}, |
| { EFI_NOT_FOUND, L"Not Found"}, |
| { EFI_ACCESS_DENIED, L"Access Denied"}, |
| { EFI_NO_RESPONSE, L"No Response"}, |
| { EFI_NO_MAPPING, L"No mapping"}, |
| { EFI_TIMEOUT, L"Time out"}, |
| { EFI_NOT_STARTED, L"Not started"}, |
| { EFI_ALREADY_STARTED, L"Already started"}, |
| { EFI_ABORTED, L"Aborted"}, |
| { EFI_ICMP_ERROR, L"ICMP Error"}, |
| { EFI_TFTP_ERROR, L"TFTP Error"}, |
| { EFI_PROTOCOL_ERROR, L"Protocol Error"}, |
| // warnings |
| { EFI_WARN_UNKOWN_GLYPH, L"Warning Unknown Glyph"}, |
| { EFI_WARN_DELETE_FAILURE, L"Warning Delete Failure"}, |
| { EFI_WARN_WRITE_FAILURE, L"Warning Write Failure"}, |
| { EFI_WARN_BUFFER_TOO_SMALL, L"Warning Buffer Too Small"}, |
| { 0, NULL} |
| } ; |
| VOID |
| StatusToString ( |
| OUT CHAR16 *Buffer, |
| IN EFI_STATUS Status |
| ) |
| { |
| UINTN Index; |
| for (Index = 0; ErrorCodeTable[Index].Desc; Index +=1) { |
| if (ErrorCodeTable[Index].Code == Status) { |
| StrCpy (Buffer, ErrorCodeTable[Index].Desc); |
| return; |
| } |
| } |
| SPrint (Buffer, 0, L"%X", Status); |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/misc.c |
|---|
| 0,0 → 1,514 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| misc.c |
| Abstract: |
| Revision History |
| --*/ |
| #include "lib.h" |
| // |
| // |
| // |
| VOID * |
| AllocatePool ( |
| IN UINTN Size |
| ) |
| { |
| EFI_STATUS Status; |
| VOID *p; |
| Status = BS->AllocatePool (PoolAllocationType, Size, &p); |
| if (EFI_ERROR(Status)) { |
| DEBUG((D_ERROR, "AllocatePool: out of pool %x\n", Status)); |
| p = NULL; |
| } |
| return p; |
| } |
| VOID * |
| AllocateZeroPool ( |
| IN UINTN Size |
| ) |
| { |
| VOID *p; |
| p = AllocatePool (Size); |
| if (p) { |
| ZeroMem (p, Size); |
| } |
| return p; |
| } |
| VOID * |
| ReallocatePool ( |
| IN VOID *OldPool, |
| IN UINTN OldSize, |
| IN UINTN NewSize |
| ) |
| { |
| VOID *NewPool; |
| NewPool = NULL; |
| if (NewSize) { |
| NewPool = AllocatePool (NewSize); |
| } |
| if (OldPool) { |
| if (NewPool) { |
| CopyMem (NewPool, OldPool, OldSize < NewSize ? OldSize : NewSize); |
| } |
| FreePool (OldPool); |
| } |
| return NewPool; |
| } |
| VOID |
| FreePool ( |
| IN VOID *Buffer |
| ) |
| { |
| BS->FreePool (Buffer); |
| } |
| VOID |
| ZeroMem ( |
| IN VOID *Buffer, |
| IN UINTN Size |
| ) |
| { |
| RtZeroMem (Buffer, Size); |
| } |
| VOID |
| SetMem ( |
| IN VOID *Buffer, |
| IN UINTN Size, |
| IN UINT8 Value |
| ) |
| { |
| RtSetMem (Buffer, Size, Value); |
| } |
| VOID |
| CopyMem ( |
| IN VOID *Dest, |
| IN VOID *Src, |
| IN UINTN len |
| ) |
| { |
| RtCopyMem (Dest, Src, len); |
| } |
| INTN |
| CompareMem ( |
| IN VOID *Dest, |
| IN VOID *Src, |
| IN UINTN len |
| ) |
| { |
| return RtCompareMem (Dest, Src, len); |
| } |
| BOOLEAN |
| GrowBuffer( |
| IN OUT EFI_STATUS *Status, |
| IN OUT VOID **Buffer, |
| IN UINTN BufferSize |
| ) |
| /*++ |
| Routine Description: |
| Helper function called as part of the code needed |
| to allocate the proper sized buffer for various |
| EFI interfaces. |
| Arguments: |
| Status - Current status |
| Buffer - Current allocated buffer, or NULL |
| BufferSize - Current buffer size needed |
| Returns: |
| TRUE - if the buffer was reallocated and the caller |
| should try the API again. |
| --*/ |
| { |
| BOOLEAN TryAgain; |
| // |
| // If this is an initial request, buffer will be null with a new buffer size |
| // |
| if (!*Buffer && BufferSize) { |
| *Status = EFI_BUFFER_TOO_SMALL; |
| } |
| // |
| // If the status code is "buffer too small", resize the buffer |
| // |
| TryAgain = FALSE; |
| if (*Status == EFI_BUFFER_TOO_SMALL) { |
| if (*Buffer) { |
| FreePool (*Buffer); |
| } |
| *Buffer = AllocatePool (BufferSize); |
| if (*Buffer) { |
| TryAgain = TRUE; |
| } else { |
| *Status = EFI_OUT_OF_RESOURCES; |
| } |
| } |
| // |
| // If there's an error, free the buffer |
| // |
| if (!TryAgain && EFI_ERROR(*Status) && *Buffer) { |
| FreePool (*Buffer); |
| *Buffer = NULL; |
| } |
| return TryAgain; |
| } |
| EFI_MEMORY_DESCRIPTOR * |
| LibMemoryMap ( |
| OUT UINTN *NoEntries, |
| OUT UINTN *MapKey, |
| OUT UINTN *DescriptorSize, |
| OUT UINT32 *DescriptorVersion |
| ) |
| { |
| EFI_STATUS Status; |
| EFI_MEMORY_DESCRIPTOR *Buffer; |
| UINTN BufferSize; |
| // |
| // Initialize for GrowBuffer loop |
| // |
| Buffer = NULL; |
| BufferSize = sizeof(EFI_MEMORY_DESCRIPTOR); |
| // |
| // Call the real function |
| // |
| while (GrowBuffer (&Status, (VOID **) &Buffer, BufferSize)) { |
| Status = BS->GetMemoryMap (&BufferSize, Buffer, MapKey, DescriptorSize, DescriptorVersion); |
| } |
| // |
| // Convert buffer size to NoEntries |
| // |
| if (!EFI_ERROR(Status)) { |
| *NoEntries = BufferSize / *DescriptorSize; |
| } |
| return Buffer; |
| } |
| VOID * |
| LibGetVariableAndSize ( |
| IN CHAR16 *Name, |
| IN EFI_GUID *VendorGuid, |
| OUT UINTN *VarSize |
| ) |
| { |
| EFI_STATUS Status; |
| VOID *Buffer; |
| UINTN BufferSize; |
| // |
| // Initialize for GrowBuffer loop |
| // |
| Buffer = NULL; |
| BufferSize = 100; |
| // |
| // Call the real function |
| // |
| while (GrowBuffer (&Status, &Buffer, BufferSize)) { |
| Status = RT->GetVariable ( |
| Name, |
| VendorGuid, |
| NULL, |
| &BufferSize, |
| Buffer |
| ); |
| } |
| if (Buffer) { |
| *VarSize = BufferSize; |
| } else { |
| *VarSize = 0; |
| } |
| return Buffer; |
| } |
| VOID * |
| LibGetVariable ( |
| IN CHAR16 *Name, |
| IN EFI_GUID *VendorGuid |
| ) |
| { |
| UINTN VarSize; |
| return LibGetVariableAndSize (Name, VendorGuid, &VarSize); |
| } |
| EFI_STATUS |
| LibDeleteVariable ( |
| IN CHAR16 *VarName, |
| IN EFI_GUID *VarGuid |
| ) |
| { |
| VOID *VarBuf; |
| EFI_STATUS Status; |
| VarBuf = LibGetVariable(VarName,VarGuid); |
| Status = EFI_NOT_FOUND; |
| if (VarBuf) { |
| // |
| // Delete variable from Storage |
| // |
| Status = RT->SetVariable ( |
| VarName, VarGuid, |
| EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE, |
| 0, NULL |
| ); |
| ASSERT (!EFI_ERROR(Status)); |
| FreePool(VarBuf); |
| } |
| return (Status); |
| } |
| EFI_STATUS |
| LibInsertToTailOfBootOrder ( |
| IN UINT16 BootOption, |
| IN BOOLEAN OnlyInsertIfEmpty |
| ) |
| { |
| UINT16 *BootOptionArray; |
| UINT16 *NewBootOptionArray; |
| UINTN VarSize; |
| UINTN Index; |
| EFI_STATUS Status; |
| BootOptionArray = LibGetVariableAndSize (VarBootOrder, &EfiGlobalVariable, &VarSize); |
| if (VarSize != 0 && OnlyInsertIfEmpty) { |
| if (BootOptionArray) { |
| FreePool (BootOptionArray); |
| } |
| return EFI_UNSUPPORTED; |
| } |
| VarSize += sizeof(UINT16); |
| NewBootOptionArray = AllocatePool (VarSize); |
| for (Index = 0; Index < ((VarSize/sizeof(UINT16)) - 1); Index++) { |
| NewBootOptionArray[Index] = BootOptionArray[Index]; |
| } |
| // |
| // Insert in the tail of the array |
| // |
| NewBootOptionArray[Index] = BootOption; |
| Status = RT->SetVariable ( |
| VarBootOrder, &EfiGlobalVariable, |
| EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE, |
| VarSize, (VOID*) NewBootOptionArray |
| ); |
| if (NewBootOptionArray) { |
| FreePool (NewBootOptionArray); |
| } |
| if (BootOptionArray) { |
| FreePool (BootOptionArray); |
| } |
| return Status; |
| } |
| BOOLEAN |
| ValidMBR( |
| IN MASTER_BOOT_RECORD *Mbr, |
| IN EFI_BLOCK_IO *BlkIo |
| ) |
| { |
| UINT32 StartingLBA, EndingLBA; |
| UINT32 NewEndingLBA; |
| INTN i, j; |
| BOOLEAN ValidMbr; |
| if (Mbr->Signature != MBR_SIGNATURE) { |
| // |
| // The BPB also has this signature, so it can not be used alone. |
| // |
| return FALSE; |
| } |
| ValidMbr = FALSE; |
| for (i=0; i<MAX_MBR_PARTITIONS; i++) { |
| if ( Mbr->Partition[i].OSIndicator == 0x00 || EXTRACT_UINT32(Mbr->Partition[i].SizeInLBA) == 0 ) { |
| continue; |
| } |
| ValidMbr = TRUE; |
| StartingLBA = EXTRACT_UINT32(Mbr->Partition[i].StartingLBA); |
| EndingLBA = StartingLBA + EXTRACT_UINT32(Mbr->Partition[i].SizeInLBA) - 1; |
| if (EndingLBA > BlkIo->Media->LastBlock) { |
| // |
| // Compatability Errata: |
| // Some systems try to hide drive space with thier INT 13h driver |
| // This does not hide space from the OS driver. This means the MBR |
| // that gets created from DOS is smaller than the MBR created from |
| // a real OS (NT & Win98). This leads to BlkIo->LastBlock being |
| // wrong on some systems FDISKed by the OS. |
| // |
| // |
| if (BlkIo->Media->LastBlock < MIN_MBR_DEVICE_SIZE) { |
| // |
| // If this is a very small device then trust the BlkIo->LastBlock |
| // |
| return FALSE; |
| } |
| if (EndingLBA > (BlkIo->Media->LastBlock + MBR_ERRATA_PAD)) { |
| return FALSE; |
| } |
| } |
| for (j=i+1; j<MAX_MBR_PARTITIONS; j++) { |
| if (Mbr->Partition[j].OSIndicator == 0x00 || EXTRACT_UINT32(Mbr->Partition[j].SizeInLBA) == 0) { |
| continue; |
| } |
| if ( EXTRACT_UINT32(Mbr->Partition[j].StartingLBA) >= StartingLBA && |
| EXTRACT_UINT32(Mbr->Partition[j].StartingLBA) <= EndingLBA ) { |
| // |
| // The Start of this region overlaps with the i'th region |
| // |
| return FALSE; |
| } |
| NewEndingLBA = EXTRACT_UINT32(Mbr->Partition[j].StartingLBA) + EXTRACT_UINT32(Mbr->Partition[j].SizeInLBA) - 1; |
| if ( NewEndingLBA >= StartingLBA && NewEndingLBA <= EndingLBA ) { |
| // |
| // The End of this region overlaps with the i'th region |
| // |
| return FALSE; |
| } |
| } |
| } |
| // |
| // Non of the regions overlapped so MBR is O.K. |
| // |
| return ValidMbr; |
| } |
| UINT8 |
| DecimaltoBCD( |
| IN UINT8 DecValue |
| ) |
| { |
| return RtDecimaltoBCD (DecValue); |
| } |
| UINT8 |
| BCDtoDecimal( |
| IN UINT8 BcdValue |
| ) |
| { |
| return RtBCDtoDecimal (BcdValue); |
| } |
| EFI_STATUS |
| LibGetSystemConfigurationTable( |
| IN EFI_GUID *TableGuid, |
| IN OUT VOID **Table |
| ) |
| { |
| UINTN Index; |
| for(Index=0;Index<ST->NumberOfTableEntries;Index++) { |
| if (CompareGuid(TableGuid,&(ST->ConfigurationTable[Index].VendorGuid))==0) { |
| *Table = ST->ConfigurationTable[Index].VendorTable; |
| return EFI_SUCCESS; |
| } |
| } |
| return EFI_NOT_FOUND; |
| } |
| CHAR16 * |
| LibGetUiString ( |
| IN EFI_HANDLE Handle, |
| IN UI_STRING_TYPE StringType, |
| IN ISO_639_2 *LangCode, |
| IN BOOLEAN ReturnDevicePathStrOnMismatch |
| ) |
| { |
| UI_INTERFACE *Ui; |
| UI_STRING_TYPE Index; |
| UI_STRING_ENTRY *Array; |
| EFI_STATUS Status; |
| Status = BS->HandleProtocol (Handle, &UiProtocol, (VOID *)&Ui); |
| if (EFI_ERROR(Status)) { |
| return (ReturnDevicePathStrOnMismatch) ? DevicePathToStr(DevicePathFromHandle(Handle)) : NULL; |
| } |
| // |
| // Skip the first strings |
| // |
| for (Index = UiDeviceString, Array = Ui->Entry; Index < StringType; Index++, Array++) { |
| while (Array->LangCode) { |
| Array++; |
| } |
| } |
| // |
| // Search for the match |
| // |
| while (Array->LangCode) { |
| if (strcmpa (Array->LangCode, LangCode) == 0) { |
| return Array->UiString; |
| } |
| } |
| return (ReturnDevicePathStrOnMismatch) ? DevicePathToStr(DevicePathFromHandle(Handle)) : NULL; |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/Makefile |
|---|
| 0,0 → 1,47 |
| # |
| # Copyright (C) 1999-2001 Hewlett-Packard Co. |
| # Contributed by David Mosberger <davidm@hpl.hp.com> |
| # Contributed by Stephane Eranian <eranian@hpl.hp.com> |
| # |
| # This file is part of the gnu-efi package. |
| # |
| # GNU-EFI is free software; you can redistribute it and/or modify |
| # it under the terms of the GNU General Public License as published by |
| # the Free Software Foundation; either version 2, or (at your option) |
| # any later version. |
| # |
| # GNU-EFI is distributed in the hope that it will be useful, |
| # but WITHOUT ANY WARRANTY; without even the implied warranty of |
| # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| # GNU General Public License for more details. |
| # |
| # You should have received a copy of the GNU General Public License |
| # along with GNU-EFI; see the file COPYING. If not, write to the Free |
| # Software Foundation, 59 Temple Place - Suite 330, Boston, MA |
| # 02111-1307, USA. |
| # |
| include ../Make.defaults |
| CDIR = $(TOPDIR)/.. |
| FILES = boxdraw smbios console crc data debug dpath \ |
| error event guid hand hw init lock \ |
| misc print sread str \ |
| runtime/rtlock runtime/efirtlib runtime/rtstr runtime/vm runtime/rtdata \ |
| $(ARCH)/initplat $(ARCH)/math |
| ifeq ($(ARCH),ia64) |
| FILES += $(ARCH)/salpal $(ARCH)/palproc |
| endif |
| OBJS = $(FILES:%=%.o) |
| libefi.a: libefi.a($(OBJS)) |
| clean: |
| rm -f libefi.a *~ $(OBJS) */*.o |
| install: libefi.a |
| mkdir -p $(INSTALLROOT)/lib |
| $(INSTALL) -m 644 libefi.a $(INSTALLROOT)/lib/ |
| include ../Make.rules |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/print.c |
|---|
| 0,0 → 1,1301 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| print.c |
| Abstract: |
| Revision History |
| --*/ |
| #include "lib.h" |
| #include "efistdarg.h" // !!! |
| // |
| // Declare runtime functions |
| // |
| #ifdef RUNTIME_CODE |
| #pragma RUNTIME_CODE(DbgPrint) |
| // For debugging.. |
| /* |
| #pragma RUNTIME_CODE(_Print) |
| #pragma RUNTIME_CODE(PFLUSH) |
| #pragma RUNTIME_CODE(PSETATTR) |
| #pragma RUNTIME_CODE(PPUTC) |
| #pragma RUNTIME_CODE(PGETC) |
| #pragma RUNTIME_CODE(PITEM) |
| #pragma RUNTIME_CODE(ValueToHex) |
| #pragma RUNTIME_CODE(ValueToString) |
| #pragma RUNTIME_CODE(TimeToString) |
| */ |
| #endif |
| // |
| // |
| // |
| #define PRINT_STRING_LEN 200 |
| #define PRINT_ITEM_BUFFER_LEN 100 |
| typedef struct { |
| BOOLEAN Ascii; |
| UINTN Index; |
| union { |
| CHAR16 *pw; |
| CHAR8 *pc; |
| } un; |
| } POINTER; |
| #define pw un.pw |
| #define pc un.pc |
| typedef struct _pitem { |
| POINTER Item; |
| CHAR16 Scratch[PRINT_ITEM_BUFFER_LEN]; |
| UINTN Width; |
| UINTN FieldWidth; |
| UINTN *WidthParse; |
| CHAR16 Pad; |
| BOOLEAN PadBefore; |
| BOOLEAN Comma; |
| BOOLEAN Long; |
| } PRINT_ITEM; |
| typedef struct _pstate { |
| // Input |
| POINTER fmt; |
| va_list args; |
| // Output |
| CHAR16 *Buffer; |
| CHAR16 *End; |
| CHAR16 *Pos; |
| UINTN Len; |
| UINTN Attr; |
| UINTN RestoreAttr; |
| UINTN AttrNorm; |
| UINTN AttrHighlight; |
| UINTN AttrError; |
| INTN (*Output)(VOID *context, CHAR16 *str); |
| INTN (*SetAttr)(VOID *context, UINTN attr); |
| VOID *Context; |
| // Current item being formatted |
| struct _pitem *Item; |
| } PRINT_STATE; |
| // |
| // Internal fucntions |
| // |
| STATIC |
| UINTN |
| _Print ( |
| IN PRINT_STATE *ps |
| ); |
| STATIC |
| UINTN |
| _IPrint ( |
| IN UINTN Column, |
| IN UINTN Row, |
| IN SIMPLE_TEXT_OUTPUT_INTERFACE *Out, |
| IN CHAR16 *fmt, |
| IN CHAR8 *fmta, |
| IN va_list args |
| ); |
| STATIC |
| INTN |
| _DbgOut ( |
| IN VOID *Context, |
| IN CHAR16 *Buffer |
| ); |
| STATIC |
| VOID |
| PFLUSH ( |
| IN OUT PRINT_STATE *ps |
| ); |
| STATIC |
| VOID |
| PPUTC ( |
| IN OUT PRINT_STATE *ps, |
| IN CHAR16 c |
| ); |
| STATIC |
| VOID |
| PITEM ( |
| IN OUT PRINT_STATE *ps |
| ); |
| STATIC |
| CHAR16 |
| PGETC ( |
| IN POINTER *p |
| ); |
| STATIC |
| VOID |
| PSETATTR ( |
| IN OUT PRINT_STATE *ps, |
| IN UINTN Attr |
| ); |
| // |
| // |
| // |
| INTN |
| DbgPrint ( |
| IN INTN mask, |
| IN CHAR8 *fmt, |
| ... |
| ) |
| /*++ |
| Routine Description: |
| Prints a formatted unicode string to the default StandardError console |
| Arguments: |
| mask - Bit mask of debug string. If a bit is set in the |
| mask that is also set in EFIDebug the string is |
| printed; otherwise, the string is not printed |
| fmt - Format string |
| Returns: |
| Length of string printed to the StandardError console |
| --*/ |
| { |
| SIMPLE_TEXT_OUTPUT_INTERFACE *DbgOut; |
| PRINT_STATE ps; |
| va_list args; |
| UINTN back; |
| UINTN attr; |
| UINTN SavedAttribute; |
| if (!(EFIDebug & mask)) { |
| return 0; |
| } |
| va_start (args, fmt); |
| ZeroMem (&ps, sizeof(ps)); |
| ps.Output = _DbgOut; |
| ps.fmt.Ascii = TRUE; |
| ps.fmt.pc = fmt; |
| va_copy(ps.args, args); |
| ps.Attr = EFI_TEXT_ATTR(EFI_LIGHTGRAY, EFI_RED); |
| DbgOut = LibRuntimeDebugOut; |
| if (!DbgOut) { |
| DbgOut = ST->StdErr; |
| } |
| if (DbgOut) { |
| ps.Attr = DbgOut->Mode->Attribute; |
| ps.Context = DbgOut; |
| ps.SetAttr = (INTN (*)(VOID *, UINTN)) DbgOut->SetAttribute; |
| } |
| SavedAttribute = ps.Attr; |
| back = (ps.Attr >> 4) & 0xf; |
| ps.AttrNorm = EFI_TEXT_ATTR(EFI_LIGHTGRAY, back); |
| ps.AttrHighlight = EFI_TEXT_ATTR(EFI_WHITE, back); |
| ps.AttrError = EFI_TEXT_ATTR(EFI_YELLOW, back); |
| attr = ps.AttrNorm; |
| if (mask & D_WARN) { |
| attr = ps.AttrHighlight; |
| } |
| if (mask & D_ERROR) { |
| attr = ps.AttrError; |
| } |
| if (ps.SetAttr) { |
| ps.Attr = attr; |
| ps.SetAttr (ps.Context, attr); |
| } |
| _Print (&ps); |
| va_end (ps.args); |
| va_end (args); |
| // |
| // Restore original attributes |
| // |
| if (ps.SetAttr) { |
| ps.SetAttr (ps.Context, SavedAttribute); |
| } |
| return 0; |
| } |
| STATIC |
| INTN |
| _DbgOut ( |
| IN VOID *Context, |
| IN CHAR16 *Buffer |
| ) |
| // Append string worker for DbgPrint |
| { |
| SIMPLE_TEXT_OUTPUT_INTERFACE *DbgOut; |
| DbgOut = Context; |
| // if (!DbgOut && ST && ST->ConOut) { |
| // DbgOut = ST->ConOut; |
| // } |
| if (DbgOut) { |
| DbgOut->OutputString (DbgOut, Buffer); |
| } |
| return 0; |
| } |
| INTN |
| _SPrint ( |
| IN VOID *Context, |
| IN CHAR16 *Buffer |
| ) |
| // Append string worker for SPrint, PoolPrint and CatPrint |
| { |
| UINTN len; |
| POOL_PRINT *spc; |
| spc = Context; |
| len = StrLen(Buffer); |
| // |
| // Is the string is over the max truncate it |
| // |
| if (spc->len + len > spc->maxlen) { |
| len = spc->maxlen - spc->len; |
| } |
| // |
| // Append the new text |
| // |
| CopyMem (spc->str + spc->len, Buffer, len * sizeof(CHAR16)); |
| spc->len += len; |
| // |
| // Null terminate it |
| // |
| if (spc->len < spc->maxlen) { |
| spc->str[spc->len] = 0; |
| } else if (spc->maxlen) { |
| spc->str[spc->maxlen-1] = 0; |
| } |
| return 0; |
| } |
| INTN |
| _PoolPrint ( |
| IN VOID *Context, |
| IN CHAR16 *Buffer |
| ) |
| // Append string worker for PoolPrint and CatPrint |
| { |
| UINTN newlen; |
| POOL_PRINT *spc; |
| spc = Context; |
| newlen = spc->len + StrLen(Buffer) + 1; |
| // |
| // Is the string is over the max, grow the buffer |
| // |
| if (newlen > spc->maxlen) { |
| // |
| // Grow the pool buffer |
| // |
| newlen += PRINT_STRING_LEN; |
| spc->maxlen = newlen; |
| spc->str = ReallocatePool ( |
| spc->str, |
| spc->len * sizeof(CHAR16), |
| spc->maxlen * sizeof(CHAR16) |
| ); |
| if (!spc->str) { |
| spc->len = 0; |
| spc->maxlen = 0; |
| } |
| } |
| // |
| // Append the new text |
| // |
| return _SPrint (Context, Buffer); |
| } |
| VOID |
| _PoolCatPrint ( |
| IN CHAR16 *fmt, |
| IN va_list args, |
| IN OUT POOL_PRINT *spc, |
| IN INTN (*Output)(VOID *context, CHAR16 *str) |
| ) |
| // Dispath function for SPrint, PoolPrint, and CatPrint |
| { |
| PRINT_STATE ps; |
| ZeroMem (&ps, sizeof(ps)); |
| ps.Output = Output; |
| ps.Context = spc; |
| ps.fmt.pw = fmt; |
| va_copy(ps.args, args); |
| _Print (&ps); |
| va_end(ps.args); |
| } |
| UINTN |
| SPrint ( |
| OUT CHAR16 *Str, |
| IN UINTN StrSize, |
| IN CHAR16 *fmt, |
| ... |
| ) |
| /*++ |
| Routine Description: |
| Prints a formatted unicode string to a buffer |
| Arguments: |
| Str - Output buffer to print the formatted string into |
| StrSize - Size of Str. String is truncated to this size. |
| A size of 0 means there is no limit |
| fmt - The format string |
| Returns: |
| String length returned in buffer |
| --*/ |
| { |
| POOL_PRINT spc; |
| va_list args; |
| va_start (args, fmt); |
| spc.str = Str; |
| spc.maxlen = StrSize / sizeof(CHAR16) - 1; |
| spc.len = 0; |
| _PoolCatPrint (fmt, args, &spc, _SPrint); |
| va_end (args); |
| return spc.len; |
| } |
| CHAR16 * |
| PoolPrint ( |
| IN CHAR16 *fmt, |
| ... |
| ) |
| /*++ |
| Routine Description: |
| Prints a formatted unicode string to allocated pool. The caller |
| must free the resulting buffer. |
| Arguments: |
| fmt - The format string |
| Returns: |
| Allocated buffer with the formatted string printed in it. |
| The caller must free the allocated buffer. The buffer |
| allocation is not packed. |
| --*/ |
| { |
| POOL_PRINT spc; |
| va_list args; |
| ZeroMem (&spc, sizeof(spc)); |
| va_start (args, fmt); |
| _PoolCatPrint (fmt, args, &spc, _PoolPrint); |
| va_end (args); |
| return spc.str; |
| } |
| CHAR16 * |
| CatPrint ( |
| IN OUT POOL_PRINT *Str, |
| IN CHAR16 *fmt, |
| ... |
| ) |
| /*++ |
| Routine Description: |
| Concatenates a formatted unicode string to allocated pool. |
| The caller must free the resulting buffer. |
| Arguments: |
| Str - Tracks the allocated pool, size in use, and |
| amount of pool allocated. |
| fmt - The format string |
| Returns: |
| Allocated buffer with the formatted string printed in it. |
| The caller must free the allocated buffer. The buffer |
| allocation is not packed. |
| --*/ |
| { |
| va_list args; |
| va_start (args, fmt); |
| _PoolCatPrint (fmt, args, Str, _PoolPrint); |
| va_end (args); |
| return Str->str; |
| } |
| UINTN |
| Print ( |
| IN CHAR16 *fmt, |
| ... |
| ) |
| /*++ |
| Routine Description: |
| Prints a formatted unicode string to the default console |
| Arguments: |
| fmt - Format string |
| Returns: |
| Length of string printed to the console |
| --*/ |
| { |
| va_list args; |
| UINTN back; |
| va_start (args, fmt); |
| back = _IPrint ((UINTN) -1, (UINTN) -1, ST->ConOut, fmt, NULL, args); |
| va_end (args); |
| return back; |
| } |
| UINTN |
| VPrint ( |
| IN CHAR16 *fmt, |
| va_list args |
| ) |
| /*++ |
| Routine Description: |
| Prints a formatted unicode string to the default console using a va_list |
| Arguments: |
| fmt - Format string |
| args - va_list |
| Returns: |
| Length of string printed to the console |
| --*/ |
| { |
| return _IPrint ((UINTN) -1, (UINTN) -1, ST->ConOut, fmt, NULL, args); |
| } |
| UINTN |
| PrintAt ( |
| IN UINTN Column, |
| IN UINTN Row, |
| IN CHAR16 *fmt, |
| ... |
| ) |
| /*++ |
| Routine Description: |
| Prints a formatted unicode string to the default console, at |
| the supplied cursor position |
| Arguments: |
| Column, Row - The cursor position to print the string at |
| fmt - Format string |
| Returns: |
| Length of string printed to the console |
| --*/ |
| { |
| va_list args; |
| UINTN back; |
| va_start (args, fmt); |
| back = _IPrint (Column, Row, ST->ConOut, fmt, NULL, args); |
| va_end (args); |
| return back; |
| } |
| UINTN |
| IPrint ( |
| IN SIMPLE_TEXT_OUTPUT_INTERFACE *Out, |
| IN CHAR16 *fmt, |
| ... |
| ) |
| /*++ |
| Routine Description: |
| Prints a formatted unicode string to the specified console |
| Arguments: |
| Out - The console to print the string too |
| fmt - Format string |
| Returns: |
| Length of string printed to the console |
| --*/ |
| { |
| va_list args; |
| UINTN back; |
| va_start (args, fmt); |
| back = _IPrint ((UINTN) -1, (UINTN) -1, Out, fmt, NULL, args); |
| va_end (args); |
| return back; |
| } |
| UINTN |
| IPrintAt ( |
| IN SIMPLE_TEXT_OUTPUT_INTERFACE *Out, |
| IN UINTN Column, |
| IN UINTN Row, |
| IN CHAR16 *fmt, |
| ... |
| ) |
| /*++ |
| Routine Description: |
| Prints a formatted unicode string to the specified console, at |
| the supplied cursor position |
| Arguments: |
| Out - The console to print the string too |
| Column, Row - The cursor position to print the string at |
| fmt - Format string |
| Returns: |
| Length of string printed to the console |
| --*/ |
| { |
| va_list args; |
| UINTN back; |
| va_start (args, fmt); |
| back = _IPrint (Column, Row, ST->ConOut, fmt, NULL, args); |
| va_end (args); |
| return back; |
| } |
| UINTN |
| _IPrint ( |
| IN UINTN Column, |
| IN UINTN Row, |
| IN SIMPLE_TEXT_OUTPUT_INTERFACE *Out, |
| IN CHAR16 *fmt, |
| IN CHAR8 *fmta, |
| IN va_list args |
| ) |
| // Display string worker for: Print, PrintAt, IPrint, IPrintAt |
| { |
| PRINT_STATE ps; |
| UINTN back; |
| ZeroMem (&ps, sizeof(ps)); |
| ps.Context = Out; |
| ps.Output = (INTN (*)(VOID *, CHAR16 *)) Out->OutputString; |
| ps.SetAttr = (INTN (*)(VOID *, UINTN)) Out->SetAttribute; |
| ps.Attr = Out->Mode->Attribute; |
| back = (ps.Attr >> 4) & 0xF; |
| ps.AttrNorm = EFI_TEXT_ATTR(EFI_LIGHTGRAY, back); |
| ps.AttrHighlight = EFI_TEXT_ATTR(EFI_WHITE, back); |
| ps.AttrError = EFI_TEXT_ATTR(EFI_YELLOW, back); |
| if (fmt) { |
| ps.fmt.pw = fmt; |
| } else { |
| ps.fmt.Ascii = TRUE; |
| ps.fmt.pc = fmta; |
| } |
| va_copy(ps.args, args); |
| if (Column != (UINTN) -1) { |
| Out->SetCursorPosition(Out, Column, Row); |
| } |
| back = _Print (&ps); |
| va_end(ps.args); |
| return back; |
| } |
| UINTN |
| APrint ( |
| IN CHAR8 *fmt, |
| ... |
| ) |
| /*++ |
| Routine Description: |
| For those whom really can't deal with unicode, a print |
| function that takes an ascii format string |
| Arguments: |
| fmt - ascii format string |
| Returns: |
| Length of string printed to the console |
| --*/ |
| { |
| va_list args; |
| UINTN back; |
| va_start (args, fmt); |
| back = _IPrint ((UINTN) -1, (UINTN) -1, ST->ConOut, NULL, fmt, args); |
| va_end (args); |
| return back; |
| } |
| STATIC |
| VOID |
| PFLUSH ( |
| IN OUT PRINT_STATE *ps |
| ) |
| { |
| *ps->Pos = 0; |
| ps->Output(ps->Context, ps->Buffer); |
| ps->Pos = ps->Buffer; |
| } |
| STATIC |
| VOID |
| PSETATTR ( |
| IN OUT PRINT_STATE *ps, |
| IN UINTN Attr |
| ) |
| { |
| PFLUSH (ps); |
| ps->RestoreAttr = ps->Attr; |
| if (ps->SetAttr) { |
| ps->SetAttr (ps->Context, Attr); |
| } |
| ps->Attr = Attr; |
| } |
| STATIC |
| VOID |
| PPUTC ( |
| IN OUT PRINT_STATE *ps, |
| IN CHAR16 c |
| ) |
| { |
| // if this is a newline, add a carraige return |
| if (c == '\n') { |
| PPUTC (ps, '\r'); |
| } |
| *ps->Pos = c; |
| ps->Pos += 1; |
| ps->Len += 1; |
| // if at the end of the buffer, flush it |
| if (ps->Pos >= ps->End) { |
| PFLUSH(ps); |
| } |
| } |
| STATIC |
| CHAR16 |
| PGETC ( |
| IN POINTER *p |
| ) |
| { |
| CHAR16 c; |
| c = p->Ascii ? p->pc[p->Index] : p->pw[p->Index]; |
| p->Index += 1; |
| return c; |
| } |
| STATIC |
| VOID |
| PITEM ( |
| IN OUT PRINT_STATE *ps |
| ) |
| { |
| UINTN Len, i; |
| PRINT_ITEM *Item; |
| CHAR16 c; |
| // Get the length of the item |
| Item = ps->Item; |
| Item->Item.Index = 0; |
| while (Item->Item.Index < Item->FieldWidth) { |
| c = PGETC(&Item->Item); |
| if (!c) { |
| Item->Item.Index -= 1; |
| break; |
| } |
| } |
| Len = Item->Item.Index; |
| // if there is no item field width, use the items width |
| if (Item->FieldWidth == (UINTN) -1) { |
| Item->FieldWidth = Len; |
| } |
| // if item is larger then width, update width |
| if (Len > Item->Width) { |
| Item->Width = Len; |
| } |
| // if pad field before, add pad char |
| if (Item->PadBefore) { |
| for (i=Item->Width; i < Item->FieldWidth; i+=1) { |
| PPUTC (ps, ' '); |
| } |
| } |
| // pad item |
| for (i=Len; i < Item->Width; i++) { |
| PPUTC (ps, Item->Pad); |
| } |
| // add the item |
| Item->Item.Index=0; |
| while (Item->Item.Index < Len) { |
| PPUTC (ps, PGETC(&Item->Item)); |
| } |
| // If pad at the end, add pad char |
| if (!Item->PadBefore) { |
| for (i=Item->Width; i < Item->FieldWidth; i+=1) { |
| PPUTC (ps, ' '); |
| } |
| } |
| } |
| STATIC |
| UINTN |
| _Print ( |
| IN PRINT_STATE *ps |
| ) |
| /*++ |
| Routine Description: |
| %w.lF - w = width |
| l = field width |
| F = format of arg |
| Args F: |
| 0 - pad with zeros |
| - - justify on left (default is on right) |
| , - add comma's to field |
| * - width provided on stack |
| n - Set output attribute to normal (for this field only) |
| h - Set output attribute to highlight (for this field only) |
| e - Set output attribute to error (for this field only) |
| l - Value is 64 bits |
| a - ascii string |
| s - unicode string |
| X - fixed 8 byte value in hex |
| x - hex value |
| d - value as decimal |
| c - Unicode char |
| t - EFI time structure |
| g - Pointer to GUID |
| r - EFI status code (result code) |
| N - Set output attribute to normal |
| H - Set output attribute to highlight |
| E - Set output attribute to error |
| % - Print a % |
| Arguments: |
| SystemTable - The system table |
| Returns: |
| Number of charactors written |
| --*/ |
| { |
| CHAR16 c; |
| UINTN Attr; |
| PRINT_ITEM Item; |
| CHAR16 Buffer[PRINT_STRING_LEN]; |
| ps->Len = 0; |
| ps->Buffer = Buffer; |
| ps->Pos = Buffer; |
| ps->End = Buffer + PRINT_STRING_LEN - 1; |
| ps->Item = &Item; |
| ps->fmt.Index = 0; |
| while ((c = PGETC(&ps->fmt))) { |
| if (c != '%') { |
| PPUTC ( ps, c ); |
| continue; |
| } |
| // setup for new item |
| Item.FieldWidth = (UINTN) -1; |
| Item.Width = 0; |
| Item.WidthParse = &Item.Width; |
| Item.Pad = ' '; |
| Item.PadBefore = TRUE; |
| Item.Comma = FALSE; |
| Item.Long = FALSE; |
| Item.Item.Ascii = FALSE; |
| Item.Item.pw = NULL; |
| ps->RestoreAttr = 0; |
| Attr = 0; |
| while ((c = PGETC(&ps->fmt))) { |
| switch (c) { |
| case '%': |
| // |
| // %% -> % |
| // |
| Item.Item.pw = Item.Scratch; |
| Item.Item.pw[0] = '%'; |
| Item.Item.pw[1] = 0; |
| break; |
| case '0': |
| Item.Pad = '0'; |
| break; |
| case '-': |
| Item.PadBefore = FALSE; |
| break; |
| case ',': |
| Item.Comma = TRUE; |
| break; |
| case '.': |
| Item.WidthParse = &Item.FieldWidth; |
| break; |
| case '*': |
| *Item.WidthParse = va_arg(ps->args, UINTN); |
| break; |
| case '1': |
| case '2': |
| case '3': |
| case '4': |
| case '5': |
| case '6': |
| case '7': |
| case '8': |
| case '9': |
| *Item.WidthParse = 0; |
| do { |
| *Item.WidthParse = *Item.WidthParse * 10 + c - '0'; |
| c = PGETC(&ps->fmt); |
| } while (c >= '0' && c <= '9') ; |
| ps->fmt.Index -= 1; |
| break; |
| case 'a': |
| Item.Item.pc = va_arg(ps->args, CHAR8 *); |
| Item.Item.Ascii = TRUE; |
| if (!Item.Item.pc) { |
| Item.Item.pc = (CHAR8 *)"(null)"; |
| } |
| break; |
| case 's': |
| Item.Item.pw = va_arg(ps->args, CHAR16 *); |
| if (!Item.Item.pw) { |
| Item.Item.pw = L"(null)"; |
| } |
| break; |
| case 'c': |
| Item.Item.pw = Item.Scratch; |
| Item.Item.pw[0] = (CHAR16) va_arg(ps->args, UINTN); |
| Item.Item.pw[1] = 0; |
| break; |
| case 'l': |
| Item.Long = TRUE; |
| break; |
| case 'X': |
| Item.Width = Item.Long ? 16 : 8; |
| Item.Pad = '0'; |
| case 'x': |
| Item.Item.pw = Item.Scratch; |
| ValueToHex ( |
| Item.Item.pw, |
| Item.Long ? va_arg(ps->args, UINT64) : va_arg(ps->args, UINTN) |
| ); |
| break; |
| case 'g': |
| Item.Item.pw = Item.Scratch; |
| GuidToString (Item.Item.pw, va_arg(ps->args, EFI_GUID *)); |
| break; |
| case 'd': |
| Item.Item.pw = Item.Scratch; |
| ValueToString ( |
| Item.Item.pw, |
| Item.Comma, |
| Item.Long ? va_arg(ps->args, UINT64) : va_arg(ps->args, UINTN) |
| ); |
| break |
| ; |
| case 't': |
| Item.Item.pw = Item.Scratch; |
| TimeToString (Item.Item.pw, va_arg(ps->args, EFI_TIME *)); |
| break; |
| case 'r': |
| Item.Item.pw = Item.Scratch; |
| StatusToString (Item.Item.pw, va_arg(ps->args, EFI_STATUS)); |
| break; |
| case 'n': |
| PSETATTR(ps, ps->AttrNorm); |
| break; |
| case 'h': |
| PSETATTR(ps, ps->AttrHighlight); |
| break; |
| case 'e': |
| PSETATTR(ps, ps->AttrError); |
| break; |
| case 'N': |
| Attr = ps->AttrNorm; |
| break; |
| case 'H': |
| Attr = ps->AttrHighlight; |
| break; |
| case 'E': |
| Attr = ps->AttrError; |
| break; |
| default: |
| Item.Item.pw = Item.Scratch; |
| Item.Item.pw[0] = '?'; |
| Item.Item.pw[1] = 0; |
| break; |
| } |
| // if we have an Item |
| if (Item.Item.pw) { |
| PITEM (ps); |
| break; |
| } |
| // if we have an Attr set |
| if (Attr) { |
| PSETATTR(ps, Attr); |
| ps->RestoreAttr = 0; |
| break; |
| } |
| } |
| if (ps->RestoreAttr) { |
| PSETATTR(ps, ps->RestoreAttr); |
| } |
| } |
| // Flush buffer |
| PFLUSH (ps); |
| return ps->Len; |
| } |
| STATIC CHAR8 Hex[] = {'0','1','2','3','4','5','6','7', |
| '8','9','A','B','C','D','E','F'}; |
| VOID |
| ValueToHex ( |
| IN CHAR16 *Buffer, |
| IN UINT64 v |
| ) |
| { |
| CHAR8 str[30], *p1; |
| CHAR16 *p2; |
| if (!v) { |
| Buffer[0] = '0'; |
| Buffer[1] = 0; |
| return ; |
| } |
| p1 = str; |
| p2 = Buffer; |
| while (v) { |
| *(p1++) = Hex[v & 0xf]; |
| v = RShiftU64 (v, 4); |
| } |
| while (p1 != str) { |
| *(p2++) = *(--p1); |
| } |
| *p2 = 0; |
| } |
| VOID |
| ValueToString ( |
| IN CHAR16 *Buffer, |
| IN BOOLEAN Comma, |
| IN INT64 v |
| ) |
| { |
| STATIC CHAR8 ca[] = { 3, 1, 2 }; |
| CHAR8 str[40], *p1; |
| CHAR16 *p2; |
| UINTN c, r; |
| if (!v) { |
| Buffer[0] = '0'; |
| Buffer[1] = 0; |
| return ; |
| } |
| p1 = str; |
| p2 = Buffer; |
| if (v < 0) { |
| *(p2++) = '-'; |
| v = -v; |
| } |
| while (v) { |
| v = (INT64)DivU64x32 ((UINT64)v, 10, &r); |
| *(p1++) = (CHAR8)r + '0'; |
| } |
| c = (Comma ? ca[(p1 - str) % 3] : 999) + 1; |
| while (p1 != str) { |
| c -= 1; |
| if (!c) { |
| *(p2++) = ','; |
| c = 3; |
| } |
| *(p2++) = *(--p1); |
| } |
| *p2 = 0; |
| } |
| VOID |
| TimeToString ( |
| OUT CHAR16 *Buffer, |
| IN EFI_TIME *Time |
| ) |
| { |
| UINTN Hour, Year; |
| CHAR16 AmPm; |
| AmPm = 'a'; |
| Hour = Time->Hour; |
| if (Time->Hour == 0) { |
| Hour = 12; |
| } else if (Time->Hour >= 12) { |
| AmPm = 'p'; |
| if (Time->Hour >= 13) { |
| Hour -= 12; |
| } |
| } |
| Year = Time->Year % 100; |
| // bugbug: for now just print it any old way |
| SPrint (Buffer, 0, L"%02d/%02d/%02d %02d:%02d%c", |
| Time->Month, |
| Time->Day, |
| Year, |
| Hour, |
| Time->Minute, |
| AmPm |
| ); |
| } |
| VOID |
| DumpHex ( |
| IN UINTN Indent, |
| IN UINTN Offset, |
| IN UINTN DataSize, |
| IN VOID *UserData |
| ) |
| { |
| CHAR8 *Data, Val[50], Str[20], c; |
| UINTN Size, Index; |
| UINTN ScreenCount; |
| UINTN TempColumn; |
| UINTN ScreenSize; |
| CHAR16 ReturnStr[1]; |
| ST->ConOut->QueryMode (ST->ConOut, ST->ConOut->Mode->Mode, &TempColumn, &ScreenSize); |
| ScreenCount = 0; |
| ScreenSize -= 2; |
| Data = UserData; |
| while (DataSize) { |
| Size = 16; |
| if (Size > DataSize) { |
| Size = DataSize; |
| } |
| for (Index=0; Index < Size; Index += 1) { |
| c = Data[Index]; |
| Val[Index*3+0] = Hex[c>>4]; |
| Val[Index*3+1] = Hex[c&0xF]; |
| Val[Index*3+2] = (Index == 7)?'-':' '; |
| Str[Index] = (c < ' ' || c > 'z') ? '.' : c; |
| } |
| Val[Index*3] = 0; |
| Str[Index] = 0; |
| Print (L"%*a%X: %-.48a *%a*\n", Indent, "", Offset, Val, Str); |
| Data += Size; |
| Offset += Size; |
| DataSize -= Size; |
| ScreenCount++; |
| if (ScreenCount >= ScreenSize && ScreenSize != 0) { |
| // |
| // If ScreenSize == 0 we have the console redirected so don't |
| // block updates |
| // |
| ScreenCount = 0; |
| Print (L"Press Enter to continue :"); |
| Input (L"", ReturnStr, sizeof(ReturnStr)/sizeof(CHAR16)); |
| Print (L"\n"); |
| } |
| } |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/lib/smbios.c |
|---|
| 0,0 → 1,126 |
| /*++ |
| Copyright (c) 2000 Intel Corporation |
| Module Name: |
| Smbios.c |
| Abstract: |
| Lib fucntions for SMBIOS. Used to get system serial number and GUID |
| Revision History |
| --*/ |
| #include "lib.h" |
| EFI_STATUS |
| LibGetSmbiosSystemGuidAndSerialNumber ( |
| IN EFI_GUID *SystemGuid, |
| OUT CHAR8 **SystemSerialNumber |
| ) |
| { |
| EFI_STATUS Status; |
| SMBIOS_STRUCTURE_TABLE *SmbiosTable; |
| SMBIOS_STRUCTURE_POINTER Smbios; |
| SMBIOS_STRUCTURE_POINTER SmbiosEnd; |
| UINT16 Index; |
| Status = LibGetSystemConfigurationTable(&SMBIOSTableGuid, (VOID**)&SmbiosTable); |
| if (EFI_ERROR(Status)) { |
| return EFI_NOT_FOUND; |
| } |
| Smbios.Hdr = (SMBIOS_HEADER *)SmbiosTable->TableAddress; |
| SmbiosEnd.Raw = (UINT8 *)(SmbiosTable->TableAddress + SmbiosTable->TableLength); |
| for (Index = 0; Index < SmbiosTable->TableLength ; Index++) { |
| if (Smbios.Hdr->Type == 1) { |
| if (Smbios.Hdr->Length < 0x19) { |
| // |
| // Older version did not support Guid and Serial number |
| // |
| continue; |
| } |
| // |
| // SMBIOS tables are byte packed so we need to do a byte copy to |
| // prevend alignment faults on IA-64. |
| CopyMem (SystemGuid, &Smbios.Type1->Uuid, sizeof(EFI_GUID)); |
| *SystemSerialNumber = LibGetSmbiosString(&Smbios, Smbios.Type1->SerialNumber); |
| return EFI_SUCCESS; |
| } |
| // |
| // Make Smbios point to the next record |
| // |
| LibGetSmbiosString (&Smbios, -1); |
| if (Smbios.Raw >= SmbiosEnd.Raw) { |
| // |
| // SMBIOS 2.1 incorrectly stated the length of SmbiosTable as 0x1e. |
| // given this we must double check against the lenght of |
| /// the structure. My home PC has this bug.ruthard |
| // |
| return EFI_SUCCESS; |
| } |
| } |
| return EFI_SUCCESS; |
| } |
| CHAR8* |
| LibGetSmbiosString ( |
| IN SMBIOS_STRUCTURE_POINTER *Smbios, |
| IN UINT16 StringNumber |
| ) |
| /*++ |
| Return SMBIOS string given the string number. |
| Arguments: |
| Smbios - Pointer to SMBIOS structure |
| StringNumber - String number to return. -1 is used to skip all strings and |
| point to the next SMBIOS structure. |
| Returns: |
| Pointer to string, or pointer to next SMBIOS strcuture if StringNumber == -1 |
| --*/ |
| { |
| UINT16 Index; |
| CHAR8 *String; |
| // |
| // Skip over formatted section |
| // |
| String = (CHAR8 *)(Smbios->Raw + Smbios->Hdr->Length); |
| // |
| // Look through unformated section |
| // |
| for (Index = 1; Index <= StringNumber; Index++) { |
| if (StringNumber == Index) { |
| return String; |
| } |
| // |
| // Skip string |
| // |
| for (; *String != 0; String++); |
| String++; |
| if (*String == 0) { |
| // |
| // If double NULL then we are done. |
| // Retrun pointer to next structure in Smbios. |
| // if you pass in a -1 you will always get here |
| // |
| Smbios->Raw = (UINT8 *)++String; |
| return NULL; |
| } |
| } |
| return NULL; |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/ChangeLog |
|---|
| 0,0 → 1,193 |
| 2006-03-21 Stephane Eranian <eranian@hpl.hp.com> |
| * merged patch to support gcc-4.1 submitted by |
| Raymund Will from Novell/SuSE |
| 2006-03-20 Stephane Eranian <eranian@hpl.hp.com> |
| * updated ia-64 and ia-32 linker scripts to |
| match latest gcc. The new gcc may put functions in |
| .text* sections. patch submitted by H.J. Lu from Intel. |
| 2004-11-19 Stephane Eranian <eranian@hpl.hp.com> |
| * added patch to ignore .eh_frame section for IA-32. Patch |
| submitted by Jim Wilson |
| 2004-09-23 Stephane Eranian <eranian@hpl.hp.com> |
| * added patch to discard unwind sections, newer toolchains |
| complained about them. Patch submitted by Jesse Barnes from SGI. |
| 2003-09-29 Stephane Eranian <eranian@hpl.hp.com> |
| * updated elf_ia64_efi.lds to reflect new data sections |
| created by gcc-3.3. Patch provided by Andreas Schwab from Suse. |
| 2003-06-20 Stephane Eranian <eranian@hpl.hp.com> |
| * updated elf_ia64_efi.lds and elf_ia32_efi.lds to include |
| new types data sections produced by recent version of gcc-3.x |
| 2002-02-22 Stephane Eranian <eranian@hpl.hp.com> |
| * release 3.0a |
| * modified both IA-64 and IA-32 loader scripts to add support for the |
| new .rodata sections names (such as rodata.str2.8). Required |
| for new versions of gcc3.x. |
| 2001-06-20 Stephane Eranian <eranian@hpl.hp.com> |
| * release 3.0 |
| * split gnu-efi package in two different packages: the libary+include+crt and the bootloader. |
| * removed W2U() hack and related files to get from wide-char to unicode. |
| * Use -fshort-wchar option for unicode. |
| * restructured Makefiles now install under INSTALLROOT. |
| 2001-04-06 Stephane Eranian <eranian@hpl.hp.com> |
| * incorporated patches from David and Michael Johnston at Intel |
| to get the package to compile for IA-32 linux target. |
| * Fixed ELILO to compile for Ia-32 (does not execute yet, though): |
| Makefile and start_kernel() function. |
| 2001-04-06 Andreas Schwab <schwab@suse.de> |
| * Fixed config.c to |
| get the timeout directive to do something. implemented the global |
| root= directive. |
| * Fix the efi_main() to deal with the -C option properly |
| 2001-04-05 Stephane Eranian <eranian@hpl.hp.com> |
| * update efi library to latest EFI toolkit 1.02 as distributed |
| by Intel. Fixed header + library files to compile with GCC |
| * merged ELI and LILO (as of gnu-efi-1.1) together, mostly |
| taking the config file feature of ELI. |
| * renamed LILO to ELILO to make the distinction |
| * restructured code to make it easier to understand and maintain |
| * fixed FPSWA driver checking and loading: we try all possible |
| files and let the driver itself figure out if it is the most |
| recent. |
| * added support for compression (gzip) but keep support for plain |
| ELF image. ELILO autodetects the format |
| * change the way the kernel is invoked. Now we call it in |
| physical memory mode. This breaks the dependency between the |
| kernel code and the loader. No more lilo_start.c madness. |
| * changed the way the boot_params are passed. We don't use the |
| ZERO_PAGE_ADDR trick anymore. Instead we use EFI runtime memory. |
| The address of the structure is passed to the kernel in r28 |
| by our convention. |
| * released as gnu-efi-2.0 |
| 2001-04-03 David Mosberger <davidm@hpl.hp.com> |
| * gnuefi/reloc_ia32.c (_relocate): Change return type from "void" |
| to "int". Return error status if relocation fails for some |
| reason. |
| * gnuefi/elf_ia32_efi.lds: Drop unneeded ".rel.reloc" section. |
| * gnuefi/crt0-efi-ia32.S (_start): Exit if _relocate() returns with |
| non-zero exit status. |
| * inc/ia32/efibind.h [__GNUC__]: Force 8-byte alignment for 64-bit |
| types as that is what EFI appears to be expecting, despite the |
| "#pragma pack()" at the beginning of the file! |
| 2001-03-29 David Mosberger <davidm@hpl.hp.com> |
| * gnuefi/reloc_ia32.c: Add a couple of defines to work around |
| libc/efilib collision on uint64_t et al. |
| (_relocate): Use ELF32_R_TYPE() instead of ELFW(R_TYPE)(). |
| * gnuefi/crt0-efi-ia32.S (dummy): Add a dummy relocation entry. |
| 2001-03-29 David Mosberger <davidm@hpl.hp.com> |
| * gnuefi/reloc_ia32.c: Add a couple of defines to work around |
| libc/efilib collision on uint64_t et al. |
| (_relocate): Use ELF32_R_TYPE() instead of ELFW(R_TYPE)(). |
| * gnuefi/crt0-efi-ia32.S (dummy): Add a dummy relocation entry. |
| 2000-10-26 David Mosberger <davidm@hpl.hp.com> |
| * gnuefi/elf_ia64_efi.lds: Mention .rela.sdata. |
| * Make.defaults (CFLAGS): Remove -nostdinc flags so we can pick |
| up the C compiler's stdarg.h. |
| * inc/stdarg.h: Remove this file. It's not correct for gcc (nor |
| most other optimizing compilers). |
| 2000-10-10 Stephane Eranian <eranian@hpl.hp.com> |
| * cleaned up the error message and printing of those. |
| * added support to load the FPSWA from a file in case support is not |
| present in the firmware already |
| * fixed split_args() to do the right thing when you have leading spaces |
| before kernel name |
| * changed the argify() function to rely on \0 instead of LoadOptionSize |
| as the field seems to be broken with current firmware |
| * bumped version to 1.0 |
| 2000-10-04 David Mosberger <davidm@hpl.hp.com> |
| * gnuefi/reloc_ia64.S: Reserve space for up to 750 function descriptors. |
| * gnuefi/elf_ia64_efi.lds: Add .sdata section for small data and |
| put __gp in the "middle" of it. |
| * gnuefi/crt0-efi-ia64.S (_start): Use movl/add to load |
| gp-relative addresses that could be out of the range of the addl |
| offset. |
| * gnuefi/reloc_ia64.S (_relocate): Ditto. |
| * apps/Makefile: Remove standard rules and include Make.rules instead. |
| * lilo/Makefile: Ditto. |
| * Make.rules: New file. |
| 2000-08-04 Stephane Eranian <eranian@hpl.hp.com> |
| * released version 0.9 |
| * incorporated ACPI changes for Asuza by NEC < kouchi@hpc.bs1.fc.nec.co.jp> |
| * added support for initrd (-i option) original ELI code from Bill Nottingham <notting@redhat.com>) |
| * lots of cleanups |
| * got rid of #ifdef LILO_DEBUG and uses macro instead |
| * fix a few extra memory leaks in create_boot_params() |
| * added exit capability just before starting the kernel |
| 2000-06-22 David Mosberger <davidm@hpl.hp.com> |
| * gnuefi/elf_ia64_efi.lds: Add .srodata, .ctors, .IA64.unwind, |
| .IA64.unwind_info to .data section and .rela.ctors to .rela |
| section. |
| 2000-04-03 David Mosberger <davidm@hpl.hp.com> |
| * lilo/lilo.c (LILO_VERSION): Up version number to 0.9. |
| * gnuefi/elf_ia64_efi.lds: Include .IA_64.unwind and |
| .IA_64.unwind_info in .data segment to avoid EFI load error |
| "ImageAddress: pointer outside of image" error due to the .dynsym |
| relocations against these sections. |
| * ChangeLog: Moved from lilo/ChangeLogs. |
| * gnuefi/reloc_ia64.S: fixed typo: .space directive had constant |
| 100 hardcoded instead of using MAX_FUNCTION_DESCRIPTORS |
| macro. Duh. |
| Fri Mar 17 15:19:18 PST 2000 Stephane Eranian <eranian@hpl.hp.com> |
| * Released 0.8 |
| * replace the getopt.c with new version free with better license |
| * created a documentation file |
| * fix a couple of memory leaks |
| * code cleanups |
| * created a separate directory for lilo in the gnu-efi package. |
| * added support for the BOOT_IMAGE argument to kernel |
| * default is to build natively now |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/README.gnuefi |
|---|
| 0,0 → 1,392 |
| ------------------------------------------------- |
| Building EFI Applications Using the GNU Toolchain |
| ------------------------------------------------- |
| David Mosberger <davidm@hpl.hp.com> |
| 23 September 1999 |
| Copyright (c) 1999-2003 Hewlett-Packard Co. |
| Last update: 08/20/2003 |
| * Introduction |
| This document has two parts: the first part describes how to develop |
| EFI applications for IA-64 and x86 using the GNU toolchain and the EFI |
| development environment contained in this directory. The second part |
| describes some of the more subtle aspects of how this development |
| environment works. |
| * Part 1: Developing EFI Applications |
| ** Prerequisites: |
| To develop x86 EFI applications, the following tools are needed: |
| - gcc-3.0 or newer (gcc 2.7.2 is NOT sufficient!) |
| As of gnu-efi-3.0b, the Redhat 8.0 toolchain is known to work, |
| but the Redhat 9.0 toolchain is not currently supported. |
| - A version of "objcopy" that supports EFI applications. To |
| check if your version includes EFI support, issue the |
| command: |
| objcopy --help |
| and verify that the line "supported targets" contains the |
| string "efi-app-ia32". |
| - For debugging purposes, it's useful to have a version of |
| "objdump" that supports EFI applications as well. This |
| allows inspect and disassemble EFI binaries. |
| To develop IA-64 EFI applications, the following tools are needed: |
| - A version of gcc newer than July 30th 1999 (older versions |
| had problems with generating position independent code). |
| As of gnu-efi-3.0b, gcc-3.1 is known to work well. |
| - A version of "objcopy" that supports EFI applications. To |
| check if your version includes EFI support, issue the |
| command: |
| objcopy --help |
| and verify that the line "supported targets" contains the |
| string "efi-app-ia64". |
| - For debugging purposes, it's useful to have a version of |
| "objdump" that supports EFI applications as well. This |
| allows inspect and disassemble EFI binaries. |
| ** Directory Structure |
| This EFI development environment contains the following |
| subdirectories: |
| inc: This directory contains the EFI-related include files. The |
| files are taken from Intel's EFI source distribution, except |
| that various fixes were applied to make it compile with the |
| GNU toolchain. |
| lib: This directory contains the source code for Intel's EFI library. |
| Again, the files are taken from Intel's EFI source |
| distribution, with changes to make them compile with the GNU |
| toolchain. |
| gnuefi: This directory contains the glue necessary to convert ELF64 |
| binaries to EFI binaries. Various runtime code bits, such as |
| a self-relocator are included as well. This code has been |
| contributed by the Hewlett-Packard Company and is distributed |
| under the GNU GPL. |
| apps: This directory contains a few simple EFI test apps. |
| ** Setup |
| It is necessary to edit the Makefile in the directory containing this |
| README file before EFI applications can be built. Specifically, you |
| should verify that macros CC, AS, LD, AR, RANLIB, and OBJCOPY point to |
| the appropriate compiler, assembler, linker, ar, and ranlib binaries, |
| respectively. |
| If you're working in a cross-development environment, be sure to set |
| macro ARCH to the desired target architecture ("ia32" for x86, "ia64" |
| for IA-64). For convenience, this can also be done from the make |
| command line (e.g., "make ARCH=ia64"). |
| ** Building |
| To build the sample EFI applications provided in subdirectory "apps", |
| simply invoke "make" in the toplevel directory (the directory |
| containing this README file). This should build lib/libefi.a and |
| gnuefi/libgnuefi.a first and then all the EFI applications such as a |
| apps/t6.efi. |
| ** Running |
| Just copy the EFI application (e.g., apps/t6.efi) to the EFI |
| filesystem, boot EFI, and then select "Invoke EFI application" to run |
| the application you want to test. Alternatively, you can invoke the |
| Intel-provided "nshell" application and then invoke your test binary |
| via the command line interface that "nshell" provides. |
| ** Writing Your Own EFI Application |
| Suppose you have your own EFI application in a file called |
| "apps/myefiapp.c". To get this application built by the GNU EFI build |
| environment, simply add "myefiapp.efi" to macro TARGETS in |
| apps/Makefile. Once this is done, invoke "make" in the top level |
| directory. This should result in EFI application apps/myefiapp.efi, |
| ready for execution. |
| The GNU EFI build environment allows to write EFI applications as |
| described in Intel's EFI documentation, except for two differences: |
| - The EFI application's entry point is always called "efi_main". The |
| declaration of this routine is: |
| EFI_STATUS efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab); |
| - UNICODE string literals must be written as W2U(L"Sample String") |
| instead of just L"Sample String". The W2U() macro is defined in |
| <efilib.h>. This header file also declares the function W2UCpy() |
| which allows to convert a wide string into a UNICODE string and |
| store the result in a programmer-supplied buffer. |
| * Part 2: Inner Workings |
| WARNING: This part contains all the gory detail of how the GNU EFI |
| toolchain works. Normal users do not have to worry about such |
| details. Reading this part incurs a definite risk of inducing severe |
| headaches or other maladies. |
| The basic idea behind the GNU EFI build environment is to use the GNU |
| toolchain to build a normal ELF binary that, at the end, is converted |
| to an EFI binary. EFI binaries are really just PE32+ binaries. PE |
| stands for "Portable Executable" and is the object file format |
| Microsoft is using on its Windows platforms. PE is basically the COFF |
| object file format with an MS-DOS2.0 compatible header slapped on in |
| front of it. The "32" in PE32+ stands for 32 bits, meaning that PE32 |
| is a 32-bit object file format. The plus in "PE32+" indicates that |
| this format has been hacked to allow loading a 4GB binary anywhere in |
| a 64-bit address space (unlike ELF64, however, this is not a full |
| 64-bit object file format because the entire binary cannot span more |
| than 4GB of address space). EFI binaries are plain PE32+ binaries |
| except that the "subsystem id" differs from normal Windows binaries. |
| There are two flavors of EFI binaries: "applications" and "drivers" |
| and each has there own subsystem id and are identical otherwise. At |
| present, the GNU EFI build environment supports the building of EFI |
| applications only, though it would be trivial to generate drivers, as |
| the only difference is the subsystem id. For more details on PE32+, |
| see the spec at |
| http://msdn.microsoft.com/library/specs/msdn_pecoff.htm. |
| In theory, converting a suitable ELF64 binary to PE32+ is easy and |
| could be accomplished with the "objcopy" utility by specifying option |
| --target=efi-app-ia32 (x86) or --target=efi-app-ia64 (IA-64). But |
| life never is that easy, so here some complicating factors: |
| (1) COFF sections are very different from ELF sections. |
| ELF binaries distinguish between program headers and sections. |
| The program headers describe the memory segments that need to |
| be loaded/initialized, whereas the sections describe what |
| constitutes those segments. In COFF (and therefore PE32+) no |
| such distinction is made. Thus, COFF sections need to be page |
| aligned and have a size that is a multiple of the page size |
| (4KB for EFI), whereas ELF allows sections at arbitrary |
| addresses and with arbitrary sizes. |
| (2) EFI binaries should be relocatable. |
| Since EFI binaries are executed in physical mode, EFI cannot |
| guarantee that a given binary can be loaded at its preferred |
| address. EFI does _try_ to load a binary at it's preferred |
| address, but if it can't do so, it will load it at another |
| address and then relocate the binary using the contents of the |
| .reloc section. |
| (3) On IA-64, the EFI entry point needs to point to a function |
| descriptor, not to the code address of the entry point. |
| (4) The EFI specification assumes that wide characters use UNICODE |
| encoding. |
| ANSI C does not specify the size or encoding that a wide |
| character uses. These choices are "implementation defined". |
| On most UNIX systems, the GNU toolchain uses a wchar_t that is |
| 4 bytes in size. The encoding used for such characters is |
| (mostly) UCS4. |
| In the following sections, we address how the GNU EFI build |
| environment addresses each of these issues. |
| ** (1) Accommodating COFF Sections |
| In order to satisfy the COFF constraint of page-sized and page-aligned |
| sections, the GNU EFI build environment uses the special linker script |
| in gnuefi/elf_$(ARCH)_efi.lds where $(ARCH) is the target architecture |
| ("ia32" for x86, and "ia64" for IA-64). This script is set up to |
| create only eight COFF section, each page aligned and page sized. |
| These eight sections are used to group together the much greater |
| number of sections that are typically present in ELF object files. |
| Specifically: |
| .hash |
| Collects the ELF .hash info (this section _must_ be the first |
| section in order to build a shared object file; the section is |
| not actually loaded or used at runtime). |
| .text |
| Collects all sections containing executable code. |
| .data |
| Collects read-only and read-write data, literal string data, |
| global offset tables, the uninitialized data segment (bss) and |
| various other sections containing data. |
| The reason read-only data is placed here instead of the in |
| .text is to make it possible to disassemble the .text section |
| without getting garbage due to read-only data. Besides, since |
| EFI binaries execute in physical mode, differences in page |
| protection do not matter. |
| The reason the uninitialized data is placed in this section is |
| that the EFI loader appears to be unable to handle sections |
| that are allocated but not loaded from the binary. |
| .dynamic, .dynsym, .rela, .rel, .reloc |
| These sections contains the dynamic information necessary to |
| self-relocate the binary (see below). |
| A couple of more points worth noting about the linker script: |
| o On IA-64, the global pointer symbol (__gp) needs to be placed such |
| that the _entire_ EFI binary can be addressed using the signed |
| 22-bit offset that the "addl" instruction affords. Specifically, |
| this means that __gp should be placed at ImageBase + 0x200000. |
| Strictly speaking, only a couple of symbols need to be addressable |
| in this fashion, so with some care it should be possible to build |
| binaries much larger than 4MB. To get a list of symbols that need |
| to be addressable in this fashion, grep the assembly files in |
| directory gnuefi for the string "@gprel". |
| o The link address (ImageBase) of the binary is (arbitrarily) set to |
| zero. This could be set to something larger to increase the chance |
| of EFI being able to load the binary without requiring relocation. |
| However, a start address of 0 makes debugging a wee bit easier |
| (great for those of us who can add, but not subtract... ;-). |
| o The relocation related sections (.dynamic, .rel, .rela, .reloc) |
| cannot be placed inside .data because some tools in the GNU |
| toolchain rely on the existence of these sections. |
| o Some sections in the ELF binary intentionally get dropped when |
| building the EFI binary. Particularly noteworthy are the dynamic |
| relocation sections for the .plabel and .reloc sections. It would |
| be _wrong_ to include these sections in the EFI binary because it |
| would result in .reloc and .plabel being relocated twice (once by |
| the EFI loader and once by the self-relocator; see below for a |
| description of the latter). Specifically, only the sections |
| mentioned with the -j option in the final "objcopy" command are |
| retained in the EFI binary (see apps/Makefile). |
| ** (2) Building Relocatable Binaries |
| ELF binaries are normally linked for a fixed load address and are thus |
| not relocatable. The only kind of ELF object that is relocatable are |
| shared objects ("shared libraries"). However, even those objects are |
| usually not completely position independent and therefore require |
| runtime relocation by the dynamic loader. For example, IA-64 binaries |
| normally require relocation of the global offset table. |
| The approach to building relocatable binaries in the GNU EFI build |
| environment is to: |
| (a) build an ELF shared object |
| (b) link it together with a self-relocator that takes care of |
| applying the dynamic relocations that may be present in the |
| ELF shared object |
| (c) convert the resulting image to an EFI binary |
| The self-relocator is of course architecture dependent. The x86 |
| version can be found in gnuefi/reloc_ia32.c, the IA-64 version can be |
| found in gnuefi/reloc_ia64.S. |
| The self-relocator operates as follows: the startup code invokes it |
| right after EFI has handed off control to the EFI binary at symbol |
| "_start". Upon activation, the self-relocator searches the .dynamic |
| section (whose starting address is given by symbol _DYNAMIC) for the |
| dynamic relocation information, which can be found in the DT_REL, |
| DT_RELSZ, and DT_RELENT entries of the dynamic table (DT_RELA, |
| DT_RELASZ, and DT_RELAENT in the case of rela relocations, as is the |
| case for IA-64). The dynamic relocation information points to the ELF |
| relocation table. Once this table is found, the self-relocator walks |
| through it, applying each relocation one by one. Since the EFI |
| binaries are fully resolved shared objects, only a subset of all |
| possible relocations need to be supported. Specifically, on x86 only |
| the R_386_RELATIVE relocation is needed. On IA-64, the relocations |
| R_IA64_DIR64LSB, R_IA64_REL64LSB, and R_IA64_FPTR64LSB are needed. |
| Note that the R_IA64_FPTR64LSB relocation requires access to the |
| dynamic symbol table. This is why the .dynsym section is included in |
| the EFI binary. Another complication is that this relocation requires |
| memory to hold the function descriptors (aka "procedure labels" or |
| "plabels"). Each function descriptor uses 16 bytes of memory. The |
| IA-64 self-relocator currently reserves a static memory area that can |
| hold 100 of these descriptors. If the self-relocator runs out of |
| space, it causes the EFI binary to fail with error code 5 |
| (EFI_BUFFER_TOO_SMALL). When this happens, the manifest constant |
| MAX_FUNCTION_DESCRIPTORS in gnuefi/reloc_ia64.S should be increased |
| and the application recompiled. An easy way to count the number of |
| function descriptors required by an EFI application is to run the |
| command: |
| objdump --dynamic-reloc example.so | fgrep FPTR64 | wc -l |
| assuming "example" is the name of the desired EFI application. |
| ** (3) Creating the Function Descriptor for the IA-64 EFI Binaries |
| As mentioned above, the IA-64 PE32+ format assumes that the entry |
| point of the binary is a function descriptor. A function descriptors |
| consists of two double words: the first one is the code entry point |
| and the second is the global pointer that should be loaded before |
| calling the entry point. Since the ELF toolchain doesn't know how to |
| generate a function descriptor for the entry point, the startup code |
| in gnuefi/crt0-efi-ia64.S crafts one manually by with the code: |
| .section .plabel, "a" |
| _start_plabel: |
| data8 _start |
| data8 __gp |
| this places the procedure label for entry point _start in a section |
| called ".plabel". Now, the only problem is that _start and __gp need |
| to be relocated _before_ EFI hands control over to the EFI binary. |
| Fortunately, PE32+ defines a section called ".reloc" that can achieve |
| this. Thus, in addition to manually crafting the function descriptor, |
| the startup code also crafts a ".reloc" section that has will cause |
| the EFI loader to relocate the function descriptor before handing over |
| control to the EFI binary (again, see the PECOFF spec mentioned above |
| for details). |
| A final question may be why .plabel and .reloc need to go in their own |
| COFF sections. The answer is simply: we need to be able to discard |
| the relocation entries that are generated for these sections. By |
| placing them in these sections, the relocations end up in sections |
| ".rela.plabel" and ".rela.reloc" which makes it easy to filter them |
| out in the filter script. Also, the ".reloc" section needs to be in |
| its own section so that the objcopy program can recognize it and can |
| create the correct directory entries in the PE32+ binary. |
| ** (4) Convenient and Portable Generation of UNICODE String Literals |
| As of gnu-efi-3.0, we make use (and somewhat abuse) the gcc option |
| that forces wide characters (WCHAR_T) to use short integers (2 bytes) |
| instead of integers (4 bytes). This way we match the Unicode character |
| size. By abuse, we mean that we rely on the fact that the regular ASCII |
| characters are encoded the same way between (short) wide characters |
| and Unicode and basically only use the first byte. This allows us |
| to just use them interchangeably. |
| The gcc option to force short wide characters is : -fshort-wchar |
| * * * The End * * * |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/efipart.h |
|---|
| 0,0 → 1,61 |
| #ifndef _EFI_PART_H |
| #define _EFI_PART_H |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| efipart.h |
| Abstract: |
| Info about disk partitions and Master Boot Records |
| Revision History |
| --*/ |
| // |
| // |
| // |
| #define EFI_PARTITION 0xef |
| #define MBR_SIZE 512 |
| #pragma pack(1) |
| typedef struct { |
| UINT8 BootIndicator; |
| UINT8 StartHead; |
| UINT8 StartSector; |
| UINT8 StartTrack; |
| UINT8 OSIndicator; |
| UINT8 EndHead; |
| UINT8 EndSector; |
| UINT8 EndTrack; |
| UINT8 StartingLBA[4]; |
| UINT8 SizeInLBA[4]; |
| } MBR_PARTITION_RECORD; |
| #define EXTRACT_UINT32(D) (UINT32)(D[0] | (D[1] << 8) | (D[2] << 16) | (D[3] << 24)) |
| #define MBR_SIGNATURE 0xaa55 |
| #define MIN_MBR_DEVICE_SIZE 0x80000 |
| #define MBR_ERRATA_PAD 0x40000 // 128 MB |
| #define MAX_MBR_PARTITIONS 4 |
| typedef struct { |
| UINT8 BootStrapCode[440]; |
| UINT8 UniqueMbrSignature[4]; |
| UINT8 Unknown[2]; |
| MBR_PARTITION_RECORD Partition[MAX_MBR_PARTITIONS]; |
| UINT16 Signature; |
| } MASTER_BOOT_RECORD; |
| #pragma pack() |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/efilib.h |
|---|
| 0,0 → 1,879 |
| #ifndef _EFILIB_INCLUDE_ |
| #define _EFILIB_INCLUDE_ |
| /*++ |
| Copyright (c) 2000 Intel Corporation |
| Module Name: |
| efilib.h |
| Abstract: |
| EFI library functions |
| Revision History |
| --*/ |
| #include "efidebug.h" |
| #include "efipart.h" |
| #include "efilibplat.h" |
| #include "efilink.h" |
| #include "efirtlib.h" |
| #include "pci22.h" |
| #include "libsmbios.h" |
| // |
| // Public read-only data in the EFI library |
| // |
| extern EFI_SYSTEM_TABLE *ST; |
| extern EFI_BOOT_SERVICES *BS; |
| extern EFI_RUNTIME_SERVICES *RT; |
| extern EFI_GUID DevicePathProtocol; |
| extern EFI_GUID LoadedImageProtocol; |
| extern EFI_GUID TextInProtocol; |
| extern EFI_GUID TextOutProtocol; |
| extern EFI_GUID BlockIoProtocol; |
| extern EFI_GUID DiskIoProtocol; |
| extern EFI_GUID FileSystemProtocol; |
| extern EFI_GUID LoadFileProtocol; |
| extern EFI_GUID DeviceIoProtocol; |
| extern EFI_GUID VariableStoreProtocol; |
| extern EFI_GUID LegacyBootProtocol; |
| extern EFI_GUID UnicodeCollationProtocol; |
| extern EFI_GUID SerialIoProtocol; |
| extern EFI_GUID VgaClassProtocol; |
| extern EFI_GUID TextOutSpliterProtocol; |
| extern EFI_GUID ErrorOutSpliterProtocol; |
| extern EFI_GUID TextInSpliterProtocol; |
| extern EFI_GUID SimpleNetworkProtocol; |
| extern EFI_GUID PxeBaseCodeProtocol; |
| extern EFI_GUID PxeCallbackProtocol; |
| extern EFI_GUID NetworkInterfaceIdentifierProtocol; |
| extern EFI_GUID UiProtocol; |
| extern EFI_GUID InternalShellProtocol; |
| extern EFI_GUID EfiGlobalVariable; |
| extern EFI_GUID GenericFileInfo; |
| extern EFI_GUID FileSystemInfo; |
| extern EFI_GUID FileSystemVolumeLabelInfo; |
| extern EFI_GUID PcAnsiProtocol; |
| extern EFI_GUID Vt100Protocol; |
| extern EFI_GUID NullGuid; |
| extern EFI_GUID UnknownDevice; |
| extern EFI_GUID EfiPartTypeSystemPartitionGuid; |
| extern EFI_GUID EfiPartTypeLegacyMbrGuid; |
| extern EFI_GUID MpsTableGuid; |
| extern EFI_GUID AcpiTableGuid; |
| extern EFI_GUID SMBIOSTableGuid; |
| extern EFI_GUID SalSystemTableGuid; |
| // |
| // EFI Variable strings |
| // |
| #define LOAD_OPTION_ACTIVE 0x00000001 |
| #define VarLanguageCodes L"LangCodes" |
| #define VarLanguage L"Lang" |
| #define VarTimeout L"Timeout" |
| #define VarConsoleInp L"ConIn" |
| #define VarConsoleOut L"ConOut" |
| #define VarErrorOut L"ErrOut" |
| #define VarBootOption L"Boot%04x" |
| #define VarBootOrder L"BootOrder" |
| #define VarBootNext L"BootNext" |
| #define VarBootCurrent L"BootCurrent" |
| #define VarDriverOption L"Driver%04x" |
| #define VarDriverOrder L"DriverOrder" |
| #define VarConsoleInpDev L"ConInDev" |
| #define VarConsoleOutDev L"ConOutDev" |
| #define VarErrorOutDev L"ErrOutDev" |
| #define LanguageCodeEnglish "eng" |
| extern EFI_DEVICE_PATH RootDevicePath[]; |
| extern EFI_DEVICE_PATH EndDevicePath[]; |
| extern EFI_DEVICE_PATH EndInstanceDevicePath[]; |
| // |
| // Other public data in the EFI library |
| // |
| extern EFI_MEMORY_TYPE PoolAllocationType; |
| // |
| // STATIC - Name is internal to the module |
| // INTERNAL - Name is internal to the component (i.e., directory) |
| // BOOTSERVCE - Name of a boot service function |
| // |
| #define STATIC |
| #define INTERNAL |
| #define BOOTSERVICE |
| // |
| // Prototypes |
| // |
| VOID |
| InitializeLib ( |
| IN EFI_HANDLE ImageHandle, |
| IN EFI_SYSTEM_TABLE *SystemTable |
| ); |
| VOID |
| InitializeUnicodeSupport ( |
| CHAR8 *LangCode |
| ); |
| VOID |
| EFIDebugVariable ( |
| VOID |
| ); |
| VOID |
| SetCrc ( |
| IN OUT EFI_TABLE_HEADER *Hdr |
| ); |
| VOID |
| SetCrcAltSize ( |
| IN UINTN Size, |
| IN OUT EFI_TABLE_HEADER *Hdr |
| ); |
| BOOLEAN |
| CheckCrc ( |
| IN UINTN MaxSize, |
| IN OUT EFI_TABLE_HEADER *Hdr |
| ); |
| BOOLEAN |
| CheckCrcAltSize ( |
| IN UINTN MaxSize, |
| IN UINTN Size, |
| IN OUT EFI_TABLE_HEADER *Hdr |
| ); |
| UINT32 |
| CalculateCrc ( |
| UINT8 *pt, |
| UINTN Size |
| ); |
| VOID |
| ZeroMem ( |
| IN VOID *Buffer, |
| IN UINTN Size |
| ); |
| VOID |
| SetMem ( |
| IN VOID *Buffer, |
| IN UINTN Size, |
| IN UINT8 Value |
| ); |
| VOID |
| CopyMem ( |
| IN VOID *Dest, |
| IN VOID *Src, |
| IN UINTN len |
| ); |
| INTN |
| CompareMem ( |
| IN VOID *Dest, |
| IN VOID *Src, |
| IN UINTN len |
| ); |
| INTN |
| StrCmp ( |
| IN CHAR16 *s1, |
| IN CHAR16 *s2 |
| ); |
| INTN |
| StrnCmp ( |
| IN CHAR16 *s1, |
| IN CHAR16 *s2, |
| IN UINTN len |
| ); |
| INTN |
| StriCmp ( |
| IN CHAR16 *s1, |
| IN CHAR16 *s2 |
| ); |
| VOID |
| StrLwr ( |
| IN CHAR16 *Str |
| ); |
| VOID |
| StrUpr ( |
| IN CHAR16 *Str |
| ); |
| VOID |
| StrCpy ( |
| IN CHAR16 *Dest, |
| IN CHAR16 *Src |
| ); |
| VOID |
| StrCat ( |
| IN CHAR16 *Dest, |
| IN CHAR16 *Src |
| ); |
| UINTN |
| StrLen ( |
| IN CHAR16 *s1 |
| ); |
| UINTN |
| StrSize ( |
| IN CHAR16 *s1 |
| ); |
| CHAR16 * |
| StrDuplicate ( |
| IN CHAR16 *Src |
| ); |
| UINTN |
| strlena ( |
| IN CHAR8 *s1 |
| ); |
| UINTN |
| strcmpa ( |
| IN CHAR8 *s1, |
| IN CHAR8 *s2 |
| ); |
| UINTN |
| strncmpa ( |
| IN CHAR8 *s1, |
| IN CHAR8 *s2, |
| IN UINTN len |
| ); |
| UINTN |
| xtoi ( |
| CHAR16 *str |
| ); |
| UINTN |
| Atoi ( |
| CHAR16 *str |
| ); |
| BOOLEAN |
| MetaMatch ( |
| IN CHAR16 *String, |
| IN CHAR16 *Pattern |
| ); |
| BOOLEAN |
| MetaiMatch ( |
| IN CHAR16 *String, |
| IN CHAR16 *Pattern |
| ); |
| UINT64 |
| LShiftU64 ( |
| IN UINT64 Operand, |
| IN UINTN Count |
| ); |
| UINT64 |
| RShiftU64 ( |
| IN UINT64 Operand, |
| IN UINTN Count |
| ); |
| UINT64 |
| MultU64x32 ( |
| IN UINT64 Multiplicand, |
| IN UINTN Multiplier |
| ); |
| UINT64 |
| DivU64x32 ( |
| IN UINT64 Dividend, |
| IN UINTN Divisor, |
| OUT UINTN *Remainder OPTIONAL |
| ); |
| VOID |
| InitializeLock ( |
| IN OUT FLOCK *Lock, |
| IN EFI_TPL Priority |
| ); |
| VOID |
| AcquireLock ( |
| IN FLOCK *Lock |
| ); |
| VOID |
| ReleaseLock ( |
| IN FLOCK *Lock |
| ); |
| INTN |
| CompareGuid( |
| IN EFI_GUID *Guid1, |
| IN EFI_GUID *Guid2 |
| ); |
| VOID * |
| AllocatePool ( |
| IN UINTN Size |
| ); |
| VOID * |
| AllocateZeroPool ( |
| IN UINTN Size |
| ); |
| VOID * |
| ReallocatePool ( |
| IN VOID *OldPool, |
| IN UINTN OldSize, |
| IN UINTN NewSize |
| ); |
| VOID |
| FreePool ( |
| IN VOID *p |
| ); |
| VOID |
| Output ( |
| IN CHAR16 *Str |
| ); |
| VOID |
| Input ( |
| IN CHAR16 *Prompt OPTIONAL, |
| OUT CHAR16 *InStr, |
| IN UINTN StrLen |
| ); |
| VOID |
| IInput ( |
| IN SIMPLE_TEXT_OUTPUT_INTERFACE *ConOut, |
| IN SIMPLE_INPUT_INTERFACE *ConIn, |
| IN CHAR16 *Prompt OPTIONAL, |
| OUT CHAR16 *InStr, |
| IN UINTN StrLen |
| ); |
| UINTN |
| Print ( |
| IN CHAR16 *fmt, |
| ... |
| ); |
| UINTN |
| SPrint ( |
| OUT CHAR16 *Str, |
| IN UINTN StrSize, |
| IN CHAR16 *fmt, |
| ... |
| ); |
| CHAR16 * |
| PoolPrint ( |
| IN CHAR16 *fmt, |
| ... |
| ); |
| typedef struct { |
| CHAR16 *str; |
| UINTN len; |
| UINTN maxlen; |
| } POOL_PRINT; |
| CHAR16 * |
| CatPrint ( |
| IN OUT POOL_PRINT *Str, |
| IN CHAR16 *fmt, |
| ... |
| ); |
| UINTN |
| PrintAt ( |
| IN UINTN Column, |
| IN UINTN Row, |
| IN CHAR16 *fmt, |
| ... |
| ); |
| UINTN |
| IPrint ( |
| IN SIMPLE_TEXT_OUTPUT_INTERFACE *Out, |
| IN CHAR16 *fmt, |
| ... |
| ); |
| UINTN |
| IPrintAt ( |
| IN SIMPLE_TEXT_OUTPUT_INTERFACE *Out, |
| IN UINTN Column, |
| IN UINTN Row, |
| IN CHAR16 *fmt, |
| ... |
| ); |
| UINTN |
| APrint ( |
| IN CHAR8 *fmt, |
| ... |
| ); |
| VOID |
| ValueToHex ( |
| IN CHAR16 *Buffer, |
| IN UINT64 v |
| ); |
| VOID |
| ValueToString ( |
| IN CHAR16 *Buffer, |
| IN BOOLEAN Comma, |
| IN INT64 v |
| ); |
| VOID |
| TimeToString ( |
| OUT CHAR16 *Buffer, |
| IN EFI_TIME *Time |
| ); |
| VOID |
| GuidToString ( |
| OUT CHAR16 *Buffer, |
| IN EFI_GUID *Guid |
| ); |
| VOID |
| StatusToString ( |
| OUT CHAR16 *Buffer, |
| EFI_STATUS Status |
| ); |
| VOID |
| DumpHex ( |
| IN UINTN Indent, |
| IN UINTN Offset, |
| IN UINTN DataSize, |
| IN VOID *UserData |
| ); |
| BOOLEAN |
| GrowBuffer( |
| IN OUT EFI_STATUS *Status, |
| IN OUT VOID **Buffer, |
| IN UINTN BufferSize |
| ); |
| EFI_MEMORY_DESCRIPTOR * |
| LibMemoryMap ( |
| OUT UINTN *NoEntries, |
| OUT UINTN *MapKey, |
| OUT UINTN *DescriptorSize, |
| OUT UINT32 *DescriptorVersion |
| ); |
| VOID * |
| LibGetVariable ( |
| IN CHAR16 *Name, |
| IN EFI_GUID *VendorGuid |
| ); |
| VOID * |
| LibGetVariableAndSize ( |
| IN CHAR16 *Name, |
| IN EFI_GUID *VendorGuid, |
| OUT UINTN *VarSize |
| ); |
| EFI_STATUS |
| LibDeleteVariable ( |
| IN CHAR16 *VarName, |
| IN EFI_GUID *VarGuid |
| ); |
| EFI_STATUS |
| LibInsertToTailOfBootOrder ( |
| IN UINT16 BootOption, |
| IN BOOLEAN OnlyInsertIfEmpty |
| ); |
| EFI_STATUS |
| LibLocateProtocol ( |
| IN EFI_GUID *ProtocolGuid, |
| OUT VOID **Interface |
| ); |
| EFI_STATUS |
| LibLocateHandle ( |
| IN EFI_LOCATE_SEARCH_TYPE SearchType, |
| IN EFI_GUID *Protocol OPTIONAL, |
| IN VOID *SearchKey OPTIONAL, |
| IN OUT UINTN *NoHandles, |
| OUT EFI_HANDLE **Buffer |
| ); |
| EFI_STATUS |
| LibLocateHandleByDiskSignature ( |
| IN UINT8 MBRType, |
| IN UINT8 SignatureType, |
| IN VOID *Signature, |
| IN OUT UINTN *NoHandles, |
| OUT EFI_HANDLE **Buffer |
| ); |
| EFI_STATUS |
| LibInstallProtocolInterfaces ( |
| IN OUT EFI_HANDLE *Handle, |
| ... |
| ); |
| VOID |
| LibUninstallProtocolInterfaces ( |
| IN EFI_HANDLE Handle, |
| ... |
| ); |
| EFI_STATUS |
| LibReinstallProtocolInterfaces ( |
| IN OUT EFI_HANDLE *Handle, |
| ... |
| ); |
| EFI_EVENT |
| LibCreateProtocolNotifyEvent ( |
| IN EFI_GUID *ProtocolGuid, |
| IN EFI_TPL NotifyTpl, |
| IN EFI_EVENT_NOTIFY NotifyFunction, |
| IN VOID *NotifyContext, |
| OUT VOID *Registration |
| ); |
| EFI_STATUS |
| WaitForSingleEvent ( |
| IN EFI_EVENT Event, |
| IN UINT64 Timeout OPTIONAL |
| ); |
| VOID |
| WaitForEventWithTimeout ( |
| IN EFI_EVENT Event, |
| IN UINTN Timeout, |
| IN UINTN Row, |
| IN UINTN Column, |
| IN CHAR16 *String, |
| IN EFI_INPUT_KEY TimeoutKey, |
| OUT EFI_INPUT_KEY *Key |
| ); |
| EFI_FILE_HANDLE |
| LibOpenRoot ( |
| IN EFI_HANDLE DeviceHandle |
| ); |
| EFI_FILE_INFO * |
| LibFileInfo ( |
| IN EFI_FILE_HANDLE FHand |
| ); |
| EFI_FILE_SYSTEM_INFO * |
| LibFileSystemInfo ( |
| IN EFI_FILE_HANDLE FHand |
| ); |
| EFI_FILE_SYSTEM_VOLUME_LABEL_INFO * |
| LibFileSystemVolumeLabelInfo ( |
| IN EFI_FILE_HANDLE FHand |
| ); |
| BOOLEAN |
| ValidMBR( |
| IN MASTER_BOOT_RECORD *Mbr, |
| IN EFI_BLOCK_IO *BlkIo |
| ); |
| BOOLEAN |
| LibMatchDevicePaths ( |
| IN EFI_DEVICE_PATH *Multi, |
| IN EFI_DEVICE_PATH *Single |
| ); |
| EFI_DEVICE_PATH * |
| LibDuplicateDevicePathInstance ( |
| IN EFI_DEVICE_PATH *DevPath |
| ); |
| EFI_DEVICE_PATH * |
| DevicePathFromHandle ( |
| IN EFI_HANDLE Handle |
| ); |
| EFI_DEVICE_PATH * |
| DevicePathInstance ( |
| IN OUT EFI_DEVICE_PATH **DevicePath, |
| OUT UINTN *Size |
| ); |
| UINTN |
| DevicePathInstanceCount ( |
| IN EFI_DEVICE_PATH *DevicePath |
| ); |
| EFI_DEVICE_PATH * |
| AppendDevicePath ( |
| IN EFI_DEVICE_PATH *Src1, |
| IN EFI_DEVICE_PATH *Src2 |
| ); |
| EFI_DEVICE_PATH * |
| AppendDevicePathNode ( |
| IN EFI_DEVICE_PATH *Src1, |
| IN EFI_DEVICE_PATH *Src2 |
| ); |
| EFI_DEVICE_PATH* |
| AppendDevicePathInstance ( |
| IN EFI_DEVICE_PATH *Src, |
| IN EFI_DEVICE_PATH *Instance |
| ); |
| EFI_DEVICE_PATH * |
| FileDevicePath ( |
| IN EFI_HANDLE Device OPTIONAL, |
| IN CHAR16 *FileName |
| ); |
| UINTN |
| DevicePathSize ( |
| IN EFI_DEVICE_PATH *DevPath |
| ); |
| EFI_DEVICE_PATH * |
| DuplicateDevicePath ( |
| IN EFI_DEVICE_PATH *DevPath |
| ); |
| EFI_DEVICE_PATH * |
| UnpackDevicePath ( |
| IN EFI_DEVICE_PATH *DevPath |
| ); |
| EFI_STATUS |
| LibDevicePathToInterface ( |
| IN EFI_GUID *Protocol, |
| IN EFI_DEVICE_PATH *FilePath, |
| OUT VOID **Interface |
| ); |
| CHAR16 * |
| DevicePathToStr ( |
| EFI_DEVICE_PATH *DevPath |
| ); |
| // |
| // BugBug: I need my own include files |
| // |
| typedef struct { |
| UINT8 Register; |
| UINT8 Function; |
| UINT8 Device; |
| UINT8 Bus; |
| UINT32 Reserved; |
| } EFI_ADDRESS; |
| typedef union { |
| UINT64 Address; |
| EFI_ADDRESS EfiAddress; |
| } EFI_PCI_ADDRESS_UNION; |
| EFI_STATUS |
| PciFindDeviceClass ( |
| IN OUT EFI_PCI_ADDRESS_UNION *Address, |
| IN UINT8 BaseClass, |
| IN UINT8 SubClass |
| ); |
| EFI_STATUS |
| PciFindDevice ( |
| IN OUT EFI_PCI_ADDRESS_UNION *DeviceAddress, |
| IN UINT16 VendorId, |
| IN UINT16 DeviceId, |
| IN OUT PCI_TYPE00 *Pci |
| ); |
| // |
| // SIMPLE_READ_FILE object used to access files |
| // |
| typedef VOID *SIMPLE_READ_FILE; |
| EFI_STATUS |
| OpenSimpleReadFile ( |
| IN BOOLEAN BootPolicy, |
| IN VOID *SourceBuffer OPTIONAL, |
| IN UINTN SourceSize, |
| IN OUT EFI_DEVICE_PATH **FilePath, |
| OUT EFI_HANDLE *DeviceHandle, |
| OUT SIMPLE_READ_FILE *SimpleReadHandle |
| ); |
| EFI_STATUS |
| ReadSimpleReadFile ( |
| IN SIMPLE_READ_FILE SimpleReadHandle, |
| IN UINTN Offset, |
| IN OUT UINTN *ReadSize, |
| OUT VOID *Buffer |
| ); |
| VOID |
| CloseSimpleReadFile ( |
| IN SIMPLE_READ_FILE SimpleReadHandle |
| ); |
| VOID |
| InitializeGuid ( |
| VOID |
| ); |
| UINT8 |
| DecimaltoBCD( |
| IN UINT8 DecValue |
| ); |
| UINT8 |
| BCDtoDecimal( |
| IN UINT8 BcdValue |
| ); |
| EFI_STATUS |
| LibGetSystemConfigurationTable( |
| IN EFI_GUID *TableGuid, |
| IN OUT VOID **Table |
| ); |
| BOOLEAN |
| LibIsValidTextGraphics ( |
| IN CHAR16 Graphic, |
| OUT CHAR8 *PcAnsi, OPTIONAL |
| OUT CHAR8 *Ascii OPTIONAL |
| ); |
| BOOLEAN |
| IsValidAscii ( |
| IN CHAR16 Ascii |
| ); |
| BOOLEAN |
| IsValidEfiCntlChar ( |
| IN CHAR16 c |
| ); |
| CHAR16 * |
| LibGetUiString ( |
| IN EFI_HANDLE Handle, |
| IN UI_STRING_TYPE StringType, |
| IN ISO_639_2 *LangCode, |
| IN BOOLEAN ReturnDevicePathStrOnMismatch |
| ); |
| CHAR8* |
| LibGetSmbiosString ( |
| IN SMBIOS_STRUCTURE_POINTER *Smbios, |
| IN UINT16 StringNumber |
| ); |
| EFI_STATUS |
| LibGetSmbiosSystemGuidAndSerialNumber ( |
| IN EFI_GUID *SystemGuid, |
| OUT CHAR8 **SystemSerialNumber |
| ); |
| EFI_STATUS |
| InitializeGlobalIoDevice ( |
| IN EFI_DEVICE_PATH *DevicePath, |
| IN EFI_GUID *Protocol, |
| IN CHAR8 *ErrorStr, |
| OUT EFI_DEVICE_IO_INTERFACE **GlobalIoFncs |
| ); |
| UINT32 |
| ReadPort ( |
| IN EFI_DEVICE_IO_INTERFACE *GlobalIoFncs, |
| IN EFI_IO_WIDTH Width, |
| IN UINTN Port |
| ); |
| UINT32 |
| WritePort ( |
| IN EFI_DEVICE_IO_INTERFACE *GlobalIoFncs, |
| IN EFI_IO_WIDTH Width, |
| IN UINTN Port, |
| IN UINTN Data |
| ); |
| UINT32 |
| ReadPciConfig ( |
| IN EFI_DEVICE_IO_INTERFACE *GlobalIoFncs, |
| IN EFI_IO_WIDTH Width, |
| IN UINTN Port |
| ); |
| UINT32 |
| WritePciConfig ( |
| IN EFI_DEVICE_IO_INTERFACE *GlobalIoFncs, |
| IN EFI_IO_WIDTH Width, |
| IN UINTN Port, |
| IN UINTN Data |
| ); |
| extern EFI_DEVICE_IO_INTERFACE *GlobalIoFncs; |
| #define outp(_Port, _DataByte) (UINT8)WritePort(GlobalIoFncs, IO_UINT8, (UINTN)_Port, (UINTN)_DataByte) |
| #define inp(_Port) (UINT8)ReadPort(GlobalIoFncs, IO_UINT8, (UINTN)_Port) |
| #define outpw(_Port, _DataByte) (UINT16)WritePort(GlobalIoFncs, IO_UINT16, (UINTN)_Port, (UINTN)_DataByte) |
| #define inpw(_Port) (UINT16)ReadPort(GlobalIoFncs, IO_UINT16, (UINTN)_Port) |
| #define outpd(_Port, _DataByte) (UINT32)WritePort(GlobalIoFncs, IO_UINT32, (UINTN)_Port, (UINTN)_DataByte) |
| #define inpd(_Port) (UINT32)ReadPort(GlobalIoFncs, IO_UINT32, (UINTN)_Port) |
| #define writepci8(_Addr, _DataByte) (UINT8)WritePciConfig(GlobalIoFncs, IO_UINT8, (UINTN)_Addr, (UINTN)_DataByte) |
| #define readpci8(_Addr) (UINT8)ReadPciConfig(GlobalIoFncs, IO_UINT8, (UINTN)_Addr) |
| #define writepci16(_Addr, _DataByte) (UINT16)WritePciConfig(GlobalIoFncs, IO_UINT16, (UINTN)_Addr, (UINTN)_DataByte) |
| #define readpci16(_Addr) (UINT16)ReadPciConfig(GlobalIoFncs, IO_UINT16, (UINTN)_Addr) |
| #define writepci32(_Addr, _DataByte) (UINT32)WritePciConfig(GlobalIoFncs, IO_UINT32, (UINTN)_Addr, (UINTN)_DataByte) |
| #define readpci32(_Addr) (UINT32)ReadPciConfig(GlobalIoFncs, IO_UINT32, (UINTN)_Addr) |
| #define Pause() WaitForSingleEvent (ST->ConIn->WaitForKey, 0) |
| #define Port80(_PostCode) GlobalIoFncs->Io.Write (GlobalIoFncs, IO_UINT16, (UINT64)0x80, 1, &(_PostCode)) |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/inc.mak |
|---|
| 0,0 → 1,19 |
| INC_DEPS = $(INC_DEPS) \ |
| efi.h \ |
| efiapi.h \ |
| efibind.h \ |
| eficon.h \ |
| efidebug.h \ |
| efidef.h \ |
| efidevp.h \ |
| efierr.h \ |
| efifs.h \ |
| efilib.h \ |
| efipart.h \ |
| efiprot.h \ |
| efipxe.h \ |
| efivar.h \ |
| pe.h \ |
| stdarg.h |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/efifs.h |
|---|
| 0,0 → 1,116 |
| #ifndef _EFI_FS_H |
| #define _EFI_FS_H |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| efifs.h |
| Abstract: |
| EFI File System structures |
| Revision History |
| --*/ |
| // |
| // EFI Partition header (normaly starts in LBA 1) |
| // |
| #define EFI_PARTITION_SIGNATURE 0x5053595320494249 |
| #define EFI_PARTITION_REVISION 0x00010001 |
| #define MIN_EFI_PARTITION_BLOCK_SIZE 512 |
| #define EFI_PARTITION_LBA 1 |
| typedef struct _EFI_PARTITION_HEADER { |
| EFI_TABLE_HEADER Hdr; |
| UINT32 DirectoryAllocationNumber; |
| UINT32 BlockSize; |
| EFI_LBA FirstUsableLba; |
| EFI_LBA LastUsableLba; |
| EFI_LBA UnusableSpace; |
| EFI_LBA FreeSpace; |
| EFI_LBA RootFile; |
| EFI_LBA SecutiryFile; |
| } EFI_PARTITION_HEADER; |
| // |
| // File header |
| // |
| #define EFI_FILE_HEADER_SIGNATURE 0x454c494620494249 |
| #define EFI_FILE_HEADER_REVISION 0x00010000 |
| #define EFI_FILE_STRING_SIZE 260 |
| typedef struct _EFI_FILE_HEADER { |
| EFI_TABLE_HEADER Hdr; |
| UINT32 Class; |
| UINT32 LBALOffset; |
| EFI_LBA Parent; |
| UINT64 FileSize; |
| UINT64 FileAttributes; |
| EFI_TIME FileCreateTime; |
| EFI_TIME FileModificationTime; |
| EFI_GUID VendorGuid; |
| CHAR16 FileString[EFI_FILE_STRING_SIZE]; |
| } EFI_FILE_HEADER; |
| // |
| // Return the file's first LBAL which is in the same |
| // logical block as the file header |
| // |
| #define EFI_FILE_LBAL(a) ((EFI_LBAL *) (((CHAR8 *) (a)) + (a)->LBALOffset)) |
| #define EFI_FILE_CLASS_FREE_SPACE 1 |
| #define EFI_FILE_CLASS_EMPTY 2 |
| #define EFI_FILE_CLASS_NORMAL 3 |
| // |
| // Logical Block Address List - the fundemental block |
| // description structure |
| // |
| #define EFI_LBAL_SIGNATURE 0x4c41424c20494249 |
| #define EFI_LBAL_REVISION 0x00010000 |
| typedef struct _EFI_LBAL { |
| EFI_TABLE_HEADER Hdr; |
| UINT32 Class; |
| EFI_LBA Parent; |
| EFI_LBA Next; |
| UINT32 ArraySize; |
| UINT32 ArrayCount; |
| } EFI_LBAL; |
| // Array size |
| #define EFI_LBAL_ARRAY_SIZE(lbal,offs,blks) \ |
| (((blks) - (offs) - (lbal)->Hdr.HeaderSize) / sizeof(EFI_RL)) |
| // |
| // Logical Block run-length |
| // |
| typedef struct { |
| EFI_LBA Start; |
| UINT64 Length; |
| } EFI_RL; |
| // |
| // Return the run-length structure from an LBAL header |
| // |
| #define EFI_LBAL_RL(a) ((EFI_RL*) (((CHAR8 *) (a)) + (a)->Hdr.HeaderSize)) |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/efiapi.h |
|---|
| 0,0 → 1,720 |
| #ifndef _EFI_API_H |
| #define _EFI_API_H |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| efiapi.h |
| Abstract: |
| Global EFI runtime & boot service interfaces |
| Revision History |
| --*/ |
| // |
| // EFI Specification Revision |
| // |
| #define EFI_SPECIFICATION_MAJOR_REVISION 1 |
| #define EFI_SPECIFICATION_MINOR_REVISION 02 |
| // |
| // Declare forward referenced data structures |
| // |
| INTERFACE_DECL(_EFI_SYSTEM_TABLE); |
| // |
| // EFI Memory |
| // |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_ALLOCATE_PAGES) ( |
| IN EFI_ALLOCATE_TYPE Type, |
| IN EFI_MEMORY_TYPE MemoryType, |
| IN UINTN NoPages, |
| OUT EFI_PHYSICAL_ADDRESS *Memory |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_FREE_PAGES) ( |
| IN EFI_PHYSICAL_ADDRESS Memory, |
| IN UINTN NoPages |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_GET_MEMORY_MAP) ( |
| IN OUT UINTN *MemoryMapSize, |
| IN OUT EFI_MEMORY_DESCRIPTOR *MemoryMap, |
| OUT UINTN *MapKey, |
| OUT UINTN *DescriptorSize, |
| OUT UINT32 *DescriptorVersion |
| ); |
| #define NextMemoryDescriptor(Ptr,Size) ((EFI_MEMORY_DESCRIPTOR *) (((UINT8 *) Ptr) + Size)) |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_ALLOCATE_POOL) ( |
| IN EFI_MEMORY_TYPE PoolType, |
| IN UINTN Size, |
| OUT VOID **Buffer |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_FREE_POOL) ( |
| IN VOID *Buffer |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_SET_VIRTUAL_ADDRESS_MAP) ( |
| IN UINTN MemoryMapSize, |
| IN UINTN DescriptorSize, |
| IN UINT32 DescriptorVersion, |
| IN EFI_MEMORY_DESCRIPTOR *VirtualMap |
| ); |
| #define EFI_OPTIONAL_PTR 0x00000001 |
| #define EFI_INTERNAL_FNC 0x00000002 // Pointer to internal runtime fnc |
| #define EFI_INTERNAL_PTR 0x00000004 // Pointer to internal runtime data |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_CONVERT_POINTER) ( |
| IN UINTN DebugDisposition, |
| IN OUT VOID **Address |
| ); |
| // |
| // EFI Events |
| // |
| #define EVT_TIMER 0x80000000 |
| #define EVT_RUNTIME 0x40000000 |
| #define EVT_RUNTIME_CONTEXT 0x20000000 |
| #define EVT_NOTIFY_WAIT 0x00000100 |
| #define EVT_NOTIFY_SIGNAL 0x00000200 |
| #define EVT_SIGNAL_EXIT_BOOT_SERVICES 0x00000201 |
| #define EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE 0x60000202 |
| #define EVT_EFI_SIGNAL_MASK 0x000000FF |
| #define EVT_EFI_SIGNAL_MAX 2 |
| typedef |
| VOID |
| (EFIAPI *EFI_EVENT_NOTIFY) ( |
| IN EFI_EVENT Event, |
| IN VOID *Context |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_CREATE_EVENT) ( |
| IN UINT32 Type, |
| IN EFI_TPL NotifyTpl, |
| IN EFI_EVENT_NOTIFY NotifyFunction, |
| IN VOID *NotifyContext, |
| OUT EFI_EVENT *Event |
| ); |
| typedef enum { |
| TimerCancel, |
| TimerPeriodic, |
| TimerRelative, |
| TimerTypeMax |
| } EFI_TIMER_DELAY; |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_SET_TIMER) ( |
| IN EFI_EVENT Event, |
| IN EFI_TIMER_DELAY Type, |
| IN UINT64 TriggerTime |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_SIGNAL_EVENT) ( |
| IN EFI_EVENT Event |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_WAIT_FOR_EVENT) ( |
| IN UINTN NumberOfEvents, |
| IN EFI_EVENT *Event, |
| OUT UINTN *Index |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_CLOSE_EVENT) ( |
| IN EFI_EVENT Event |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_CHECK_EVENT) ( |
| IN EFI_EVENT Event |
| ); |
| // |
| // Task priority level |
| // |
| #define TPL_APPLICATION 4 |
| #define TPL_CALLBACK 8 |
| #define TPL_NOTIFY 16 |
| #define TPL_HIGH_LEVEL 31 |
| typedef |
| EFI_TPL |
| (EFIAPI *EFI_RAISE_TPL) ( |
| IN EFI_TPL NewTpl |
| ); |
| typedef |
| VOID |
| (EFIAPI *EFI_RESTORE_TPL) ( |
| IN EFI_TPL OldTpl |
| ); |
| // |
| // EFI platform varibles |
| // |
| #define EFI_GLOBAL_VARIABLE \ |
| { 0x8BE4DF61, 0x93CA, 0x11d2, {0xAA, 0x0D, 0x00, 0xE0, 0x98, 0x03, 0x2B, 0x8C} } |
| // Variable attributes |
| #define EFI_VARIABLE_NON_VOLATILE 0x00000001 |
| #define EFI_VARIABLE_BOOTSERVICE_ACCESS 0x00000002 |
| #define EFI_VARIABLE_RUNTIME_ACCESS 0x00000004 |
| // Variable size limitation |
| #define EFI_MAXIMUM_VARIABLE_SIZE 1024 |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_GET_VARIABLE) ( |
| IN CHAR16 *VariableName, |
| IN EFI_GUID *VendorGuid, |
| OUT UINT32 *Attributes OPTIONAL, |
| IN OUT UINTN *DataSize, |
| OUT VOID *Data |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_GET_NEXT_VARIABLE_NAME) ( |
| IN OUT UINTN *VariableNameSize, |
| IN OUT CHAR16 *VariableName, |
| IN OUT EFI_GUID *VendorGuid |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_SET_VARIABLE) ( |
| IN CHAR16 *VariableName, |
| IN EFI_GUID *VendorGuid, |
| IN UINT32 Attributes, |
| IN UINTN DataSize, |
| IN VOID *Data |
| ); |
| // |
| // EFI Time |
| // |
| typedef struct { |
| UINT32 Resolution; // 1e-6 parts per million |
| UINT32 Accuracy; // hertz |
| BOOLEAN SetsToZero; // Set clears sub-second time |
| } EFI_TIME_CAPABILITIES; |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_GET_TIME) ( |
| OUT EFI_TIME *Time, |
| OUT EFI_TIME_CAPABILITIES *Capabilities OPTIONAL |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_SET_TIME) ( |
| IN EFI_TIME *Time |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_GET_WAKEUP_TIME) ( |
| OUT BOOLEAN *Enabled, |
| OUT BOOLEAN *Pending, |
| OUT EFI_TIME *Time |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_SET_WAKEUP_TIME) ( |
| IN BOOLEAN Enable, |
| IN EFI_TIME *Time OPTIONAL |
| ); |
| // |
| // Image functions |
| // |
| // PE32+ Subsystem type for EFI images |
| #if !defined(IMAGE_SUBSYSTEM_EFI_APPLICATION) |
| #define IMAGE_SUBSYSTEM_EFI_APPLICATION 10 |
| #define IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER 11 |
| #define IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER 12 |
| #endif |
| // PE32+ Machine type for EFI images |
| #if !defined(EFI_IMAGE_MACHINE_IA32) |
| #define EFI_IMAGE_MACHINE_IA32 0x014c |
| #endif |
| #if !defined(EFI_IMAGE_MACHINE_IA64) |
| #define EFI_IMAGE_MACHINE_IA64 0x0200 |
| #endif |
| // Image Entry prototype |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_IMAGE_ENTRY_POINT) ( |
| IN EFI_HANDLE ImageHandle, |
| IN struct _EFI_SYSTEM_TABLE *SystemTable |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_IMAGE_LOAD) ( |
| IN BOOLEAN BootPolicy, |
| IN EFI_HANDLE ParentImageHandle, |
| IN EFI_DEVICE_PATH *FilePath, |
| IN VOID *SourceBuffer OPTIONAL, |
| IN UINTN SourceSize, |
| OUT EFI_HANDLE *ImageHandle |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_IMAGE_START) ( |
| IN EFI_HANDLE ImageHandle, |
| OUT UINTN *ExitDataSize, |
| OUT CHAR16 **ExitData OPTIONAL |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_EXIT) ( |
| IN EFI_HANDLE ImageHandle, |
| IN EFI_STATUS ExitStatus, |
| IN UINTN ExitDataSize, |
| IN CHAR16 *ExitData OPTIONAL |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_IMAGE_UNLOAD) ( |
| IN EFI_HANDLE ImageHandle |
| ); |
| // Image handle |
| #define LOADED_IMAGE_PROTOCOL \ |
| { 0x5B1B31A1, 0x9562, 0x11d2, {0x8E, 0x3F, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B} } |
| #define EFI_IMAGE_INFORMATION_REVISION 0x1000 |
| typedef struct { |
| UINT32 Revision; |
| EFI_HANDLE ParentHandle; |
| struct _EFI_SYSTEM_TABLE *SystemTable; |
| // Source location of image |
| EFI_HANDLE DeviceHandle; |
| EFI_DEVICE_PATH *FilePath; |
| VOID *Reserved; |
| // Images load options |
| UINT32 LoadOptionsSize; |
| VOID *LoadOptions; |
| // Location of where image was loaded |
| VOID *ImageBase; |
| UINT64 ImageSize; |
| EFI_MEMORY_TYPE ImageCodeType; |
| EFI_MEMORY_TYPE ImageDataType; |
| // If the driver image supports a dynamic unload request |
| EFI_IMAGE_UNLOAD Unload; |
| } EFI_LOADED_IMAGE; |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_EXIT_BOOT_SERVICES) ( |
| IN EFI_HANDLE ImageHandle, |
| IN UINTN MapKey |
| ); |
| // |
| // Misc |
| // |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_STALL) ( |
| IN UINTN Microseconds |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_SET_WATCHDOG_TIMER) ( |
| IN UINTN Timeout, |
| IN UINT64 WatchdogCode, |
| IN UINTN DataSize, |
| IN CHAR16 *WatchdogData OPTIONAL |
| ); |
| typedef enum { |
| EfiResetCold, |
| EfiResetWarm |
| } EFI_RESET_TYPE; |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_RESET_SYSTEM) ( |
| IN EFI_RESET_TYPE ResetType, |
| IN EFI_STATUS ResetStatus, |
| IN UINTN DataSize, |
| IN CHAR16 *ResetData OPTIONAL |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_GET_NEXT_MONOTONIC_COUNT) ( |
| OUT UINT64 *Count |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_GET_NEXT_HIGH_MONO_COUNT) ( |
| OUT UINT32 *HighCount |
| ); |
| // |
| // Protocol handler functions |
| // |
| typedef enum { |
| EFI_NATIVE_INTERFACE, |
| EFI_PCODE_INTERFACE |
| } EFI_INTERFACE_TYPE; |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_INSTALL_PROTOCOL_INTERFACE) ( |
| IN OUT EFI_HANDLE *Handle, |
| IN EFI_GUID *Protocol, |
| IN EFI_INTERFACE_TYPE InterfaceType, |
| IN VOID *Interface |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_REINSTALL_PROTOCOL_INTERFACE) ( |
| IN EFI_HANDLE Handle, |
| IN EFI_GUID *Protocol, |
| IN VOID *OldInterface, |
| IN VOID *NewInterface |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_UNINSTALL_PROTOCOL_INTERFACE) ( |
| IN EFI_HANDLE Handle, |
| IN EFI_GUID *Protocol, |
| IN VOID *Interface |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_HANDLE_PROTOCOL) ( |
| IN EFI_HANDLE Handle, |
| IN EFI_GUID *Protocol, |
| OUT VOID **Interface |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_REGISTER_PROTOCOL_NOTIFY) ( |
| IN EFI_GUID *Protocol, |
| IN EFI_EVENT Event, |
| OUT VOID **Registration |
| ); |
| typedef enum { |
| AllHandles, |
| ByRegisterNotify, |
| ByProtocol |
| } EFI_LOCATE_SEARCH_TYPE; |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_LOCATE_HANDLE) ( |
| IN EFI_LOCATE_SEARCH_TYPE SearchType, |
| IN EFI_GUID *Protocol OPTIONAL, |
| IN VOID *SearchKey OPTIONAL, |
| IN OUT UINTN *BufferSize, |
| OUT EFI_HANDLE *Buffer |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_LOCATE_DEVICE_PATH) ( |
| IN EFI_GUID *Protocol, |
| IN OUT EFI_DEVICE_PATH **DevicePath, |
| OUT EFI_HANDLE *Device |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_INSTALL_CONFIGURATION_TABLE) ( |
| IN EFI_GUID *Guid, |
| IN VOID *Table |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_RESERVED_SERVICE) ( |
| ); |
| // |
| // Standard EFI table header |
| // |
| typedef struct _EFI_TABLE_HEARDER { |
| UINT64 Signature; |
| UINT32 Revision; |
| UINT32 HeaderSize; |
| UINT32 CRC32; |
| UINT32 Reserved; |
| } EFI_TABLE_HEADER; |
| // |
| // EFI Runtime Serivces Table |
| // |
| #define EFI_RUNTIME_SERVICES_SIGNATURE 0x56524553544e5552 |
| #define EFI_RUNTIME_SERVICES_REVISION (EFI_SPECIFICATION_MAJOR_REVISION<<16) | (EFI_SPECIFICATION_MINOR_REVISION) |
| typedef struct { |
| EFI_TABLE_HEADER Hdr; |
| // |
| // Time services |
| // |
| EFI_GET_TIME GetTime; |
| EFI_SET_TIME SetTime; |
| EFI_GET_WAKEUP_TIME GetWakeupTime; |
| EFI_SET_WAKEUP_TIME SetWakeupTime; |
| // |
| // Virtual memory services |
| // |
| EFI_SET_VIRTUAL_ADDRESS_MAP SetVirtualAddressMap; |
| EFI_CONVERT_POINTER ConvertPointer; |
| // |
| // Variable serviers |
| // |
| EFI_GET_VARIABLE GetVariable; |
| EFI_GET_NEXT_VARIABLE_NAME GetNextVariableName; |
| EFI_SET_VARIABLE SetVariable; |
| // |
| // Misc |
| // |
| EFI_GET_NEXT_HIGH_MONO_COUNT GetNextHighMonotonicCount; |
| EFI_RESET_SYSTEM ResetSystem; |
| } EFI_RUNTIME_SERVICES; |
| // |
| // EFI Boot Services Table |
| // |
| #define EFI_BOOT_SERVICES_SIGNATURE 0x56524553544f4f42 |
| #define EFI_BOOT_SERVICES_REVISION (EFI_SPECIFICATION_MAJOR_REVISION<<16) | (EFI_SPECIFICATION_MINOR_REVISION) |
| typedef struct _EFI_BOOT_SERVICES { |
| EFI_TABLE_HEADER Hdr; |
| // |
| // Task priority functions |
| // |
| EFI_RAISE_TPL RaiseTPL; |
| EFI_RESTORE_TPL RestoreTPL; |
| // |
| // Memory functions |
| // |
| EFI_ALLOCATE_PAGES AllocatePages; |
| EFI_FREE_PAGES FreePages; |
| EFI_GET_MEMORY_MAP GetMemoryMap; |
| EFI_ALLOCATE_POOL AllocatePool; |
| EFI_FREE_POOL FreePool; |
| // |
| // Event & timer functions |
| // |
| EFI_CREATE_EVENT CreateEvent; |
| EFI_SET_TIMER SetTimer; |
| EFI_WAIT_FOR_EVENT WaitForEvent; |
| EFI_SIGNAL_EVENT SignalEvent; |
| EFI_CLOSE_EVENT CloseEvent; |
| EFI_CHECK_EVENT CheckEvent; |
| // |
| // Protocol handler functions |
| // |
| EFI_INSTALL_PROTOCOL_INTERFACE InstallProtocolInterface; |
| EFI_REINSTALL_PROTOCOL_INTERFACE ReinstallProtocolInterface; |
| EFI_UNINSTALL_PROTOCOL_INTERFACE UninstallProtocolInterface; |
| EFI_HANDLE_PROTOCOL HandleProtocol; |
| EFI_HANDLE_PROTOCOL PCHandleProtocol; |
| EFI_REGISTER_PROTOCOL_NOTIFY RegisterProtocolNotify; |
| EFI_LOCATE_HANDLE LocateHandle; |
| EFI_LOCATE_DEVICE_PATH LocateDevicePath; |
| EFI_INSTALL_CONFIGURATION_TABLE InstallConfigurationTable; |
| // |
| // Image functions |
| // |
| EFI_IMAGE_LOAD LoadImage; |
| EFI_IMAGE_START StartImage; |
| EFI_EXIT Exit; |
| EFI_IMAGE_UNLOAD UnloadImage; |
| EFI_EXIT_BOOT_SERVICES ExitBootServices; |
| // |
| // Misc functions |
| // |
| EFI_GET_NEXT_MONOTONIC_COUNT GetNextMonotonicCount; |
| EFI_STALL Stall; |
| EFI_SET_WATCHDOG_TIMER SetWatchdogTimer; |
| } EFI_BOOT_SERVICES; |
| // |
| // EFI Configuration Table and GUID definitions |
| // |
| #define MPS_TABLE_GUID \ |
| { 0xeb9d2d2f, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d} } |
| #define ACPI_TABLE_GUID \ |
| { 0xeb9d2d30, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d} } |
| #define ACPI_20_TABLE_GUID \ |
| { 0x8868e871, 0xe4f1, 0x11d3, {0xbc, 0x22, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81} } |
| #define SMBIOS_TABLE_GUID \ |
| { 0xeb9d2d31, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d} } |
| #define SAL_SYSTEM_TABLE_GUID \ |
| { 0xeb9d2d32, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d} } |
| typedef struct _EFI_CONFIGURATION_TABLE { |
| EFI_GUID VendorGuid; |
| VOID *VendorTable; |
| } EFI_CONFIGURATION_TABLE; |
| // |
| // EFI System Table |
| // |
| #define EFI_SYSTEM_TABLE_SIGNATURE 0x5453595320494249 |
| #define EFI_SYSTEM_TABLE_REVISION (EFI_SPECIFICATION_MAJOR_REVISION<<16) | (EFI_SPECIFICATION_MINOR_REVISION) |
| typedef struct _EFI_SYSTEM_TABLE { |
| EFI_TABLE_HEADER Hdr; |
| CHAR16 *FirmwareVendor; |
| UINT32 FirmwareRevision; |
| EFI_HANDLE ConsoleInHandle; |
| SIMPLE_INPUT_INTERFACE *ConIn; |
| EFI_HANDLE ConsoleOutHandle; |
| SIMPLE_TEXT_OUTPUT_INTERFACE *ConOut; |
| EFI_HANDLE StandardErrorHandle; |
| SIMPLE_TEXT_OUTPUT_INTERFACE *StdErr; |
| EFI_RUNTIME_SERVICES *RuntimeServices; |
| EFI_BOOT_SERVICES *BootServices; |
| UINTN NumberOfTableEntries; |
| EFI_CONFIGURATION_TABLE *ConfigurationTable; |
| } EFI_SYSTEM_TABLE; |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/romload.h |
|---|
| 0,0 → 1,41 |
| #ifndef _EFI_ROMLOAD_H |
| #define _EFI_ROMLOAD_H |
| #define ROM_SIGNATURE 0xaa55 |
| #define PCIDS_SIGNATURE "PCIR" |
| #pragma pack(push) |
| #pragma pack(1) |
| typedef struct |
| { |
| UINT8 Pcids_Sig[4]; |
| UINT16 VendId; |
| UINT16 DevId; |
| UINT16 Vpd_Off; |
| UINT16 Size; |
| UINT8 Rev; |
| UINT8 Class_Code[3]; |
| UINT16 Image_Len; |
| UINT16 Rev_Lvl; |
| UINT8 Code_Type; |
| UINT8 Indi; |
| UINT16 Rsvd; |
| }PciDataStructure; |
| typedef struct |
| { |
| UINT16 Size; |
| UINT32 Header_Sig; |
| UINT16 SubSystem; |
| UINT16 MachineType; |
| UINT8 Resvd[10]; |
| UINT16 EfiOffset; |
| }ArchData; |
| typedef struct |
| { |
| UINT16 Rom_Sig; |
| ArchData Arch_Data; |
| UINT16 Pcids_Off; |
| UINT8 resvd[38]; |
| }RomHeader; |
| #pragma pack(pop) |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/efirtlib.h |
|---|
| 0,0 → 1,141 |
| #ifndef _EFI_RT_LIB_INCLUDE_ |
| #define _EFI_RT_LIB_INCLUDE_ |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| efilib.h |
| Abstract: |
| EFI Runtime library functions |
| Revision History |
| --*/ |
| #include "efidebug.h" |
| #include "efipart.h" |
| #include "efilibplat.h" |
| VOID |
| RUNTIMEFUNCTION |
| RtZeroMem ( |
| IN VOID *Buffer, |
| IN UINTN Size |
| ); |
| VOID |
| RUNTIMEFUNCTION |
| RtSetMem ( |
| IN VOID *Buffer, |
| IN UINTN Size, |
| IN UINT8 Value |
| ); |
| VOID |
| RUNTIMEFUNCTION |
| RtCopyMem ( |
| IN VOID *Dest, |
| IN VOID *Src, |
| IN UINTN len |
| ); |
| INTN |
| RUNTIMEFUNCTION |
| RtCompareMem ( |
| IN VOID *Dest, |
| IN VOID *Src, |
| IN UINTN len |
| ); |
| INTN |
| RUNTIMEFUNCTION |
| RtStrCmp ( |
| IN CHAR16 *s1, |
| IN CHAR16 *s2 |
| ); |
| VOID |
| RUNTIMEFUNCTION |
| RtStrCpy ( |
| IN CHAR16 *Dest, |
| IN CHAR16 *Src |
| ); |
| VOID |
| RUNTIMEFUNCTION |
| RtStrCat ( |
| IN CHAR16 *Dest, |
| IN CHAR16 *Src |
| ); |
| UINTN |
| RUNTIMEFUNCTION |
| RtStrLen ( |
| IN CHAR16 *s1 |
| ); |
| UINTN |
| RUNTIMEFUNCTION |
| RtStrSize ( |
| IN CHAR16 *s1 |
| ); |
| INTN |
| RUNTIMEFUNCTION |
| RtCompareGuid ( |
| IN EFI_GUID *Guid1, |
| IN EFI_GUID *Guid2 |
| ); |
| UINT8 |
| RUNTIMEFUNCTION |
| RtDecimaltoBCD( |
| IN UINT8 BcdValue |
| ); |
| UINT8 |
| RUNTIMEFUNCTION |
| RtBCDtoDecimal( |
| IN UINT8 BcdValue |
| ); |
| // |
| // Virtual mapping transition support. (Only used during |
| // the virtual address change transisition) |
| // |
| VOID |
| RUNTIMEFUNCTION |
| RtLibEnableVirtualMappings ( |
| VOID |
| ); |
| VOID |
| RUNTIMEFUNCTION |
| RtConvertList ( |
| IN UINTN DebugDisposition, |
| IN OUT LIST_ENTRY *ListHead |
| ); |
| VOID |
| RUNTIMEFUNCTION |
| RtAcquireLock ( |
| IN FLOCK *Lock |
| ); |
| VOID |
| RUNTIMEFUNCTION |
| RtReleaseLock ( |
| IN FLOCK *Lock |
| ); |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/efiui.h |
|---|
| 0,0 → 1,54 |
| #ifndef _EFI_UI_H |
| #define _EFI_UI_H |
| /*++ |
| Copyright (c) 200 Intel Corporation |
| Module Name: |
| EfiUi.h |
| Abstract: |
| Protocol used to build User Interface (UI) stuff. |
| This protocol is just data. It is a multi dimentional array. |
| For each string there is an array of UI_STRING_ENTRY. Each string |
| is for a different language translation of the same string. The list |
| is terminated by a NULL UiString. There can be any number of |
| UI_STRING_ENTRY arrays. A NULL array terminates the list. A NULL array |
| entry contains all zeros. |
| Thus the shortest possible EFI_UI_PROTOCOL has three UI_STRING_ENTRY. |
| The String, it's NULL terminator, and the NULL terminator for the entire |
| thing. |
| Revision History |
| --*/ |
| #define EFI_UI_PROTOCOL \ |
| { 0x32dd7981, 0x2d27, 0x11d4, {0xbc, 0x8b, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81} } |
| typedef enum { |
| UiDeviceString, |
| UiVendorString, |
| UiMaxString |
| } UI_STRING_TYPE; |
| typedef struct { |
| ISO_639_2 *LangCode; |
| CHAR16 *UiString; |
| } UI_STRING_ENTRY; |
| #define EFI_UI_VERSION 0x00010000 |
| typedef struct _UI_INTERFACE { |
| UINT32 Version; |
| UI_STRING_ENTRY *Entry; |
| } UI_INTERFACE; |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/efi_nii.h |
|---|
| 0,0 → 1,74 |
| #ifndef _EFI_NII_H |
| #define _EFI_NII_H |
| /*++ |
| Copyright (c) 2000 Intel Corporation |
| Module name: |
| efi_nii.h |
| Abstract: |
| Revision history: |
| 2000-Feb-18 M(f)J GUID updated. |
| Structure order changed for machine word alignment. |
| Added StringId[4] to structure. |
| 2000-Feb-14 M(f)J Genesis. |
| --*/ |
| #define EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL \ |
| { 0xE18541CD, 0xF755, 0x4f73, {0x92, 0x8D, 0x64, 0x3C, 0x8A, 0x79, 0xB2, 0x29} } |
| #define EFI_NETWORK_INTERFACE_IDENTIFIER_INTERFACE_REVISION 0x00010000 |
| typedef enum { |
| EfiNetworkInterfaceUndi = 1 |
| } EFI_NETWORK_INTERFACE_TYPE; |
| typedef struct { |
| UINT64 Revision; |
| // Revision of the network interface identifier protocol interface. |
| UINT64 ID; |
| // Address of the first byte of the identifying structure for this |
| // network interface. This is set to zero if there is no structure. |
| // |
| // For PXE/UNDI this is the first byte of the !PXE structure. |
| UINT64 ImageAddr; |
| // Address of the UNrelocated driver/ROM image. This is set |
| // to zero if there is no driver/ROM image. |
| // |
| // For 16-bit UNDI, this is the first byte of the option ROM in |
| // upper memory. |
| // |
| // For 32/64-bit S/W UNDI, this is the first byte of the EFI ROM |
| // image. |
| // |
| // For H/W UNDI, this is set to zero. |
| UINT32 ImageSize; |
| // Size of the UNrelocated driver/ROM image of this network interface. |
| // This is set to zero if there is no driver/ROM image. |
| CHAR8 StringId[4]; |
| // 4 char ASCII string to go in class identifier (option 60) in DHCP |
| // and Boot Server discover packets. |
| // For EfiNetworkInterfaceUndi this field is "UNDI". |
| // For EfiNetworkInterfaceSnp this field is "SNPN". |
| UINT8 Type; |
| UINT8 MajorVer; |
| UINT8 MinorVer; |
| // Information to be placed into the PXE DHCP and Discover packets. |
| // This is the network interface type and version number that will |
| // be placed into DHCP option 94 (client network interface identifier). |
| BOOLEAN Ipv6Supported; |
| UINT8 IfNum; // interface number to be used with pxeid structure |
| } EFI_NETWORK_INTERFACE_IDENTIFIER_INTERFACE; |
| extern EFI_GUID NetworkInterfaceIdentifierProtocol; |
| #endif // _EFI_NII_H |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/make.inf |
|---|
| 0,0 → 1,29 |
| # |
| # |
| # |
| [sources] |
| efi.h |
| efiapi.h |
| eficon.h |
| efidebug.h |
| efidef.h |
| efidevp.h |
| efierr.h |
| efifs.h |
| efilib.h |
| efipart.h |
| efiprot.h |
| efipxebc.h |
| efistdarg.h |
| efinet.h |
| [ia32sources] |
| efibind.h |
| pe.h |
| efilibplat.h |
| [ia64sources] |
| efibind.h |
| pe.h |
| efilibplat.h |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/eficon.h |
|---|
| 0,0 → 1,302 |
| #ifndef _EFI_CON_H |
| #define _EFI_CON_H |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| eficon.h |
| Abstract: |
| EFI console protocols |
| Revision History |
| --*/ |
| // |
| // Text output protocol |
| // |
| #define SIMPLE_TEXT_OUTPUT_PROTOCOL \ |
| { 0x387477c2, 0x69c7, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } |
| INTERFACE_DECL(_SIMPLE_TEXT_OUTPUT_INTERFACE); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_TEXT_RESET) ( |
| IN struct _SIMPLE_TEXT_OUTPUT_INTERFACE *This, |
| IN BOOLEAN ExtendedVerification |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_TEXT_OUTPUT_STRING) ( |
| IN struct _SIMPLE_TEXT_OUTPUT_INTERFACE *This, |
| IN CHAR16 *String |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_TEXT_TEST_STRING) ( |
| IN struct _SIMPLE_TEXT_OUTPUT_INTERFACE *This, |
| IN CHAR16 *String |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_TEXT_QUERY_MODE) ( |
| IN struct _SIMPLE_TEXT_OUTPUT_INTERFACE *This, |
| IN UINTN ModeNumber, |
| OUT UINTN *Columns, |
| OUT UINTN *Rows |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_TEXT_SET_MODE) ( |
| IN struct _SIMPLE_TEXT_OUTPUT_INTERFACE *This, |
| IN UINTN ModeNumber |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_TEXT_SET_ATTRIBUTE) ( |
| IN struct _SIMPLE_TEXT_OUTPUT_INTERFACE *This, |
| IN UINTN Attribute |
| ); |
| #define EFI_BLACK 0x00 |
| #define EFI_BLUE 0x01 |
| #define EFI_GREEN 0x02 |
| #define EFI_CYAN (EFI_BLUE | EFI_GREEN) |
| #define EFI_RED 0x04 |
| #define EFI_MAGENTA (EFI_BLUE | EFI_RED) |
| #define EFI_BROWN (EFI_GREEN | EFI_RED) |
| #define EFI_LIGHTGRAY (EFI_BLUE | EFI_GREEN | EFI_RED) |
| #define EFI_BRIGHT 0x08 |
| #define EFI_DARKGRAY (EFI_BRIGHT) |
| #define EFI_LIGHTBLUE (EFI_BLUE | EFI_BRIGHT) |
| #define EFI_LIGHTGREEN (EFI_GREEN | EFI_BRIGHT) |
| #define EFI_LIGHTCYAN (EFI_CYAN | EFI_BRIGHT) |
| #define EFI_LIGHTRED (EFI_RED | EFI_BRIGHT) |
| #define EFI_LIGHTMAGENTA (EFI_MAGENTA | EFI_BRIGHT) |
| #define EFI_YELLOW (EFI_BROWN | EFI_BRIGHT) |
| #define EFI_WHITE (EFI_BLUE | EFI_GREEN | EFI_RED | EFI_BRIGHT) |
| #define EFI_TEXT_ATTR(f,b) ((f) | ((b) << 4)) |
| #define EFI_BACKGROUND_BLACK 0x00 |
| #define EFI_BACKGROUND_BLUE 0x10 |
| #define EFI_BACKGROUND_GREEN 0x20 |
| #define EFI_BACKGROUND_CYAN (EFI_BACKGROUND_BLUE | EFI_BACKGROUND_GREEN) |
| #define EFI_BACKGROUND_RED 0x40 |
| #define EFI_BACKGROUND_MAGENTA (EFI_BACKGROUND_BLUE | EFI_BACKGROUND_RED) |
| #define EFI_BACKGROUND_BROWN (EFI_BACKGROUND_GREEN | EFI_BACKGROUND_RED) |
| #define EFI_BACKGROUND_LIGHTGRAY (EFI_BACKGROUND_BLUE | EFI_BACKGROUND_GREEN | EFI_BACKGROUND_RED) |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_TEXT_CLEAR_SCREEN) ( |
| IN struct _SIMPLE_TEXT_OUTPUT_INTERFACE *This |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_TEXT_SET_CURSOR_POSITION) ( |
| IN struct _SIMPLE_TEXT_OUTPUT_INTERFACE *This, |
| IN UINTN Column, |
| IN UINTN Row |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_TEXT_ENABLE_CURSOR) ( |
| IN struct _SIMPLE_TEXT_OUTPUT_INTERFACE *This, |
| IN BOOLEAN Enable |
| ); |
| typedef struct { |
| INT32 MaxMode; |
| // current settings |
| INT32 Mode; |
| INT32 Attribute; |
| INT32 CursorColumn; |
| INT32 CursorRow; |
| BOOLEAN CursorVisible; |
| } SIMPLE_TEXT_OUTPUT_MODE; |
| typedef struct _SIMPLE_TEXT_OUTPUT_INTERFACE { |
| EFI_TEXT_RESET Reset; |
| EFI_TEXT_OUTPUT_STRING OutputString; |
| EFI_TEXT_TEST_STRING TestString; |
| EFI_TEXT_QUERY_MODE QueryMode; |
| EFI_TEXT_SET_MODE SetMode; |
| EFI_TEXT_SET_ATTRIBUTE SetAttribute; |
| EFI_TEXT_CLEAR_SCREEN ClearScreen; |
| EFI_TEXT_SET_CURSOR_POSITION SetCursorPosition; |
| EFI_TEXT_ENABLE_CURSOR EnableCursor; |
| // Current mode |
| SIMPLE_TEXT_OUTPUT_MODE *Mode; |
| } SIMPLE_TEXT_OUTPUT_INTERFACE; |
| // |
| // Define's for required EFI Unicode Box Draw character |
| // |
| #define BOXDRAW_HORIZONTAL 0x2500 |
| #define BOXDRAW_VERTICAL 0x2502 |
| #define BOXDRAW_DOWN_RIGHT 0x250c |
| #define BOXDRAW_DOWN_LEFT 0x2510 |
| #define BOXDRAW_UP_RIGHT 0x2514 |
| #define BOXDRAW_UP_LEFT 0x2518 |
| #define BOXDRAW_VERTICAL_RIGHT 0x251c |
| #define BOXDRAW_VERTICAL_LEFT 0x2524 |
| #define BOXDRAW_DOWN_HORIZONTAL 0x252c |
| #define BOXDRAW_UP_HORIZONTAL 0x2534 |
| #define BOXDRAW_VERTICAL_HORIZONTAL 0x253c |
| #define BOXDRAW_DOUBLE_HORIZONTAL 0x2550 |
| #define BOXDRAW_DOUBLE_VERTICAL 0x2551 |
| #define BOXDRAW_DOWN_RIGHT_DOUBLE 0x2552 |
| #define BOXDRAW_DOWN_DOUBLE_RIGHT 0x2553 |
| #define BOXDRAW_DOUBLE_DOWN_RIGHT 0x2554 |
| #define BOXDRAW_DOWN_LEFT_DOUBLE 0x2555 |
| #define BOXDRAW_DOWN_DOUBLE_LEFT 0x2556 |
| #define BOXDRAW_DOUBLE_DOWN_LEFT 0x2557 |
| #define BOXDRAW_UP_RIGHT_DOUBLE 0x2558 |
| #define BOXDRAW_UP_DOUBLE_RIGHT 0x2559 |
| #define BOXDRAW_DOUBLE_UP_RIGHT 0x255a |
| #define BOXDRAW_UP_LEFT_DOUBLE 0x255b |
| #define BOXDRAW_UP_DOUBLE_LEFT 0x255c |
| #define BOXDRAW_DOUBLE_UP_LEFT 0x255d |
| #define BOXDRAW_VERTICAL_RIGHT_DOUBLE 0x255e |
| #define BOXDRAW_VERTICAL_DOUBLE_RIGHT 0x255f |
| #define BOXDRAW_DOUBLE_VERTICAL_RIGHT 0x2560 |
| #define BOXDRAW_VERTICAL_LEFT_DOUBLE 0x2561 |
| #define BOXDRAW_VERTICAL_DOUBLE_LEFT 0x2562 |
| #define BOXDRAW_DOUBLE_VERTICAL_LEFT 0x2563 |
| #define BOXDRAW_DOWN_HORIZONTAL_DOUBLE 0x2564 |
| #define BOXDRAW_DOWN_DOUBLE_HORIZONTAL 0x2565 |
| #define BOXDRAW_DOUBLE_DOWN_HORIZONTAL 0x2566 |
| #define BOXDRAW_UP_HORIZONTAL_DOUBLE 0x2567 |
| #define BOXDRAW_UP_DOUBLE_HORIZONTAL 0x2568 |
| #define BOXDRAW_DOUBLE_UP_HORIZONTAL 0x2569 |
| #define BOXDRAW_VERTICAL_HORIZONTAL_DOUBLE 0x256a |
| #define BOXDRAW_VERTICAL_DOUBLE_HORIZONTAL 0x256b |
| #define BOXDRAW_DOUBLE_VERTICAL_HORIZONTAL 0x256c |
| // |
| // EFI Required Block Elements Code Chart |
| // |
| #define BLOCKELEMENT_FULL_BLOCK 0x2588 |
| #define BLOCKELEMENT_LIGHT_SHADE 0x2591 |
| // |
| // EFI Required Geometric Shapes Code Chart |
| // |
| #define GEOMETRICSHAPE_UP_TRIANGLE 0x25b2 |
| #define GEOMETRICSHAPE_RIGHT_TRIANGLE 0x25ba |
| #define GEOMETRICSHAPE_DOWN_TRIANGLE 0x25bc |
| #define GEOMETRICSHAPE_LEFT_TRIANGLE 0x25c4 |
| // |
| // EFI Required Arrow shapes |
| // |
| #define ARROW_UP 0x2191 |
| #define ARROW_DOWN 0x2193 |
| // |
| // Text input protocol |
| // |
| #define SIMPLE_TEXT_INPUT_PROTOCOL \ |
| { 0x387477c1, 0x69c7, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } |
| INTERFACE_DECL(_SIMPLE_INPUT_INTERFACE); |
| typedef struct { |
| UINT16 ScanCode; |
| CHAR16 UnicodeChar; |
| } EFI_INPUT_KEY; |
| // |
| // Baseline unicode control chars |
| // |
| #define CHAR_NULL 0x0000 |
| #define CHAR_BACKSPACE 0x0008 |
| #define CHAR_TAB 0x0009 |
| #define CHAR_LINEFEED 0x000A |
| #define CHAR_CARRIAGE_RETURN 0x000D |
| // |
| // Scan codes for base line keys |
| // |
| #define SCAN_NULL 0x0000 |
| #define SCAN_UP 0x0001 |
| #define SCAN_DOWN 0x0002 |
| #define SCAN_RIGHT 0x0003 |
| #define SCAN_LEFT 0x0004 |
| #define SCAN_HOME 0x0005 |
| #define SCAN_END 0x0006 |
| #define SCAN_INSERT 0x0007 |
| #define SCAN_DELETE 0x0008 |
| #define SCAN_PAGE_UP 0x0009 |
| #define SCAN_PAGE_DOWN 0x000A |
| #define SCAN_F1 0x000B |
| #define SCAN_F2 0x000C |
| #define SCAN_F3 0x000D |
| #define SCAN_F4 0x000E |
| #define SCAN_F5 0x000F |
| #define SCAN_F6 0x0010 |
| #define SCAN_F7 0x0011 |
| #define SCAN_F8 0x0012 |
| #define SCAN_F9 0x0013 |
| #define SCAN_F10 0x0014 |
| #define SCAN_ESC 0x0017 |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_INPUT_RESET) ( |
| IN struct _SIMPLE_INPUT_INTERFACE *This, |
| IN BOOLEAN ExtendedVerification |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_INPUT_READ_KEY) ( |
| IN struct _SIMPLE_INPUT_INTERFACE *This, |
| OUT EFI_INPUT_KEY *Key |
| ); |
| typedef struct _SIMPLE_INPUT_INTERFACE { |
| EFI_INPUT_RESET Reset; |
| EFI_INPUT_READ_KEY ReadKeyStroke; |
| EFI_EVENT WaitForKey; |
| } SIMPLE_INPUT_INTERFACE; |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/efi.h |
|---|
| 0,0 → 1,49 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| efi.h |
| Abstract: |
| Public EFI header files |
| Revision History |
| --*/ |
| // |
| // Build flags on input |
| // EFI32 |
| // EFI_DEBUG - Enable debugging code |
| // EFI_NT_EMULATOR - Building for running under NT |
| // |
| #ifndef _EFI_INCLUDE_ |
| #define _EFI_INCLUDE_ |
| #define EFI_FIRMWARE_VENDOR L"INTEL" |
| #define EFI_FIRMWARE_MAJOR_REVISION 12 |
| #define EFI_FIRMWARE_MINOR_REVISION 33 |
| #define EFI_FIRMWARE_REVISION ((EFI_FIRMWARE_MAJOR_REVISION <<16) | (EFI_FIRMWARE_MINOR_REVISION)) |
| #include "efibind.h" |
| #include "efidef.h" |
| #include "efidevp.h" |
| #include "efiprot.h" |
| #include "eficon.h" |
| #include "efiser.h" |
| #include "efi_nii.h" |
| #include "efipxebc.h" |
| #include "efinet.h" |
| #include "efiapi.h" |
| #include "efifs.h" |
| #include "efierr.h" |
| #include "efiui.h" |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/makefile.hdr |
|---|
| 0,0 → 1,44 |
| # |
| # This is a machine generated file - DO NOT EDIT |
| # Generated by genmake.exe |
| # Generated from make.inf |
| # Copyright (c) 1998 Intel Corporation |
| # |
| INC_DEPS = $(INC_DEPS) \ |
| $(SDK_INSTALL_DIR)\include\efi\efi.h \ |
| $(SDK_INSTALL_DIR)\include\efi\efiapi.h \ |
| $(SDK_INSTALL_DIR)\include\efi\eficon.h \ |
| $(SDK_INSTALL_DIR)\include\efi\efidebug.h \ |
| $(SDK_INSTALL_DIR)\include\efi\efidef.h \ |
| $(SDK_INSTALL_DIR)\include\efi\efidevp.h \ |
| $(SDK_INSTALL_DIR)\include\efi\efierr.h \ |
| $(SDK_INSTALL_DIR)\include\efi\efifs.h \ |
| $(SDK_INSTALL_DIR)\include\efi\efilib.h \ |
| $(SDK_INSTALL_DIR)\include\efi\efipart.h \ |
| $(SDK_INSTALL_DIR)\include\efi\efiprot.h \ |
| $(SDK_INSTALL_DIR)\include\efi\efipxebc.h \ |
| $(SDK_INSTALL_DIR)\include\efi\efistdarg.h \ |
| $(SDK_INSTALL_DIR)\include\efi\efinet.h \ |
| !IF "$(PROCESSOR)" == "Ia32" |
| INC_DEPS = $(INC_DEPS) \ |
| $(SDK_INSTALL_DIR)\include\efi\Ia32\efibind.h \ |
| $(SDK_INSTALL_DIR)\include\efi\Ia32\pe.h \ |
| $(SDK_INSTALL_DIR)\include\efi\Ia32\efilibplat.h \ |
| !ENDIF |
| !IF "$(PROCESSOR)" == "Ia64" |
| INC_DEPS = $(INC_DEPS) \ |
| $(SDK_INSTALL_DIR)\include\efi\Ia64\efibind.h \ |
| $(SDK_INSTALL_DIR)\include\efi\Ia64\pe.h \ |
| $(SDK_INSTALL_DIR)\include\efi\Ia64\efilibplat.h \ |
| !ENDIF |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/efiprot.h |
|---|
| 0,0 → 1,558 |
| #ifndef _EFI_PROT_H |
| #define _EFI_PROT_H |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| efiprot.h |
| Abstract: |
| EFI Protocols |
| Revision History |
| --*/ |
| // |
| // FPSWA library protocol |
| // |
| #define FPSWA_PROTOCOL \ |
| { 0xc41b6531, 0x97b9, 0x11d3, {0x9a, 0x29, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d} } |
| // |
| // Device Path protocol |
| // |
| #define DEVICE_PATH_PROTOCOL \ |
| { 0x9576e91, 0x6d3f, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } |
| // |
| // Block IO protocol |
| // |
| #define BLOCK_IO_PROTOCOL \ |
| { 0x964e5b21, 0x6459, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } |
| #define EFI_BLOCK_IO_INTERFACE_REVISION 0x00010000 |
| INTERFACE_DECL(_EFI_BLOCK_IO); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_BLOCK_RESET) ( |
| IN struct _EFI_BLOCK_IO *This, |
| IN BOOLEAN ExtendedVerification |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_BLOCK_READ) ( |
| IN struct _EFI_BLOCK_IO *This, |
| IN UINT32 MediaId, |
| IN EFI_LBA LBA, |
| IN UINTN BufferSize, |
| OUT VOID *Buffer |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_BLOCK_WRITE) ( |
| IN struct _EFI_BLOCK_IO *This, |
| IN UINT32 MediaId, |
| IN EFI_LBA LBA, |
| IN UINTN BufferSize, |
| IN VOID *Buffer |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_BLOCK_FLUSH) ( |
| IN struct _EFI_BLOCK_IO *This |
| ); |
| typedef struct { |
| UINT32 MediaId; |
| BOOLEAN RemovableMedia; |
| BOOLEAN MediaPresent; |
| BOOLEAN LogicalPartition; |
| BOOLEAN ReadOnly; |
| BOOLEAN WriteCaching; |
| UINT32 BlockSize; |
| UINT32 IoAlign; |
| EFI_LBA LastBlock; |
| } EFI_BLOCK_IO_MEDIA; |
| typedef struct _EFI_BLOCK_IO { |
| UINT64 Revision; |
| EFI_BLOCK_IO_MEDIA *Media; |
| EFI_BLOCK_RESET Reset; |
| EFI_BLOCK_READ ReadBlocks; |
| EFI_BLOCK_WRITE WriteBlocks; |
| EFI_BLOCK_FLUSH FlushBlocks; |
| } EFI_BLOCK_IO; |
| // |
| // Disk Block IO protocol |
| // |
| #define DISK_IO_PROTOCOL \ |
| { 0xce345171, 0xba0b, 0x11d2, {0x8e, 0x4f, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } |
| #define EFI_DISK_IO_INTERFACE_REVISION 0x00010000 |
| INTERFACE_DECL(_EFI_DISK_IO); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_DISK_READ) ( |
| IN struct _EFI_DISK_IO *This, |
| IN UINT32 MediaId, |
| IN UINT64 Offset, |
| IN UINTN BufferSize, |
| OUT VOID *Buffer |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_DISK_WRITE) ( |
| IN struct _EFI_DISK_IO *This, |
| IN UINT32 MediaId, |
| IN UINT64 Offset, |
| IN UINTN BufferSize, |
| IN VOID *Buffer |
| ); |
| typedef struct _EFI_DISK_IO { |
| UINT64 Revision; |
| EFI_DISK_READ ReadDisk; |
| EFI_DISK_WRITE WriteDisk; |
| } EFI_DISK_IO; |
| // |
| // Simple file system protocol |
| // |
| #define SIMPLE_FILE_SYSTEM_PROTOCOL \ |
| { 0x964e5b22, 0x6459, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } |
| INTERFACE_DECL(_EFI_FILE_IO_INTERFACE); |
| INTERFACE_DECL(_EFI_FILE_HANDLE); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_VOLUME_OPEN) ( |
| IN struct _EFI_FILE_IO_INTERFACE *This, |
| OUT struct _EFI_FILE_HANDLE **Root |
| ); |
| #define EFI_FILE_IO_INTERFACE_REVISION 0x00010000 |
| typedef struct _EFI_FILE_IO_INTERFACE { |
| UINT64 Revision; |
| EFI_VOLUME_OPEN OpenVolume; |
| } EFI_FILE_IO_INTERFACE; |
| // |
| // |
| // |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_FILE_OPEN) ( |
| IN struct _EFI_FILE_HANDLE *File, |
| OUT struct _EFI_FILE_HANDLE **NewHandle, |
| IN CHAR16 *FileName, |
| IN UINT64 OpenMode, |
| IN UINT64 Attributes |
| ); |
| // Open modes |
| #define EFI_FILE_MODE_READ 0x0000000000000001 |
| #define EFI_FILE_MODE_WRITE 0x0000000000000002 |
| #define EFI_FILE_MODE_CREATE 0x8000000000000000 |
| // File attributes |
| #define EFI_FILE_READ_ONLY 0x0000000000000001 |
| #define EFI_FILE_HIDDEN 0x0000000000000002 |
| #define EFI_FILE_SYSTEM 0x0000000000000004 |
| #define EFI_FILE_RESERVIED 0x0000000000000008 |
| #define EFI_FILE_DIRECTORY 0x0000000000000010 |
| #define EFI_FILE_ARCHIVE 0x0000000000000020 |
| #define EFI_FILE_VALID_ATTR 0x0000000000000037 |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_FILE_CLOSE) ( |
| IN struct _EFI_FILE_HANDLE *File |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_FILE_DELETE) ( |
| IN struct _EFI_FILE_HANDLE *File |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_FILE_READ) ( |
| IN struct _EFI_FILE_HANDLE *File, |
| IN OUT UINTN *BufferSize, |
| OUT VOID *Buffer |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_FILE_WRITE) ( |
| IN struct _EFI_FILE_HANDLE *File, |
| IN OUT UINTN *BufferSize, |
| IN VOID *Buffer |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_FILE_SET_POSITION) ( |
| IN struct _EFI_FILE_HANDLE *File, |
| IN UINT64 Position |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_FILE_GET_POSITION) ( |
| IN struct _EFI_FILE_HANDLE *File, |
| OUT UINT64 *Position |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_FILE_GET_INFO) ( |
| IN struct _EFI_FILE_HANDLE *File, |
| IN EFI_GUID *InformationType, |
| IN OUT UINTN *BufferSize, |
| OUT VOID *Buffer |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_FILE_SET_INFO) ( |
| IN struct _EFI_FILE_HANDLE *File, |
| IN EFI_GUID *InformationType, |
| IN UINTN BufferSize, |
| IN VOID *Buffer |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_FILE_FLUSH) ( |
| IN struct _EFI_FILE_HANDLE *File |
| ); |
| #define EFI_FILE_HANDLE_REVISION 0x00010000 |
| typedef struct _EFI_FILE_HANDLE { |
| UINT64 Revision; |
| EFI_FILE_OPEN Open; |
| EFI_FILE_CLOSE Close; |
| EFI_FILE_DELETE Delete; |
| EFI_FILE_READ Read; |
| EFI_FILE_WRITE Write; |
| EFI_FILE_GET_POSITION GetPosition; |
| EFI_FILE_SET_POSITION SetPosition; |
| EFI_FILE_GET_INFO GetInfo; |
| EFI_FILE_SET_INFO SetInfo; |
| EFI_FILE_FLUSH Flush; |
| } EFI_FILE, *EFI_FILE_HANDLE; |
| // |
| // File information types |
| // |
| #define EFI_FILE_INFO_ID \ |
| { 0x9576e92, 0x6d3f, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } |
| typedef struct { |
| UINT64 Size; |
| UINT64 FileSize; |
| UINT64 PhysicalSize; |
| EFI_TIME CreateTime; |
| EFI_TIME LastAccessTime; |
| EFI_TIME ModificationTime; |
| UINT64 Attribute; |
| CHAR16 FileName[1]; |
| } EFI_FILE_INFO; |
| // |
| // The FileName field of the EFI_FILE_INFO data structure is variable length. |
| // Whenever code needs to know the size of the EFI_FILE_INFO data structure, it needs to |
| // be the size of the data structure without the FileName field. The following macro |
| // computes this size correctly no matter how big the FileName array is declared. |
| // This is required to make the EFI_FILE_INFO data structure ANSI compilant. |
| // |
| #define SIZE_OF_EFI_FILE_INFO EFI_FIELD_OFFSET(EFI_FILE_INFO,FileName) |
| #define EFI_FILE_SYSTEM_INFO_ID \ |
| { 0x9576e93, 0x6d3f, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } |
| typedef struct { |
| UINT64 Size; |
| BOOLEAN ReadOnly; |
| UINT64 VolumeSize; |
| UINT64 FreeSpace; |
| UINT32 BlockSize; |
| CHAR16 VolumeLabel[1]; |
| } EFI_FILE_SYSTEM_INFO; |
| // |
| // The VolumeLabel field of the EFI_FILE_SYSTEM_INFO data structure is variable length. |
| // Whenever code needs to know the size of the EFI_FILE_SYSTEM_INFO data structure, it needs |
| // to be the size of the data structure without the VolumeLable field. The following macro |
| // computes this size correctly no matter how big the VolumeLable array is declared. |
| // This is required to make the EFI_FILE_SYSTEM_INFO data structure ANSI compilant. |
| // |
| #define SIZE_OF_EFI_FILE_SYSTEM_INFO EFI_FIELD_OFFSET(EFI_FILE_SYSTEM_INFO,VolumeLabel) |
| #define EFI_FILE_SYSTEM_VOLUME_LABEL_INFO_ID \ |
| { 0xDB47D7D3,0xFE81, 0x11d3, {0x9A, 0x35, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D} } |
| typedef struct { |
| CHAR16 VolumeLabel[1]; |
| } EFI_FILE_SYSTEM_VOLUME_LABEL_INFO; |
| #define SIZE_OF_EFI_FILE_SYSTEM_VOLUME_LABEL_INFO EFI_FIELD_OFFSET(EFI_FILE_SYSTEM_VOLUME_LABEL_INFO,VolumeLabel) |
| // |
| // Load file protocol |
| // |
| #define LOAD_FILE_PROTOCOL \ |
| { 0x56EC3091, 0x954C, 0x11d2, {0x8E, 0x3F, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B} } |
| INTERFACE_DECL(_EFI_LOAD_FILE_INTERFACE); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_LOAD_FILE) ( |
| IN struct _EFI_LOAD_FILE_INTERFACE *This, |
| IN EFI_DEVICE_PATH *FilePath, |
| IN BOOLEAN BootPolicy, |
| IN OUT UINTN *BufferSize, |
| IN VOID *Buffer OPTIONAL |
| ); |
| typedef struct _EFI_LOAD_FILE_INTERFACE { |
| EFI_LOAD_FILE LoadFile; |
| } EFI_LOAD_FILE_INTERFACE; |
| // |
| // Device IO protocol |
| // |
| #define DEVICE_IO_PROTOCOL \ |
| { 0xaf6ac311, 0x84c3, 0x11d2, {0x8e, 0x3c, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } |
| INTERFACE_DECL(_EFI_DEVICE_IO_INTERFACE); |
| typedef enum { |
| IO_UINT8, |
| IO_UINT16, |
| IO_UINT32, |
| IO_UINT64, |
| // |
| // Specification Change: Copy from MMIO to MMIO vs. MMIO to buffer, buffer to MMIO |
| // |
| MMIO_COPY_UINT8, |
| MMIO_COPY_UINT16, |
| MMIO_COPY_UINT32, |
| MMIO_COPY_UINT64 |
| } EFI_IO_WIDTH; |
| #define EFI_PCI_ADDRESS(_bus,_dev,_func) \ |
| ( (UINT64) ( (((UINTN)_bus) << 24) + (((UINTN)_dev) << 16) + (((UINTN)_func) << 8) ) ) |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_DEVICE_IO) ( |
| IN struct _EFI_DEVICE_IO_INTERFACE *This, |
| IN EFI_IO_WIDTH Width, |
| IN UINT64 Address, |
| IN UINTN Count, |
| IN OUT VOID *Buffer |
| ); |
| typedef struct { |
| EFI_DEVICE_IO Read; |
| EFI_DEVICE_IO Write; |
| } EFI_IO_ACCESS; |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_PCI_DEVICE_PATH) ( |
| IN struct _EFI_DEVICE_IO_INTERFACE *This, |
| IN UINT64 Address, |
| IN OUT EFI_DEVICE_PATH **PciDevicePath |
| ); |
| typedef enum { |
| EfiBusMasterRead, |
| EfiBusMasterWrite, |
| EfiBusMasterCommonBuffer |
| } EFI_IO_OPERATION_TYPE; |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_IO_MAP) ( |
| IN struct _EFI_DEVICE_IO_INTERFACE *This, |
| IN EFI_IO_OPERATION_TYPE Operation, |
| IN EFI_PHYSICAL_ADDRESS *HostAddress, |
| IN OUT UINTN *NumberOfBytes, |
| OUT EFI_PHYSICAL_ADDRESS *DeviceAddress, |
| OUT VOID **Mapping |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_IO_UNMAP) ( |
| IN struct _EFI_DEVICE_IO_INTERFACE *This, |
| IN VOID *Mapping |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_IO_ALLOCATE_BUFFER) ( |
| IN struct _EFI_DEVICE_IO_INTERFACE *This, |
| IN EFI_ALLOCATE_TYPE Type, |
| IN EFI_MEMORY_TYPE MemoryType, |
| IN UINTN Pages, |
| IN OUT EFI_PHYSICAL_ADDRESS *HostAddress |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_IO_FLUSH) ( |
| IN struct _EFI_DEVICE_IO_INTERFACE *This |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_IO_FREE_BUFFER) ( |
| IN struct _EFI_DEVICE_IO_INTERFACE *This, |
| IN UINTN Pages, |
| IN EFI_PHYSICAL_ADDRESS HostAddress |
| ); |
| typedef struct _EFI_DEVICE_IO_INTERFACE { |
| EFI_IO_ACCESS Mem; |
| EFI_IO_ACCESS Io; |
| EFI_IO_ACCESS Pci; |
| EFI_IO_MAP Map; |
| EFI_PCI_DEVICE_PATH PciDevicePath; |
| EFI_IO_UNMAP Unmap; |
| EFI_IO_ALLOCATE_BUFFER AllocateBuffer; |
| EFI_IO_FLUSH Flush; |
| EFI_IO_FREE_BUFFER FreeBuffer; |
| } EFI_DEVICE_IO_INTERFACE; |
| // |
| // Unicode Collation protocol |
| // |
| #define UNICODE_COLLATION_PROTOCOL \ |
| { 0x1d85cd7f, 0xf43d, 0x11d2, {0x9a, 0xc, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d} } |
| #define UNICODE_BYTE_ORDER_MARK (CHAR16)(0xfeff) |
| INTERFACE_DECL(_EFI_UNICODE_COLLATION_INTERFACE); |
| typedef |
| INTN |
| (EFIAPI *EFI_UNICODE_STRICOLL) ( |
| IN struct _EFI_UNICODE_COLLATION_INTERFACE *This, |
| IN CHAR16 *s1, |
| IN CHAR16 *s2 |
| ); |
| typedef |
| BOOLEAN |
| (EFIAPI *EFI_UNICODE_METAIMATCH) ( |
| IN struct _EFI_UNICODE_COLLATION_INTERFACE *This, |
| IN CHAR16 *String, |
| IN CHAR16 *Pattern |
| ); |
| typedef |
| VOID |
| (EFIAPI *EFI_UNICODE_STRLWR) ( |
| IN struct _EFI_UNICODE_COLLATION_INTERFACE *This, |
| IN OUT CHAR16 *Str |
| ); |
| typedef |
| VOID |
| (EFIAPI *EFI_UNICODE_STRUPR) ( |
| IN struct _EFI_UNICODE_COLLATION_INTERFACE *This, |
| IN OUT CHAR16 *Str |
| ); |
| typedef |
| VOID |
| (EFIAPI *EFI_UNICODE_FATTOSTR) ( |
| IN struct _EFI_UNICODE_COLLATION_INTERFACE *This, |
| IN UINTN FatSize, |
| IN CHAR8 *Fat, |
| OUT CHAR16 *String |
| ); |
| typedef |
| BOOLEAN |
| (EFIAPI *EFI_UNICODE_STRTOFAT) ( |
| IN struct _EFI_UNICODE_COLLATION_INTERFACE *This, |
| IN CHAR16 *String, |
| IN UINTN FatSize, |
| OUT CHAR8 *Fat |
| ); |
| typedef struct _EFI_UNICODE_COLLATION_INTERFACE { |
| // general |
| EFI_UNICODE_STRICOLL StriColl; |
| EFI_UNICODE_METAIMATCH MetaiMatch; |
| EFI_UNICODE_STRLWR StrLwr; |
| EFI_UNICODE_STRUPR StrUpr; |
| // for supporting fat volumes |
| EFI_UNICODE_FATTOSTR FatToStr; |
| EFI_UNICODE_STRTOFAT StrToFat; |
| CHAR8 *SupportedLanguages; |
| } EFI_UNICODE_COLLATION_INTERFACE; |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/efistdarg.h |
|---|
| 0,0 → 1,33 |
| #ifndef _EFISTDARG_H_ |
| #define _EFISTDARG_H_ |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| devpath.h |
| Abstract: |
| Defines for parsing the EFI Device Path structures |
| Revision History |
| --*/ |
| #ifdef __GNUC__ |
| #include "stdarg.h" |
| #else |
| #define _INTSIZEOF(n) ( (sizeof(n) + sizeof(UINTN) - 1) & ~(sizeof(UINTN) - 1) ) |
| typedef CHAR8 * va_list; |
| #define va_start(ap,v) ( ap = (va_list)&v + _INTSIZEOF(v) ) |
| #define va_arg(ap,t) ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) ) |
| #define va_end(ap) ( ap = (va_list)0 ) |
| #endif |
| #endif /* _INC_STDARG */ |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/ia32/efilibplat.h |
|---|
| 0,0 → 1,26 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| efilibplat.h |
| Abstract: |
| EFI to compile bindings |
| Revision History |
| --*/ |
| VOID |
| InitializeLibPlatform ( |
| IN EFI_HANDLE ImageHandle, |
| IN EFI_SYSTEM_TABLE *SystemTable |
| ); |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/ia32/efibind.h |
|---|
| 0,0 → 1,263 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| efefind.h |
| Abstract: |
| EFI to compile bindings |
| Revision History |
| --*/ |
| #ifndef __GNUC__ |
| #pragma pack() |
| #endif |
| // |
| // Basic int types of various widths |
| // |
| #if (__STDC_VERSION__ < 199901L ) |
| // No ANSI C 1999/2000 stdint.h integer width declarations |
| #if _MSC_EXTENSIONS |
| // Use Microsoft C compiler integer width declarations |
| typedef unsigned __int64 uint64_t; |
| typedef __int64 int64_t; |
| typedef unsigned __int32 uint32_t; |
| typedef __int32 int32_t; |
| typedef unsigned short uint16_t; |
| typedef short int16_t; |
| typedef unsigned char uint8_t; |
| typedef char int8_t; |
| #elif defined(__GNUC__) |
| typedef unsigned long long uint64_t __attribute__((aligned (8))); |
| typedef long long int64_t __attribute__((aligned (8))); |
| typedef unsigned int uint32_t; |
| typedef int int32_t; |
| typedef unsigned short uint16_t; |
| typedef short int16_t; |
| typedef unsigned char uint8_t; |
| typedef char int8_t; |
| #elif defined(UNIX_LP64) |
| /* Use LP64 programming model from C_FLAGS for integer width declarations */ |
| typedef unsigned long uint64_t; |
| typedef long int64_t; |
| typedef unsigned int uint32_t; |
| typedef int int32_t; |
| typedef unsigned short uint16_t; |
| typedef short int16_t; |
| typedef unsigned char uint8_t; |
| typedef char int8_t; |
| #else |
| /* Assume P64 programming model from C_FLAGS for integer width declarations */ |
| typedef unsigned long long uint64_t __attribute__((aligned (8))); |
| typedef long long int64_t __attribute__((aligned (8))); |
| typedef unsigned int uint32_t; |
| typedef int int32_t; |
| typedef unsigned short uint16_t; |
| typedef short int16_t; |
| typedef unsigned char uint8_t; |
| typedef char int8_t; |
| #endif |
| #endif |
| // |
| // Basic EFI types of various widths |
| // |
| #ifndef __WCHAR_TYPE__ |
| # define __WCHAR_TYPE__ short |
| #endif |
| typedef uint64_t UINT64; |
| typedef int64_t INT64; |
| #ifndef _BASETSD_H_ |
| typedef uint32_t UINT32; |
| typedef int32_t INT32; |
| #endif |
| typedef uint16_t UINT16; |
| typedef int16_t INT16; |
| typedef uint8_t UINT8; |
| typedef int8_t INT8; |
| typedef __WCHAR_TYPE__ WCHAR; |
| #undef VOID |
| #define VOID void |
| typedef int32_t INTN; |
| typedef uint32_t UINTN; |
| #ifdef EFI_NT_EMULATOR |
| #define POST_CODE(_Data) |
| #else |
| #ifdef EFI_DEBUG |
| #define POST_CODE(_Data) __asm mov eax,(_Data) __asm out 0x80,al |
| #else |
| #define POST_CODE(_Data) |
| #endif |
| #endif |
| #define EFIERR(a) (0x80000000 | a) |
| #define EFI_ERROR_MASK 0x80000000 |
| #define EFIERR_OEM(a) (0xc0000000 | a) |
| #define BAD_POINTER 0xFBFBFBFB |
| #define MAX_ADDRESS 0xFFFFFFFF |
| #ifdef EFI_NT_EMULATOR |
| #define BREAKPOINT() __asm { int 3 } |
| #else |
| #define BREAKPOINT() while (TRUE); // Make it hang on Bios[Dbg]32 |
| #endif |
| // |
| // Pointers must be aligned to these address to function |
| // |
| #define MIN_ALIGNMENT_SIZE 4 |
| #define ALIGN_VARIABLE(Value ,Adjustment) \ |
| (UINTN)Adjustment = 0; \ |
| if((UINTN)Value % MIN_ALIGNMENT_SIZE) \ |
| (UINTN)Adjustment = MIN_ALIGNMENT_SIZE - ((UINTN)Value % MIN_ALIGNMENT_SIZE); \ |
| Value = (UINTN)Value + (UINTN)Adjustment |
| // |
| // Define macros to build data structure signatures from characters. |
| // |
| #define EFI_SIGNATURE_16(A,B) ((A) | (B<<8)) |
| #define EFI_SIGNATURE_32(A,B,C,D) (EFI_SIGNATURE_16(A,B) | (EFI_SIGNATURE_16(C,D) << 16)) |
| #define EFI_SIGNATURE_64(A,B,C,D,E,F,G,H) (EFI_SIGNATURE_32(A,B,C,D) | ((UINT64)(EFI_SIGNATURE_32(E,F,G,H)) << 32)) |
| // |
| // To export & import functions in the EFI emulator environment |
| // |
| #if EFI_NT_EMULATOR |
| #define EXPORTAPI __declspec( dllexport ) |
| #else |
| #define EXPORTAPI |
| #endif |
| // |
| // EFIAPI - prototype calling convention for EFI function pointers |
| // BOOTSERVICE - prototype for implementation of a boot service interface |
| // RUNTIMESERVICE - prototype for implementation of a runtime service interface |
| // RUNTIMEFUNCTION - prototype for implementation of a runtime function that is not a service |
| // RUNTIME_CODE - pragma macro for declaring runtime code |
| // |
| #ifndef EFIAPI // Forces EFI calling conventions reguardless of compiler options |
| #if _MSC_EXTENSIONS |
| #define EFIAPI __cdecl // Force C calling convention for Microsoft C compiler |
| #else |
| #define EFIAPI // Substitute expresion to force C calling convention |
| #endif |
| #endif |
| #define BOOTSERVICE |
| //#define RUNTIMESERVICE(proto,a) alloc_text("rtcode",a); proto a |
| //#define RUNTIMEFUNCTION(proto,a) alloc_text("rtcode",a); proto a |
| #define RUNTIMESERVICE |
| #define RUNTIMEFUNCTION |
| #define RUNTIME_CODE(a) alloc_text("rtcode", a) |
| #define BEGIN_RUNTIME_DATA() data_seg("rtdata") |
| #define END_RUNTIME_DATA() data_seg("") |
| #define VOLATILE volatile |
| #define MEMORY_FENCE() |
| #ifdef EFI_NT_EMULATOR |
| // |
| // To help ensure proper coding of integrated drivers, they are |
| // compiled as DLLs. In NT they require a dll init entry pointer. |
| // The macro puts a stub entry point into the DLL so it will load. |
| // |
| #define EFI_DRIVER_ENTRY_POINT(InitFunction) \ |
| UINTN \ |
| __stdcall \ |
| _DllMainCRTStartup ( \ |
| UINTN Inst, \ |
| UINTN reason_for_call, \ |
| VOID *rserved \ |
| ) \ |
| { \ |
| return 1; \ |
| } \ |
| \ |
| int \ |
| EXPORTAPI \ |
| __cdecl \ |
| InitializeDriver ( \ |
| void *ImageHandle, \ |
| void *SystemTable \ |
| ) \ |
| { \ |
| return InitFunction(ImageHandle, SystemTable); \ |
| } |
| #define LOAD_INTERNAL_DRIVER(_if, type, name, entry) \ |
| (_if)->LoadInternal(type, name, NULL) |
| #else // EFI_NT_EMULATOR |
| // |
| // When build similiar to FW, then link everything together as |
| // one big module. |
| // |
| #define EFI_DRIVER_ENTRY_POINT(InitFunction) |
| #define LOAD_INTERNAL_DRIVER(_if, type, name, entry) \ |
| (_if)->LoadInternal(type, name, entry) |
| #endif // EFI_FW_NT |
| // |
| // Some compilers don't support the forward reference construct: |
| // typedef struct XXXXX |
| // |
| // The following macro provide a workaround for such cases. |
| // |
| #ifdef NO_INTERFACE_DECL |
| #define INTERFACE_DECL(x) |
| #else |
| #ifdef __GNUC__ |
| #define INTERFACE_DECL(x) struct x |
| #else |
| #define INTERFACE_DECL(x) typedef struct x |
| #endif |
| #endif |
| #if _MSC_EXTENSIONS |
| #pragma warning ( disable : 4731 ) // Suppress warnings about modification of EBP |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/ia32/pe.h |
|---|
| 0,0 → 1,591 |
| /* |
| PE32+ header file |
| */ |
| #ifndef _PE_H |
| #define _PE_H |
| #define IMAGE_DOS_SIGNATURE 0x5A4D // MZ |
| #define IMAGE_OS2_SIGNATURE 0x454E // NE |
| #define IMAGE_OS2_SIGNATURE_LE 0x454C // LE |
| #define IMAGE_NT_SIGNATURE 0x00004550 // PE00 |
| #define IMAGE_EDOS_SIGNATURE 0x44454550 // PEED |
| typedef struct _IMAGE_DOS_HEADER { // DOS .EXE header |
| UINT16 e_magic; // Magic number |
| UINT16 e_cblp; // Bytes on last page of file |
| UINT16 e_cp; // Pages in file |
| UINT16 e_crlc; // Relocations |
| UINT16 e_cparhdr; // Size of header in paragraphs |
| UINT16 e_minalloc; // Minimum extra paragraphs needed |
| UINT16 e_maxalloc; // Maximum extra paragraphs needed |
| UINT16 e_ss; // Initial (relative) SS value |
| UINT16 e_sp; // Initial SP value |
| UINT16 e_csum; // Checksum |
| UINT16 e_ip; // Initial IP value |
| UINT16 e_cs; // Initial (relative) CS value |
| UINT16 e_lfarlc; // File address of relocation table |
| UINT16 e_ovno; // Overlay number |
| UINT16 e_res[4]; // Reserved words |
| UINT16 e_oemid; // OEM identifier (for e_oeminfo) |
| UINT16 e_oeminfo; // OEM information; e_oemid specific |
| UINT16 e_res2[10]; // Reserved words |
| UINT32 e_lfanew; // File address of new exe header |
| } IMAGE_DOS_HEADER, *PIMAGE_DOS_HEADER; |
| typedef struct _IMAGE_OS2_HEADER { // OS/2 .EXE header |
| UINT16 ne_magic; // Magic number |
| UINT8 ne_ver; // Version number |
| UINT8 ne_rev; // Revision number |
| UINT16 ne_enttab; // Offset of Entry Table |
| UINT16 ne_cbenttab; // Number of bytes in Entry Table |
| UINT32 ne_crc; // Checksum of whole file |
| UINT16 ne_flags; // Flag UINT16 |
| UINT16 ne_autodata; // Automatic data segment number |
| UINT16 ne_heap; // Initial heap allocation |
| UINT16 ne_stack; // Initial stack allocation |
| UINT32 ne_csip; // Initial CS:IP setting |
| UINT32 ne_sssp; // Initial SS:SP setting |
| UINT16 ne_cseg; // Count of file segments |
| UINT16 ne_cmod; // Entries in Module Reference Table |
| UINT16 ne_cbnrestab; // Size of non-resident name table |
| UINT16 ne_segtab; // Offset of Segment Table |
| UINT16 ne_rsrctab; // Offset of Resource Table |
| UINT16 ne_restab; // Offset of resident name table |
| UINT16 ne_modtab; // Offset of Module Reference Table |
| UINT16 ne_imptab; // Offset of Imported Names Table |
| UINT32 ne_nrestab; // Offset of Non-resident Names Table |
| UINT16 ne_cmovent; // Count of movable entries |
| UINT16 ne_align; // Segment alignment shift count |
| UINT16 ne_cres; // Count of resource segments |
| UINT8 ne_exetyp; // Target Operating system |
| UINT8 ne_flagsothers; // Other .EXE flags |
| UINT16 ne_pretthunks; // offset to return thunks |
| UINT16 ne_psegrefbytes; // offset to segment ref. bytes |
| UINT16 ne_swaparea; // Minimum code swap area size |
| UINT16 ne_expver; // Expected Windows version number |
| } IMAGE_OS2_HEADER, *PIMAGE_OS2_HEADER; |
| // |
| // File header format. |
| // |
| typedef struct _IMAGE_FILE_HEADER { |
| UINT16 Machine; |
| UINT16 NumberOfSections; |
| UINT32 TimeDateStamp; |
| UINT32 PointerToSymbolTable; |
| UINT32 NumberOfSymbols; |
| UINT16 SizeOfOptionalHeader; |
| UINT16 Characteristics; |
| } IMAGE_FILE_HEADER, *PIMAGE_FILE_HEADER; |
| #define IMAGE_SIZEOF_FILE_HEADER 20 |
| #define IMAGE_FILE_RELOCS_STRIPPED 0x0001 // Relocation info stripped from file. |
| #define IMAGE_FILE_EXECUTABLE_IMAGE 0x0002 // File is executable (i.e. no unresolved externel references). |
| #define IMAGE_FILE_LINE_NUMS_STRIPPED 0x0004 // Line nunbers stripped from file. |
| #define IMAGE_FILE_LOCAL_SYMS_STRIPPED 0x0008 // Local symbols stripped from file. |
| #define IMAGE_FILE_BYTES_REVERSED_LO 0x0080 // Bytes of machine word are reversed. |
| #define IMAGE_FILE_32BIT_MACHINE 0x0100 // 32 bit word machine. |
| #define IMAGE_FILE_DEBUG_STRIPPED 0x0200 // Debugging info stripped from file in .DBG file |
| #define IMAGE_FILE_SYSTEM 0x1000 // System File. |
| #define IMAGE_FILE_DLL 0x2000 // File is a DLL. |
| #define IMAGE_FILE_BYTES_REVERSED_HI 0x8000 // Bytes of machine word are reversed. |
| #define IMAGE_FILE_MACHINE_UNKNOWN 0 |
| #define IMAGE_FILE_MACHINE_I386 0x14c // Intel 386. |
| #define IMAGE_FILE_MACHINE_R3000 0x162 // MIPS little-endian, 0540 big-endian |
| #define IMAGE_FILE_MACHINE_R4000 0x166 // MIPS little-endian |
| #define IMAGE_FILE_MACHINE_ALPHA 0x184 // Alpha_AXP |
| #define IMAGE_FILE_MACHINE_POWERPC 0x1F0 // IBM PowerPC Little-Endian |
| #define IMAGE_FILE_MACHINE_TAHOE 0x7cc // Intel EM machine |
| // |
| // Directory format. |
| // |
| typedef struct _IMAGE_DATA_DIRECTORY { |
| UINT32 VirtualAddress; |
| UINT32 Size; |
| } IMAGE_DATA_DIRECTORY, *PIMAGE_DATA_DIRECTORY; |
| #define IMAGE_NUMBEROF_DIRECTORY_ENTRIES 16 |
| // |
| // Optional header format. |
| // |
| typedef struct _IMAGE_OPTIONAL_HEADER { |
| // |
| // Standard fields. |
| // |
| UINT16 Magic; |
| UINT8 MajorLinkerVersion; |
| UINT8 MinorLinkerVersion; |
| UINT32 SizeOfCode; |
| UINT32 SizeOfInitializedData; |
| UINT32 SizeOfUninitializedData; |
| UINT32 AddressOfEntryPoint; |
| UINT32 BaseOfCode; |
| UINT32 BaseOfData; |
| // |
| // NT additional fields. |
| // |
| UINT32 ImageBase; |
| UINT32 SectionAlignment; |
| UINT32 FileAlignment; |
| UINT16 MajorOperatingSystemVersion; |
| UINT16 MinorOperatingSystemVersion; |
| UINT16 MajorImageVersion; |
| UINT16 MinorImageVersion; |
| UINT16 MajorSubsystemVersion; |
| UINT16 MinorSubsystemVersion; |
| UINT32 Reserved1; |
| UINT32 SizeOfImage; |
| UINT32 SizeOfHeaders; |
| UINT32 CheckSum; |
| UINT16 Subsystem; |
| UINT16 DllCharacteristics; |
| UINT32 SizeOfStackReserve; |
| UINT32 SizeOfStackCommit; |
| UINT32 SizeOfHeapReserve; |
| UINT32 SizeOfHeapCommit; |
| UINT32 LoaderFlags; |
| UINT32 NumberOfRvaAndSizes; |
| IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES]; |
| } IMAGE_OPTIONAL_HEADER, *PIMAGE_OPTIONAL_HEADER; |
| typedef struct _IMAGE_ROM_OPTIONAL_HEADER { |
| UINT16 Magic; |
| UINT8 MajorLinkerVersion; |
| UINT8 MinorLinkerVersion; |
| UINT32 SizeOfCode; |
| UINT32 SizeOfInitializedData; |
| UINT32 SizeOfUninitializedData; |
| UINT32 AddressOfEntryPoint; |
| UINT32 BaseOfCode; |
| UINT32 BaseOfData; |
| UINT32 BaseOfBss; |
| UINT32 GprMask; |
| UINT32 CprMask[4]; |
| UINT32 GpValue; |
| } IMAGE_ROM_OPTIONAL_HEADER, *PIMAGE_ROM_OPTIONAL_HEADER; |
| #define IMAGE_SIZEOF_ROM_OPTIONAL_HEADER 56 |
| #define IMAGE_SIZEOF_STD_OPTIONAL_HEADER 28 |
| #define IMAGE_SIZEOF_NT_OPTIONAL_HEADER 224 |
| #define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b |
| #define IMAGE_ROM_OPTIONAL_HDR_MAGIC 0x107 |
| typedef struct _IMAGE_NT_HEADERS { |
| UINT32 Signature; |
| IMAGE_FILE_HEADER FileHeader; |
| IMAGE_OPTIONAL_HEADER OptionalHeader; |
| } IMAGE_NT_HEADERS, *PIMAGE_NT_HEADERS; |
| typedef struct _IMAGE_ROM_HEADERS { |
| IMAGE_FILE_HEADER FileHeader; |
| IMAGE_ROM_OPTIONAL_HEADER OptionalHeader; |
| } IMAGE_ROM_HEADERS, *PIMAGE_ROM_HEADERS; |
| #define IMAGE_FIRST_SECTION( ntheader ) ((PIMAGE_SECTION_HEADER) \ |
| ((UINT32)ntheader + \ |
| FIELD_OFFSET( IMAGE_NT_HEADERS, OptionalHeader ) + \ |
| ((PIMAGE_NT_HEADERS)(ntheader))->FileHeader.SizeOfOptionalHeader \ |
| )) |
| // Subsystem Values |
| #define IMAGE_SUBSYSTEM_UNKNOWN 0 // Unknown subsystem. |
| #define IMAGE_SUBSYSTEM_NATIVE 1 // Image doesn't require a subsystem. |
| #define IMAGE_SUBSYSTEM_WINDOWS_GUI 2 // Image runs in the Windows GUI subsystem. |
| #define IMAGE_SUBSYSTEM_WINDOWS_CUI 3 // Image runs in the Windows character subsystem. |
| #define IMAGE_SUBSYSTEM_OS2_CUI 5 // image runs in the OS/2 character subsystem. |
| #define IMAGE_SUBSYSTEM_POSIX_CUI 7 // image run in the Posix character subsystem. |
| // Directory Entries |
| #define IMAGE_DIRECTORY_ENTRY_EXPORT 0 // Export Directory |
| #define IMAGE_DIRECTORY_ENTRY_IMPORT 1 // Import Directory |
| #define IMAGE_DIRECTORY_ENTRY_RESOURCE 2 // Resource Directory |
| #define IMAGE_DIRECTORY_ENTRY_EXCEPTION 3 // Exception Directory |
| #define IMAGE_DIRECTORY_ENTRY_SECURITY 4 // Security Directory |
| #define IMAGE_DIRECTORY_ENTRY_BASERELOC 5 // Base Relocation Table |
| #define IMAGE_DIRECTORY_ENTRY_DEBUG 6 // Debug Directory |
| #define IMAGE_DIRECTORY_ENTRY_COPYRIGHT 7 // Description String |
| #define IMAGE_DIRECTORY_ENTRY_GLOBALPTR 8 // Machine Value (MIPS GP) |
| #define IMAGE_DIRECTORY_ENTRY_TLS 9 // TLS Directory |
| #define IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG 10 // Load Configuration Directory |
| // |
| // Section header format. |
| // |
| #define IMAGE_SIZEOF_SHORT_NAME 8 |
| typedef struct _IMAGE_SECTION_HEADER { |
| UINT8 Name[IMAGE_SIZEOF_SHORT_NAME]; |
| union { |
| UINT32 PhysicalAddress; |
| UINT32 VirtualSize; |
| } Misc; |
| UINT32 VirtualAddress; |
| UINT32 SizeOfRawData; |
| UINT32 PointerToRawData; |
| UINT32 PointerToRelocations; |
| UINT32 PointerToLinenumbers; |
| UINT16 NumberOfRelocations; |
| UINT16 NumberOfLinenumbers; |
| UINT32 Characteristics; |
| } IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER; |
| #define IMAGE_SIZEOF_SECTION_HEADER 40 |
| #define IMAGE_SCN_TYPE_NO_PAD 0x00000008 // Reserved. |
| #define IMAGE_SCN_CNT_CODE 0x00000020 // Section contains code. |
| #define IMAGE_SCN_CNT_INITIALIZED_DATA 0x00000040 // Section contains initialized data. |
| #define IMAGE_SCN_CNT_UNINITIALIZED_DATA 0x00000080 // Section contains uninitialized data. |
| #define IMAGE_SCN_LNK_OTHER 0x00000100 // Reserved. |
| #define IMAGE_SCN_LNK_INFO 0x00000200 // Section contains comments or some other type of information. |
| #define IMAGE_SCN_LNK_REMOVE 0x00000800 // Section contents will not become part of image. |
| #define IMAGE_SCN_LNK_COMDAT 0x00001000 // Section contents comdat. |
| #define IMAGE_SCN_ALIGN_1BYTES 0x00100000 // |
| #define IMAGE_SCN_ALIGN_2BYTES 0x00200000 // |
| #define IMAGE_SCN_ALIGN_4BYTES 0x00300000 // |
| #define IMAGE_SCN_ALIGN_8BYTES 0x00400000 // |
| #define IMAGE_SCN_ALIGN_16BYTES 0x00500000 // Default alignment if no others are specified. |
| #define IMAGE_SCN_ALIGN_32BYTES 0x00600000 // |
| #define IMAGE_SCN_ALIGN_64BYTES 0x00700000 // |
| #define IMAGE_SCN_MEM_DISCARDABLE 0x02000000 // Section can be discarded. |
| #define IMAGE_SCN_MEM_NOT_CACHED 0x04000000 // Section is not cachable. |
| #define IMAGE_SCN_MEM_NOT_PAGED 0x08000000 // Section is not pageable. |
| #define IMAGE_SCN_MEM_SHARED 0x10000000 // Section is shareable. |
| #define IMAGE_SCN_MEM_EXECUTE 0x20000000 // Section is executable. |
| #define IMAGE_SCN_MEM_READ 0x40000000 // Section is readable. |
| #define IMAGE_SCN_MEM_WRITE 0x80000000 // Section is writeable. |
| // |
| // Symbol format. |
| // |
| #define IMAGE_SIZEOF_SYMBOL 18 |
| // |
| // Section values. |
| // |
| // Symbols have a section number of the section in which they are |
| // defined. Otherwise, section numbers have the following meanings: |
| // |
| #define IMAGE_SYM_UNDEFINED (UINT16)0 // Symbol is undefined or is common. |
| #define IMAGE_SYM_ABSOLUTE (UINT16)-1 // Symbol is an absolute value. |
| #define IMAGE_SYM_DEBUG (UINT16)-2 // Symbol is a special debug item. |
| // |
| // Type (fundamental) values. |
| // |
| #define IMAGE_SYM_TYPE_NULL 0 // no type. |
| #define IMAGE_SYM_TYPE_VOID 1 // |
| #define IMAGE_SYM_TYPE_CHAR 2 // type character. |
| #define IMAGE_SYM_TYPE_SHORT 3 // type short integer. |
| #define IMAGE_SYM_TYPE_INT 4 // |
| #define IMAGE_SYM_TYPE_LONG 5 // |
| #define IMAGE_SYM_TYPE_FLOAT 6 // |
| #define IMAGE_SYM_TYPE_DOUBLE 7 // |
| #define IMAGE_SYM_TYPE_STRUCT 8 // |
| #define IMAGE_SYM_TYPE_UNION 9 // |
| #define IMAGE_SYM_TYPE_ENUM 10 // enumeration. |
| #define IMAGE_SYM_TYPE_MOE 11 // member of enumeration. |
| #define IMAGE_SYM_TYPE_BYTE 12 // |
| #define IMAGE_SYM_TYPE_WORD 13 // |
| #define IMAGE_SYM_TYPE_UINT 14 // |
| #define IMAGE_SYM_TYPE_DWORD 15 // |
| // |
| // Type (derived) values. |
| // |
| #define IMAGE_SYM_DTYPE_NULL 0 // no derived type. |
| #define IMAGE_SYM_DTYPE_POINTER 1 // pointer. |
| #define IMAGE_SYM_DTYPE_FUNCTION 2 // function. |
| #define IMAGE_SYM_DTYPE_ARRAY 3 // array. |
| // |
| // Storage classes. |
| // |
| #define IMAGE_SYM_CLASS_END_OF_FUNCTION (BYTE )-1 |
| #define IMAGE_SYM_CLASS_NULL 0 |
| #define IMAGE_SYM_CLASS_AUTOMATIC 1 |
| #define IMAGE_SYM_CLASS_EXTERNAL 2 |
| #define IMAGE_SYM_CLASS_STATIC 3 |
| #define IMAGE_SYM_CLASS_REGISTER 4 |
| #define IMAGE_SYM_CLASS_EXTERNAL_DEF 5 |
| #define IMAGE_SYM_CLASS_LABEL 6 |
| #define IMAGE_SYM_CLASS_UNDEFINED_LABEL 7 |
| #define IMAGE_SYM_CLASS_MEMBER_OF_STRUCT 8 |
| #define IMAGE_SYM_CLASS_ARGUMENT 9 |
| #define IMAGE_SYM_CLASS_STRUCT_TAG 10 |
| #define IMAGE_SYM_CLASS_MEMBER_OF_UNION 11 |
| #define IMAGE_SYM_CLASS_UNION_TAG 12 |
| #define IMAGE_SYM_CLASS_TYPE_DEFINITION 13 |
| #define IMAGE_SYM_CLASS_UNDEFINED_STATIC 14 |
| #define IMAGE_SYM_CLASS_ENUM_TAG 15 |
| #define IMAGE_SYM_CLASS_MEMBER_OF_ENUM 16 |
| #define IMAGE_SYM_CLASS_REGISTER_PARAM 17 |
| #define IMAGE_SYM_CLASS_BIT_FIELD 18 |
| #define IMAGE_SYM_CLASS_BLOCK 100 |
| #define IMAGE_SYM_CLASS_FUNCTION 101 |
| #define IMAGE_SYM_CLASS_END_OF_STRUCT 102 |
| #define IMAGE_SYM_CLASS_FILE 103 |
| // new |
| #define IMAGE_SYM_CLASS_SECTION 104 |
| #define IMAGE_SYM_CLASS_WEAK_EXTERNAL 105 |
| // type packing constants |
| #define N_BTMASK 017 |
| #define N_TMASK 060 |
| #define N_TMASK1 0300 |
| #define N_TMASK2 0360 |
| #define N_BTSHFT 4 |
| #define N_TSHIFT 2 |
| // MACROS |
| // |
| // Communal selection types. |
| // |
| #define IMAGE_COMDAT_SELECT_NODUPLICATES 1 |
| #define IMAGE_COMDAT_SELECT_ANY 2 |
| #define IMAGE_COMDAT_SELECT_SAME_SIZE 3 |
| #define IMAGE_COMDAT_SELECT_EXACT_MATCH 4 |
| #define IMAGE_COMDAT_SELECT_ASSOCIATIVE 5 |
| #define IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY 1 |
| #define IMAGE_WEAK_EXTERN_SEARCH_LIBRARY 2 |
| #define IMAGE_WEAK_EXTERN_SEARCH_ALIAS 3 |
| // |
| // Relocation format. |
| // |
| typedef struct _IMAGE_RELOCATION { |
| UINT32 VirtualAddress; |
| UINT32 SymbolTableIndex; |
| UINT16 Type; |
| } IMAGE_RELOCATION; |
| #define IMAGE_SIZEOF_RELOCATION 10 |
| // |
| // I386 relocation types. |
| // |
| #define IMAGE_REL_I386_ABSOLUTE 0 // Reference is absolute, no relocation is necessary |
| #define IMAGE_REL_I386_DIR16 01 // Direct 16-bit reference to the symbols virtual address |
| #define IMAGE_REL_I386_REL16 02 // PC-relative 16-bit reference to the symbols virtual address |
| #define IMAGE_REL_I386_DIR32 06 // Direct 32-bit reference to the symbols virtual address |
| #define IMAGE_REL_I386_DIR32NB 07 // Direct 32-bit reference to the symbols virtual address, base not included |
| #define IMAGE_REL_I386_SEG12 011 // Direct 16-bit reference to the segment-selector bits of a 32-bit virtual address |
| #define IMAGE_REL_I386_SECTION 012 |
| #define IMAGE_REL_I386_SECREL 013 |
| #define IMAGE_REL_I386_REL32 024 // PC-relative 32-bit reference to the symbols virtual address |
| // |
| // MIPS relocation types. |
| // |
| #define IMAGE_REL_MIPS_ABSOLUTE 0 // Reference is absolute, no relocation is necessary |
| #define IMAGE_REL_MIPS_REFHALF 01 |
| #define IMAGE_REL_MIPS_REFWORD 02 |
| #define IMAGE_REL_MIPS_JMPADDR 03 |
| #define IMAGE_REL_MIPS_REFHI 04 |
| #define IMAGE_REL_MIPS_REFLO 05 |
| #define IMAGE_REL_MIPS_GPREL 06 |
| #define IMAGE_REL_MIPS_LITERAL 07 |
| #define IMAGE_REL_MIPS_SECTION 012 |
| #define IMAGE_REL_MIPS_SECREL 013 |
| #define IMAGE_REL_MIPS_REFWORDNB 042 |
| #define IMAGE_REL_MIPS_PAIR 045 |
| // |
| // Alpha Relocation types. |
| // |
| #define IMAGE_REL_ALPHA_ABSOLUTE 0x0 |
| #define IMAGE_REL_ALPHA_REFLONG 0x1 |
| #define IMAGE_REL_ALPHA_REFQUAD 0x2 |
| #define IMAGE_REL_ALPHA_GPREL32 0x3 |
| #define IMAGE_REL_ALPHA_LITERAL 0x4 |
| #define IMAGE_REL_ALPHA_LITUSE 0x5 |
| #define IMAGE_REL_ALPHA_GPDISP 0x6 |
| #define IMAGE_REL_ALPHA_BRADDR 0x7 |
| #define IMAGE_REL_ALPHA_HINT 0x8 |
| #define IMAGE_REL_ALPHA_INLINE_REFLONG 0x9 |
| #define IMAGE_REL_ALPHA_REFHI 0xA |
| #define IMAGE_REL_ALPHA_REFLO 0xB |
| #define IMAGE_REL_ALPHA_PAIR 0xC |
| #define IMAGE_REL_ALPHA_MATCH 0xD |
| #define IMAGE_REL_ALPHA_SECTION 0xE |
| #define IMAGE_REL_ALPHA_SECREL 0xF |
| #define IMAGE_REL_ALPHA_REFLONGNB 0x10 |
| // |
| // IBM PowerPC relocation types. |
| // |
| #define IMAGE_REL_PPC_ABSOLUTE 0x0000 // NOP |
| #define IMAGE_REL_PPC_ADDR64 0x0001 // 64-bit address |
| #define IMAGE_REL_PPC_ADDR32 0x0002 // 32-bit address |
| #define IMAGE_REL_PPC_ADDR24 0x0003 // 26-bit address, shifted left 2 (branch absolute) |
| #define IMAGE_REL_PPC_ADDR16 0x0004 // 16-bit address |
| #define IMAGE_REL_PPC_ADDR14 0x0005 // 16-bit address, shifted left 2 (load doubleword) |
| #define IMAGE_REL_PPC_REL24 0x0006 // 26-bit PC-relative offset, shifted left 2 (branch relative) |
| #define IMAGE_REL_PPC_REL14 0x0007 // 16-bit PC-relative offset, shifted left 2 (br cond relative) |
| #define IMAGE_REL_PPC_TOCREL16 0x0008 // 16-bit offset from TOC base |
| #define IMAGE_REL_PPC_TOCREL14 0x0009 // 16-bit offset from TOC base, shifted left 2 (load doubleword) |
| #define IMAGE_REL_PPC_ADDR32NB 0x000A // 32-bit addr w/o image base |
| #define IMAGE_REL_PPC_SECREL 0x000B // va of containing section (as in an image sectionhdr) |
| #define IMAGE_REL_PPC_SECTION 0x000C // sectionheader number |
| #define IMAGE_REL_PPC_IFGLUE 0x000D // substitute TOC restore instruction iff symbol is glue code |
| #define IMAGE_REL_PPC_IMGLUE 0x000E // symbol is glue code; virtual address is TOC restore instruction |
| #define IMAGE_REL_PPC_TYPEMASK 0x00FF // mask to isolate above values in IMAGE_RELOCATION.Type |
| // Flag bits in IMAGE_RELOCATION.TYPE |
| #define IMAGE_REL_PPC_NEG 0x0100 // subtract reloc value rather than adding it |
| #define IMAGE_REL_PPC_BRTAKEN 0x0200 // fix branch prediction bit to predict branch taken |
| #define IMAGE_REL_PPC_BRNTAKEN 0x0400 // fix branch prediction bit to predict branch not taken |
| #define IMAGE_REL_PPC_TOCDEFN 0x0800 // toc slot defined in file (or, data in toc) |
| // |
| // Based relocation format. |
| // |
| typedef struct _IMAGE_BASE_RELOCATION { |
| UINT32 VirtualAddress; |
| UINT32 SizeOfBlock; |
| // UINT16 TypeOffset[1]; |
| } IMAGE_BASE_RELOCATION, *PIMAGE_BASE_RELOCATION; |
| #define IMAGE_SIZEOF_BASE_RELOCATION 8 |
| // |
| // Based relocation types. |
| // |
| #define IMAGE_REL_BASED_ABSOLUTE 0 |
| #define IMAGE_REL_BASED_HIGH 1 |
| #define IMAGE_REL_BASED_LOW 2 |
| #define IMAGE_REL_BASED_HIGHLOW 3 |
| #define IMAGE_REL_BASED_HIGHADJ 4 |
| #define IMAGE_REL_BASED_MIPS_JMPADDR 5 |
| #define IMAGE_REL_BASED_IA64_IMM64 9 |
| #define IMAGE_REL_BASED_DIR64 10 |
| // |
| // Line number format. |
| // |
| typedef struct _IMAGE_LINENUMBER { |
| union { |
| UINT32 SymbolTableIndex; // Symbol table index of function name if Linenumber is 0. |
| UINT32 VirtualAddress; // Virtual address of line number. |
| } Type; |
| UINT16 Linenumber; // Line number. |
| } IMAGE_LINENUMBER; |
| #define IMAGE_SIZEOF_LINENUMBER 6 |
| // |
| // Archive format. |
| // |
| #define IMAGE_ARCHIVE_START_SIZE 8 |
| #define IMAGE_ARCHIVE_START "!<arch>\n" |
| #define IMAGE_ARCHIVE_END "`\n" |
| #define IMAGE_ARCHIVE_PAD "\n" |
| #define IMAGE_ARCHIVE_LINKER_MEMBER "/ " |
| #define IMAGE_ARCHIVE_LONGNAMES_MEMBER "// " |
| typedef struct _IMAGE_ARCHIVE_MEMBER_HEADER { |
| UINT8 Name[16]; // File member name - `/' terminated. |
| UINT8 Date[12]; // File member date - decimal. |
| UINT8 UserID[6]; // File member user id - decimal. |
| UINT8 GroupID[6]; // File member group id - decimal. |
| UINT8 Mode[8]; // File member mode - octal. |
| UINT8 Size[10]; // File member size - decimal. |
| UINT8 EndHeader[2]; // String to end header. |
| } IMAGE_ARCHIVE_MEMBER_HEADER, *PIMAGE_ARCHIVE_MEMBER_HEADER; |
| #define IMAGE_SIZEOF_ARCHIVE_MEMBER_HDR 60 |
| // |
| // DLL support. |
| // |
| // |
| // Export Format |
| // |
| typedef struct _IMAGE_EXPORT_DIRECTORY { |
| UINT32 Characteristics; |
| UINT32 TimeDateStamp; |
| UINT16 MajorVersion; |
| UINT16 MinorVersion; |
| UINT32 Name; |
| UINT32 Base; |
| UINT32 NumberOfFunctions; |
| UINT32 NumberOfNames; |
| UINT32 *AddressOfFunctions; |
| UINT32 *AddressOfNames; |
| UINT32 *AddressOfNameOrdinals; |
| } IMAGE_EXPORT_DIRECTORY, *PIMAGE_EXPORT_DIRECTORY; |
| // |
| // Import Format |
| // |
| typedef struct _IMAGE_IMPORT_BY_NAME { |
| UINT16 Hint; |
| UINT8 Name[1]; |
| } IMAGE_IMPORT_BY_NAME, *PIMAGE_IMPORT_BY_NAME; |
| typedef struct _IMAGE_THUNK_DATA { |
| union { |
| UINT32 Function; |
| UINT32 Ordinal; |
| PIMAGE_IMPORT_BY_NAME AddressOfData; |
| } u1; |
| } IMAGE_THUNK_DATA, *PIMAGE_THUNK_DATA; |
| #define IMAGE_ORDINAL_FLAG 0x80000000 |
| #define IMAGE_SNAP_BY_ORDINAL(Ordinal) ((Ordinal & IMAGE_ORDINAL_FLAG) != 0) |
| #define IMAGE_ORDINAL(Ordinal) (Ordinal & 0xffff) |
| typedef struct _IMAGE_IMPORT_DESCRIPTOR { |
| UINT32 Characteristics; |
| UINT32 TimeDateStamp; |
| UINT32 ForwarderChain; |
| UINT32 Name; |
| PIMAGE_THUNK_DATA FirstThunk; |
| } IMAGE_IMPORT_DESCRIPTOR, *PIMAGE_IMPORT_DESCRIPTOR; |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/efinet.h |
|---|
| 0,0 → 1,340 |
| #ifndef _EFINET_H |
| #define _EFINET_H |
| /*++ |
| Copyright (c) 1999 Intel Corporation |
| Module Name: |
| efinet.h |
| Abstract: |
| EFI Simple Network protocol |
| Revision History |
| --*/ |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // Simple Network Protocol |
| // |
| #define EFI_SIMPLE_NETWORK_PROTOCOL \ |
| { 0xA19832B9, 0xAC25, 0x11D3, {0x9A, 0x2D, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D} } |
| INTERFACE_DECL(_EFI_SIMPLE_NETWORK); |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| typedef struct { |
| // |
| // Total number of frames received. Includes frames with errors and |
| // dropped frames. |
| // |
| UINT64 RxTotalFrames; |
| // |
| // Number of valid frames received and copied into receive buffers. |
| // |
| UINT64 RxGoodFrames; |
| // |
| // Number of frames below the minimum length for the media. |
| // This would be <64 for ethernet. |
| // |
| UINT64 RxUndersizeFrames; |
| // |
| // Number of frames longer than the maxminum length for the |
| // media. This would be >1500 for ethernet. |
| // |
| UINT64 RxOversizeFrames; |
| // |
| // Valid frames that were dropped because receive buffers were full. |
| // |
| UINT64 RxDroppedFrames; |
| // |
| // Number of valid unicast frames received and not dropped. |
| // |
| UINT64 RxUnicastFrames; |
| // |
| // Number of valid broadcast frames received and not dropped. |
| // |
| UINT64 RxBroadcastFrames; |
| // |
| // Number of valid mutlicast frames received and not dropped. |
| // |
| UINT64 RxMulticastFrames; |
| // |
| // Number of frames w/ CRC or alignment errors. |
| // |
| UINT64 RxCrcErrorFrames; |
| // |
| // Total number of bytes received. Includes frames with errors |
| // and dropped frames. |
| // |
| UINT64 RxTotalBytes; |
| // |
| // Transmit statistics. |
| // |
| UINT64 TxTotalFrames; |
| UINT64 TxGoodFrames; |
| UINT64 TxUndersizeFrames; |
| UINT64 TxOversizeFrames; |
| UINT64 TxDroppedFrames; |
| UINT64 TxUnicastFrames; |
| UINT64 TxBroadcastFrames; |
| UINT64 TxMulticastFrames; |
| UINT64 TxCrcErrorFrames; |
| UINT64 TxTotalBytes; |
| // |
| // Number of collisions detection on this subnet. |
| // |
| UINT64 Collisions; |
| // |
| // Number of frames destined for unsupported protocol. |
| // |
| UINT64 UnsupportedProtocol; |
| } EFI_NETWORK_STATISTICS; |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| typedef enum { |
| EfiSimpleNetworkStopped, |
| EfiSimpleNetworkStarted, |
| EfiSimpleNetworkInitialized, |
| EfiSimpleNetworkMaxState |
| } EFI_SIMPLE_NETWORK_STATE; |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| #define EFI_SIMPLE_NETWORK_RECEIVE_UNICAST 0x01 |
| #define EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST 0x02 |
| #define EFI_SIMPLE_NETWORK_RECEIVE_BROADCAST 0x04 |
| #define EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS 0x08 |
| #define EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST 0x10 |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| #define EFI_SIMPLE_NETWORK_RECEIVE_INTERRUPT 0x01 |
| #define EFI_SIMPLE_NETWORK_TRANSMIT_INTERRUPT 0x02 |
| #define EFI_SIMPLE_NETWORK_COMMAND_INTERRUPT 0x04 |
| #define EFI_SIMPLE_NETWORK_SOFTWARE_INTERRUPT 0x08 |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| #define MAX_MCAST_FILTER_CNT 16 |
| typedef struct { |
| UINT32 State; |
| UINT32 HwAddressSize; |
| UINT32 MediaHeaderSize; |
| UINT32 MaxPacketSize; |
| UINT32 NvRamSize; |
| UINT32 NvRamAccessSize; |
| UINT32 ReceiveFilterMask; |
| UINT32 ReceiveFilterSetting; |
| UINT32 MaxMCastFilterCount; |
| UINT32 MCastFilterCount; |
| EFI_MAC_ADDRESS MCastFilter[MAX_MCAST_FILTER_CNT]; |
| EFI_MAC_ADDRESS CurrentAddress; |
| EFI_MAC_ADDRESS BroadcastAddress; |
| EFI_MAC_ADDRESS PermanentAddress; |
| UINT8 IfType; |
| BOOLEAN MacAddressChangeable; |
| BOOLEAN MultipleTxSupported; |
| BOOLEAN MediaPresentSupported; |
| BOOLEAN MediaPresent; |
| } EFI_SIMPLE_NETWORK_MODE; |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_SIMPLE_NETWORK_START) ( |
| IN struct _EFI_SIMPLE_NETWORK *This |
| ); |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_SIMPLE_NETWORK_STOP) ( |
| IN struct _EFI_SIMPLE_NETWORK *This |
| ); |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_SIMPLE_NETWORK_INITIALIZE) ( |
| IN struct _EFI_SIMPLE_NETWORK *This, |
| IN UINTN ExtraRxBufferSize OPTIONAL, |
| IN UINTN ExtraTxBufferSize OPTIONAL |
| ); |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_SIMPLE_NETWORK_RESET) ( |
| IN struct _EFI_SIMPLE_NETWORK *This, |
| IN BOOLEAN ExtendedVerification |
| ); |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_SIMPLE_NETWORK_SHUTDOWN) ( |
| IN struct _EFI_SIMPLE_NETWORK *This |
| ); |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_SIMPLE_NETWORK_RECEIVE_FILTERS) ( |
| IN struct _EFI_SIMPLE_NETWORK *This, |
| IN UINT32 Enable, |
| IN UINT32 Disable, |
| IN BOOLEAN ResetMCastFilter, |
| IN UINTN MCastFilterCnt OPTIONAL, |
| IN EFI_MAC_ADDRESS *MCastFilter OPTIONAL |
| ); |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_SIMPLE_NETWORK_STATION_ADDRESS) ( |
| IN struct _EFI_SIMPLE_NETWORK *This, |
| IN BOOLEAN Reset, |
| IN EFI_MAC_ADDRESS *New OPTIONAL |
| ); |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_SIMPLE_NETWORK_STATISTICS) ( |
| IN struct _EFI_SIMPLE_NETWORK *This, |
| IN BOOLEAN Reset, |
| IN OUT UINTN *StatisticsSize OPTIONAL, |
| OUT EFI_NETWORK_STATISTICS *StatisticsTable OPTIONAL |
| ); |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_SIMPLE_NETWORK_MCAST_IP_TO_MAC) ( |
| IN struct _EFI_SIMPLE_NETWORK *This, |
| IN BOOLEAN IPv6, |
| IN EFI_IP_ADDRESS *IP, |
| OUT EFI_MAC_ADDRESS *MAC |
| ); |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_SIMPLE_NETWORK_NVDATA) ( |
| IN struct _EFI_SIMPLE_NETWORK *This, |
| IN BOOLEAN ReadWrite, |
| IN UINTN Offset, |
| IN UINTN BufferSize, |
| IN OUT VOID *Buffer |
| ); |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_SIMPLE_NETWORK_GET_STATUS) ( |
| IN struct _EFI_SIMPLE_NETWORK *This, |
| OUT UINT32 *InterruptStatus OPTIONAL, |
| OUT VOID **TxBuf OPTIONAL |
| ); |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_SIMPLE_NETWORK_TRANSMIT) ( |
| IN struct _EFI_SIMPLE_NETWORK *This, |
| IN UINTN HeaderSize, |
| IN UINTN BufferSize, |
| IN VOID *Buffer, |
| IN EFI_MAC_ADDRESS *SrcAddr OPTIONAL, |
| IN EFI_MAC_ADDRESS *DestAddr OPTIONAL, |
| IN UINT16 *Protocol OPTIONAL |
| ); |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_SIMPLE_NETWORK_RECEIVE) ( |
| IN struct _EFI_SIMPLE_NETWORK *This, |
| OUT UINTN *HeaderSize OPTIONAL, |
| IN OUT UINTN *BufferSize, |
| OUT VOID *Buffer, |
| OUT EFI_MAC_ADDRESS *SrcAddr OPTIONAL, |
| OUT EFI_MAC_ADDRESS *DestAddr OPTIONAL, |
| OUT UINT16 *Protocol OPTIONAL |
| ); |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| #define EFI_SIMPLE_NETWORK_INTERFACE_REVISION 0x00010000 |
| typedef struct _EFI_SIMPLE_NETWORK { |
| UINT64 Revision; |
| EFI_SIMPLE_NETWORK_START Start; |
| EFI_SIMPLE_NETWORK_STOP Stop; |
| EFI_SIMPLE_NETWORK_INITIALIZE Initialize; |
| EFI_SIMPLE_NETWORK_RESET Reset; |
| EFI_SIMPLE_NETWORK_SHUTDOWN Shutdown; |
| EFI_SIMPLE_NETWORK_RECEIVE_FILTERS ReceiveFilters; |
| EFI_SIMPLE_NETWORK_STATION_ADDRESS StationAddress; |
| EFI_SIMPLE_NETWORK_STATISTICS Statistics; |
| EFI_SIMPLE_NETWORK_MCAST_IP_TO_MAC MCastIpToMac; |
| EFI_SIMPLE_NETWORK_NVDATA NvData; |
| EFI_SIMPLE_NETWORK_GET_STATUS GetStatus; |
| EFI_SIMPLE_NETWORK_TRANSMIT Transmit; |
| EFI_SIMPLE_NETWORK_RECEIVE Receive; |
| EFI_EVENT WaitForPacket; |
| EFI_SIMPLE_NETWORK_MODE *Mode; |
| } EFI_SIMPLE_NETWORK; |
| #endif /* _EFINET_H */ |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/efidebug.h |
|---|
| 0,0 → 1,110 |
| #ifndef _EFI_DEBUG_H |
| #define _EFI_DEBUG_H |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| efidebug.h |
| Abstract: |
| EFI library debug functions |
| Revision History |
| --*/ |
| extern UINTN EFIDebug; |
| #if EFI_DEBUG |
| #define DBGASSERT(a) DbgAssert(__FILE__, __LINE__, #a) |
| #define DEBUG(a) DbgPrint a |
| #else |
| #define DBGASSERT(a) |
| #define DEBUG(a) |
| #endif |
| #if EFI_DEBUG_CLEAR_MEMORY |
| #define DBGSETMEM(a,l) SetMem(a,l,(CHAR8)BAD_POINTER) |
| #else |
| #define DBGSETMEM(a,l) |
| #endif |
| #define D_INIT 0x00000001 // Initialization style messages |
| #define D_WARN 0x00000002 // Warnings |
| #define D_LOAD 0x00000004 // Load events |
| #define D_FS 0x00000008 // EFI File system |
| #define D_POOL 0x00000010 // Alloc & Free's |
| #define D_PAGE 0x00000020 // Alloc & Free's |
| #define D_INFO 0x00000040 // Verbose |
| #define D_VAR 0x00000100 // Variable |
| #define D_PARSE 0x00000200 // Command parsing |
| #define D_BM 0x00000400 // Boot manager |
| #define D_BLKIO 0x00001000 // BlkIo Driver |
| #define D_BLKIO_ULTRA 0x00002000 // BlkIo Driver |
| #define D_NET 0x00004000 // SNI Driver |
| #define D_NET_ULTRA 0x00008000 // SNI Driver |
| #define D_TXTIN 0x00010000 // Simple Input Driver |
| #define D_TXTOUT 0x00020000 // Simple Text Output Driver |
| #define D_ERROR_ATA 0x00040000 // ATA error messages |
| #define D_ERROR 0x80000000 // Error |
| #define D_RESERVED 0x7fffC880 // Bits not reserved above |
| // |
| // Current Debug level of the system, value of EFIDebug |
| // |
| //#define EFI_DBUG_MASK (D_ERROR | D_WARN | D_LOAD | D_BLKIO | D_INIT) |
| #define EFI_DBUG_MASK (D_ERROR) |
| // |
| // |
| // |
| #if EFI_DEBUG |
| #define ASSERT(a) if(!(a)) DBGASSERT(a) |
| #define ASSERT_LOCKED(l) if(!(l)->Lock) DBGASSERT(l not locked) |
| #define ASSERT_STRUCT(p,t) DBGASSERT(t not structure), p |
| #else |
| #define ASSERT(a) |
| #define ASSERT_LOCKED(l) |
| #define ASSERT_STRUCT(p,t) |
| #endif |
| // |
| // Prototypes |
| // |
| INTN |
| DbgAssert ( |
| CHAR8 *file, |
| INTN lineno, |
| CHAR8 *string |
| ); |
| INTN |
| DbgPrint ( |
| INTN mask, |
| CHAR8 *format, |
| ... |
| ); |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/protocol/intload.h |
|---|
| 0,0 → 1,27 |
| /*++ |
| Copyright (c) 1999 Intel Corporation |
| Module Name: |
| intload |
| Abstract: |
| EFI support for loading internally linked in apps |
| Revision History |
| --*/ |
| #ifndef _INTERNAL_LOAD_INCLUDE_ |
| #define _INTERNAL_LOAD_INCLUDE_ |
| // {D65A6B8C-71E5-4df0-A909-F0D2992B5AA9} |
| #define INTERNAL_SHELL_GUID \ |
| { 0xd65a6b8c, 0x71e5, 0x4df0, {0xa9, 0x09, 0xf0, 0xd2, 0x99, 0x2b, 0x5a, 0xa9} } |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/protocol/efivar.h |
|---|
| 0,0 → 1,133 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| Abstract: |
| Revision History |
| --*/ |
| // |
| // The variable store protocol interface is specific to the reference |
| // implementation. The initialization code adds variable store devices |
| // to the system, and the FW connects to the devices to provide the |
| // variable store interfaces through these devices. |
| // |
| // |
| // Variable Store Device protocol |
| // |
| #define VARIABLE_STORE_PROTOCOL \ |
| { 0xf088cd91, 0xa046, 0x11d2, {0x8e, 0x42, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } |
| INTERFACE_DECL(_EFI_VARIABLE_STORE); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_STORE_CLEAR) ( |
| IN struct _EFI_VARIABLE_STORE *This, |
| IN UINTN BankNo, |
| IN OUT VOID *Scratch |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_STORE_READ) ( |
| IN struct _EFI_VARIABLE_STORE *This, |
| IN UINTN BankNo, |
| IN UINTN Offset, |
| IN UINTN BufferSize, |
| OUT VOID *Buffer |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_STORE_UPDATE) ( |
| IN struct _EFI_VARIABLE_STORE *This, |
| IN UINTN BankNo, |
| IN UINTN Offset, |
| IN UINTN BufferSize, |
| IN VOID *Buffer |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_STORE_SIZE) ( |
| IN struct _EFI_VARIABLE_STORE *This, |
| IN UINTN NoBanks |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_TRANSACTION_UPDATE) ( |
| IN struct _EFI_VARIABLE_STORE *This, |
| IN UINTN BankNo, |
| IN VOID *NewContents |
| ); |
| typedef struct _EFI_VARIABLE_STORE { |
| // |
| // Number of banks and bank size |
| // |
| UINT32 Attributes; |
| UINT32 BankSize; |
| UINT32 NoBanks; |
| // |
| // Functions to access the storage banks |
| // |
| EFI_STORE_CLEAR ClearStore; |
| EFI_STORE_READ ReadStore; |
| EFI_STORE_UPDATE UpdateStore; |
| EFI_STORE_SIZE SizeStore OPTIONAL; |
| EFI_TRANSACTION_UPDATE TransactionUpdate OPTIONAL; |
| } EFI_VARIABLE_STORE; |
| // |
| // |
| // ClearStore() - A function to clear the requested storage bank. A cleared |
| // bank contains all "on" bits. |
| // |
| // ReadStore() - Read data from the requested store. |
| // |
| // UpdateStore() - Updates data on the requested store. The FW will only |
| // ever issue updates to clear bits in the store. Updates must be |
| // performed in LSb to MSb order of the update buffer. |
| // |
| // SizeStore() - An optional function for non-runtime stores that can be |
| // dynamically sized. The FW will only ever increase or decrease the store |
| // by 1 banksize at a time, and it is always adding or removing a bank from |
| // the end of the store. |
| // |
| // By default the FW will update variables and storage banks in an |
| // "atomic" manner by keeping 1 old copy of the data during an update, |
| // and recovering appropiately if the power is lost during the middle |
| // of an operation. To do this the FW needs to have multiple banks |
| // of storage dedicated to its use. If that's not possible, the driver |
| // can implement an atomic bank update function and the FW will allow |
| // 1 bank in this case. (It will allow any number of banks, |
| // but it won't require an "extra" bank to provide its bank transaction |
| // function). |
| // |
| // TransactionUpdate() - An optional function that can clear & update an |
| // entire bank in an "atomic" fashion. If the operation fails in the |
| // middle the driver is responsible for having either the previous copy |
| // of the bank's data or the new copy. A copy that's partially written |
| // is not valid as internal data settings may get lost. Supply this |
| // function only when needed. |
| // |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/protocol/ia64/eficontext.h |
|---|
| 0,0 → 1,208 |
| /* |
| * Copyright (c) 1999, 2000 |
| * Intel Corporation. |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. 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. |
| * |
| * 3. All advertising materials mentioning features or use of this software |
| * must display the following acknowledgement: |
| * |
| * This product includes software developed by Intel Corporation and |
| * its contributors. |
| * |
| * 4. Neither the name of Intel Corporation or its contributors may be |
| * used to endorse or promote products derived from this software |
| * without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY INTEL CORPORATION AND CONTRIBUTORS ``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 INTEL CORPORATION OR CONTRIBUTORS 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 _EFICONTEXT_H_ |
| #define _EFICONTEXT_H_ |
| // |
| // IA-64 processor exception types |
| // |
| #define EXCPT_ALT_DTLB 4 |
| #define EXCPT_DNESTED_TLB 5 |
| #define EXCPT_BREAKPOINT 11 |
| #define EXCPT_EXTERNAL_INTERRUPT 12 |
| #define EXCPT_GEN_EXCEPT 24 |
| #define EXCPT_NAT_CONSUMPTION 26 |
| #define EXCPT_DEBUG_EXCEPT 29 |
| #define EXCPT_UNALIGNED_ACCESS 30 |
| #define EXCPT_FP_FAULT 32 |
| #define EXCPT_FP_TRAP 33 |
| #define EXCPT_TAKEN_BRANCH 35 |
| #define EXCPT_SINGLE_STEP 36 |
| // |
| // IA-64 processor context definition - must be 512 byte aligned!!! |
| // |
| typedef |
| struct { |
| UINT64 reserved; // necessary to preserve alignment for the correct bits in UNAT and to insure F2 is 16 byte aligned... |
| UINT64 r1; |
| UINT64 r2; |
| UINT64 r3; |
| UINT64 r4; |
| UINT64 r5; |
| UINT64 r6; |
| UINT64 r7; |
| UINT64 r8; |
| UINT64 r9; |
| UINT64 r10; |
| UINT64 r11; |
| UINT64 r12; |
| UINT64 r13; |
| UINT64 r14; |
| UINT64 r15; |
| UINT64 r16; |
| UINT64 r17; |
| UINT64 r18; |
| UINT64 r19; |
| UINT64 r20; |
| UINT64 r21; |
| UINT64 r22; |
| UINT64 r23; |
| UINT64 r24; |
| UINT64 r25; |
| UINT64 r26; |
| UINT64 r27; |
| UINT64 r28; |
| UINT64 r29; |
| UINT64 r30; |
| UINT64 r31; |
| UINT64 f2[2]; |
| UINT64 f3[2]; |
| UINT64 f4[2]; |
| UINT64 f5[2]; |
| UINT64 f6[2]; |
| UINT64 f7[2]; |
| UINT64 f8[2]; |
| UINT64 f9[2]; |
| UINT64 f10[2]; |
| UINT64 f11[2]; |
| UINT64 f12[2]; |
| UINT64 f13[2]; |
| UINT64 f14[2]; |
| UINT64 f15[2]; |
| UINT64 f16[2]; |
| UINT64 f17[2]; |
| UINT64 f18[2]; |
| UINT64 f19[2]; |
| UINT64 f20[2]; |
| UINT64 f21[2]; |
| UINT64 f22[2]; |
| UINT64 f23[2]; |
| UINT64 f24[2]; |
| UINT64 f25[2]; |
| UINT64 f26[2]; |
| UINT64 f27[2]; |
| UINT64 f28[2]; |
| UINT64 f29[2]; |
| UINT64 f30[2]; |
| UINT64 f31[2]; |
| UINT64 pr; |
| UINT64 b0; |
| UINT64 b1; |
| UINT64 b2; |
| UINT64 b3; |
| UINT64 b4; |
| UINT64 b5; |
| UINT64 b6; |
| UINT64 b7; |
| // application registers |
| UINT64 ar_rsc; |
| UINT64 ar_bsp; |
| UINT64 ar_bspstore; |
| UINT64 ar_rnat; |
| UINT64 ar_fcr; |
| UINT64 ar_eflag; |
| UINT64 ar_csd; |
| UINT64 ar_ssd; |
| UINT64 ar_cflg; |
| UINT64 ar_fsr; |
| UINT64 ar_fir; |
| UINT64 ar_fdr; |
| UINT64 ar_ccv; |
| UINT64 ar_unat; |
| UINT64 ar_fpsr; |
| UINT64 ar_pfs; |
| UINT64 ar_lc; |
| UINT64 ar_ec; |
| // control registers |
| UINT64 cr_dcr; |
| UINT64 cr_itm; |
| UINT64 cr_iva; |
| UINT64 cr_pta; |
| UINT64 cr_ipsr; |
| UINT64 cr_isr; |
| UINT64 cr_iip; |
| UINT64 cr_ifa; |
| UINT64 cr_itir; |
| UINT64 cr_iipa; |
| UINT64 cr_ifs; |
| UINT64 cr_iim; |
| UINT64 cr_iha; |
| // debug registers |
| UINT64 dbr0; |
| UINT64 dbr1; |
| UINT64 dbr2; |
| UINT64 dbr3; |
| UINT64 dbr4; |
| UINT64 dbr5; |
| UINT64 dbr6; |
| UINT64 dbr7; |
| UINT64 ibr0; |
| UINT64 ibr1; |
| UINT64 ibr2; |
| UINT64 ibr3; |
| UINT64 ibr4; |
| UINT64 ibr5; |
| UINT64 ibr6; |
| UINT64 ibr7; |
| // virtual registers |
| UINT64 int_nat; // nat bits for R1-R31 |
| } SYSTEM_CONTEXT; |
| #endif /* _EFI_CONTEXT_H_ */ |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/protocol/eficonsplit.h |
|---|
| 0,0 → 1,32 |
| #ifndef _EFI_CONFORK_H |
| #define _EFI_CONFORK_H |
| /*++ |
| Copyright (c) 1999 Intel Corporation |
| Module Name: |
| Abstract: |
| Revision History |
| --*/ |
| // |
| // ConOut Forker Protocol |
| // |
| #define TEXT_OUT_SPLITER_PROTOCOL \ |
| { 0x56d830a0, 0x7e7a, 0x11d3, {0xbb, 0xa0, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } |
| #define ERROR_OUT_SPLITER_PROTOCOL \ |
| { 0xf0ba9039, 0x68f1, 0x425e, {0xaa, 0x7f, 0xd9, 0xaa, 0xf9, 0x1b, 0x82, 0xa1}} |
| #define TEXT_IN_SPLITER_PROTOCOL \ |
| { 0xf9a3c550, 0x7fb5, 0x11d3, {0xbb, 0xa0, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/protocol/efidbg.h |
|---|
| 0,0 → 1,210 |
| /* |
| * Copyright (c) 1999, 2000 |
| * Intel Corporation. |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. 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. |
| * |
| * 3. All advertising materials mentioning features or use of this software |
| * must display the following acknowledgement: |
| * |
| * This product includes software developed by Intel Corporation and |
| * its contributors. |
| * |
| * 4. Neither the name of Intel Corporation or its contributors may be |
| * used to endorse or promote products derived from this software |
| * without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY INTEL CORPORATION AND CONTRIBUTORS ``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 INTEL CORPORATION OR CONTRIBUTORS 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 _EFIDBG_H_ |
| #define _EFIDBG_H_ |
| #include "eficontext.h" |
| #include "efiser.h" |
| typedef struct _DEBUGPORT_16550_CONFIG_DATA { |
| UINT32 PortAddress; |
| UINT64 BaudRate; |
| UINT32 ReceiveFifoDepth; |
| UINT32 Timeout; |
| UINT8 Parity; |
| UINT8 DataBits; |
| UINT8 StopBits; |
| UINT32 ControlMask; |
| BOOLEAN RtsCtsEnable; // RTS, CTS control |
| } DEBUGPORT_16550_CONFIG_DATA; |
| typedef struct _DEBUGPORT_16550_DEVICE_PATH { |
| EFI_DEVICE_PATH Header; |
| DEBUGPORT_16550_CONFIG_DATA ConfigData; |
| } DEBUGPORT_16550_DEVICE_PATH; |
| typedef union { |
| EFI_DEVICE_PATH DevPath; |
| DEBUGPORT_16550_DEVICE_PATH Uart; |
| // add new types of debugport device paths to this union... |
| } DEBUGPORT_DEV_PATH; |
| // |
| // Debug Support protocol {2755590C-6F3C-42FA-9EA4-A3BA543CDA25} |
| // |
| #define DEBUG_SUPPORT_PROTOCOL \ |
| { 0x2755590C, 0x6F3C, 0x42fa, 0x9E, 0xA4, 0xA3, 0xBA, 0x54, 0x3C, 0xDA, 0x25 } |
| typedef UINTN EXCEPTION_TYPE; |
| typedef |
| VOID |
| (*EXCEPTION_HANDLER) ( |
| IN EXCEPTION_TYPE ExceptionType, |
| IN SYSTEM_CONTEXT *SystemContext |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_REGISTER_TIMER_TICK_CALLBACK) ( |
| IN struct _EFI_DEBUG_SUPPORT_INTERFACE *This, |
| IN EXCEPTION_HANDLER TimerTickCallback |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_REGISTER_EXCEPTION_HANDLER) ( |
| IN struct _EFI_DEBUG_SUPPORT_INTERFACE *This, |
| IN EXCEPTION_HANDLER ExceptionHandler, |
| IN EXCEPTION_TYPE ExceptionType |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_IP_CALL_TRACE) ( |
| IN struct _EFI_DEBUG_SUPPORT_INTERFACE *This |
| ); |
| #define EFI_DEBUG_SUPPORT_INTERFACE_REVISION 0x00010000 |
| typedef struct _EFI_DEBUG_SUPPORT_INTERFACE { |
| UINT32 Revision; |
| EFI_REGISTER_TIMER_TICK_CALLBACK RegisterTimerTickCallback; |
| EFI_REGISTER_EXCEPTION_HANDLER RegisterExceptionHandler; |
| EFI_IP_CALL_TRACE IpCallTrace; |
| } EFI_DEBUG_SUPPORT_INTERFACE; |
| // |
| // Debugport io protocol {EBA4E8D2-3858-41EC-A281-2647BA9660D0} |
| // |
| #define DEBUGPORT_IO_PROTOCOL \ |
| { 0XEBA4E8D2, 0X3858, 0X41EC, 0XA2, 0X81, 0X26, 0X47, 0XBA, 0X96, 0X60, 0XD0 } |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_DEBUGPORT_IO_RESET) ( |
| IN struct _EFI_DEBUGPORT_IO_INTERFACE *This |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_DEBUGPORT_IO_READ) ( |
| IN struct _EFI_DEBUGPORT_IO_INTERFACE *This, |
| IN OUT UINTN *BufferSize, |
| OUT VOID *Buffer |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_DEBUGPORT_IO_WRITE) ( |
| IN struct _EFI_DEBUGPORT_IO_INTERFACE *This, |
| IN OUT UINTN *BufferSize, |
| IN VOID *Buffer |
| ); |
| #define EFI_DEBUGPORT_IO_INTERFACE_REVISION 0x00010000 |
| typedef struct _EFI_DEBUGPORT_IO_INTERFACE { |
| UINT32 Revision; |
| EFI_DEBUGPORT_IO_READ Read; |
| EFI_DEBUGPORT_IO_WRITE Write; |
| EFI_DEBUGPORT_IO_RESET Reset; |
| } EFI_DEBUGPORT_IO_INTERFACE; |
| // |
| // Debugport UART16550 control protocol {628EA978-4C26-4605-BC02-A42A496917DD} |
| // |
| #define DEBUGPORT_UART16550_CONTROL_PROTOCOL \ |
| { 0X628EA978, 0X4C26, 0X4605, 0XBC, 0X2, 0XA4, 0X2A, 0X49, 0X69, 0X17, 0XDD } |
| // Note: The definitions for EFI_PARITY_TYPE, EFI_STOP_BITS_TYPE, and |
| // SERIAL_IO_MODE are included from efiser.h |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_UART16550_SET_ATTRIBUTES) ( |
| IN struct _EFI_DEBUGPORT_UART16550_CONTROL_INTERFACE *This, |
| IN UINT64 BaudRate, |
| IN UINT32 ReceiveFifoDepth, |
| IN UINT32 Timeout, |
| IN EFI_PARITY_TYPE Parity, |
| IN UINT8 DataBits, |
| IN EFI_STOP_BITS_TYPE StopBits |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_UART16550_SET_CONTROL_BITS) ( |
| IN struct _EFI_DEBUGPORT_UART16550_CONTROL_INTERFACE *This, |
| IN UINT32 Control |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_UART16550_GET_CONTROL_BITS) ( |
| IN struct _EFI_DEBUGPORT_UART16550_CONTROL_INTERFACE *This, |
| OUT UINT32 *Control |
| ); |
| #define EFI_DEBUGPORT_UART16550_CONTROL_INTERFACE_REVISION 0x00010000 |
| typedef struct _EFI_DEBUGPORT_UART16550_CONTROL_INTERFACE { |
| UINT32 Revision; |
| EFI_UART16550_SET_ATTRIBUTES SetAttributes; |
| EFI_UART16550_SET_CONTROL_BITS SetControl; |
| EFI_UART16550_GET_CONTROL_BITS GetControl; |
| DEBUGPORT_16550_CONFIG_DATA *Mode; |
| } EFI_DEBUGPORT_UART16550_CONTROL_INTERFACE; |
| #define DEVICE_PATH_DEBUGPORT DEBUGPORT_IO_PROTOCOL |
| #endif /* _EFIDBG_H_ */ |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/protocol/piflash64.h |
|---|
| 0,0 → 1,121 |
| #ifndef _PIFLASH64_H |
| #define _PIFLASH64_H |
| /*++ |
| Copyright (c) 1999 Intel Corporation |
| Module Name: |
| PIflash64.h |
| Abstract: |
| Iflash64.efi protocol to abstract iflash from |
| the system. |
| Revision History |
| --*/ |
| // |
| // Guid that identifies the IFLASH protocol |
| // |
| #define IFLASH64_PROTOCOL_PROTOCOL \ |
| { 0x65cba110, 0x74ab, 0x11d3, 0xbb, 0x89, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 }; |
| // |
| // Unlock FLASH from StartAddress to EndAddress and return a LockKey |
| // |
| typedef |
| EFI_STATUS |
| (EFIAPI *UNLOCK_FLASH_API)( |
| IN struct _IFLASH64_PROTOCOL_INTERFACE *This |
| ); |
| // |
| // Lock the flash represented by the LockKey |
| // |
| typedef |
| EFI_STATUS |
| (EFIAPI *LOCK_FLASH_API)( |
| IN struct _IFLASH64_PROTOCOL_INTERFACE *This |
| ); |
| // |
| // Status callback for a utility like IFLASH64 |
| // |
| // Token would map to a list like Ted proposed. The utility has no idea what |
| // happens on the other side. |
| // ErrorStatus - Level of Error or success. Independent of Token. If you |
| // don't know the token you will at least know pass or fail. |
| // String - Optional extra information about the error. Could be used for |
| // debug or future expansion |
| // |
| // Attributes - Options screen attributes for String. Could allow the string to be different colors. |
| // |
| typedef |
| EFI_STATUS |
| (EFIAPI *UTILITY_PROGRESS_API)( |
| IN struct _IFLASH64_PROTOCOL_INTERFACE *This, |
| IN UINTN Token, |
| IN EFI_STATUS ErrorStatus, |
| IN CHAR16 *String, OPTIONAL |
| IN UINTN *Attributes OPTIONAL |
| ); |
| // |
| // Token Values |
| // |
| // IFlash64 Token Codes |
| #define IFLASH_TOKEN_IFLASHSTART 0xB0 // IFlash64 has started |
| #define IFLASH_TOKEN_READINGFILE 0xB1 // Reading File |
| #define IFLASH_TOKEN_INITVPP 0xB2 // Initializing Vpp |
| #define IFLASH_TOKEN_DISABLEVPP 0x10 // Disable Vpp |
| #define IFLASH_TOKEN_FLASHUNLOCK 0xB3 // Unlocking FLASH Devices |
| #define IFLASH_TOKEN_FLASHERASE 0xB4 // Erasing FLASH Devices |
| #define IFLASH_TOKEN_FLASHPROGRAM 0xB5 // Programming FLASH |
| #define IFLASH_TOKEN_FLASHVERIFY 0xB6 // Verifying FLASH |
| #define IFLASH_TOKEN_UPDATESUCCES 0xB7 // FLASH Updage Success! |
| #define IFLASH_TOKEN_PROGRESS_READINGFILE 0x11 // % Reading File |
| #define IFLASH_TOKEN_PROGRESS_FLASHUNLOCK 0x13 // % Unlocking FLASH Devices |
| #define IFLASH_TOKEN_PROGRESS_FLASHERASE 0x14 // % Erasing FLASH Devices |
| #define IFLASH_TOKEN_PROGRESS_FLASHPROGRAM 0x15 // % Programming FLASH |
| #define IFLASH_TOKEN_PROGRESS_FLASHVERIFY 0x16 // % Verifying FLASH |
| #define IFLASH_TOKEN_READINGFILE_ER 0xB8 // File Read Error |
| #define IFLASH_TOKEN_INITVPP_ER 0xB9 // Initialization of IFB Error |
| #define IFLASH_TOKEN_FLASHUNLOCK_ER 0xBA // FLASH Unlock Error |
| #define IFLASH_TOKEN_FLASHERASE_ER 0xBB // FLASH Erase Error |
| #define IFLASH_TOKEN_FLASHVERIFY_ER 0xBC // FLASH Verify Error |
| #define IFLASH_TOKEN_FLASHPROG_ER 0xBD // FLASH Program Error |
| #define IFLASH_TABLE_END 0x00 |
| // |
| // If this number changes one of the existing API's has changes |
| // |
| #define IFLASH_PI_MAJOR_VERSION 0x01 |
| // |
| // This number changes when new APIs or data variables get added to the end |
| // of the data structure |
| // |
| #define IFLASH_PI_MINOR_VERSION 0x01 |
| typedef struct _IFLASH64_PROTOCOL_INTERFACE { |
| UINT32 MajorVersion; |
| UINT32 MinorVersion; |
| UNLOCK_FLASH_API UnlockFlash; |
| LOCK_FLASH_API LockFlash; |
| UTILITY_PROGRESS_API Progress; |
| // |
| // Future expansion goes here |
| // |
| } IFLASH64_PROTOCOL_INTERFACE; |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/protocol/make.inf |
|---|
| 0,0 → 1,13 |
| # |
| # |
| # |
| [sources] |
| efivar.h |
| legacyboot.h |
| VgaClass.h |
| intload.h |
| [ia32sources] |
| [ia64sources] |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/protocol/makefile.hdr |
|---|
| 0,0 → 1,29 |
| # |
| # This is a machine generated file - DO NOT EDIT |
| # Generated by genmake.exe |
| # Generated from make.inf |
| # Copyright (c) 1998 Intel Corporation |
| # |
| INC_DEPS = $(INC_DEPS) \ |
| $(SDK_INSTALL_DIR)\include\efi\protocol\efivar.h \ |
| $(SDK_INSTALL_DIR)\include\efi\protocol\legacyboot.h \ |
| $(SDK_INSTALL_DIR)\include\efi\protocol\vgaclass.h \ |
| $(SDK_INSTALL_DIR)\include\efi\protocol\efidbg.h \ |
| !IF "$(PROCESSOR)" == "Ia32" |
| INC_DEPS = $(INC_DEPS) \ |
| !ENDIF |
| !IF "$(PROCESSOR)" == "Ia64" |
| INC_DEPS = $(INC_DEPS) \ |
| $(SDK_INSTALL_DIR)\include\efi\protocol\$(PROCESSOR)\eficontext.h \ |
| !ENDIF |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/protocol/vgaclass.h |
|---|
| 0,0 → 1,95 |
| #ifndef _VGA_CLASS_H |
| #define _VGA_CLASS_H |
| /*++ |
| Copyright (c) 1999 Intel Corporation |
| Module Name: |
| VgaClass.h |
| Abstract: |
| Vga Mini port binding to Vga Class protocol |
| Revision History |
| --*/ |
| // |
| // VGA Device Structure |
| // |
| // {0E3D6310-6FE4-11d3-BB81-0080C73C8881} |
| #define VGA_CLASS_DRIVER_PROTOCOL \ |
| { 0xe3d6310, 0x6fe4, 0x11d3, {0xbb, 0x81, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81} } |
| typedef |
| EFI_STATUS |
| (* INIT_VGA_CARD) ( |
| IN UINTN VgaMode, |
| IN VOID *Context |
| ); |
| typedef struct { |
| UINTN MaxColumns; |
| UINTN MaxRows; |
| } MAX_CONSOLE_GEOMETRY; |
| #define VGA_CON_OUT_DEV_SIGNATURE EFI_SIGNATURE_32('c','v','g','a') |
| typedef struct { |
| UINTN Signature; |
| EFI_HANDLE Handle; |
| SIMPLE_TEXT_OUTPUT_INTERFACE ConOut; |
| SIMPLE_TEXT_OUTPUT_MODE ConOutMode; |
| EFI_DEVICE_PATH *DevicePath; |
| UINT8 *Buffer; |
| EFI_DEVICE_IO_INTERFACE *DeviceIo; |
| // |
| // Video Card Context |
| // |
| INIT_VGA_CARD InitVgaCard; |
| VOID *VgaCardContext; |
| MAX_CONSOLE_GEOMETRY *Geometry; |
| // |
| // Video buffer normally 0xb8000 |
| // |
| UINT64 VideoBuffer; |
| // |
| // Clear Screen & Default Attribute |
| // |
| UINT32 Attribute; |
| // |
| // -1 means search for active VGA device |
| // |
| EFI_PCI_ADDRESS_UNION Pci; |
| } VGA_CON_OUT_DEV; |
| #define VGA_CON_OUT_DEV_FROM_THIS(a) CR(a, VGA_CON_OUT_DEV, ConOut, VGA_CON_OUT_DEV_SIGNATURE) |
| // |
| // Vga Class Driver Protocol. |
| // GUID defined in EFI Lib |
| // |
| typedef |
| EFI_STATUS |
| (EFIAPI *INSTALL_VGA_DRIVER) ( |
| IN VGA_CON_OUT_DEV *ConOutDev |
| ); |
| typedef struct { |
| UINT32 Version; |
| INSTALL_VGA_DRIVER InstallGenericVgaDriver; |
| } INSTALL_VGA_DRIVER_INTERFACE; |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/protocol/readme.txt |
|---|
| 0,0 → 1,3 |
| The protocol directory contains non Architectural |
| Protocols that span the FW, Platform, or application |
| space. |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/protocol/adapterdebug.h |
|---|
| 0,0 → 1,32 |
| #ifndef _ADAPTER_DEBUG_H |
| #define _ADAPTER_DEBUG_H |
| /*++ |
| Copyright (c) 1999 Intel Corporation |
| Module Name: |
| AdapterDebug.h |
| Abstract: |
| Protocol to debug the EDD 3.0 enablement of BIOS option ROMs |
| Revision History |
| --*/ |
| // {82F86881-282B-11d4-BC7D-0080C73C8881} |
| #define ADAPTER_DEBUG_PROTOCOL \ |
| { 0x82f86881, 0x282b, 0x11d4, {0xbc, 0x7d, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81} } |
| // |
| // This protocol points to the BIOS_LEGACY_DRIVE data structure |
| // see edd.h for more details |
| // |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/protocol/legacyboot.h |
|---|
| 0,0 → 1,119 |
| /*++ |
| Copyright (c) 1999 Intel Corporation |
| Module Name: |
| legacyboot |
| Abstract: |
| EFI support for legacy boot |
| Revision History |
| --*/ |
| #ifndef _LEGACY_BOOT_INCLUDE_ |
| #define _LEGACY_BOOT_INCLUDE_ |
| #define LEGACY_BOOT_PROTOCOL \ |
| { 0x376e5eb2, 0x30e4, 0x11d3, { 0xba, 0xe5, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } } |
| #pragma pack(1) |
| // |
| // BBS 1.01 (See Appendix A) IPL and BCV Table Entry Data structure. |
| // Seg:Off pointers have been converted to EFI pointers in this data structure |
| // This is the structure that also maps to the EFI device path for the boot selection |
| // |
| typedef struct { |
| UINT16 DeviceType; |
| UINT16 StatusFlag; |
| UINT32 Reserved; |
| VOID *BootHandler; // Not an EFI entry point |
| CHAR8 *DescString; |
| } BBS_TABLE_ENTRY; |
| #pragma pack() |
| typedef |
| EFI_STATUS |
| (EFIAPI *LEGACY_BOOT_CALL) ( |
| IN EFI_DEVICE_PATH *DevicePath |
| ); |
| // |
| // BBS support functions |
| // PnP Call numbers and BiosSelector hidden in implementation |
| // |
| typedef enum { |
| IplRelative, |
| BcvRelative |
| } BBS_TYPE; |
| INTERFACE_DECL(_LEGACY_BOOT_INTERFACE); |
| // |
| // == PnP Function 0x60 then BbsVersion == 0x0101 if this call fails then BbsVersion == 0x0000 |
| // |
| // |
| // == PnP Function 0x61 |
| // |
| typedef |
| EFI_STATUS |
| (EFIAPI *GET_DEVICE_COUNT) ( |
| IN struct _LEGACY_BOOT_INTERFACE *This, |
| IN BBS_TYPE *TableType, |
| OUT UINTN *DeviceCount, |
| OUT UINTN *MaxCount |
| ); |
| // |
| // == PnP Function 0x62 |
| // |
| typedef |
| EFI_STATUS |
| (EFIAPI *GET_PRIORITY_AND_TABLE) ( |
| IN struct _LEGACY_BOOT_INTERFACE *This, |
| IN BBS_TYPE *TableType, |
| IN OUT UINTN *PrioritySize, // MaxCount * sizeof(UINT8) |
| OUT UINTN *Priority, |
| IN OUT UINTN *TableSize, // MaxCount * sizeof(BBS_TABLE_ENTRY) |
| OUT BBS_TABLE_ENTRY *TableEntrySize |
| ); |
| // |
| // == PnP Function 0x63 |
| // |
| typedef |
| EFI_STATUS |
| (EFIAPI *SET_PRIORITY) ( |
| IN struct _LEGACY_BOOT_INTERFACE *This, |
| IN BBS_TYPE *TableType, |
| IN OUT UINTN *PrioritySize, |
| OUT UINTN *Priority |
| ); |
| typedef struct _LEGACY_BOOT_INTERFACE { |
| LEGACY_BOOT_CALL BootIt; |
| // |
| // New functions to allow BBS booting to be configured from EFI |
| // |
| UINTN BbsVersion; // Currently 0x0101 |
| GET_DEVICE_COUNT GetDeviceCount; |
| GET_PRIORITY_AND_TABLE GetPriorityAndTable; |
| SET_PRIORITY SetPriority; |
| } LEGACY_BOOT_INTERFACE; |
| EFI_STATUS |
| PlInitializeLegacyBoot ( |
| VOID |
| ); |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/efierr.h |
|---|
| 0,0 → 1,60 |
| #ifndef _EFI_ERR_H |
| #define _EFI_ERR_H |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| efierr.h |
| Abstract: |
| EFI error codes |
| Revision History |
| --*/ |
| #define EFIWARN(a) (a) |
| #define EFI_ERROR(a) (((INTN) a) < 0) |
| #define EFI_SUCCESS 0 |
| #define EFI_LOAD_ERROR EFIERR(1) |
| #define EFI_INVALID_PARAMETER EFIERR(2) |
| #define EFI_UNSUPPORTED EFIERR(3) |
| #define EFI_BAD_BUFFER_SIZE EFIERR(4) |
| #define EFI_BUFFER_TOO_SMALL EFIERR(5) |
| #define EFI_NOT_READY EFIERR(6) |
| #define EFI_DEVICE_ERROR EFIERR(7) |
| #define EFI_WRITE_PROTECTED EFIERR(8) |
| #define EFI_OUT_OF_RESOURCES EFIERR(9) |
| #define EFI_VOLUME_CORRUPTED EFIERR(10) |
| #define EFI_VOLUME_FULL EFIERR(11) |
| #define EFI_NO_MEDIA EFIERR(12) |
| #define EFI_MEDIA_CHANGED EFIERR(13) |
| #define EFI_NOT_FOUND EFIERR(14) |
| #define EFI_ACCESS_DENIED EFIERR(15) |
| #define EFI_NO_RESPONSE EFIERR(16) |
| #define EFI_NO_MAPPING EFIERR(17) |
| #define EFI_TIMEOUT EFIERR(18) |
| #define EFI_NOT_STARTED EFIERR(19) |
| #define EFI_ALREADY_STARTED EFIERR(20) |
| #define EFI_ABORTED EFIERR(21) |
| #define EFI_ICMP_ERROR EFIERR(22) |
| #define EFI_TFTP_ERROR EFIERR(23) |
| #define EFI_PROTOCOL_ERROR EFIERR(24) |
| #define EFI_WARN_UNKOWN_GLYPH EFIWARN(1) |
| #define EFI_WARN_DELETE_FAILURE EFIWARN(2) |
| #define EFI_WARN_WRITE_FAILURE EFIWARN(3) |
| #define EFI_WARN_BUFFER_TOO_SMALL EFIWARN(4) |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/efiser.h |
|---|
| 0,0 → 1,132 |
| #ifndef _EFI_SER_H |
| #define _EFI_SER_H |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| efiser.h |
| Abstract: |
| EFI serial protocol |
| Revision History |
| --*/ |
| // |
| // Serial protocol |
| // |
| #define SERIAL_IO_PROTOCOL \ |
| { 0xBB25CF6F, 0xF1D4, 0x11D2, {0x9A, 0x0C, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0xFD} } |
| INTERFACE_DECL(_SERIAL_IO_INTERFACE); |
| typedef enum { |
| DefaultParity, |
| NoParity, |
| EvenParity, |
| OddParity, |
| MarkParity, |
| SpaceParity |
| } EFI_PARITY_TYPE; |
| typedef enum { |
| DefaultStopBits, |
| OneStopBit, // 1 stop bit |
| OneFiveStopBits, // 1.5 stop bits |
| TwoStopBits // 2 stop bits |
| } EFI_STOP_BITS_TYPE; |
| #define EFI_SERIAL_CLEAR_TO_SEND 0x0010 // RO |
| #define EFI_SERIAL_DATA_SET_READY 0x0020 // RO |
| #define EFI_SERIAL_RING_INDICATE 0x0040 // RO |
| #define EFI_SERIAL_CARRIER_DETECT 0x0080 // RO |
| #define EFI_SERIAL_REQUEST_TO_SEND 0x0002 // WO |
| #define EFI_SERIAL_DATA_TERMINAL_READY 0x0001 // WO |
| #define EFI_SERIAL_INPUT_BUFFER_EMPTY 0x0100 // RO |
| #define EFI_SERIAL_OUTPUT_BUFFER_EMPTY 0x0200 // RO |
| #define EFI_SERIAL_HARDWARE_LOOPBACK_ENABLE 0x1000 // RW |
| #define EFI_SERIAL_SOFTWARE_LOOPBACK_ENABLE 0x2000 // RW |
| #define EFI_SERIAL_HARDWARE_FLOW_CONTROL_ENABLE 0x4000 // RW |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_SERIAL_RESET) ( |
| IN struct _SERIAL_IO_INTERFACE *This |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_SERIAL_SET_ATTRIBUTES) ( |
| IN struct _SERIAL_IO_INTERFACE *This, |
| IN UINT64 BaudRate, |
| IN UINT32 ReceiveFifoDepth, |
| IN UINT32 Timeout, |
| IN EFI_PARITY_TYPE Parity, |
| IN UINT8 DataBits, |
| IN EFI_STOP_BITS_TYPE StopBits |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_SERIAL_SET_CONTROL_BITS) ( |
| IN struct _SERIAL_IO_INTERFACE *This, |
| IN UINT32 Control |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_SERIAL_GET_CONTROL_BITS) ( |
| IN struct _SERIAL_IO_INTERFACE *This, |
| OUT UINT32 *Control |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_SERIAL_WRITE) ( |
| IN struct _SERIAL_IO_INTERFACE *This, |
| IN OUT UINTN *BufferSize, |
| IN VOID *Buffer |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_SERIAL_READ) ( |
| IN struct _SERIAL_IO_INTERFACE *This, |
| IN OUT UINTN *BufferSize, |
| OUT VOID *Buffer |
| ); |
| typedef struct { |
| UINT32 ControlMask; |
| // current Attributes |
| UINT32 Timeout; |
| UINT64 BaudRate; |
| UINT32 ReceiveFifoDepth; |
| UINT32 DataBits; |
| UINT32 Parity; |
| UINT32 StopBits; |
| } SERIAL_IO_MODE; |
| #define SERIAL_IO_INTERFACE_REVISION 0x00010000 |
| typedef struct _SERIAL_IO_INTERFACE { |
| UINT32 Revision; |
| EFI_SERIAL_RESET Reset; |
| EFI_SERIAL_SET_ATTRIBUTES SetAttributes; |
| EFI_SERIAL_SET_CONTROL_BITS SetControl; |
| EFI_SERIAL_GET_CONTROL_BITS GetControl; |
| EFI_SERIAL_WRITE Write; |
| EFI_SERIAL_READ Read; |
| SERIAL_IO_MODE *Mode; |
| } SERIAL_IO_INTERFACE; |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/ia64/efilibplat.h |
|---|
| 0,0 → 1,80 |
| #ifndef _EFI_LIB_PLAT_H |
| #define _EFI_LIB_PLAT_H |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| efilibplat.h |
| Abstract: |
| EFI to compile bindings |
| Revision History |
| --*/ |
| #include "salproc.h" |
| VOID |
| InitializeLibPlatform ( |
| IN EFI_HANDLE ImageHandle, |
| IN EFI_SYSTEM_TABLE *SystemTable |
| ); |
| VOID |
| LibInitSalAndPalProc( |
| OUT PLABEL *SalPlabel, |
| OUT UINT64 *PalEntry |
| ); |
| EFI_STATUS |
| LibGetSalIoPortMapping ( |
| OUT UINT64 *IoPortMapping |
| ); |
| EFI_STATUS |
| LibGetSalIpiBlock ( |
| OUT UINT64 *IpiBlock |
| ); |
| EFI_STATUS |
| LibGetSalWakeupVector ( |
| OUT UINT64 *WakeVector |
| ); |
| VOID * |
| LibSearchSalSystemTable ( |
| IN UINT8 EntryType |
| ); |
| VOID |
| LibSalProc ( |
| IN UINT64 Arg1, |
| IN UINT64 Arg2, |
| IN UINT64 Arg3, |
| IN UINT64 Arg4, |
| IN UINT64 Arg5, |
| IN UINT64 Arg6, |
| IN UINT64 Arg7, |
| IN UINT64 Arg8, |
| OUT rArg *Results OPTIONAL |
| ); |
| VOID |
| LibPalProc ( |
| IN UINT64 Arg1, |
| IN UINT64 Arg2, |
| IN UINT64 Arg3, |
| IN UINT64 Arg4, |
| OUT rArg *Results OPTIONAL |
| ); |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/ia64/efibind.h |
|---|
| 0,0 → 1,209 |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| efefind.h |
| Abstract: |
| EFI to compile bindings |
| Revision History |
| --*/ |
| #pragma pack() |
| // |
| // Basic int types of various widths |
| // |
| #if (__STDC_VERSION__ < 199901L ) |
| // No ANSI C 1999/2000 stdint.h integer width declarations |
| #if _MSC_EXTENSIONS |
| // Use Microsoft C compiler integer width declarations |
| typedef unsigned __int64 uint64_t; |
| typedef __int64 int64_t; |
| typedef unsigned __int32 uint32_t; |
| typedef __int32 int32_t; |
| typedef unsigned __int16 uint16_t; |
| typedef __int16 int16_t; |
| typedef unsigned __int8 uint8_t; |
| typedef __int8 int8_t; |
| #else |
| #ifdef UNIX_LP64 |
| // Use LP64 programming model from C_FLAGS for integer width declarations |
| typedef unsigned long uint64_t; |
| typedef long int64_t; |
| typedef unsigned int uint32_t; |
| typedef int int32_t; |
| typedef unsigned short uint16_t; |
| typedef short int16_t; |
| typedef unsigned char uint8_t; |
| typedef char int8_t; |
| #else |
| // Assume P64 programming model from C_FLAGS for integer width declarations |
| typedef unsigned long long uint64_t; |
| typedef long long int64_t; |
| typedef unsigned int uint32_t; |
| typedef int int32_t; |
| typedef unsigned short uint16_t; |
| typedef short int16_t; |
| typedef unsigned char uint8_t; |
| typedef char int8_t; |
| #endif |
| #endif |
| #endif |
| // |
| // Basic EFI types of various widths |
| // |
| #ifndef __WCHAR_TYPE__ |
| # define __WCHAR_TYPE__ short |
| #endif |
| typedef uint64_t UINT64; |
| typedef int64_t INT64; |
| typedef uint32_t UINT32; |
| typedef int32_t INT32; |
| typedef uint16_t UINT16; |
| typedef int16_t INT16; |
| typedef uint8_t UINT8; |
| typedef int8_t INT8; |
| typedef __WCHAR_TYPE__ WCHAR; |
| #undef VOID |
| #define VOID void |
| typedef int64_t INTN; |
| typedef uint64_t UINTN; |
| //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // BugBug: Code to debug |
| // |
| #define BIT63 0x8000000000000000 |
| #define PLATFORM_IOBASE_ADDRESS (0xffffc000000 | BIT63) |
| #define PORT_TO_MEMD(_Port) (PLATFORM_IOBASE_ADDRESS | ( ( ( (_Port) & 0xfffc) << 10 ) | ( (_Port) & 0x0fff) ) ) |
| // |
| // Macro's with casts make this much easier to use and read. |
| // |
| #define PORT_TO_MEM8D(_Port) (*(UINT8 *)(PORT_TO_MEMD(_Port))) |
| #define POST_CODE(_Data) (PORT_TO_MEM8D(0x80) = (_Data)) |
| // |
| // BugBug: End Debug Code!!! |
| //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| #define EFIERR(a) (0x8000000000000000 | a) |
| #define EFI_ERROR_MASK 0x8000000000000000 |
| #define EFIERR_OEM(a) (0xc000000000000000 | a) |
| #define BAD_POINTER 0xFBFBFBFBFBFBFBFB |
| #define MAX_ADDRESS 0xFFFFFFFFFFFFFFFF |
| #define BREAKPOINT() while (TRUE) |
| // |
| // Pointers must be aligned to these address to function |
| // you will get an alignment fault if this value is less than 8 |
| // |
| #define MIN_ALIGNMENT_SIZE 8 |
| #define ALIGN_VARIABLE(Value , Adjustment) \ |
| (UINTN) Adjustment = 0; \ |
| if((UINTN)Value % MIN_ALIGNMENT_SIZE) \ |
| (UINTN)Adjustment = MIN_ALIGNMENT_SIZE - ((UINTN)Value % MIN_ALIGNMENT_SIZE); \ |
| Value = (UINTN)Value + (UINTN)Adjustment |
| // |
| // Define macros to create data structure signatures. |
| // |
| #define EFI_SIGNATURE_16(A,B) ((A) | (B<<8)) |
| #define EFI_SIGNATURE_32(A,B,C,D) (EFI_SIGNATURE_16(A,B) | (EFI_SIGNATURE_16(C,D) << 16)) |
| #define EFI_SIGNATURE_64(A,B,C,D,E,F,G,H) (EFI_SIGNATURE_32(A,B,C,D) | ((UINT64)(EFI_SIGNATURE_32(E,F,G,H)) << 32)) |
| // |
| // To export & import functions in the EFI emulator environment |
| // |
| #define EXPORTAPI |
| // |
| // EFIAPI - prototype calling convention for EFI function pointers |
| // BOOTSERVICE - prototype for implementation of a boot service interface |
| // RUNTIMESERVICE - prototype for implementation of a runtime service interface |
| // RUNTIMEFUNCTION - prototype for implementation of a runtime function that is not a service |
| // RUNTIME_CODE - pragma macro for declaring runtime code |
| // |
| #ifndef EFIAPI // Forces EFI calling conventions reguardless of compiler options |
| #if _MSC_EXTENSIONS |
| #define EFIAPI __cdecl // Force C calling convention for Microsoft C compiler |
| #else |
| #define EFIAPI // Substitute expresion to force C calling convention |
| #endif |
| #endif |
| #define BOOTSERVICE |
| #define RUNTIMESERVICE |
| #define RUNTIMEFUNCTION |
| #define RUNTIME_CODE(a) alloc_text("rtcode", a) |
| #define BEGIN_RUNTIME_DATA() data_seg("rtdata") |
| #define END_RUNTIME_DATA() data_seg("") |
| #define VOLATILE volatile |
| // |
| // BugBug: Need to find out if this is portable accross compliers. |
| // |
| #ifdef __GNUC__ |
| #define MEMORY_FENCE() __asm__ __volatile__ ("mf.a" ::: "memory") |
| #else |
| void __mf (void); |
| #pragma intrinsic (__mf) |
| #define MEMORY_FENCE() __mf() |
| #endif |
| // |
| // When build similiar to FW, then link everything together as |
| // one big module. |
| // |
| #define EFI_DRIVER_ENTRY_POINT(InitFunction) |
| #define LOAD_INTERNAL_DRIVER(_if, type, name, entry) \ |
| (_if)->LoadInternal(type, name, entry) |
| // |
| // Some compilers don't support the forward reference construct: |
| // typedef struct XXXXX |
| // |
| // The following macro provide a workaround for such cases. |
| // |
| #ifdef NO_INTERFACE_DECL |
| #define INTERFACE_DECL(x) |
| #else |
| #ifdef __GNUC__ |
| #define INTERFACE_DECL(x) struct x |
| #else |
| #define INTERFACE_DECL(x) typedef struct x |
| #endif |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/ia64/salproc.h |
|---|
| 0,0 → 1,264 |
| #ifndef _SAL_PROC_H |
| #define _SAL_PROC_H |
| // |
| // |
| //Copyright (c) 1999 Intel Corporation |
| // |
| //Module Name: |
| // |
| // SalProc.h |
| // |
| //Abstract: |
| // |
| // Main SAL interface routins for IA-64 calls. |
| // |
| // |
| //Revision History |
| // |
| // |
| // return value that mimicks r8,r9,r10 & r11 registers |
| typedef struct { |
| UINT64 p0; |
| UINT64 p1; |
| UINT64 p2; |
| UINT64 p3; |
| } rArg; |
| #define SAL_PCI_CONFIG_READ 0x01000010 |
| #define SAL_PCI_CONFIG_WRITE 0x01000011 |
| typedef VOID (*PFN)(); |
| typedef rArg (*PFN_SAL_PROC)(UINT64,UINT64,UINT64,UINT64,UINT64,UINT64,UINT64,UINT64); |
| typedef rArg (*PFN_SAL_CALLBACK)(UINT64,UINT64,UINT64,UINT64,UINT64,UINT64,UINT64,UINT64); |
| typedef struct _PLABEL { |
| UINT64 ProcEntryPoint; |
| UINT64 GP; |
| } PLABEL; |
| typedef struct tagIA32_BIOS_REGISTER_STATE { |
| // general registers |
| UINT32 eax; |
| UINT32 ecx; |
| UINT32 edx; |
| UINT32 ebx; |
| // stack registers |
| UINT32 esp; |
| UINT32 ebp; |
| UINT32 esi; |
| UINT32 edi; |
| // eflags |
| UINT32 eflags; |
| // instruction pointer |
| UINT32 eip; |
| UINT16 cs; |
| UINT16 ds; |
| UINT16 es; |
| UINT16 fs; |
| UINT16 gs; |
| UINT16 ss; |
| // Reserved |
| UINT32 Reserved1; |
| UINT64 Reserved2; |
| } IA32_BIOS_REGISTER_STATE; |
| VOID EFIInitMsg(VOID); |
| EFI_STATUS |
| PlRegisterAndStartTimer( |
| IN UINTN Period |
| ); |
| EFI_STATUS |
| PlDeRegisterAndCancelTimer(VOID); |
| VOID |
| SalProc ( |
| IN UINT64 Arg1, |
| IN UINT64 Arg2, |
| IN UINT64 Arg3, |
| IN UINT64 Arg4, |
| IN UINT64 Arg5, |
| IN UINT64 Arg6, |
| IN UINT64 Arg7, |
| IN UINT64 Arg8, |
| OUT rArg *Results OPTIONAL |
| ); |
| VOID |
| SalCallBack ( |
| IN UINT64 Arg1, |
| IN UINT64 Arg2, |
| IN UINT64 Arg3, |
| IN UINT64 Arg4, |
| IN UINT64 Arg5, |
| IN UINT64 Arg6, |
| IN UINT64 Arg7, |
| IN UINT64 Arg8, |
| OUT rArg *Results OPTIONAL |
| ); |
| VOID |
| RUNTIMEFUNCTION |
| RtSalCallBack ( |
| IN UINT64 Arg1, |
| IN UINT64 Arg2, |
| IN UINT64 Arg3, |
| IN UINT64 Arg4, |
| IN UINT64 Arg5, |
| IN UINT64 Arg6, |
| IN UINT64 Arg7, |
| IN UINT64 Arg8, |
| OUT rArg *Results OPTIONAL |
| ); |
| extern PLABEL RtGlobalSalProcEntry; |
| extern PLABEL RtGlobalSALCallBack; |
| #pragma pack(1) |
| // |
| // SAL System Table |
| // |
| typedef struct { |
| UINT32 Signature; |
| UINT32 Length; |
| UINT16 Revision; |
| UINT16 EntryCount; |
| UINT8 CheckSum; |
| UINT8 Reserved[7]; |
| UINT16 SALA_Ver; |
| UINT16 SALB_Ver; |
| UINT8 OemId[32]; |
| UINT8 ProductID[32]; |
| UINT8 Reserved2[8]; |
| } SAL_SYSTEM_TABLE_HDR; |
| #define SAL_ST_ENTRY_POINT 0 |
| #define SAL_ST_MEMORY_DESCRIPTOR 1 |
| #define SAL_ST_PLATFORM_FEATURES 2 |
| #define SAL_ST_TR_USAGE 3 |
| #define SAL_ST_PTC 4 |
| #define SAL_ST_AP_WAKEUP 5 |
| typedef struct { |
| UINT8 Type; // Type == 0 |
| UINT8 Reserved[7]; |
| UINT64 PalProcEntry; |
| UINT64 SalProcEntry; |
| UINT64 GlobalDataPointer; |
| UINT64 Reserved2[2]; |
| } SAL_ST_ENTRY_POINT_DESCRIPTOR; |
| typedef struct { |
| UINT8 Type; // Type == 1 |
| UINT8 NeedVirtualRegistration; |
| UINT8 MemoryAttributes; |
| UINT8 PageAccessRights; |
| UINT8 SupportedAttributes; |
| UINT8 Reserved; |
| UINT16 MemoryType; |
| UINT64 PhysicalMemoryAddress; |
| UINT32 Length; |
| UINT32 Reserved1; |
| UINT64 OemReserved; |
| } SAL_ST_MEMORY_DESCRIPTOR_ENTRY; |
| // |
| // MemoryType info |
| // |
| #define SAL_SAPIC_IPI_BLOCK 0x0002 |
| #define SAL_IO_PORT_MAPPING 0x0003 |
| typedef struct { |
| UINT8 Type; // Type == 2 |
| UINT8 PlatformFeatures; |
| UINT8 Reserved[14]; |
| } SAL_ST_MEMORY_DECRIPTOR; |
| typedef struct { |
| UINT8 Type; // Type == 3 |
| UINT8 TRType; |
| UINT8 TRNumber; |
| UINT8 Reserved[5]; |
| UINT64 VirtualAddress; |
| UINT64 EncodedPageSize; |
| UINT64 Reserved1; |
| } SAL_ST_TR_DECRIPTOR; |
| typedef struct { |
| UINT64 NumberOfProcessors; |
| UINT64 LocalIDRegister; |
| } SAL_COHERENCE_DOMAIN_INFO; |
| typedef struct { |
| UINT8 Type; // Type == 4 |
| UINT8 Reserved[3]; |
| UINT32 NumberOfDomains; |
| SAL_COHERENCE_DOMAIN_INFO *DomainInformation; |
| } SAL_ST_CACHE_COHERENCE_DECRIPTOR; |
| typedef struct { |
| UINT8 Type; // Type == 5 |
| UINT8 WakeUpType; |
| UINT8 Reserved[6]; |
| UINT64 ExternalInterruptVector; |
| } SAL_ST_AP_WAKEUP_DECRIPTOR; |
| typedef struct { |
| SAL_SYSTEM_TABLE_HDR Header; |
| SAL_ST_ENTRY_POINT_DESCRIPTOR Entry0; |
| } SAL_SYSTEM_TABLE_ASCENDING_ORDER; |
| #define FIT_ENTRY_PTR (0x100000000 - 32) // 4GB - 24 |
| #define FIT_PALA_ENTRY (0x100000000 - 48) // 4GB - 32 |
| #define FIT_PALB_TYPE 01 |
| typedef struct { |
| UINT64 Address; |
| UINT8 Size[3]; |
| UINT8 Reserved; |
| UINT16 Revision; |
| UINT8 Type:7; |
| UINT8 CheckSumValid:1; |
| UINT8 CheckSum; |
| } FIT_ENTRY; |
| #pragma pack() |
| typedef |
| rArg |
| (*CALL_SAL_PROC)( |
| IN UINT64 Arg1, |
| IN UINT64 Arg2, |
| IN UINT64 Arg3, |
| IN UINT64 Arg4, |
| IN UINT64 Arg5, |
| IN UINT64 Arg6, |
| IN UINT64 Arg7, |
| IN UINT64 Arg8 |
| ); |
| typedef |
| rArg |
| (*CALL_PAL_PROC)( |
| IN UINT64 Arg1, |
| IN UINT64 Arg2, |
| IN UINT64 Arg3, |
| IN UINT64 Arg4 |
| ); |
| extern CALL_SAL_PROC GlobalSalProc; |
| extern CALL_PAL_PROC GlobalPalProc; |
| extern PLABEL SalProcPlabel; |
| extern PLABEL PalProcPlabel; |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/ia64/pe.h |
|---|
| 0,0 → 1,597 |
| /* |
| PE32+ header file |
| */ |
| #ifndef _PE_H |
| #define _PE_H |
| #define IMAGE_DOS_SIGNATURE 0x5A4D // MZ |
| #define IMAGE_OS2_SIGNATURE 0x454E // NE |
| #define IMAGE_OS2_SIGNATURE_LE 0x454C // LE |
| #define IMAGE_NT_SIGNATURE 0x00004550 // PE00 |
| #define IMAGE_EDOS_SIGNATURE 0x44454550 // PEED |
| /***************************************************************************** |
| * The following stuff comes from winnt.h from the ia64sdk, plus the Plabel for |
| * loading EM executables. |
| *****************************************************************************/ |
| // |
| // Intel IA64 specific |
| // |
| #define IMAGE_REL_BASED_IA64_IMM64 9 |
| #define IMAGE_REL_BASED_IA64_DIR64 10 |
| struct Plabel { |
| UINT64 EntryPoint; |
| UINT64 NewGP; |
| }; |
| typedef struct _IMAGE_DOS_HEADER { // DOS .EXE header |
| UINT16 e_magic; // Magic number |
| UINT16 e_cblp; // Bytes on last page of file |
| UINT16 e_cp; // Pages in file |
| UINT16 e_crlc; // Relocations |
| UINT16 e_cparhdr; // Size of header in paragraphs |
| UINT16 e_minalloc; // Minimum extra paragraphs needed |
| UINT16 e_maxalloc; // Maximum extra paragraphs needed |
| UINT16 e_ss; // Initial (relative) SS value |
| UINT16 e_sp; // Initial SP value |
| UINT16 e_csum; // Checksum |
| UINT16 e_ip; // Initial IP value |
| UINT16 e_cs; // Initial (relative) CS value |
| UINT16 e_lfarlc; // File address of relocation table |
| UINT16 e_ovno; // Overlay number |
| UINT16 e_res[4]; // Reserved words |
| UINT16 e_oemid; // OEM identifier (for e_oeminfo) |
| UINT16 e_oeminfo; // OEM information; e_oemid specific |
| UINT16 e_res2[10]; // Reserved words |
| UINT32 e_lfanew; // File address of new exe header |
| } IMAGE_DOS_HEADER, *PIMAGE_DOS_HEADER; |
| typedef struct _IMAGE_OS2_HEADER { // OS/2 .EXE header |
| UINT16 ne_magic; // Magic number |
| UINT8 ne_ver; // Version number |
| UINT8 ne_rev; // Revision number |
| UINT16 ne_enttab; // Offset of Entry Table |
| UINT16 ne_cbenttab; // Number of bytes in Entry Table |
| UINT32 ne_crc; // Checksum of whole file |
| UINT16 ne_flags; // Flag UINT16 |
| UINT16 ne_autodata; // Automatic data segment number |
| UINT16 ne_heap; // Initial heap allocation |
| UINT16 ne_stack; // Initial stack allocation |
| UINT32 ne_csip; // Initial CS:IP setting |
| UINT32 ne_sssp; // Initial SS:SP setting |
| UINT16 ne_cseg; // Count of file segments |
| UINT16 ne_cmod; // Entries in Module Reference Table |
| UINT16 ne_cbnrestab; // Size of non-resident name table |
| UINT16 ne_segtab; // Offset of Segment Table |
| UINT16 ne_rsrctab; // Offset of Resource Table |
| UINT16 ne_restab; // Offset of resident name table |
| UINT16 ne_modtab; // Offset of Module Reference Table |
| UINT16 ne_imptab; // Offset of Imported Names Table |
| UINT32 ne_nrestab; // Offset of Non-resident Names Table |
| UINT16 ne_cmovent; // Count of movable entries |
| UINT16 ne_align; // Segment alignment shift count |
| UINT16 ne_cres; // Count of resource segments |
| UINT8 ne_exetyp; // Target Operating system |
| UINT8 ne_flagsothers; // Other .EXE flags |
| UINT16 ne_pretthunks; // offset to return thunks |
| UINT16 ne_psegrefbytes; // offset to segment ref. bytes |
| UINT16 ne_swaparea; // Minimum code swap area size |
| UINT16 ne_expver; // Expected Windows version number |
| } IMAGE_OS2_HEADER, *PIMAGE_OS2_HEADER; |
| // |
| // File header format. |
| // |
| typedef struct _IMAGE_FILE_HEADER { |
| UINT16 Machine; |
| UINT16 NumberOfSections; |
| UINT32 TimeDateStamp; |
| UINT32 PointerToSymbolTable; |
| UINT32 NumberOfSymbols; |
| UINT16 SizeOfOptionalHeader; |
| UINT16 Characteristics; |
| } IMAGE_FILE_HEADER, *PIMAGE_FILE_HEADER; |
| #define IMAGE_SIZEOF_FILE_HEADER 20 |
| #define IMAGE_FILE_RELOCS_STRIPPED 0x0001 // Relocation info stripped from file. |
| #define IMAGE_FILE_EXECUTABLE_IMAGE 0x0002 // File is executable (i.e. no unresolved externel references). |
| #define IMAGE_FILE_LINE_NUMS_STRIPPED 0x0004 // Line nunbers stripped from file. |
| #define IMAGE_FILE_LOCAL_SYMS_STRIPPED 0x0008 // Local symbols stripped from file. |
| #define IMAGE_FILE_BYTES_REVERSED_LO 0x0080 // Bytes of machine word are reversed. |
| #define IMAGE_FILE_32BIT_MACHINE 0x0100 // 32 bit word machine. |
| #define IMAGE_FILE_DEBUG_STRIPPED 0x0200 // Debugging info stripped from file in .DBG file |
| #define IMAGE_FILE_SYSTEM 0x1000 // System File. |
| #define IMAGE_FILE_DLL 0x2000 // File is a DLL. |
| #define IMAGE_FILE_BYTES_REVERSED_HI 0x8000 // Bytes of machine word are reversed. |
| #define IMAGE_FILE_MACHINE_UNKNOWN 0 |
| #define IMAGE_FILE_MACHINE_I386 0x14c // Intel 386. |
| #define IMAGE_FILE_MACHINE_R3000 0x162 // MIPS little-endian, 0540 big-endian |
| #define IMAGE_FILE_MACHINE_R4000 0x166 // MIPS little-endian |
| #define IMAGE_FILE_MACHINE_ALPHA 0x184 // Alpha_AXP |
| #define IMAGE_FILE_MACHINE_POWERPC 0x1F0 // IBM PowerPC Little-Endian |
| #define IMAGE_FILE_MACHINE_TAHOE 0x7cc // Intel EM machine |
| // |
| // Directory format. |
| // |
| typedef struct _IMAGE_DATA_DIRECTORY { |
| UINT32 VirtualAddress; |
| UINT32 Size; |
| } IMAGE_DATA_DIRECTORY, *PIMAGE_DATA_DIRECTORY; |
| #define IMAGE_NUMBEROF_DIRECTORY_ENTRIES 16 |
| typedef struct _IMAGE_ROM_OPTIONAL_HEADER { |
| UINT16 Magic; |
| UINT8 MajorLinkerVersion; |
| UINT8 MinorLinkerVersion; |
| UINT32 SizeOfCode; |
| UINT32 SizeOfInitializedData; |
| UINT32 SizeOfUninitializedData; |
| UINT32 AddressOfEntryPoint; |
| UINT32 BaseOfCode; |
| UINT32 BaseOfData; |
| UINT32 BaseOfBss; |
| UINT32 GprMask; |
| UINT32 CprMask[4]; |
| UINT32 GpValue; |
| } IMAGE_ROM_OPTIONAL_HEADER, *PIMAGE_ROM_OPTIONAL_HEADER; |
| typedef struct _IMAGE_OPTIONAL_HEADER { |
| UINT16 Magic; |
| UINT8 MajorLinkerVersion; |
| UINT8 MinorLinkerVersion; |
| UINT32 SizeOfCode; |
| UINT32 SizeOfInitializedData; |
| UINT32 SizeOfUninitializedData; |
| UINT32 AddressOfEntryPoint; |
| UINT32 BaseOfCode; |
| // UINT32 BaseOfData; |
| UINT64 ImageBase; |
| UINT32 SectionAlignment; |
| UINT32 FileAlignment; |
| UINT16 MajorOperatingSystemVersion; |
| UINT16 MinorOperatingSystemVersion; |
| UINT16 MajorImageVersion; |
| UINT16 MinorImageVersion; |
| UINT16 MajorSubsystemVersion; |
| UINT16 MinorSubsystemVersion; |
| UINT32 Win32VersionValue; |
| UINT32 SizeOfImage; |
| UINT32 SizeOfHeaders; |
| UINT32 CheckSum; |
| UINT16 Subsystem; |
| UINT16 DllCharacteristics; |
| UINT64 SizeOfStackReserve; |
| UINT64 SizeOfStackCommit; |
| UINT64 SizeOfHeapReserve; |
| UINT64 SizeOfHeapCommit; |
| UINT32 LoaderFlags; |
| UINT32 NumberOfRvaAndSizes; |
| IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES]; |
| } IMAGE_OPTIONAL_HEADER, *PIMAGE_OPTIONAL_HEADER; |
| #define IMAGE_SIZEOF_ROM_OPTIONAL_HEADER 56 |
| #define IMAGE_SIZEOF_STD_OPTIONAL_HEADER 28 |
| #define IMAGE_SIZEOF_NT_OPTIONAL_HEADER 224 |
| #define IMAGE_SIZEOF_NT_OPTIONAL64_HEADER 244 |
| #define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b |
| #define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b |
| #define IMAGE_ROM_OPTIONAL_HDR_MAGIC 0x107 |
| typedef struct _IMAGE_NT_HEADERS { |
| UINT32 Signature; |
| IMAGE_FILE_HEADER FileHeader; |
| IMAGE_OPTIONAL_HEADER OptionalHeader; |
| } IMAGE_NT_HEADERS, *PIMAGE_NT_HEADERS; |
| typedef struct _IMAGE_ROM_HEADERS { |
| IMAGE_FILE_HEADER FileHeader; |
| IMAGE_ROM_OPTIONAL_HEADER OptionalHeader; |
| } IMAGE_ROM_HEADERS, *PIMAGE_ROM_HEADERS; |
| #define IMAGE_FIRST_SECTION( ntheader ) ((PIMAGE_SECTION_HEADER) \ |
| ((UINT32)ntheader + \ |
| FIELD_OFFSET( IMAGE_NT_HEADERS, OptionalHeader ) + \ |
| ((PIMAGE_NT_HEADERS)(ntheader))->FileHeader.SizeOfOptionalHeader \ |
| )) |
| // Subsystem Values |
| #define IMAGE_SUBSYSTEM_UNKNOWN 0 // Unknown subsystem. |
| #define IMAGE_SUBSYSTEM_NATIVE 1 // Image doesn't require a subsystem. |
| #define IMAGE_SUBSYSTEM_WINDOWS_GUI 2 // Image runs in the Windows GUI subsystem. |
| #define IMAGE_SUBSYSTEM_WINDOWS_CUI 3 // Image runs in the Windows character subsystem. |
| #define IMAGE_SUBSYSTEM_OS2_CUI 5 // image runs in the OS/2 character subsystem. |
| #define IMAGE_SUBSYSTEM_POSIX_CUI 7 // image run in the Posix character subsystem. |
| // Directory Entries |
| #define IMAGE_DIRECTORY_ENTRY_EXPORT 0 // Export Directory |
| #define IMAGE_DIRECTORY_ENTRY_IMPORT 1 // Import Directory |
| #define IMAGE_DIRECTORY_ENTRY_RESOURCE 2 // Resource Directory |
| #define IMAGE_DIRECTORY_ENTRY_EXCEPTION 3 // Exception Directory |
| #define IMAGE_DIRECTORY_ENTRY_SECURITY 4 // Security Directory |
| #define IMAGE_DIRECTORY_ENTRY_BASERELOC 5 // Base Relocation Table |
| #define IMAGE_DIRECTORY_ENTRY_DEBUG 6 // Debug Directory |
| #define IMAGE_DIRECTORY_ENTRY_COPYRIGHT 7 // Description String |
| #define IMAGE_DIRECTORY_ENTRY_GLOBALPTR 8 // Machine Value (MIPS GP) |
| #define IMAGE_DIRECTORY_ENTRY_TLS 9 // TLS Directory |
| #define IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG 10 // Load Configuration Directory |
| // |
| // Section header format. |
| // |
| #define IMAGE_SIZEOF_SHORT_NAME 8 |
| typedef struct _IMAGE_SECTION_HEADER { |
| UINT8 Name[IMAGE_SIZEOF_SHORT_NAME]; |
| union { |
| UINT32 PhysicalAddress; |
| UINT32 VirtualSize; |
| } Misc; |
| UINT32 VirtualAddress; |
| UINT32 SizeOfRawData; |
| UINT32 PointerToRawData; |
| UINT32 PointerToRelocations; |
| UINT32 PointerToLinenumbers; |
| UINT16 NumberOfRelocations; |
| UINT16 NumberOfLinenumbers; |
| UINT32 Characteristics; |
| } IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER; |
| #define IMAGE_SIZEOF_SECTION_HEADER 40 |
| #define IMAGE_SCN_TYPE_NO_PAD 0x00000008 // Reserved. |
| #define IMAGE_SCN_CNT_CODE 0x00000020 // Section contains code. |
| #define IMAGE_SCN_CNT_INITIALIZED_DATA 0x00000040 // Section contains initialized data. |
| #define IMAGE_SCN_CNT_UNINITIALIZED_DATA 0x00000080 // Section contains uninitialized data. |
| #define IMAGE_SCN_LNK_OTHER 0x00000100 // Reserved. |
| #define IMAGE_SCN_LNK_INFO 0x00000200 // Section contains comments or some other type of information. |
| #define IMAGE_SCN_LNK_REMOVE 0x00000800 // Section contents will not become part of image. |
| #define IMAGE_SCN_LNK_COMDAT 0x00001000 // Section contents comdat. |
| #define IMAGE_SCN_ALIGN_1BYTES 0x00100000 // |
| #define IMAGE_SCN_ALIGN_2BYTES 0x00200000 // |
| #define IMAGE_SCN_ALIGN_4BYTES 0x00300000 // |
| #define IMAGE_SCN_ALIGN_8BYTES 0x00400000 // |
| #define IMAGE_SCN_ALIGN_16BYTES 0x00500000 // Default alignment if no others are specified. |
| #define IMAGE_SCN_ALIGN_32BYTES 0x00600000 // |
| #define IMAGE_SCN_ALIGN_64BYTES 0x00700000 // |
| #define IMAGE_SCN_MEM_DISCARDABLE 0x02000000 // Section can be discarded. |
| #define IMAGE_SCN_MEM_NOT_CACHED 0x04000000 // Section is not cachable. |
| #define IMAGE_SCN_MEM_NOT_PAGED 0x08000000 // Section is not pageable. |
| #define IMAGE_SCN_MEM_SHARED 0x10000000 // Section is shareable. |
| #define IMAGE_SCN_MEM_EXECUTE 0x20000000 // Section is executable. |
| #define IMAGE_SCN_MEM_READ 0x40000000 // Section is readable. |
| #define IMAGE_SCN_MEM_WRITE 0x80000000 // Section is writeable. |
| // |
| // Symbol format. |
| // |
| #define IMAGE_SIZEOF_SYMBOL 18 |
| // |
| // Section values. |
| // |
| // Symbols have a section number of the section in which they are |
| // defined. Otherwise, section numbers have the following meanings: |
| // |
| #define IMAGE_SYM_UNDEFINED (UINT16)0 // Symbol is undefined or is common. |
| #define IMAGE_SYM_ABSOLUTE (UINT16)-1 // Symbol is an absolute value. |
| #define IMAGE_SYM_DEBUG (UINT16)-2 // Symbol is a special debug item. |
| // |
| // Type (fundamental) values. |
| // |
| #define IMAGE_SYM_TYPE_NULL 0 // no type. |
| #define IMAGE_SYM_TYPE_VOID 1 // |
| #define IMAGE_SYM_TYPE_CHAR 2 // type character. |
| #define IMAGE_SYM_TYPE_SHORT 3 // type short integer. |
| #define IMAGE_SYM_TYPE_INT 4 // |
| #define IMAGE_SYM_TYPE_LONG 5 // |
| #define IMAGE_SYM_TYPE_FLOAT 6 // |
| #define IMAGE_SYM_TYPE_DOUBLE 7 // |
| #define IMAGE_SYM_TYPE_STRUCT 8 // |
| #define IMAGE_SYM_TYPE_UNION 9 // |
| #define IMAGE_SYM_TYPE_ENUM 10 // enumeration. |
| #define IMAGE_SYM_TYPE_MOE 11 // member of enumeration. |
| #define IMAGE_SYM_TYPE_BYTE 12 // |
| #define IMAGE_SYM_TYPE_WORD 13 // |
| #define IMAGE_SYM_TYPE_UINT 14 // |
| #define IMAGE_SYM_TYPE_DWORD 15 // |
| // |
| // Type (derived) values. |
| // |
| #define IMAGE_SYM_DTYPE_NULL 0 // no derived type. |
| #define IMAGE_SYM_DTYPE_POINTER 1 // pointer. |
| #define IMAGE_SYM_DTYPE_FUNCTION 2 // function. |
| #define IMAGE_SYM_DTYPE_ARRAY 3 // array. |
| // |
| // Storage classes. |
| // |
| #define IMAGE_SYM_CLASS_END_OF_FUNCTION (BYTE )-1 |
| #define IMAGE_SYM_CLASS_NULL 0 |
| #define IMAGE_SYM_CLASS_AUTOMATIC 1 |
| #define IMAGE_SYM_CLASS_EXTERNAL 2 |
| #define IMAGE_SYM_CLASS_STATIC 3 |
| #define IMAGE_SYM_CLASS_REGISTER 4 |
| #define IMAGE_SYM_CLASS_EXTERNAL_DEF 5 |
| #define IMAGE_SYM_CLASS_LABEL 6 |
| #define IMAGE_SYM_CLASS_UNDEFINED_LABEL 7 |
| #define IMAGE_SYM_CLASS_MEMBER_OF_STRUCT 8 |
| #define IMAGE_SYM_CLASS_ARGUMENT 9 |
| #define IMAGE_SYM_CLASS_STRUCT_TAG 10 |
| #define IMAGE_SYM_CLASS_MEMBER_OF_UNION 11 |
| #define IMAGE_SYM_CLASS_UNION_TAG 12 |
| #define IMAGE_SYM_CLASS_TYPE_DEFINITION 13 |
| #define IMAGE_SYM_CLASS_UNDEFINED_STATIC 14 |
| #define IMAGE_SYM_CLASS_ENUM_TAG 15 |
| #define IMAGE_SYM_CLASS_MEMBER_OF_ENUM 16 |
| #define IMAGE_SYM_CLASS_REGISTER_PARAM 17 |
| #define IMAGE_SYM_CLASS_BIT_FIELD 18 |
| #define IMAGE_SYM_CLASS_BLOCK 100 |
| #define IMAGE_SYM_CLASS_FUNCTION 101 |
| #define IMAGE_SYM_CLASS_END_OF_STRUCT 102 |
| #define IMAGE_SYM_CLASS_FILE 103 |
| // new |
| #define IMAGE_SYM_CLASS_SECTION 104 |
| #define IMAGE_SYM_CLASS_WEAK_EXTERNAL 105 |
| // type packing constants |
| #define N_BTMASK 017 |
| #define N_TMASK 060 |
| #define N_TMASK1 0300 |
| #define N_TMASK2 0360 |
| #define N_BTSHFT 4 |
| #define N_TSHIFT 2 |
| // MACROS |
| // |
| // Communal selection types. |
| // |
| #define IMAGE_COMDAT_SELECT_NODUPLICATES 1 |
| #define IMAGE_COMDAT_SELECT_ANY 2 |
| #define IMAGE_COMDAT_SELECT_SAME_SIZE 3 |
| #define IMAGE_COMDAT_SELECT_EXACT_MATCH 4 |
| #define IMAGE_COMDAT_SELECT_ASSOCIATIVE 5 |
| #define IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY 1 |
| #define IMAGE_WEAK_EXTERN_SEARCH_LIBRARY 2 |
| #define IMAGE_WEAK_EXTERN_SEARCH_ALIAS 3 |
| // |
| // Relocation format. |
| // |
| typedef struct _IMAGE_RELOCATION { |
| UINT32 VirtualAddress; |
| UINT32 SymbolTableIndex; |
| UINT16 Type; |
| } IMAGE_RELOCATION; |
| #define IMAGE_SIZEOF_RELOCATION 10 |
| // |
| // I386 relocation types. |
| // |
| #define IMAGE_REL_I386_ABSOLUTE 0 // Reference is absolute, no relocation is necessary |
| #define IMAGE_REL_I386_DIR16 01 // Direct 16-bit reference to the symbols virtual address |
| #define IMAGE_REL_I386_REL16 02 // PC-relative 16-bit reference to the symbols virtual address |
| #define IMAGE_REL_I386_DIR32 06 // Direct 32-bit reference to the symbols virtual address |
| #define IMAGE_REL_I386_DIR32NB 07 // Direct 32-bit reference to the symbols virtual address, base not included |
| #define IMAGE_REL_I386_SEG12 011 // Direct 16-bit reference to the segment-selector bits of a 32-bit virtual address |
| #define IMAGE_REL_I386_SECTION 012 |
| #define IMAGE_REL_I386_SECREL 013 |
| #define IMAGE_REL_I386_REL32 024 // PC-relative 32-bit reference to the symbols virtual address |
| // |
| // MIPS relocation types. |
| // |
| #define IMAGE_REL_MIPS_ABSOLUTE 0 // Reference is absolute, no relocation is necessary |
| #define IMAGE_REL_MIPS_REFHALF 01 |
| #define IMAGE_REL_MIPS_REFWORD 02 |
| #define IMAGE_REL_MIPS_JMPADDR 03 |
| #define IMAGE_REL_MIPS_REFHI 04 |
| #define IMAGE_REL_MIPS_REFLO 05 |
| #define IMAGE_REL_MIPS_GPREL 06 |
| #define IMAGE_REL_MIPS_LITERAL 07 |
| #define IMAGE_REL_MIPS_SECTION 012 |
| #define IMAGE_REL_MIPS_SECREL 013 |
| #define IMAGE_REL_MIPS_REFWORDNB 042 |
| #define IMAGE_REL_MIPS_PAIR 045 |
| // |
| // Alpha Relocation types. |
| // |
| #define IMAGE_REL_ALPHA_ABSOLUTE 0x0 |
| #define IMAGE_REL_ALPHA_REFLONG 0x1 |
| #define IMAGE_REL_ALPHA_REFQUAD 0x2 |
| #define IMAGE_REL_ALPHA_GPREL32 0x3 |
| #define IMAGE_REL_ALPHA_LITERAL 0x4 |
| #define IMAGE_REL_ALPHA_LITUSE 0x5 |
| #define IMAGE_REL_ALPHA_GPDISP 0x6 |
| #define IMAGE_REL_ALPHA_BRADDR 0x7 |
| #define IMAGE_REL_ALPHA_HINT 0x8 |
| #define IMAGE_REL_ALPHA_INLINE_REFLONG 0x9 |
| #define IMAGE_REL_ALPHA_REFHI 0xA |
| #define IMAGE_REL_ALPHA_REFLO 0xB |
| #define IMAGE_REL_ALPHA_PAIR 0xC |
| #define IMAGE_REL_ALPHA_MATCH 0xD |
| #define IMAGE_REL_ALPHA_SECTION 0xE |
| #define IMAGE_REL_ALPHA_SECREL 0xF |
| #define IMAGE_REL_ALPHA_REFLONGNB 0x10 |
| // |
| // IBM PowerPC relocation types. |
| // |
| #define IMAGE_REL_PPC_ABSOLUTE 0x0000 // NOP |
| #define IMAGE_REL_PPC_ADDR64 0x0001 // 64-bit address |
| #define IMAGE_REL_PPC_ADDR32 0x0002 // 32-bit address |
| #define IMAGE_REL_PPC_ADDR24 0x0003 // 26-bit address, shifted left 2 (branch absolute) |
| #define IMAGE_REL_PPC_ADDR16 0x0004 // 16-bit address |
| #define IMAGE_REL_PPC_ADDR14 0x0005 // 16-bit address, shifted left 2 (load doubleword) |
| #define IMAGE_REL_PPC_REL24 0x0006 // 26-bit PC-relative offset, shifted left 2 (branch relative) |
| #define IMAGE_REL_PPC_REL14 0x0007 // 16-bit PC-relative offset, shifted left 2 (br cond relative) |
| #define IMAGE_REL_PPC_TOCREL16 0x0008 // 16-bit offset from TOC base |
| #define IMAGE_REL_PPC_TOCREL14 0x0009 // 16-bit offset from TOC base, shifted left 2 (load doubleword) |
| #define IMAGE_REL_PPC_ADDR32NB 0x000A // 32-bit addr w/o image base |
| #define IMAGE_REL_PPC_SECREL 0x000B // va of containing section (as in an image sectionhdr) |
| #define IMAGE_REL_PPC_SECTION 0x000C // sectionheader number |
| #define IMAGE_REL_PPC_IFGLUE 0x000D // substitute TOC restore instruction iff symbol is glue code |
| #define IMAGE_REL_PPC_IMGLUE 0x000E // symbol is glue code; virtual address is TOC restore instruction |
| #define IMAGE_REL_PPC_TYPEMASK 0x00FF // mask to isolate above values in IMAGE_RELOCATION.Type |
| // Flag bits in IMAGE_RELOCATION.TYPE |
| #define IMAGE_REL_PPC_NEG 0x0100 // subtract reloc value rather than adding it |
| #define IMAGE_REL_PPC_BRTAKEN 0x0200 // fix branch prediction bit to predict branch taken |
| #define IMAGE_REL_PPC_BRNTAKEN 0x0400 // fix branch prediction bit to predict branch not taken |
| #define IMAGE_REL_PPC_TOCDEFN 0x0800 // toc slot defined in file (or, data in toc) |
| // |
| // Based relocation format. |
| // |
| typedef struct _IMAGE_BASE_RELOCATION { |
| UINT32 VirtualAddress; |
| UINT32 SizeOfBlock; |
| // UINT16 TypeOffset[1]; |
| } IMAGE_BASE_RELOCATION, *PIMAGE_BASE_RELOCATION; |
| #define IMAGE_SIZEOF_BASE_RELOCATION 8 |
| // |
| // Based relocation types. |
| // |
| #define IMAGE_REL_BASED_ABSOLUTE 0 |
| #define IMAGE_REL_BASED_HIGH 1 |
| #define IMAGE_REL_BASED_LOW 2 |
| #define IMAGE_REL_BASED_HIGHLOW 3 |
| #define IMAGE_REL_BASED_HIGHADJ 4 |
| #define IMAGE_REL_BASED_MIPS_JMPADDR 5 |
| #define IMAGE_REL_BASED_IA64_IMM64 9 |
| #define IMAGE_REL_BASED_DIR64 10 |
| // |
| // Line number format. |
| // |
| typedef struct _IMAGE_LINENUMBER { |
| union { |
| UINT32 SymbolTableIndex; // Symbol table index of function name if Linenumber is 0. |
| UINT32 VirtualAddress; // Virtual address of line number. |
| } Type; |
| UINT16 Linenumber; // Line number. |
| } IMAGE_LINENUMBER; |
| #define IMAGE_SIZEOF_LINENUMBER 6 |
| // |
| // Archive format. |
| // |
| #define IMAGE_ARCHIVE_START_SIZE 8 |
| #define IMAGE_ARCHIVE_START "!<arch>\n" |
| #define IMAGE_ARCHIVE_END "`\n" |
| #define IMAGE_ARCHIVE_PAD "\n" |
| #define IMAGE_ARCHIVE_LINKER_MEMBER "/ " |
| #define IMAGE_ARCHIVE_LONGNAMES_MEMBER "// " |
| typedef struct _IMAGE_ARCHIVE_MEMBER_HEADER { |
| UINT8 Name[16]; // File member name - `/' terminated. |
| UINT8 Date[12]; // File member date - decimal. |
| UINT8 UserID[6]; // File member user id - decimal. |
| UINT8 GroupID[6]; // File member group id - decimal. |
| UINT8 Mode[8]; // File member mode - octal. |
| UINT8 Size[10]; // File member size - decimal. |
| UINT8 EndHeader[2]; // String to end header. |
| } IMAGE_ARCHIVE_MEMBER_HEADER, *PIMAGE_ARCHIVE_MEMBER_HEADER; |
| #define IMAGE_SIZEOF_ARCHIVE_MEMBER_HDR 60 |
| // |
| // DLL support. |
| // |
| // |
| // Export Format |
| // |
| typedef struct _IMAGE_EXPORT_DIRECTORY { |
| UINT32 Characteristics; |
| UINT32 TimeDateStamp; |
| UINT16 MajorVersion; |
| UINT16 MinorVersion; |
| UINT32 Name; |
| UINT32 Base; |
| UINT32 NumberOfFunctions; |
| UINT32 NumberOfNames; |
| UINT32 AddressOfFunctions; |
| UINT32 AddressOfNames; |
| UINT32 AddressOfNameOrdinals; |
| } IMAGE_EXPORT_DIRECTORY, *PIMAGE_EXPORT_DIRECTORY; |
| // |
| // Import Format |
| // |
| typedef struct _IMAGE_IMPORT_BY_NAME { |
| UINT16 Hint; |
| UINT8 Name[1]; |
| } IMAGE_IMPORT_BY_NAME, *PIMAGE_IMPORT_BY_NAME; |
| typedef struct _IMAGE_THUNK_DATA { |
| union { |
| UINT32 Function; |
| UINT32 Ordinal; |
| PIMAGE_IMPORT_BY_NAME AddressOfData; |
| } u1; |
| } IMAGE_THUNK_DATA, *PIMAGE_THUNK_DATA; |
| #define IMAGE_ORDINAL_FLAG 0x80000000 |
| #define IMAGE_SNAP_BY_ORDINAL(Ordinal) ((Ordinal & IMAGE_ORDINAL_FLAG) != 0) |
| #define IMAGE_ORDINAL(Ordinal) (Ordinal & 0xffff) |
| typedef struct _IMAGE_IMPORT_DESCRIPTOR { |
| UINT32 Characteristics; |
| UINT32 TimeDateStamp; |
| UINT32 ForwarderChain; |
| UINT32 Name; |
| PIMAGE_THUNK_DATA FirstThunk; |
| } IMAGE_IMPORT_DESCRIPTOR, *PIMAGE_IMPORT_DESCRIPTOR; |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/efigpt.h |
|---|
| 0,0 → 1,68 |
| #ifndef _EFI_GPT_H |
| #define _EFI_GPT_H |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| EfiGpt.h |
| Abstract: |
| Include file for EFI partitioning scheme |
| Revision History |
| --*/ |
| #define PRIMARY_PART_HEADER_LBA 1 |
| typedef struct { |
| EFI_TABLE_HEADER Header; |
| EFI_LBA MyLBA; |
| EFI_LBA AlternateLBA; |
| EFI_LBA FirstUsableLBA; |
| EFI_LBA LastUsableLBA; |
| EFI_GUID DiskGUID; |
| EFI_LBA PartitionEntryLBA; |
| UINT32 NumberOfPartitionEntries; |
| UINT32 SizeOfPartitionEntry; |
| UINT32 PartitionEntryArrayCRC32; |
| } EFI_PARTITION_TABLE_HEADER; |
| #define EFI_PTAB_HEADER_ID "EFI PART" |
| typedef struct { |
| EFI_GUID PartitionTypeGUID; |
| EFI_GUID UniquePartitionGUID; |
| EFI_LBA StartingLBA; |
| EFI_LBA EndingLBA; |
| UINT64 Attributes; |
| CHAR16 PartitionName[36]; |
| } EFI_PARTITION_ENTRY; |
| // |
| // EFI Partition Attributes |
| // |
| #define EFI_PART_USED_BY_EFI 0x0000000000000001 |
| #define EFI_PART_REQUIRED_TO_FUNCTION 0x0000000000000002 |
| #define EFI_PART_USED_BY_OS 0x0000000000000004 |
| #define EFI_PART_REQUIRED_BY_OS 0x0000000000000008 |
| #define EFI_PART_BACKUP_REQUIRED 0x0000000000000010 |
| #define EFI_PART_USER_DATA 0x0000000000000020 |
| #define EFI_PART_CRITICAL_USER_DATA 0x0000000000000040 |
| #define EFI_PART_REDUNDANT_PARTITION 0x0000000000000080 |
| #define EFI_PART_TYPE_UNUSED_GUID \ |
| { 0x00000000, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} } |
| #define EFI_PART_TYPE_EFI_SYSTEM_PART_GUID \ |
| { 0xc12a7328, 0xf81f, 0x11d2, {0xba, 0x4b, 0x00, 0xa0, 0xc9, 0x3e, 0xc9, 0x3b} } |
| #define EFI_PART_TYPE_LEGACY_MBR_GUID \ |
| { 0x024dee41, 0x33e7, 0x11d3, {0x9d, 0x69, 0x00, 0x08, 0xc7, 0x81, 0xf3, 0x9f} } |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/efi_pxe.h |
|---|
| 0,0 → 1,1743 |
| #ifndef _EFI_PXE_H |
| #define _EFI_PXE_H |
| /*++ |
| Copyright (c) Intel 1999 |
| Module name: |
| efi_pxe.h |
| 32/64-bit PXE specification: |
| alpha-4, 99-Dec-17 |
| Abstract: |
| This header file contains all of the PXE type definitions, |
| structure prototypes, global variables and constants that |
| are needed for porting PXE to EFI. |
| --*/ |
| #pragma pack(1) |
| #define PXE_INTEL_ORDER 1 // Intel order |
| //#define PXE_NETWORK_ORDER 1 // network order |
| #define PXE_UINT64_SUPPORT 1 // UINT64 supported |
| //#define PXE_NO_UINT64_SUPPORT 1 // UINT64 not supported |
| #define PXE_BUSTYPE(a,b,c,d) \ |
| ((((PXE_UINT32)(d) & 0xFF) << 24) | \ |
| (((PXE_UINT32)(c) & 0xFF) << 16) | \ |
| (((PXE_UINT32)(b) & 0xFF) << 8) | \ |
| ((PXE_UINT32)(a) & 0xFF)) |
| // |
| // UNDI ROM ID and devive ID signature |
| // |
| #define PXE_BUSTYPE_PXE PXE_BUSTYPE('!', 'P', 'X', 'E') |
| // |
| // BUS ROM ID signatures |
| // |
| #define PXE_BUSTYPE_PCI PXE_BUSTYPE('P', 'C', 'I', 'R') |
| #define PXE_BUSTYPE_PC_CARD PXE_BUSTYPE('P', 'C', 'C', 'R') |
| #define PXE_BUSTYPE_USB PXE_BUSTYPE('U', 'S', 'B', 'R') |
| #define PXE_BUSTYPE_1394 PXE_BUSTYPE('1', '3', '9', '4') |
| #define PXE_SWAP_UINT16(n) \ |
| ((((PXE_UINT16)(n) & 0x00FF) << 8) | \ |
| (((PXE_UINT16)(n) & 0xFF00) >> 8)) |
| #define PXE_SWAP_UINT32(n) \ |
| ((((PXE_UINT32)(n) & 0x000000FF) << 24) | \ |
| (((PXE_UINT32)(n) & 0x0000FF00) << 8) | \ |
| (((PXE_UINT32)(n) & 0x00FF0000) >> 8) | \ |
| (((PXE_UINT32)(n) & 0xFF000000) >> 24)) |
| #if PXE_UINT64_SUPPORT != 0 |
| #define PXE_SWAP_UINT64(n) \ |
| ((((PXE_UINT64)(n) & 0x00000000000000FF) << 56) | \ |
| (((PXE_UINT64)(n) & 0x000000000000FF00) << 40) | \ |
| (((PXE_UINT64)(n) & 0x0000000000FF0000) << 24) | \ |
| (((PXE_UINT64)(n) & 0x00000000FF000000) << 8) | \ |
| (((PXE_UINT64)(n) & 0x000000FF00000000) >> 8) | \ |
| (((PXE_UINT64)(n) & 0x0000FF0000000000) >> 24) | \ |
| (((PXE_UINT64)(n) & 0x00FF000000000000) >> 40) | \ |
| (((PXE_UINT64)(n) & 0xFF00000000000000) >> 56)) |
| #endif // PXE_UINT64_SUPPORT |
| #if PXE_NO_UINT64_SUPPORT != 0 |
| #define PXE_SWAP_UINT64(n) \ |
| { \ |
| PXE_UINT32 tmp = (PXE_UINT64)(n)[1]; \ |
| (PXE_UINT64)(n)[1] = PXE_SWAP_UINT32((PXE_UINT64)(n)[0]); \ |
| (PXE_UINT64)(n)[0] = tmp; \ |
| } |
| #endif // PXE_NO_UINT64_SUPPORT |
| #define PXE_CPBSIZE_NOT_USED 0 // zero |
| #define PXE_DBSIZE_NOT_USED 0 // zero |
| #define PXE_CPBADDR_NOT_USED (PXE_UINT64)0 // zero |
| #define PXE_DBADDR_NOT_USED (PXE_UINT64)0 // zero |
| #define PXE_CONST const |
| #define PXE_VOLATILE volatile |
| typedef void PXE_VOID; |
| typedef unsigned char PXE_UINT8; |
| typedef unsigned short PXE_UINT16; |
| typedef unsigned PXE_UINT32; |
| #if PXE_UINT64_SUPPORT != 0 |
| // typedef unsigned long PXE_UINT64; |
| typedef UINT64 PXE_UINT64; |
| #endif // PXE_UINT64_SUPPORT |
| #if PXE_NO_UINT64_SUPPORT != 0 |
| typedef PXE_UINT32 PXE_UINT64[2]; |
| #endif // PXE_NO_UINT64_SUPPORT |
| typedef unsigned PXE_UINTN; |
| typedef PXE_UINT8 PXE_BOOL; |
| #define PXE_FALSE 0 // zero |
| #define PXE_TRUE (!PXE_FALSE) |
| typedef PXE_UINT16 PXE_OPCODE; |
| // |
| // Return UNDI operational state. |
| // |
| #define PXE_OPCODE_GET_STATE 0x0000 |
| // |
| // Change UNDI operational state from Stopped to Started. |
| // |
| #define PXE_OPCODE_START 0x0001 |
| // |
| // Change UNDI operational state from Started to Stopped. |
| // |
| #define PXE_OPCODE_STOP 0x0002 |
| // |
| // Get UNDI initialization information. |
| // |
| #define PXE_OPCODE_GET_INIT_INFO 0x0003 |
| // |
| // Get NIC configuration information. |
| // |
| #define PXE_OPCODE_GET_CONFIG_INFO 0x0004 |
| // |
| // Changed UNDI operational state from Started to Initialized. |
| // |
| #define PXE_OPCODE_INITIALIZE 0x0005 |
| // |
| // Re-initialize the NIC H/W. |
| // |
| #define PXE_OPCODE_RESET 0x0006 |
| // |
| // Change the UNDI operational state from Initialized to Started. |
| // |
| #define PXE_OPCODE_SHUTDOWN 0x0007 |
| // |
| // Read & change state of external interrupt enables. |
| // |
| #define PXE_OPCODE_INTERRUPT_ENABLES 0x0008 |
| // |
| // Read & change state of packet receive filters. |
| // |
| #define PXE_OPCODE_RECEIVE_FILTERS 0x0009 |
| // |
| // Read & change station MAC address. |
| // |
| #define PXE_OPCODE_STATION_ADDRESS 0x000A |
| // |
| // Read traffic statistics. |
| // |
| #define PXE_OPCODE_STATISTICS 0x000B |
| // |
| // Convert multicast IP address to multicast MAC address. |
| // |
| #define PXE_OPCODE_MCAST_IP_TO_MAC 0x000C |
| // |
| // Read or change non-volatile storage on the NIC. |
| // |
| #define PXE_OPCODE_NVDATA 0x000D |
| // |
| // Get & clear interrupt status. |
| // |
| #define PXE_OPCODE_GET_STATUS 0x000E |
| // |
| // Fill media header in packet for transmit. |
| // |
| #define PXE_OPCODE_FILL_HEADER 0x000F |
| // |
| // Transmit packet(s). |
| // |
| #define PXE_OPCODE_TRANSMIT 0x0010 |
| // |
| // Receive packet. |
| // |
| #define PXE_OPCODE_RECEIVE 0x0011 |
| // last valid opcode: |
| #define PXE_OPCODE_VALID_MAX 0x0011 |
| // |
| // Last valid PXE UNDI OpCode number. |
| // |
| #define PXE_OPCODE_LAST_VALID 0x0011 |
| typedef PXE_UINT16 PXE_OPFLAGS; |
| #define PXE_OPFLAGS_NOT_USED 0x0000 |
| //////////////////////////////////////// |
| // UNDI Get State |
| // |
| // No OpFlags |
| //////////////////////////////////////// |
| // UNDI Start |
| // |
| // No OpFlags |
| //////////////////////////////////////// |
| // UNDI Stop |
| // |
| // No OpFlags |
| //////////////////////////////////////// |
| // UNDI Get Init Info |
| // |
| // No Opflags |
| //////////////////////////////////////// |
| // UNDI Get Config Info |
| // |
| // No Opflags |
| //////////////////////////////////////// |
| // UNDI Initialize |
| // |
| #define PXE_OPFLAGS_INITIALIZE_CABLE_DETECT_MASK 0x0001 |
| #define PXE_OPFLAGS_INITIALIZE_DETECT_CABLE 0x0000 |
| #define PXE_OPFLAGS_INITIALIZE_DO_NOT_DETECT_CABLE 0x0001 |
| //////////////////////////////////////// |
| // UNDI Reset |
| // |
| #define PXE_OPFLAGS_RESET_DISABLE_INTERRUPTS 0x0001 |
| #define PXE_OPFLAGS_RESET_DISABLE_FILTERS 0x0002 |
| //////////////////////////////////////// |
| // UNDI Shutdown |
| // |
| // No OpFlags |
| //////////////////////////////////////// |
| // UNDI Interrupt Enables |
| // |
| // |
| // Select whether to enable or disable external interrupt signals. |
| // Setting both enable and disable will return PXE_STATCODE_INVALID_OPFLAGS. |
| // |
| #define PXE_OPFLAGS_INTERRUPT_OPMASK 0xC000 |
| #define PXE_OPFLAGS_INTERRUPT_ENABLE 0x8000 |
| #define PXE_OPFLAGS_INTERRUPT_DISABLE 0x4000 |
| #define PXE_OPFLAGS_INTERRUPT_READ 0x0000 |
| // |
| // Enable receive interrupts. An external interrupt will be generated |
| // after a complete non-error packet has been received. |
| // |
| #define PXE_OPFLAGS_INTERRUPT_RECEIVE 0x0001 |
| // |
| // Enable transmit interrupts. An external interrupt will be generated |
| // after a complete non-error packet has been transmitted. |
| // |
| #define PXE_OPFLAGS_INTERRUPT_TRANSMIT 0x0002 |
| // |
| // Enable command interrupts. An external interrupt will be generated |
| // when command execution stops. |
| // |
| #define PXE_OPFLAGS_INTERRUPT_COMMAND 0x0004 |
| // |
| // Generate software interrupt. Setting this bit generates an external |
| // interrupt, if it is supported by the hardware. |
| // |
| #define PXE_OPFLAGS_INTERRUPT_SOFTWARE 0x0008 |
| //////////////////////////////////////// |
| // UNDI Receive Filters |
| // |
| // |
| // Select whether to enable or disable receive filters. |
| // Setting both enable and disable will return PXE_STATCODE_INVALID_OPCODE. |
| // |
| #define PXE_OPFLAGS_RECEIVE_FILTER_OPMASK 0xC000 |
| #define PXE_OPFLAGS_RECEIVE_FILTER_ENABLE 0x8000 |
| #define PXE_OPFLAGS_RECEIVE_FILTER_DISABLE 0x4000 |
| #define PXE_OPFLAGS_RECEIVE_FILTER_READ 0x0000 |
| // |
| // To reset the contents of the multicast MAC address filter list, |
| // set this OpFlag: |
| // |
| #define PXE_OPFLAGS_RECEIVE_FILTER_RESET_MCAST_LIST 0x2000 |
| // |
| // Enable unicast packet receiving. Packets sent to the current station |
| // MAC address will be received. |
| // |
| #define PXE_OPFLAGS_RECEIVE_FILTER_UNICAST 0x0001 |
| // |
| // Enable broadcast packet receiving. Packets sent to the broadcast |
| // MAC address will be received. |
| // |
| #define PXE_OPFLAGS_RECEIVE_FILTER_BROADCAST 0x0002 |
| // |
| // Enable filtered multicast packet receiving. Packets sent to any |
| // of the multicast MAC addresses in the multicast MAC address filter |
| // list will be received. If the filter list is empty, no multicast |
| // |
| #define PXE_OPFLAGS_RECEIVE_FILTER_FILTERED_MULTICAST 0x0004 |
| // |
| // Enable promiscuous packet receiving. All packets will be received. |
| // |
| #define PXE_OPFLAGS_RECEIVE_FILTER_PROMISCUOUS 0x0008 |
| // |
| // Enable promiscuous multicast packet receiving. All multicast |
| // packets will be received. |
| // |
| #define PXE_OPFLAGS_RECEIVE_FILTER_ALL_MULTICAST 0x0010 |
| //////////////////////////////////////// |
| // UNDI Station Address |
| // |
| #define PXE_OPFLAGS_STATION_ADDRESS_READ 0x0000 |
| #define PXE_OPFLAGS_STATION_ADDRESS_RESET 0x0001 |
| //////////////////////////////////////// |
| // UNDI Statistics |
| // |
| #define PXE_OPFLAGS_STATISTICS_READ 0x0000 |
| #define PXE_OPFLAGS_STATISTICS_RESET 0x0001 |
| //////////////////////////////////////// |
| // UNDI MCast IP to MAC |
| // |
| // |
| // Identify the type of IP address in the CPB. |
| // |
| #define PXE_OPFLAGS_MCAST_IP_TO_MAC_OPMASK 0x0003 |
| #define PXE_OPFLAGS_MCAST_IPV4_TO_MAC 0x0000 |
| #define PXE_OPFLAGS_MCAST_IPV6_TO_MAC 0x0001 |
| //////////////////////////////////////// |
| // UNDI NvData |
| // |
| // |
| // Select the type of non-volatile data operation. |
| // |
| #define PXE_OPFLAGS_NVDATA_OPMASK 0x0001 |
| #define PXE_OPFLAGS_NVDATA_READ 0x0000 |
| #define PXE_OPFLAGS_NVDATA_WRITE 0x0001 |
| //////////////////////////////////////// |
| // UNDI Get Status |
| // |
| // |
| // Return current interrupt status. This will also clear any interrupts |
| // that are currently set. This can be used in a polling routine. The |
| // interrupt flags are still set and cleared even when the interrupts |
| // are disabled. |
| // |
| #define PXE_OPFLAGS_GET_INTERRUPT_STATUS 0x0001 |
| // |
| // Return list of transmitted buffers for recycling. Transmit buffers |
| // must not be changed or unallocated until they have recycled. After |
| // issuing a transmit command, wait for a transmit complete interrupt. |
| // When a transmit complete interrupt is received, read the transmitted |
| // buffers. Do not plan on getting one buffer per interrupt. Some |
| // NICs and UNDIs may transmit multiple buffers per interrupt. |
| // |
| #define PXE_OPFLAGS_GET_TRANSMITTED_BUFFERS 0x0002 |
| //////////////////////////////////////// |
| // UNDI Fill Header |
| // |
| #define PXE_OPFLAGS_FILL_HEADER_OPMASK 0x0001 |
| #define PXE_OPFLAGS_FILL_HEADER_FRAGMENTED 0x0001 |
| #define PXE_OPFLAGS_FILL_HEADER_WHOLE 0x0000 |
| //////////////////////////////////////// |
| // UNDI Transmit |
| // |
| // |
| // S/W UNDI only. Return after the packet has been transmitted. A |
| // transmit complete interrupt will still be generated and the transmit |
| // buffer will have to be recycled. |
| // |
| #define PXE_OPFLAGS_SWUNDI_TRANSMIT_OPMASK 0x0001 |
| #define PXE_OPFLAGS_TRANSMIT_BLOCK 0x0001 |
| #define PXE_OPFLAGS_TRANSMIT_DONT_BLOCK 0x0000 |
| // |
| // |
| // |
| #define PXE_OPFLAGS_TRANSMIT_OPMASK 0x0002 |
| #define PXE_OPFLAGS_TRANSMIT_FRAGMENTED 0x0002 |
| #define PXE_OPFLAGS_TRANSMIT_WHOLE 0x0000 |
| //////////////////////////////////////// |
| // UNDI Receive |
| // |
| // No OpFlags |
| typedef PXE_UINT16 PXE_STATFLAGS; |
| #define PXE_STATFLAGS_INITIALIZE 0x0000 |
| //////////////////////////////////////// |
| // Common StatFlags that can be returned by all commands. |
| // |
| // |
| // The COMMAND_COMPLETE and COMMAND_FAILED status flags must be |
| // implemented by all UNDIs. COMMAND_QUEUED is only needed by UNDIs |
| // that support command queuing. |
| // |
| #define PXE_STATFLAGS_STATUS_MASK 0xC000 |
| #define PXE_STATFLAGS_COMMAND_COMPLETE 0xC000 |
| #define PXE_STATFLAGS_COMMAND_FAILED 0x8000 |
| #define PXE_STATFLAGS_COMMAND_QUEUED 0x4000 |
| //#define PXE_STATFLAGS_INITIALIZE 0x0000 |
| #define PXE_STATFLAGS_DB_WRITE_TRUNCATED 0x2000 |
| //////////////////////////////////////// |
| // UNDI Get State |
| // |
| #define PXE_STATFLAGS_GET_STATE_MASK 0x0003 |
| #define PXE_STATFLAGS_GET_STATE_INITIALIZED 0x0002 |
| #define PXE_STATFLAGS_GET_STATE_STARTED 0x0001 |
| #define PXE_STATFLAGS_GET_STATE_STOPPED 0x0000 |
| //////////////////////////////////////// |
| // UNDI Start |
| // |
| // No additional StatFlags |
| //////////////////////////////////////// |
| // UNDI Get Init Info |
| // |
| #define PXE_STATFLAGS_CABLE_DETECT_MASK 0x0001 |
| #define PXE_STATFLAGS_CABLE_DETECT_NOT_SUPPORTED 0x0000 |
| #define PXE_STATFLAGS_CABLE_DETECT_SUPPORTED 0x0001 |
| //////////////////////////////////////// |
| // UNDI Initialize |
| // |
| #define PXE_STATFLAGS_INITIALIZED_NO_MEDIA 0x0001 |
| //////////////////////////////////////// |
| // UNDI Reset |
| // |
| #define PXE_STATFLAGS_RESET_NO_MEDIA 0x0001 |
| //////////////////////////////////////// |
| // UNDI Shutdown |
| // |
| // No additional StatFlags |
| //////////////////////////////////////// |
| // UNDI Interrupt Enables |
| // |
| // |
| // If set, receive interrupts are enabled. |
| // |
| #define PXE_STATFLAGS_INTERRUPT_RECEIVE 0x0001 |
| // |
| // If set, transmit interrupts are enabled. |
| // |
| #define PXE_STATFLAGS_INTERRUPT_TRANSMIT 0x0002 |
| // |
| // If set, command interrupts are enabled. |
| // |
| #define PXE_STATFLAGS_INTERRUPT_COMMAND 0x0004 |
| //////////////////////////////////////// |
| // UNDI Receive Filters |
| // |
| // |
| // If set, unicast packets will be received. |
| // |
| #define PXE_STATFLAGS_RECEIVE_FILTER_UNICAST 0x0001 |
| // |
| // If set, broadcast packets will be received. |
| // |
| #define PXE_STATFLAGS_RECEIVE_FILTER_BROADCAST 0x0002 |
| // |
| // If set, multicast packets that match up with the multicast address |
| // filter list will be received. |
| // |
| #define PXE_STATFLAGS_RECEIVE_FILTER_FILTERED_MULTICAST 0x0004 |
| // |
| // If set, all packets will be received. |
| // |
| #define PXE_STATFLAGS_RECEIVE_FILTER_PROMISCUOUS 0x0008 |
| // |
| // If set, all multicast packets will be received. |
| // |
| #define PXE_STATFLAGS_RECEIVE_FILTER_ALL_MULTICAST 0x0010 |
| //////////////////////////////////////// |
| // UNDI Station Address |
| // |
| // No additional StatFlags |
| //////////////////////////////////////// |
| // UNDI Statistics |
| // |
| // No additional StatFlags |
| //////////////////////////////////////// |
| // UNDI MCast IP to MAC |
| // |
| // No additional StatFlags |
| //////////////////////////////////////// |
| // UNDI NvData |
| // |
| // No additional StatFlags |
| //////////////////////////////////////// |
| // UNDI Get Status |
| // |
| // |
| // Use to determine if an interrupt has occurred. |
| // |
| #define PXE_STATFLAGS_GET_STATUS_INTERRUPT_MASK 0x000F |
| #define PXE_STATFLAGS_GET_STATUS_NO_INTERRUPTS 0x0000 |
| // |
| // If set, at least one receive interrupt occurred. |
| // |
| #define PXE_STATFLAGS_GET_STATUS_RECEIVE 0x0001 |
| // |
| // If set, at least one transmit interrupt occurred. |
| // |
| #define PXE_STATFLAGS_GET_STATUS_TRANSMIT 0x0002 |
| // |
| // If set, at least one command interrupt occurred. |
| // |
| #define PXE_STATFLAGS_GET_STATUS_COMMAND 0x0004 |
| // |
| // If set, at least one software interrupt occurred. |
| // |
| #define PXE_STATFLAGS_GET_STATUS_SOFTWARE 0x0008 |
| // |
| // This flag is set if the transmitted buffer queue is empty. This flag |
| // will be set if all transmitted buffer addresses get written into the DB. |
| // |
| #define PXE_STATFLAGS_GET_STATUS_TXBUF_QUEUE_EMPTY 0x0010 |
| // |
| // This flag is set if no transmitted buffer addresses were written |
| // into the DB. (This could be because DBsize was too small.) |
| // |
| #define PXE_STATFLAGS_GET_STATUS_NO_TXBUFS_WRITTEN 0x0020 |
| //////////////////////////////////////// |
| // UNDI Fill Header |
| // |
| // No additional StatFlags |
| //////////////////////////////////////// |
| // UNDI Transmit |
| // |
| // No additional StatFlags. |
| //////////////////////////////////////// |
| // UNDI Receive |
| // |
| // No additional StatFlags. |
| typedef PXE_UINT16 PXE_STATCODE; |
| #define PXE_STATCODE_INITIALIZE 0x0000 |
| //////////////////////////////////////// |
| // Common StatCodes returned by all UNDI commands, UNDI protocol functions |
| // and BC protocol functions. |
| // |
| #define PXE_STATCODE_SUCCESS 0x0000 |
| #define PXE_STATCODE_INVALID_CDB 0x0001 |
| #define PXE_STATCODE_INVALID_CPB 0x0002 |
| #define PXE_STATCODE_BUSY 0x0003 |
| #define PXE_STATCODE_QUEUE_FULL 0x0004 |
| #define PXE_STATCODE_ALREADY_STARTED 0x0005 |
| #define PXE_STATCODE_NOT_STARTED 0x0006 |
| #define PXE_STATCODE_NOT_SHUTDOWN 0x0007 |
| #define PXE_STATCODE_ALREADY_INITIALIZED 0x0008 |
| #define PXE_STATCODE_NOT_INITIALIZED 0x0009 |
| #define PXE_STATCODE_DEVICE_FAILURE 0x000A |
| #define PXE_STATCODE_NVDATA_FAILURE 0x000B |
| #define PXE_STATCODE_UNSUPPORTED 0x000C |
| #define PXE_STATCODE_BUFFER_FULL 0x000D |
| #define PXE_STATCODE_INVALID_PARAMETER 0x000E |
| #define PXE_STATCODE_INVALID_UNDI 0x000F |
| #define PXE_STATCODE_IPV4_NOT_SUPPORTED 0x0010 |
| #define PXE_STATCODE_IPV6_NOT_SUPPORTED 0x0011 |
| #define PXE_STATCODE_NOT_ENOUGH_MEMORY 0x0012 |
| #define PXE_STATCODE_NO_DATA 0x0013 |
| typedef PXE_UINT16 PXE_IFNUM; |
| // |
| // This interface number must be passed to the S/W UNDI Start command. |
| // |
| #define PXE_IFNUM_START 0x0000 |
| // |
| // This interface number is returned by the S/W UNDI Get State and |
| // Start commands if information in the CDB, CPB or DB is invalid. |
| // |
| #define PXE_IFNUM_INVALID 0x0000 |
| typedef PXE_UINT16 PXE_CONTROL; |
| // |
| // Setting this flag directs the UNDI to queue this command for later |
| // execution if the UNDI is busy and it supports command queuing. |
| // If queuing is not supported, a PXE_STATCODE_INVALID_CONTROL error |
| // is returned. If the queue is full, a PXE_STATCODE_CDB_QUEUE_FULL |
| // error is returned. |
| // |
| #define PXE_CONTROL_QUEUE_IF_BUSY 0x0002 |
| // |
| // These two bit values are used to determine if there are more UNDI |
| // CDB structures following this one. If the link bit is set, there |
| // must be a CDB structure following this one. Execution will start |
| // on the next CDB structure as soon as this one completes successfully. |
| // If an error is generated by this command, execution will stop. |
| // |
| #define PXE_CONTROL_LINK 0x0001 |
| #define PXE_CONTROL_LAST_CDB_IN_LIST 0x0000 |
| typedef PXE_UINT8 PXE_FRAME_TYPE; |
| #define PXE_FRAME_TYPE_NONE 0x00 |
| #define PXE_FRAME_TYPE_UNICAST 0x01 |
| #define PXE_FRAME_TYPE_BROADCAST 0x02 |
| #define PXE_FRAME_TYPE_MULTICAST 0x03 |
| #define PXE_FRAME_TYPE_PROMISCUOUS 0x04 |
| typedef PXE_UINT32 PXE_IPV4; |
| typedef PXE_UINT32 PXE_IPV6[4]; |
| #define PXE_MAC_LENGTH 32 |
| typedef PXE_UINT8 PXE_MAC_ADDR[PXE_MAC_LENGTH]; |
| typedef PXE_UINT8 PXE_IFTYPE; |
| typedef PXE_UINT16 PXE_MEDIA_PROTOCOL; |
| // |
| // This information is from the ARP section of RFC 1700. |
| // |
| // 1 Ethernet (10Mb) [JBP] |
| // 2 Experimental Ethernet (3Mb) [JBP] |
| // 3 Amateur Radio AX.25 [PXK] |
| // 4 Proteon ProNET Token Ring [JBP] |
| // 5 Chaos [GXP] |
| // 6 IEEE 802 Networks [JBP] |
| // 7 ARCNET [JBP] |
| // 8 Hyperchannel [JBP] |
| // 9 Lanstar [TU] |
| // 10 Autonet Short Address [MXB1] |
| // 11 LocalTalk [JKR1] |
| // 12 LocalNet (IBM PCNet or SYTEK LocalNET) [JXM] |
| // 13 Ultra link [RXD2] |
| // 14 SMDS [GXC1] |
| // 15 Frame Relay [AGM] |
| // 16 Asynchronous Transmission Mode (ATM) [JXB2] |
| // 17 HDLC [JBP] |
| // 18 Fibre Channel [Yakov Rekhter] |
| // 19 Asynchronous Transmission Mode (ATM) [Mark Laubach] |
| // 20 Serial Line [JBP] |
| // 21 Asynchronous Transmission Mode (ATM) [MXB1] |
| // |
| #define PXE_IFTYPE_ETHERNET 0x01 |
| #define PXE_IFTYPE_TOKENRING 0x04 |
| #define PXE_IFTYPE_FIBRE_CHANNEL 0x12 |
| typedef struct s_pxe_hw_undi { |
| PXE_UINT32 Signature; // PXE_ROMID_SIGNATURE |
| PXE_UINT8 Len; // sizeof(PXE_HW_UNDI) |
| PXE_UINT8 Fudge; // makes 8-bit cksum equal zero |
| PXE_UINT8 Rev; // PXE_ROMID_REV |
| PXE_UINT8 IFcnt; // physical connector count |
| PXE_UINT8 MajorVer; // PXE_ROMID_MAJORVER |
| PXE_UINT8 MinorVer; // PXE_ROMID_MINORVER |
| PXE_UINT16 reserved; // zero, not used |
| PXE_UINT32 Implementation; // implementation flags |
| // reserved // vendor use |
| // PXE_UINT32 Status; // status port |
| // PXE_UINT32 Command; // command port |
| // PXE_UINT64 CDBaddr; // CDB address port |
| } PXE_HW_UNDI; |
| // |
| // Status port bit definitions |
| // |
| // |
| // UNDI operation state |
| // |
| #define PXE_HWSTAT_STATE_MASK 0xC0000000 |
| #define PXE_HWSTAT_BUSY 0xC0000000 |
| #define PXE_HWSTAT_INITIALIZED 0x80000000 |
| #define PXE_HWSTAT_STARTED 0x40000000 |
| #define PXE_HWSTAT_STOPPED 0x00000000 |
| // |
| // If set, last command failed |
| // |
| #define PXE_HWSTAT_COMMAND_FAILED 0x20000000 |
| // |
| // If set, identifies enabled receive filters |
| // |
| #define PXE_HWSTAT_PROMISCUOUS_MULTICAST_RX_ENABLED 0x00001000 |
| #define PXE_HWSTAT_PROMISCUOUS_RX_ENABLED 0x00000800 |
| #define PXE_HWSTAT_BROADCAST_RX_ENABLED 0x00000400 |
| #define PXE_HWSTAT_MULTICAST_RX_ENABLED 0x00000200 |
| #define PXE_HWSTAT_UNICAST_RX_ENABLED 0x00000100 |
| // |
| // If set, identifies enabled external interrupts |
| // |
| #define PXE_HWSTAT_SOFTWARE_INT_ENABLED 0x00000080 |
| #define PXE_HWSTAT_TX_COMPLETE_INT_ENABLED 0x00000040 |
| #define PXE_HWSTAT_PACKET_RX_INT_ENABLED 0x00000020 |
| #define PXE_HWSTAT_CMD_COMPLETE_INT_ENABLED 0x00000010 |
| // |
| // If set, identifies pending interrupts |
| // |
| #define PXE_HWSTAT_SOFTWARE_INT_PENDING 0x00000008 |
| #define PXE_HWSTAT_TX_COMPLETE_INT_PENDING 0x00000004 |
| #define PXE_HWSTAT_PACKET_RX_INT_PENDING 0x00000002 |
| #define PXE_HWSTAT_CMD_COMPLETE_INT_PENDING 0x00000001 |
| // |
| // Command port definitions |
| // |
| // |
| // If set, CDB identified in CDBaddr port is given to UNDI. |
| // If not set, other bits in this word will be processed. |
| // |
| #define PXE_HWCMD_ISSUE_COMMAND 0x80000000 |
| #define PXE_HWCMD_INTS_AND_FILTS 0x00000000 |
| // |
| // Use these to enable/disable receive filters. |
| // |
| #define PXE_HWCMD_PROMISCUOUS_MULTICAST_RX_ENABLE 0x00001000 |
| #define PXE_HWCMD_PROMISCUOUS_RX_ENABLE 0x00000800 |
| #define PXE_HWCMD_BROADCAST_RX_ENABLE 0x00000400 |
| #define PXE_HWCMD_MULTICAST_RX_ENABLE 0x00000200 |
| #define PXE_HWCMD_UNICAST_RX_ENABLE 0x00000100 |
| // |
| // Use these to enable/disable external interrupts |
| // |
| #define PXE_HWCMD_SOFTWARE_INT_ENABLE 0x00000080 |
| #define PXE_HWCMD_TX_COMPLETE_INT_ENABLE 0x00000040 |
| #define PXE_HWCMD_PACKET_RX_INT_ENABLE 0x00000020 |
| #define PXE_HWCMD_CMD_COMPLETE_INT_ENABLE 0x00000010 |
| // |
| // Use these to clear pending external interrupts |
| // |
| #define PXE_HWCMD_CLEAR_SOFTWARE_INT 0x00000008 |
| #define PXE_HWCMD_CLEAR_TX_COMPLETE_INT 0x00000004 |
| #define PXE_HWCMD_CLEAR_PACKET_RX_INT 0x00000002 |
| #define PXE_HWCMD_CLEAR_CMD_COMPLETE_INT 0x00000001 |
| typedef struct s_pxe_sw_undi { |
| PXE_UINT32 Signature; // PXE_ROMID_SIGNATURE |
| PXE_UINT8 Len; // sizeof(PXE_SW_UNDI) |
| PXE_UINT8 Fudge; // makes 8-bit cksum zero |
| PXE_UINT8 Rev; // PXE_ROMID_REV |
| PXE_UINT8 IFcnt; // physical connector count |
| PXE_UINT8 MajorVer; // PXE_ROMID_MAJORVER |
| PXE_UINT8 MinorVer; // PXE_ROMID_MINORVER |
| PXE_UINT16 reserved1; // zero, not used |
| PXE_UINT32 Implementation; // Implementation flags |
| PXE_UINT64 EntryPoint; // API entry point |
| PXE_UINT8 reserved2[3]; // zero, not used |
| PXE_UINT8 BusCnt; // number of bustypes supported |
| PXE_UINT32 BusType[1]; // list of supported bustypes |
| } PXE_SW_UNDI; |
| typedef union u_pxe_undi { |
| PXE_HW_UNDI hw; |
| PXE_SW_UNDI sw; |
| } PXE_UNDI; |
| // |
| // Signature of !PXE structure |
| // |
| #define PXE_ROMID_SIGNATURE PXE_BUSTYPE('!', 'P', 'X', 'E') |
| // |
| // !PXE structure format revision |
| // |
| #define PXE_ROMID_REV 0x02 |
| // |
| // UNDI command interface revision. These are the values that get sent |
| // in option 94 (Client Network Interface Identifier) in the DHCP Discover |
| // and PXE Boot Server Request packets. |
| // |
| #define PXE_ROMID_MAJORVER 0x03 |
| #define PXE_ROMID_MINORVER 0x00 |
| // |
| // Implementation flags |
| // |
| #define PXE_ROMID_IMP_HW_UNDI 0x80000000 |
| #define PXE_ROMID_IMP_SW_VIRT_ADDR 0x40000000 |
| #define PXE_ROMID_IMP_64BIT_DEVICE 0x00010000 |
| #define PXE_ROMID_IMP_FRAG_SUPPORTED 0x00008000 |
| #define PXE_ROMID_IMP_CMD_LINK_SUPPORTED 0x00004000 |
| #define PXE_ROMID_IMP_CMD_QUEUE_SUPPORTED 0x00002000 |
| #define PXE_ROMID_IMP_MULTI_FRAME_SUPPORTED 0x00001000 |
| #define PXE_ROMID_IMP_NVDATA_SUPPORT_MASK 0x00000C00 |
| #define PXE_ROMID_IMP_NVDATA_BULK_WRITABLE 0x00000C00 |
| #define PXE_ROMID_IMP_NVDATA_SPARSE_WRITABLE 0x00000800 |
| #define PXE_ROMID_IMP_NVDATA_READ_ONLY 0x00000400 |
| #define PXE_ROMID_IMP_NVDATA_NOT_AVAILABLE 0x00000000 |
| #define PXE_ROMID_IMP_STATISTICS_SUPPORTED 0x00000200 |
| #define PXE_ROMID_IMP_STATION_ADDR_SETTABLE 0x00000100 |
| #define PXE_ROMID_IMP_PROMISCUOUS_MULTICAST_RX_SUPPORTED 0x00000080 |
| #define PXE_ROMID_IMP_PROMISCUOUS_RX_SUPPORTED 0x00000040 |
| #define PXE_ROMID_IMP_BROADCAST_RX_SUPPORTED 0x00000020 |
| #define PXE_ROMID_IMP_FILTERED_MULTICAST_RX_SUPPORTED 0x00000010 |
| #define PXE_ROMID_IMP_SOFTWARE_INT_SUPPORTED 0x00000008 |
| #define PXE_ROMID_IMP_TX_COMPLETE_INT_SUPPORTED 0x00000004 |
| #define PXE_ROMID_IMP_PACKET_RX_INT_SUPPORTED 0x00000002 |
| #define PXE_ROMID_IMP_CMD_COMPLETE_INT_SUPPORTED 0x00000001 |
| typedef struct s_pxe_cdb { |
| PXE_OPCODE OpCode; |
| PXE_OPFLAGS OpFlags; |
| PXE_UINT16 CPBsize; |
| PXE_UINT16 DBsize; |
| UINT64 CPBaddr; |
| UINT64 DBaddr; |
| PXE_STATCODE StatCode; |
| PXE_STATFLAGS StatFlags; |
| PXE_UINT16 IFnum; |
| PXE_CONTROL Control; |
| } PXE_CDB; |
| typedef union u_pxe_ip_addr { |
| PXE_IPV6 IPv6; |
| PXE_IPV4 IPv4; |
| } PXE_IP_ADDR; |
| typedef union pxe_device { |
| // |
| // PCI and PC Card NICs are both identified using bus, device |
| // and function numbers. For PC Card, this may require PC |
| // Card services to be loaded in the BIOS or preboot |
| // environment. |
| // |
| struct { |
| // |
| // See S/W UNDI ROMID structure definition for PCI and |
| // PCC BusType definitions. |
| // |
| PXE_UINT32 BusType; |
| // |
| // Bus, device & function numbers that locate this device. |
| // |
| PXE_UINT16 Bus; |
| PXE_UINT8 Device; |
| PXE_UINT8 Function; |
| } PCI, PCC; |
| // |
| // %%TBD - More information is needed about enumerating |
| // USB and 1394 devices. |
| // |
| struct { |
| PXE_UINT32 BusType; |
| PXE_UINT32 tdb; |
| } USB, _1394; |
| } PXE_DEVICE; |
| // cpb and db definitions |
| #define MAX_PCI_CONFIG_LEN 64 // # of dwords |
| #define MAX_EEPROM_LEN 128 // #of dwords |
| #define MAX_XMIT_BUFFERS 32 // recycling Q length for xmit_done |
| #define MAX_MCAST_ADDRESS_CNT 8 |
| typedef struct s_pxe_cpb_start { |
| // |
| // PXE_VOID Delay(PXE_UINT64 microseconds); |
| // |
| // UNDI will never request a delay smaller than 10 microseconds |
| // and will always request delays in increments of 10 microseconds. |
| // The Delay() CallBack routine must delay between n and n + 10 |
| // microseconds before returning control to the UNDI. |
| // |
| // This field cannot be set to zero. |
| // |
| PXE_UINT64 Delay; |
| // |
| // PXE_VOID Block(PXE_UINT32 enable); |
| // |
| // UNDI may need to block multi-threaded/multi-processor access to |
| // critical code sections when programming or accessing the network |
| // device. To this end, a blocking service is needed by the UNDI. |
| // When UNDI needs a block, it will call Block() passing a non-zero |
| // value. When UNDI no longer needs a block, it will call Block() |
| // with a zero value. When called, if the Block() is already enabled, |
| // do not return control to the UNDI until the previous Block() is |
| // disabled. |
| // |
| // This field cannot be set to zero. |
| // |
| PXE_UINT64 Block; |
| // |
| // PXE_VOID Virt2Phys(PXE_UINT64 virtual, PXE_UINT64 physical_ptr); |
| // |
| // UNDI will pass the virtual address of a buffer and the virtual |
| // address of a 64-bit physical buffer. Convert the virtual address |
| // to a physical address and write the result to the physical address |
| // buffer. If virtual and physical addresses are the same, just |
| // copy the virtual address to the physical address buffer. |
| // |
| // This field can be set to zero if virtual and physical addresses |
| // are equal. |
| // |
| PXE_UINT64 Virt2Phys; |
| // |
| // PXE_VOID Mem_IO(PXE_UINT8 read_write, PXE_UINT8 len, PXE_UINT64 port, |
| // PXE_UINT64 buf_addr); |
| // |
| // UNDI will read or write the device io space using this call back |
| // function. It passes the number of bytes as the len parameter and it |
| // will be either 1,2,4 or 8. |
| // |
| // This field can not be set to zero. |
| // |
| PXE_UINT64 Mem_IO; |
| } PXE_CPB_START; |
| #define PXE_DELAY_MILLISECOND 1000 |
| #define PXE_DELAY_SECOND 1000000 |
| #define PXE_IO_READ 0 |
| #define PXE_IO_WRITE 1 |
| #define PXE_MEM_READ 2 |
| #define PXE_MEM_WRITE 4 |
| typedef struct s_pxe_db_get_init_info { |
| // |
| // Minimum length of locked memory buffer that must be given to |
| // the Initialize command. Giving UNDI more memory will generally |
| // give better performance. |
| // |
| // If MemoryRequired is zero, the UNDI does not need and will not |
| // use system memory to receive and transmit packets. |
| // |
| PXE_UINT32 MemoryRequired; |
| // |
| // Maximum frame data length for Tx/Rx excluding the media header. |
| // |
| PXE_UINT32 FrameDataLen; |
| // |
| // Supported link speeds are in units of mega bits. Common ethernet |
| // values are 10, 100 and 1000. Unused LinkSpeeds[] entries are zero |
| // filled. |
| // |
| PXE_UINT32 LinkSpeeds[4]; |
| // |
| // Number of non-volatile storage items. |
| // |
| PXE_UINT32 NvCount; |
| // |
| // Width of non-volatile storage item in bytes. 0, 1, 2 or 4 |
| // |
| PXE_UINT16 NvWidth; |
| // |
| // Media header length. This is the typical media header length for |
| // this UNDI. This information is needed when allocating receive |
| // and transmit buffers. |
| // |
| PXE_UINT16 MediaHeaderLen; |
| // |
| // Number of bytes in the NIC hardware (MAC) address. |
| // |
| PXE_UINT16 HWaddrLen; |
| // |
| // Maximum number of multicast MAC addresses in the multicast |
| // MAC address filter list. |
| // |
| PXE_UINT16 MCastFilterCnt; |
| // |
| // Default number and size of transmit and receive buffers that will |
| // be allocated by the UNDI. If MemoryRequired is non-zero, this |
| // allocation will come out of the memory buffer given to the Initialize |
| // command. If MemoryRequired is zero, this allocation will come out of |
| // memory on the NIC. |
| // |
| PXE_UINT16 TxBufCnt; |
| PXE_UINT16 TxBufSize; |
| PXE_UINT16 RxBufCnt; |
| PXE_UINT16 RxBufSize; |
| // |
| // Hardware interface types defined in the Assigned Numbers RFC |
| // and used in DHCP and ARP packets. |
| // See the PXE_IFTYPE typedef and PXE_IFTYPE_xxx macros. |
| // |
| PXE_UINT8 IFtype; |
| // |
| // Supported duplex. See PXE_DUPLEX_xxxxx #defines below. |
| // |
| PXE_UINT8 Duplex; |
| // |
| // Supported loopback options. See PXE_LOOPBACK_xxxxx #defines below. |
| // |
| PXE_UINT8 LoopBack; |
| } PXE_DB_GET_INIT_INFO; |
| #define PXE_MAX_TXRX_UNIT_ETHER 1500 |
| #define PXE_HWADDR_LEN_ETHER 0x0006 |
| #define PXE_MAC_HEADER_LEN_ETHER 0x000E |
| #define PXE_DUPLEX_ENABLE_FULL_SUPPORTED 1 |
| #define PXE_DUPLEX_FORCE_FULL_SUPPORTED 2 |
| #define PXE_LOOPBACK_INTERNAL_SUPPORTED 1 |
| #define PXE_LOOPBACK_EXTERNAL_SUPPORTED 2 |
| typedef struct s_pxe_pci_config_info { |
| // |
| // This is the flag field for the PXE_DB_GET_CONFIG_INFO union. |
| // For PCI bus devices, this field is set to PXE_BUSTYPE_PCI. |
| // |
| PXE_UINT32 BusType; |
| // |
| // This identifies the PCI network device that this UNDI interface |
| // is bound to. |
| // |
| PXE_UINT16 Bus; |
| PXE_UINT8 Device; |
| PXE_UINT8 Function; |
| // |
| // This is a copy of the PCI configuration space for this |
| // network device. |
| // |
| union { |
| PXE_UINT8 Byte[256]; |
| PXE_UINT16 Word[128]; |
| PXE_UINT32 Dword[64]; |
| } Config; |
| } PXE_PCI_CONFIG_INFO; |
| typedef struct s_pxe_pcc_config_info { |
| // |
| // This is the flag field for the PXE_DB_GET_CONFIG_INFO union. |
| // For PCC bus devices, this field is set to PXE_BUSTYPE_PCC. |
| // |
| PXE_UINT32 BusType; |
| // |
| // This identifies the PCC network device that this UNDI interface |
| // is bound to. |
| // |
| PXE_UINT16 Bus; |
| PXE_UINT8 Device; |
| PXE_UINT8 Function; |
| // |
| // This is a copy of the PCC configuration space for this |
| // network device. |
| // |
| union { |
| PXE_UINT8 Byte[256]; |
| PXE_UINT16 Word[128]; |
| PXE_UINT32 Dword[64]; |
| } Config; |
| } PXE_PCC_CONFIG_INFO; |
| typedef struct s_pxe_usb_config_info { |
| PXE_UINT32 BusType; |
| // %%TBD What should we return here... |
| } PXE_USB_CONFIG_INFO; |
| typedef struct s_pxe_1394_config_info { |
| PXE_UINT32 BusType; |
| // %%TBD What should we return here... |
| } PXE_1394_CONFIG_INFO; |
| typedef union u_pxe_db_get_config_info { |
| PXE_PCI_CONFIG_INFO pci; |
| PXE_PCC_CONFIG_INFO pcc; |
| PXE_USB_CONFIG_INFO usb; |
| PXE_1394_CONFIG_INFO _1394; |
| } PXE_DB_GET_CONFIG_INFO; |
| typedef struct s_pxe_cpb_initialize { |
| // |
| // Address of first (lowest) byte of the memory buffer. This buffer must |
| // be in contiguous physical memory and cannot be swapped out. The UNDI |
| // will be using this for transmit and receive buffering. |
| // |
| PXE_UINT64 MemoryAddr; |
| // |
| // MemoryLength must be greater than or equal to MemoryRequired |
| // returned by the Get Init Info command. |
| // |
| PXE_UINT32 MemoryLength; |
| // |
| // Desired link speed in Mbit/sec. Common ethernet values are 10, 100 |
| // and 1000. Setting a value of zero will auto-detect and/or use the |
| // default link speed (operation depends on UNDI/NIC functionality). |
| // |
| PXE_UINT32 LinkSpeed; |
| // |
| // Suggested number and size of receive and transmit buffers to |
| // allocate. If MemoryAddr and MemoryLength are non-zero, this |
| // allocation comes out of the supplied memory buffer. If MemoryAddr |
| // and MemoryLength are zero, this allocation comes out of memory |
| // on the NIC. |
| // |
| // If these fields are set to zero, the UNDI will allocate buffer |
| // counts and sizes as it sees fit. |
| // |
| PXE_UINT16 TxBufCnt; |
| PXE_UINT16 TxBufSize; |
| PXE_UINT16 RxBufCnt; |
| PXE_UINT16 RxBufSize; |
| // |
| // The following configuration parameters are optional and must be zero |
| // to use the default values. |
| // |
| PXE_UINT8 Duplex; |
| PXE_UINT8 LoopBack; |
| } PXE_CPB_INITIALIZE; |
| #define PXE_DUPLEX_DEFAULT 0x00 |
| #define PXE_FORCE_FULL_DUPLEX 0x01 |
| #define PXE_ENABLE_FULL_DUPLEX 0x02 |
| #define LOOPBACK_NORMAL 0 |
| #define LOOPBACK_INTERNAL 1 |
| #define LOOPBACK_EXTERNAL 2 |
| typedef struct s_pxe_db_initialize { |
| // |
| // Actual amount of memory used from the supplied memory buffer. This |
| // may be less that the amount of memory suppllied and may be zero if |
| // the UNDI and network device do not use external memory buffers. |
| // |
| // Memory used by the UNDI and network device is allocated from the |
| // lowest memory buffer address. |
| // |
| PXE_UINT32 MemoryUsed; |
| // |
| // Actual number and size of receive and transmit buffers that were |
| // allocated. |
| // |
| PXE_UINT16 TxBufCnt; |
| PXE_UINT16 TxBufSize; |
| PXE_UINT16 RxBufCnt; |
| PXE_UINT16 RxBufSize; |
| } PXE_DB_INITIALIZE; |
| typedef struct s_pxe_cpb_receive_filters { |
| // |
| // List of multicast MAC addresses. This list, if present, will |
| // replace the existing multicast MAC address filter list. |
| // |
| PXE_MAC_ADDR MCastList[MAX_MCAST_ADDRESS_CNT]; |
| } PXE_CPB_RECEIVE_FILTERS; |
| typedef struct s_pxe_db_receive_filters { |
| // |
| // Filtered multicast MAC address list. |
| // |
| PXE_MAC_ADDR MCastList[MAX_MCAST_ADDRESS_CNT]; |
| } PXE_DB_RECEIVE_FILTERS; |
| typedef struct s_pxe_cpb_station_address { |
| // |
| // If supplied and supported, the current station MAC address |
| // will be changed. |
| // |
| PXE_MAC_ADDR StationAddr; |
| } PXE_CPB_STATION_ADDRESS; |
| typedef struct s_pxe_dpb_station_address { |
| // |
| // Current station MAC address. |
| // |
| PXE_MAC_ADDR StationAddr; |
| // |
| // Station broadcast MAC address. |
| // |
| PXE_MAC_ADDR BroadcastAddr; |
| // |
| // Permanent station MAC address. |
| // |
| PXE_MAC_ADDR PermanentAddr; |
| } PXE_DB_STATION_ADDRESS; |
| typedef struct s_pxe_db_statistics { |
| // |
| // Bit field identifying what statistic data is collected by the |
| // UNDI/NIC. |
| // If bit 0x00 is set, Data[0x00] is collected. |
| // If bit 0x01 is set, Data[0x01] is collected. |
| // If bit 0x20 is set, Data[0x20] is collected. |
| // If bit 0x21 is set, Data[0x21] is collected. |
| // Etc. |
| // |
| PXE_UINT64 Supported; |
| // |
| // Statistic data. |
| // |
| PXE_UINT64 Data[64]; |
| } PXE_DB_STATISTICS; |
| // |
| // Total number of frames received. Includes frames with errors and |
| // dropped frames. |
| // |
| #define PXE_STATISTICS_RX_TOTAL_FRAMES 0x00 |
| // |
| // Number of valid frames received and copied into receive buffers. |
| // |
| #define PXE_STATISTICS_RX_GOOD_FRAMES 0x01 |
| // |
| // Number of frames below the minimum length for the media. |
| // This would be <64 for ethernet. |
| // |
| #define PXE_STATISTICS_RX_UNDERSIZE_FRAMES 0x02 |
| // |
| // Number of frames longer than the maxminum length for the |
| // media. This would be >1500 for ethernet. |
| // |
| #define PXE_STATISTICS_RX_OVERSIZE_FRAMES 0x03 |
| // |
| // Valid frames that were dropped because receive buffers were full. |
| // |
| #define PXE_STATISTICS_RX_DROPPED_FRAMES 0x04 |
| // |
| // Number of valid unicast frames received and not dropped. |
| // |
| #define PXE_STATISTICS_RX_UNICAST_FRAMES 0x05 |
| // |
| // Number of valid broadcast frames received and not dropped. |
| // |
| #define PXE_STATISTICS_RX_BROADCAST_FRAMES 0x06 |
| // |
| // Number of valid mutlicast frames received and not dropped. |
| // |
| #define PXE_STATISTICS_RX_MULTICAST_FRAMES 0x07 |
| // |
| // Number of frames w/ CRC or alignment errors. |
| // |
| #define PXE_STATISTICS_RX_CRC_ERROR_FRAMES 0x08 |
| // |
| // Total number of bytes received. Includes frames with errors |
| // and dropped frames. |
| // |
| #define PXE_STATISTICS_RX_TOTAL_BYTES 0x09 |
| // |
| // Transmit statistics. |
| // |
| #define PXE_STATISTICS_TX_TOTAL_FRAMES 0x0A |
| #define PXE_STATISTICS_TX_GOOD_FRAMES 0x0B |
| #define PXE_STATISTICS_TX_UNDERSIZE_FRAMES 0x0C |
| #define PXE_STATISTICS_TX_OVERSIZE_FRAMES 0x0D |
| #define PXE_STATISTICS_TX_DROPPED_FRAMES 0x0E |
| #define PXE_STATISTICS_TX_UNICAST_FRAMES 0x0F |
| #define PXE_STATISTICS_TX_BROADCAST_FRAMES 0x10 |
| #define PXE_STATISTICS_TX_MULTICAST_FRAMES 0x11 |
| #define PXE_STATISTICS_TX_CRC_ERROR_FRAMES 0x12 |
| #define PXE_STATISTICS_TX_TOTAL_BYTES 0x13 |
| // |
| // Number of collisions detection on this subnet. |
| // |
| #define PXE_STATISTICS_COLLISIONS 0x14 |
| // |
| // Number of frames destined for unsupported protocol. |
| // |
| #define PXE_STATISTICS_UNSUPPORTED_PROTOCOL 0x15 |
| typedef struct s_pxe_cpb_mcast_ip_to_mac { |
| // |
| // Multicast IP address to be converted to multicast MAC address. |
| // |
| PXE_IP_ADDR IP; |
| } PXE_CPB_MCAST_IP_TO_MAC; |
| typedef struct s_pxe_db_mcast_ip_to_mac { |
| // |
| // Multicast MAC address. |
| // |
| PXE_MAC_ADDR MAC; |
| } PXE_DB_MCAST_IP_TO_MAC; |
| typedef struct s_pxe_cpb_nvdata_sparse { |
| // |
| // NvData item list. Only items in this list will be updated. |
| // |
| struct { |
| // Non-volatile storage address to be changed. |
| PXE_UINT32 Addr; |
| // Data item to write into above storage address. |
| union { |
| PXE_UINT8 Byte; |
| PXE_UINT16 Word; |
| PXE_UINT32 Dword; |
| } Data; |
| } Item[MAX_EEPROM_LEN]; |
| } PXE_CPB_NVDATA_SPARSE; |
| // |
| // When using bulk update, the size of the CPB structure must be |
| // the same size as the non-volatile NIC storage. |
| // |
| typedef union u_pxe_cpb_nvdata_bulk { |
| // |
| // Array of byte-wide data items. |
| // |
| PXE_UINT8 Byte[MAX_EEPROM_LEN << 2]; |
| // |
| // Array of word-wide data items. |
| // |
| PXE_UINT16 Word[MAX_EEPROM_LEN << 1]; |
| // |
| // Array of dword-wide data items. |
| // |
| PXE_UINT32 Dword[MAX_EEPROM_LEN]; |
| } PXE_CPB_NVDATA_BULK; |
| typedef struct s_pxe_db_nvdata { |
| // Arrays of data items from non-volatile storage. |
| union { |
| // |
| // Array of byte-wide data items. |
| // |
| PXE_UINT8 Byte[MAX_EEPROM_LEN << 2]; |
| // |
| // Array of word-wide data items. |
| // |
| PXE_UINT16 Word[MAX_EEPROM_LEN << 1]; |
| // Array of dword-wide data items. |
| PXE_UINT32 Dword[MAX_EEPROM_LEN]; |
| } Data; |
| } PXE_DB_NVDATA; |
| typedef struct s_pxe_db_get_status { |
| // |
| // Length of next receive frame (header + data). If this is zero, |
| // there is no next receive frame available. |
| // |
| PXE_UINT32 RxFrameLen; |
| // |
| // Reserved, set to zero. |
| // |
| PXE_UINT32 reserved; |
| // |
| // Addresses of transmitted buffers that need to be recycled. |
| // |
| PXE_UINT64 TxBuffer[MAX_XMIT_BUFFERS]; |
| } PXE_DB_GET_STATUS; |
| typedef struct s_pxe_cpb_fill_header { |
| // |
| // Source and destination MAC addresses. These will be copied into |
| // the media header without doing byte swapping. |
| // |
| PXE_MAC_ADDR SrcAddr; |
| PXE_MAC_ADDR DestAddr; |
| // |
| // Address of first byte of media header. The first byte of packet data |
| // follows the last byte of the media header. |
| // |
| PXE_UINT64 MediaHeader; |
| // |
| // Length of packet data in bytes (not including the media header). |
| // |
| PXE_UINT32 PacketLen; |
| // |
| // Protocol type. This will be copied into the media header without |
| // doing byte swapping. Protocol type numbers can be obtained from |
| // the Assigned Numbers RFC 1700. |
| // |
| PXE_UINT16 Protocol; |
| // |
| // Length of the media header in bytes. |
| // |
| PXE_UINT16 MediaHeaderLen; |
| } PXE_CPB_FILL_HEADER; |
| #define PXE_PROTOCOL_ETHERNET_IP 0x0800 |
| #define PXE_PROTOCOL_ETHERNET_ARP 0x0806 |
| #define MAX_XMIT_FRAGMENTS 16 |
| typedef struct s_pxe_cpb_fill_header_fragmented { |
| // |
| // Source and destination MAC addresses. These will be copied into |
| // the media header without doing byte swapping. |
| // |
| PXE_MAC_ADDR SrcAddr; |
| PXE_MAC_ADDR DestAddr; |
| // |
| // Length of packet data in bytes (not including the media header). |
| // |
| PXE_UINT32 PacketLen; |
| // |
| // Protocol type. This will be copied into the media header without |
| // doing byte swapping. Protocol type numbers can be obtained from |
| // the Assigned Numbers RFC 1700. |
| // |
| PXE_MEDIA_PROTOCOL Protocol; |
| // |
| // Length of the media header in bytes. |
| // |
| PXE_UINT16 MediaHeaderLen; |
| // |
| // Number of packet fragment descriptors. |
| // |
| PXE_UINT16 FragCnt; |
| // |
| // Reserved, must be set to zero. |
| // |
| PXE_UINT16 reserved; |
| // |
| // Array of packet fragment descriptors. The first byte of the media |
| // header is the first byte of the first fragment. |
| // |
| struct { |
| // |
| // Address of this packet fragment. |
| // |
| PXE_UINT64 FragAddr; |
| // |
| // Length of this packet fragment. |
| // |
| PXE_UINT32 FragLen; |
| // |
| // Reserved, must be set to zero. |
| // |
| PXE_UINT32 reserved; |
| } FragDesc[MAX_XMIT_FRAGMENTS]; |
| } PXE_CPB_FILL_HEADER_FRAGMENTED; |
| typedef struct s_pxe_cpb_transmit { |
| // |
| // Address of first byte of frame buffer. This is also the first byte |
| // of the media header. |
| // |
| PXE_UINT64 FrameAddr; |
| // |
| // Length of the data portion of the frame buffer in bytes. Do not |
| // include the length of the media header. |
| // |
| PXE_UINT32 DataLen; |
| // |
| // Length of the media header in bytes. |
| // |
| PXE_UINT16 MediaheaderLen; |
| // |
| // Reserved, must be zero. |
| // |
| PXE_UINT16 reserved; |
| } PXE_CPB_TRANSMIT; |
| typedef struct s_pxe_cpb_transmit_fragments { |
| // |
| // Length of packet data in bytes (not including the media header). |
| // |
| PXE_UINT32 FrameLen; |
| // |
| // Length of the media header in bytes. |
| // |
| PXE_UINT16 MediaheaderLen; |
| // |
| // Number of packet fragment descriptors. |
| // |
| PXE_UINT16 FragCnt; |
| // |
| // Array of frame fragment descriptors. The first byte of the first |
| // fragment is also the first byte of the media header. |
| // |
| struct { |
| // |
| // Address of this frame fragment. |
| // |
| PXE_UINT64 FragAddr; |
| // |
| // Length of this frame fragment. |
| // |
| PXE_UINT32 FragLen; |
| // |
| // Reserved, must be set to zero. |
| // |
| PXE_UINT32 reserved; |
| } FragDesc[MAX_XMIT_FRAGMENTS]; |
| } PXE_CPB_TRANSMIT_FRAGMENTS; |
| typedef struct s_pxe_cpb_receive { |
| // |
| // Address of first byte of receive buffer. This is also the first byte |
| // of the frame header. |
| // |
| PXE_UINT64 BufferAddr; |
| // |
| // Length of receive buffer. This must be large enough to hold the |
| // received frame (media header + data). If the length of smaller than |
| // the received frame, data will be lost. |
| // |
| PXE_UINT32 BufferLen; |
| // |
| // Reserved, must be set to zero. |
| // |
| PXE_UINT32 reserved; |
| } PXE_CPB_RECEIVE; |
| typedef struct s_pxe_db_receive { |
| // |
| // Source and destination MAC addresses from media header. |
| // |
| PXE_MAC_ADDR SrcAddr; |
| PXE_MAC_ADDR DestAddr; |
| // |
| // Length of received frame. May be larger than receive buffer size. |
| // The receive buffer will not be overwritten. This is how to tell |
| // if data was lost because the receive buffer was too small. |
| // |
| PXE_UINT32 FrameLen; |
| // |
| // Protocol type from media header. |
| // |
| PXE_MEDIA_PROTOCOL Protocol; |
| // |
| // Length of media header in received frame. |
| // |
| PXE_UINT16 MediaHeaderLen; |
| // |
| // Type of receive frame. |
| // |
| PXE_FRAME_TYPE Type; |
| // |
| // Reserved, must be zero. |
| // |
| PXE_UINT8 reserved[7]; |
| } PXE_DB_RECEIVE; |
| #pragma pack() |
| /* EOF - efi_pxe.h */ |
| #endif /* _EFI_PXE_H */ |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/pci22.h |
|---|
| 0,0 → 1,193 |
| #ifndef _PCI22_H |
| #define _PCI22_H |
| /*++ |
| Copyright (c) 1999 Intel Corporation |
| Module Name: |
| pci22.h |
| Abstract: |
| Support for PCI 2.2 standard. |
| Revision History |
| --*/ |
| #ifdef SOFT_SDV |
| #define PCI_MAX_BUS 1 |
| #else |
| #define PCI_MAX_BUS 255 |
| #endif |
| #define PCI_MAX_DEVICE 31 |
| #define PCI_MAX_FUNC 7 |
| // |
| // Command |
| // |
| #define PCI_VGA_PALETTE_SNOOP_DISABLED 0x20 |
| #pragma pack(1) |
| typedef struct { |
| UINT16 VendorId; |
| UINT16 DeviceId; |
| UINT16 Command; |
| UINT16 Status; |
| UINT8 RevisionID; |
| UINT8 ClassCode[3]; |
| UINT8 CacheLineSize; |
| UINT8 LaytencyTimer; |
| UINT8 HeaderType; |
| UINT8 BIST; |
| } PCI_DEVICE_INDEPENDENT_REGION; |
| typedef struct { |
| UINT32 Bar[6]; |
| UINT32 CISPtr; |
| UINT16 SubsystemVendorID; |
| UINT16 SubsystemID; |
| UINT32 ExpansionRomBar; |
| UINT32 Reserved[2]; |
| UINT8 InterruptLine; |
| UINT8 InterruptPin; |
| UINT8 MinGnt; |
| UINT8 MaxLat; |
| } PCI_DEVICE_HEADER_TYPE_REGION; |
| typedef struct { |
| PCI_DEVICE_INDEPENDENT_REGION Hdr; |
| PCI_DEVICE_HEADER_TYPE_REGION Device; |
| } PCI_TYPE00; |
| typedef struct { |
| UINT32 Bar[2]; |
| UINT8 PrimaryBus; |
| UINT8 SecondaryBus; |
| UINT8 SubordinateBus; |
| UINT8 SecondaryLatencyTimer; |
| UINT8 IoBase; |
| UINT8 IoLimit; |
| UINT16 SecondaryStatus; |
| UINT16 MemoryBase; |
| UINT16 MemoryLimit; |
| UINT16 PrefetchableMemoryBase; |
| UINT16 PrefetchableMemoryLimit; |
| UINT32 PrefetchableBaseUpper32; |
| UINT32 PrefetchableLimitUpper32; |
| UINT16 IoBaseUpper16; |
| UINT16 IoLimitUpper16; |
| UINT32 Reserved; |
| UINT32 ExpansionRomBAR; |
| UINT8 InterruptLine; |
| UINT8 InterruptPin; |
| UINT16 BridgeControl; |
| } PCI_BRIDGE_CONTROL_REGISTER; |
| #define PCI_CLASS_DISPLAY_CTRL 0x03 |
| #define PCI_CLASS_VGA 0x00 |
| #define PCI_CLASS_BRIDGE 0x06 |
| #define PCI_CLASS_ISA 0x01 |
| #define PCI_CLASS_ISA_POSITIVE_DECODE 0x80 |
| #define PCI_CLASS_NETWORK 0x02 |
| #define PCI_CLASS_ETHERNET 0x00 |
| #define HEADER_TYPE_DEVICE 0x00 |
| #define HEADER_TYPE_PCI_TO_PCI_BRIDGE 0x01 |
| #define HEADER_TYPE_MULTI_FUNCTION 0x80 |
| #define HEADER_LAYOUT_CODE 0x7f |
| #define IS_PCI_BRIDGE(_p) ((((_p)->Hdr.HeaderType) & HEADER_LAYOUT_CODE) == HEADER_TYPE_PCI_TO_PCI_BRIDGE) |
| #define IS_PCI_MULTI_FUNC(_p) (((_p)->Hdr.HeaderType) & HEADER_TYPE_MULTI_FUNCTION) |
| typedef struct { |
| PCI_DEVICE_INDEPENDENT_REGION Hdr; |
| PCI_BRIDGE_CONTROL_REGISTER Bridge; |
| } PCI_TYPE01; |
| typedef struct { |
| UINT8 Register; |
| UINT8 Function; |
| UINT8 Device; |
| UINT8 Bus; |
| UINT8 Reserved[4]; |
| } DEFIO_PCI_ADDR; |
| typedef struct { |
| UINT32 Reg : 8; |
| UINT32 Func : 3; |
| UINT32 Dev : 5; |
| UINT32 Bus : 8; |
| UINT32 Reserved: 7; |
| UINT32 Enable : 1; |
| } PCI_CONFIG_ACCESS_CF8; |
| #pragma pack() |
| #define EFI_ROOT_BRIDGE_LIST 'eprb' |
| typedef struct { |
| UINTN Signature; |
| UINT16 BridgeNumber; |
| UINT16 PrimaryBus; |
| UINT16 SubordinateBus; |
| EFI_DEVICE_PATH *DevicePath; |
| LIST_ENTRY Link; |
| } PCI_ROOT_BRIDGE_ENTRY; |
| #define PCI_EXPANSION_ROM_HEADER_SIGNATURE 0xaa55 |
| #define EFI_PCI_EXPANSION_ROM_HEADER_EFISIGNATURE 0x0EF1 |
| #define PCI_DATA_STRUCTURE_SIGNATURE EFI_SIGNATURE_32('P','C','I','R') |
| #pragma pack(1) |
| typedef struct { |
| UINT16 Signature; // 0xaa55 |
| UINT8 Reserved[0x16]; |
| UINT16 PcirOffset; |
| } PCI_EXPANSION_ROM_HEADER; |
| typedef struct { |
| UINT16 Signature; // 0xaa55 |
| UINT16 InitializationSize; |
| UINT16 EfiSignature; // 0x0EF1 |
| UINT16 EfiSubsystem; |
| UINT16 EfiMachineType; |
| UINT8 Reserved[0x0A]; |
| UINT16 EfiImageHeaderOffset; |
| UINT16 PcirOffset; |
| } EFI_PCI_EXPANSION_ROM_HEADER; |
| typedef struct { |
| UINT32 Signature; // "PCIR" |
| UINT16 VendorId; |
| UINT16 DeviceId; |
| UINT16 Reserved0; |
| UINT16 Length; |
| UINT8 Revision; |
| UINT8 ClassCode[3]; |
| UINT16 ImageLength; |
| UINT16 CodeRevision; |
| UINT8 CodeType; |
| UINT8 Indicator; |
| UINT16 Reserved1; |
| } PCI_DATA_STRUCTURE; |
| #pragma pack() |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/efilink.h |
|---|
| 0,0 → 1,177 |
| #ifndef _EFI_LINK_H |
| #define _EFI_LINK_H |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| link.h (renamed efilink.h to avoid conflicts) |
| Abstract: |
| EFI link list macro's |
| Revision History |
| --*/ |
| #ifndef EFI_NT_EMUL |
| // |
| // List entry - doubly linked list |
| // |
| typedef struct _LIST_ENTRY { |
| struct _LIST_ENTRY *Flink; |
| struct _LIST_ENTRY *Blink; |
| } LIST_ENTRY; |
| #endif |
| // |
| // VOID |
| // InitializeListHead( |
| // LIST_ENTRY *ListHead |
| // ); |
| // |
| #define InitializeListHead(ListHead) \ |
| (ListHead)->Flink = ListHead; \ |
| (ListHead)->Blink = ListHead; |
| // |
| // BOOLEAN |
| // IsListEmpty( |
| // PLIST_ENTRY ListHead |
| // ); |
| // |
| #define IsListEmpty(ListHead) \ |
| ((ListHead)->Flink == (ListHead)) |
| // |
| // VOID |
| // RemoveEntryList( |
| // PLIST_ENTRY Entry |
| // ); |
| // |
| #define _RemoveEntryList(Entry) { \ |
| LIST_ENTRY *_Blink, *_Flink; \ |
| _Flink = (Entry)->Flink; \ |
| _Blink = (Entry)->Blink; \ |
| _Blink->Flink = _Flink; \ |
| _Flink->Blink = _Blink; \ |
| } |
| #if EFI_DEBUG |
| #define RemoveEntryList(Entry) \ |
| _RemoveEntryList(Entry); \ |
| (Entry)->Flink = (LIST_ENTRY *) BAD_POINTER; \ |
| (Entry)->Blink = (LIST_ENTRY *) BAD_POINTER; |
| #else |
| #define RemoveEntryList(Entry) \ |
| _RemoveEntryList(Entry); |
| #endif |
| // |
| // VOID |
| // InsertTailList( |
| // PLIST_ENTRY ListHead, |
| // PLIST_ENTRY Entry |
| // ); |
| // |
| #define InsertTailList(ListHead,Entry) {\ |
| LIST_ENTRY *_ListHead, *_Blink; \ |
| _ListHead = (ListHead); \ |
| _Blink = _ListHead->Blink; \ |
| (Entry)->Flink = _ListHead; \ |
| (Entry)->Blink = _Blink; \ |
| _Blink->Flink = (Entry); \ |
| _ListHead->Blink = (Entry); \ |
| } |
| // |
| // VOID |
| // InsertHeadList( |
| // PLIST_ENTRY ListHead, |
| // PLIST_ENTRY Entry |
| // ); |
| // |
| #define InsertHeadList(ListHead,Entry) {\ |
| LIST_ENTRY *_ListHead, *_Flink; \ |
| _ListHead = (ListHead); \ |
| _Flink = _ListHead->Flink; \ |
| (Entry)->Flink = _Flink; \ |
| (Entry)->Blink = _ListHead; \ |
| _Flink->Blink = (Entry); \ |
| _ListHead->Flink = (Entry); \ |
| } |
| // VOID |
| // SwapListEntries( |
| // PLIST_ENTRY Entry1, |
| // PLIST_ENTRY Entry2 |
| // ); |
| // |
| // Put Entry2 before Entry1 |
| // |
| #define SwapListEntries(Entry1,Entry2) {\ |
| LIST_ENTRY *Entry1Flink, *Entry1Blink; \ |
| LIST_ENTRY *Entry2Flink, *Entry2Blink; \ |
| Entry2Flink = (Entry2)->Flink; \ |
| Entry2Blink = (Entry2)->Blink; \ |
| Entry1Flink = (Entry1)->Flink; \ |
| Entry1Blink = (Entry1)->Blink; \ |
| Entry2Blink->Flink = Entry2Flink; \ |
| Entry2Flink->Blink = Entry2Blink; \ |
| (Entry2)->Flink = Entry1; \ |
| (Entry2)->Blink = Entry1Blink; \ |
| Entry1Blink->Flink = (Entry2); \ |
| (Entry1)->Blink = (Entry2); \ |
| } |
| // |
| // EFI_FIELD_OFFSET - returns the byte offset to a field within a structure |
| // |
| #define EFI_FIELD_OFFSET(TYPE,Field) ((UINTN)(&(((TYPE *) 0)->Field))) |
| // |
| // CONTAINING_RECORD - returns a pointer to the structure |
| // from one of it's elements. |
| // |
| #define _CR(Record, TYPE, Field) \ |
| ((TYPE *) ( (CHAR8 *)(Record) - (CHAR8 *) &(((TYPE *) 0)->Field))) |
| #if EFI_DEBUG |
| #define CR(Record, TYPE, Field, Sig) \ |
| _CR(Record, TYPE, Field)->Signature != Sig ? \ |
| (TYPE *) ASSERT_STRUCT(_CR(Record, TYPE, Field), Record) : \ |
| _CR(Record, TYPE, Field) |
| #else |
| #define CR(Record, TYPE, Field, Signature) \ |
| _CR(Record, TYPE, Field) |
| #endif |
| // |
| // A lock structure |
| // |
| typedef struct _FLOCK { |
| EFI_TPL Tpl; |
| EFI_TPL OwnerTpl; |
| UINTN Lock; |
| } FLOCK; |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/efidevp.h |
|---|
| 0,0 → 1,393 |
| #ifndef _DEVPATH_H |
| #define _DEVPATH_H |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| devpath.h |
| Abstract: |
| Defines for parsing the EFI Device Path structures |
| Revision History |
| --*/ |
| // |
| // Device Path structures - Section C |
| // |
| typedef struct _EFI_DEVICE_PATH { |
| UINT8 Type; |
| UINT8 SubType; |
| UINT8 Length[2]; |
| } EFI_DEVICE_PATH; |
| #define EFI_DP_TYPE_MASK 0x7F |
| #define EFI_DP_TYPE_UNPACKED 0x80 |
| //#define END_DEVICE_PATH_TYPE 0xff |
| #define END_DEVICE_PATH_TYPE 0x7f |
| //#define END_DEVICE_PATH_TYPE_UNPACKED 0x7f |
| #define END_ENTIRE_DEVICE_PATH_SUBTYPE 0xff |
| #define END_INSTANCE_DEVICE_PATH_SUBTYPE 0x01 |
| #define END_DEVICE_PATH_LENGTH (sizeof(EFI_DEVICE_PATH)) |
| #define DP_IS_END_TYPE(a) |
| #define DP_IS_END_SUBTYPE(a) ( ((a)->SubType == END_ENTIRE_DEVICE_PATH_SUBTYPE ) |
| #define DevicePathType(a) ( ((a)->Type) & EFI_DP_TYPE_MASK ) |
| #define DevicePathSubType(a) ( (a)->SubType ) |
| #define DevicePathNodeLength(a) ( ((a)->Length[0]) | ((a)->Length[1] << 8) ) |
| #define NextDevicePathNode(a) ( (EFI_DEVICE_PATH *) ( ((UINT8 *) (a)) + DevicePathNodeLength(a))) |
| //#define IsDevicePathEndType(a) ( DevicePathType(a) == END_DEVICE_PATH_TYPE_UNPACKED ) |
| #define IsDevicePathEndType(a) ( DevicePathType(a) == END_DEVICE_PATH_TYPE ) |
| #define IsDevicePathEndSubType(a) ( (a)->SubType == END_ENTIRE_DEVICE_PATH_SUBTYPE ) |
| #define IsDevicePathEnd(a) ( IsDevicePathEndType(a) && IsDevicePathEndSubType(a) ) |
| #define IsDevicePathUnpacked(a) ( (a)->Type & EFI_DP_TYPE_UNPACKED ) |
| #define SetDevicePathNodeLength(a,l) { \ |
| (a)->Length[0] = (UINT8) (l); \ |
| (a)->Length[1] = (UINT8) ((l) >> 8); \ |
| } |
| #define SetDevicePathEndNode(a) { \ |
| (a)->Type = END_DEVICE_PATH_TYPE; \ |
| (a)->SubType = END_ENTIRE_DEVICE_PATH_SUBTYPE; \ |
| (a)->Length[0] = sizeof(EFI_DEVICE_PATH); \ |
| (a)->Length[1] = 0; \ |
| } |
| /* |
| * |
| */ |
| #define HARDWARE_DEVICE_PATH 0x01 |
| #define HW_PCI_DP 0x01 |
| typedef struct _PCI_DEVICE_PATH { |
| EFI_DEVICE_PATH Header; |
| UINT8 Function; |
| UINT8 Device; |
| } PCI_DEVICE_PATH; |
| #define HW_PCCARD_DP 0x02 |
| typedef struct _PCCARD_DEVICE_PATH { |
| EFI_DEVICE_PATH Header; |
| UINT8 SocketNumber; |
| } PCCARD_DEVICE_PATH; |
| #define HW_MEMMAP_DP 0x03 |
| typedef struct _MEMMAP_DEVICE_PATH { |
| EFI_DEVICE_PATH Header; |
| UINT32 MemoryType; |
| EFI_PHYSICAL_ADDRESS StartingAddress; |
| EFI_PHYSICAL_ADDRESS EndingAddress; |
| } MEMMAP_DEVICE_PATH; |
| #define HW_VENDOR_DP 0x04 |
| typedef struct _VENDOR_DEVICE_PATH { |
| EFI_DEVICE_PATH Header; |
| EFI_GUID Guid; |
| } VENDOR_DEVICE_PATH; |
| #define UNKNOWN_DEVICE_GUID \ |
| { 0xcf31fac5, 0xc24e, 0x11d2, {0x85, 0xf3, 0x0, 0xa0, 0xc9, 0x3e, 0xc9, 0x3b} } |
| typedef struct _UKNOWN_DEVICE_VENDOR_DP { |
| VENDOR_DEVICE_PATH DevicePath; |
| UINT8 LegacyDriveLetter; |
| } UNKNOWN_DEVICE_VENDOR_DEVICE_PATH; |
| #define HW_CONTROLLER_DP 0x05 |
| typedef struct _CONTROLLER_DEVICE_PATH { |
| EFI_DEVICE_PATH Header; |
| UINT32 Controller; |
| } CONTROLLER_DEVICE_PATH; |
| /* |
| * |
| */ |
| #define ACPI_DEVICE_PATH 0x02 |
| #define ACPI_DP 0x01 |
| typedef struct _ACPI_HID_DEVICE_PATH { |
| EFI_DEVICE_PATH Header; |
| UINT32 HID; |
| UINT32 UID; |
| } ACPI_HID_DEVICE_PATH; |
| // |
| // EISA ID Macro |
| // EISA ID Definition 32-bits |
| // bits[15:0] - three character compressed ASCII EISA ID. |
| // bits[31:16] - binary number |
| // Compressed ASCII is 5 bits per character 0b00001 = 'A' 0b11010 = 'Z' |
| // |
| #define PNP_EISA_ID_CONST 0x41d0 |
| #define EISA_ID(_Name, _Num) ((UINT32) ((_Name) | (_Num) << 16)) |
| #define EISA_PNP_ID(_PNPId) (EISA_ID(PNP_EISA_ID_CONST, (_PNPId))) |
| #define PNP_EISA_ID_MASK 0xffff |
| #define EISA_ID_TO_NUM(_Id) ((_Id) >> 16) |
| /* |
| * |
| */ |
| #define MESSAGING_DEVICE_PATH 0x03 |
| #define MSG_ATAPI_DP 0x01 |
| typedef struct _ATAPI_DEVICE_PATH { |
| EFI_DEVICE_PATH Header; |
| UINT8 PrimarySecondary; |
| UINT8 SlaveMaster; |
| UINT16 Lun; |
| } ATAPI_DEVICE_PATH; |
| #define MSG_SCSI_DP 0x02 |
| typedef struct _SCSI_DEVICE_PATH { |
| EFI_DEVICE_PATH Header; |
| UINT16 Pun; |
| UINT16 Lun; |
| } SCSI_DEVICE_PATH; |
| #define MSG_FIBRECHANNEL_DP 0x03 |
| typedef struct _FIBRECHANNEL_DEVICE_PATH { |
| EFI_DEVICE_PATH Header; |
| UINT32 Reserved; |
| UINT64 WWN; |
| UINT64 Lun; |
| } FIBRECHANNEL_DEVICE_PATH; |
| #define MSG_1394_DP 0x04 |
| typedef struct _F1394_DEVICE_PATH { |
| EFI_DEVICE_PATH Header; |
| UINT32 Reserved; |
| UINT64 Guid; |
| } F1394_DEVICE_PATH; |
| #define MSG_USB_DP 0x05 |
| typedef struct _USB_DEVICE_PATH { |
| EFI_DEVICE_PATH Header; |
| UINT8 Port; |
| UINT8 Endpoint; |
| } USB_DEVICE_PATH; |
| #define MSG_USB_CLASS_DP 0x0F |
| typedef struct _USB_CLASS_DEVICE_PATH { |
| EFI_DEVICE_PATH Header; |
| UINT16 VendorId; |
| UINT16 ProductId; |
| UINT8 DeviceClass; |
| UINT8 DeviceSubclass; |
| UINT8 DeviceProtocol; |
| } USB_CLASS_DEVICE_PATH; |
| #define MSG_I2O_DP 0x06 |
| typedef struct _I2O_DEVICE_PATH { |
| EFI_DEVICE_PATH Header; |
| UINT32 Tid; |
| } I2O_DEVICE_PATH; |
| #define MSG_MAC_ADDR_DP 0x0b |
| typedef struct _MAC_ADDR_DEVICE_PATH { |
| EFI_DEVICE_PATH Header; |
| EFI_MAC_ADDRESS MacAddress; |
| UINT8 IfType; |
| } MAC_ADDR_DEVICE_PATH; |
| #define MSG_IPv4_DP 0x0c |
| typedef struct _IPv4_DEVICE_PATH { |
| EFI_DEVICE_PATH Header; |
| EFI_IPv4_ADDRESS LocalIpAddress; |
| EFI_IPv4_ADDRESS RemoteIpAddress; |
| UINT16 LocalPort; |
| UINT16 RemotePort; |
| UINT16 Protocol; |
| BOOLEAN StaticIpAddress; |
| } IPv4_DEVICE_PATH; |
| #define MSG_IPv6_DP 0x0d |
| typedef struct _IPv6_DEVICE_PATH { |
| EFI_DEVICE_PATH Header; |
| EFI_IPv6_ADDRESS LocalIpAddress; |
| EFI_IPv6_ADDRESS RemoteIpAddress; |
| UINT16 LocalPort; |
| UINT16 RemotePort; |
| UINT16 Protocol; |
| BOOLEAN StaticIpAddress; |
| } IPv6_DEVICE_PATH; |
| #define MSG_INFINIBAND_DP 0x09 |
| typedef struct _INFINIBAND_DEVICE_PATH { |
| EFI_DEVICE_PATH Header; |
| UINT32 Reserved; |
| UINT64 NodeGuid; |
| UINT64 IocGuid; |
| UINT64 DeviceId; |
| } INFINIBAND_DEVICE_PATH; |
| #define MSG_UART_DP 0x0e |
| typedef struct _UART_DEVICE_PATH { |
| EFI_DEVICE_PATH Header; |
| UINT32 Reserved; |
| UINT64 BaudRate; |
| UINT8 DataBits; |
| UINT8 Parity; |
| UINT8 StopBits; |
| } UART_DEVICE_PATH; |
| #define MSG_VENDOR_DP 0x0A |
| /* Use VENDOR_DEVICE_PATH struct */ |
| #define DEVICE_PATH_MESSAGING_PC_ANSI \ |
| { 0xe0c14753, 0xf9be, 0x11d2, {0x9a, 0x0c, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d} } |
| #define DEVICE_PATH_MESSAGING_VT_100 \ |
| { 0xdfa66065, 0xb419, 0x11d3, {0x9a, 0x2d, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d} } |
| #define MEDIA_DEVICE_PATH 0x04 |
| #define MEDIA_HARDDRIVE_DP 0x01 |
| typedef struct _HARDDRIVE_DEVICE_PATH { |
| EFI_DEVICE_PATH Header; |
| UINT32 PartitionNumber; |
| UINT64 PartitionStart; |
| UINT64 PartitionSize; |
| UINT8 Signature[16]; |
| UINT8 MBRType; |
| UINT8 SignatureType; |
| } HARDDRIVE_DEVICE_PATH; |
| #define MBR_TYPE_PCAT 0x01 |
| #define MBR_TYPE_EFI_PARTITION_TABLE_HEADER 0x02 |
| #define SIGNATURE_TYPE_MBR 0x01 |
| #define SIGNATURE_TYPE_GUID 0x02 |
| #define MEDIA_CDROM_DP 0x02 |
| typedef struct _CDROM_DEVICE_PATH { |
| EFI_DEVICE_PATH Header; |
| UINT32 BootEntry; |
| UINT64 PartitionStart; |
| UINT64 PartitionSize; |
| } CDROM_DEVICE_PATH; |
| #define MEDIA_VENDOR_DP 0x03 |
| /* Use VENDOR_DEVICE_PATH struct */ |
| #define MEDIA_FILEPATH_DP 0x04 |
| typedef struct _FILEPATH_DEVICE_PATH { |
| EFI_DEVICE_PATH Header; |
| CHAR16 PathName[1]; |
| } FILEPATH_DEVICE_PATH; |
| #define SIZE_OF_FILEPATH_DEVICE_PATH EFI_FIELD_OFFSET(FILEPATH_DEVICE_PATH,PathName) |
| #define MEDIA_PROTOCOL_DP 0x05 |
| typedef struct _MEDIA_PROTOCOL_DEVICE_PATH { |
| EFI_DEVICE_PATH Header; |
| EFI_GUID Protocol; |
| } MEDIA_PROTOCOL_DEVICE_PATH; |
| #define BBS_DEVICE_PATH 0x05 |
| #define BBS_BBS_DP 0x01 |
| typedef struct _BBS_BBS_DEVICE_PATH { |
| EFI_DEVICE_PATH Header; |
| UINT16 DeviceType; |
| UINT16 StatusFlag; |
| CHAR8 String[1]; |
| } BBS_BBS_DEVICE_PATH; |
| /* DeviceType definitions - from BBS specification */ |
| #define BBS_TYPE_FLOPPY 0x01 |
| #define BBS_TYPE_HARDDRIVE 0x02 |
| #define BBS_TYPE_CDROM 0x03 |
| #define BBS_TYPE_PCMCIA 0x04 |
| #define BBS_TYPE_USB 0x05 |
| #define BBS_TYPE_EMBEDDED_NETWORK 0x06 |
| #define BBS_TYPE_DEV 0x80 |
| #define BBS_TYPE_UNKNOWN 0xFF |
| typedef union { |
| EFI_DEVICE_PATH DevPath; |
| PCI_DEVICE_PATH Pci; |
| PCCARD_DEVICE_PATH PcCard; |
| MEMMAP_DEVICE_PATH MemMap; |
| VENDOR_DEVICE_PATH Vendor; |
| UNKNOWN_DEVICE_VENDOR_DEVICE_PATH UnknownVendor; |
| CONTROLLER_DEVICE_PATH Controller; |
| ACPI_HID_DEVICE_PATH Acpi; |
| ATAPI_DEVICE_PATH Atapi; |
| SCSI_DEVICE_PATH Scsi; |
| FIBRECHANNEL_DEVICE_PATH FibreChannel; |
| F1394_DEVICE_PATH F1394; |
| USB_DEVICE_PATH Usb; |
| USB_CLASS_DEVICE_PATH UsbClass; |
| I2O_DEVICE_PATH I2O; |
| MAC_ADDR_DEVICE_PATH MacAddr; |
| IPv4_DEVICE_PATH Ipv4; |
| IPv6_DEVICE_PATH Ipv6; |
| INFINIBAND_DEVICE_PATH InfiniBand; |
| UART_DEVICE_PATH Uart; |
| HARDDRIVE_DEVICE_PATH HardDrive; |
| CDROM_DEVICE_PATH CD; |
| FILEPATH_DEVICE_PATH FilePath; |
| MEDIA_PROTOCOL_DEVICE_PATH MediaProtocol; |
| BBS_BBS_DEVICE_PATH Bbs; |
| } EFI_DEV_PATH; |
| typedef union { |
| EFI_DEVICE_PATH *DevPath; |
| PCI_DEVICE_PATH *Pci; |
| PCCARD_DEVICE_PATH *PcCard; |
| MEMMAP_DEVICE_PATH *MemMap; |
| VENDOR_DEVICE_PATH *Vendor; |
| UNKNOWN_DEVICE_VENDOR_DEVICE_PATH *UnknownVendor; |
| CONTROLLER_DEVICE_PATH *Controller; |
| ACPI_HID_DEVICE_PATH *Acpi; |
| ATAPI_DEVICE_PATH *Atapi; |
| SCSI_DEVICE_PATH *Scsi; |
| FIBRECHANNEL_DEVICE_PATH *FibreChannel; |
| F1394_DEVICE_PATH *F1394; |
| USB_DEVICE_PATH *Usb; |
| USB_CLASS_DEVICE_PATH *UsbClass; |
| I2O_DEVICE_PATH *I2O; |
| MAC_ADDR_DEVICE_PATH *MacAddr; |
| IPv4_DEVICE_PATH *Ipv4; |
| IPv6_DEVICE_PATH *Ipv6; |
| INFINIBAND_DEVICE_PATH *InfiniBand; |
| UART_DEVICE_PATH *Uart; |
| HARDDRIVE_DEVICE_PATH *HardDrive; |
| FILEPATH_DEVICE_PATH *FilePath; |
| MEDIA_PROTOCOL_DEVICE_PATH *MediaProtocol; |
| CDROM_DEVICE_PATH *CD; |
| BBS_BBS_DEVICE_PATH *Bbs; |
| } EFI_DEV_PATH_PTR; |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/efidef.h |
|---|
| 0,0 → 1,195 |
| #ifndef _EFI_DEF_H |
| #define _EFI_DEF_H |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| efidef.h |
| Abstract: |
| EFI definitions |
| Revision History |
| --*/ |
| typedef UINT16 CHAR16; |
| typedef UINT8 CHAR8; |
| typedef UINT8 BOOLEAN; |
| #ifndef TRUE |
| #define TRUE ((BOOLEAN) 1) |
| #define FALSE ((BOOLEAN) 0) |
| #endif |
| #ifndef NULL |
| #define NULL ((VOID *) 0) |
| #endif |
| typedef UINTN EFI_STATUS; |
| typedef UINT64 EFI_LBA; |
| typedef UINTN EFI_TPL; |
| typedef VOID *EFI_HANDLE; |
| typedef VOID *EFI_EVENT; |
| // |
| // Prototype argument decoration for EFI parameters to indicate |
| // their direction |
| // |
| // IN - argument is passed into the function |
| // OUT - argument (pointer) is returned from the function |
| // OPTIONAL - argument is optional |
| // |
| #ifndef IN |
| #define IN |
| #define OUT |
| #define OPTIONAL |
| #endif |
| // |
| // A GUID |
| // |
| typedef struct { |
| UINT32 Data1; |
| UINT16 Data2; |
| UINT16 Data3; |
| UINT8 Data4[8]; |
| } EFI_GUID; |
| // |
| // Time |
| // |
| typedef struct { |
| UINT16 Year; // 1998 - 20XX |
| UINT8 Month; // 1 - 12 |
| UINT8 Day; // 1 - 31 |
| UINT8 Hour; // 0 - 23 |
| UINT8 Minute; // 0 - 59 |
| UINT8 Second; // 0 - 59 |
| UINT8 Pad1; |
| UINT32 Nanosecond; // 0 - 999,999,999 |
| INT16 TimeZone; // -1440 to 1440 or 2047 |
| UINT8 Daylight; |
| UINT8 Pad2; |
| } EFI_TIME; |
| // Bit definitions for EFI_TIME.Daylight |
| #define EFI_TIME_ADJUST_DAYLIGHT 0x01 |
| #define EFI_TIME_IN_DAYLIGHT 0x02 |
| // Value definition for EFI_TIME.TimeZone |
| #define EFI_UNSPECIFIED_TIMEZONE 0x07FF |
| // |
| // Networking |
| // |
| typedef struct { |
| UINT8 Addr[4]; |
| } EFI_IPv4_ADDRESS; |
| typedef struct { |
| UINT8 Addr[16]; |
| } EFI_IPv6_ADDRESS; |
| typedef struct { |
| UINT8 Addr[32]; |
| } EFI_MAC_ADDRESS; |
| // |
| // Memory |
| // |
| typedef UINT64 EFI_PHYSICAL_ADDRESS; |
| typedef UINT64 EFI_VIRTUAL_ADDRESS; |
| typedef enum { |
| AllocateAnyPages, |
| AllocateMaxAddress, |
| AllocateAddress, |
| MaxAllocateType |
| } EFI_ALLOCATE_TYPE; |
| //Preseve the attr on any range supplied. |
| //ConventialMemory must have WB,SR,SW when supplied. |
| //When allocating from ConventialMemory always make it WB,SR,SW |
| //When returning to ConventialMemory always make it WB,SR,SW |
| //When getting the memory map, or on RT for runtime types |
| typedef enum { |
| EfiReservedMemoryType, |
| EfiLoaderCode, |
| EfiLoaderData, |
| EfiBootServicesCode, |
| EfiBootServicesData, |
| EfiRuntimeServicesCode, |
| EfiRuntimeServicesData, |
| EfiConventionalMemory, |
| EfiUnusableMemory, |
| EfiACPIReclaimMemory, |
| EfiACPIMemoryNVS, |
| EfiMemoryMappedIO, |
| EfiMemoryMappedIOPortSpace, |
| EfiPalCode, |
| EfiMaxMemoryType |
| } EFI_MEMORY_TYPE; |
| // possible caching types for the memory range |
| #define EFI_MEMORY_UC 0x0000000000000001 |
| #define EFI_MEMORY_WC 0x0000000000000002 |
| #define EFI_MEMORY_WT 0x0000000000000004 |
| #define EFI_MEMORY_WB 0x0000000000000008 |
| #define EFI_MEMORY_UCE 0x0000000000000010 |
| // physical memory protection on range |
| #define EFI_MEMORY_WP 0x0000000000001000 |
| #define EFI_MEMORY_RP 0x0000000000002000 |
| #define EFI_MEMORY_XP 0x0000000000004000 |
| // range requires a runtime mapping |
| #define EFI_MEMORY_RUNTIME 0x8000000000000000 |
| #define EFI_MEMORY_DESCRIPTOR_VERSION 1 |
| typedef struct { |
| UINT32 Type; // Field size is 32 bits followed by 32 bit pad |
| EFI_PHYSICAL_ADDRESS PhysicalStart; // Field size is 64 bits |
| EFI_VIRTUAL_ADDRESS VirtualStart; // Field size is 64 bits |
| UINT64 NumberOfPages; // Field size is 64 bits |
| UINT64 Attribute; // Field size is 64 bits |
| } EFI_MEMORY_DESCRIPTOR; |
| // |
| // International Language |
| // |
| typedef UINT8 ISO_639_2; |
| #define ISO_639_2_ENTRY_SIZE 3 |
| // |
| // |
| // |
| #define EFI_PAGE_SIZE 4096 |
| #define EFI_PAGE_MASK 0xFFF |
| #define EFI_PAGE_SHIFT 12 |
| #define EFI_SIZE_TO_PAGES(a) \ |
| ( ((a) >> EFI_PAGE_SHIFT) + ((a) & EFI_PAGE_MASK ? 1 : 0) ) |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/libsmbios.h |
|---|
| 0,0 → 1,132 |
| #ifndef _LIB_SMBIOS_H |
| #define _LIB_SMBIOS_H |
| /*++ |
| Copyright (c) 2000 Intel Corporation |
| Module Name: |
| LibSmbios.h |
| Abstract: |
| Lib include for SMBIOS services. Used to get system serial number and GUID |
| Revision History |
| --*/ |
| // |
| // Define SMBIOS tables. |
| // |
| #pragma pack(1) |
| typedef struct { |
| UINT8 AnchorString[4]; |
| UINT8 EntryPointStructureChecksum; |
| UINT8 EntryPointLength; |
| UINT8 MajorVersion; |
| UINT8 MinorVersion; |
| UINT16 MaxStructureSize; |
| UINT8 EntryPointRevision; |
| UINT8 FormattedArea[5]; |
| UINT8 IntermediateAnchorString[5]; |
| UINT8 IntermediateChecksum; |
| UINT16 TableLength; |
| UINT32 TableAddress; |
| UINT16 NumberOfSmbiosStructures; |
| UINT8 SmbiosBcdRevision; |
| } SMBIOS_STRUCTURE_TABLE; |
| // |
| // Please note that SMBIOS structures can be odd byte aligned since the |
| // unformated section of each record is a set of arbitrary size strings. |
| // |
| typedef struct { |
| UINT8 Type; |
| UINT8 Length; |
| UINT8 Handle[2]; |
| } SMBIOS_HEADER; |
| typedef UINT8 SMBIOS_STRING; |
| typedef struct { |
| SMBIOS_HEADER Hdr; |
| SMBIOS_STRING Vendor; |
| SMBIOS_STRING BiosVersion; |
| UINT8 BiosSegment[2]; |
| SMBIOS_STRING BiosReleaseDate; |
| UINT8 BiosSize; |
| UINT8 BiosCharacteristics[8]; |
| } SMBIOS_TYPE0; |
| typedef struct { |
| SMBIOS_HEADER Hdr; |
| SMBIOS_STRING Manufacturer; |
| SMBIOS_STRING ProductName; |
| SMBIOS_STRING Version; |
| SMBIOS_STRING SerialNumber; |
| // |
| // always byte copy this data to prevent alignment faults! |
| // |
| EFI_GUID Uuid; |
| UINT8 WakeUpType; |
| } SMBIOS_TYPE1; |
| typedef struct { |
| SMBIOS_HEADER Hdr; |
| SMBIOS_STRING Manufacturer; |
| SMBIOS_STRING ProductName; |
| SMBIOS_STRING Version; |
| SMBIOS_STRING SerialNumber; |
| } SMBIOS_TYPE2; |
| typedef struct { |
| SMBIOS_HEADER Hdr; |
| SMBIOS_STRING Manufacturer; |
| UINT8 Type; |
| SMBIOS_STRING Version; |
| SMBIOS_STRING SerialNumber; |
| SMBIOS_STRING AssetTag; |
| UINT8 BootupState; |
| UINT8 PowerSupplyState; |
| UINT8 ThermalState; |
| UINT8 SecurityStatus; |
| UINT8 OemDefined[4]; |
| } SMBIOS_TYPE3; |
| typedef struct { |
| SMBIOS_HEADER Hdr; |
| UINT8 Socket; |
| UINT8 ProcessorType; |
| UINT8 ProcessorFamily; |
| SMBIOS_STRING ProcessorManufacture; |
| UINT8 ProcessorId[8]; |
| SMBIOS_STRING ProcessorVersion; |
| UINT8 Voltage; |
| UINT8 ExternalClock[2]; |
| UINT8 MaxSpeed[2]; |
| UINT8 CurrentSpeed[2]; |
| UINT8 Status; |
| UINT8 ProcessorUpgrade; |
| UINT8 L1CacheHandle[2]; |
| UINT8 L2CacheHandle[2]; |
| UINT8 L3CacheHandle[2]; |
| } SMBIOS_TYPE4; |
| typedef union { |
| SMBIOS_HEADER *Hdr; |
| SMBIOS_TYPE0 *Type0; |
| SMBIOS_TYPE1 *Type1; |
| SMBIOS_TYPE2 *Type2; |
| SMBIOS_TYPE3 *Type3; |
| SMBIOS_TYPE4 *Type4; |
| UINT8 *Raw; |
| } SMBIOS_STRUCTURE_POINTER; |
| #pragma pack() |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/efipxebc.h |
|---|
| 0,0 → 1,463 |
| #ifndef _EFIPXEBC_H |
| #define _EFIPXEBC_H |
| /*++ |
| Copyright (c) 1998 Intel Corporation |
| Module Name: |
| efipxebc.h |
| Abstract: |
| EFI PXE Base Code Protocol |
| Revision History |
| --*/ |
| // |
| // PXE Base Code protocol |
| // |
| #define EFI_PXE_BASE_CODE_PROTOCOL \ |
| { 0x03c4e603, 0xac28, 0x11d3, {0x9a, 0x2d, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d} } |
| INTERFACE_DECL(_EFI_PXE_BASE_CODE); |
| #define DEFAULT_TTL 4 |
| #define DEFAULT_ToS 0 |
| // |
| // Address definitions |
| // |
| typedef union { |
| UINT32 Addr[4]; |
| EFI_IPv4_ADDRESS v4; |
| EFI_IPv6_ADDRESS v6; |
| } EFI_IP_ADDRESS; |
| typedef UINT16 EFI_PXE_BASE_CODE_UDP_PORT; |
| // |
| // Packet definitions |
| // |
| typedef struct { |
| UINT8 BootpOpcode; |
| UINT8 BootpHwType; |
| UINT8 BootpHwAddrLen; |
| UINT8 BootpGateHops; |
| UINT32 BootpIdent; |
| UINT16 BootpSeconds; |
| UINT16 BootpFlags; |
| UINT8 BootpCiAddr[4]; |
| UINT8 BootpYiAddr[4]; |
| UINT8 BootpSiAddr[4]; |
| UINT8 BootpGiAddr[4]; |
| UINT8 BootpHwAddr[16]; |
| UINT8 BootpSrvName[64]; |
| UINT8 BootpBootFile[128]; |
| UINT32 DhcpMagik; |
| UINT8 DhcpOptions[56]; |
| } EFI_PXE_BASE_CODE_DHCPV4_PACKET; |
| // TBD in EFI v1.1 |
| //typedef struct { |
| // UINT8 reserved; |
| //} EFI_PXE_BASE_CODE_DHCPV6_PACKET; |
| typedef union { |
| UINT8 Raw[1472]; |
| EFI_PXE_BASE_CODE_DHCPV4_PACKET Dhcpv4; |
| // EFI_PXE_BASE_CODE_DHCPV6_PACKET Dhcpv6; |
| } EFI_PXE_BASE_CODE_PACKET; |
| typedef struct { |
| UINT8 Type; |
| UINT8 Code; |
| UINT16 Checksum; |
| union { |
| UINT32 reserved; |
| UINT32 Mtu; |
| UINT32 Pointer; |
| struct { |
| UINT16 Identifier; |
| UINT16 Sequence; |
| } Echo; |
| } u; |
| UINT8 Data[494]; |
| } EFI_PXE_BASE_CODE_ICMP_ERROR; |
| typedef struct { |
| UINT8 ErrorCode; |
| CHAR8 ErrorString[127]; |
| } EFI_PXE_BASE_CODE_TFTP_ERROR; |
| // |
| // IP Receive Filter definitions |
| // |
| #define EFI_PXE_BASE_CODE_MAX_IPCNT 8 |
| typedef struct { |
| UINT8 Filters; |
| UINT8 IpCnt; |
| UINT16 reserved; |
| EFI_IP_ADDRESS IpList[EFI_PXE_BASE_CODE_MAX_IPCNT]; |
| } EFI_PXE_BASE_CODE_IP_FILTER; |
| #define EFI_PXE_BASE_CODE_IP_FILTER_STATION_IP 0x0001 |
| #define EFI_PXE_BASE_CODE_IP_FILTER_BROADCAST 0x0002 |
| #define EFI_PXE_BASE_CODE_IP_FILTER_PROMISCUOUS 0x0004 |
| #define EFI_PXE_BASE_CODE_IP_FILTER_PROMISCUOUS_MULTICAST 0x0008 |
| // |
| // ARP Cache definitions |
| // |
| typedef struct { |
| EFI_IP_ADDRESS IpAddr; |
| EFI_MAC_ADDRESS MacAddr; |
| } EFI_PXE_BASE_CODE_ARP_ENTRY; |
| typedef struct { |
| EFI_IP_ADDRESS IpAddr; |
| EFI_IP_ADDRESS SubnetMask; |
| EFI_IP_ADDRESS GwAddr; |
| } EFI_PXE_BASE_CODE_ROUTE_ENTRY; |
| // |
| // UDP definitions |
| // |
| #define EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_SRC_IP 0x0001 |
| #define EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_SRC_PORT 0x0002 |
| #define EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_DEST_IP 0x0004 |
| #define EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_DEST_PORT 0x0008 |
| #define EFI_PXE_BASE_CODE_UDP_OPFLAGS_USE_FILTER 0x0010 |
| #define EFI_PXE_BASE_CODE_UDP_OPFLAGS_MAY_FRAGMENT 0x0020 |
| // |
| // Discover() definitions |
| // |
| #define EFI_PXE_BASE_CODE_BOOT_TYPE_BOOTSTRAP 0 |
| #define EFI_PXE_BASE_CODE_BOOT_TYPE_MS_WINNT_RIS 1 |
| #define EFI_PXE_BASE_CODE_BOOT_TYPE_INTEL_LCM 2 |
| #define EFI_PXE_BASE_CODE_BOOT_TYPE_DOSUNDI 3 |
| #define EFI_PXE_BASE_CODE_BOOT_TYPE_NEC_ESMPRO 4 |
| #define EFI_PXE_BASE_CODE_BOOT_TYPE_IBM_WSoD 5 |
| #define EFI_PXE_BASE_CODE_BOOT_TYPE_IBM_LCCM 6 |
| #define EFI_PXE_BASE_CODE_BOOT_TYPE_CA_UNICENTER_TNG 7 |
| #define EFI_PXE_BASE_CODE_BOOT_TYPE_HP_OPENVIEW 8 |
| #define EFI_PXE_BASE_CODE_BOOT_TYPE_ALTIRIS_9 9 |
| #define EFI_PXE_BASE_CODE_BOOT_TYPE_ALTIRIS_10 10 |
| #define EFI_PXE_BASE_CODE_BOOT_TYPE_ALTIRIS_11 11 |
| #define EFI_PXE_BASE_CODE_BOOT_TYPE_NOT_USED_12 12 |
| #define EFI_PXE_BASE_CODE_BOOT_TYPE_REDHAT_INSTALL 13 |
| #define EFI_PXE_BASE_CODE_BOOT_TYPE_REDHAT_BOOT 14 |
| #define EFI_PXE_BASE_CODE_BOOT_TYPE_REMBO 15 |
| #define EFI_PXE_BASE_CODE_BOOT_TYPE_BEOBOOT 16 |
| // |
| // 17 through 32767 are reserved |
| // 32768 through 65279 are for vendor use |
| // 65280 through 65534 are reserved |
| // |
| #define EFI_PXE_BASE_CODE_BOOT_TYPE_PXETEST 65535 |
| #define EFI_PXE_BASE_CODE_BOOT_LAYER_MASK 0x7FFF |
| #define EFI_PXE_BASE_CODE_BOOT_LAYER_INITIAL 0x0000 |
| typedef struct { |
| UINT16 Type; |
| BOOLEAN AcceptAnyResponse; |
| UINT8 Reserved; |
| EFI_IP_ADDRESS IpAddr; |
| } EFI_PXE_BASE_CODE_SRVLIST; |
| typedef struct { |
| BOOLEAN UseMCast; |
| BOOLEAN UseBCast; |
| BOOLEAN UseUCast; |
| BOOLEAN MustUseList; |
| EFI_IP_ADDRESS ServerMCastIp; |
| UINT16 IpCnt; |
| EFI_PXE_BASE_CODE_SRVLIST SrvList[1]; |
| } EFI_PXE_BASE_CODE_DISCOVER_INFO; |
| // |
| // Mtftp() definitions |
| // |
| typedef enum { |
| EFI_PXE_BASE_CODE_TFTP_FIRST, |
| EFI_PXE_BASE_CODE_TFTP_GET_FILE_SIZE, |
| EFI_PXE_BASE_CODE_TFTP_READ_FILE, |
| EFI_PXE_BASE_CODE_TFTP_WRITE_FILE, |
| EFI_PXE_BASE_CODE_TFTP_READ_DIRECTORY, |
| EFI_PXE_BASE_CODE_MTFTP_GET_FILE_SIZE, |
| EFI_PXE_BASE_CODE_MTFTP_READ_FILE, |
| EFI_PXE_BASE_CODE_MTFTP_READ_DIRECTORY, |
| EFI_PXE_BASE_CODE_MTFTP_LAST |
| } EFI_PXE_BASE_CODE_TFTP_OPCODE; |
| typedef struct { |
| EFI_IP_ADDRESS MCastIp; |
| EFI_PXE_BASE_CODE_UDP_PORT CPort; |
| EFI_PXE_BASE_CODE_UDP_PORT SPort; |
| UINT16 ListenTimeout; |
| UINT16 TransmitTimeout; |
| } EFI_PXE_BASE_CODE_MTFTP_INFO; |
| // |
| // PXE Base Code Mode structure |
| // |
| #define EFI_PXE_BASE_CODE_MAX_ARP_ENTRIES 8 |
| #define EFI_PXE_BASE_CODE_MAX_ROUTE_ENTRIES 8 |
| typedef struct { |
| BOOLEAN Started; |
| BOOLEAN Ipv6Available; |
| BOOLEAN Ipv6Supported; |
| BOOLEAN UsingIpv6; |
| BOOLEAN BisSupported; |
| BOOLEAN BisDetected; |
| BOOLEAN AutoArp; |
| BOOLEAN SendGUID; |
| BOOLEAN DhcpDiscoverValid; |
| BOOLEAN DhcpAckReceived; |
| BOOLEAN ProxyOfferReceived; |
| BOOLEAN PxeDiscoverValid; |
| BOOLEAN PxeReplyReceived; |
| BOOLEAN PxeBisReplyReceived; |
| BOOLEAN IcmpErrorReceived; |
| BOOLEAN TftpErrorReceived; |
| BOOLEAN MakeCallbacks; |
| UINT8 TTL; |
| UINT8 ToS; |
| EFI_IP_ADDRESS StationIp; |
| EFI_IP_ADDRESS SubnetMask; |
| EFI_PXE_BASE_CODE_PACKET DhcpDiscover; |
| EFI_PXE_BASE_CODE_PACKET DhcpAck; |
| EFI_PXE_BASE_CODE_PACKET ProxyOffer; |
| EFI_PXE_BASE_CODE_PACKET PxeDiscover; |
| EFI_PXE_BASE_CODE_PACKET PxeReply; |
| EFI_PXE_BASE_CODE_PACKET PxeBisReply; |
| EFI_PXE_BASE_CODE_IP_FILTER IpFilter; |
| UINT32 ArpCacheEntries; |
| EFI_PXE_BASE_CODE_ARP_ENTRY ArpCache[EFI_PXE_BASE_CODE_MAX_ARP_ENTRIES]; |
| UINT32 RouteTableEntries; |
| EFI_PXE_BASE_CODE_ROUTE_ENTRY RouteTable[EFI_PXE_BASE_CODE_MAX_ROUTE_ENTRIES]; |
| EFI_PXE_BASE_CODE_ICMP_ERROR IcmpError; |
| EFI_PXE_BASE_CODE_TFTP_ERROR TftpError; |
| } EFI_PXE_BASE_CODE_MODE; |
| // |
| // PXE Base Code Interface Function definitions |
| // |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_PXE_BASE_CODE_START) ( |
| IN struct _EFI_PXE_BASE_CODE *This, |
| IN BOOLEAN UseIpv6 |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_PXE_BASE_CODE_STOP) ( |
| IN struct _EFI_PXE_BASE_CODE *This |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_PXE_BASE_CODE_DHCP) ( |
| IN struct _EFI_PXE_BASE_CODE *This, |
| IN BOOLEAN SortOffers |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_PXE_BASE_CODE_DISCOVER) ( |
| IN struct _EFI_PXE_BASE_CODE *This, |
| IN UINT16 Type, |
| IN UINT16 *Layer, |
| IN BOOLEAN UseBis, |
| IN OUT EFI_PXE_BASE_CODE_DISCOVER_INFO *Info OPTIONAL |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_PXE_BASE_CODE_MTFTP) ( |
| IN struct _EFI_PXE_BASE_CODE *This, |
| IN EFI_PXE_BASE_CODE_TFTP_OPCODE Operation, |
| IN OUT VOID *BufferPtr OPTIONAL, |
| IN BOOLEAN Overwrite, |
| IN OUT UINTN *BufferSize, |
| IN UINTN *BlockSize OPTIONAL, |
| IN EFI_IP_ADDRESS *ServerIp, |
| IN UINT8 *Filename, |
| IN EFI_PXE_BASE_CODE_MTFTP_INFO *Info OPTIONAL, |
| IN BOOLEAN DontUseBuffer |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_PXE_BASE_CODE_UDP_WRITE) ( |
| IN struct _EFI_PXE_BASE_CODE *This, |
| IN UINT16 OpFlags, |
| IN EFI_IP_ADDRESS *DestIp, |
| IN EFI_PXE_BASE_CODE_UDP_PORT *DestPort, |
| IN EFI_IP_ADDRESS *GatewayIp, OPTIONAL |
| IN EFI_IP_ADDRESS *SrcIp, OPTIONAL |
| IN OUT EFI_PXE_BASE_CODE_UDP_PORT *SrcPort, OPTIONAL |
| IN UINTN *HeaderSize, OPTIONAL |
| IN VOID *HeaderPtr, OPTIONAL |
| IN UINTN *BufferSize, |
| IN VOID *BufferPtr |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_PXE_BASE_CODE_UDP_READ) ( |
| IN struct _EFI_PXE_BASE_CODE *This, |
| IN UINT16 OpFlags, |
| IN OUT EFI_IP_ADDRESS *DestIp, OPTIONAL |
| IN OUT EFI_PXE_BASE_CODE_UDP_PORT *DestPort, OPTIONAL |
| IN OUT EFI_IP_ADDRESS *SrcIp, OPTIONAL |
| IN OUT EFI_PXE_BASE_CODE_UDP_PORT *SrcPort, OPTIONAL |
| IN UINTN *HeaderSize, OPTIONAL |
| IN VOID *HeaderPtr, OPTIONAL |
| IN OUT UINTN *BufferSize, |
| IN VOID *BufferPtr |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_PXE_BASE_CODE_SET_IP_FILTER) ( |
| IN struct _EFI_PXE_BASE_CODE *This, |
| IN EFI_PXE_BASE_CODE_IP_FILTER *NewFilter |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_PXE_BASE_CODE_ARP) ( |
| IN struct _EFI_PXE_BASE_CODE *This, |
| IN EFI_IP_ADDRESS *IpAddr, |
| IN EFI_MAC_ADDRESS *MacAddr OPTIONAL |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_PXE_BASE_CODE_SET_PARAMETERS) ( |
| IN struct _EFI_PXE_BASE_CODE *This, |
| IN BOOLEAN *NewAutoArp, OPTIONAL |
| IN BOOLEAN *NewSendGUID, OPTIONAL |
| IN UINT8 *NewTTL, OPTIONAL |
| IN UINT8 *NewToS, OPTIONAL |
| IN BOOLEAN *NewMakeCallback OPTIONAL |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_PXE_BASE_CODE_SET_STATION_IP) ( |
| IN struct _EFI_PXE_BASE_CODE *This, |
| IN EFI_IP_ADDRESS *NewStationIp, OPTIONAL |
| IN EFI_IP_ADDRESS *NewSubnetMask OPTIONAL |
| ); |
| typedef |
| EFI_STATUS |
| (EFIAPI *EFI_PXE_BASE_CODE_SET_PACKETS) ( |
| IN struct _EFI_PXE_BASE_CODE *This, |
| BOOLEAN *NewDhcpDiscoverValid, OPTIONAL |
| BOOLEAN *NewDhcpAckReceived, OPTIONAL |
| BOOLEAN *NewProxyOfferReceived, OPTIONAL |
| BOOLEAN *NewPxeDiscoverValid, OPTIONAL |
| BOOLEAN *NewPxeReplyReceived, OPTIONAL |
| BOOLEAN *NewPxeBisReplyReceived,OPTIONAL |
| IN EFI_PXE_BASE_CODE_PACKET *NewDhcpDiscover, OPTIONAL |
| IN EFI_PXE_BASE_CODE_PACKET *NewDhcpAck, OPTIONAL |
| IN EFI_PXE_BASE_CODE_PACKET *NewProxyOffer, OPTIONAL |
| IN EFI_PXE_BASE_CODE_PACKET *NewPxeDiscover, OPTIONAL |
| IN EFI_PXE_BASE_CODE_PACKET *NewPxeReply, OPTIONAL |
| IN EFI_PXE_BASE_CODE_PACKET *NewPxeBisReply OPTIONAL |
| ); |
| // |
| // PXE Base Code Protocol structure |
| // |
| #define EFI_PXE_BASE_CODE_INTERFACE_REVISION 0x00010000 |
| typedef struct _EFI_PXE_BASE_CODE { |
| UINT64 Revision; |
| EFI_PXE_BASE_CODE_START Start; |
| EFI_PXE_BASE_CODE_STOP Stop; |
| EFI_PXE_BASE_CODE_DHCP Dhcp; |
| EFI_PXE_BASE_CODE_DISCOVER Discover; |
| EFI_PXE_BASE_CODE_MTFTP Mtftp; |
| EFI_PXE_BASE_CODE_UDP_WRITE UdpWrite; |
| EFI_PXE_BASE_CODE_UDP_READ UdpRead; |
| EFI_PXE_BASE_CODE_SET_IP_FILTER SetIpFilter; |
| EFI_PXE_BASE_CODE_ARP Arp; |
| EFI_PXE_BASE_CODE_SET_PARAMETERS SetParameters; |
| EFI_PXE_BASE_CODE_SET_STATION_IP SetStationIp; |
| EFI_PXE_BASE_CODE_SET_PACKETS SetPackets; |
| EFI_PXE_BASE_CODE_MODE *Mode; |
| } EFI_PXE_BASE_CODE; |
| // |
| // Call Back Definitions |
| // |
| #define EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL \ |
| { 0x245dca21, 0xfb7b, 0x11d3, {0x8f, 0x01, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b} } |
| // |
| // Revision Number |
| // |
| #define EFI_PXE_BASE_CODE_CALLBACK_INTERFACE_REVISION 0x00010000 |
| INTERFACE_DECL(_EFI_PXE_BASE_CODE_CALLBACK); |
| typedef enum { |
| EFI_PXE_BASE_CODE_FUNCTION_FIRST, |
| EFI_PXE_BASE_CODE_FUNCTION_DHCP, |
| EFI_PXE_BASE_CODE_FUNCTION_DISCOVER, |
| EFI_PXE_BASE_CODE_FUNCTION_MTFTP, |
| EFI_PXE_BASE_CODE_FUNCTION_UDP_WRITE, |
| EFI_PXE_BASE_CODE_FUNCTION_UDP_READ, |
| EFI_PXE_BASE_CODE_FUNCTION_ARP, |
| EFI_PXE_BASE_CODE_FUNCTION_IGMP, |
| EFI_PXE_BASE_CODE_PXE_FUNCTION_LAST |
| } EFI_PXE_BASE_CODE_FUNCTION; |
| typedef enum { |
| EFI_PXE_BASE_CODE_CALLBACK_STATUS_FIRST, |
| EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE, |
| EFI_PXE_BASE_CODE_CALLBACK_STATUS_ABORT, |
| EFI_PXE_BASE_CODE_CALLBACK_STATUS_LAST |
| } EFI_PXE_BASE_CODE_CALLBACK_STATUS; |
| typedef |
| EFI_PXE_BASE_CODE_CALLBACK_STATUS |
| (EFIAPI *EFI_PXE_CALLBACK) ( |
| IN struct _EFI_PXE_BASE_CODE_CALLBACK *This, |
| IN EFI_PXE_BASE_CODE_FUNCTION Function, |
| IN BOOLEAN Received, |
| IN UINT32 PacketLen, |
| IN EFI_PXE_BASE_CODE_PACKET *Packet OPTIONAL |
| ); |
| typedef struct _EFI_PXE_BASE_CODE_CALLBACK { |
| UINT64 Revision; |
| EFI_PXE_CALLBACK Callback; |
| } EFI_PXE_BASE_CODE_CALLBACK; |
| #endif /* _EFIPXEBC_H */ |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/inc/Makefile |
|---|
| 0,0 → 1,21 |
| include ../Make.defaults |
| CDIR=$(TOPDIR)/.. |
| all: |
| clean: |
| install: |
| mkdir -p $(INSTALLROOT)/include/efi |
| mkdir -p $(INSTALLROOT)/include/efi/protocol |
| mkdir -p $(INSTALLROOT)/include/efi/$(ARCH) |
| $(INSTALL) -m 644 *.h $(INSTALLROOT)/include/efi |
| $(INSTALL) -m 644 protocol/*.h $(INSTALLROOT)/include/efi/protocol |
| $(INSTALL) -m 644 $(ARCH)/*.h $(INSTALLROOT)/include/efi/$(ARCH) |
| ifeq ($(ARCH),ia64) |
| mkdir -p $(INSTALLROOT)/include/efi/protocol/ia64 |
| $(INSTALL) -m 644 protocol/ia64/*.h $(INSTALLROOT)/include/efi/protocol/ia64 |
| endif |
| include ../Make.rules |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/gnuefi/reloc_ia32.c |
|---|
| 0,0 → 1,103 |
| /* reloc_ia32.c - position independent x86 ELF shared object relocator |
| Copyright (C) 1999 Hewlett-Packard Co. |
| Contributed by David Mosberger <davidm@hpl.hp.com>. |
| This file is part of GNU-EFI, the GNU EFI development environment. |
| GNU EFI is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| GNU EFI is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| You should have received a copy of the GNU General Public License |
| along with GNU EFI; see the file COPYING. If not, write to the Free |
| Software Foundation, 59 Temple Place - Suite 330, Boston, MA |
| 02111-1307, USA. */ |
| #include <elf.h> |
| #include <link.h> /* get _DYNAMIC decl and ElfW and ELFW macros */ |
| #undef NULL |
| #define uint64_t efi_uint64_t |
| #define int64_t efi_int64_t |
| #define uint32_t efi_uint32_t |
| #define int32_t efi_int32_t |
| #define uint16_t efi_uint16_t |
| #define int16_t efi_int16_t |
| #define uint8_t efi_uint8_t |
| #define int8_t efi_int8_t |
| #undef NULL |
| #define uint64_t efi_uint64_t |
| #define int64_t efi_int64_t |
| #define uint32_t efi_uint32_t |
| #define int32_t efi_int32_t |
| #define uint16_t efi_uint16_t |
| #define int16_t efi_int16_t |
| #define uint8_t efi_uint8_t |
| #define int8_t efi_int8_t |
| #include <efi.h> |
| #include <efilib.h> |
| int |
| _relocate (long ldbase, ElfW(Dyn) *dyn, EFI_HANDLE image, EFI_SYSTEM_TABLE *systab) |
| { |
| extern EFI_STATUS efi_main (EFI_HANDLE, EFI_SYSTEM_TABLE *); |
| long relsz = 0, relent = 0; |
| ElfW(Rel) *rel = 0; |
| int i; |
| for (i = 0; dyn[i].d_tag != DT_NULL; ++i) { |
| switch (dyn[i].d_tag) { |
| case DT_REL: |
| rel = (ElfW(Rel)*) ((long) dyn[i].d_un.d_ptr + ldbase); |
| break; |
| case DT_RELSZ: |
| relsz = dyn[i].d_un.d_val; |
| break; |
| case DT_RELENT: |
| relent = dyn[i].d_un.d_val; |
| break; |
| case DT_RELA: |
| break; |
| default: |
| break; |
| } |
| } |
| while (relsz > 0) { |
| if (!rel || relent == 0) |
| return EFI_LOAD_ERROR; |
| /* apply the relocs */ |
| switch (ELF32_R_TYPE (rel->r_info)) { |
| case R_386_NONE: |
| break; |
| case R_386_RELATIVE: |
| { |
| long *addr; |
| addr = (long *) (ldbase + rel->r_offset); |
| *addr += ldbase; |
| break; |
| } |
| default: |
| return EFI_LOAD_ERROR; |
| } |
| rel = (ElfW(Rel)*) ((char *) rel + relent); |
| relsz -= relent; |
| } |
| return EFI_SUCCESS; |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/gnuefi/crt0-efi-ia32.S |
|---|
| 0,0 → 1,62 |
| /* crt0-efi-ia32.S - x86 EFI startup code. |
| Copyright (C) 1999 Hewlett-Packard Co. |
| Contributed by David Mosberger <davidm@hpl.hp.com>. |
| This file is part of GNU-EFI, the GNU EFI development environment. |
| GNU EFI is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| GNU EFI is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| You should have received a copy of the GNU General Public License |
| along with GNU EFI; see the file COPYING. If not, write to the Free |
| Software Foundation, 59 Temple Place - Suite 330, Boston, MA |
| 02111-1307, USA. */ |
| .text |
| .align 4 |
| .globl _start |
| _start: |
| pushl %ebp |
| movl %esp,%ebp |
| pushl 12(%ebp) # copy "image" argument |
| pushl 8(%ebp) # copy "systab" argument |
| call 0f |
| 0: popl %eax |
| movl %eax,%ebx |
| addl $ImageBase-0b,%eax # %eax = ldbase |
| addl $_DYNAMIC-0b,%ebx # %ebx = _DYNAMIC |
| pushl %ebx # pass _DYNAMIC as second argument |
| pushl %eax # pass ldbase as first argument |
| call _relocate |
| popl %ebx |
| popl %ebx |
| testl %eax,%eax |
| jne .exit |
| call efi_main # call app with "image" and "systab" argument |
| .exit: leave |
| ret |
| // hand-craft a dummy .reloc section so EFI knows it's a relocatable executable: |
| .data |
| dummy: .long 0 |
| #define IMAGE_REL_ABSOLUTE 0 |
| .section .reloc, "a" |
| .long dummy // Page RVA |
| .long 10 // Block Size (2*4+2) |
| .word (IMAGE_REL_ABSOLUTE<<12) + 0 // reloc for dummy |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/gnuefi/elf_ia32_efi.lds |
|---|
| 0,0 → 1,62 |
| OUTPUT_FORMAT("elf32-i386", "elf32-i386", "elf32-i386") |
| OUTPUT_ARCH(i386) |
| ENTRY(_start) |
| SECTIONS |
| { |
| . = 0; |
| ImageBase = .; |
| .hash : { *(.hash) } /* this MUST come first! */ |
| . = ALIGN(4096); |
| .text : |
| { |
| *(.text) |
| *(.text.*) |
| *(.gnu.linkonce.t.*) |
| } |
| .reloc : |
| { |
| *(.reloc) |
| } |
| . = ALIGN(4096); |
| .data : |
| { |
| *(.rodata*) |
| *(.data) |
| *(.data1) |
| *(.data.*) |
| *(.sdata) |
| *(.got.plt) |
| *(.got) |
| /* the EFI loader doesn't seem to like a .bss section, so we stick |
| it all into .data: */ |
| *(.sbss) |
| *(.scommon) |
| *(.dynbss) |
| *(.bss) |
| *(COMMON) |
| } |
| . = ALIGN(4096); |
| .dynamic : { *(.dynamic) } |
| . = ALIGN(4096); |
| .rel : |
| { |
| *(.rel.data) |
| *(.rel.data.*) |
| *(.rel.got) |
| *(.rel.stab) |
| *(.data.rel.ro.local) |
| *(.data.rel.local) |
| *(.data.rel.ro) |
| *(.data.rel*) |
| } |
| . = ALIGN(4096); |
| .dynsym : { *(.dynsym) } |
| . = ALIGN(4096); |
| .dynstr : { *(.dynstr) } |
| . = ALIGN(4096); |
| /DISCARD/ : |
| { |
| *(.rel.reloc) |
| *(.eh_frame) |
| } |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/gnuefi/reloc_ia64.S |
|---|
| 0,0 → 1,212 |
| /* reloc_ia64.S - position independent IA-64 ELF shared object relocator |
| Copyright (C) 1999 Hewlett-Packard Co. |
| Contributed by David Mosberger <davidm@hpl.hp.com>. |
| This file is part of GNU-EFI, the GNU EFI development environment. |
| GNU EFI is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| GNU EFI is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| You should have received a copy of the GNU General Public License |
| along with GNU EFI; see the file COPYING. If not, write to the Free |
| Software Foundation, 59 Temple Place - Suite 330, Boston, MA |
| 02111-1307, USA. */ |
| /* |
| * This is written in assembly because the entire code needs to be position |
| * independent. Note that the compiler does not generate code that's position |
| * independent by itself because it relies on the global offset table being |
| * relocated. |
| */ |
| .text |
| .psr abi64 |
| .psr lsb |
| .lsb |
| /* |
| * This constant determines how many R_IA64_FPTR64LSB relocations we |
| * can deal with. If you get EFI_BUFFER_TOO_SMALL errors, you may |
| * need to increase this number. |
| */ |
| #define MAX_FUNCTION_DESCRIPTORS 750 |
| #define ST_VALUE_OFF 8 /* offset of st_value in elf sym */ |
| #define EFI_SUCCESS 0 |
| #define EFI_LOAD_ERROR 1 |
| #define EFI_BUFFER_TOO_SMALL 5 |
| #define DT_NULL 0 /* Marks end of dynamic section */ |
| #define DT_RELA 7 /* Address of Rela relocs */ |
| #define DT_RELASZ 8 /* Total size of Rela relocs */ |
| #define DT_RELAENT 9 /* Size of one Rela reloc */ |
| #define DT_SYMTAB 6 /* Address of symbol table */ |
| #define DT_SYMENT 11 /* Size of one symbol table entry */ |
| #define R_IA64_NONE 0 |
| #define R_IA64_REL64MSB 0x6e |
| #define R_IA64_REL64LSB 0x6f |
| #define R_IA64_DIR64MSB 0x26 |
| #define R_IA64_DIR64LSB 0x27 |
| #define R_IA64_FPTR64MSB 0x46 |
| #define R_IA64_FPTR64LSB 0x47 |
| #define ldbase in0 /* load address (address of .text) */ |
| #define dyn in1 /* address of _DYNAMIC */ |
| #define d_tag r16 |
| #define d_val r17 |
| #define rela r18 |
| #define relasz r19 |
| #define relaent r20 |
| #define addr r21 |
| #define r_info r22 |
| #define r_offset r23 |
| #define r_addend r24 |
| #define r_type r25 |
| #define r_sym r25 /* alias of r_type ! */ |
| #define fptr r26 |
| #define fptr_limit r27 |
| #define symtab f8 |
| #define syment f9 |
| #define ftmp f10 |
| #define target r16 |
| #define val r17 |
| #define NLOC 0 |
| #define Pnull p6 |
| #define Prela p7 |
| #define Prelasz p8 |
| #define Prelaent p9 |
| #define Psymtab p10 |
| #define Psyment p11 |
| #define Pnone p6 |
| #define Prel p7 |
| #define Pfptr p8 |
| #define Pmore p6 |
| #define Poom p6 /* out-of-memory */ |
| .global _relocate |
| .proc _relocate |
| _relocate: |
| alloc r2=ar.pfs,2,0,0,0 |
| movl fptr = @gprel(fptr_mem_base) |
| ;; |
| add fptr = fptr, gp |
| movl fptr_limit = @gprel(fptr_mem_limit) |
| ;; |
| add fptr_limit = fptr_limit, gp |
| search_dynamic: |
| ld8 d_tag = [dyn],8 |
| ;; |
| ld8 d_val = [dyn],8 |
| cmp.eq Pnull,p0 = DT_NULL,d_tag |
| (Pnull) br.cond.sptk.few apply_relocs |
| cmp.eq Prela,p0 = DT_RELA,d_tag |
| cmp.eq Prelasz,p0 = DT_RELASZ,d_tag |
| cmp.eq Psymtab,p0 = DT_SYMTAB,d_tag |
| cmp.eq Psyment,p0 = DT_SYMENT,d_tag |
| cmp.eq Prelaent,p0 = DT_RELAENT,d_tag |
| ;; |
| (Prela) add rela = d_val, ldbase |
| (Prelasz) mov relasz = d_val |
| (Prelaent) mov relaent = d_val |
| (Psymtab) add val = d_val, ldbase |
| (Psyment) setf.sig syment = d_val |
| ;; |
| (Psymtab) setf.sig symtab = val |
| br.sptk.few search_dynamic |
| apply_loop: |
| ld8 r_offset = [rela] |
| add addr = 8,rela |
| sub relasz = relasz,relaent |
| ;; |
| ld8 r_info = [addr],8 |
| ;; |
| ld8 r_addend = [addr] |
| add target = ldbase, r_offset |
| add rela = rela,relaent |
| extr.u r_type = r_info, 0, 32 |
| ;; |
| cmp.eq Pnone,p0 = R_IA64_NONE,r_type |
| cmp.eq Prel,p0 = R_IA64_REL64LSB,r_type |
| cmp.eq Pfptr,p0 = R_IA64_FPTR64LSB,r_type |
| (Prel) br.cond.sptk.few apply_REL64 |
| ;; |
| cmp.eq Prel,p0 = R_IA64_DIR64LSB,r_type // treat DIR64 just like REL64 |
| (Pnone) br.cond.sptk.few apply_relocs |
| (Prel) br.cond.sptk.few apply_REL64 |
| (Pfptr) br.cond.sptk.few apply_FPTR64 |
| mov r8 = EFI_LOAD_ERROR |
| br.ret.sptk.few rp |
| apply_relocs: |
| cmp.ltu Pmore,p0=0,relasz |
| (Pmore) br.cond.sptk.few apply_loop |
| mov r8 = EFI_SUCCESS |
| br.ret.sptk.few rp |
| apply_REL64: |
| ld8 val = [target] |
| ;; |
| add val = val,ldbase |
| ;; |
| st8 [target] = val |
| br.cond.sptk.few apply_relocs |
| // FPTR relocs are a bit more interesting: we need to lookup |
| // the symbol's value in symtab, allocate 16 bytes of memory, |
| // store the value in [target] in the first and the gp in the |
| // second dword. |
| apply_FPTR64: |
| st8 [target] = fptr |
| extr.u r_sym = r_info,32,32 |
| add target = 8,fptr |
| ;; |
| setf.sig ftmp = r_sym |
| mov r8=EFI_BUFFER_TOO_SMALL |
| ;; |
| cmp.geu Poom,p0 = fptr,fptr_limit |
| xma.lu ftmp = ftmp,syment,symtab |
| (Poom) br.ret.sptk.few rp |
| ;; |
| getf.sig addr = ftmp |
| st8 [target] = gp |
| ;; |
| add addr = ST_VALUE_OFF, addr |
| ;; |
| ld8 val = [addr] |
| ;; |
| add val = val,ldbase |
| ;; |
| st8 [fptr] = val,16 |
| br.cond.sptk.few apply_relocs |
| .endp _relocate |
| .data |
| .align 16 |
| fptr_mem_base: |
| .space MAX_FUNCTION_DESCRIPTORS*16 |
| fptr_mem_limit: |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/gnuefi/crt0-efi-ia64.S |
|---|
| 0,0 → 1,74 |
| /* crt0-efi-ia64.S - IA-64 EFI startup code. |
| Copyright (C) 1999 Hewlett-Packard Co. |
| Contributed by David Mosberger <davidm@hpl.hp.com>. |
| This file is part of GNU-EFI, the GNU EFI development environment. |
| GNU EFI is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| GNU EFI is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| You should have received a copy of the GNU General Public License |
| along with GNU EFI; see the file COPYING. If not, write to the Free |
| Software Foundation, 59 Temple Place - Suite 330, Boston, MA |
| 02111-1307, USA. */ |
| .text |
| .psr abi64 |
| .psr lsb |
| .lsb |
| .proc _start |
| _start: |
| alloc loc0=ar.pfs,2,2,2,0 |
| mov loc1=rp |
| movl out0=@gprel(ImageBase) // out0 <- ImageBase (ldbase) |
| ;; |
| add out0=out0,gp |
| movl out1=@gprel(_DYNAMIC) // out1 <- _DYNAMIC |
| ;; // avoid WAW on CFM |
| add out1=out1,gp |
| br.call.sptk.few rp=_relocate |
| .Lret0: |
| cmp.ne p6,p0=r0,r8 // r8 == EFI_SUCCESS? |
| (p6) br.cond.sptk.few .exit // no -> |
| .Lret1: |
| mov out0=in0 // image handle |
| mov out1=in1 // systab |
| br.call.sptk.few rp=efi_main |
| .Lret2: |
| .exit: |
| mov ar.pfs=loc0 |
| mov rp=loc1 |
| ;; |
| br.ret.sptk.few rp |
| .endp _start |
| // PE32+ wants a PLABEL, not the code address of the entry point: |
| .align 16 |
| .global _start_plabel |
| .section .plabel, "a" |
| _start_plabel: |
| data8 _start |
| data8 __gp |
| // hand-craft a .reloc section for the plabel: |
| #define IMAGE_REL_BASED_DIR64 10 |
| .section .reloc, "a" |
| data4 _start_plabel // Page RVA |
| data4 12 // Block Size (2*4+2*2) |
| data2 (IMAGE_REL_BASED_DIR64<<12) + 0 // reloc for plabel's entry point |
| data2 (IMAGE_REL_BASED_DIR64<<12) + 8 // reloc for plabel's global pointer |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/gnuefi/Makefile |
|---|
| 0,0 → 1,44 |
| # |
| # Copyright (C) 1999-2001 Hewlett-Packard Co. |
| # Contributed by David Mosberger <davidm@hpl.hp.com> |
| # Contributed by Stephane Eranian <eranian@hpl.hp.com> |
| # |
| # This file is part of the gnu-efi package. |
| # |
| # GNU-EFI is free software; you can redistribute it and/or modify |
| # it under the terms of the GNU General Public License as published by |
| # the Free Software Foundation; either version 2, or (at your option) |
| # any later version. |
| # |
| # GNU-EFI is distributed in the hope that it will be useful, |
| # but WITHOUT ANY WARRANTY; without even the implied warranty of |
| # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| # GNU General Public License for more details. |
| # |
| # You should have received a copy of the GNU General Public License |
| # along with GNU-EFI; see the file COPYING. If not, write to the Free |
| # Software Foundation, 59 Temple Place - Suite 330, Boston, MA |
| # 02111-1307, USA. |
| # |
| include ../Make.defaults |
| CDIR=$(TOPDIR)/.. |
| FILES = reloc_$(ARCH) |
| OBJS = $(FILES:%=%.o) |
| TARGETS = crt0-efi-$(ARCH).o libgnuefi.a |
| all: $(TARGETS) |
| libgnuefi.a: libgnuefi.a($(OBJS)) |
| clean: |
| rm -f $(TARGETS) *~ *.o $(OBJS) |
| install: |
| mkdir -p $(INSTALLROOT)/lib |
| $(INSTALL) -m 644 $(TARGETS) $(INSTALLROOT)/lib |
| $(INSTALL) -m 644 elf_$(ARCH)_efi.lds $(INSTALLROOT)/lib |
| include ../Make.rules |
| /tags/0.4.0/boot/arch/ia64/loader/gefi/gnuefi/elf_ia64_efi.lds |
|---|
| 0,0 → 1,70 |
| OUTPUT_FORMAT("elf64-ia64-little") |
| OUTPUT_ARCH(ia64) |
| ENTRY(_start_plabel) |
| SECTIONS |
| { |
| . = 0; |
| ImageBase = .; |
| .hash : { *(.hash) } /* this MUST come first! */ |
| . = ALIGN(4096); |
| .text : |
| { |
| *(.text) |
| *(.text.*) |
| *(.gnu.linkonce.t.*) |
| } |
| . = ALIGN(4096); |
| __gp = ALIGN (8) + 0x200000; |
| .sdata : |
| { |
| *(.got.plt) |
| *(.got) |
| *(.srodata) |
| *(.sdata) |
| *(.sbss) |
| *(.scommon) |
| } |
| . = ALIGN(4096); |
| .data : |
| { |
| *(.rodata*) |
| *(.ctors) |
| *(.data*) |
| *(.gnu.linkonce.d*) |
| *(.plabel) /* data whose relocs we want to ignore */ |
| /* the EFI loader doesn't seem to like a .bss section, so we stick |
| it all into .data: */ |
| *(.dynbss) |
| *(.bss) |
| *(COMMON) |
| } |
| . = ALIGN(4096); |
| .dynamic : { *(.dynamic) } |
| . = ALIGN(4096); |
| .rela : |
| { |
| *(.rela.text) |
| *(.rela.data*) |
| *(.rela.sdata) |
| *(.rela.got) |
| *(.rela.gnu.linkonce.d*) |
| *(.rela.stab) |
| *(.rela.ctors) |
| } |
| . = ALIGN(4096); |
| .reloc : /* This is the PECOFF .reloc section! */ |
| { |
| *(.reloc) |
| } |
| . = ALIGN(4096); |
| .dynsym : { *(.dynsym) } |
| . = ALIGN(4096); |
| .dynstr : { *(.dynstr) } |
| /DISCARD/ : |
| { |
| *(.rela.plabel) |
| *(.rela.reloc) |
| *(.IA_64.unwind*) |
| *(.IA64.unwind*) |
| } |
| } |
| /tags/0.4.0/boot/arch/ia64/loader/asm.S |
|---|
| 0,0 → 1,41 |
| # |
| # Copyright (c) 2006 Martin Decky |
| # Copyright (c) 2006 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 <stack.h> |
| .text |
| .global jump_to_kernel |
| jump_to_kernel: |
| alloc loc0 = ar.pfs, 1, 1, 0, 0 |
| movl r8 = 0x4404000;; |
| mov b1 = r8 ;; |
| mov r1 = in0; #Save bootinfo prt |
| br.call.sptk.many b0 = b1;; |
| /tags/0.4.0/boot/arch/ia64/loader/boot.S |
|---|
| 0,0 → 1,85 |
| # |
| # Copyright (c) 2006 Martin Decky |
| # Copyright (c) 2006 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 <stack.h> |
| .section BOOTSTRAP, "ax" |
| .global start |
| start: |
| mov ar.rsc = r0 |
| # movl r8 = (VRN_KERNEL << VRN_SHIFT) ;; |
| movl r1 = 0x4400000 |
| movl r8 = initial_stack ;; |
| mov ar.bspstore = r8 |
| loadrs |
| # initialize memory stack to some sane value |
| movl r12 = initial_stack_top ;; |
| add r12 = -16, r12 /* allocate a scratch area on the stack */ |
| # initialize gp (Global Pointer) register |
| #movl r1 = _hardcoded_load_address |
| ssm (1 << 19) ;; /* Disable f32 - f127 */ |
| srlz.i |
| srlz.d ;; |
| movl r18 = bootstrap ;; |
| mov b1 = r18 ;; |
| br.call.sptk.many b0 = b1 |
| .align 512 |
| ap_start: |
| ap_loop: |
| movl r18=0x4405000;; |
| mov b1 = r18 ;; |
| br.call.sptk.many b0 = b1;; |
| .align 1024 |
| .align 4096 |
| .global binfo |
| binfo: |
| .bss #on this line is ".bss", it cannot be seen in my mcedit :-( |
| .align 8192 |
| initial_stack: |
| .space 8192 |
| initial_stack_top: |
| /tags/0.4.0/boot/arch/ia64/loader/main.h |
|---|
| 0,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 BOOT_ia64_MAIN_H_ |
| #define BOOT_ia64_MAIN_H_ |
| #include <types.h> |
| #include <../../../../kernel/arch/ia64/include/bootinfo.h> |
| #define CONFIG_INIT_TASKS 32 |
| extern void start(void); |
| extern void bootstrap(void); |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/asm.h |
|---|
| 0,0 → 1,48 |
| /* |
| * Copyright (c) 2006 Martin Decky |
| * Copyright (c) 2006 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 BOOT_ia64_ASM_H_ |
| #define BOOT_ia64_ASM_H_ |
| #include "types.h" |
| #include "main.h" |
| #define PAGE_WIDTH 14 |
| #define PAGE_SIZE (1 << PAGE_WIDTH) |
| #define memcpy(dst, src, cnt) __builtin_memcpy((dst), (src), (cnt)) |
| extern void halt(void); |
| /*extern void jump_to_kernel(void *entry, uint64_t cfg, bootinfo_t *bootinfo, |
| unsigned int bootinfo_size) __attribute__((noreturn));*/ |
| extern void jump_to_kernel(void *) __attribute__((noreturn)); |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/types.h |
|---|
| 0,0 → 1,47 |
| /* |
| * Copyright (c) 2006 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 BOOT_ia64_TYPES_H_ |
| #define BOOT_ia64_TYPES_H_ |
| #include <gentypes.h> |
| typedef signed char int8_t; |
| typedef unsigned char uint8_t; |
| typedef unsigned short uint16_t; |
| typedef unsigned int uint32_t; |
| typedef unsigned long uint64_t; |
| typedef uint64_t uintptr_t; |
| typedef uint64_t unative_t; |
| typedef unsigned long count_t; |
| #endif |
| /tags/0.4.0/boot/arch/ia64/loader/stack.h |
|---|
| 0,0 → 1,36 |
| /* |
| * Copyright (c) 2006 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 BOOT_ia64_STACK_H_ |
| #define BOOT_ia64_STACK_H_ |
| #define STACK_ALIGNMENT 16 |
| #define STACK_BIAS 2047 |
| #define STACK_WINDOW_SAVE_AREA_SIZE (16*8) |
| #endif |
| /tags/0.4.0/boot/arch/ia64/Makefile.inc |
|---|
| 0,0 → 1,47 |
| # |
| # Copyright (c) 2006 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. |
| # |
| #ifeq ($(MACHINE),ski) |
| build: $(BASE)/image.boot |
| $(BASE)/image.boot: depend arch/$(ARCH)/loader/image.boot |
| cp arch/$(ARCH)/loader/image.boot $(BASE)/image.boot |
| depend: |
| -rm arch/$(ARCH)/loader/image.boot |
| arch/$(ARCH)/loader/image.boot: |
| make -C arch/$(ARCH)/loader COMPILER=$(COMPILER) KERNELDIR=../../../$(KERNELDIR) USPACEDIR=../../../$(USPACEDIR) "DEFS=$(DEFS)" |
| clean: generic_clean |
| make -C arch/$(ARCH)/loader clean COMPILER=$(COMPILER) KERNELDIR=../../../$(KERNELDIR) USPACEDIR=../../../$(USPACEDIR) "DEFS=$(DEFS)" |
| -rm -f $(BASE)/image.boot |
| #endif |
| /tags/0.4.0/boot/arch/arm32/loader/Makefile |
|---|
| 0,0 → 1,158 |
| # |
| # Copyright (c) 2006 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 ../../../../version |
| include ../../../../Makefile.config |
| ## Toolchain configuration |
| # |
| ifndef CROSS_PREFIX |
| CROSS_PREFIX = /usr/local |
| endif |
| BFD_NAME = elf32-littlearm |
| BFD_ARCH = arm |
| TARGET = arm-linux-gnu |
| TOOLCHAIN_DIR = $(CROSS_PREFIX)/arm/bin |
| ifeq ($(COMPILER),gcc_native) |
| CC = gcc |
| AS = as |
| LD = ld |
| OBJCOPY = objcopy |
| OBJDUMP = objdump |
| endif |
| ifeq ($(COMPILER),gcc_cross) |
| CC = $(TOOLCHAIN_DIR)/$(TARGET)-gcc |
| AS = $(TOOLCHAIN_DIR)/$(TARGET)-as |
| LD = $(TOOLCHAIN_DIR)/$(TARGET)-ld |
| OBJCOPY = $(TOOLCHAIN_DIR)/$(TARGET)-objcopy |
| OBJDUMP = $(TOOLCHAIN_DIR)/$(TARGET)-objdump |
| endif |
| CFLAGS = -DRELEASE=\"$(RELEASE)\" -I. -I../../../generic -I../../.. -nostdinc -nostdlib -fno-builtin -Werror-implicit-function-declaration -Wmissing-prototypes -Werror -O3 -pipe |
| ifdef REVISION |
| CFLAGS += "-DREVISION=\"$(REVISION)\"" |
| endif |
| ifdef TIMESTAMP |
| CFLAGS += "-DTIMESTAMP=\"$(TIMESTAMP)\"" |
| endif |
| ifdef MACHINE |
| CFLAGS += "-DMACHINE=$(MACHINE)" |
| endif |
| SOURCES = \ |
| main.c \ |
| boot.S \ |
| asm.S \ |
| mm.c \ |
| print/gxemul.c \ |
| _components.c \ |
| ../../../generic/printf.c \ |
| ../../../genarch/division.c |
| COMPONENTS = \ |
| $(KERNELDIR)/kernel.bin \ |
| $(USPACEDIR)/srv/ns/ns \ |
| $(USPACEDIR)/srv/loader/loader \ |
| $(USPACEDIR)/app/init/init \ |
| $(USPACEDIR)/srv/devmap/devmap \ |
| $(USPACEDIR)/srv/rd/rd \ |
| $(USPACEDIR)/srv/vfs/vfs |
| ifeq ($(RDFMT),tmpfs) |
| COMPONENTS += $(USPACEDIR)/srv/fs/tmpfs/tmpfs |
| endif |
| ifeq ($(RDFMT),fat) |
| COMPONENTS += $(USPACEDIR)/srv/fs/fat/fat |
| endif |
| RD_SRVS = \ |
| $(USPACEDIR)/srv/fb/fb \ |
| $(USPACEDIR)/srv/kbd/kbd \ |
| $(USPACEDIR)/srv/console/console \ |
| $(USPACEDIR)/srv/fs/tmpfs/tmpfs \ |
| $(USPACEDIR)/srv/fs/fat/fat |
| RD_APPS = \ |
| $(USPACEDIR)/app/tetris/tetris \ |
| $(USPACEDIR)/app/tester/tester \ |
| $(USPACEDIR)/app/trace/trace \ |
| $(USPACEDIR)/app/klog/klog \ |
| $(USPACEDIR)/app/bdsh/bdsh |
| OBJECTS := $(addsuffix .o,$(basename $(SOURCES))) |
| COMPONENT_OBJECTS := $(addsuffix .o,$(basename $(notdir $(COMPONENTS)))) |
| .PHONY: all clean depend |
| all: image.boot |
| -include Makefile.depend |
| image.boot: depend _components.h _link.ld $(COMPONENT_OBJECTS) initrd.o $(OBJECTS) |
| $(LD) -no-check-sections -N -T _link.ld $(COMPONENT_OBJECTS) initrd.o $(OBJECTS) -o $@ |
| depend: |
| -makedepend -f - -- $(DEFS) $(CFLAGS) -- $(SOURCES) > Makefile.depend 2> /dev/null |
| clean: |
| -for file in $(RD_SRVS) ; do \ |
| rm -f $(USPACEDIR)/dist/srv/`basename $$file` ; \ |
| done |
| -for file in $(RD_APPS) ; do \ |
| rm -f $(USPACEDIR)/dist/app/`basename $$file` ; \ |
| done |
| -rm -f _components.h _components.c _link.ld $(COMPONENT_OBJECTS) initrd.o $(OBJECTS) initrd.img image.boot Makefile.depend |
| _components.h _components.c _link.ld $(COMPONENT_OBJECTS) initrd.o: $(COMPONENTS) $(RD_SRVS) $(RD_APPS) _link.ld.in |
| for file in $(RD_SRVS) ; do \ |
| cp $$file $(USPACEDIR)/dist/srv/ ; \ |
| done |
| for file in $(RD_APPS) ; do \ |
| cp $$file $(USPACEDIR)/dist/app/ ; \ |
| done |
| ifeq ($(RDFMT),tmpfs) |
| ../../../../tools/mktmpfs.py $(USPACEDIR)/dist/ initrd.fs |
| endif |
| ifeq ($(RDFMT),fat) |
| ../../../../tools/mkfat.py $(USPACEDIR)/dist/ initrd.fs |
| endif |
| ../../../../tools/mkhord.py 4096 initrd.fs initrd.img |
| rm initrd.fs |
| ../../../tools/pack.py $(OBJCOPY) $(BFD_NAME) $(BFD_ARCH) 4096 "unsigned int" $(COMPONENTS) ./initrd.img |
| %.o: %.S |
| $(CC) $(DEFS) $(CFLAGS) -D__ASM__ -c $< -o $@ |
| %.o: %.c |
| $(CC) $(DEFS) $(CFLAGS) -c $< -o $@ |
| /tags/0.4.0/boot/arch/arm32/loader/asm.S |
|---|
| 0,0 → 1,86 |
| # |
| # Copyright (c) 2007 Michal Kebrt |
| # 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: |
| add r3, r1, #3 |
| bic r3, r3, #3 |
| cmp r1, r3 |
| stmdb sp!, {r4, r5, lr} |
| mov r5, r0 |
| beq 4f |
| 1: |
| cmp r2, #0 |
| movne ip, #0 |
| beq 3f |
| 2: |
| ldrb r3, [ip, r1] |
| strb r3, [ip, r0] |
| add ip, ip, #1 |
| cmp ip, r2 |
| bne 2b |
| 3: |
| mov r0, r5 |
| ldmia sp!, {r4, r5, pc} |
| 4: |
| add r3, r0, #3 |
| bic r3, r3, #3 |
| cmp r0, r3 |
| bne 1b |
| movs r4, r2, lsr #2 |
| moveq lr, r4 |
| beq 6f |
| mov lr, #0 |
| mov ip, lr |
| 5: |
| ldr r3, [ip, r1] |
| add lr, lr, #1 |
| cmp lr, r4 |
| str r3, [ip, r0] |
| add ip, ip, #4 |
| bne 5b |
| 6: |
| ands r4, r2, #3 |
| beq 3b |
| mov r3, lr, lsl #2 |
| add r0, r3, r0 |
| add ip, r3, r1 |
| mov r2, #0 |
| 7: |
| ldrb r3, [r2, ip] |
| strb r3, [r2, r0] |
| add r2, r2, #1 |
| cmp r2, r4 |
| bne 7b |
| b 3b |
| /tags/0.4.0/boot/arch/arm32/loader/boot.S |
|---|
| 0,0 → 1,57 |
| # |
| # Copyright (c) 2007 Michal Kebrt |
| # 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.h" |
| .section BOOTSTRAP |
| .global start |
| .global jump_to_kernel |
| .global page_table |
| start: |
| b bootstrap |
| jump_to_kernel: |
| # |
| # TODO |
| # Make sure that the I-cache, D-cache and memory are mutually coherent |
| # before passing control to the copied code. |
| # |
| bx r0 |
| # place page_table to PT section |
| .section PT |
| # make place for PTL0 page table |
| page_table: |
| .skip PTL0_ENTRIES * PTL0_ENTRY_SIZE |
| /tags/0.4.0/boot/arch/arm32/loader/_link.ld.in |
|---|
| 0,0 → 1,24 |
| OUTPUT_FORMAT("elf32-littlearm") |
| ENTRY(start) |
| SECTIONS { |
| .boot 0x0: AT (0) { |
| *(BOOTSTRAP); |
| *(.text); |
| *(.rodata); |
| *(.rodata.*); |
| *(.data); /* initialized data */ |
| *(.sdata); |
| *(.sdata2); |
| *(.sbss); |
| *(.scommon); |
| *(.bss); /* uninitialized static variables */ |
| *(COMMON); /* global variables */ |
| *(.reginfo); |
| . = 0x4000; |
| *(PT); /* page table placed at 0x4000 */ |
| [[COMPONENTS]] |
| } |
| } |
| /tags/0.4.0/boot/arch/arm32/loader/main.c |
|---|
| 0,0 → 1,116 |
| /* |
| * Copyright (c) 2007 Michal Kebrt |
| * 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. |
| */ |
| /** @addtogroup arm32boot |
| * @{ |
| */ |
| /** @file |
| * @brief Bootstrap. |
| */ |
| #include "main.h" |
| #include "asm.h" |
| #include "_components.h" |
| #include <printf.h> |
| #include "mm.h" |
| /** Kernel entry point address. */ |
| #define KERNEL_VIRTUAL_ADDRESS 0x80200000 |
| char *release = RELEASE; |
| #ifdef REVISION |
| char *revision = ", revision " REVISION; |
| #else |
| char *revision = ""; |
| #endif |
| #ifdef TIMESTAMP |
| char *timestamp = "\nBuilt on " TIMESTAMP; |
| #else |
| char *timestamp = ""; |
| #endif |
| /** Prints bootloader version information. */ |
| static void version_print(void) |
| { |
| printf("HelenOS ARM32 Bootloader\nRelease %s%s%s\nCopyright (c) 2007 HelenOS project\n", |
| release, revision, timestamp); |
| } |
| /** Copies all images (kernel + user tasks) to #KERNEL_VIRTUAL_ADDRESS and jumps there. */ |
| void bootstrap(void) |
| { |
| mmu_start(); |
| version_print(); |
| component_t components[COMPONENTS]; |
| init_components(components); |
| bootinfo_t bootinfo; |
| printf("\nMemory statistics\n"); |
| printf(" kernel entry point at %L\n", KERNEL_VIRTUAL_ADDRESS); |
| printf(" %L: boot info structure\n", &bootinfo); |
| unsigned int i, j; |
| for (i = 0; i < COMPONENTS; i++) { |
| printf(" %L: %s image (size %d bytes)\n", |
| components[i].start, components[i].name, components[i].size); |
| } |
| printf("\nCopying components\n"); |
| unsigned int top = 0; |
| bootinfo.cnt = 0; |
| for (i = 0; i < COMPONENTS; i++) { |
| printf(" %s...", components[i].name); |
| top = ALIGN_UP(top, KERNEL_PAGE_SIZE); |
| memcpy(((void *) KERNEL_VIRTUAL_ADDRESS) + top, components[i].start, components[i].size); |
| if (i > 0) { |
| bootinfo.tasks[bootinfo.cnt].addr = ((void *) KERNEL_VIRTUAL_ADDRESS) + top; |
| bootinfo.tasks[bootinfo.cnt].size = components[i].size; |
| bootinfo.cnt++; |
| } |
| top += components[i].size; |
| printf("done.\n"); |
| } |
| printf("\nBooting the kernel...\n"); |
| jump_to_kernel((void *) KERNEL_VIRTUAL_ADDRESS, &bootinfo, sizeof(bootinfo)); |
| } |
| /** @} |
| */ |
| /tags/0.4.0/boot/arch/arm32/loader/mm.h |
|---|
| 0,0 → 1,166 |
| /* |
| * Copyright (c) 2007 Pavel Jancik |
| * Copyright (c) 2007 Michal Kebrt |
| * 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. |
| */ |
| /** @addtogroup arm32boot |
| * @{ |
| */ |
| /** @file |
| * @brief Memory management used while booting the kernel. |
| * |
| * So called "section" paging is used while booting the kernel. The term |
| * "section" comes from the ARM architecture specification and stands for the |
| * following: one-level paging, 1MB sized pages, 4096 entries in the page |
| * table. |
| */ |
| #ifndef BOOT_arm32__MM_H |
| #define BOOT_arm32__MM_H |
| #ifndef __ASM__ |
| #include "types.h" |
| #endif |
| /** Frame width. */ |
| #define FRAME_WIDTH 20 |
| /** Frame size. */ |
| #define FRAME_SIZE (1 << FRAME_WIDTH) |
| /** Page size in 2-level paging which is switched on later after the kernel |
| * initialization. |
| */ |
| #define KERNEL_PAGE_SIZE (1 << 12) |
| #ifndef __ASM__ |
| /** Converts kernel address to physical address. */ |
| # define KA2PA(x) (((uintptr_t) (x)) - 0x80000000) |
| /** Converts physical address to kernel address. */ |
| # define PA2KA(x) (((uintptr_t) (x)) + 0x80000000) |
| #else |
| # define KA2PA(x) ((x) - 0x80000000) |
| # define PA2KA(x) ((x) + 0x80000000) |
| #endif |
| /** Number of entries in PTL0. */ |
| #define PTL0_ENTRIES (1 << 12) /* 4096 */ |
| /** Size of an entry in PTL0. */ |
| #define PTL0_ENTRY_SIZE 4 |
| /** Returns number of frame the address belongs to. */ |
| #define ADDR2PFN(addr) (((uintptr_t) (addr)) >> FRAME_WIDTH) |
| /** Describes "section" page table entry (one-level paging with 1MB sized pages). */ |
| #define PTE_DESCRIPTOR_SECTION 0x2 |
| /** Page table access rights: user - no access, kernel - read/write. */ |
| #define PTE_AP_USER_NO_KERNEL_RW 0x1 |
| #ifndef __ASM__ |
| /** Page table level 0 entry - "section" format is used (one-level paging, 1MB |
| * sized pages). Used only while booting the kernel. |
| */ |
| typedef struct { |
| unsigned descriptor_type : 2; |
| unsigned bufferable : 1; |
| unsigned cacheable : 1; |
| unsigned impl_specific : 1; |
| unsigned domain : 4; |
| unsigned should_be_zero_1 : 1; |
| unsigned access_permission : 2; |
| unsigned should_be_zero_2 : 8; |
| unsigned section_base_addr : 12; |
| } __attribute__ ((packed)) pte_level0_section_t; |
| /** Page table that holds 1:1 virtual to physical mapping used while booting the |
| * kernel. |
| */ |
| extern pte_level0_section_t page_table[PTL0_ENTRIES]; |
| extern void mmu_start(void); |
| /** Enables paging. */ |
| static inline void enable_paging() |
| { |
| /* c3 - each two bits controls access to the one of domains (16) |
| * 0b01 - behave as a client (user) of a domain |
| */ |
| asm volatile ( |
| /* behave as a client of domains */ |
| "ldr r0, =0x55555555\n" |
| "mcr p15, 0, r0, c3, c0, 0\n" |
| /* current settings */ |
| "mrc p15, 0, r0, c1, c0, 0\n" |
| /* mask to enable paging */ |
| "ldr r1, =0x00000001\n" |
| "orr r0, r0, r1\n" |
| /* store settings */ |
| "mcr p15, 0, r0, c1, c0, 0\n" |
| : |
| : |
| : "r0", "r1" |
| ); |
| } |
| /** Sets the address of level 0 page table to CP15 register 2. |
| * |
| * @param pt Address of a page table to set. |
| */ |
| static inline void set_ptl0_address(pte_level0_section_t* pt) |
| { |
| asm volatile ( |
| "mcr p15, 0, %0, c2, c0, 0\n" |
| : |
| : "r" (pt) |
| ); |
| } |
| #endif |
| #endif |
| /** @} |
| */ |
| /tags/0.4.0/boot/arch/arm32/loader/asm.h |
|---|
| 0,0 → 1,72 |
| /* |
| * Copyright (c) 2007 Michal Kebrt |
| * 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. |
| */ |
| /** @addtogroup arm32boot |
| * @{ |
| */ |
| /** @file |
| * @brief Functions implemented in assembly. |
| */ |
| #ifndef BOOT_arm32_ASM_H |
| #define BOOT_arm32_ASM_H |
| /** Copies cnt bytes from dst to src. |
| * |
| * @param dst Destination address. |
| * @param src Source address. |
| * @param cnt Count of bytes to be copied. |
| */ |
| #define memcpy(dst, src, cnt) __builtin_memcpy((dst), (src), (cnt)) |
| /** Called when the CPU is switched on. |
| * |
| * This function is placed to the 0x0 address where ARM CPU starts execution. |
| * Jumps to the #bootstrap only. |
| */ |
| extern void start(void); |
| /** Jumps to the kernel entry point. |
| * |
| * @param entry Kernel entry point address. |
| * @param bootinfo Structure holding information about loaded tasks. |
| * @param bootinfo_size Size of the bootinfo structure. |
| */ |
| extern void jump_to_kernel(void *entry, void *bootinfo, |
| unsigned int bootinfo_size) __attribute__((noreturn)); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.0/boot/arch/arm32/loader/main.h |
|---|
| 0,0 → 1,77 |
| /* |
| * Copyright (c) 2007 Michal Kebrt |
| * 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. |
| */ |
| /** @addtogroup arm32boot |
| * @{ |
| */ |
| /** @file |
| * @brief Boot related declarations. |
| */ |
| #ifndef BOOT_arm32_MAIN_H |
| #define BOOT_arm32_MAIN_H |
| /** Aligns to the nearest higher address. |
| * |
| * @param addr Address or number to be aligned. |
| * @param align Size of alignment, must be power of 2. |
| */ |
| #define ALIGN_UP(addr, align) (((addr) + ((align) - 1)) & ~((align) - 1)) |
| /** Maximum number of tasks in the #bootinfo_t struct. */ |
| #define TASKMAP_MAX_RECORDS 32 |
| /** Struct holding information about single loaded task. */ |
| typedef struct { |
| /** Address where the task was placed. */ |
| void *addr; |
| /** Size of the task's binary. */ |
| unsigned int size; |
| } task_t; |
| /** Struct holding information about loaded tasks. */ |
| typedef struct { |
| /** Number of loaded tasks. */ |
| unsigned int cnt; |
| /** Array of loaded tasks. */ |
| task_t tasks[TASKMAP_MAX_RECORDS]; |
| } bootinfo_t; |
| extern void bootstrap(void); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.0/boot/arch/arm32/loader/mm.c |
|---|
| 0,0 → 1,95 |
| /* |
| * Copyright (c) 2007 Pavel Jancik, Michal Kebrt |
| * 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. |
| */ |
| /** @addtogroup arm32boot |
| * @{ |
| */ |
| /** @file |
| * @brief Memory management used while booting the kernel. |
| */ |
| #include "mm.h" |
| /** Initializes "section" page table entry. |
| * |
| * Will be readable/writable by kernel with no access from user mode. |
| * Will belong to domain 0. No cache or buffering is enabled. |
| * |
| * @param pte Section entry to initialize. |
| * @param frame First frame in the section (frame number). |
| * |
| * @note If frame is not 1MB aligned, first lower 1MB aligned frame will be |
| * used. |
| */ |
| static void init_pte_level0_section(pte_level0_section_t* pte, |
| unsigned int frame) |
| { |
| pte->descriptor_type = PTE_DESCRIPTOR_SECTION; |
| pte->bufferable = 0; |
| pte->cacheable = 0; |
| pte->impl_specific = 0; |
| pte->domain = 0; |
| pte->should_be_zero_1 = 0; |
| pte->access_permission = PTE_AP_USER_NO_KERNEL_RW; |
| pte->should_be_zero_2 = 0; |
| pte->section_base_addr = frame; |
| } |
| /** Initializes page table used while booting the kernel. */ |
| static void init_page_table(void) |
| { |
| int i; |
| const unsigned int first_kernel_page = ADDR2PFN(PA2KA(0)); |
| /* Create 1:1 virtual-physical mapping (in lower 2GB). */ |
| for (i = 0; i < first_kernel_page; i++) { |
| init_pte_level0_section(&page_table[i], i); |
| } |
| /* |
| * Create 1:1 virtual-physical mapping in kernel space (upper 2GB), |
| * physical addresses start from 0. |
| */ |
| for (i = first_kernel_page; i < PTL0_ENTRIES; i++) { |
| init_pte_level0_section(&page_table[i], i - first_kernel_page); |
| } |
| } |
| /** Starts the MMU - initializes page table and enables paging. */ |
| void mmu_start() { |
| init_page_table(); |
| set_ptl0_address(page_table); |
| enable_paging(); |
| } |
| /** @} |
| */ |
| /tags/0.4.0/boot/arch/arm32/loader/types.h |
|---|
| 0,0 → 1,59 |
| /* |
| * Copyright (c) 2006 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. |
| */ |
| /** @addtogroup arm32boot |
| * @{ |
| */ |
| /** @file |
| * @brief Definitions of basic types like #uintptr_t. |
| */ |
| #ifndef BOOT_arm32_TYPES_H |
| #define BOOT_arm32_TYPES_H |
| #include <gentypes.h> |
| typedef signed char int8_t; |
| typedef unsigned char uint8_t; |
| typedef unsigned short uint16_t; |
| typedef unsigned int uint32_t; |
| typedef unsigned long long uint64_t; |
| typedef uint32_t uintptr_t; |
| typedef uint32_t unative_t; |
| #endif |
| /** @} |
| */ |
| /tags/0.4.0/boot/arch/arm32/loader/print/gxemul.c |
|---|
| 0,0 → 1,70 |
| /* |
| * Copyright (c) 2007 Michal Kebrt |
| * 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. |
| */ |
| /** @addtogroup arm32boot |
| * @{ |
| */ |
| /** @file |
| * @brief GXemul specific code. |
| */ |
| #include <printf.h> |
| /** Address where characters to be printed are expected. */ |
| #define PUTC_ADDRESS 0x10000000 |
| /** Prints a character to the console. |
| * |
| * @param ch Character to be printed. |
| */ |
| static void putc(char ch) |
| { |
| *((volatile char *) PUTC_ADDRESS) = ch; |
| } |
| /** Prints a string to the console. |
| * |
| * @param str String to be printed. |
| * @param len Number of characters to be printed. |
| */ |
| void write(const char *str, const int len) |
| { |
| int i; |
| for (i = 0; i < len; ++i) { |
| putc(str[i]); |
| } |
| } |
| /** @} |
| */ |
| /tags/0.4.0/boot/arch/arm32/Makefile.inc |
|---|
| 0,0 → 1,42 |
| # |
| # Copyright (c) 2006 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. |
| # |
| build: $(BASE)/image.boot |
| $(BASE)/image.boot: depend arch/$(ARCH)/loader/image.boot |
| cp arch/$(ARCH)/loader/image.boot $(BASE)/image.boot |
| depend: |
| -rm arch/$(ARCH)/loader/image.boot |
| arch/$(ARCH)/loader/image.boot: |
| make -C arch/$(ARCH)/loader COMPILER=$(COMPILER) KERNELDIR=../../../$(KERNELDIR) USPACEDIR=../../../$(USPACEDIR) IMAGE=$(IMAGE) |
| clean: |
| make -C arch/$(ARCH)/loader clean COMPILER=$(COMPILER) KERNELDIR=../../../$(KERNELDIR) USPACEDIR=../../../$(USPACEDIR) IMAGE=$(IMAGE) |
| -rm -f $(BASE)/image.boot |
| /tags/0.4.0/boot/arch/mips32/loader/Makefile |
|---|
| 0,0 → 1,161 |
| # |
| # Copyright (c) 2006 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 ../../../../version |
| include ../../../../Makefile.config |
| ## Toolchain configuration |
| # |
| ifndef CROSS_PREFIX |
| CROSS_PREFIX = /usr/local |
| endif |
| ifeq ($(IMAGE),binary) |
| LD_IN = binary |
| endif |
| ifeq ($(IMAGE),ecoff) |
| LD_IN = ecoff |
| endif |
| BFD_NAME = elf32-tradlittlemips |
| BFD_ARCH = mips |
| TARGET = mipsel-linux-gnu |
| TOOLCHAIN_DIR = $(CROSS_PREFIX)/mipsel/bin |
| ifeq ($(COMPILER),gcc_native) |
| CC = gcc |
| AS = as |
| LD = ld |
| OBJCOPY = objcopy |
| OBJDUMP = objdump |
| endif |
| ifeq ($(COMPILER),gcc_cross) |
| CC = $(TOOLCHAIN_DIR)/$(TARGET)-gcc |
| AS = $(TOOLCHAIN_DIR)/$(TARGET)-as |
| LD = $(TOOLCHAIN_DIR)/$(TARGET)-ld |
| OBJCOPY = $(TOOLCHAIN_DIR)/$(TARGET)-objcopy |
| OBJDUMP = $(TOOLCHAIN_DIR)/$(TARGET)-objdump |
| endif |
| CFLAGS = -DRELEASE=\"$(RELEASE)\" -I. -I../../../generic -nostdinc -nostdlib -fno-builtin -Werror-implicit-function-declaration -Wmissing-prototypes -Werror -O3 -mno-abicalls -G 0 -fno-zero-initialized-in-bss -mhard-float -mips3 -pipe |
| ifdef REVISION |
| CFLAGS += "-DREVISION=\"$(REVISION)\"" |
| endif |
| ifdef TIMESTAMP |
| CFLAGS += "-DTIMESTAMP=\"$(TIMESTAMP)\"" |
| endif |
| SOURCES = \ |
| main.c \ |
| msim.c \ |
| _components.c \ |
| ../../../generic/printf.c \ |
| asm.S \ |
| boot.S |
| COMPONENTS = \ |
| $(KERNELDIR)/kernel.bin \ |
| $(USPACEDIR)/srv/ns/ns \ |
| $(USPACEDIR)/srv/loader/loader \ |
| $(USPACEDIR)/app/init/init \ |
| $(USPACEDIR)/srv/devmap/devmap \ |
| $(USPACEDIR)/srv/rd/rd \ |
| $(USPACEDIR)/srv/vfs/vfs |
| ifeq ($(RDFMT),tmpfs) |
| COMPONENTS += $(USPACEDIR)/srv/fs/tmpfs/tmpfs |
| endif |
| ifeq ($(RDFMT),fat) |
| COMPONENTS += $(USPACEDIR)/srv/fs/fat/fat |
| endif |
| RD_SRVS = \ |
| $(USPACEDIR)/srv/fb/fb \ |
| $(USPACEDIR)/srv/kbd/kbd \ |
| $(USPACEDIR)/srv/console/console \ |
| $(USPACEDIR)/srv/fs/tmpfs/tmpfs \ |
| $(USPACEDIR)/srv/fs/fat/fat |
| RD_APPS = \ |
| $(USPACEDIR)/app/tetris/tetris \ |
| $(USPACEDIR)/app/tester/tester \ |
| $(USPACEDIR)/app/trace/trace \ |
| $(USPACEDIR)/app/bdsh/bdsh \ |
| $(USPACEDIR)/app/klog/klog |
| OBJECTS := $(addsuffix .o,$(basename $(SOURCES))) |
| COMPONENT_OBJECTS := $(addsuffix .o,$(basename $(notdir $(COMPONENTS)))) |
| .PHONY: all clean depend |
| all: image.boot |
| -include Makefile.depend |
| image.boot: depend _components.h _link.ld $(COMPONENT_OBJECTS) initrd.o $(OBJECTS) |
| $(LD) -no-check-sections -N -T _link.ld $(COMPONENT_OBJECTS) initrd.o $(OBJECTS) -o $@ |
| depend: |
| -makedepend -f - -- $(DEFS) $(CFLAGS) -- $(SOURCES) > Makefile.depend 2> /dev/null |
| clean: |
| -for file in $(RD_SRVS) ; do \ |
| rm -f $(USPACEDIR)/dist/srv/`basename $$file` ; \ |
| done |
| -for file in $(RD_APPS) ; do \ |
| rm -f $(USPACEDIR)/dist/app/`basename $$file` ; \ |
| done |
| -rm -f _components.h _components.c _link.ld _link.ld.in $(COMPONENT_OBJECTS) initrd.o $(OBJECTS) initrd.img image.boot Makefile.depend |
| _components.h _components.c _link.ld $(COMPONENT_OBJECTS) initrd.o: $(COMPONENTS) $(RD_SRVS) $(RD_APPS) _link.ld.in |
| for file in $(RD_SRVS) ; do \ |
| cp $$file $(USPACEDIR)/dist/srv/ ; \ |
| done |
| for file in $(RD_APPS) ; do \ |
| cp $$file $(USPACEDIR)/dist/app/ ; \ |
| done |
| ifeq ($(RDFMT),tmpfs) |
| ../../../../tools/mktmpfs.py $(USPACEDIR)/dist/ initrd.fs |
| endif |
| ifeq ($(RDFMT),fat) |
| ../../../../tools/mkfat.py $(USPACEDIR)/dist/ initrd.fs |
| endif |
| ../../../../tools/mkhord.py 16384 initrd.fs initrd.img |
| rm initrd.fs |
| ../../../tools/pack.py $(OBJCOPY) $(BFD_NAME) $(BFD_ARCH) 16384 "unsigned int" $(COMPONENTS) ./initrd.img |
| _link.ld.in: _link.ld.in.$(LD_IN) |
| cp $< $@ |
| %.o: %.S |
| $(CC) $(DEFS) $(CFLAGS) -D__ASM__ -c $< -o $@ |
| %.o: %.c |
| $(CC) $(DEFS) $(CFLAGS) -c $< -o $@ |
| /tags/0.4.0/boot/arch/mips32/loader/asm.S |
|---|
| 0,0 → 1,116 |
| # |
| # Copyright (c) 2006 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 "regname.h" |
| .set noat |
| .set noreorder |
| .set nomacro |
| .text |
| .global halt |
| .global memcpy |
| .global jump_to_kernel |
| halt: |
| b halt |
| nop |
| memcpy: |
| addiu $v0,$a1,3 |
| li $v1,-4 # 0xfffffffffffffffc |
| and $v0,$v0,$v1 |
| beq $a1,$v0,3f |
| move $t0,$a0 |
| move $t2,$a0 # save dst |
| 0: |
| beq $a2,$zero,2f |
| move $a3,$zero |
| 1: |
| addu $v0,$a1,$a3 |
| lbu $a0,0($v0) |
| addu $v1,$t0,$a3 |
| addiu $a3,$a3,1 |
| bne $a3,$a2,1b |
| sb $a0,0($v1) |
| 2: |
| jr $ra |
| move $v0,$t2 |
| 3: |
| addiu $v0,$a0,3 |
| and $v0,$v0,$v1 |
| bne $a0,$v0,0b |
| srl $t1,$a2,2 |
| beq $t1,$zero,5f |
| move $a3,$zero |
| move $a3,$zero |
| move $a0,$zero |
| 4: |
| addu $v0,$a1,$a0 |
| lw $v1,0($v0) |
| addiu $a3,$a3,1 |
| addu $v0,$t0,$a0 |
| sw $v1,0($v0) |
| bne $a3,$t1,4b |
| addiu $a0,$a0,4 |
| 5: |
| andi $a2,$a2,0x3 |
| beq $a2,$zero,2b |
| nop |
| sll $v0,$a3,2 |
| addu $t1,$v0,$t0 |
| move $a3,$zero |
| addu $t0,$v0,$a1 |
| 6: |
| addu $v0,$t0,$a3 |
| lbu $a0,0($v0) |
| addu $v1,$t1,$a3 |
| addiu $a3,$a3,1 |
| bne $a3,$a2,6b |
| sb $a0,0($v1) |
| jr $ra |
| move $v0,$t2 |
| jump_to_kernel: |
| # |
| # TODO |
| # Make sure that the I-cache, D-cache and memory are mutually coherent |
| # before passing control to the copied code. |
| # |
| j $a0 |
| nop |
| /tags/0.4.0/boot/arch/mips32/loader/_link.ld.in.ecoff |
|---|
| 0,0 → 1,21 |
| OUTPUT_FORMAT("ecoff-littlemips") |
| ENTRY(start) |
| SECTIONS { |
| .boot 0xbfc00000: AT (0) { |
| *(BOOTSTRAP); |
| *(.text); |
| *(.rodata); |
| *(.rodata.*); |
| *(.data); /* initialized data */ |
| *(.sdata); |
| *(.sdata2); |
| *(.sbss); |
| *(.scommon); |
| *(.bss); /* uninitialized static variables */ |
| *(COMMON); /* global variables */ |
| *(.reginfo); |
| [[COMPONENTS]] |
| } |
| } |
| /tags/0.4.0/boot/arch/mips32/loader/_link.ld.in.binary |
|---|
| 0,0 → 1,21 |
| OUTPUT_FORMAT("binary") |
| ENTRY(start) |
| SECTIONS { |
| .boot 0xbfc00000: AT (0) { |
| *(BOOTSTRAP); |
| *(.text); |
| *(.rodata); |
| *(.rodata.*); |
| *(.data); /* initialized data */ |
| *(.sdata); |
| *(.sdata2); |
| *(.sbss); |
| *(.scommon); |
| *(.bss); /* uninitialized static variables */ |
| *(COMMON); /* global variables */ |
| *(.reginfo); |
| [[COMPONENTS]] |
| } |
| } |
| /tags/0.4.0/boot/arch/mips32/loader/main.c |
|---|
| 0,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 "main.h" |
| #include <printf.h> |
| #include "msim.h" |
| #include "asm.h" |
| #include "_components.h" |
| #define KERNEL_VIRTUAL_ADDRESS 0x80100000 |
| char *release = RELEASE; |
| #ifdef REVISION |
| char *revision = ", revision " REVISION; |
| #else |
| char *revision = ""; |
| #endif |
| #ifdef TIMESTAMP |
| char *timestamp = "\nBuilt on " TIMESTAMP; |
| #else |
| char *timestamp = ""; |
| #endif |
| /** Print version information. */ |
| static void version_print(void) |
| { |
| printf("HelenOS MIPS32 Bootloader\nRelease %s%s%s\nCopyright (c) 2006 HelenOS project\n", release, revision, timestamp); |
| } |
| void bootstrap(void) |
| { |
| version_print(); |
| component_t components[COMPONENTS]; |
| init_components(components); |
| bootinfo_t bootinfo; |
| printf("\nMemory statistics\n"); |
| printf(" kernel entry point at %L\n", KERNEL_VIRTUAL_ADDRESS); |
| printf(" %L: boot info structure\n", &bootinfo); |
| unsigned int i; |
| for (i = 0; i < COMPONENTS; i++) |
| printf(" %L: %s image (size %d bytes)\n", components[i].start, components[i].name, components[i].size); |
| printf("\nCopying components\n"); |
| unsigned int top = 0; |
| bootinfo.cnt = 0; |
| for (i = 0; i < COMPONENTS; i++) { |
| printf(" %s...", components[i].name); |
| top = ALIGN_UP(top, PAGE_SIZE); |
| memcpy(((void *) KERNEL_VIRTUAL_ADDRESS) + top, components[i].start, components[i].size); |
| if (i > 0) { |
| bootinfo.tasks[bootinfo.cnt].addr = ((void *) KERNEL_VIRTUAL_ADDRESS) + top; |
| bootinfo.tasks[bootinfo.cnt].size = components[i].size; |
| bootinfo.cnt++; |
| } |
| top += components[i].size; |
| printf("done.\n"); |
| } |
| printf("\nBooting the kernel...\n"); |
| jump_to_kernel((void *) KERNEL_VIRTUAL_ADDRESS, &bootinfo, sizeof(bootinfo)); |
| } |
| /tags/0.4.0/boot/arch/mips32/loader/regname.h |
|---|
| 0,0 → 1,88 |
| /* |
| * 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 BOOT_mips32_REGNAME_H_ |
| #define BOOT_mips32_REGNAME_H_ |
| #define zero 0 |
| #define at 1 |
| #define v0 2 |
| #define v1 3 |
| #define a0 4 |
| #define a1 5 |
| #define a2 6 |
| #define a3 7 |
| #define t0 8 |
| #define t1 9 |
| #define t2 10 |
| #define t3 11 |
| #define t4 12 |
| #define t5 13 |
| #define t6 14 |
| #define t7 15 |
| #define s0 16 |
| #define s1 17 |
| #define s2 18 |
| #define s3 19 |
| #define s4 20 |
| #define s5 21 |
| #define s6 22 |
| #define s7 23 |
| #define t8 24 |
| #define t9 25 |
| #define k0 26 |
| #define k1 27 |
| #define gp 28 |
| #define sp 29 |
| #define s8 30 |
| #define ra 31 |
| #define rindex 0 |
| #define rrandom 1 |
| #define entrylo0 2 |
| #define entrylo1 3 |
| #define context 4 |
| #define pagemask 5 |
| #define wired 6 |
| #define badvaddr 8 |
| #define count 9 |
| #define entryhi 10 |
| #define compare 11 |
| #define status 12 |
| #define cause 13 |
| #define epc 14 |
| #define rconfig 16 |
| #define lladdr 17 |
| #define watchlo 18 |
| #define watchhi 19 |
| #define xcontext 20 |
| #define rdebug 23 |
| #define depc 24 |
| #define eepc 30 |
| #endif /* _REGNAME_H_ */ |
| /tags/0.4.0/boot/arch/mips32/loader/asm.h |
|---|
| 0,0 → 1,39 |
| /* |
| * Copyright (c) 2006 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 BOOT_mips32_ASM_H_ |
| #define BOOT_mips32_ASM_H_ |
| #define PAGE_SIZE 16384 |
| #define PAGE_WIDTH 14 |
| #define memcpy(dst, src, cnt) __builtin_memcpy((dst), (src), (cnt)) |
| void jump_to_kernel(void *entry, void *bootinfo, unsigned int bootinfo_size) __attribute__((noreturn)); |
| #endif |
| /tags/0.4.0/boot/arch/mips32/loader/main.h |
|---|
| 0,0 → 1,54 |
| /* |
| * 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 BOOT_mips32_MAIN_H_ |
| #define BOOT_mips32_MAIN_H_ |
| /** Align to the nearest higher address. |
| * |
| * @param addr Address or size to be aligned. |
| * @param align Size of alignment, must be power of 2. |
| */ |
| #define ALIGN_UP(addr, align) (((addr) + ((align) - 1)) & ~((align) - 1)) |
| #define TASKMAP_MAX_RECORDS 32 |
| typedef struct { |
| void *addr; |
| unsigned int size; |
| } task_t; |
| typedef struct { |
| unsigned int cnt; |
| task_t tasks[TASKMAP_MAX_RECORDS]; |
| } bootinfo_t; |
| extern void start(void); |
| extern void bootstrap(void); |
| #endif |
| /tags/0.4.0/boot/arch/mips32/loader/types.h |
|---|
| 0,0 → 1,44 |
| /* |
| * Copyright (c) 2006 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 BOOT_mips32_TYPES_H_ |
| #define BOOT_mips32_TYPES_H_ |
| #include <gentypes.h> |
| typedef signed char int8_t; |
| typedef unsigned char uint8_t; |
| typedef unsigned short uint16_t; |
| typedef unsigned int uint32_t; |
| typedef unsigned long long uint64_t; |
| typedef uint32_t uintptr_t; |
| typedef uint32_t unative_t; |
| #endif |
| /tags/0.4.0/boot/arch/mips32/loader/msim.h |
|---|
| 0,0 → 1,37 |
| /* |
| * Copyright (c) 2006 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 BOOT_mips32_MSIM_H_ |
| #define BOOT_mips32_MSIM_H_ |
| extern void init(void); |
| extern void halt(void); |
| extern void *translate(void *addr); |
| #endif |
| /tags/0.4.0/boot/arch/mips32/loader/boot.S |
|---|
| 0,0 → 1,45 |
| # |
| # Copyright (c) 2006 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 "regname.h" |
| #define INITIAL_STACK 0x80040000 |
| .set noat |
| .set noreorder |
| .set nomacro |
| .section BOOTSTRAP |
| .global start |
| start: |
| lui $sp, INITIAL_STACK >> 16 |
| ori $sp, $sp, INITIAL_STACK & 0xffff |
| j bootstrap |
| nop |
| /tags/0.4.0/boot/arch/mips32/loader/msim.c |
|---|
| 0,0 → 1,40 |
| /* |
| * Copyright (c) 2006 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 "msim.h" |
| #include <printf.h> |
| #define MSIM_VIDEORAM 0xB0000000 |
| void write(const char *str, const int len) |
| { |
| int i; |
| for (i = 0; i < len; i++) |
| *((char *) MSIM_VIDEORAM) = str[i]; |
| } |
| /tags/0.4.0/boot/arch/mips32/Makefile.inc |
|---|
| 0,0 → 1,42 |
| # |
| # Copyright (c) 2006 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. |
| # |
| build: $(BASE)/image.boot |
| $(BASE)/image.boot: depend arch/$(ARCH)/loader/image.boot |
| cp arch/$(ARCH)/loader/image.boot $(BASE)/image.boot |
| depend: |
| -rm arch/$(ARCH)/loader/image.boot |
| arch/$(ARCH)/loader/image.boot: |
| make -C arch/$(ARCH)/loader COMPILER=$(COMPILER) KERNELDIR=../../../$(KERNELDIR) USPACEDIR=../../../$(USPACEDIR) IMAGE=$(IMAGE) |
| clean: |
| make -C arch/$(ARCH)/loader clean COMPILER=$(COMPILER) KERNELDIR=../../../$(KERNELDIR) USPACEDIR=../../../$(USPACEDIR) IMAGE=$(IMAGE) |
| -rm -f $(BASE)/image.boot |
| /tags/0.4.0/boot/arch/amd64/Makefile.inc |
|---|
| 0,0 → 1,97 |
| # |
| # Copyright (c) 2006 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. |
| # |
| INIT_TASKS = \ |
| $(USPACEDIR)/srv/ns/ns \ |
| $(USPACEDIR)/srv/loader/loader \ |
| $(USPACEDIR)/app/init/init \ |
| $(USPACEDIR)/srv/devmap/devmap \ |
| $(USPACEDIR)/srv/rd/rd \ |
| $(USPACEDIR)/srv/vfs/vfs |
| ifeq ($(RDFMT),tmpfs) |
| INIT_TASKS += $(USPACEDIR)/srv/fs/tmpfs/tmpfs |
| endif |
| ifeq ($(RDFMT),fat) |
| INIT_TASKS += $(USPACEDIR)/srv/fs/fat/fat |
| endif |
| RD_SRVS = \ |
| $(USPACEDIR)/srv/pci/pci \ |
| $(USPACEDIR)/srv/fb/fb \ |
| $(USPACEDIR)/srv/kbd/kbd \ |
| $(USPACEDIR)/srv/console/console \ |
| $(USPACEDIR)/srv/fs/tmpfs/tmpfs \ |
| $(USPACEDIR)/srv/fs/fat/fat |
| RD_APPS = \ |
| $(USPACEDIR)/app/tetris/tetris \ |
| $(USPACEDIR)/app/tester/tester \ |
| $(USPACEDIR)/app/trace/trace \ |
| $(USPACEDIR)/app/klog/klog \ |
| $(USPACEDIR)/app/bdsh/bdsh |
| build: $(BASE)/image.iso |
| $(BASE)/image.iso: arch/$(ARCH)/grub/stage2_eltorito arch/$(ARCH)/grub/menu.lst $(KERNELDIR)/kernel.bin $(INIT_TASKS) $(RD_SRVS) $(RD_APPS) |
| mkdir -p arch/$(ARCH)/iso/boot/grub |
| cp arch/$(ARCH)/grub/stage2_eltorito arch/$(ARCH)/iso/boot/grub/ |
| ifneq ($(RDFMT),tmpfs) |
| cat arch/$(ARCH)/grub/menu.lst | grep -v "tmpfs" >arch/$(ARCH)/iso/boot/grub/menu.lst |
| endif |
| ifneq ($(RDFMT),fat) |
| cat arch/$(ARCH)/grub/menu.lst | grep -v "fat" >arch/$(ARCH)/iso/boot/grub/menu.lst |
| endif |
| cp $(KERNELDIR)/kernel.bin arch/$(ARCH)/iso/boot/ |
| for task in $(INIT_TASKS) ; do \ |
| cp $$task arch/$(ARCH)/iso/boot/ ; \ |
| done |
| for file in $(RD_SRVS) ; do \ |
| cp $$file $(USPACEDIR)/dist/srv/ ; \ |
| done |
| for file in $(RD_APPS) ; do \ |
| cp $$file $(USPACEDIR)/dist/app/ ; \ |
| done |
| ifeq ($(RDFMT),tmpfs) |
| $(BASE)/tools/mktmpfs.py $(USPACEDIR)/dist/ arch/$(ARCH)/iso/boot/initrd.fs |
| endif |
| ifeq ($(RDFMT),fat) |
| $(BASE)/tools/mkfat.py $(USPACEDIR)/dist/ arch/$(ARCH)/iso/boot/initrd.fs |
| endif |
| $(BASE)/tools/mkhord.py 4096 arch/$(ARCH)/iso/boot/initrd.fs arch/$(ARCH)/iso/boot/initrd.img |
| rm arch/$(ARCH)/iso/boot/initrd.fs |
| mkisofs -J -r -b boot/grub/stage2_eltorito -no-emul-boot -boot-load-size 4 -boot-info-table -o $(BASE)/image.iso arch/$(ARCH)/iso/ |
| clean: |
| -for file in $(RD_SRVS) ; do \ |
| rm -f $(USPACEDIR)/dist/srv/`basename $$file` ; \ |
| done |
| -for file in $(RD_APPS) ; do \ |
| rm -f $(USPACEDIR)/dist/app/`basename $$file` ; \ |
| done |
| -rm -fr arch/$(ARCH)/iso |
| -rm -f $(BASE)/image.iso |
| /tags/0.4.0/boot/arch/amd64/grub/menu.lst |
|---|
| 0,0 → 1,15 |
| default 0 |
| timeout 10 |
| title=HelenOS |
| root (cd) |
| kernel /boot/kernel.bin |
| module /boot/ns |
| module /boot/init |
| module /boot/devmap |
| module /boot/rd |
| module /boot/vfs |
| module /boot/tmpfs |
| module /boot/fat |
| module /boot/loader |
| module /boot/initrd.img |
| /tags/0.4.0/boot/arch/amd64/grub/stage2_eltorito |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /tags/0.4.0/boot/arch/amd64/grub/COPYING |
|---|
| 0,0 → 1,340 |
| GNU GENERAL PUBLIC LICENSE |
| Version 2, June 1991 |
| Copyright (C) 1989, 1991 Free Software Foundation, Inc. |
| 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| Everyone is permitted to copy and distribute verbatim copies |
| of this license document, but changing it is not allowed. |
| Preamble |
| The licenses for most software are designed to take away your |
| freedom to share and change it. By contrast, the GNU General Public |
| License is intended to guarantee your freedom to share and change free |
| software--to make sure the software is free for all its users. This |
| General Public License applies to most of the Free Software |
| Foundation's software and to any other program whose authors commit to |
| using it. (Some other Free Software Foundation software is covered by |
| the GNU Library General Public License instead.) You can apply it to |
| your programs, too. |
| When we speak of free software, we are referring to freedom, not |
| price. Our General Public Licenses are designed to make sure that you |
| have the freedom to distribute copies of free software (and charge for |
| this service if you wish), that you receive source code or can get it |
| if you want it, that you can change the software or use pieces of it |
| in new free programs; and that you know you can do these things. |
| To protect your rights, we need to make restrictions that forbid |
| anyone to deny you these rights or to ask you to surrender the rights. |
| These restrictions translate to certain responsibilities for you if you |
| distribute copies of the software, or if you modify it. |
| For example, if you distribute copies of such a program, whether |
| gratis or for a fee, you must give the recipients all the rights that |
| you have. You must make sure that they, too, receive or can get the |
| source code. And you must show them these terms so they know their |
| rights. |
| We protect your rights with two steps: (1) copyright the software, and |
| (2) offer you this license which gives you legal permission to copy, |
| distribute and/or modify the software. |
| Also, for each author's protection and ours, we want to make certain |
| that everyone understands that there is no warranty for this free |
| software. If the software is modified by someone else and passed on, we |
| want its recipients to know that what they have is not the original, so |
| that any problems introduced by others will not reflect on the original |
| authors' reputations. |
| Finally, any free program is threatened constantly by software |
| patents. We wish to avoid the danger that redistributors of a free |
| program will individually obtain patent licenses, in effect making the |
| program proprietary. To prevent this, we have made it clear that any |
| patent must be licensed for everyone's free use or not licensed at all. |
| The precise terms and conditions for copying, distribution and |
| modification follow. |
| GNU GENERAL PUBLIC LICENSE |
| TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION |
| 0. This License applies to any program or other work which contains |
| a notice placed by the copyright holder saying it may be distributed |
| under the terms of this General Public License. The "Program", below, |
| refers to any such program or work, and a "work based on the Program" |
| means either the Program or any derivative work under copyright law: |
| that is to say, a work containing the Program or a portion of it, |
| either verbatim or with modifications and/or translated into another |
| language. (Hereinafter, translation is included without limitation in |
| the term "modification".) Each licensee is addressed as "you". |
| Activities other than copying, distribution and modification are not |
| covered by this License; they are outside its scope. The act of |
| running the Program is not restricted, and the output from the Program |
| is covered only if its contents constitute a work based on the |
| Program (independent of having been made by running the Program). |
| Whether that is true depends on what the Program does. |
| 1. You may copy and distribute verbatim copies of the Program's |
| source code as you receive it, in any medium, provided that you |
| conspicuously and appropriately publish on each copy an appropriate |
| copyright notice and disclaimer of warranty; keep intact all the |
| notices that refer to this License and to the absence of any warranty; |
| and give any other recipients of the Program a copy of this License |
| along with the Program. |
| You may charge a fee for the physical act of transferring a copy, and |
| you may at your option offer warranty protection in exchange for a fee. |
| 2. You may modify your copy or copies of the Program or any portion |
| of it, thus forming a work based on the Program, and copy and |
| distribute such modifications or work under the terms of Section 1 |
| above, provided that you also meet all of these conditions: |
| a) You must cause the modified files to carry prominent notices |
| stating that you changed the files and the date of any change. |
| b) You must cause any work that you distribute or publish, that in |
| whole or in part contains or is derived from the Program or any |
| part thereof, to be licensed as a whole at no charge to all third |
| parties under the terms of this License. |
| c) If the modified program normally reads commands interactively |
| when run, you must cause it, when started running for such |
| interactive use in the most ordinary way, to print or display an |
| announcement including an appropriate copyright notice and a |
| notice that there is no warranty (or else, saying that you provide |
| a warranty) and that users may redistribute the program under |
| these conditions, and telling the user how to view a copy of this |
| License. (Exception: if the Program itself is interactive but |
| does not normally print such an announcement, your work based on |
| the Program is not required to print an announcement.) |
| These requirements apply to the modified work as a whole. If |
| identifiable sections of that work are not derived from the Program, |
| and can be reasonably considered independent and separate works in |
| themselves, then this License, and its terms, do not apply to those |
| sections when you distribute them as separate works. But when you |
| distribute the same sections as part of a whole which is a work based |
| on the Program, the distribution of the whole must be on the terms of |
| this License, whose permissions for other licensees extend to the |
| entire whole, and thus to each and every part regardless of who wrote it. |
| Thus, it is not the intent of this section to claim rights or contest |
| your rights to work written entirely by you; rather, the intent is to |
| exercise the right to control the distribution of derivative or |
| collective works based on the Program. |
| In addition, mere aggregation of another work not based on the Program |
| with the Program (or with a work based on the Program) on a volume of |
| a storage or distribution medium does not bring the other work under |
| the scope of this License. |
| 3. You may copy and distribute the Program (or a work based on it, |
| under Section 2) in object code or executable form under the terms of |
| Sections 1 and 2 above provided that you also do one of the following: |
| a) Accompany it with the complete corresponding machine-readable |
| source code, which must be distributed under the terms of Sections |
| 1 and 2 above on a medium customarily used for software interchange; or, |
| b) Accompany it with a written offer, valid for at least three |
| years, to give any third party, for a charge no more than your |
| cost of physically performing source distribution, a complete |
| machine-readable copy of the corresponding source code, to be |
| distributed under the terms of Sections 1 and 2 above on a medium |
| customarily used for software interchange; or, |
| c) Accompany it with the information you received as to the offer |
| to distribute corresponding source code. (This alternative is |
| allowed only for noncommercial distribution and only if you |
| received the program in object code or executable form with such |
| an offer, in accord with Subsection b above.) |
| The source code for a work means the preferred form of the work for |
| making modifications to it. For an executable work, complete source |
| code means all the source code for all modules it contains, plus any |
| associated interface definition files, plus the scripts used to |
| control compilation and installation of the executable. However, as a |
| special exception, the source code distributed need not include |
| anything that is normally distributed (in either source or binary |
| form) with the major components (compiler, kernel, and so on) of the |
| operating system on which the executable runs, unless that component |
| itself accompanies the executable. |
| If distribution of executable or object code is made by offering |
| access to copy from a designated place, then offering equivalent |
| access to copy the source code from the same place counts as |
| distribution of the source code, even though third parties are not |
| compelled to copy the source along with the object code. |
| 4. You may not copy, modify, sublicense, or distribute the Program |
| except as expressly provided under this License. Any attempt |
| otherwise to copy, modify, sublicense or distribute the Program is |
| void, and will automatically terminate your rights under this License. |
| However, parties who have received copies, or rights, from you under |
| this License will not have their licenses terminated so long as such |
| parties remain in full compliance. |
| 5. You are not required to accept this License, since you have not |
| signed it. However, nothing else grants you permission to modify or |
| distribute the Program or its derivative works. These actions are |
| prohibited by law if you do not accept this License. Therefore, by |
| modifying or distributing the Program (or any work based on the |
| Program), you indicate your acceptance of this License to do so, and |
| all its terms and conditions for copying, distributing or modifying |
| the Program or works based on it. |
| 6. Each time you redistribute the Program (or any work based on the |
| Program), the recipient automatically receives a license from the |
| original licensor to copy, distribute or modify the Program subject to |
| these terms and conditions. You may not impose any further |
| restrictions on the recipients' exercise of the rights granted herein. |
| You are not responsible for enforcing compliance by third parties to |
| this License. |
| 7. If, as a consequence of a court judgment or allegation of patent |
| infringement or for any other reason (not limited to patent issues), |
| conditions are imposed on you (whether by court order, agreement or |
| otherwise) that contradict the conditions of this License, they do not |
| excuse you from the conditions of this License. If you cannot |
| distribute so as to satisfy simultaneously your obligations under this |
| License and any other pertinent obligations, then as a consequence you |
| may not distribute the Program at all. For example, if a patent |
| license would not permit royalty-free redistribution of the Program by |
| all those who receive copies directly or indirectly through you, then |
| the only way you could satisfy both it and this License would be to |
| refrain entirely from distribution of the Program. |
| If any portion of this section is held invalid or unenforceable under |
| any particular circumstance, the balance of the section is intended to |
| apply and the section as a whole is intended to apply in other |
| circumstances. |
| It is not the purpose of this section to induce you to infringe any |
| patents or other property right claims or to contest validity of any |
| such claims; this section has the sole purpose of protecting the |
| integrity of the free software distribution system, which is |
| implemented by public license practices. Many people have made |
| generous contributions to the wide range of software distributed |
| through that system in reliance on consistent application of that |
| system; it is up to the author/donor to decide if he or she is willing |
| to distribute software through any other system and a licensee cannot |
| impose that choice. |
| This section is intended to make thoroughly clear what is believed to |
| be a consequence of the rest of this License. |
| 8. If the distribution and/or use of the Program is restricted in |
| certain countries either by patents or by copyrighted interfaces, the |
| original copyright holder who places the Program under this License |
| may add an explicit geographical distribution limitation excluding |
| those countries, so that distribution is permitted only in or among |
| countries not thus excluded. In such case, this License incorporates |
| the limitation as if written in the body of this License. |
| 9. The Free Software Foundation may publish revised and/or new versions |
| of the General Public License from time to time. Such new versions will |
| be similar in spirit to the present version, but may differ in detail to |
| address new problems or concerns. |
| Each version is given a distinguishing version number. If the Program |
| specifies a version number of this License which applies to it and "any |
| later version", you have the option of following the terms and conditions |
| either of that version or of any later version published by the Free |
| Software Foundation. If the Program does not specify a version number of |
| this License, you may choose any version ever published by the Free Software |
| Foundation. |
| 10. If you wish to incorporate parts of the Program into other free |
| programs whose distribution conditions are different, write to the author |
| to ask for permission. For software which is copyrighted by the Free |
| Software Foundation, write to the Free Software Foundation; we sometimes |
| make exceptions for this. Our decision will be guided by the two goals |
| of preserving the free status of all derivatives of our free software and |
| of promoting the sharing and reuse of software generally. |
| NO WARRANTY |
| 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY |
| FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN |
| OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES |
| PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED |
| OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS |
| TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE |
| PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, |
| REPAIR OR CORRECTION. |
| 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING |
| WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR |
| REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, |
| INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING |
| OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED |
| TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY |
| YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER |
| PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE |
| POSSIBILITY OF SUCH DAMAGES. |
| END OF TERMS AND CONDITIONS |
| How to Apply These Terms to Your New Programs |
| If you develop a new program, and you want it to be of the greatest |
| possible use to the public, the best way to achieve this is to make it |
| free software which everyone can redistribute and change under these terms. |
| To do so, attach the following notices to the program. It is safest |
| to attach them to the start of each source file to most effectively |
| convey the exclusion of warranty; and each file should have at least |
| the "copyright" line and a pointer to where the full notice is found. |
| <one line to give the program's name and a brief idea of what it does.> |
| Copyright (C) <year> <name of author> |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2 of the License, or |
| (at your option) any later version. |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| You should have received a copy of the GNU General Public License |
| along with this program; if not, write to the Free Software |
| Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| Also add information on how to contact you by electronic and paper mail. |
| If the program is interactive, make it output a short notice like this |
| when it starts in an interactive mode: |
| Gnomovision version 69, Copyright (C) year name of author |
| Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. |
| This is free software, and you are welcome to redistribute it |
| under certain conditions; type `show c' for details. |
| The hypothetical commands `show w' and `show c' should show the appropriate |
| parts of the General Public License. Of course, the commands you use may |
| be called something other than `show w' and `show c'; they could even be |
| mouse-clicks or menu items--whatever suits your program. |
| You should also get your employer (if you work as a programmer) or your |
| school, if any, to sign a "copyright disclaimer" for the program, if |
| necessary. Here is a sample; alter the names: |
| Yoyodyne, Inc., hereby disclaims all copyright interest in the program |
| `Gnomovision' (which makes passes at compilers) written by James Hacker. |
| <signature of Ty Coon>, 1 April 1989 |
| Ty Coon, President of Vice |
| This General Public License does not permit incorporating your program into |
| proprietary programs. If your program is a subroutine library, you may |
| consider it more useful to permit linking proprietary applications with the |
| library. If this is what you want to do, use the GNU Library General |
| Public License instead of this License. |
| /tags/0.4.0/boot/arch/amd64/grub/README |
|---|
| 0,0 → 1,5 |
| For licensing terms of GRUB boot loader see the file COPYING contained |
| in this directory. Full version of GRUB, including its source code, |
| can be downloaded from GRUB's project page: |
| http://www.gnu.org/software/grub/ |
| /tags/0.4.0/boot/arch/ia32/Makefile.inc |
|---|
| 0,0 → 1,96 |
| # |
| # Copyright (c) 2006 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. |
| # |
| INIT_TASKS = \ |
| $(USPACEDIR)/srv/ns/ns \ |
| $(USPACEDIR)/srv/loader/loader \ |
| $(USPACEDIR)/app/init/init \ |
| $(USPACEDIR)/srv/devmap/devmap \ |
| $(USPACEDIR)/srv/rd/rd \ |
| $(USPACEDIR)/srv/vfs/vfs |
| ifeq ($(RDFMT),tmpfs) |
| INIT_TASKS += $(USPACEDIR)/srv/fs/tmpfs/tmpfs |
| endif |
| ifeq ($(RDFMT),fat) |
| INIT_TASKS += $(USPACEDIR)/srv/fs/fat/fat |
| endif |
| RD_SRVS = \ |
| $(USPACEDIR)/srv/pci/pci \ |
| $(USPACEDIR)/srv/fb/fb \ |
| $(USPACEDIR)/srv/kbd/kbd \ |
| $(USPACEDIR)/srv/console/console \ |
| $(USPACEDIR)/srv/fs/fat/fat |
| RD_APPS = \ |
| $(USPACEDIR)/app/tetris/tetris \ |
| $(USPACEDIR)/app/tester/tester \ |
| $(USPACEDIR)/app/trace/trace \ |
| $(USPACEDIR)/app/klog/klog \ |
| $(USPACEDIR)/app/bdsh/bdsh |
| build: $(BASE)/image.iso |
| $(BASE)/image.iso: arch/$(ARCH)/grub/stage2_eltorito arch/$(ARCH)/grub/menu.lst $(KERNELDIR)/kernel.bin $(INIT_TASKS) $(RD_SRVS) $(RD_APPS) |
| mkdir -p arch/$(ARCH)/iso/boot/grub |
| cp arch/$(ARCH)/grub/stage2_eltorito arch/$(ARCH)/iso/boot/grub/ |
| ifneq ($(RDFMT),tmpfs) |
| cat arch/$(ARCH)/grub/menu.lst | grep -v "tmpfs" >arch/$(ARCH)/iso/boot/grub/menu.lst |
| endif |
| ifneq ($(RDFMT),fat) |
| cat arch/$(ARCH)/grub/menu.lst | grep -v "fat" >arch/$(ARCH)/iso/boot/grub/menu.lst |
| endif |
| cp $(KERNELDIR)/kernel.bin arch/$(ARCH)/iso/boot/ |
| for task in $(INIT_TASKS) ; do \ |
| cp $$task arch/$(ARCH)/iso/boot/ ; \ |
| done |
| for file in $(RD_SRVS) ; do \ |
| cp $$file $(USPACEDIR)/dist/srv/ ; \ |
| done |
| for file in $(RD_APPS) ; do \ |
| cp $$file $(USPACEDIR)/dist/app/ ; \ |
| done |
| ifeq ($(RDFMT),tmpfs) |
| $(BASE)/tools/mktmpfs.py $(USPACEDIR)/dist/ arch/$(ARCH)/iso/boot/initrd.fs |
| endif |
| ifeq ($(RDFMT),fat) |
| $(BASE)/tools/mkfat.py $(USPACEDIR)/dist/ arch/$(ARCH)/iso/boot/initrd.fs |
| endif |
| $(BASE)/tools/mkhord.py 4096 arch/$(ARCH)/iso/boot/initrd.fs arch/$(ARCH)/iso/boot/initrd.img |
| rm arch/$(ARCH)/iso/boot/initrd.fs |
| mkisofs -J -r -b boot/grub/stage2_eltorito -no-emul-boot -boot-load-size 4 -boot-info-table -o $(BASE)/image.iso arch/$(ARCH)/iso/ |
| clean: |
| -for file in $(RD_SRVS) ; do \ |
| rm -f $(USPACEDIR)/dist/srv/`basename $$file` ; \ |
| done |
| -for file in $(RD_APPS) ; do \ |
| rm -f $(USPACEDIR)/dist/app/`basename $$file` ; \ |
| done |
| -rm -fr arch/$(ARCH)/iso |
| -rm -f $(BASE)/image.iso |
| /tags/0.4.0/boot/arch/ia32/grub/menu.lst |
|---|
| 0,0 → 1,15 |
| default 0 |
| timeout 10 |
| title=HelenOS |
| root (cd) |
| kernel /boot/kernel.bin |
| module /boot/ns |
| module /boot/init |
| module /boot/devmap |
| module /boot/rd |
| module /boot/vfs |
| module /boot/tmpfs |
| module /boot/fat |
| module /boot/loader |
| module /boot/initrd.img |
| /tags/0.4.0/boot/arch/ia32/grub/stage2_eltorito |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /tags/0.4.0/boot/arch/ia32/grub/COPYING |
|---|
| 0,0 → 1,340 |
| GNU GENERAL PUBLIC LICENSE |
| Version 2, June 1991 |
| Copyright (C) 1989, 1991 Free Software Foundation, Inc. |
| 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| Everyone is permitted to copy and distribute verbatim copies |
| of this license document, but changing it is not allowed. |
| Preamble |
| The licenses for most software are designed to take away your |
| freedom to share and change it. By contrast, the GNU General Public |
| License is intended to guarantee your freedom to share and change free |
| software--to make sure the software is free for all its users. This |
| General Public License applies to most of the Free Software |
| Foundation's software and to any other program whose authors commit to |
| using it. (Some other Free Software Foundation software is covered by |
| the GNU Library General Public License instead.) You can apply it to |
| your programs, too. |
| When we speak of free software, we are referring to freedom, not |
| price. Our General Public Licenses are designed to make sure that you |
| have the freedom to distribute copies of free software (and charge for |
| this service if you wish), that you receive source code or can get it |
| if you want it, that you can change the software or use pieces of it |
| in new free programs; and that you know you can do these things. |
| To protect your rights, we need to make restrictions that forbid |
| anyone to deny you these rights or to ask you to surrender the rights. |
| These restrictions translate to certain responsibilities for you if you |
| distribute copies of the software, or if you modify it. |
| For example, if you distribute copies of such a program, whether |
| gratis or for a fee, you must give the recipients all the rights that |
| you have. You must make sure that they, too, receive or can get the |
| source code. And you must show them these terms so they know their |
| rights. |
| We protect your rights with two steps: (1) copyright the software, and |
| (2) offer you this license which gives you legal permission to copy, |
| distribute and/or modify the software. |
| Also, for each author's protection and ours, we want to make certain |
| that everyone understands that there is no warranty for this free |
| software. If the software is modified by someone else and passed on, we |
| want its recipients to know that what they have is not the original, so |
| that any problems introduced by others will not reflect on the original |
| authors' reputations. |
| Finally, any free program is threatened constantly by software |
| patents. We wish to avoid the danger that redistributors of a free |
| program will individually obtain patent licenses, in effect making the |
| program proprietary. To prevent this, we have made it clear that any |
| patent must be licensed for everyone's free use or not licensed at all. |
| The precise terms and conditions for copying, distribution and |
| modification follow. |
| GNU GENERAL PUBLIC LICENSE |
| TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION |
| 0. This License applies to any program or other work which contains |
| a notice placed by the copyright holder saying it may be distributed |
| under the terms of this General Public License. The "Program", below, |
| refers to any such program or work, and a "work based on the Program" |
| means either the Program or any derivative work under copyright law: |
| that is to say, a work containing the Program or a portion of it, |
| either verbatim or with modifications and/or translated into another |
| language. (Hereinafter, translation is included without limitation in |
| the term "modification".) Each licensee is addressed as "you". |
| Activities other than copying, distribution and modification are not |
| covered by this License; they are outside its scope. The act of |
| running the Program is not restricted, and the output from the Program |
| is covered only if its contents constitute a work based on the |
| Program (independent of having been made by running the Program). |
| Whether that is true depends on what the Program does. |
| 1. You may copy and distribute verbatim copies of the Program's |
| source code as you receive it, in any medium, provided that you |
| conspicuously and appropriately publish on each copy an appropriate |
| copyright notice and disclaimer of warranty; keep intact all the |
| notices that refer to this License and to the absence of any warranty; |
| and give any other recipients of the Program a copy of this License |
| along with the Program. |
| You may charge a fee for the physical act of transferring a copy, and |
| you may at your option offer warranty protection in exchange for a fee. |
| 2. You may modify your copy or copies of the Program or any portion |
| of it, thus forming a work based on the Program, and copy and |
| distribute such modifications or work under the terms of Section 1 |
| above, provided that you also meet all of these conditions: |
| a) You must cause the modified files to carry prominent notices |
| stating that you changed the files and the date of any change. |
| b) You must cause any work that you distribute or publish, that in |
| whole or in part contains or is derived from the Program or any |
| part thereof, to be licensed as a whole at no charge to all third |
| parties under the terms of this License. |
| c) If the modified program normally reads commands interactively |
| when run, you must cause it, when started running for such |
| interactive use in the most ordinary way, to print or display an |
| announcement including an appropriate copyright notice and a |
| notice that there is no warranty (or else, saying that you provide |
| a warranty) and that users may redistribute the program under |
| these conditions, and telling the user how to view a copy of this |
| License. (Exception: if the Program itself is interactive but |
| does not normally print such an announcement, your work based on |
| the Program is not required to print an announcement.) |
| These requirements apply to the modified work as a whole. If |
| identifiable sections of that work are not derived from the Program, |
| and can be reasonably considered independent and separate works in |
| themselves, then this License, and its terms, do not apply to those |
| sections when you distribute them as separate works. But when you |
| distribute the same sections as part of a whole which is a work based |
| on the Program, the distribution of the whole must be on the terms of |
| this License, whose permissions for other licensees extend to the |
| entire whole, and thus to each and every part regardless of who wrote it. |
| Thus, it is not the intent of this section to claim rights or contest |
| your rights to work written entirely by you; rather, the intent is to |
| exercise the right to control the distribution of derivative or |
| collective works based on the Program. |
| In addition, mere aggregation of another work not based on the Program |
| with the Program (or with a work based on the Program) on a volume of |
| a storage or distribution medium does not bring the other work under |
| the scope of this License. |
| 3. You may copy and distribute the Program (or a work based on it, |
| under Section 2) in object code or executable form under the terms of |
| Sections 1 and 2 above provided that you also do one of the following: |
| a) Accompany it with the complete corresponding machine-readable |
| source code, which must be distributed under the terms of Sections |
| 1 and 2 above on a medium customarily used for software interchange; or, |
| b) Accompany it with a written offer, valid for at least three |
| years, to give any third party, for a charge no more than your |
| cost of physically performing source distribution, a complete |
| machine-readable copy of the corresponding source code, to be |
| distributed under the terms of Sections 1 and 2 above on a medium |
| customarily used for software interchange; or, |
| c) Accompany it with the information you received as to the offer |
| to distribute corresponding source code. (This alternative is |
| allowed only for noncommercial distribution and only if you |
| received the program in object code or executable form with such |
| an offer, in accord with Subsection b above.) |
| The source code for a work means the preferred form of the work for |
| making modifications to it. For an executable work, complete source |
| code means all the source code for all modules it contains, plus any |
| associated interface definition files, plus the scripts used to |
| control compilation and installation of the executable. However, as a |
| special exception, the source code distributed need not include |
| anything that is normally distributed (in either source or binary |
| form) with the major components (compiler, kernel, and so on) of the |
| operating system on which the executable runs, unless that component |
| itself accompanies the executable. |
| If distribution of executable or object code is made by offering |
| access to copy from a designated place, then offering equivalent |
| access to copy the source code from the same place counts as |
| distribution of the source code, even though third parties are not |
| compelled to copy the source along with the object code. |
| 4. You may not copy, modify, sublicense, or distribute the Program |
| except as expressly provided under this License. Any attempt |
| otherwise to copy, modify, sublicense or distribute the Program is |
| void, and will automatically terminate your rights under this License. |
| However, parties who have received copies, or rights, from you under |
| this License will not have their licenses terminated so long as such |
| parties remain in full compliance. |
| 5. You are not required to accept this License, since you have not |
| signed it. However, nothing else grants you permission to modify or |
| distribute the Program or its derivative works. These actions are |
| prohibited by law if you do not accept this License. Therefore, by |
| modifying or distributing the Program (or any work based on the |
| Program), you indicate your acceptance of this License to do so, and |
| all its terms and conditions for copying, distributing or modifying |
| the Program or works based on it. |
| 6. Each time you redistribute the Program (or any work based on the |
| Program), the recipient automatically receives a license from the |
| original licensor to copy, distribute or modify the Program subject to |
| these terms and conditions. You may not impose any further |
| restrictions on the recipients' exercise of the rights granted herein. |
| You are not responsible for enforcing compliance by third parties to |
| this License. |
| 7. If, as a consequence of a court judgment or allegation of patent |
| infringement or for any other reason (not limited to patent issues), |
| conditions are imposed on you (whether by court order, agreement or |
| otherwise) that contradict the conditions of this License, they do not |
| excuse you from the conditions of this License. If you cannot |
| distribute so as to satisfy simultaneously your obligations under this |
| License and any other pertinent obligations, then as a consequence you |
| may not distribute the Program at all. For example, if a patent |
| license would not permit royalty-free redistribution of the Program by |
| all those who receive copies directly or indirectly through you, then |
| the only way you could satisfy both it and this License would be to |
| refrain entirely from distribution of the Program. |
| If any portion of this section is held invalid or unenforceable under |
| any particular circumstance, the balance of the section is intended to |
| apply and the section as a whole is intended to apply in other |
| circumstances. |
| It is not the purpose of this section to induce you to infringe any |
| patents or other property right claims or to contest validity of any |
| such claims; this section has the sole purpose of protecting the |
| integrity of the free software distribution system, which is |
| implemented by public license practices. Many people have made |
| generous contributions to the wide range of software distributed |
| through that system in reliance on consistent application of that |
| system; it is up to the author/donor to decide if he or she is willing |
| to distribute software through any other system and a licensee cannot |
| impose that choice. |
| This section is intended to make thoroughly clear what is believed to |
| be a consequence of the rest of this License. |
| 8. If the distribution and/or use of the Program is restricted in |
| certain countries either by patents or by copyrighted interfaces, the |
| original copyright holder who places the Program under this License |
| may add an explicit geographical distribution limitation excluding |
| those countries, so that distribution is permitted only in or among |
| countries not thus excluded. In such case, this License incorporates |
| the limitation as if written in the body of this License. |
| 9. The Free Software Foundation may publish revised and/or new versions |
| of the General Public License from time to time. Such new versions will |
| be similar in spirit to the present version, but may differ in detail to |
| address new problems or concerns. |
| Each version is given a distinguishing version number. If the Program |
| specifies a version number of this License which applies to it and "any |
| later version", you have the option of following the terms and conditions |
| either of that version or of any later version published by the Free |
| Software Foundation. If the Program does not specify a version number of |
| this License, you may choose any version ever published by the Free Software |
| Foundation. |
| 10. If you wish to incorporate parts of the Program into other free |
| programs whose distribution conditions are different, write to the author |
| to ask for permission. For software which is copyrighted by the Free |
| Software Foundation, write to the Free Software Foundation; we sometimes |
| make exceptions for this. Our decision will be guided by the two goals |
| of preserving the free status of all derivatives of our free software and |
| of promoting the sharing and reuse of software generally. |
| NO WARRANTY |
| 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY |
| FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN |
| OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES |
| PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED |
| OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS |
| TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE |
| PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, |
| REPAIR OR CORRECTION. |
| 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING |
| WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR |
| REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, |
| INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING |
| OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED |
| TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY |
| YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER |
| PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE |
| POSSIBILITY OF SUCH DAMAGES. |
| END OF TERMS AND CONDITIONS |
| How to Apply These Terms to Your New Programs |
| If you develop a new program, and you want it to be of the greatest |
| possible use to the public, the best way to achieve this is to make it |
| free software which everyone can redistribute and change under these terms. |
| To do so, attach the following notices to the program. It is safest |
| to attach them to the start of each source file to most effectively |
| convey the exclusion of warranty; and each file should have at least |
| the "copyright" line and a pointer to where the full notice is found. |
| <one line to give the program's name and a brief idea of what it does.> |
| Copyright (C) <year> <name of author> |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2 of the License, or |
| (at your option) any later version. |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| You should have received a copy of the GNU General Public License |
| along with this program; if not, write to the Free Software |
| Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| Also add information on how to contact you by electronic and paper mail. |
| If the program is interactive, make it output a short notice like this |
| when it starts in an interactive mode: |
| Gnomovision version 69, Copyright (C) year name of author |
| Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. |
| This is free software, and you are welcome to redistribute it |
| under certain conditions; type `show c' for details. |
| The hypothetical commands `show w' and `show c' should show the appropriate |
| parts of the General Public License. Of course, the commands you use may |
| be called something other than `show w' and `show c'; they could even be |
| mouse-clicks or menu items--whatever suits your program. |
| You should also get your employer (if you work as a programmer) or your |
| school, if any, to sign a "copyright disclaimer" for the program, if |
| necessary. Here is a sample; alter the names: |
| Yoyodyne, Inc., hereby disclaims all copyright interest in the program |
| `Gnomovision' (which makes passes at compilers) written by James Hacker. |
| <signature of Ty Coon>, 1 April 1989 |
| Ty Coon, President of Vice |
| This General Public License does not permit incorporating your program into |
| proprietary programs. If your program is a subroutine library, you may |
| consider it more useful to permit linking proprietary applications with the |
| library. If this is what you want to do, use the GNU Library General |
| Public License instead of this License. |
| /tags/0.4.0/boot/arch/ia32/grub/README |
|---|
| 0,0 → 1,5 |
| For licensing terms of GRUB boot loader see the file COPYING contained |
| in this directory. Full version of GRUB, including its source code, |
| can be downloaded from GRUB's project page: |
| http://www.gnu.org/software/grub/ |
| /tags/0.4.0/boot/tools/ia32/gen_vga323.c |
|---|
| 0,0 → 1,42 |
| /* |
| * Copyright (c) 2008 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 <stdio.h> |
| #define RED(i) (((i) >> 5) & ((1 << 3) - 1)) |
| #define GREEN(i) (((i) >> 3) & ((1 << 2) - 1)) |
| #define BLUE(i) ((i) & ((1 << 3) - 1)) |
| int main(int argc, char *argv[]) { |
| unsigned int i; |
| for (i = 0; i < 256; i++) |
| printf("\t.byte 0x%02x, 0x%02x, 0x%02x, 0x00\n", BLUE(i) * 9, GREEN(i) * 21, RED(i) * 9); |
| return 0; |
| } |
| /tags/0.4.0/boot/tools/pack.py |
|---|
| 0,0 → 1,132 |
| #!/usr/bin/env python |
| # |
| # Copyright (c) 2008 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. |
| # |
| """ |
| Binary package creator |
| """ |
| import sys |
| import os |
| import subprocess |
| def usage(prname): |
| "Print usage syntax" |
| print prname + " <OBJCOPY> <FORMAT> <ARCH> <ALIGNMENT> <UINTPTR>" |
| def main(): |
| if (len(sys.argv) < 6): |
| usage(sys.argv[0]) |
| return |
| if (not sys.argv[4].isdigit()): |
| print "<ALIGNMENT> must be a number" |
| return |
| objcopy = sys.argv[1] |
| format = sys.argv[2] |
| arch = sys.argv[3] |
| align = int(sys.argv[4], 0) |
| uintptr = sys.argv[5] |
| workdir = os.getcwd() |
| header = file("_components.h", "w") |
| data = file("_components.c", "w") |
| header.write("#ifndef ___COMPONENTS_H__\n") |
| header.write("#define ___COMPONENTS_H__\n\n") |
| data.write("#include \"_components.h\"\n\n") |
| data.write("void init_components(component_t *components)\n") |
| data.write("{\n") |
| cnt = 0 |
| link = "" |
| for task in sys.argv[6:]: |
| basename = os.path.basename(task) |
| plainname = os.path.splitext(basename)[0] |
| path = os.path.dirname(task) |
| object = plainname + ".o" |
| symbol = "_binary_" + basename.replace(".", "_") |
| macro = plainname.upper() |
| print task + " -> " + object |
| if (align > 1): |
| link += "\t\t. = ALIGN(" + ("%d" % align) + ");\n" |
| link += "\t\t*(." + plainname + "_image);\n" |
| header.write("extern int " + symbol + "_start;\n") |
| header.write("extern int " + symbol + "_end;\n\n") |
| header.write("#define " + macro + "_START ((void *) &" + symbol + "_start)\n") |
| header.write("#define " + macro + "_END ((void *) &" + symbol + "_end)\n") |
| header.write("#define " + macro + "_SIZE ((" + uintptr + ") " + macro + "_END - (" + uintptr + ") " + macro + "_START)\n\n") |
| data.write("\tcomponents[" + ("%d" % cnt) + "].name = \"" + plainname + "\";\n") |
| data.write("\tcomponents[" + ("%d" % cnt) + "].start = " + macro + "_START;\n") |
| data.write("\tcomponents[" + ("%d" % cnt) + "].end = " + macro + "_END;\n") |
| data.write("\tcomponents[" + ("%d" % cnt) + "].size = " + macro + "_SIZE;\n\n") |
| os.chdir(path) |
| subprocess.call([objcopy, |
| "-I", "binary", |
| "-O", format, |
| "-B", arch, |
| "--rename-section", ".data=." + plainname + "_image", |
| basename, os.path.join(workdir, object)]) |
| os.chdir(workdir) |
| cnt += 1 |
| header.write("#define COMPONENTS " + ("%d" % cnt) + "\n\n") |
| header.write("typedef struct {\n") |
| header.write("\tchar *name;\n\n") |
| header.write("\tvoid *start;\n") |
| header.write("\tvoid *end;\n") |
| header.write("\t" + uintptr + " size;\n") |
| header.write("} component_t;\n\n") |
| header.write("extern void init_components(component_t *components);\n\n") |
| header.write("#endif\n") |
| data.write("}\n") |
| header.close() |
| data.close() |
| linkname = "_link.ld" |
| link_in = file(linkname + ".in", "r") |
| template = link_in.read(os.path.getsize(linkname + ".in")) |
| link_in.close() |
| link_out = file(linkname, "w") |
| link_out.write(template.replace("[[COMPONENTS]]", link)) |
| link_out.close() |
| if __name__ == '__main__': |
| main() |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /tags/0.4.0/boot/genarch/ofw.h |
|---|
| 0,0 → 1,129 |
| /* |
| * 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 BOOT_OFW_H_ |
| #define BOOT_OFW_H_ |
| #include <types.h> |
| #include <stdarg.h> |
| #define BUF_SIZE 1024 |
| #define MEMMAP_MAX_RECORDS 32 |
| #define MAX_OFW_ARGS 12 |
| typedef unative_t ofw_arg_t; |
| typedef unsigned int ihandle; |
| typedef unsigned int phandle; |
| /** OpenFirmware command structure |
| * |
| */ |
| typedef struct { |
| ofw_arg_t service; /**< Command name. */ |
| ofw_arg_t nargs; /**< Number of in arguments. */ |
| ofw_arg_t nret; /**< Number of out arguments. */ |
| ofw_arg_t args[MAX_OFW_ARGS]; /**< List of arguments. */ |
| } ofw_args_t; |
| typedef struct { |
| void *start; |
| uint32_t size; |
| } memzone_t; |
| typedef struct { |
| uint32_t total; |
| uint32_t count; |
| memzone_t zones[MEMMAP_MAX_RECORDS]; |
| } memmap_t; |
| typedef struct { |
| void *addr; |
| uint32_t width; |
| uint32_t height; |
| uint32_t bpp; |
| uint32_t scanline; |
| } screen_t; |
| typedef struct { |
| void *addr; |
| uint32_t size; |
| } macio_t; |
| typedef struct { |
| uint32_t info; |
| uint32_t addr_hi; |
| uint32_t addr_lo; |
| } pci_addr_t; |
| typedef struct { |
| pci_addr_t addr; |
| uint32_t size_hi; |
| uint32_t size_lo; |
| } pci_reg_t; |
| extern uintptr_t ofw_cif; |
| extern phandle ofw_chosen; |
| extern ihandle ofw_stdout; |
| extern phandle ofw_root; |
| extern ihandle ofw_mmu; |
| extern phandle ofw_memory; |
| extern phandle ofw_aliases; |
| extern void ofw_init(void); |
| extern void ofw_write(const char *str, const int len); |
| extern int ofw_get_property(const phandle device, const char *name, void *buf, const int buflen); |
| extern int ofw_get_proplen(const phandle device, const char *name); |
| extern int ofw_next_property(const phandle device, char *previous, char *buf); |
| extern phandle ofw_get_child_node(const phandle node); |
| extern phandle ofw_get_peer_node(const phandle node); |
| extern phandle ofw_find_device(const char *name); |
| extern int ofw_package_to_path(const phandle device, char *buf, const int buflen); |
| extern int ofw(ofw_args_t *arg); |
| extern unsigned long ofw_call(const char *service, const int nargs, const int nret, ofw_arg_t *rets, ...); |
| extern unsigned int ofw_get_address_cells(const phandle device); |
| extern unsigned int ofw_get_size_cells(const phandle device); |
| extern void *ofw_translate(const void *virt); |
| extern int ofw_translate_failed(ofw_arg_t flag); |
| extern void *ofw_claim_virt(const void *virt, const int len); |
| extern void *ofw_claim_phys(const void *virt, const int len); |
| extern int ofw_map(const void *phys, const void *virt, const int size, const int mode); |
| extern int ofw_memmap(memmap_t *map); |
| extern int ofw_screen(screen_t *screen); |
| extern int ofw_macio(macio_t *macio); |
| extern int ofw_setup_palette(void); |
| extern void ofw_quiesce(void); |
| #endif |
| /tags/0.4.0/boot/genarch/ofw.c |
|---|
| 0,0 → 1,425 |
| /* |
| * 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 <ofw.h> |
| #include <ofwarch.h> |
| #include <printf.h> |
| #include <asm.h> |
| #include <types.h> |
| uintptr_t ofw_cif; |
| phandle ofw_chosen; |
| ihandle ofw_stdout; |
| phandle ofw_root; |
| ihandle ofw_mmu; |
| ihandle ofw_memory_prop; |
| phandle ofw_memory; |
| phandle ofw_aliases; |
| void ofw_init(void) |
| { |
| ofw_chosen = ofw_find_device("/chosen"); |
| if (ofw_chosen == -1) |
| halt(); |
| if (ofw_get_property(ofw_chosen, "stdout", &ofw_stdout, |
| sizeof(ofw_stdout)) <= 0) |
| ofw_stdout = 0; |
| ofw_root = ofw_find_device("/"); |
| if (ofw_root == -1) { |
| puts("\r\nError: Unable to find / device, halted.\r\n"); |
| halt(); |
| } |
| if (ofw_get_property(ofw_chosen, "mmu", &ofw_mmu, |
| sizeof(ofw_mmu)) <= 0) { |
| puts("\r\nError: Unable to get mmu property, halted.\r\n"); |
| halt(); |
| } |
| if (ofw_get_property(ofw_chosen, "memory", &ofw_memory_prop, |
| sizeof(ofw_memory_prop)) <= 0) { |
| puts("\r\nError: Unable to get memory property, halted.\r\n"); |
| halt(); |
| } |
| ofw_memory = ofw_find_device("/memory"); |
| if (ofw_memory == -1) { |
| puts("\r\nError: Unable to find /memory device, halted.\r\n"); |
| halt(); |
| } |
| ofw_aliases = ofw_find_device("/aliases"); |
| if (ofw_aliases == -1) { |
| puts("\r\nError: Unable to find /aliases device, halted.\r\n"); |
| halt(); |
| } |
| } |
| /** Perform a call to OpenFirmware client interface. |
| * |
| * @param service String identifying the service requested. |
| * @param nargs Number of input arguments. |
| * @param nret Number of output arguments. This includes the return |
| * value. |
| * @param rets Buffer for output arguments or NULL. The buffer must |
| * accommodate nret - 1 items. |
| * |
| * @return Return value returned by the client interface. |
| */ |
| unsigned long |
| ofw_call(const char *service, const int nargs, const int nret, ofw_arg_t *rets, |
| ...) |
| { |
| va_list list; |
| ofw_args_t args; |
| int i; |
| args.service = (ofw_arg_t) service; |
| args.nargs = nargs; |
| args.nret = nret; |
| va_start(list, rets); |
| for (i = 0; i < nargs; i++) |
| args.args[i] = va_arg(list, ofw_arg_t); |
| va_end(list); |
| for (i = 0; i < nret; i++) |
| args.args[i + nargs] = 0; |
| (void) ofw(&args); |
| for (i = 1; i < nret; i++) |
| rets[i - 1] = args.args[i + nargs]; |
| return args.args[nargs]; |
| } |
| phandle ofw_find_device(const char *name) |
| { |
| return ofw_call("finddevice", 1, 1, NULL, name); |
| } |
| int |
| ofw_get_property(const phandle device, const char *name, void *buf, |
| const int buflen) |
| { |
| return ofw_call("getprop", 4, 1, NULL, device, name, buf, buflen); |
| } |
| int ofw_get_proplen(const phandle device, const char *name) |
| { |
| return ofw_call("getproplen", 2, 1, NULL, device, name); |
| } |
| int ofw_next_property(const phandle device, char *previous, char *buf) |
| { |
| return ofw_call("nextprop", 3, 1, NULL, device, previous, buf); |
| } |
| int ofw_package_to_path(const phandle device, char *buf, const int buflen) |
| { |
| return ofw_call("package-to-path", 3, 1, NULL, device, buf, buflen); |
| } |
| unsigned int ofw_get_address_cells(const phandle device) |
| { |
| unsigned int ret = 1; |
| if (ofw_get_property(device, "#address-cells", &ret, sizeof(ret)) <= 0) |
| if (ofw_get_property(ofw_root, "#address-cells", &ret, |
| sizeof(ret)) <= 0) |
| ret = OFW_ADDRESS_CELLS; |
| return ret; |
| } |
| unsigned int ofw_get_size_cells(const phandle device) |
| { |
| unsigned int ret; |
| if (ofw_get_property(device, "#size-cells", &ret, sizeof(ret)) <= 0) |
| if (ofw_get_property(ofw_root, "#size-cells", &ret, |
| sizeof(ret)) <= 0) |
| ret = OFW_SIZE_CELLS; |
| return ret; |
| } |
| phandle ofw_get_child_node(const phandle node) |
| { |
| return ofw_call("child", 1, 1, NULL, node); |
| } |
| phandle ofw_get_peer_node(const phandle node) |
| { |
| return ofw_call("peer", 1, 1, NULL, node); |
| } |
| static ihandle ofw_open(const char *name) |
| { |
| return ofw_call("open", 1, 1, NULL, name); |
| } |
| void ofw_write(const char *str, const int len) |
| { |
| if (ofw_stdout == 0) |
| return; |
| ofw_call("write", 3, 1, NULL, ofw_stdout, str, len); |
| } |
| void *ofw_translate(const void *virt) |
| { |
| ofw_arg_t result[4]; |
| int shift; |
| if (ofw_call("call-method", 4, 5, result, "translate", ofw_mmu, |
| virt, 0) != 0) { |
| puts("Error: MMU method translate() failed, halting.\n"); |
| halt(); |
| } |
| if (ofw_translate_failed(result[0])) |
| return NULL; |
| if (sizeof(unative_t) == 8) |
| shift = 32; |
| else |
| shift = 0; |
| return (void *) ((result[2] << shift) | result[3]); |
| } |
| void *ofw_claim_virt(const void *virt, const int len) |
| { |
| ofw_arg_t retaddr; |
| if (ofw_call("call-method", 5, 2, &retaddr, "claim", ofw_mmu, 0, len, |
| virt) != 0) { |
| puts("Error: MMU method claim() failed, halting.\n"); |
| halt(); |
| } |
| return (void *) retaddr; |
| } |
| void *ofw_claim_phys(const void *phys, const int len) |
| { |
| ofw_arg_t retaddr[2]; |
| int shift; |
| if (sizeof(unative_t) == 8) { |
| shift = 32; |
| if (ofw_call("call-method", 6, 3, retaddr, "claim", |
| ofw_memory_prop, 0, len, ((uintptr_t) phys) >> shift, |
| ((uintptr_t) phys) & ((uint32_t) -1)) != 0) { |
| /* |
| * Note that this will help us to discover |
| * conflicts between OpenFirmware allocations |
| * and our use of physical memory. |
| * It is better to detect collisions here |
| * than to cope with weird errors later. |
| * |
| * So this is really not to make the loader |
| * more generic; it is here for debugging |
| * purposes. |
| */ |
| puts("Error: memory method claim() failed, halting.\n"); |
| halt(); |
| } |
| } else { |
| shift = 0; |
| /* |
| * FIXME: the number of arguments is probably different... |
| */ |
| puts("Error: 32-bit ofw_claim_phys not implemented.\n"); |
| halt(); |
| } |
| return (void *) ((retaddr[0] << shift) | retaddr[1]); |
| } |
| int ofw_map(const void *phys, const void *virt, const int size, const int mode) |
| { |
| uintptr_t phys_hi, phys_lo; |
| if (sizeof(unative_t) == 8) { |
| int shift = 32; |
| phys_hi = (uintptr_t) phys >> shift; |
| phys_lo = (uintptr_t) phys & 0xffffffff; |
| } else { |
| phys_hi = 0; |
| phys_lo = (uintptr_t) phys; |
| } |
| return ofw_call("call-method", 7, 1, NULL, "map", ofw_mmu, mode, size, |
| virt, phys_hi, phys_lo); |
| } |
| /** Save OpenFirmware physical memory map. |
| * |
| * @param map Memory map structure where the map will be saved. |
| * |
| * @return Zero on failure, non-zero on success. |
| */ |
| int ofw_memmap(memmap_t *map) |
| { |
| unsigned int ac = ofw_get_address_cells(ofw_memory) / |
| (sizeof(uintptr_t) / sizeof(uint32_t)); |
| unsigned int sc = ofw_get_size_cells(ofw_memory) / |
| (sizeof(uintptr_t) / sizeof(uint32_t)); |
| uintptr_t buf[((ac + sc) * MEMMAP_MAX_RECORDS)]; |
| int ret = ofw_get_property(ofw_memory, "reg", buf, sizeof(buf)); |
| if (ret <= 0) /* ret is the number of written bytes */ |
| return false; |
| int pos; |
| map->total = 0; |
| map->count = 0; |
| for (pos = 0; (pos < ret / sizeof(uintptr_t)) && |
| (map->count < MEMMAP_MAX_RECORDS); pos += ac + sc) { |
| void *start = (void *) (buf[pos + ac - 1]); |
| unsigned int size = buf[pos + ac + sc - 1]; |
| /* |
| * This is a hot fix of the issue which occurs on machines |
| * where there are holes in the physical memory (such as |
| * SunBlade 1500). Should we detect a hole in the physical |
| * memory, we will ignore any memory detected behind |
| * the hole and pretend the hole does not exist. |
| */ |
| if ((map->count > 0) && (map->zones[map->count - 1].start + |
| map->zones[map->count - 1].size < start)) |
| break; |
| if (size > 0) { |
| map->zones[map->count].start = start; |
| map->zones[map->count].size = size; |
| map->count++; |
| map->total += size; |
| } |
| } |
| return true; |
| } |
| int ofw_screen(screen_t *screen) |
| { |
| char device_name[BUF_SIZE]; |
| uint32_t virtaddr; |
| if (ofw_get_property(ofw_aliases, "screen", device_name, |
| sizeof(device_name)) <= 0) |
| return false; |
| phandle device = ofw_find_device(device_name); |
| if (device == -1) |
| return false; |
| if (ofw_get_property(device, "address", &virtaddr, |
| sizeof(virtaddr)) <= 0) |
| return false; |
| screen->addr = (void *) ((uintptr_t) virtaddr); |
| if (ofw_get_property(device, "width", &screen->width, |
| sizeof(screen->width)) <= 0) |
| return false; |
| if (ofw_get_property(device, "height", &screen->height, |
| sizeof(screen->height)) <= 0) |
| return false; |
| if (ofw_get_property(device, "depth", &screen->bpp, |
| sizeof(screen->bpp)) <= 0) |
| return false; |
| if (ofw_get_property(device, "linebytes", &screen->scanline, |
| sizeof(screen->scanline)) <= 0) |
| return false; |
| return true; |
| } |
| #define RED(i) (((i) >> 5) & ((1 << 3) - 1)) |
| #define GREEN(i) (((i) >> 3) & ((1 << 2) - 1)) |
| #define BLUE(i) ((i) & ((1 << 3) - 1)) |
| #define CLIP(i) ((i) <= 255 ? (i) : 255) |
| /** |
| * Sets up the palette for the 8-bit color depth configuration so that the |
| * 3:2:3 color scheme can be used. Checks that setting the palette makes sense |
| * (appropriate nodes exist in the OBP tree and the color depth is not greater |
| * than 8). |
| * |
| * @return true if the palette has been set, false otherwise |
| * |
| */ |
| int ofw_setup_palette(void) |
| { |
| char device_name[BUF_SIZE]; |
| /* resolve alias */ |
| if (ofw_get_property(ofw_aliases, "screen", device_name, |
| sizeof(device_name)) <= 0) |
| return false; |
| /* for depth greater than 8 it makes no sense to set up the palette */ |
| uint32_t depth; |
| phandle device = ofw_find_device(device_name); |
| if (device == -1) |
| return false; |
| if (ofw_get_property(device, "depth", &depth, sizeof(uint32_t)) <= 0) |
| return false; |
| if (depth != 8) |
| return false; |
| /* required in order to be able to make a method call */ |
| ihandle screen = ofw_open(device_name); |
| if (screen == -1) |
| return false; |
| /* setup the palette so that the (inverted) 3:2:3 scheme is usable */ |
| unsigned int i; |
| for (i = 0; i < 256; i++) |
| ofw_call("call-method", 6, 1, NULL, "color!", screen, |
| 255 - i, CLIP(BLUE(i) * 37), GREEN(i) * 85, CLIP(RED(i) * 37)); |
| return true; |
| } |
| void ofw_quiesce(void) |
| { |
| ofw_call("quiesce", 0, 0, NULL); |
| } |
| /tags/0.4.0/boot/genarch/ofw_tree.c |
|---|
| 0,0 → 1,257 |
| /* |
| * Copyright (c) 2006 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 <ofw_tree.h> |
| #include <ofw.h> |
| #include <types.h> |
| #include <string.h> |
| #include <balloc.h> |
| #include <asm.h> |
| #define MAX_PATH_LEN 256 |
| static ofw_tree_node_t *ofw_tree_node_alloc(void) |
| { |
| return balloc(sizeof(ofw_tree_node_t), sizeof(ofw_tree_node_t)); |
| } |
| static ofw_tree_property_t *ofw_tree_properties_alloc(unsigned count) |
| { |
| return balloc(count * sizeof(ofw_tree_property_t), |
| sizeof(ofw_tree_property_t)); |
| } |
| static void *ofw_tree_space_alloc(size_t size) |
| { |
| char *addr; |
| /* |
| * What we do here is a nasty hack :-) |
| * Problem: string property values that are allocated via this |
| * function typically do not contain the trailing '\0'. This |
| * is very uncomfortable for kernel, which is supposed to deal |
| * with the properties. |
| * Solution: when allocating space via this function, we always |
| * allocate space for the extra '\0' character that we store |
| * behind the requested memory. |
| */ |
| addr = balloc(size + 1, size); |
| if (addr) |
| addr[size] = '\0'; |
| return addr; |
| } |
| /** Transfer information from one OpenFirmware node into its memory |
| * representation. |
| * |
| * Transfer entire information from the OpenFirmware device tree 'current' node |
| * to its memory representation in 'current_node'. This function recursively |
| * processes all node's children. Node's peers are processed iteratively in |
| * order to prevent stack from overflowing. |
| * |
| * @param current_node Pointer to uninitialized ofw_tree_node structure that |
| * will become the memory represenation of 'current'. |
| * @param parent_node Parent ofw_tree_node structure or NULL in case of root |
| * node. |
| * @param current OpenFirmware phandle to the current device tree node. |
| */ |
| static void ofw_tree_node_process(ofw_tree_node_t *current_node, |
| ofw_tree_node_t *parent_node, phandle current) |
| { |
| static char path[MAX_PATH_LEN + 1]; |
| static char name[OFW_TREE_PROPERTY_MAX_NAMELEN]; |
| static char name2[OFW_TREE_PROPERTY_MAX_NAMELEN]; |
| phandle peer; |
| phandle child; |
| size_t len; |
| int i; |
| while (current_node) { |
| /* |
| * Initialize node. |
| */ |
| current_node->parent = parent_node; |
| current_node->peer = NULL; |
| current_node->child = NULL; |
| current_node->node_handle = current; |
| current_node->properties = 0; |
| current_node->property = NULL; |
| current_node->device = NULL; |
| /* |
| * Get the disambigued name. |
| */ |
| len = ofw_package_to_path(current, path, MAX_PATH_LEN); |
| if (len == -1) |
| return; |
| path[len] = '\0'; |
| for (i = len - 1; i >= 0 && path[i] != '/'; i--) |
| ; |
| i++; /* do not include '/' */ |
| len -= i; |
| /* add space for trailing '\0' */ |
| current_node->da_name = ofw_tree_space_alloc(len + 1); |
| if (!current_node->da_name) |
| return; |
| memcpy(current_node->da_name, &path[i], len); |
| current_node->da_name[len] = '\0'; |
| /* |
| * Recursively process the potential child node. |
| */ |
| child = ofw_get_child_node(current); |
| if (child != 0 && child != -1) { |
| ofw_tree_node_t *child_node; |
| child_node = ofw_tree_node_alloc(); |
| if (child_node) { |
| ofw_tree_node_process(child_node, current_node, |
| child); |
| current_node->child = child_node; |
| } |
| } |
| /* |
| * Count properties. |
| */ |
| name[0] = '\0'; |
| while (ofw_next_property(current, name, name2) == 1) { |
| current_node->properties++; |
| memcpy(name, name2, OFW_TREE_PROPERTY_MAX_NAMELEN); |
| } |
| if (!current_node->properties) |
| return; |
| /* |
| * Copy properties. |
| */ |
| current_node->property = |
| ofw_tree_properties_alloc(current_node->properties); |
| if (!current_node->property) |
| return; |
| name[0] = '\0'; |
| for (i = 0; ofw_next_property(current, name, name2) == 1; i++) { |
| size_t size; |
| if (i == current_node->properties) |
| break; |
| memcpy(name, name2, OFW_TREE_PROPERTY_MAX_NAMELEN); |
| memcpy(current_node->property[i].name, name, |
| OFW_TREE_PROPERTY_MAX_NAMELEN); |
| current_node->property[i].name[ |
| OFW_TREE_PROPERTY_MAX_NAMELEN] = '\0'; |
| size = ofw_get_proplen(current, name); |
| current_node->property[i].size = size; |
| if (size) { |
| void *buf; |
| buf = ofw_tree_space_alloc(size); |
| if (current_node->property[i].value = buf) { |
| /* |
| * Copy property value to memory node. |
| */ |
| (void) ofw_get_property(current, name, |
| buf, size); |
| } |
| } else { |
| current_node->property[i].value = NULL; |
| } |
| } |
| /* Just in case we ran out of memory. */ |
| current_node->properties = i; |
| /* |
| * Iteratively process the next peer node. |
| * Note that recursion is a bad idea here. |
| * Due to the topology of the OpenFirmware device tree, |
| * the nesting of peer nodes could be to wide and the |
| * risk of overflowing the stack is too real. |
| */ |
| peer = ofw_get_peer_node(current); |
| if (peer != 0 && peer != -1) { |
| ofw_tree_node_t *peer_node; |
| peer_node = ofw_tree_node_alloc(); |
| if (peer_node) { |
| current_node->peer = peer_node; |
| current_node = peer_node; |
| current = peer; |
| /* |
| * Process the peer in next iteration. |
| */ |
| continue; |
| } |
| } |
| /* |
| * No more peers on this level. |
| */ |
| break; |
| } |
| } |
| /** Construct memory representation of OpenFirmware device tree. |
| * |
| * @return NULL on failure or pointer to the root node. |
| */ |
| ofw_tree_node_t *ofw_tree_build(void) |
| { |
| ofw_tree_node_t *root; |
| phandle ssm_node; |
| ofw_tree_node_t *ssm; |
| root = ofw_tree_node_alloc(); |
| if (root) |
| ofw_tree_node_process(root, NULL, ofw_root); |
| /* |
| * The firmware client interface does not automatically include the |
| * "ssm" node in the list of children of "/". A nasty yet working |
| * solution is to explicitly stick "ssm" to the OFW tree. |
| */ |
| ssm_node = ofw_find_device("/ssm@0,0"); |
| if (ssm_node != -1) { |
| ssm = ofw_tree_node_alloc(); |
| if (ssm) { |
| ofw_tree_node_process(ssm, root, |
| ofw_find_device("/ssm@0,0")); |
| ssm->peer = root->child; |
| root->child = ssm; |
| } |
| } |
| return root; |
| } |
| /tags/0.4.0/boot/genarch/balloc.h |
|---|
| 0,0 → 1,44 |
| /* |
| * Copyright (c) 2006 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 BOOT_BALLOC_H_ |
| #define BOOT_BALLOC_H_ |
| #include <types.h> |
| #define BALLOC_MAX_SIZE (128 * 1024) |
| typedef struct { |
| uintptr_t base; |
| size_t size; |
| } ballocs_t; |
| extern void balloc_init(ballocs_t *b, uintptr_t base); |
| extern void *balloc(size_t size, size_t alignment); |
| #endif |
| /tags/0.4.0/boot/genarch/include/softint |
|---|
| 0,0 → 1,0 |
| link ../../../kernel/genarch/include/softint |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /tags/0.4.0/boot/genarch/division.c |
|---|
| 0,0 → 1,0 |
| link ../../kernel/genarch/src/softint/division.c |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /tags/0.4.0/boot/genarch/balloc.c |
|---|
| 0,0 → 1,57 |
| /* |
| * Copyright (c) 2006 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 <balloc.h> |
| #include <types.h> |
| #include <align.h> |
| static ballocs_t *ballocs; |
| void balloc_init(ballocs_t *b, uintptr_t base) |
| { |
| ballocs = b; |
| ballocs->base = base; |
| ballocs->size = 0; |
| } |
| void *balloc(size_t size, size_t alignment) |
| { |
| uintptr_t addr; |
| /* Enforce minimal alignment. */ |
| alignment = ALIGN_UP(alignment, 4); |
| addr = ballocs->base + ALIGN_UP(ballocs->size, alignment); |
| if (ALIGN_UP(ballocs->size, alignment) + size > BALLOC_MAX_SIZE) |
| return NULL; |
| ballocs->size = ALIGN_UP(ballocs->size, alignment) + size; |
| return (void *) addr; |
| } |
| /tags/0.4.0/boot/genarch/ofw_tree.h |
|---|
| 0,0 → 1,65 |
| /* |
| * Copyright (c) 2006 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 BOOT_OFW_TREE_H_ |
| #define BOOT_OFW_TREE_H_ |
| #include <types.h> |
| #include <ofw.h> |
| #define OFW_TREE_PROPERTY_MAX_NAMELEN 32 |
| typedef struct ofw_tree_node ofw_tree_node_t; |
| typedef struct ofw_tree_property ofw_tree_property_t; |
| /** Memory representation of OpenFirmware device tree node. */ |
| struct ofw_tree_node { |
| ofw_tree_node_t *parent; |
| ofw_tree_node_t *peer; |
| ofw_tree_node_t *child; |
| uint32_t node_handle; /**< Old OpenFirmware node handle. */ |
| char *da_name; /**< Disambigued name. */ |
| unsigned properties; /**< Number of properties. */ |
| ofw_tree_property_t *property; |
| void *device; /**< Member used solely by the kernel. */ |
| }; |
| /** Memory representation of OpenFirmware device tree node property. */ |
| struct ofw_tree_property { |
| char name[OFW_TREE_PROPERTY_MAX_NAMELEN]; |
| size_t size; |
| void *value; |
| }; |
| extern ofw_tree_node_t *ofw_tree_build(void); |
| #endif |
| /tags/0.4.0/boot/Makefile |
|---|
| 0,0 → 1,60 |
| # |
| # Copyright (c) 2006 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 configuration |
| # |
| -include ../Makefile.config |
| ## Paths |
| # |
| BASE = .. |
| KERNELDIR = $(BASE)/kernel |
| USPACEDIR = $(BASE)/uspace |
| ifeq ($(CONFIG_DEBUG),y) |
| DEFS += -DCONFIG_DEBUG |
| endif |
| ifeq ($(CONFIG_BAT),y) |
| DEFS += -DCONFIG_BAT |
| endif |
| ifeq ($(CONFIG_AP),y) |
| DEFS += -DCONFIG_AP |
| endif |
| .PHONY: all build clean generic_clean |
| all: ../Makefile.config build |
| -include arch/$(ARCH)/Makefile.inc |
| generic_clean: |
| -rm generic/*.o genarch/*.o |
| /tags/0.4.0/boot/generic/string.c |
|---|
| 0,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. |
| */ |
| /** @addtogroup generic |
| * @{ |
| */ |
| #include <string.h> |
| /** |
| * @file |
| * @brief String manipulation functions. |
| */ |
| /** Return number of characters in a string. |
| * |
| * @param str NULL terminated string. |
| * |
| * @return Number of characters in str. |
| */ |
| size_t strlen(const char *str) |
| { |
| int i; |
| for (i = 0; str[i]; i++) |
| ; |
| return i; |
| } |
| /** Compare two NULL terminated strings. |
| * |
| * Do a char-by-char comparison of two NULL terminated strings. |
| * The strings are considered equal iff they consist of the same |
| * characters on the minimum of their lengths. |
| * |
| * @param src First string to compare. |
| * @param dst Second string to compare. |
| * |
| * @return 0 if the strings are equal, -1 if first is smaller, |
| * 1 if second smaller. |
| * |
| */ |
| int strcmp(const char *src, const char *dst) |
| { |
| for (; *src && *dst; src++, dst++) { |
| if (*src < *dst) |
| return -1; |
| if (*src > *dst) |
| return 1; |
| } |
| if (*src == *dst) |
| return 0; |
| if (!*src) |
| return -1; |
| return 1; |
| } |
| /** Compare two NULL terminated strings. |
| * |
| * Do a char-by-char comparison of two NULL terminated strings. |
| * The strings are considered equal iff they consist of the same |
| * characters on the minimum of their lengths and specified maximal |
| * length. |
| * |
| * @param src First string to compare. |
| * @param dst Second string to compare. |
| * @param len Maximal length for comparison. |
| * |
| * @return 0 if the strings are equal, -1 if first is smaller, |
| * 1 if second smaller. |
| * |
| */ |
| int strncmp(const char *src, const char *dst, size_t len) |
| { |
| int i; |
| for (i = 0; *src && *dst && i < len; src++, dst++, i++) { |
| if (*src < *dst) |
| return -1; |
| if (*src > *dst) |
| return 1; |
| } |
| if (i == len || *src == *dst) |
| return 0; |
| if (!*src) |
| return -1; |
| return 1; |
| } |
| /** Copy NULL terminated string. |
| * |
| * Copy at most 'len' characters from string 'src' to 'dest'. |
| * If 'src' is shorter than 'len', '\0' is inserted behind the |
| * last copied character. |
| * |
| * @param src Source string. |
| * @param dest Destination buffer. |
| * @param len Size of destination buffer. |
| */ |
| void strncpy(char *dest, const char *src, size_t len) |
| { |
| int i; |
| for (i = 0; i < len; i++) { |
| if (!(dest[i] = src[i])) |
| return; |
| } |
| dest[i-1] = '\0'; |
| } |
| /** Convert ascii representation to unative_t. |
| * |
| * Supports 0x for hexa & 0 for octal notation. |
| * Does not check for overflows, does not support negative numbers |
| * |
| * @param text Textual representation of number. |
| * @return Converted number or 0 if no valid number found. |
| */ |
| unative_t atoi(const char *text) |
| { |
| int base = 10; |
| unative_t result = 0; |
| if (text[0] == '0' && text[1] == 'x') { |
| base = 16; |
| text += 2; |
| } else if (text[0] == '0') |
| base = 8; |
| while (*text) { |
| if (base != 16 && |
| ((*text >= 'A' && *text <= 'F') || |
| (*text >='a' && *text <='f'))) |
| break; |
| if (base == 8 && *text >='8') |
| break; |
| if (*text >= '0' && *text <= '9') { |
| result *= base; |
| result += *text - '0'; |
| } else if (*text >= 'A' && *text <= 'F') { |
| result *= base; |
| result += *text - 'A' + 10; |
| } else if (*text >= 'a' && *text <= 'f') { |
| result *= base; |
| result += *text - 'a' + 10; |
| } else |
| break; |
| text++; |
| } |
| return result; |
| } |
| /** Move piece of memory to another, possibly overlapping, location. |
| * |
| * @param dst Destination address. |
| * @param src Source address. |
| * @param len Number of bytes to move. |
| * |
| * @return Destination address. |
| */ |
| void *memmove(void *dst, const void *src, size_t len) |
| { |
| char *d = dst; |
| const char *s = src; |
| if (s < d) { |
| while (len--) |
| *(d + len) = *(s + len); |
| } else { |
| while (len--) |
| *d++ = *s++; |
| } |
| return dst; |
| } |
| /** @} |
| */ |
| /tags/0.4.0/boot/generic/string.h |
|---|
| 0,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. |
| */ |
| /** @addtogroup generic |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef BOOT_STRING_H_ |
| #define BOOT_STRING_H_ |
| #include <types.h> |
| extern size_t strlen(const char *str); |
| extern int strcmp(const char *src, const char *dst); |
| extern int strncmp(const char *src, const char *dst, size_t len); |
| extern void strncpy(char *dest, const char *src, size_t len); |
| extern unative_t atoi(const char *text); |
| extern void *memmove(void *dst, const void *src, size_t len); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.0/boot/generic/genarch |
|---|
| 0,0 → 1,0 |
| link ../genarch/include |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /tags/0.4.0/boot/generic/align.h |
|---|
| 0,0 → 1,48 |
| /* |
| * Copyright (c) 2006 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. |
| */ |
| /** @addtogroup generic |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef BOOT_ALIGN_H_ |
| #define BOOT_ALIGN_H_ |
| /** Align to the nearest higher address. |
| * |
| * @param addr Address or size to be aligned. |
| * @param align Size of alignment, must be power of 2. |
| */ |
| #define ALIGN_UP(addr, align) (((addr) + ((align) - 1)) & ~((align) - 1)) |
| #endif |
| /** @} |
| */ |
| /tags/0.4.0/boot/generic/printf.c |
|---|
| 0,0 → 1,252 |
| /* |
| * Copyright (c) 2006 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. |
| */ |
| /** @addtogroup generic |
| * @{ |
| */ |
| /** @file |
| */ |
| #include "printf.h" |
| #include "stdarg.h" |
| #include <types.h> |
| typedef char *char_ptr; |
| static char digits[] = "0123456789abcdef"; /**< Hexadecimal characters */ |
| void puts(const char *str) |
| { |
| int len = 0; |
| while (str[len] != 0) |
| len++; |
| write(str, len); |
| } |
| /** 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. |
| * |
| */ |
| static void print_fixed_hex(const uint64_t num, const int width) |
| { |
| int i; |
| for (i = width * 8 - 4; i >= 0; i -= 4) |
| write(digits + ((num >> i) & 0xf), 1); |
| } |
| /** 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). |
| * |
| */ |
| static void print_number(const unative_t num, const unsigned int base) |
| { |
| int val = num; |
| char d[sizeof(unative_t) * 8 + 1]; /* this is good enough even for base == 2 */ |
| int i = sizeof(unative_t) * 8 - 1; |
| do { |
| d[i--] = digits[val % base]; |
| } while (val /= base); |
| d[sizeof(unative_t) * 8] = 0; |
| puts(&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. |
| * |
| * B 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 i = 0; |
| va_list ap; |
| char c; |
| va_start(ap, fmt); |
| while ((c = fmt[i++])) { |
| switch (c) { |
| /* control character */ |
| case '%': |
| switch (c = fmt[i++]) { |
| /* percentile itself */ |
| case '%': |
| break; |
| /* |
| * String and character conversions. |
| */ |
| case 's': |
| puts(va_arg(ap, char_ptr)); |
| goto loop; |
| case 'c': |
| c = (char) va_arg(ap, int); |
| break; |
| /* |
| * Hexadecimal conversions with fixed width. |
| */ |
| case 'P': |
| puts("0x"); |
| case 'p': |
| print_fixed_hex(va_arg(ap, unative_t), sizeof(unative_t)); |
| goto loop; |
| case 'Q': |
| puts("0x"); |
| case 'q': |
| print_fixed_hex(va_arg(ap, uint64_t), INT64); |
| goto loop; |
| case 'L': |
| puts("0x"); |
| case 'l': |
| print_fixed_hex(va_arg(ap, unative_t), INT32); |
| goto loop; |
| case 'W': |
| puts("0x"); |
| case 'w': |
| print_fixed_hex(va_arg(ap, unative_t), INT16); |
| goto loop; |
| case 'B': |
| puts("0x"); |
| case 'b': |
| print_fixed_hex(va_arg(ap, unative_t), INT8); |
| goto loop; |
| /* |
| * Decimal and hexadecimal conversions. |
| */ |
| case 'd': |
| print_number(va_arg(ap, unative_t), 10); |
| goto loop; |
| case 'X': |
| puts("0x"); |
| case 'x': |
| print_number(va_arg(ap, unative_t), 16); |
| goto loop; |
| /* |
| * Bad formatting. |
| */ |
| default: |
| goto out; |
| } |
| default: |
| write(&c, 1); |
| } |
| loop: |
| ; |
| } |
| out: |
| va_end(ap); |
| } |
| /** @} |
| */ |
| /tags/0.4.0/boot/generic/gentypes.h |
|---|
| 0,0 → 1,47 |
| /* |
| * Copyright (c) 2006 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. |
| */ |
| /** @addtogroup generic |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef BOOT_GENTYPES_H_ |
| #define BOOT_GENTYPES_H_ |
| #define NULL 0 |
| #define false 0 |
| #define true 1 |
| typedef unsigned long size_t; |
| #endif |
| /** @} |
| */ |
| /tags/0.4.0/boot/generic/printf.h |
|---|
| 0,0 → 1,51 |
| /* |
| * Copyright (c) 2006 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. |
| */ |
| /** @addtogroup generic |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef BOOT_PRINTF_H_ |
| #define BOOT_PRINTF_H_ |
| #define INT8 1 |
| #define INT16 2 |
| #define INT32 4 |
| #define INT64 8 |
| extern void puts(const char *str); |
| extern void printf(const char *fmt, ...); |
| extern void write(const char *str, const int len); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.0/boot/generic/stdarg.h |
|---|
| 0,0 → 1,47 |
| /* |
| * Copyright (c) 2006 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. |
| */ |
| /** @addtogroup generic |
| * @{ |
| */ |
| /** @file |
| */ |
| #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 |
| /** @} |
| */ |
| /tags/0.4.0/boot/doc/doxygroups.h |
|---|
| 0,0 → 1,10 |
| /* Definitions of modules and its relations for generating Doxygen documentation */ |
| /** @defgroup generic generic |
| */ |
| /** @defgroup arm32boot arm32 |
| */ |