main.c

AT91RM9200的完整启动代码：包括loader, boot及U-boot三部分均已编译通过！欢迎下载使用！

/*
 * Copyright 1999 Egbert Eich
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of the authors not be used in
 * advertising or publicity pertaining to distribution of the software without
 * specific, written prior permission.  The authors makes no representations
 * about the suitability of this software for any purpose.  It is provided
 * "as is" without express or implied warranty.
 *
 * THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */
#define DELETE
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/stat.h>
#if defined(__alpha__) || defined (__ia64__)
#include <sys/io.h>
#elif defined(HAVE_SYS_PERM)
#include <sys/perm.h>
#endif
#include "debug.h"
#include "v86bios.h"
#include "pci.h"
#include "AsmMacros.h"

#define SIZE 0x100000
#define VRAM_START 0xA0000
#define VRAM_SIZE 0x1FFFF
#define V_BIOS_SIZE 0x1FFFF
#define BIOS_START 0x7C00            /* default BIOS entry */

//CARD8 code[] = { 0xb8 , 0xf0 , 0xf0, 0xf4 };
#define VB_X(x) (V_BIOS >> x) & 0xFF
CARD8 code[] = { 0x9a, 0x03, 0x00, 0x00, VB_X(12), 0xf4 };
//CARD8 code[] = { 0x9a, 0x03, 0x00, 0x00, VB_X(12), 0xb8, 0x03, 0x00,
//0xcd, 0x10, 0xf4 };
//CARD8 code[] = {  0xb8 , 0xf0 , 0xf0 ,0xf4 };

static void sig_handler(int);
static int map(void);
static void unmap(void);
static void bootBIOS(CARD16 ax);
static int map_vram(void);
static void unmap_vram(void);
static int copy_vbios(void);
static int copy_sys_bios(void);
static void save_bios_to_file(void);
static int setup_system_bios(void);
static void setup_int_vect(void);
static int chksum(CARD8 *start);
static void setup_bios_regs(i86biosRegsPtr regs, CARD32 ax);

void loadCodeToMem(unsigned char *ptr, CARD8 *code);
void dprint(unsigned long start, unsigned long size);

static int vram_mapped = 0;
static CARD8 save_msr;
static CARD8 save_pos102;
static CARD8 save_vse;
static CARD8 save_46e8;
console Console;
struct config Config;


int
main(void)
{
    int Active_is_Pci = 0;
#ifdef DELETE
    Config.PrintPort = PRINT_PORT;
    Config.IoStatistics = IO_STATISTICS;
    Config.PrintIrq = PRINT_IRQ;
    Config.PrintPci = PRINT_PCI;
    Config.ShowAllDev = SHOW_ALL_DEV;        
    Config.PrintIp = PRINT_IP;           
    Config.SaveBios = SAVE_BIOS;          
    Config.Trace = TRACE;             
    Config.ConfigActiveOnly = CONFIG_ACTIVE_ONLY;  
    Config.ConfigActiveDevice = CONFIG_ACTIVE_DEVICE;
    Config.MapSysBios = MAP_SYS_BIOS;        
    Config.Resort = RESORT;            
    Config.FixRom = FIX_ROM;            
    Config.NoConsole = NO_CONSOLE;         
    Config.Verbose = VERBOSE;

    if (!map())
        exit(1);
    
    if (!setup_system_bios())
        exit(1);
    
    iopl(3);
    setup_io();
    
    scan_pci();
    if (!CurrentPci && !Config.ConfigActiveDevice && !Config.ConfigActiveOnly)
        exit (1);
#endif
    Console = open_console();

    if (Config.ConfigActiveOnly) {
        CARD16 ax;
        int activePci = 0;
        int error = 0;
        
        while (CurrentPci) {
            if (CurrentPci->active) {
                activePci = 1;
                            if (!(mapPciRom(NULL) && chksum((CARD8*)V_BIOS)))
                                error = 1;
                            break;
            }
            CurrentPci = CurrentPci->next;
        }
        ax = ((CARD16)(CurrentPci->bus) << 8)
            | (CurrentPci->dev << 3) | (CurrentPci->func & 0x7);
        P_printf("ax: 0x%x\n",ax);
        setup_int_vect();
        if (!error && (activePci || copy_vbios())) {
            
            if (Config.SaveBios) save_bios_to_file();
            if  (map_vram()) {
                printf("initializing ISA\n");
                            bootBIOS(0);
            }
        }
        unmap_vram();
        sleep(1);       
    } else {
        /* disable primary card */
        save_msr = inb(0x3CC);
        save_vse = inb(0x3C3);
        save_46e8 = inb(0x46e8);
        save_pos102 = inb(0x102);
        
        signal(2,sig_handler);
        signal(11,sig_handler);
        
        outb(0x3C2,~(CARD8)0x03 & save_msr);
        outb(0x3C3,~(CARD8)0x01 & save_vse);
        outb(0x46e8, ~(CARD8)0x08 & save_46e8);
        outb(0x102, ~(CARD8)0x01 & save_pos102);
        
        pciVideoDisable();
        
        while (CurrentPci) {
            CARD16 ax;
            
            if (CurrentPci->active) {
                Active_is_Pci = 1;
                if (!Config.ConfigActiveDevice) {
                    CurrentPci = CurrentPci->next;
                    continue;
                }
            }
            
            EnableCurrent();
            
            if (CurrentPci->active) {
                outb(0x102, save_pos102);
                outb(0x46e8, save_46e8);
                outb(0x3C3, save_vse);
                outb(0x3C2, save_msr);
            }
            
            /* clear interrupt vectors */
            setup_int_vect();
            
            ax = ((CARD16)(CurrentPci->bus) << 8)
                | (CurrentPci->dev << 3) | (CurrentPci->func & 0x7);
            P_printf("ax: 0x%x\n",ax);
            
            if (!((mapPciRom(NULL) && chksum((CARD8*)V_BIOS))
                  || (CurrentPci->active && copy_vbios()))) {
                CurrentPci = CurrentPci->next;
                continue;
            }
            if (!map_vram()) {
                CurrentPci = CurrentPci->next;
                continue;
            }
            if (Config.SaveBios) save_bios_to_file();
            printf("initializing PCI bus: %i dev: %i func: %i\n",CurrentPci->bus,
                   CurrentPci->dev,CurrentPci->func);
            bootBIOS(ax);
            unmap_vram();
            
            CurrentPci = CurrentPci->next;
        }
        
        /* We have an ISA device - configure if requested */
        if (!Active_is_Pci && Config.ConfigActiveDevice) {
            pciVideoDisable();
            
            outb(0x102, save_pos102);
            outb(0x46e8, save_46e8);
            outb(0x3C3, save_vse);
            outb(0x3C2, save_msr);

            setup_int_vect();
            if (copy_vbios()) {
                
                if (Config.SaveBios) save_bios_to_file();
                if  (map_vram()) {
                    printf("initializing ISA\n");
                    bootBIOS(0);
                }
            }
        
            unmap_vram();
            sleep(1);
        }
        
        pciVideoRestore();

        outb(0x102, save_pos102);
        outb(0x46e8, save_46e8);
        outb(0x3C3, save_vse);
        outb(0x3C2, save_msr);
    }
    
    close_console(Console);
#ifdef DELETE
    iopl(0);
    unmap();

    printf("done !\n");
#endif
    if (Config.IoStatistics)
        io_statistics();
#ifdef DELETE
    exit(0);
#endif
}

int  
map(void)
{
    void* mem;

    mem = mmap(0, (size_t)SIZE,
               PROT_EXEC | PROT_READ | PROT_WRITE,
               MAP_FIXED | MAP_PRIVATE | MAP_ANON,
               -1, 0 ); 
    if (mem != 0) {
        perror("anonymous map");
        return (0);
    }
    memset(mem,0,SIZE);

    loadCodeToMem((unsigned char *) BIOS_START, code);
    return (1);
}

static void
unmap(void)
{
    munmap(0,SIZE);
}

static void
bootBIOS(CARD16 ax)
{
    i86biosRegs bRegs;
#ifdef V86BIOS_DEBUG
    printf("starting BIOS\n");
#endif
    setup_bios_regs(&bRegs, ax);
    do_x86(BIOS_START,&bRegs);
#ifdef V86BIOS_DEBUG
    printf("done\n");
#endif
}

static int
map_vram(void)
{
    int mem_fd;

#ifdef __ia64__
    if ((mem_fd = open(MEM_FILE,O_RDWR | O_SYNC))<0) 
#else
    if ((mem_fd = open(MEM_FILE,O_RDWR))<0) 
#endif
      {
        perror("opening memory");
        return 0;
    }

#ifndef __alpha__
    if (mmap((void *) VRAM_START, (size_t) VRAM_SIZE,
                     PROT_EXEC | PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED,
                     mem_fd, VRAM_START) == (void *) -1)